@zenstackhq/runtime 3.0.0-alpha.26 → 3.0.0-alpha.27

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { C as ClientConstructor } from './contract-BF6mvhVn.cjs';
-export { K as AggregateArgs, L as AggregateResult, B as BatchResult, i as BooleanFilter, h as BytesFilter, c as ClientContract, d as ClientOptions, G as CountArgs, H as CountResult, u as CreateArgs, w as CreateManyAndReturnArgs, v as CreateManyArgs, D as DateTimeFilter, A as DeleteArgs, E as DeleteManyArgs, F as FindArgs, s as FindFirstArgs, r as FindManyArgs, t as FindUniqueArgs, P as GroupByArgs, Q as GroupByResult, I as IncludeInput, J as JsonArray, a as JsonObject, b as JsonValue, M as ModelResult, k as NullsOrder, N as NumberFilter, m as OmitInput, O as OrderBy, n as SelectIncludeOmit, o as SelectInput, q as SelectSubset, S as SimplifiedModelResult, j as SortOrder, g as StringFilter, p as Subset, T as ToKysely, f as TypeDefResult, U as UpdateArgs, y as UpdateManyAndReturnArgs, x as UpdateManyArgs, z as UpsertArgs, W as WhereInput, l as WhereUniqueInput, e as definePlugin } from './contract-BF6mvhVn.cjs';
+import { C as ClientConstructor } from './contract-c8GpEAl3.cjs';
+export { K as AggregateArgs, L as AggregateResult, B as BatchResult, i as BooleanFilter, h as BytesFilter, c as ClientContract, d as ClientOptions, G as CountArgs, H as CountResult, u as CreateArgs, w as CreateManyAndReturnArgs, v as CreateManyArgs, D as DateTimeFilter, A as DeleteArgs, E as DeleteManyArgs, F as FindArgs, s as FindFirstArgs, r as FindManyArgs, t as FindUniqueArgs, P as GroupByArgs, Q as GroupByResult, I as IncludeInput, J as JsonArray, a as JsonObject, b as JsonValue, M as ModelResult, k as NullsOrder, N as NumberFilter, m as OmitInput, O as OrderBy, n as SelectIncludeOmit, o as SelectInput, q as SelectSubset, S as SimplifiedModelResult, j as SortOrder, g as StringFilter, p as Subset, T as ToKysely, f as TypeDefResult, U as UpdateArgs, y as UpdateManyAndReturnArgs, x as UpdateManyArgs, z as UpsertArgs, W as WhereInput, l as WhereUniqueInput, e as definePlugin } from './contract-c8GpEAl3.cjs';
 import 'decimal.js';
 import '@zenstackhq/sdk/schema';
 import 'kysely';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { C as ClientConstructor } from './contract-BF6mvhVn.js';
