@zenstackhq/orm 3.4.0-beta.1 → 3.4.0-beta.3

package/dist/index.cjs

@@ -644,13 +644,50 @@ var LOGICAL_COMBINATORS = [
   "OR",
   "NOT"
 ];
-var AGGREGATE_OPERATORS = [
+var AggregateOperators = [
   "_count",
   "_sum",
   "_avg",
   "_min",
   "_max"
 ];
+var FILTER_PROPERTY_TO_KIND = {
+  // Equality operators
+  equals: "Equality",
+  not: "Equality",
+  in: "Equality",
+  notIn: "Equality",
+  // Range operators
+  lt: "Range",
+  lte: "Range",
+  gt: "Range",
+  gte: "Range",
+  between: "Range",
+  // Like operators
+  contains: "Like",
+  startsWith: "Like",
+  endsWith: "Like",
+  mode: "Like",
+  // Relation operators
+  is: "Relation",
+  isNot: "Relation",
+  some: "Relation",
+  every: "Relation",
+  none: "Relation",
+  // Json operators
+  path: "Json",
+  string_contains: "Json",
+  string_starts_with: "Json",
+  string_ends_with: "Json",
+  array_contains: "Json",
+  array_starts_with: "Json",
+  array_ends_with: "Json",
+  // List operators
+  has: "List",
+  hasEvery: "List",
+  hasSome: "List",
+  isEmpty: "List"
+};
 
 // src/client/contract.ts
 var TransactionIsolationLevel = /* @__PURE__ */ function(TransactionIsolationLevel2) {
@@ -1213,7 +1250,7 @@ var BaseCrudDialect = class {
           this.eb(lhs, ">=", start),
           this.eb(lhs, "<=", end)
         ]);
-      }).with("not", () => this.eb.not(recurse(value))).with(import_ts_pattern2.P.union(...AGGREGATE_OPERATORS), (op2) => {
+      }).with("not", () => this.eb.not(recurse(value))).with(import_ts_pattern2.P.union(...AggregateOperators), (op2) => {
         const innerResult = this.buildStandardFilter(type, value, aggregate(this.eb, lhs, op2), getRhs, recurse, throwIfInvalid);
         consumedKeys.push(...innerResult.consumedKeys);
         return this.and(...innerResult.conditions);
@@ -5025,6 +5062,9 @@ var InputValidator = class {
   }
   client;
   schemaCache = /* @__PURE__ */ new Map();
+  allFilterKinds = [
+    ...new Set(Object.values(FILTER_PROPERTY_TO_KIND))
+  ];
   constructor(client) {
     this.client = client;
   }
@@ -5296,6 +5336,10 @@ var InputValidator = class {
   }
   makeWhereSchema(model, unique, withoutRelationFields = false, withAggregations = false) {
     const modelDef = requireModel(this.schema, model);
+    const uniqueFieldNames = unique ? getUniqueFields(this.schema, model).filter((uf) => (
+      // single-field unique
+      "def" in uf
+    )).map((uf) => uf.name) : void 0;
     const fields = {};
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
@@ -5304,38 +5348,44 @@ var InputValidator = class {
         if (withoutRelationFields) {
           continue;
         }
-        fieldSchema = import_zod2.z.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
-        fieldSchema = this.nullableIf(fieldSchema, !fieldDef.array && !!fieldDef.optional);
-        if (fieldDef.array) {
-          fieldSchema = import_zod2.z.union([
-            fieldSchema,
-            import_zod2.z.strictObject({
-              some: fieldSchema.optional(),
-              every: fieldSchema.optional(),
-              none: fieldSchema.optional()
-            })
-          ]);
+        const allowedFilterKinds = this.getEffectiveFilterKinds(model, field);
+        if (allowedFilterKinds && !allowedFilterKinds.includes("Relation")) {
+          fieldSchema = import_zod2.z.never();
         } else {
-          fieldSchema = import_zod2.z.union([
-            fieldSchema,
-            import_zod2.z.strictObject({
-              is: fieldSchema.optional(),
-              isNot: fieldSchema.optional()
-            })
-          ]);
+          fieldSchema = import_zod2.z.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
+          fieldSchema = this.nullableIf(fieldSchema, !fieldDef.array && !!fieldDef.optional);
+          if (fieldDef.array) {
+            fieldSchema = import_zod2.z.union([
+              fieldSchema,
+              import_zod2.z.strictObject({
+                some: fieldSchema.optional(),
+                every: fieldSchema.optional(),
+                none: fieldSchema.optional()
+              })
+            ]);
+          } else {
+            fieldSchema = import_zod2.z.union([
+              fieldSchema,
+              import_zod2.z.strictObject({
+                is: fieldSchema.optional(),
+                isNot: fieldSchema.optional()
+              })
+            ]);
+          }
         }
       } else {
+        const ignoreSlicing = !!uniqueFieldNames?.includes(field);
         const enumDef = getEnum(this.schema, fieldDef.type);
         if (enumDef) {
           if (Object.keys(enumDef.values).length > 0) {
-            fieldSchema = this.makeEnumFilterSchema(fieldDef.type, !!fieldDef.optional, withAggregations, !!fieldDef.array);
+            fieldSchema = this.makeEnumFilterSchema(model, fieldDef, withAggregations, ignoreSlicing);
           }
         } else if (fieldDef.array) {
-          fieldSchema = this.makeArrayFilterSchema(fieldDef.type);
+          fieldSchema = this.makeArrayFilterSchema(model, fieldDef);
         } else if (this.isTypeDefType(fieldDef.type)) {
-          fieldSchema = this.makeTypedJsonFilterSchema(fieldDef.type, !!fieldDef.optional, !!fieldDef.array);
+          fieldSchema = this.makeTypedJsonFilterSchema(model, fieldDef);
         } else {
-          fieldSchema = this.makePrimitiveFilterSchema(fieldDef.type, !!fieldDef.optional, withAggregations);
+          fieldSchema = this.makePrimitiveFilterSchema(model, fieldDef, withAggregations, ignoreSlicing);
         }
       }
       if (fieldSchema) {
@@ -5352,12 +5402,12 @@ var InputValidator = class {
             const enumDef = getEnum(this.schema, def.type);
             if (enumDef) {
               if (Object.keys(enumDef.values).length > 0) {
-                fieldSchema = this.makeEnumFilterSchema(def.type, !!def.optional, false, false);
+                fieldSchema = this.makeEnumFilterSchema(model, def, false, true);
               } else {
                 fieldSchema = import_zod2.z.never();
               }
             } else {
-              fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional, false);
+              fieldSchema = this.makePrimitiveFilterSchema(model, def, false, true);
             }
             return [
               key,
@@ -5392,7 +5442,11 @@ var InputValidator = class {
     }
     return result;
   }
-  makeTypedJsonFilterSchema(type, optional, array) {
+  makeTypedJsonFilterSchema(contextModel, fieldInfo) {
+    const field = fieldInfo.name;
+    const type = fieldInfo.type;
+    const optional = !!fieldInfo.optional;
+    const array = !!fieldInfo.array;
     const typeDef = getTypeDef(this.schema, type);
     (0, import_common_helpers9.invariant)(typeDef, `Type definition "${type}" not found in schema`);
     const candidates = [];
@@ -5400,21 +5454,26 @@ var InputValidator = class {
       const fieldSchemas = {};
       for (const [fieldName, fieldDef] of Object.entries(typeDef.fields)) {
         if (this.isTypeDefType(fieldDef.type)) {
-          fieldSchemas[fieldName] = this.makeTypedJsonFilterSchema(fieldDef.type, !!fieldDef.optional, !!fieldDef.array).optional();
+          fieldSchemas[fieldName] = this.makeTypedJsonFilterSchema(contextModel, fieldDef).optional();
         } else {
           const enumDef = getEnum(this.schema, fieldDef.type);
           if (enumDef) {
-            fieldSchemas[fieldName] = this.makeEnumFilterSchema(fieldDef.type, !!fieldDef.optional, false, !!fieldDef.array).optional();
+            fieldSchemas[fieldName] = this.makeEnumFilterSchema(contextModel, fieldDef, false).optional();
           } else if (fieldDef.array) {
-            fieldSchemas[fieldName] = this.makeArrayFilterSchema(fieldDef.type).optional();
+            fieldSchemas[fieldName] = this.makeArrayFilterSchema(contextModel, fieldDef).optional();
           } else {
-            fieldSchemas[fieldName] = this.makePrimitiveFilterSchema(fieldDef.type, !!fieldDef.optional, false).optional();
+            fieldSchemas[fieldName] = this.makePrimitiveFilterSchema(contextModel, fieldDef, false).optional();
           }
         }
       }
       candidates.push(import_zod2.z.strictObject(fieldSchemas));
     }
-    const recursiveSchema = import_zod2.z.lazy(() => this.makeTypedJsonFilterSchema(type, optional, false)).optional();
+    const recursiveSchema = import_zod2.z.lazy(() => this.makeTypedJsonFilterSchema(contextModel, {
+      name: field,
+      type,
+      optional,
+      array: false
+    })).optional();
     if (array) {
       candidates.push(import_zod2.z.strictObject({
         some: recursiveSchema,
@@ -5427,7 +5486,7 @@ var InputValidator = class {
         isNot: recursiveSchema
       }));
     }
-    candidates.push(this.makeJsonFilterSchema(optional));
+    candidates.push(this.makeJsonFilterSchema(contextModel, field, optional));
     if (optional) {
       candidates.push(import_zod2.z.null());
     }
@@ -5436,14 +5495,18 @@ var InputValidator = class {
   isTypeDefType(type) {
     return this.schema.typeDefs && type in this.schema.typeDefs;
   }
-  makeEnumFilterSchema(enumName, optional, withAggregations, array) {
+  makeEnumFilterSchema(model, fieldInfo, withAggregations, ignoreSlicing = false) {
+    const enumName = fieldInfo.type;
+    const optional = !!fieldInfo.optional;
+    const array = !!fieldInfo.array;
     const enumDef = getEnum(this.schema, enumName);
     (0, import_common_helpers9.invariant)(enumDef, `Enum "${enumName}" not found in schema`);
     const baseSchema = import_zod2.z.enum(Object.keys(enumDef.values));
     if (array) {
-      return this.internalMakeArrayFilterSchema(baseSchema);
+      return this.internalMakeArrayFilterSchema(model, fieldInfo.name, baseSchema);
     }
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod2.z.lazy(() => this.makeEnumFilterSchema(enumName, optional, withAggregations, array)), [
+    const allowedFilterKinds = ignoreSlicing ? void 0 : this.getEffectiveFilterKinds(model, fieldInfo.name);
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod2.z.lazy(() => this.makeEnumFilterSchema(model, fieldInfo, withAggregations)), [
       "equals",
       "in",
       "notIn",
@@ -5452,26 +5515,29 @@ var InputValidator = class {
       "_count",
       "_min",
       "_max"
-    ] : void 0);
-    return import_zod2.z.union([
-      this.nullableIf(baseSchema, optional),
-      import_zod2.z.strictObject(components)
-    ]);
+    ] : void 0, allowedFilterKinds);
+    return this.createUnionFilterSchema(baseSchema, optional, components, allowedFilterKinds);
   }
-  makeArrayFilterSchema(type) {
-    return this.internalMakeArrayFilterSchema(this.makeScalarSchema(type));
+  makeArrayFilterSchema(model, fieldInfo) {
+    return this.internalMakeArrayFilterSchema(model, fieldInfo.name, this.makeScalarSchema(fieldInfo.type));
   }
-  internalMakeArrayFilterSchema(elementSchema) {
-    return import_zod2.z.strictObject({
+  internalMakeArrayFilterSchema(contextModel, field, elementSchema) {
+    const allowedFilterKinds = this.getEffectiveFilterKinds(contextModel, field);
+    const operators = {
       equals: elementSchema.array().optional(),
       has: elementSchema.optional(),
       hasEvery: elementSchema.array().optional(),
       hasSome: elementSchema.array().optional(),
       isEmpty: import_zod2.z.boolean().optional()
-    });
+    };
+    const filteredOperators = this.trimFilterOperators(operators, allowedFilterKinds);
+    return import_zod2.z.strictObject(filteredOperators);
   }
-  makePrimitiveFilterSchema(type, optional, withAggregations) {
-    return (0, import_ts_pattern14.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(import_ts_pattern14.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makeScalarSchema(type2), optional, withAggregations)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations)).with("Json", () => this.makeJsonFilterSchema(optional)).with("Unsupported", () => import_zod2.z.never()).exhaustive();
+  makePrimitiveFilterSchema(contextModel, fieldInfo, withAggregations, ignoreSlicing = false) {
+    const allowedFilterKinds = ignoreSlicing ? void 0 : this.getEffectiveFilterKinds(contextModel, fieldInfo.name);
+    const type = fieldInfo.type;
+    const optional = !!fieldInfo.optional;
+    return (0, import_ts_pattern14.match)(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)).with(import_ts_pattern14.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makeScalarSchema(type2), optional, withAggregations, allowedFilterKinds)).with("Boolean", () => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)).with("DateTime", () => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Bytes", () => this.makeBytesFilterSchema(optional, withAggregations, allowedFilterKinds)).with("Json", () => this.makeJsonFilterSchema(contextModel, fieldInfo.name, optional)).with("Unsupported", () => import_zod2.z.never()).exhaustive();
   }
   makeJsonValueSchema(nullable, forFilter) {
     const options = [
@@ -5503,7 +5569,11 @@ var InputValidator = class {
     ]);
     return this.nullableIf(schema, nullable);
   }
-  makeJsonFilterSchema(optional) {
+  makeJsonFilterSchema(contextModel, field, optional) {
+    const allowedFilterKinds = this.getEffectiveFilterKinds(contextModel, field);
+    if (allowedFilterKinds && !allowedFilterKinds.includes("Json")) {
+      return import_zod2.z.never();
+    }
     const valueSchema = this.makeJsonValueSchema(optional, true);
     return import_zod2.z.strictObject({
       path: import_zod2.z.string().optional(),
@@ -5518,31 +5588,28 @@ var InputValidator = class {
       array_ends_with: valueSchema.optional()
     });
   }
-  makeDateTimeFilterSchema(optional, withAggregations) {
+  makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds) {
     return this.makeCommonPrimitiveFilterSchema(import_zod2.z.union([
       import_zod2.z.iso.datetime(),
       import_zod2.z.date()
-    ]), optional, () => import_zod2.z.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
+    ]), optional, () => import_zod2.z.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)), withAggregations ? [
       "_count",
       "_min",
       "_max"
-    ] : void 0);
+    ] : void 0, allowedFilterKinds);
   }
-  makeBooleanFilterSchema(optional, withAggregations) {
-    const components = this.makeCommonPrimitiveFilterComponents(import_zod2.z.boolean(), optional, () => import_zod2.z.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
+  makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds) {
+    const components = this.makeCommonPrimitiveFilterComponents(import_zod2.z.boolean(), optional, () => import_zod2.z.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)), [
       "equals",
       "not"
     ], withAggregations ? [
       "_count",
       "_min",
       "_max"
-    ] : void 0);
-    return import_zod2.z.union([
-      this.nullableIf(import_zod2.z.boolean(), optional),
-      import_zod2.z.strictObject(components)
-    ]);
+    ] : void 0, allowedFilterKinds);
+    return this.createUnionFilterSchema(import_zod2.z.boolean(), optional, components, allowedFilterKinds);
   }
-  makeBytesFilterSchema(optional, withAggregations) {
+  makeBytesFilterSchema(optional, withAggregations, allowedFilterKinds) {
     const baseSchema = import_zod2.z.instanceof(Uint8Array);
     const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod2.z.instanceof(Uint8Array), [
       "equals",
@@ -5553,17 +5620,13 @@ var InputValidator = class {
       "_count",
       "_min",
       "_max"
-    ] : void 0);
-    return import_zod2.z.union([
-      this.nullableIf(baseSchema, optional),
-      import_zod2.z.strictObject(components)
-    ]);
+    ] : void 0, allowedFilterKinds);
+    return this.createUnionFilterSchema(baseSchema, optional, components, allowedFilterKinds);
   }
-  makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, supportedOperators = void 0, withAggregations = void 0) {
-    const commonAggSchema = /* @__PURE__ */ __name(() => this.makeCommonPrimitiveFilterSchema(baseSchema, false, makeThis, void 0).optional(), "commonAggSchema");
+  makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, supportedOperators = void 0, withAggregations = void 0, allowedFilterKinds = void 0) {
+    const commonAggSchema = /* @__PURE__ */ __name(() => this.makeCommonPrimitiveFilterSchema(baseSchema, false, makeThis, void 0, allowedFilterKinds).optional(), "commonAggSchema");
     let result = {
       equals: this.nullableIf(baseSchema.optional(), optional),
-      notEquals: this.nullableIf(baseSchema.optional(), optional),
       in: baseSchema.array().optional(),
       notIn: baseSchema.array().optional(),
       lt: baseSchema.optional(),
@@ -5573,7 +5636,7 @@ var InputValidator = class {
       between: baseSchema.array().length(2).optional(),
       not: makeThis().optional(),
       ...withAggregations?.includes("_count") ? {
-        _count: this.makeNumberFilterSchema(import_zod2.z.number().int(), false, false).optional()
+        _count: this.makeNumberFilterSchema(import_zod2.z.number().int(), false, false, void 0).optional()
       } : {},
       ...withAggregations?.includes("_avg") ? {
         _avg: commonAggSchema()
@@ -5595,40 +5658,42 @@ var InputValidator = class {
       ];
       result = extractFields(result, keys);
     }
+    result = this.trimFilterOperators(result, allowedFilterKinds);
     return result;
   }
-  makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis, withAggregations = void 0) {
-    return import_zod2.z.union([
-      this.nullableIf(baseSchema, optional),
-      import_zod2.z.strictObject(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations))
-    ]);
+  makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis, withAggregations = void 0, allowedFilterKinds = void 0) {
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis, void 0, withAggregations, allowedFilterKinds);
+    return this.createUnionFilterSchema(baseSchema, optional, components, allowedFilterKinds);
   }
