@zenstackhq/orm 3.3.3 → 3.4.0-beta.2

package/dist/index.js

@@ -599,13 +599,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) {
@@ -1168,7 +1205,7 @@ var BaseCrudDialect = class {
           this.eb(lhs, ">=", start),
           this.eb(lhs, "<=", end)
         ]);
-      }).with("not", () => this.eb.not(recurse(value))).with(P.union(...AGGREGATE_OPERATORS), (op2) => {
+      }).with("not", () => this.eb.not(recurse(value))).with(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);
@@ -5251,6 +5288,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);
@@ -5259,38 +5300,44 @@ var InputValidator = class {
         if (withoutRelationFields) {
           continue;
         }
-        fieldSchema = z2.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
-        fieldSchema = this.nullableIf(fieldSchema, !fieldDef.array && !!fieldDef.optional);
-        if (fieldDef.array) {
-          fieldSchema = z2.union([
-            fieldSchema,
-            z2.strictObject({
-              some: fieldSchema.optional(),
-              every: fieldSchema.optional(),
-              none: fieldSchema.optional()
-            })
-          ]);
+        const allowedFilterKinds = this.getEffectiveFilterKinds(model, field);
+        if (allowedFilterKinds && !allowedFilterKinds.has("Relation")) {
+          fieldSchema = z2.never();
         } else {
-          fieldSchema = z2.union([
-            fieldSchema,
-            z2.strictObject({
-              is: fieldSchema.optional(),
-              isNot: fieldSchema.optional()
-            })
-          ]);
+          fieldSchema = z2.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
+          fieldSchema = this.nullableIf(fieldSchema, !fieldDef.array && !!fieldDef.optional);
+          if (fieldDef.array) {
+            fieldSchema = z2.union([
+              fieldSchema,
+              z2.strictObject({
+                some: fieldSchema.optional(),
+                every: fieldSchema.optional(),
+                none: fieldSchema.optional()
+              })
+            ]);
+          } else {
+            fieldSchema = z2.union([
+              fieldSchema,
+              z2.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) {
@@ -5307,12 +5354,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 = z2.never();
               }
             } else {
-              fieldSchema = this.makePrimitiveFilterSchema(def.type, !!def.optional, false);
+              fieldSchema = this.makePrimitiveFilterSchema(model, def, false, true);
             }
             return [
               key,
@@ -5347,7 +5394,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);
     invariant9(typeDef, `Type definition "${type}" not found in schema`);
     const candidates = [];
@@ -5355,21 +5406,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(z2.strictObject(fieldSchemas));
     }
-    const recursiveSchema = z2.lazy(() => this.makeTypedJsonFilterSchema(type, optional, false)).optional();
+    const recursiveSchema = z2.lazy(() => this.makeTypedJsonFilterSchema(contextModel, {
+      name: field,
+      type,
+      optional,
+      array: false
+    })).optional();
     if (array) {
       candidates.push(z2.strictObject({
         some: recursiveSchema,
@@ -5382,7 +5438,7 @@ var InputValidator = class {
         isNot: recursiveSchema
       }));
     }
-    candidates.push(this.makeJsonFilterSchema(optional));
+    candidates.push(this.makeJsonFilterSchema(contextModel, field, optional));
     if (optional) {
       candidates.push(z2.null());
     }
@@ -5391,14 +5447,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);
     invariant9(enumDef, `Enum "${enumName}" not found in schema`);
     const baseSchema = z2.enum(Object.keys(enumDef.values));
     if (array) {
-      return this.internalMakeArrayFilterSchema(baseSchema);
+      return this.internalMakeArrayFilterSchema(model, fieldInfo.name, baseSchema);
     }
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z2.lazy(() => this.makeEnumFilterSchema(enumName, optional, withAggregations, array)), [
+    const allowedFilterKinds = ignoreSlicing ? void 0 : this.getEffectiveFilterKinds(model, fieldInfo.name);
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z2.lazy(() => this.makeEnumFilterSchema(model, fieldInfo, withAggregations)), [
       "equals",
       "in",
       "notIn",
@@ -5407,26 +5467,29 @@ var InputValidator = class {
       "_count",
       "_min",
       "_max"
-    ] : void 0);
-    return z2.union([
-      this.nullableIf(baseSchema, optional),
-      z2.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 z2.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: z2.boolean().optional()
-    });
+    };
+    const filteredOperators = this.trimFilterOperators(operators, allowedFilterKinds);
+    return z2.strictObject(filteredOperators);
   }
-  makePrimitiveFilterSchema(type, optional, withAggregations) {
-    return match14(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations)).with(P3.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", () => z2.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 match14(type).with("String", () => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)).with(P3.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", () => z2.never()).exhaustive();
   }
   makeJsonValueSchema(nullable, forFilter) {
     const options = [
@@ -5458,7 +5521,11 @@ var InputValidator = class {
     ]);
     return this.nullableIf(schema, nullable);
   }
-  makeJsonFilterSchema(optional) {
+  makeJsonFilterSchema(contextModel, field, optional) {
+    const allowedFilterKinds = this.getEffectiveFilterKinds(contextModel, field);
+    if (allowedFilterKinds && !allowedFilterKinds.has("Json")) {
+      return z2.never();
+    }
     const valueSchema = this.makeJsonValueSchema(optional, true);
     return z2.strictObject({
       path: z2.string().optional(),
@@ -5473,31 +5540,28 @@ var InputValidator = class {
       array_ends_with: valueSchema.optional()
     });
   }
-  makeDateTimeFilterSchema(optional, withAggregations) {
+  makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds) {
     return this.makeCommonPrimitiveFilterSchema(z2.union([
       z2.iso.datetime(),
       z2.date()
-    ]), optional, () => z2.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations)), withAggregations ? [
+    ]), optional, () => z2.lazy(() => this.makeDateTimeFilterSchema(optional, withAggregations, allowedFilterKinds)), withAggregations ? [
       "_count",
       "_min",
       "_max"
-    ] : void 0);
+    ] : void 0, allowedFilterKinds);
   }
