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

package/dist/index.cjs

@@ -414,16 +414,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);
@@ -560,6 +550,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) => import_kysely.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);
@@ -597,6 +614,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 = (0, import_kysely.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);
   }
@@ -1123,18 +1160,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) {
@@ -1297,18 +1323,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) {
@@ -2750,27 +2765,8 @@ var BaseOperationHandler = class {
   }
   async read(kysely, model, args) {
     let query = this.dialect.buildSelectModel((0, import_kysely8.expressionBuilder)(), 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) => import_kysely8.sql.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);
@@ -2780,9 +2776,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"
@@ -2803,21 +2796,6 @@ ${compiled.parameters.map((p) => (0, import_node_util.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) {
@@ -2856,28 +2834,6 @@ ${compiled.parameters.map((p) => (0, import_node_util.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 = (0, import_kysely8.expressionBuilder)();
-    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) {
@@ -4506,8 +4462,7 @@ var InputValidator = class {
   }
   validateFindArgs(model, unique, args) {
     return this.validate(model, "find", {
-      unique,
-      collection: true
+      unique
     }, (model2, options) => this.makeFindSchema(model2, options), args);
   }
   validateCreateArgs(model, args) {
@@ -4575,12 +4530,12 @@ var InputValidator = class {
     fields["select"] = this.makeSelectSchema(model).optional();
     fields["include"] = this.makeIncludeSchema(model).optional();
     fields["omit"] = this.makeOmitSchema(model).optional();
-    fields["distinct"] = this.makeDistinctSchema(model).optional();
-    fields["cursor"] = this.makeCursorSchema(model).optional();
-    if (options.collection) {
+    if (!options.unique) {
       fields["skip"] = this.makeSkipSchema().optional();
       fields["take"] = this.makeTakeSchema().optional();
       fields["orderBy"] = this.orArray(this.makeOrderBySchema(model, true, false), true).optional();
+      fields["cursor"] = this.makeCursorSchema(model).optional();
+      fields["distinct"] = this.makeDistinctSchema(model).optional();
     }
     let result = import_zod.z.strictObject(fields);
     result = this.refineForSelectIncludeMutuallyExclusive(result);
@@ -4886,13 +4841,7 @@ var InputValidator = class {
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
-        fields[field] = import_zod.z.union([
-          import_zod.z.literal(true),
-          import_zod.z.strictObject({
-            select: import_zod.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
-            include: import_zod.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional()
-          })
-        ]).optional();
+        fields[field] = this.makeRelationSelectIncludeSchema(fieldDef).optional();
       } else {
         fields[field] = import_zod.z.boolean().optional();
       }
@@ -4916,6 +4865,31 @@ var InputValidator = class {
     }
     return import_zod.z.strictObject(fields);
   }
+  makeRelationSelectIncludeSchema(fieldDef) {
+    let objSchema = import_zod.z.strictObject({
+      ...fieldDef.array || fieldDef.optional ? {
+        // to-many relations and optional to-one relations are filterable
+        where: import_zod.z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
+      } : {},
+      select: import_zod.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
+      include: import_zod.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional(),
+      omit: import_zod.z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional(),
+      ...fieldDef.array ? {
+        // to-many relations can be ordered, skipped, taken, and cursor-located
+        orderBy: import_zod.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 import_zod.z.union([
+      import_zod.z.boolean(),
+      objSchema
+    ]);
+  }
   makeOmitSchema(model) {
     const modelDef = requireModel(this.schema, model);
     const fields = {};
@@ -4933,19 +4907,7 @@ var InputValidator = class {
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
-        fields[field] = import_zod.z.union([
-          import_zod.z.literal(true),
-          import_zod.z.strictObject({
-            select: import_zod.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
-            include: import_zod.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional(),
-            omit: import_zod.z.lazy(() => this.makeOmitSchema(fieldDef.type)).optional(),
-            where: import_zod.z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional(),
-            orderBy: import_zod.z.lazy(() => this.makeOrderBySchema(fieldDef.type, true, false)).optional(),
-            skip: this.makeSkipSchema().optional(),
-            take: this.makeTakeSchema().optional(),
-            distinct: this.makeDistinctSchema(fieldDef.type).optional()
-          })
-        ]).optional();
+        fields[field] = this.makeRelationSelectIncludeSchema(fieldDef).optional();
       }
     }
     return import_zod.z.strictObject(fields);
@@ -5014,7 +4976,7 @@ var InputValidator = class {
   // #region Create
   makeCreateSchema(model) {
     const dataSchema = this.makeCreateDataSchema(model, false);
-    const schema = import_zod.z.object({
+    const schema = import_zod.z.strictObject({
       data: dataSchema,
       select: this.makeSelectSchema(model).optional(),
       include: this.makeIncludeSchema(model).optional(),
@@ -5027,10 +4989,10 @@ var InputValidator = class {
   }
   makeCreateManyAndReturnSchema(model) {
     const base = this.makeCreateManyDataSchema(model, []);
-    const result = base.merge(import_zod.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) {
@@ -5195,13 +5157,13 @@ var InputValidator = class {
   makeConnectOrCreateDataSchema(model, canBeArray, withoutFields) {
     const whereSchema = this.makeWhereSchema(model, true);
     const createSchema = this.makeCreateDataSchema(model, false, withoutFields);
-    return this.orArray(import_zod.z.object({
+    return this.orArray(import_zod.z.strictObject({
       where: whereSchema,
       create: createSchema
     }), canBeArray);
   }
   makeCreateManyDataSchema(model, withoutFields) {
-    return import_zod.z.object({
+    return import_zod.z.strictObject({
       data: this.makeCreateDataSchema(model, true, withoutFields, true),
       skipDuplicates: import_zod.z.boolean().optional()
     });
@@ -5209,7 +5171,7 @@ var InputValidator = class {
   // #endregion
   // #region Update
   makeUpdateSchema(model) {
-    const schema = import_zod.z.object({
+    const schema = import_zod.z.strictObject({
       where: this.makeWhereSchema(model, true),
       data: this.makeUpdateDataSchema(model),
       select: this.makeSelectSchema(model).optional(),
@@ -5219,7 +5181,7 @@ var InputValidator = class {
     return this.refineForSelectIncludeMutuallyExclusive(schema);
   }
   makeUpdateManySchema(model) {
-    return import_zod.z.object({
+    return import_zod.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
       limit: import_zod.z.int().nonnegative().optional()
@@ -5227,14 +5189,14 @@ var InputValidator = class {
   }
   makeUpdateManyAndReturnSchema(model) {
     const base = this.makeUpdateManySchema(model);
-    const result = base.merge(import_zod.z.strictObject({
+    const result = base.extend({
       select: this.makeSelectSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
-    }));
+    });
     return this.refineForSelectOmitMutuallyExclusive(result);
   }
   makeUpsertSchema(model) {
-    const schema = import_zod.z.object({
+    const schema = import_zod.z.strictObject({
       where: this.makeWhereSchema(model, true),
       create: this.makeCreateDataSchema(model, false),
       update: this.makeUpdateDataSchema(model),
@@ -5319,7 +5281,7 @@ var InputValidator = class {
   // #endregion
   // #region Delete
   makeDeleteSchema(model) {
-    const schema = import_zod.z.object({
+    const schema = import_zod.z.strictObject({
       where: this.makeWhereSchema(model, true),
       select: this.makeSelectSchema(model).optional(),
       include: this.makeIncludeSchema(model).optional()
@@ -5347,7 +5309,7 @@ var InputValidator = class {
     const modelDef = requireModel(this.schema, model);
     return import_zod.z.union([
       import_zod.z.literal(true),
-      import_zod.z.object({
+      import_zod.z.strictObject({
         _all: import_zod.z.literal(true).optional(),
         ...Object.keys(modelDef.fields).reduce((acc, field) => {
           acc[field] = import_zod.z.literal(true).optional();
@@ -5394,7 +5356,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 = import_zod.z.object({
+    let schema = import_zod.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
       by: this.orArray(import_zod.z.enum(nonRelationFields), true),
@@ -6440,6 +6402,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 = (0, import_ts_pattern18.match)(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}`);
@@ -6450,6 +6415,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";
   }
@@ -6900,7 +6868,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;
@@ -6926,7 +6894,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
@@ -6939,55 +6907,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")
   };
 }