-  makeNumberFilterSchema(baseSchema, optional, withAggregations) {
-    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => import_zod2.z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
+  makeNumberFilterSchema(baseSchema, optional, withAggregations, allowedFilterKinds) {
+    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => import_zod2.z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations, allowedFilterKinds)), withAggregations ? [
       "_count",
       "_avg",
       "_sum",
       "_min",
       "_max"
-    ] : void 0);
+    ] : void 0, allowedFilterKinds);
   }
-  makeStringFilterSchema(optional, withAggregations) {
-    return import_zod2.z.union([
-      this.nullableIf(import_zod2.z.string(), optional),
-      import_zod2.z.strictObject({
-        ...this.makeCommonPrimitiveFilterComponents(import_zod2.z.string(), optional, () => import_zod2.z.lazy(() => this.makeStringFilterSchema(optional, withAggregations)), void 0, withAggregations ? [
-          "_count",
-          "_min",
-          "_max"
-        ] : void 0),
-        startsWith: import_zod2.z.string().optional(),
-        endsWith: import_zod2.z.string().optional(),
-        contains: import_zod2.z.string().optional(),
-        ...this.providerSupportsCaseSensitivity ? {
-          mode: this.makeStringModeSchema().optional()
-        } : {}
-      })
-    ]);
+  makeStringFilterSchema(optional, withAggregations, allowedFilterKinds) {
+    const baseComponents = this.makeCommonPrimitiveFilterComponents(import_zod2.z.string(), optional, () => import_zod2.z.lazy(() => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)), void 0, withAggregations ? [
+      "_count",
+      "_min",
+      "_max"
+    ] : void 0, allowedFilterKinds);
+    const stringSpecificOperators = {
+      startsWith: import_zod2.z.string().optional(),
+      endsWith: import_zod2.z.string().optional(),
+      contains: import_zod2.z.string().optional(),
+      ...this.providerSupportsCaseSensitivity ? {
+        mode: this.makeStringModeSchema().optional()
+      } : {}
+    };
+    const filteredStringOperators = this.trimFilterOperators(stringSpecificOperators, allowedFilterKinds);
+    const allComponents = {
+      ...baseComponents,
+      ...filteredStringOperators
+    };
+    return this.createUnionFilterSchema(import_zod2.z.string(), optional, allComponents, allowedFilterKinds);
   }
   makeStringModeSchema() {
     return import_zod2.z.union([
@@ -5642,7 +5707,9 @@ var InputValidator = class {
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
-        fields[field] = this.makeRelationSelectIncludeSchema(model, field).optional();
+        if (this.isModelAllowed(fieldDef.type)) {
+          fields[field] = this.makeRelationSelectIncludeSchema(model, field).optional();
+        }
       } else {
         fields[field] = import_zod2.z.boolean().optional();
       }
@@ -5722,7 +5789,9 @@ var InputValidator = class {
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
-        fields[field] = this.makeRelationSelectIncludeSchema(model, field).optional();
+        if (this.isModelAllowed(fieldDef.type)) {
+          fields[field] = this.makeRelationSelectIncludeSchema(model, field).optional();
+        }
       }
     }
     const _countSchema = this.makeCountSelectionSchema(model);
@@ -5838,6 +5907,9 @@ var InputValidator = class {
         if (withoutRelationFields) {
           return;
         }
+        if (!this.isModelAllowed(fieldDef.type)) {
+          return;
+        }
         const excludeFields = [];
         const oppositeField = fieldDef.relation.opposite;
         if (oppositeField) {
@@ -6065,6 +6137,9 @@ var InputValidator = class {
         if (withoutRelationFields) {
           return;
         }
+        if (!this.isModelAllowed(fieldDef.type)) {
+          return;
+        }
         const excludeFields = [];
         const oppositeField = fieldDef.relation.opposite;
         if (oppositeField) {
@@ -6240,7 +6315,7 @@ var InputValidator = class {
       ] : value.by;
       if (value.having && typeof value.having === "object") {
         for (const [key, val] of Object.entries(value.having)) {
-          if (AGGREGATE_OPERATORS.includes(key)) {
+          if (AggregateOperators.includes(key)) {
             continue;
           }
           if (bys.includes(key)) {
@@ -6260,7 +6335,7 @@ var InputValidator = class {
       const bys = typeof value.by === "string" ? [
         value.by
       ] : value.by;
-      if (value.orderBy && Object.keys(value.orderBy).filter((f) => !AGGREGATE_OPERATORS.includes(f)).some((key) => !bys.includes(key))) {
+      if (value.orderBy && Object.keys(value.orderBy).filter((f) => !AggregateOperators.includes(f)).some((key) => !bys.includes(key))) {
         return false;
       } else {
         return true;
@@ -6270,7 +6345,7 @@ var InputValidator = class {
   }
   onlyAggregationFields(val) {
     for (const [key, value] of Object.entries(val)) {
-      if (AGGREGATE_OPERATORS.includes(key)) {
+      if (AggregateOperators.includes(key)) {
         continue;
       }
       if (LOGICAL_COMBINATORS.includes(key)) {
@@ -6355,6 +6430,108 @@ var InputValidator = class {
   get providerSupportsCaseSensitivity() {
     return this.schema.provider.type === "postgresql";
   }
+  /**
+   * Gets the effective set of allowed FilterKind values for a specific model and field.
+   * Respects the precedence: field-level > model-level $all > global $all.
+   */
+  getEffectiveFilterKinds(model, field) {
+    if (!model) {
+      return void 0;
+    }
+    const slicing = this.options.slicing;
+    if (!slicing?.models) {
+      return void 0;
+    }
+    const modelConfig = slicing.models[model];
+    if (modelConfig?.fields) {
+      const fieldConfig = modelConfig.fields[field];
+      if (fieldConfig) {
+        return this.computeFilterKinds(fieldConfig.includedFilterKinds, fieldConfig.excludedFilterKinds);
+      }
+      const allFieldsConfig = modelConfig.fields.$all;
+      if (allFieldsConfig) {
+        return this.computeFilterKinds(allFieldsConfig.includedFilterKinds, allFieldsConfig.excludedFilterKinds);
+      }
+    }
+    const allModelsConfig = slicing.models.$all;
+    if (allModelsConfig?.fields) {
+      if (allModelsConfig.fields.$all) {
+        return this.computeFilterKinds(allModelsConfig.fields.$all.includedFilterKinds, allModelsConfig.fields.$all.excludedFilterKinds);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Computes the effective set of filter kinds based on inclusion and exclusion lists.
+   */
+  computeFilterKinds(included, excluded) {
+    let result;
+    if (included !== void 0) {
+      result = [
+        ...included
+      ];
+    }
+    if (excluded !== void 0) {
+      if (!result) {
+        result = [
+          ...this.allFilterKinds
+        ];
+      }
+      for (const kind of excluded) {
+        result = result.filter((k) => k !== kind);
+      }
+    }
+    return result;
+  }
+  /**
+   * Filters operators based on allowed filter kinds.
+   */
+  trimFilterOperators(operators, allowedKinds) {
+    if (!allowedKinds) {
+      return operators;
+    }
+    return Object.fromEntries(Object.entries(operators).filter(([key, _]) => {
+      return !(key in FILTER_PROPERTY_TO_KIND) || allowedKinds.includes(FILTER_PROPERTY_TO_KIND[key]);
+    }));
+  }
+  createUnionFilterSchema(valueSchema, optional, components, allowedFilterKinds) {
+    if (Object.keys(components).length === 0) {
+      if (!allowedFilterKinds || allowedFilterKinds.includes("Equality")) {
+        return this.nullableIf(valueSchema, optional);
+      }
+      return import_zod2.z.never();
+    }
+    if (!allowedFilterKinds || allowedFilterKinds.includes("Equality")) {
+      return import_zod2.z.union([
+        this.nullableIf(valueSchema, optional),
+        import_zod2.z.strictObject(components)
+      ]);
+    } else {
+      return import_zod2.z.strictObject(components);
+    }
+  }
+  /**
+   * Checks if a model is included in the slicing configuration.
+   * Returns true if the model is allowed, false if it's excluded.
+   */
+  isModelAllowed(targetModel) {
+    const slicing = this.options.slicing;
+    if (!slicing) {
+      return true;
+    }
+    const { includedModels, excludedModels } = slicing;
+    if (includedModels !== void 0) {
+      if (!includedModels.includes(targetModel)) {
+        return false;
+      }
+    }
+    if (excludedModels !== void 0) {
+      if (excludedModels.includes(targetModel)) {
+        return false;
+      }
+    }
+    return true;
+  }
 };
 _ts_decorate([
   cache(),
@@ -6404,9 +6581,8 @@ _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String,
-    Boolean,
-    Boolean
+    Object,
+    typeof FieldInfo === "undefined" ? Object : FieldInfo
   ]),
   _ts_metadata("design:returntype", void 0)
 ], InputValidator.prototype, "makeTypedJsonFilterSchema", null);
@@ -6414,8 +6590,8 @@ _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String,
-    Boolean,
+    Object,
+    typeof FieldInfo === "undefined" ? Object : FieldInfo,
     Boolean,
     Boolean
   ]),
@@ -6425,7 +6601,8 @@ _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof BuiltinType === "undefined" ? Object : BuiltinType
+    Object,
+    typeof FieldInfo === "undefined" ? Object : FieldInfo
   ]),
   _ts_metadata("design:returntype", void 0)
 ], InputValidator.prototype, "makeArrayFilterSchema", null);
@@ -6433,9 +6610,10 @@ _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof BuiltinType === "undefined" ? Object : BuiltinType,
+    Object,
+    typeof FieldInfo === "undefined" ? Object : FieldInfo,
     Boolean,
-    Boolean
+    void 0
   ]),
   _ts_metadata("design:returntype", void 0)
 ], InputValidator.prototype, "makePrimitiveFilterSchema", null);
@@ -6443,6 +6621,8 @@ _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
+    Object,
+    String,
     Boolean
   ]),
   _ts_metadata("design:returntype", void 0)
@@ -6452,7 +6632,8 @@ _ts_decorate([
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     Boolean,
-    Boolean
+    Boolean,
+    Object
   ]),
   _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
 ], InputValidator.prototype, "makeDateTimeFilterSchema", null);
@@ -6461,7 +6642,8 @@ _ts_decorate([
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     Boolean,
-    Boolean
+    Boolean,
+    Object
   ]),
   _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
 ], InputValidator.prototype, "makeBooleanFilterSchema", null);
@@ -6470,7 +6652,8 @@ _ts_decorate([
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     Boolean,
-    Boolean
+    Boolean,
+    Object
   ]),
   _ts_metadata("design:returntype", typeof import_zod2.ZodType === "undefined" ? Object : import_zod2.ZodType)
 ], InputValidator.prototype, "makeBytesFilterSchema", null);