-  makeBooleanFilterSchema(optional, withAggregations) {
-    const components = this.makeCommonPrimitiveFilterComponents(z2.boolean(), optional, () => z2.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations)), [
+  makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds) {
+    const components = this.makeCommonPrimitiveFilterComponents(z2.boolean(), optional, () => z2.lazy(() => this.makeBooleanFilterSchema(optional, withAggregations, allowedFilterKinds)), [
       "equals",
       "not"
     ], withAggregations ? [
       "_count",
       "_min",
       "_max"
-    ] : void 0);
-    return z2.union([
-      this.nullableIf(z2.boolean(), optional),
-      z2.strictObject(components)
-    ]);
+    ] : void 0, allowedFilterKinds);
+    return this.createUnionFilterSchema(z2.boolean(), optional, components, allowedFilterKinds);
   }
-  makeBytesFilterSchema(optional, withAggregations) {
+  makeBytesFilterSchema(optional, withAggregations, allowedFilterKinds) {
     const baseSchema = z2.instanceof(Uint8Array);
     const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => z2.instanceof(Uint8Array), [
       "equals",
@@ -5508,17 +5572,13 @@ var InputValidator = class {
       "_count",
       "_min",
       "_max"
-    ] : void 0);
-    return z2.union([
-      this.nullableIf(baseSchema, optional),
-      z2.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(),
@@ -5528,7 +5588,7 @@ var InputValidator = class {
       between: baseSchema.array().length(2).optional(),
       not: makeThis().optional(),
       ...withAggregations?.includes("_count") ? {
-        _count: this.makeNumberFilterSchema(z2.number().int(), false, false).optional()
+        _count: this.makeNumberFilterSchema(z2.number().int(), false, false, void 0).optional()
       } : {},
       ...withAggregations?.includes("_avg") ? {
         _avg: commonAggSchema()
@@ -5550,40 +5610,42 @@ var InputValidator = class {
       ];
       result = extractFields(result, keys);
     }
+    result = this.trimFilterOperators(result, allowedFilterKinds);
     return result;
   }
-  makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis, withAggregations = void 0) {
-    return z2.union([
-      this.nullableIf(baseSchema, optional),
-      z2.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, () => z2.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations)), withAggregations ? [
+  makeNumberFilterSchema(baseSchema, optional, withAggregations, allowedFilterKinds) {
+    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => z2.lazy(() => this.makeNumberFilterSchema(baseSchema, optional, withAggregations, allowedFilterKinds)), withAggregations ? [
       "_count",
       "_avg",
       "_sum",
       "_min",
       "_max"
-    ] : void 0);
+    ] : void 0, allowedFilterKinds);
   }
-  makeStringFilterSchema(optional, withAggregations) {
-    return z2.union([
-      this.nullableIf(z2.string(), optional),
-      z2.strictObject({
-        ...this.makeCommonPrimitiveFilterComponents(z2.string(), optional, () => z2.lazy(() => this.makeStringFilterSchema(optional, withAggregations)), void 0, withAggregations ? [
-          "_count",
-          "_min",
-          "_max"
-        ] : void 0),
-        startsWith: z2.string().optional(),
-        endsWith: z2.string().optional(),
-        contains: z2.string().optional(),
-        ...this.providerSupportsCaseSensitivity ? {
-          mode: this.makeStringModeSchema().optional()
-        } : {}
-      })
-    ]);
+  makeStringFilterSchema(optional, withAggregations, allowedFilterKinds) {
+    const baseComponents = this.makeCommonPrimitiveFilterComponents(z2.string(), optional, () => z2.lazy(() => this.makeStringFilterSchema(optional, withAggregations, allowedFilterKinds)), void 0, withAggregations ? [
+      "_count",
+      "_min",
+      "_max"
+    ] : void 0, allowedFilterKinds);
+    const stringSpecificOperators = {
+      startsWith: z2.string().optional(),
+      endsWith: z2.string().optional(),
+      contains: z2.string().optional(),
+      ...this.providerSupportsCaseSensitivity ? {
+        mode: this.makeStringModeSchema().optional()
+      } : {}
+    };
+    const filteredStringOperators = this.trimFilterOperators(stringSpecificOperators, allowedFilterKinds);
+    const allComponents = {
+      ...baseComponents,
+      ...filteredStringOperators
+    };
+    return this.createUnionFilterSchema(z2.string(), optional, allComponents, allowedFilterKinds);
   }
   makeStringModeSchema() {
     return z2.union([
@@ -5597,7 +5659,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] = z2.boolean().optional();
       }
@@ -5677,7 +5741,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);
@@ -5793,6 +5859,9 @@ var InputValidator = class {
         if (withoutRelationFields) {
           return;
         }
+        if (!this.isModelAllowed(fieldDef.type)) {
+          return;
+        }
         const excludeFields = [];
         const oppositeField = fieldDef.relation.opposite;
         if (oppositeField) {
@@ -6020,6 +6089,9 @@ var InputValidator = class {
         if (withoutRelationFields) {
           return;
         }
+        if (!this.isModelAllowed(fieldDef.type)) {
+          return;
+        }
         const excludeFields = [];
         const oppositeField = fieldDef.relation.opposite;
         if (oppositeField) {
@@ -6195,7 +6267,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)) {
@@ -6215,7 +6287,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;
@@ -6225,7 +6297,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)) {
@@ -6310,6 +6382,111 @@ 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 = new Set(included);
+    }
+    if (excluded !== void 0) {
+      if (!result) {
+        result = /* @__PURE__ */ new Set([
+          "Equality",
+          "Range",
+          "Like",
+          "Json",
+          "List",
+          "Relation"
+        ]);
+      }
+      for (const kind of excluded) {
+        result.delete(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.has(FILTER_PROPERTY_TO_KIND[key]);
+    }));
+  }
+  createUnionFilterSchema(valueSchema, optional, components, allowedFilterKinds) {
+    if (Object.keys(components).length === 0) {
+      if (!allowedFilterKinds || allowedFilterKinds.has("Equality")) {
+        return this.nullableIf(valueSchema, optional);
+      }
+      return z2.never();
+    }
+    if (!allowedFilterKinds || allowedFilterKinds.has("Equality")) {
+      return z2.union([
+        this.nullableIf(valueSchema, optional),
+        z2.strictObject(components)
+      ]);
+    } else {
+      return z2.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(),
@@ -6359,9 +6536,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);
@@ -6369,8 +6545,8 @@ _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    String,
-    Boolean,
+    Object,
+    typeof FieldInfo === "undefined" ? Object : FieldInfo,
     Boolean,
     Boolean
   ]),
@@ -6380,7 +6556,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);
@@ -6388,9 +6565,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);
@@ -6398,6 +6576,8 @@ _ts_decorate([
   cache(),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
+    Object,
+    String,
     Boolean
   ]),
   _ts_metadata("design:returntype", void 0)
