@zenstackhq/orm 3.4.0-beta.2 → 3.4.0-beta.4

package/dist/index.cjs

@@ -5062,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;
   }
@@ -5346,7 +5349,7 @@ var InputValidator = class {
           continue;
         }
         const allowedFilterKinds = this.getEffectiveFilterKinds(model, field);
-        if (allowedFilterKinds && !allowedFilterKinds.has("Relation")) {
+        if (allowedFilterKinds && !allowedFilterKinds.includes("Relation")) {
           fieldSchema = import_zod2.z.never();
         } else {
           fieldSchema = import_zod2.z.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
@@ -5568,7 +5571,7 @@ var InputValidator = class {
   }
   makeJsonFilterSchema(contextModel, field, optional) {
     const allowedFilterKinds = this.getEffectiveFilterKinds(contextModel, field);
-    if (allowedFilterKinds && !allowedFilterKinds.has("Json")) {
+    if (allowedFilterKinds && !allowedFilterKinds.includes("Json")) {
       return import_zod2.z.never();
     }
     const valueSchema = this.makeJsonValueSchema(optional, true);
@@ -6429,7 +6432,7 @@ var InputValidator = class {
   }
   /**
    * Gets the effective set of allowed FilterKind values for a specific model and field.
-   * Respects the precedence: field-level > model-level $all > global $all.
+   * Respects the precedence: model[field] > model.$all > $all[field] > $all.$all.
    */
   getEffectiveFilterKinds(model, field) {
     if (!model) {
@@ -6439,21 +6442,27 @@ var InputValidator = class {
     if (!slicing?.models) {
       return void 0;
     }
-    const modelConfig = slicing.models[model];
+    const modelsRecord = slicing.models;
+    const modelConfig = modelsRecord[(0, import_common_helpers9.lowerCaseFirst)(model)];
     if (modelConfig?.fields) {
       const fieldConfig = modelConfig.fields[field];
       if (fieldConfig) {
         return this.computeFilterKinds(fieldConfig.includedFilterKinds, fieldConfig.excludedFilterKinds);
       }
-      const allFieldsConfig = modelConfig.fields.$all;
+      const allFieldsConfig = modelConfig.fields["$all"];
       if (allFieldsConfig) {
         return this.computeFilterKinds(allFieldsConfig.includedFilterKinds, allFieldsConfig.excludedFilterKinds);
       }
     }
-    const allModelsConfig = slicing.models.$all;
+    const allModelsConfig = modelsRecord["$all"];
     if (allModelsConfig?.fields) {
-      if (allModelsConfig.fields.$all) {
-        return this.computeFilterKinds(allModelsConfig.fields.$all.includedFilterKinds, allModelsConfig.fields.$all.excludedFilterKinds);
+      const allModelsFieldConfig = allModelsConfig.fields[field];
+      if (allModelsFieldConfig) {
+        return this.computeFilterKinds(allModelsFieldConfig.includedFilterKinds, allModelsFieldConfig.excludedFilterKinds);
+      }
+      const allModelsAllFieldsConfig = allModelsConfig.fields["$all"];
+      if (allModelsAllFieldsConfig) {
+        return this.computeFilterKinds(allModelsAllFieldsConfig.includedFilterKinds, allModelsAllFieldsConfig.excludedFilterKinds);
       }
     }
     return void 0;
@@ -6464,21 +6473,18 @@ var InputValidator = class {
   computeFilterKinds(included, excluded) {
     let result;
     if (included !== void 0) {
-      result = new Set(included);
+      result = [
+        ...included
+      ];
     }
     if (excluded !== void 0) {
       if (!result) {
-        result = /* @__PURE__ */ new Set([
-          "Equality",
-          "Range",
-          "Like",
-          "Json",
-          "List",
-          "Relation"
-        ]);
+        result = [
+          ...this.allFilterKinds
+        ];
       }
       for (const kind of excluded) {
-        result.delete(kind);
+        result = result.filter((k) => k !== kind);
       }
     }
     return result;
@@ -6491,17 +6497,17 @@ var InputValidator = class {
       return operators;
     }
     return Object.fromEntries(Object.entries(operators).filter(([key, _]) => {
-      return !(key in FILTER_PROPERTY_TO_KIND) || allowedKinds.has(FILTER_PROPERTY_TO_KIND[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.has("Equality")) {
+      if (!allowedFilterKinds || allowedFilterKinds.includes("Equality")) {
         return this.nullableIf(valueSchema, optional);
       }
       return import_zod2.z.never();
     }
-    if (!allowedFilterKinds || allowedFilterKinds.has("Equality")) {
+    if (!allowedFilterKinds || allowedFilterKinds.includes("Equality")) {
       return import_zod2.z.union([
         this.nullableIf(valueSchema, optional),
         import_zod2.z.strictObject(components)
@@ -9253,7 +9259,7 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
   };
   const slicing = client.$options.slicing;
   if (slicing?.models) {
-    const modelSlicing = slicing.models[model];
+    const modelSlicing = slicing.models[(0, import_common_helpers14.lowerCaseFirst)(model)];
     const allSlicing = slicing.models.$all;
     const includedOperations = modelSlicing?.includedOperations ?? allSlicing?.includedOperations;
     const excludedOperations = modelSlicing?.excludedOperations ?? allSlicing?.excludedOperations;