-export { K as AggregateArgs, L as AggregateResult, B as BatchResult, i as BooleanFilter, h as BytesFilter, c as ClientContract, d as ClientOptions, G as CountArgs, H as CountResult, u as CreateArgs, w as CreateManyAndReturnArgs, v as CreateManyArgs, D as DateTimeFilter, A as DeleteArgs, E as DeleteManyArgs, F as FindArgs, s as FindFirstArgs, r as FindManyArgs, t as FindUniqueArgs, P as GroupByArgs, Q as GroupByResult, I as IncludeInput, J as JsonArray, a as JsonObject, b as JsonValue, M as ModelResult, k as NullsOrder, N as NumberFilter, m as OmitInput, O as OrderBy, n as SelectIncludeOmit, o as SelectInput, q as SelectSubset, S as SimplifiedModelResult, j as SortOrder, g as StringFilter, p as Subset, T as ToKysely, f as TypeDefResult, U as UpdateArgs, y as UpdateManyAndReturnArgs, x as UpdateManyArgs, z as UpsertArgs, W as WhereInput, l as WhereUniqueInput, e as definePlugin } from './contract-BF6mvhVn.js';
+import { C as ClientConstructor } from './contract-c8GpEAl3.js';
+export { K as AggregateArgs, L as AggregateResult, B as BatchResult, i as BooleanFilter, h as BytesFilter, c as ClientContract, d as ClientOptions, G as CountArgs, H as CountResult, u as CreateArgs, w as CreateManyAndReturnArgs, v as CreateManyArgs, D as DateTimeFilter, A as DeleteArgs, E as DeleteManyArgs, F as FindArgs, s as FindFirstArgs, r as FindManyArgs, t as FindUniqueArgs, P as GroupByArgs, Q as GroupByResult, I as IncludeInput, J as JsonArray, a as JsonObject, b as JsonValue, M as ModelResult, k as NullsOrder, N as NumberFilter, m as OmitInput, O as OrderBy, n as SelectIncludeOmit, o as SelectInput, q as SelectSubset, S as SimplifiedModelResult, j as SortOrder, g as StringFilter, p as Subset, T as ToKysely, f as TypeDefResult, U as UpdateArgs, y as UpdateManyAndReturnArgs, x as UpdateManyArgs, z as UpsertArgs, W as WhereInput, l as WhereUniqueInput, e as definePlugin } from './contract-c8GpEAl3.js';
 import 'decimal.js';
 import '@zenstackhq/sdk/schema';
 import 'kysely';

package/dist/index.js

@@ -379,16 +379,6 @@ function ensureArray(value) {
   }
 }
 __name(ensureArray, "ensureArray");
-function safeJSONStringify(value) {
-  return JSON.stringify(value, (_, v) => {
-    if (typeof v === "bigint") {
-      return v.toString();
-    } else {
-      return v;
-    }
-  });
-}
-__name(safeJSONStringify, "safeJSONStringify");
 function extractIdFields(entity, schema, model) {
   const idFields = getIdFields(schema, model);
   return extractFields(entity, idFields);
@@ -525,6 +515,33 @@ var BaseCrudDialect = class {
     }
     return result;
   }
