@zenstackhq/orm 3.2.1 → 3.3.0-beta.1

package/dist/index.cjs

@@ -32,11 +32,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  AllCrudOperations: () => AllCrudOperations,
+  AllReadOperations: () => AllReadOperations,
   AnyNull: () => AnyNull,
   AnyNullClass: () => AnyNullClass,
   BaseCrudDialect: () => BaseCrudDialect,
   CRUD: () => CRUD,
   CRUD_EXT: () => CRUD_EXT,
+  CoreCrudOperations: () => CoreCrudOperations,
+  CoreReadOperations: () => CoreReadOperations,
+  CoreWriteOperations: () => CoreWriteOperations,
   DbNull: () => DbNull,
   DbNullClass: () => DbNullClass,
   InputValidator: () => InputValidator,
@@ -2107,6 +2112,54 @@ function getCrudDialect(schema, options) {
 __name(getCrudDialect, "getCrudDialect");
 
 // src/client/crud/operations/base.ts
+var CoreCrudOperations = [
+  "findMany",
+  "findUnique",
+  "findFirst",
+  "create",
+  "createMany",
+  "createManyAndReturn",
+  "update",
+  "updateMany",
+  "updateManyAndReturn",
+  "upsert",
+  "delete",
+  "deleteMany",
+  "count",
+  "aggregate",
+  "groupBy",
+  "exists"
+];
+var CoreReadOperations = [
+  "findMany",
+  "findUnique",
+  "findFirst",
+  "count",
+  "aggregate",
+  "groupBy",
+  "exists"
+];
+var CoreWriteOperations = [
+  "create",
+  "createMany",
+  "createManyAndReturn",
+  "update",
+  "updateMany",
+  "updateManyAndReturn",
+  "upsert",
+  "delete",
+  "deleteMany"
+];
+var AllCrudOperations = [
+  ...CoreCrudOperations,
+  "findUniqueOrThrow",
+  "findFirstOrThrow"
+];
+var AllReadOperations = [
+  ...CoreReadOperations,
+  "findUniqueOrThrow",
+  "findFirstOrThrow"
+];
 var BaseOperationHandler = class {
   static {
     __name(this, "BaseOperationHandler");
@@ -3759,6 +3812,18 @@ var DeleteOperationHandler = class extends BaseOperationHandler {
   }
 };
 
+// src/client/crud/operations/exists.ts
+var ExistsOperationHandler = class extends BaseOperationHandler {
+  static {
+    __name(this, "ExistsOperationHandler");
+  }
+  async handle(_operation, args) {
+    const normalizedArgs = this.normalizeArgs(args);
+    const parsedArgs = this.inputValidator.validateExistsArgs(this.model, normalizedArgs);
+    return await this.existsNonUnique(this.client.$qb, this.model, parsedArgs?.where);
+  }
+};
+
 // src/client/crud/operations/find.ts
 var FindOperationHandler = class extends BaseOperationHandler {
   static {
@@ -3767,10 +3832,7 @@ var FindOperationHandler = class extends BaseOperationHandler {
   async handle(operation, args, validateArgs = true) {
     const normalizedArgs = this.normalizeArgs(args);
     const findOne = operation === "findFirst" || operation === "findUnique";
-    let parsedArgs = validateArgs ? this.inputValidator.validateFindArgs(this.model, normalizedArgs, {
-      unique: operation === "findUnique",
-      findOne
-    }) : normalizedArgs;
+    let parsedArgs = validateArgs ? this.inputValidator.validateFindArgs(this.model, normalizedArgs, operation) : normalizedArgs;
     if (findOne) {
       parsedArgs = parsedArgs ?? {};
       parsedArgs.take = 1;
@@ -3781,18 +3843,6 @@ var FindOperationHandler = class extends BaseOperationHandler {
   }
 };
 
-// src/client/crud/operations/exists.ts
-var ExistsOperationHandler = class extends BaseOperationHandler {
-  static {
-    __name(this, "ExistsOperationHandler");
-  }
-  async handle(_operation, args) {
-    const normalizedArgs = this.normalizeArgs(args);
-    const parsedArgs = this.inputValidator.validateExistsArgs(this.model, normalizedArgs);
-    return await this.existsNonUnique(this.client.$qb, this.model, parsedArgs?.where);
-  }
-};
-
 // src/client/crud/operations/group-by.ts
 var import_ts_pattern10 = require("ts-pattern");
 var GroupByOperationHandler = class extends BaseOperationHandler {
@@ -4391,12 +4441,12 @@ function evalCall(data, expr) {
 __name(evalCall, "evalCall");
 
 // src/client/crud/validator/index.ts
-var schemaCache = /* @__PURE__ */ new WeakMap();
 var InputValidator = class {
   static {
     __name(this, "InputValidator");
   }
   client;
+  schemaCache = /* @__PURE__ */ new Map();
   constructor(client) {
     this.client = client;
   }
@@ -4493,75 +4543,64 @@ var InputValidator = class {
     }
     return schema;
   }
-  validateFindArgs(model, args, options) {
-    return this.validate(model, "find", options, (model2, options2) => this.makeFindSchema(model2, options2), args);
+  validateFindArgs(model, args, operation) {
+    return this.validate(model, operation, (model2) => this.makeFindSchema(model2, operation), args);
   }
   validateExistsArgs(model, args) {
-    return this.validate(model, "exists", void 0, (model2) => this.makeExistsSchema(model2), args);
+    return this.validate(model, "exists", (model2) => this.makeExistsSchema(model2), args);
   }
   validateCreateArgs(model, args) {
-    return this.validate(model, "create", void 0, (model2) => this.makeCreateSchema(model2), args);
+    return this.validate(model, "create", (model2) => this.makeCreateSchema(model2), args);
   }
   validateCreateManyArgs(model, args) {
-    return this.validate(model, "createMany", void 0, (model2) => this.makeCreateManySchema(model2), args);
+    return this.validate(model, "createMany", (model2) => this.makeCreateManySchema(model2), args);
   }
   validateCreateManyAndReturnArgs(model, args) {
-    return this.validate(model, "createManyAndReturn", void 0, (model2) => this.makeCreateManyAndReturnSchema(model2), args);
+    return this.validate(model, "createManyAndReturn", (model2) => this.makeCreateManyAndReturnSchema(model2), args);
   }
   validateUpdateArgs(model, args) {
-    return this.validate(model, "update", void 0, (model2) => this.makeUpdateSchema(model2), args);
+    return this.validate(model, "update", (model2) => this.makeUpdateSchema(model2), args);
   }
   validateUpdateManyArgs(model, args) {
-    return this.validate(model, "updateMany", void 0, (model2) => this.makeUpdateManySchema(model2), args);
+    return this.validate(model, "updateMany", (model2) => this.makeUpdateManySchema(model2), args);
   }
   validateUpdateManyAndReturnArgs(model, args) {
-    return this.validate(model, "updateManyAndReturn", void 0, (model2) => this.makeUpdateManyAndReturnSchema(model2), args);
+    return this.validate(model, "updateManyAndReturn", (model2) => this.makeUpdateManyAndReturnSchema(model2), args);
   }
   validateUpsertArgs(model, args) {
-    return this.validate(model, "upsert", void 0, (model2) => this.makeUpsertSchema(model2), args);
+    return this.validate(model, "upsert", (model2) => this.makeUpsertSchema(model2), args);
   }
   validateDeleteArgs(model, args) {
-    return this.validate(model, "delete", void 0, (model2) => this.makeDeleteSchema(model2), args);
+    return this.validate(model, "delete", (model2) => this.makeDeleteSchema(model2), args);
   }
   validateDeleteManyArgs(model, args) {
-    return this.validate(model, "deleteMany", void 0, (model2) => this.makeDeleteManySchema(model2), args);
+    return this.validate(model, "deleteMany", (model2) => this.makeDeleteManySchema(model2), args);
   }
   validateCountArgs(model, args) {
-    return this.validate(model, "count", void 0, (model2) => this.makeCountSchema(model2), args);
+    return this.validate(model, "count", (model2) => this.makeCountSchema(model2), args);
   }
   validateAggregateArgs(model, args) {
-    return this.validate(model, "aggregate", void 0, (model2) => this.makeAggregateSchema(model2), args);
+    return this.validate(model, "aggregate", (model2) => this.makeAggregateSchema(model2), args);
   }
   validateGroupByArgs(model, args) {
-    return this.validate(model, "groupBy", void 0, (model2) => this.makeGroupBySchema(model2), args);
+    return this.validate(model, "groupBy", (model2) => this.makeGroupBySchema(model2), args);
   }
   getSchemaCache(cacheKey) {
-    let thisCache = schemaCache.get(this.schema);
-    if (!thisCache) {
-      thisCache = /* @__PURE__ */ new Map();
-      schemaCache.set(this.schema, thisCache);
-    }
-    return thisCache.get(cacheKey);
+    return this.schemaCache.get(cacheKey);
   }
   setSchemaCache(cacheKey, schema) {
-    let thisCache = schemaCache.get(this.schema);
-    if (!thisCache) {
-      thisCache = /* @__PURE__ */ new Map();
-      schemaCache.set(this.schema, thisCache);
-    }
-    return thisCache.set(cacheKey, schema);
+    return this.schemaCache.set(cacheKey, schema);
   }
-  validate(model, operation, options, getSchema, args) {
+  validate(model, operation, getSchema, args) {
     const cacheKey = (0, import_json_stable_stringify.default)({
       type: "model",
       model,
       operation,
-      options,
       extraValidationsEnabled: this.extraValidationsEnabled
     });
     let schema = this.getSchemaCache(cacheKey);
     if (!schema) {
-      schema = getSchema(model, options);
+      schema = getSchema(model);
       this.setSchemaCache(cacheKey, schema);
     }
     const { error, data } = schema.safeParse(args);
@@ -4572,11 +4611,25 @@ var InputValidator = class {
     }
     return data;
   }
+  mergePluginArgsSchema(schema, operation) {
+    let result = schema;
+    for (const plugin of this.options.plugins ?? []) {
+      if (plugin.extQueryArgs) {
+        const pluginSchema = plugin.extQueryArgs.getValidationSchema(operation);
+        if (pluginSchema) {
+          result = result.extend(pluginSchema.shape);
+        }
+      }
+    }
+    return result.strict();
+  }
   // #region Find
-  makeFindSchema(model, options) {
+  makeFindSchema(model, operation) {
     const fields = {};
-    const where = this.makeWhereSchema(model, options.unique);
-    if (options.unique) {
+    const unique = operation === "findUnique";
+    const findOne = operation === "findUnique" || operation === "findFirst";
+    const where = this.makeWhereSchema(model, unique);
+    if (unique) {
       fields["where"] = where;
     } else {
       fields["where"] = where.optional();
@@ -4584,9 +4637,9 @@ var InputValidator = class {
     fields["select"] = this.makeSelectSchema(model).optional().nullable();
     fields["include"] = this.makeIncludeSchema(model).optional().nullable();
     fields["omit"] = this.makeOmitSchema(model).optional().nullable();
-    if (!options.unique) {
+    if (!unique) {
       fields["skip"] = this.makeSkipSchema().optional();
-      if (options.findOne) {
+      if (findOne) {
         fields["take"] = import_zod3.z.literal(1).optional();
       } else {
         fields["take"] = this.makeTakeSchema().optional();
@@ -4595,18 +4648,20 @@ var InputValidator = class {
       fields["cursor"] = this.makeCursorSchema(model).optional();
       fields["distinct"] = this.makeDistinctSchema(model).optional();
     }
-    let result = import_zod3.z.strictObject(fields);
+    const baseSchema = import_zod3.z.strictObject(fields);
+    let result = this.mergePluginArgsSchema(baseSchema, operation);
     result = this.refineForSelectIncludeMutuallyExclusive(result);
     result = this.refineForSelectOmitMutuallyExclusive(result);
-    if (!options.unique) {
+    if (!unique) {
       result = result.optional();
     }
     return result;
   }
   makeExistsSchema(model) {
-    return import_zod3.z.strictObject({
+    const baseSchema = import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, false).optional()
-    }).optional();
+    });
+    return this.mergePluginArgsSchema(baseSchema, "exists").optional();
   }
   makeScalarSchema(type, attributes) {
     if (this.schema.typeDefs && type in this.schema.typeDefs) {
@@ -5174,25 +5229,27 @@ var InputValidator = class {
   // #region Create
   makeCreateSchema(model) {
     const dataSchema = this.makeCreateDataSchema(model, false);
-    let schema = import_zod3.z.strictObject({
+    const baseSchema = import_zod3.z.strictObject({
       data: dataSchema,
       select: this.makeSelectSchema(model).optional().nullable(),
       include: this.makeIncludeSchema(model).optional().nullable(),
       omit: this.makeOmitSchema(model).optional().nullable()
     });
+    let schema = this.mergePluginArgsSchema(baseSchema, "create");
     schema = this.refineForSelectIncludeMutuallyExclusive(schema);
     schema = this.refineForSelectOmitMutuallyExclusive(schema);
     return schema;
   }
   makeCreateManySchema(model) {
-    return this.makeCreateManyDataSchema(model, []).optional();
+    return this.mergePluginArgsSchema(this.makeCreateManyDataSchema(model, []), "createMany").optional();
   }
   makeCreateManyAndReturnSchema(model) {
     const base = this.makeCreateManyDataSchema(model, []);
-    const result = base.extend({
+    let result = base.extend({
       select: this.makeSelectSchema(model).optional().nullable(),
       omit: this.makeOmitSchema(model).optional().nullable()
     });
+    result = this.mergePluginArgsSchema(result, "createManyAndReturn");
     return this.refineForSelectOmitMutuallyExclusive(result).optional();
   }
   makeCreateDataSchema(model, canBeArray, withoutFields = [], withoutRelationFields = false) {
@@ -5385,27 +5442,28 @@ var InputValidator = class {
   // #endregion
   // #region Update
   makeUpdateSchema(model) {
-    let schema = import_zod3.z.strictObject({
+    const baseSchema = import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, true),
       data: this.makeUpdateDataSchema(model),
       select: this.makeSelectSchema(model).optional().nullable(),
       include: this.makeIncludeSchema(model).optional().nullable(),
       omit: this.makeOmitSchema(model).optional().nullable()
     });
+    let schema = this.mergePluginArgsSchema(baseSchema, "update");
     schema = this.refineForSelectIncludeMutuallyExclusive(schema);
     schema = this.refineForSelectOmitMutuallyExclusive(schema);
     return schema;
   }
   makeUpdateManySchema(model) {
-    return import_zod3.z.strictObject({
+    return this.mergePluginArgsSchema(import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
       limit: import_zod3.z.number().int().nonnegative().optional()
-    });
+    }), "updateMany");
   }
   makeUpdateManyAndReturnSchema(model) {
-    const base = this.makeUpdateManySchema(model);
-    let schema = base.extend({
+    const baseSchema = this.makeUpdateManySchema(model);
+    let schema = baseSchema.extend({
       select: this.makeSelectSchema(model).optional().nullable(),
       omit: this.makeOmitSchema(model).optional().nullable()
     });
@@ -5413,7 +5471,7 @@ var InputValidator = class {
     return schema;
   }
   makeUpsertSchema(model) {
-    let schema = import_zod3.z.strictObject({
+    const baseSchema = import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, true),
       create: this.makeCreateDataSchema(model, false),
       update: this.makeUpdateDataSchema(model),
@@ -5421,6 +5479,7 @@ var InputValidator = class {
       include: this.makeIncludeSchema(model).optional().nullable(),
       omit: this.makeOmitSchema(model).optional().nullable()
     });
+    let schema = this.mergePluginArgsSchema(baseSchema, "upsert");
     schema = this.refineForSelectIncludeMutuallyExclusive(schema);
     schema = this.refineForSelectOmitMutuallyExclusive(schema);
     return schema;
@@ -5514,32 +5573,33 @@ var InputValidator = class {
   // #endregion
   // #region Delete
   makeDeleteSchema(model) {
-    let schema = import_zod3.z.strictObject({
+    const baseSchema = import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, true),
       select: this.makeSelectSchema(model).optional().nullable(),
       include: this.makeIncludeSchema(model).optional().nullable(),
       omit: this.makeOmitSchema(model).optional().nullable()
     });
+    let schema = this.mergePluginArgsSchema(baseSchema, "delete");
     schema = this.refineForSelectIncludeMutuallyExclusive(schema);
     schema = this.refineForSelectOmitMutuallyExclusive(schema);
     return schema;
   }
   makeDeleteManySchema(model) {
-    return import_zod3.z.object({
+    return this.mergePluginArgsSchema(import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       limit: import_zod3.z.number().int().nonnegative().optional()
-    }).optional();
+    }), "deleteMany").optional();
   }
   // #endregion
   // #region Count
   makeCountSchema(model) {
-    return import_zod3.z.object({
+    return this.mergePluginArgsSchema(import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, true, false), true).optional(),
       select: this.makeCountAggregateInputSchema(model).optional()
-    }).optional();
+    }), "count").optional();
   }
   makeCountAggregateInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -5557,7 +5617,7 @@ var InputValidator = class {
   // #endregion
   // #region Aggregate
   makeAggregateSchema(model) {
-    return import_zod3.z.object({
+    return this.mergePluginArgsSchema(import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       skip: this.makeSkipSchema().optional(),
       take: this.makeTakeSchema().optional(),
@@ -5567,7 +5627,7 @@ var InputValidator = class {
       _sum: this.makeSumAvgInputSchema(model).optional(),
       _min: this.makeMinMaxInputSchema(model).optional(),
       _max: this.makeMinMaxInputSchema(model).optional()
-    }).optional();
+    }), "aggregate").optional();
   }
   makeSumAvgInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -5593,7 +5653,7 @@ var InputValidator = class {
     const modelDef = requireModel(this.schema, model);
     const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
     const bySchema = nonRelationFields.length > 0 ? this.orArray(import_zod3.z.enum(nonRelationFields), true) : import_zod3.z.never();
-    let schema = import_zod3.z.strictObject({
+    const baseSchema = import_zod3.z.strictObject({
       where: this.makeWhereSchema(model, false).optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
       by: bySchema,
@@ -5606,6 +5666,7 @@ var InputValidator = class {
       _min: this.makeMinMaxInputSchema(model).optional(),
       _max: this.makeMinMaxInputSchema(model).optional()
     });
+    let schema = this.mergePluginArgsSchema(baseSchema, "groupBy");
     schema = schema.refine((value) => {
       const bys = typeof value.by === "string" ? [
         value.by
@@ -7296,6 +7357,7 @@ var ClientImpl = class _ClientImpl {
   $schema;
   kyselyProps;
   auth;
+  inputValidator;
   constructor(schema, options, baseClient, executor) {
     this.schema = schema;
     this.options = options;
@@ -7332,6 +7394,7 @@ var ClientImpl = class _ClientImpl {
       });
     }
     this.kysely = new import_kysely10.Kysely(this.kyselyProps);
+    this.inputValidator = baseClient?.inputValidator ?? new InputValidator(this);
     return createClientProxy(this);
   }
   get $qb() {
@@ -7416,8 +7479,7 @@ var ClientImpl = class _ClientImpl {
     if (!procOptions[name] || typeof procOptions[name] !== "function") {
       throw createConfigError(`Procedure "${name}" does not have a handler configured.`);
     }
-    const inputValidator = new InputValidator(this);
-    const validatedInput = inputValidator.validateProcedureInput(name, input);
+    const validatedInput = this.inputValidator.validateProcedureInput(name, input);
     const handler = procOptions[name];
     const invokeWithClient = /* @__PURE__ */ __name(async (client, _input) => {
       let proceed = /* @__PURE__ */ __name(async (nextInput) => {
@@ -7467,7 +7529,9 @@ var ClientImpl = class _ClientImpl {
       ...this.options,
       plugins: newPlugins
     };
-    return new _ClientImpl(this.schema, newOptions, this);
+    const newClient = new _ClientImpl(this.schema, newOptions, this);
+    newClient.inputValidator = new InputValidator(newClient);
+    return newClient;
   }
   $unuse(pluginId) {
     const newPlugins = [];
@@ -7480,14 +7544,18 @@ var ClientImpl = class _ClientImpl {
       ...this.options,
       plugins: newPlugins
     };
-    return new _ClientImpl(this.schema, newOptions, this);
+    const newClient = new _ClientImpl(this.schema, newOptions, this);
+    newClient.inputValidator = new InputValidator(newClient);
+    return newClient;
   }
   $unuseAll() {
     const newOptions = {
       ...this.options,
       plugins: []
     };
-    return new _ClientImpl(this.schema, newOptions, this);
+    const newClient = new _ClientImpl(this.schema, newOptions, this);
+    newClient.inputValidator = new InputValidator(newClient);
+    return newClient;
   }
   $setAuth(auth) {
     if (auth !== void 0 && typeof auth !== "object") {
@@ -7501,14 +7569,16 @@ var ClientImpl = class _ClientImpl {
     return this.auth;
   }
   $setOptions(options) {
-    return new _ClientImpl(this.schema, options, this);
+    const newClient = new _ClientImpl(this.schema, options, this);
+    newClient.inputValidator = new InputValidator(newClient);
+    return newClient;
   }
   $setInputValidation(enable) {
     const newOptions = {
       ...this.options,
       validateInput: enable
     };
-    return new _ClientImpl(this.schema, newOptions, this);
+    return this.$setOptions(newOptions);
   }
   $executeRaw(query, ...values) {
     return createZenStackPromise(async () => {
@@ -7545,7 +7615,6 @@ var ClientImpl = class _ClientImpl {
   }
 };
 function createClientProxy(client) {
-  const inputValidator = new InputValidator(client);
   const resultProcessor = new ResultProcessor(client.$schema, client.$options);
   return new Proxy(client, {
     get: /* @__PURE__ */ __name((target, prop, receiver) => {
@@ -7555,7 +7624,7 @@ function createClientProxy(client) {
       if (typeof prop === "string") {
         const model = Object.keys(client.$schema.models).find((m) => m.toLowerCase() === prop.toLowerCase());
         if (model) {
-          return createModelCrudHandler(client, model, inputValidator, resultProcessor);
+          return createModelCrudHandler(client, model, client.inputValidator, resultProcessor);
         }
       }
       return Reflect.get(target, prop, receiver);
@@ -7587,15 +7656,18 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
         const onQuery = plugin.onQuery;
         if (onQuery) {
           const _proceed = proceed;
-          proceed = /* @__PURE__ */ __name((_args) => onQuery({
-            client,
-            model,
-            operation: nominalOperation,
-            // reflect the latest override if provided
-            args: _args,
-            // ensure inner overrides are propagated to the previous proceed
-            proceed: /* @__PURE__ */ __name((nextArgs) => _proceed(nextArgs), "proceed")
-          }), "proceed");
+          proceed = /* @__PURE__ */ __name((_args) => {
+            const ctx = {
+              client,
+              model,
+              operation: nominalOperation,
+              // reflect the latest override if provided
+              args: _args,
+              // ensure inner overrides are propagated to the previous proceed
+              proceed: /* @__PURE__ */ __name((nextArgs) => _proceed(nextArgs), "proceed")
+            };
+            return onQuery(ctx);
+          }, "proceed");
         }
       }
       return proceed(args);
@@ -7615,7 +7687,7 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
       return createPromise("findFirst", "findFirstOrThrow", args, new FindOperationHandler(client, model, inputValidator), true, true);
     }, "findFirstOrThrow"),
     findMany: /* @__PURE__ */ __name((args) => {
-      return createPromise("findMany", "findMany", args, new FindOperationHandler(client, model, inputValidator), true);
+      return createPromise("findMany", "findMany", args, new FindOperationHandler(client, model, inputValidator), true, false);
     }, "findMany"),
     create: /* @__PURE__ */ __name((args) => {
       return createPromise("create", "create", args, new CreateOperationHandler(client, model, inputValidator), true);
@@ -8080,11 +8152,16 @@ var MatchingExpressionVisitor = class extends ExpressionVisitor {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AllCrudOperations,
+  AllReadOperations,
   AnyNull,
   AnyNullClass,
   BaseCrudDialect,
   CRUD,
   CRUD_EXT,
+  CoreCrudOperations,
+  CoreReadOperations,
+  CoreWriteOperations,
   DbNull,
   DbNullClass,
   InputValidator,