@zenstackhq/orm 3.2.1 → 3.3.0-beta.2

package/dist/index.cjs

@@ -32,11 +32,19 @@ 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,
+  CoreCreateOperations: () => CoreCreateOperations,
+  CoreCrudOperations: () => CoreCrudOperations,
+  CoreDeleteOperations: () => CoreDeleteOperations,
+  CoreReadOperations: () => CoreReadOperations,
+  CoreUpdateOperations: () => CoreUpdateOperations,
+  CoreWriteOperations: () => CoreWriteOperations,
   DbNull: () => DbNull,
   DbNullClass: () => DbNullClass,
   InputValidator: () => InputValidator,
@@ -1159,7 +1167,15 @@ var BaseCrudDialect = class {
         } else {
           return this.eb.not(this.eb(lhs, "in", rhs));
         }
-      }).with("lt", () => this.eb(lhs, "<", rhs)).with("lte", () => this.eb(lhs, "<=", rhs)).with("gt", () => this.eb(lhs, ">", rhs)).with("gte", () => this.eb(lhs, ">=", rhs)).with("not", () => this.eb.not(recurse(value))).with(import_ts_pattern2.P.union(...AGGREGATE_OPERATORS), (op2) => {
+      }).with("lt", () => this.eb(lhs, "<", rhs)).with("lte", () => this.eb(lhs, "<=", rhs)).with("gt", () => this.eb(lhs, ">", rhs)).with("gte", () => this.eb(lhs, ">=", rhs)).with("between", () => {
+        (0, import_common_helpers2.invariant)(Array.isArray(rhs), "right hand side must be an array");
+        (0, import_common_helpers2.invariant)(rhs.length === 2, "right hand side must have a length of 2");
+        const [start, end] = rhs;
+        return this.eb.and([
+          this.eb(lhs, ">=", start),
+          this.eb(lhs, "<=", end)
+        ]);
+      }).with("not", () => this.eb.not(recurse(value))).with(import_ts_pattern2.P.union(...AGGREGATE_OPERATORS), (op2) => {
         const innerResult = this.buildStandardFilter(type, value, aggregate(this.eb, lhs, op2), getRhs, recurse, throwIfInvalid);
         consumedKeys.push(...innerResult.consumedKeys);
         return this.and(...innerResult.conditions);
@@ -2107,6 +2123,70 @@ 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 CoreCreateOperations = [
+  "create",
+  "createMany",
+  "createManyAndReturn",
+  "upsert"
+];
+var CoreUpdateOperations = [
+  "update",
+  "updateMany",
+  "updateManyAndReturn",
+  "upsert"
+];
+var CoreDeleteOperations = [
+  "delete",
+  "deleteMany"
+];
+var AllCrudOperations = [
+  ...CoreCrudOperations,
+  "findUniqueOrThrow",
+  "findFirstOrThrow"
+];
+var AllReadOperations = [
+  ...CoreReadOperations,
+  "findUniqueOrThrow",
+  "findFirstOrThrow"
+];
 var BaseOperationHandler = class {
   static {
     __name(this, "BaseOperationHandler");
@@ -3759,6 +3839,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 +3859,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 +3870,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 +4468,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 +4570,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 +4638,61 @@ var InputValidator = class {
     }
     return data;
   }
+  mergePluginArgsSchema(schema, operation) {
+    let result = schema;
+    for (const plugin of this.options.plugins ?? []) {
+      if (plugin.queryArgs) {
+        const pluginSchema = this.getPluginExtQueryArgsSchema(plugin, operation);
+        if (pluginSchema) {
+          result = result.extend(pluginSchema.shape);
+        }
+      }
+    }
+    return result.strict();
+  }
+  getPluginExtQueryArgsSchema(plugin, operation) {
+    if (!plugin.queryArgs) {
+      return void 0;
+    }
+    let result;
+    if (operation in plugin.queryArgs && plugin.queryArgs[operation]) {
+      result = plugin.queryArgs[operation];
+    } else if (operation === "upsert") {
+      const createSchema = "$create" in plugin.queryArgs && plugin.queryArgs["$create"] ? plugin.queryArgs["$create"] : void 0;
+      const updateSchema = "$update" in plugin.queryArgs && plugin.queryArgs["$update"] ? plugin.queryArgs["$update"] : void 0;
+      if (createSchema && updateSchema) {
+        (0, import_common_helpers7.invariant)(createSchema instanceof import_zod3.z.ZodObject, "Plugin extended query args schema must be a Zod object");
+        (0, import_common_helpers7.invariant)(updateSchema instanceof import_zod3.z.ZodObject, "Plugin extended query args schema must be a Zod object");
+        result = createSchema.extend(updateSchema.shape);
+      } else if (createSchema) {
+        result = createSchema;
+      } else if (updateSchema) {
+        result = updateSchema;
+      }
+    } else if (
+      // then comes grouped operations: $create, $read, $update, $delete
+      CoreCreateOperations.includes(operation) && "$create" in plugin.queryArgs && plugin.queryArgs["$create"]
+    ) {
+      result = plugin.queryArgs["$create"];
+    } else if (CoreReadOperations.includes(operation) && "$read" in plugin.queryArgs && plugin.queryArgs["$read"]) {
+      result = plugin.queryArgs["$read"];
+    } else if (CoreUpdateOperations.includes(operation) && "$update" in plugin.queryArgs && plugin.queryArgs["$update"]) {
+      result = plugin.queryArgs["$update"];
+    } else if (CoreDeleteOperations.includes(operation) && "$delete" in plugin.queryArgs && plugin.queryArgs["$delete"]) {
+      result = plugin.queryArgs["$delete"];
+    } else if ("$all" in plugin.queryArgs && plugin.queryArgs["$all"]) {
+      result = plugin.queryArgs["$all"];
+    }
+    (0, import_common_helpers7.invariant)(result === void 0 || result instanceof import_zod3.z.ZodObject, "Plugin extended query args schema must be a Zod object");
+    return result;
+  }
   // #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 +4700,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 +4711,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) {
@@ -4952,6 +5070,7 @@ var InputValidator = class {
       lte: baseSchema.optional(),
       gt: baseSchema.optional(),
       gte: baseSchema.optional(),
+      between: baseSchema.array().length(2).optional(),
       not: makeThis().optional(),
       ...withAggregations?.includes("_count") ? {
         _count: this.makeNumberFilterSchema(import_zod3.z.number().int(), false, false).optional()
@@ -5174,25 +5293,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 +5506,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 +5535,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 +5543,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 +5637,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 +5681,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 +5691,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 +5717,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 +5730,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 +7421,7 @@ var ClientImpl = class _ClientImpl {
   $schema;
   kyselyProps;
   auth;
+  inputValidator;
   constructor(schema, options, baseClient, executor) {
     this.schema = schema;
     this.options = options;
@@ -7332,6 +7458,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 +7543,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 +7593,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 +7608,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 +7633,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,17 +7679,24 @@ 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) => {
       if (typeof prop === "string" && prop.startsWith("$")) {
+        const plugins = target.$options.plugins ?? [];
+        for (let i = plugins.length - 1; i >= 0; i--) {
+          const plugin = plugins[i];
+          const clientMembers = plugin?.client;
+          if (clientMembers && prop in clientMembers) {
+            return clientMembers[prop];
+          }
+        }
         return Reflect.get(target, prop, receiver);
       }
       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 +7728,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 +7759,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 +8224,19 @@ 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,
+  CoreCreateOperations,
+  CoreCrudOperations,
+  CoreDeleteOperations,
+  CoreReadOperations,
+  CoreUpdateOperations,
+  CoreWriteOperations,
   DbNull,
   DbNullClass,
   InputValidator,