@@ -6407,7 +6587,8 @@ _ts_decorate([
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     Boolean,
-    Boolean
+    Boolean,
+    Object
   ]),
   _ts_metadata("design:returntype", typeof ZodType === "undefined" ? Object : ZodType)
 ], InputValidator.prototype, "makeDateTimeFilterSchema", null);
@@ -6416,7 +6597,8 @@ _ts_decorate([
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     Boolean,
-    Boolean
+    Boolean,
+    Object
   ]),
   _ts_metadata("design:returntype", typeof ZodType === "undefined" ? Object : ZodType)
 ], InputValidator.prototype, "makeBooleanFilterSchema", null);
@@ -6425,7 +6607,8 @@ _ts_decorate([
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
     Boolean,
-    Boolean
+    Boolean,
+    Object
   ]),
   _ts_metadata("design:returntype", typeof ZodType === "undefined" ? Object : ZodType)
 ], InputValidator.prototype, "makeBytesFilterSchema", null);
@@ -8580,6 +8763,9 @@ var ClientImpl = class _ClientImpl {
       ...functions_exports,
       ...this.$options.functions
     };
+    if (!baseClient) {
+      this.validateComputedFieldsConfig();
+    }
     if (baseClient) {
       this.kyselyProps = {
         ...baseClient.kyselyProps,
@@ -8625,6 +8811,26 @@ var ClientImpl = class _ClientImpl {
   withExecutor(executor) {
     return new _ClientImpl(this.schema, this.$options, this, executor);
   }
+  /**
+   * Validates that all computed fields in the schema have corresponding configurations.
+   */
+  validateComputedFieldsConfig() {
+    const computedFieldsConfig = "computedFields" in this.$options ? this.$options.computedFields : void 0;
+    for (const [modelName, modelDef] of Object.entries(this.$schema.models)) {
+      if (modelDef.computedFields) {
+        for (const fieldName of Object.keys(modelDef.computedFields)) {
+          const modelConfig = computedFieldsConfig?.[modelName];
+          const fieldConfig = modelConfig?.[fieldName];
+          if (fieldConfig === null || fieldConfig === void 0) {
+            throw createConfigError(`Computed field "${fieldName}" in model "${modelName}" does not have a configuration. Please provide an implementation in the computedFields option.`);
+          }
+          if (typeof fieldConfig !== "function") {
+            throw createConfigError(`Computed field "${fieldName}" in model "${modelName}" has an invalid configuration: expected a function but received ${typeof fieldConfig}.`);
+          }
+        }
+      }
+    }
+  }
   // implementation
   async $transaction(input, options) {
     invariant14(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
@@ -8676,6 +8882,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;
     }, {});
@@ -8845,6 +9054,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);
         }
       }
@@ -8853,6 +9065,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) => {
@@ -8894,7 +9144,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"),
@@ -8956,6 +9206,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");