d59f1d55ea
- Added JobOrderStatus enum (PENDING, IN_PROGRESS, COMPLETED, CANCELLED) - Added JobOrder model with ticket FK, assignedTo/createdBy user FKs - Added orderNumber (JO-NNNN), scheduledDate, timestamps, outcomeNotes - Added jobOrders reverse relation on Ticket model - Added assignedJobOrders/createdJobOrders reverse relations on User model - Applied migration: 20260304235859_add_job_orders - Added jobOrder to TENANT_SCOPED_MODELS with full 12-operation extension block
1750 lines
53 KiB
TypeScript
1750 lines
53 KiB
TypeScript
import { prisma } from "@/lib/prisma";
|
|
|
|
// =============================================================================
|
|
// Tenant-Scoped Prisma Client
|
|
// =============================================================================
|
|
//
|
|
// ARCHITECTURE:
|
|
// This module provides a Prisma client extended with query-level extensions
|
|
// that automatically inject the current tenant's ID into all reads, writes,
|
|
// and deletes on tenant-scoped models.
|
|
//
|
|
// This is the PRIMARY enforcement layer for multi-tenancy.
|
|
// PostgreSQL RLS (see migration: add-rls-policies) is DEFENSE-IN-DEPTH —
|
|
// it catches application bugs if this middleware is somehow bypassed.
|
|
//
|
|
// USAGE:
|
|
// const tenantPrisma = withTenantContext(tenantId);
|
|
// const users = await tenantPrisma.user.findMany(); // auto-filters by tenantId
|
|
//
|
|
// EXTENDING:
|
|
// When adding new tenant-scoped models (Subscriber, Invoice, Plan, etc.),
|
|
// add the model name to TENANT_SCOPED_MODELS below and extend the $extends
|
|
// block in withTenantContext() following the same pattern.
|
|
// =============================================================================
|
|
|
|
/**
|
|
* List of Prisma model names that are scoped to a tenant.
|
|
* Models NOT in this list (like Tenant itself) bypass tenant filtering.
|
|
*
|
|
* Extend this list as new models are added in later phases:
|
|
* e.g., "subscriber", "invoice", "servicePlan", "payment"
|
|
*/
|
|
export const TENANT_SCOPED_MODELS = ["user", "account", "accountingPeriod", "subscriber", "servicePlan", "tenantSettings", "journalEntry", "journalEntryLine", "invoice", "invoiceLine", "payment", "paymentAllocation", "zone", "zoneAssignment", "ticket", "ticketCategory", "collection", "collectionAllocation", "remittance", "jobOrder"] as const;
|
|
|
|
export type TenantScopedModel = (typeof TENANT_SCOPED_MODELS)[number];
|
|
|
|
/**
|
|
* Returns a Prisma client extended with tenant-scoped query filtering.
|
|
*
|
|
* All operations on tenant-scoped models automatically include the tenantId:
|
|
* - findMany / findFirst: where clause gets tenantId injected
|
|
* - findUnique: converted to findFirst with tenantId guard
|
|
* - create: data gets tenantId set
|
|
* - update / updateMany: where clause gets tenantId added
|
|
* - delete / deleteMany: where clause gets tenantId added
|
|
* - upsert: where clause gets tenantId added, create data gets tenantId set
|
|
*
|
|
* @param tenantId - The tenant UUID to scope all queries to
|
|
*/
|
|
export function withTenantContext(tenantId: string) {
|
|
return prisma.$extends({
|
|
query: {
|
|
user: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
// findUnique requires an exact unique key — we can't simply inject
|
|
// tenantId there. Route through findFirst to enforce tenant scoping.
|
|
async findUnique({ args, query }) {
|
|
// Check if tenantId is already part of a compound unique key
|
|
// If so, let Prisma handle it. Otherwise, use findFirst with tenant guard.
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
// Use findFirst to enforce tenant boundary
|
|
return prisma.user.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.user.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
// Remove the nested `tenant` relation object when injecting tenantId
|
|
// (they are mutually exclusive in Prisma's UncheckedCreateInput)
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
const { tenant: _tenant, ...rest } = args.data as typeof args.data & { tenant?: unknown };
|
|
args.data = { ...rest, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async createMany({ args, query }) {
|
|
if (Array.isArray(args.data)) {
|
|
args.data = args.data.map((item) => {
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
const { tenant: _t, ...rest } = item as typeof item & { tenant?: unknown };
|
|
return { ...rest, tenantId } as typeof item;
|
|
});
|
|
} else {
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
const { tenant: _t, ...rest } = args.data as typeof args.data & { tenant?: unknown };
|
|
args.data = { ...rest, tenantId } as typeof args.data;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async delete({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async upsert({ args, query }) {
|
|
args.where = { ...args.where, tenantId } as typeof args.where;
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
const { tenant: _t, ...createRest } = args.create as typeof args.create & { tenant?: unknown };
|
|
args.create = { ...createRest, tenantId } as typeof args.create;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
account: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.account.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.account.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async createMany({ args, query }) {
|
|
if (Array.isArray(args.data)) {
|
|
args.data = args.data.map((item) => ({ ...item, tenantId })) as typeof args.data;
|
|
} else {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async delete({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async upsert({ args, query }) {
|
|
args.where = { ...args.where, tenantId } as typeof args.where;
|
|
args.create = { ...args.create, tenantId } as typeof args.create;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
accountingPeriod: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.accountingPeriod.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.accountingPeriod.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async createMany({ args, query }) {
|
|
if (Array.isArray(args.data)) {
|
|
args.data = args.data.map((item) => ({ ...item, tenantId })) as typeof args.data;
|
|
} else {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async delete({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async upsert({ args, query }) {
|
|
args.where = { ...args.where, tenantId } as typeof args.where;
|
|
args.create = { ...args.create, tenantId } as typeof args.create;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
subscriber: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.subscriber.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.subscriber.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async createMany({ args, query }) {
|
|
if (Array.isArray(args.data)) {
|
|
args.data = args.data.map((item) => ({ ...item, tenantId })) as typeof args.data;
|
|
} else {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async delete({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async upsert({ args, query }) {
|
|
args.where = { ...args.where, tenantId } as typeof args.where;
|
|
args.create = { ...args.create, tenantId } as typeof args.create;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
servicePlan: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.servicePlan.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.servicePlan.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async createMany({ args, query }) {
|
|
if (Array.isArray(args.data)) {
|
|
args.data = args.data.map((item) => ({ ...item, tenantId })) as typeof args.data;
|
|
} else {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async delete({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async upsert({ args, query }) {
|
|
args.where = { ...args.where, tenantId } as typeof args.where;
|
|
args.create = { ...args.create, tenantId } as typeof args.create;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
tenantSettings: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.tenantSettings.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.tenantSettings.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async upsert({ args, query }) {
|
|
args.where = { ...args.where, tenantId } as typeof args.where;
|
|
args.create = { ...args.create, tenantId } as typeof args.create;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
journalEntry: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.journalEntry.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.journalEntry.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async delete({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
journalEntryLine: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.journalEntryLine.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
invoice: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.invoice.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.invoice.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async createMany({ args, query }) {
|
|
if (Array.isArray(args.data)) {
|
|
args.data = args.data.map((item) => ({ ...item, tenantId })) as typeof args.data;
|
|
} else {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async delete({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
invoiceLine: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
payment: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.payment.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
paymentAllocation: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async createMany({ args, query }) {
|
|
if (Array.isArray(args.data)) {
|
|
args.data = args.data.map((item) => ({ ...item, tenantId })) as typeof args.data;
|
|
} else {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
zone: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.zone.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.zone.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async createMany({ args, query }) {
|
|
if (Array.isArray(args.data)) {
|
|
args.data = args.data.map((item) => ({ ...item, tenantId })) as typeof args.data;
|
|
} else {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async delete({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async upsert({ args, query }) {
|
|
args.where = { ...args.where, tenantId } as typeof args.where;
|
|
args.create = { ...args.create, tenantId } as typeof args.create;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
zoneAssignment: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.zoneAssignment.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.zoneAssignment.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async createMany({ args, query }) {
|
|
if (Array.isArray(args.data)) {
|
|
args.data = args.data.map((item) => ({ ...item, tenantId })) as typeof args.data;
|
|
} else {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async delete({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async upsert({ args, query }) {
|
|
args.where = { ...args.where, tenantId } as typeof args.where;
|
|
args.create = { ...args.create, tenantId } as typeof args.create;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
ticketCategory: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.ticketCategory.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.ticketCategory.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async createMany({ args, query }) {
|
|
if (Array.isArray(args.data)) {
|
|
args.data = args.data.map((item) => ({ ...item, tenantId })) as typeof args.data;
|
|
} else {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async delete({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async upsert({ args, query }) {
|
|
args.where = { ...args.where, tenantId } as typeof args.where;
|
|
args.create = { ...args.create, tenantId } as typeof args.create;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
ticket: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.ticket.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.ticket.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async createMany({ args, query }) {
|
|
if (Array.isArray(args.data)) {
|
|
args.data = args.data.map((item) => ({ ...item, tenantId })) as typeof args.data;
|
|
} else {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async delete({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async upsert({ args, query }) {
|
|
args.where = { ...args.where, tenantId } as typeof args.where;
|
|
args.create = { ...args.create, tenantId } as typeof args.create;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
collection: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.collection.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.collection.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async createMany({ args, query }) {
|
|
if (Array.isArray(args.data)) {
|
|
args.data = args.data.map((item) => ({ ...item, tenantId })) as typeof args.data;
|
|
} else {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async delete({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async upsert({ args, query }) {
|
|
args.where = { ...args.where, tenantId } as typeof args.where;
|
|
args.create = { ...args.create, tenantId } as typeof args.create;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
collectionAllocation: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.collectionAllocation.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.collectionAllocation.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async createMany({ args, query }) {
|
|
if (Array.isArray(args.data)) {
|
|
args.data = args.data.map((item) => ({ ...item, tenantId })) as typeof args.data;
|
|
} else {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async delete({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async upsert({ args, query }) {
|
|
args.where = { ...args.where, tenantId } as typeof args.where;
|
|
args.create = { ...args.create, tenantId } as typeof args.create;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
remittance: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.remittance.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.remittance.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async createMany({ args, query }) {
|
|
if (Array.isArray(args.data)) {
|
|
args.data = args.data.map((item) => ({ ...item, tenantId })) as typeof args.data;
|
|
} else {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async delete({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async upsert({ args, query }) {
|
|
args.where = { ...args.where, tenantId } as typeof args.where;
|
|
args.create = { ...args.create, tenantId } as typeof args.create;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
|
|
jobOrder: {
|
|
async findMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirst({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findFirstOrThrow({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async findUnique({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
return prisma.jobOrder.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async findUniqueOrThrow({ args, query }) {
|
|
if (args.where && "id" in args.where && !("tenantId" in (args.where as object))) {
|
|
const result = await prisma.jobOrder.findFirst({
|
|
...args,
|
|
where: { ...args.where, tenantId },
|
|
});
|
|
if (!result) {
|
|
throw new Error("Record not found");
|
|
}
|
|
return result;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async create({ args, query }) {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
return query(args);
|
|
},
|
|
|
|
async createMany({ args, query }) {
|
|
if (Array.isArray(args.data)) {
|
|
args.data = args.data.map((item) => ({ ...item, tenantId })) as typeof args.data;
|
|
} else {
|
|
args.data = { ...args.data, tenantId } as typeof args.data;
|
|
}
|
|
return query(args);
|
|
},
|
|
|
|
async update({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async updateMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async delete({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async deleteMany({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async upsert({ args, query }) {
|
|
args.where = { ...args.where, tenantId } as typeof args.where;
|
|
args.create = { ...args.create, tenantId } as typeof args.create;
|
|
return query(args);
|
|
},
|
|
|
|
async count({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async aggregate({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
|
|
async groupBy({ args, query }) {
|
|
args.where = { ...args.where, tenantId };
|
|
return query(args);
|
|
},
|
|
},
|
|
},
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Alias for withTenantContext — exported under both names as per plan spec.
|
|
* Use either name; they are identical.
|
|
*/
|
|
export const createTenantPrisma = withTenantContext;
|
|
|
|
/**
|
|
* Sets the PostgreSQL session variable used by RLS policies for the duration
|
|
* of the provided transaction or connection.
|
|
*
|
|
* RLS ARCHITECTURE NOTE:
|
|
* The Prisma client connects as the database OWNER, which bypasses RLS
|
|
* by default (PostgreSQL superusers and table owners bypass RLS unless
|
|
* FORCE ROW LEVEL SECURITY is set). This means RLS is NOT the primary
|
|
* enforcement — withTenantContext() (application-level Prisma extensions)
|
|
* is the primary enforcement layer.
|
|
*
|
|
* This function enables RLS enforcement for code paths that explicitly opt in,
|
|
* or in future scenarios where a non-owner role is used for queries.
|
|
*
|
|
* Usage (inside a Prisma transaction):
|
|
* await prisma.$transaction(async (tx) => {
|
|
* await setTenantRLS(tx, tenantId);
|
|
* // ... queries here will be RLS-enforced
|
|
* });
|
|
*
|
|
* @param tx - A Prisma client or transaction client
|
|
* @param tenantId - The tenant UUID to set as the current RLS context
|
|
*/
|
|
export async function setTenantRLS(
|
|
tx: { $executeRawUnsafe: (query: string, ...args: unknown[]) => Promise<unknown> },
|
|
tenantId: string
|
|
): Promise<void> {
|
|
// SET LOCAL scopes the variable to the current transaction
|
|
await tx.$executeRawUnsafe(
|
|
`SET LOCAL "app.current_tenant_id" = $1`,
|
|
tenantId
|
|
);
|
|
}
|