+  buildFilterSortTake(model, args, query) {
+    let result = query;
+    if (args.where) {
+      result = result.where((eb) => this.buildFilter(eb, model, model, args?.where));
+    }
+    let negateOrderBy = false;
+    const skip = args.skip;
+    let take = args.take;
+    if (take !== void 0 && take < 0) {
+      negateOrderBy = true;
+      take = -take;
+    }
+    result = this.buildSkipTake(result, skip, take);
+    result = this.buildOrderBy(result, model, model, args.orderBy, skip !== void 0 || take !== void 0, negateOrderBy);
+    if ("distinct" in args && args.distinct) {
+      const distinct = ensureArray(args.distinct);
+      if (this.supportsDistinctOn) {
+        result = result.distinctOn(distinct.map((f) => sql.ref(`${model}.${f}`)));
+      } else {
+        throw new QueryError(`"distinct" is not supported by "${this.schema.provider.type}" provider`);
+      }
+    }
+    if (args.cursor) {
+      result = this.buildCursorFilter(model, result, args.cursor, args.orderBy, negateOrderBy);
+    }
+    return result;
+  }
   buildFilter(eb, model, modelAlias, where) {
     if (where === true || where === void 0) {
       return this.true(eb);
@@ -562,6 +579,26 @@ var BaseCrudDialect = class {
     }
     return result;
   }
+  buildCursorFilter(model, query, cursor, orderBy, negateOrderBy) {
+    const _orderBy = orderBy ?? makeDefaultOrderBy(this.schema, model);
+    const orderByItems = ensureArray(_orderBy).flatMap((obj) => Object.entries(obj));
+    const eb = expressionBuilder();
+    const cursorFilter = this.buildFilter(eb, model, model, cursor);
+    let result = query;
+    const filters = [];
+    for (let i = orderByItems.length - 1; i >= 0; i--) {
+      const andFilters = [];
+      for (let j = 0; j <= i; j++) {
+        const [field, order] = orderByItems[j];
+        const _order = negateOrderBy ? order === "asc" ? "desc" : "asc" : order;
+        const op = j === i ? _order === "asc" ? ">=" : "<=" : "=";
+        andFilters.push(eb(eb.ref(`${model}.${field}`), op, eb.selectFrom(model).select(`${model}.${field}`).where(cursorFilter)));
+      }
+      filters.push(eb.and(andFilters));
+    }
+    result = result.where((eb2) => eb2.or(filters));
+    return result;
+  }
   isLogicalCombinator(key) {
     return LOGICAL_COMBINATORS.includes(key);
   }
@@ -1088,18 +1125,7 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
         let subQuery = this.buildSelectModel(eb, relationModel);
         subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0);
         if (payload && typeof payload === "object") {
-          if (payload.where) {
-            subQuery = subQuery.where((eb2) => this.buildFilter(eb2, relationModel, relationModel, payload.where));
-          }
-          const skip = payload.skip;
-          let take = payload.take;
-          let negateOrderBy = false;
-          if (take !== void 0 && take < 0) {
-            negateOrderBy = true;
-            take = -take;
-          }
-          subQuery = this.buildSkipTake(subQuery, skip, take);
-          subQuery = this.buildOrderBy(subQuery, relationModel, relationModel, payload.orderBy, skip !== void 0 || take !== void 0, negateOrderBy);
+          subQuery = this.buildFilterSortTake(relationModel, payload, subQuery);
         }
         const m2m = getManyToManyRelation(this.schema, model, relationField);
         if (m2m) {
@@ -1262,18 +1288,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       let subQuery = this.buildSelectModel(eb, relationModel);
       subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0);
       if (payload && typeof payload === "object") {
-        if (payload.where) {
-          subQuery = subQuery.where((eb2) => this.buildFilter(eb2, relationModel, relationModel, payload.where));
-        }
-        const skip = payload.skip;
-        let take = payload.take;
-        let negateOrderBy = false;
-        if (take !== void 0 && take < 0) {
-          negateOrderBy = true;
-          take = -take;
-        }
-        subQuery = this.buildSkipTake(subQuery, skip, take);
-        subQuery = this.buildOrderBy(subQuery, relationModel, relationModel, payload.orderBy, skip !== void 0 || take !== void 0, negateOrderBy);
+        subQuery = this.buildFilterSortTake(relationModel, payload, subQuery);
       }
       const m2m = getManyToManyRelation(this.schema, model, relationField);
       if (m2m) {
@@ -2715,27 +2730,8 @@ var BaseOperationHandler = class {
   }
   async read(kysely, model, args) {
     let query = this.dialect.buildSelectModel(expressionBuilder3(), model);
-    if (args?.where) {
-      query = query.where((eb) => this.dialect.buildFilter(eb, model, model, args?.where));
-    }
-    let negateOrderBy = false;
-    const skip = args?.skip;
-    let take = args?.take;
-    if (take !== void 0 && take < 0) {
-      negateOrderBy = true;
-      take = -take;
-    }
-    query = this.dialect.buildSkipTake(query, skip, take);
-    query = this.dialect.buildOrderBy(query, model, model, args?.orderBy, skip !== void 0 || take !== void 0, negateOrderBy);
-    let inMemoryDistinct = void 0;
-    if (args?.distinct) {
-      const distinct = ensureArray(args.distinct);
-      if (this.dialect.supportsDistinctOn) {
-        query = query.distinctOn(distinct.map((f) => sql4.ref(`${model}.${f}`)));
-      } else {
-        inMemoryDistinct = distinct;
-        query = distinct.reduce((acc, field) => acc.select((eb) => this.dialect.fieldRef(model, field, eb).as(`$distinct$${field}`)), query);
-      }
+    if (args) {
+      query = this.dialect.buildFilterSortTake(model, args, query);
     }
     if (args && "select" in args && args.select) {
       query = this.buildFieldSelection(model, query, args.select, model);
@@ -2745,9 +2741,6 @@ var BaseOperationHandler = class {
     if (args && "include" in args && args.include) {
       query = this.buildFieldSelection(model, query, args.include, model);
     }
-    if (args?.cursor) {
-      query = this.buildCursorFilter(model, query, args.cursor, args.orderBy, negateOrderBy);
-    }
     query = query.modifyEnd(this.makeContextComment({
       model,
       operation: "read"
@@ -2768,21 +2761,6 @@ ${compiled.parameters.map((p) => inspect(p)).join("\n")}`;
       }
       throw new QueryError(message, err);
     }
-    if (inMemoryDistinct) {
-      const distinctResult = [];
-      const seen = /* @__PURE__ */ new Set();
-      for (const r of result) {
-        const key = safeJSONStringify(inMemoryDistinct.map((f) => r[`$distinct$${f}`]));
-        if (!seen.has(key)) {
-          distinctResult.push(r);
-          seen.add(key);
-        }
-      }
-      result = distinctResult;
-      for (const r of result) {
-        Object.keys(r).filter((k) => k.startsWith("$distinct$")).forEach((k) => delete r[k]);
-      }
-    }
     return result;
   }
   async readUnique(kysely, model, args) {
@@ -2821,28 +2799,6 @@ ${compiled.parameters.map((p) => inspect(p)).join("\n")}`;
   buildCountSelection(query, model, parentAlias, payload) {
     return query.select((eb) => this.dialect.buildCountJson(model, eb, parentAlias, payload).as("_count"));
   }
-  buildCursorFilter(model, query, cursor, orderBy, negateOrderBy) {
-    if (!orderBy) {
-      orderBy = makeDefaultOrderBy(this.schema, model);
-    }
-    const orderByItems = ensureArray(orderBy).flatMap((obj) => Object.entries(obj));
-    const eb = expressionBuilder3();
-    const cursorFilter = this.dialect.buildFilter(eb, model, model, cursor);
-    let result = query;
-    const filters = [];
-    for (let i = orderByItems.length - 1; i >= 0; i--) {
-      const andFilters = [];
-      for (let j = 0; j <= i; j++) {
-        const [field, order] = orderByItems[j];
-        const _order = negateOrderBy ? order === "asc" ? "desc" : "asc" : order;
-        const op = j === i ? _order === "asc" ? ">=" : "<=" : "=";
-        andFilters.push(eb(eb.ref(`${model}.${field}`), op, eb.selectFrom(model).select(`${model}.${field}`).where(cursorFilter)));
-      }
-      filters.push(eb.and(andFilters));
-    }
-    result = result.where((eb2) => eb2.or(filters));
-    return result;
-  }
   async create(kysely, model, data, fromRelation, creatingForDelegate = false) {
     const modelDef = this.requireModel(model);
     if (modelDef.isDelegate && !creatingForDelegate) {
@@ -4875,25 +4831,28 @@ var InputValidator = class {
     return z.strictObject(fields);
   }
   makeRelationSelectIncludeSchema(fieldDef) {
+    let objSchema = z.strictObject({
+      ...fieldDef.array || fieldDef.optional ? {
+        // to-many relations and optional to-one relations are filterable
+        where: z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
+      } : {},
+      select: z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
+      include: z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional(),
+      omit: z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional(),
+      ...fieldDef.array ? {
+        // to-many relations can be ordered, skipped, taken, and cursor-located
+        orderBy: z.lazy(() => this.makeOrderBySchema(fieldDef.type, true, false)).optional(),
+        skip: this.makeSkipSchema().optional(),
+        take: this.makeTakeSchema().optional(),
+        cursor: this.makeCursorSchema(fieldDef.type).optional(),
+        distinct: this.makeDistinctSchema(fieldDef.type).optional()
+      } : {}
+    });
+    objSchema = this.refineForSelectIncludeMutuallyExclusive(objSchema);
+    objSchema = this.refineForSelectOmitMutuallyExclusive(objSchema);
     return z.union([
       z.boolean(),
-      z.strictObject({
-        ...fieldDef.array || fieldDef.optional ? {
-          // to-many relations and optional to-one relations are filterable
-          where: z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
-        } : {},
-        select: z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
-        include: z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional(),
-        omit: z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional(),
-        ...fieldDef.array ? {
-          // to-many relations can be ordered, skipped, taken, and cursor-located
-          orderBy: z.lazy(() => this.makeOrderBySchema(fieldDef.type, true, false)).optional(),
-          skip: this.makeSkipSchema().optional(),
-          take: this.makeTakeSchema().optional(),
-          cursor: this.makeCursorSchema(fieldDef.type).optional(),
-          distinct: this.makeDistinctSchema(fieldDef.type).optional()
-        } : {}
-      })
+      objSchema
     ]);
   }
   makeOmitSchema(model) {
@@ -4982,7 +4941,7 @@ var InputValidator = class {
   // #region Create
   makeCreateSchema(model) {
     const dataSchema = this.makeCreateDataSchema(model, false);
-    const schema = z.object({
+    const schema = z.strictObject({
       data: dataSchema,
       select: this.makeSelectSchema(model).optional(),
       include: this.makeIncludeSchema(model).optional(),
@@ -4995,10 +4954,10 @@ var InputValidator = class {
   }
   makeCreateManyAndReturnSchema(model) {
     const base = this.makeCreateManyDataSchema(model, []);
-    const result = base.merge(z.strictObject({
+    const result = base.extend({
       select: this.makeSelectSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
-    }));
+    });
     return this.refineForSelectOmitMutuallyExclusive(result).optional();
   }
   makeCreateDataSchema(model, canBeArray, withoutFields = [], withoutRelationFields = false) {
@@ -5163,13 +5122,13 @@ var InputValidator = class {
   makeConnectOrCreateDataSchema(model, canBeArray, withoutFields) {
     const whereSchema = this.makeWhereSchema(model, true);
     const createSchema = this.makeCreateDataSchema(model, false, withoutFields);
-    return this.orArray(z.object({
+    return this.orArray(z.strictObject({
       where: whereSchema,
       create: createSchema
     }), canBeArray);
   }
   makeCreateManyDataSchema(model, withoutFields) {
-    return z.object({
+    return z.strictObject({
       data: this.makeCreateDataSchema(model, true, withoutFields, true),
       skipDuplicates: z.boolean().optional()
     });
@@ -5177,7 +5136,7 @@ var InputValidator = class {
   // #endregion
   // #region Update
   makeUpdateSchema(model) {
-    const schema = z.object({
+    const schema = z.strictObject({
       where: this.makeWhereSchema(model, true),
       data: this.makeUpdateDataSchema(model),
       select: this.makeSelectSchema(model).optional(),
@@ -5187,7 +5146,7 @@ var InputValidator = class {
     return this.refineForSelectIncludeMutuallyExclusive(schema);
   }
   makeUpdateManySchema(model) {
-    return z.object({
+    return z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
       limit: z.int().nonnegative().optional()
@@ -5195,14 +5154,14 @@ var InputValidator = class {
   }
   makeUpdateManyAndReturnSchema(model) {
     const base = this.makeUpdateManySchema(model);
-    const result = base.merge(z.strictObject({
+    const result = base.extend({
       select: this.makeSelectSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
-    }));
+    });
     return this.refineForSelectOmitMutuallyExclusive(result);
   }
   makeUpsertSchema(model) {
-    const schema = z.object({
+    const schema = z.strictObject({
       where: this.makeWhereSchema(model, true),
       create: this.makeCreateDataSchema(model, false),
       update: this.makeUpdateDataSchema(model),
@@ -5287,7 +5246,7 @@ var InputValidator = class {
   // #endregion
   // #region Delete
   makeDeleteSchema(model) {
-    const schema = z.object({
+    const schema = z.strictObject({
       where: this.makeWhereSchema(model, true),
       select: this.makeSelectSchema(model).optional(),
       include: this.makeIncludeSchema(model).optional()
@@ -5315,7 +5274,7 @@ var InputValidator = class {
     const modelDef = requireModel(this.schema, model);
     return z.union([
       z.literal(true),
-      z.object({
+      z.strictObject({
         _all: z.literal(true).optional(),
         ...Object.keys(modelDef.fields).reduce((acc, field) => {
           acc[field] = z.literal(true).optional();
@@ -5362,7 +5321,7 @@ var InputValidator = class {
   makeGroupBySchema(model) {
     const modelDef = requireModel(this.schema, model);
     const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
-    let schema = z.object({
+    let schema = z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
       by: this.orArray(z.enum(nonRelationFields), true),
@@ -6408,6 +6367,9 @@ var SchemaDbPusher = class {
     if (this.isAutoIncrement(fieldDef) && this.schema.provider.type === "postgresql") {
       return "serial";
     }
+    if (this.isCustomType(fieldDef.type)) {
+      return "jsonb";
+    }
     const type = fieldDef.type;
     const result = match18(type).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("Float", () => "real").with("BigInt", () => "bigint").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => this.schema.provider.type === "postgresql" ? "bytea" : "blob").with("Json", () => "jsonb").otherwise(() => {
       throw new Error(`Unsupported field type: ${type}`);
@@ -6418,6 +6380,9 @@ var SchemaDbPusher = class {
       return result;
     }
   }
+  isCustomType(type) {
+    return this.schema.typeDefs && Object.values(this.schema.typeDefs).some((def) => def.name === type);
+  }
   isAutoIncrement(fieldDef) {
     return fieldDef.default && ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "autoincrement";
   }
@@ -6868,7 +6833,7 @@ function createClientProxy(client) {
 }
 __name(createClientProxy, "createClientProxy");
 function createModelCrudHandler(client, model, inputValidator, resultProcessor) {
-  const createPromise = /* @__PURE__ */ __name((operation, args, handler, postProcess = false, throwIfNoResult = false) => {
+  const createPromise = /* @__PURE__ */ __name((operation, nominalOperation, args, handler, postProcess = false, throwIfNoResult = false) => {
     return createZenStackPromise(async (txClient) => {
       let proceed = /* @__PURE__ */ __name(async (_args) => {
         const _handler = txClient ? handler.withClient(txClient) : handler;
@@ -6894,7 +6859,7 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
           proceed = /* @__PURE__ */ __name((_args) => onQuery({
             client,
             model,
-            operation,
+            operation: nominalOperation,
             // reflect the latest override if provided
             args: _args,
             // ensure inner overrides are propagated to the previous proceed
@@ -6907,55 +6872,55 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
   }, "createPromise");
   return {
     findUnique: /* @__PURE__ */ __name((args) => {
-      return createPromise("findUnique", args, new FindOperationHandler(client, model, inputValidator), true);
+      return createPromise("findUnique", "findUnique", args, new FindOperationHandler(client, model, inputValidator), true);
     }, "findUnique"),
     findUniqueOrThrow: /* @__PURE__ */ __name((args) => {
-      return createPromise("findUnique", args, new FindOperationHandler(client, model, inputValidator), true, true);
+      return createPromise("findUnique", "findUniqueOrThrow", args, new FindOperationHandler(client, model, inputValidator), true, true);
     }, "findUniqueOrThrow"),
     findFirst: /* @__PURE__ */ __name((args) => {
-      return createPromise("findFirst", args, new FindOperationHandler(client, model, inputValidator), true);
+      return createPromise("findFirst", "findFirst", args, new FindOperationHandler(client, model, inputValidator), true);
     }, "findFirst"),
     findFirstOrThrow: /* @__PURE__ */ __name((args) => {
-      return createPromise("findFirst", args, new FindOperationHandler(client, model, inputValidator), true, true);
+      return createPromise("findFirst", "findFirstOrThrow", args, new FindOperationHandler(client, model, inputValidator), true, true);
     }, "findFirstOrThrow"),
     findMany: /* @__PURE__ */ __name((args) => {
-      return createPromise("findMany", args, new FindOperationHandler(client, model, inputValidator), true);
+      return createPromise("findMany", "findMany", args, new FindOperationHandler(client, model, inputValidator), true);
     }, "findMany"),
     create: /* @__PURE__ */ __name((args) => {
-      return createPromise("create", args, new CreateOperationHandler(client, model, inputValidator), true);
+      return createPromise("create", "create", args, new CreateOperationHandler(client, model, inputValidator), true);
     }, "create"),
     createMany: /* @__PURE__ */ __name((args) => {
-      return createPromise("createMany", args, new CreateOperationHandler(client, model, inputValidator), false);
+      return createPromise("createMany", "createMany", args, new CreateOperationHandler(client, model, inputValidator), false);
     }, "createMany"),
     createManyAndReturn: /* @__PURE__ */ __name((args) => {
-      return createPromise("createManyAndReturn", args, new CreateOperationHandler(client, model, inputValidator), true);
+      return createPromise("createManyAndReturn", "createManyAndReturn", args, new CreateOperationHandler(client, model, inputValidator), true);
     }, "createManyAndReturn"),
     update: /* @__PURE__ */ __name((args) => {
-      return createPromise("update", args, new UpdateOperationHandler(client, model, inputValidator), true);
+      return createPromise("update", "update", args, new UpdateOperationHandler(client, model, inputValidator), true);
     }, "update"),
     updateMany: /* @__PURE__ */ __name((args) => {
-      return createPromise("updateMany", args, new UpdateOperationHandler(client, model, inputValidator), false);
+      return createPromise("updateMany", "updateMany", args, new UpdateOperationHandler(client, model, inputValidator), false);
     }, "updateMany"),
     updateManyAndReturn: /* @__PURE__ */ __name((args) => {
-      return createPromise("updateManyAndReturn", args, new UpdateOperationHandler(client, model, inputValidator), true);
+      return createPromise("updateManyAndReturn", "updateManyAndReturn", args, new UpdateOperationHandler(client, model, inputValidator), true);
     }, "updateManyAndReturn"),
     upsert: /* @__PURE__ */ __name((args) => {
-      return createPromise("upsert", args, new UpdateOperationHandler(client, model, inputValidator), true);
+      return createPromise("upsert", "upsert", args, new UpdateOperationHandler(client, model, inputValidator), true);
     }, "upsert"),
     delete: /* @__PURE__ */ __name((args) => {
-      return createPromise("delete", args, new DeleteOperationHandler(client, model, inputValidator), true);
+      return createPromise("delete", "delete", args, new DeleteOperationHandler(client, model, inputValidator), true);
     }, "delete"),
     deleteMany: /* @__PURE__ */ __name((args) => {
-      return createPromise("deleteMany", args, new DeleteOperationHandler(client, model, inputValidator), false);
+      return createPromise("deleteMany", "deleteMany", args, new DeleteOperationHandler(client, model, inputValidator), false);
     }, "deleteMany"),
     count: /* @__PURE__ */ __name((args) => {
-      return createPromise("count", args, new CountOperationHandler(client, model, inputValidator), false);
+      return createPromise("count", "count", args, new CountOperationHandler(client, model, inputValidator), false);
     }, "count"),
     aggregate: /* @__PURE__ */ __name((args) => {
-      return createPromise("aggregate", args, new AggregateOperationHandler(client, model, inputValidator), false);
+      return createPromise("aggregate", "aggregate", args, new AggregateOperationHandler(client, model, inputValidator), false);
     }, "aggregate"),
     groupBy: /* @__PURE__ */ __name((args) => {
-      return createPromise("groupBy", args, new GroupByOperationHandler(client, model, inputValidator), true);
+      return createPromise("groupBy", "groupBy", args, new GroupByOperationHandler(client, model, inputValidator), true);
     }, "groupBy")
   };
 }