@@ -8744,6 +8927,9 @@ var ClientImpl = class _ClientImpl {
   }
   get $procs() {
     return Object.keys(this.$schema.procedures ?? {}).reduce((acc, name) => {
+      if (!isProcedureIncluded(this.$options, name)) {
+        return acc;
+      }
       acc[name] = (input) => this.handleProc(name, input);
       return acc;
     }, {});
@@ -8913,6 +9099,9 @@ function createClientProxy(client) {
       if (typeof prop === "string") {
         const model = Object.keys(client.$schema.models).find((m) => m.toLowerCase() === prop.toLowerCase());
         if (model) {
+          if (!isModelIncluded(client.$options, model)) {
+            return void 0;
+          }
           return createModelCrudHandler(client, model, client.inputValidator, resultProcessor);
         }
       }
@@ -8921,6 +9110,44 @@ function createClientProxy(client) {
   });
 }
 __name(createClientProxy, "createClientProxy");
+function isModelIncluded(options, model) {
+  const slicing = options.slicing;
+  if (!slicing) {
+    return true;
+  }
+  const { includedModels, excludedModels } = slicing;
+  if (includedModels !== void 0) {
+    if (!includedModels.includes(model)) {
+      return false;
+    }
+  }
+  if (excludedModels && excludedModels.length > 0) {
+    if (excludedModels.includes(model)) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(isModelIncluded, "isModelIncluded");
+function isProcedureIncluded(options, procedureName) {
+  const slicing = options.slicing;
+  if (!slicing) {
+    return true;
+  }
+  const { includedProcedures, excludedProcedures } = slicing;
+  if (includedProcedures !== void 0) {
+    if (!includedProcedures.includes(procedureName)) {
+      return false;
+    }
+  }
+  if (excludedProcedures && excludedProcedures.length > 0) {
+    if (excludedProcedures.includes(procedureName)) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(isProcedureIncluded, "isProcedureIncluded");
 function createModelCrudHandler(client, model, inputValidator, resultProcessor) {
   const createPromise = /* @__PURE__ */ __name((operation, nominalOperation, args, handler, postProcess = false, throwIfNoResult = false) => {
     return createZenStackPromise(async (txClient) => {
@@ -8962,7 +9189,7 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
       return proceed(args);
     });
   }, "createPromise");
-  return {
+  const operations = {
     findUnique: /* @__PURE__ */ __name((args) => {
       return createPromise("findUnique", "findUnique", args, new FindOperationHandler(client, model, inputValidator), true);
     }, "findUnique"),
@@ -9024,6 +9251,26 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
       return createPromise("exists", "exists", args, new ExistsOperationHandler(client, model, inputValidator), false);
     }, "exists")
   };
+  const slicing = client.$options.slicing;
+  if (slicing?.models) {
+    const modelSlicing = slicing.models[model];
+    const allSlicing = slicing.models.$all;
+    const includedOperations = modelSlicing?.includedOperations ?? allSlicing?.includedOperations;
+    const excludedOperations = modelSlicing?.excludedOperations ?? allSlicing?.excludedOperations;
+    if (includedOperations !== void 0) {
+      for (const key of Object.keys(operations)) {
+        if (!includedOperations.includes(key)) {
+          delete operations[key];
+        }
+      }
+    }
+    if (excludedOperations && excludedOperations.length > 0) {
+      for (const operation of excludedOperations) {
+        delete operations[operation];
+      }
+    }
+  }
+  return operations;
 }
 __name(createModelCrudHandler, "createModelCrudHandler");