@danielhritcu/zenstack-orm 3.5.4 → 3.5.6

package/dist/index.cjs

@@ -68,7 +68,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/client/client-impl.ts
-var import_common_helpers14 = require("@zenstackhq/common-helpers");
+var import_common_helpers15 = require("@zenstackhq/common-helpers");
 var import_kysely12 = require("kysely");
 var import_zod3 = __toESM(require("zod"), 1);
 
@@ -666,7 +666,7 @@ __name(tmpAlias, "tmpAlias");
 
 // src/client/crud/operations/base.ts
 var import_cuid2 = require("@paralleldrive/cuid2");
-var import_common_helpers7 = require("@zenstackhq/common-helpers");
+var import_common_helpers8 = require("@zenstackhq/common-helpers");
 var import_cuid = __toESM(require("cuid"), 1);
 var import_kysely6 = require("kysely");
 var import_nanoid = require("nanoid");
@@ -2824,6 +2824,224 @@ function getCrudDialect(schema, options) {
 }
 __name(getCrudDialect, "getCrudDialect");
 
+// src/client/plugins/search.ts
+var import_common_helpers7 = require("@zenstackhq/common-helpers");
+function isSearchPayload(value) {
+  return (0, import_common_helpers7.isPlainObject)(value) && typeof value.q === "string" && (value.fields !== void 0 || value.profile !== void 0);
+}
+__name(isSearchPayload, "isSearchPayload");
+function buildStringFilter(mode, token) {
+  if (mode === "equals") return {
+    equals: token,
+    mode: "insensitive"
+  };
+  if (mode === "startsWith") return {
+    startsWith: token,
+    mode: "insensitive"
+  };
+  return {
+    contains: token,
+    mode: "insensitive"
+  };
+}
+__name(buildStringFilter, "buildStringFilter");
+function unique(arr) {
+  return [
+    ...new Set(arr)
+  ];
+}
+__name(unique, "unique");
+function extractSearch(where) {
+  if (Array.isArray(where)) {
+    let found2;
+    const cleaned2 = [];
+    for (const item of where) {
+      const result = extractSearch(item);
+      if (result.search) found2 = result.search;
+      cleaned2.push(result.where);
+    }
+    return {
+      where: cleaned2,
+      search: found2
+    };
+  }
+  if (!(0, import_common_helpers7.isPlainObject)(where)) {
+    return {
+      where
+    };
+  }
+  const obj = where;
+  let found;
+  const cleaned = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === "search" && isSearchPayload(value)) {
+      found = value;
+      continue;
+    }
+    if (key === "AND" || key === "OR") {
+      const result = extractSearch(value);
+      if (result.search) found = result.search;
+      cleaned[key] = result.where;
+    } else if (key === "NOT") {
+      const result = extractSearch(value);
+      if (result.search) found = result.search;
+      cleaned[key] = result.where;
+    } else {
+      cleaned[key] = value;
+    }
+  }
+  return {
+    where: cleaned,
+    search: found
+  };
+}
+__name(extractSearch, "extractSearch");
+function buildTokenFilter(model, fields, token, mode, models, virtualRelations) {
+  const clauses = [];
+  const modelDef = models[model];
+  if (!modelDef) return void 0;
+  for (const [fieldName, fieldSpec] of Object.entries(fields)) {
+    const schemaDef = modelDef.fields[fieldName];
+    if (schemaDef) {
+      if (schemaDef.relation) {
+        const childFields = fieldSpec === true ? void 0 : fieldSpec;
+        if (!childFields) continue;
+        const childFilter = buildTokenFilter(schemaDef.type, childFields, token, mode, models, virtualRelations);
+        if (childFilter) {
+          if (schemaDef.array) {
+            clauses.push({
+              [fieldName]: {
+                some: childFilter
+              }
+            });
+          } else {
+            clauses.push({
+              [fieldName]: childFilter
+            });
+          }
+        }
+      } else if (schemaDef.type === "String") {
+        clauses.push({
+          [fieldName]: buildStringFilter(mode, token)
+        });
+      }
+    } else if (virtualRelations) {
+      const modelVRs = virtualRelations[model];
+      const vr = modelVRs?.[fieldName];
+      if (!vr) continue;
+      const childFields = fieldSpec === true ? void 0 : fieldSpec;
+      if (!childFields) continue;
+      if (vr.kind === "filtered" && vr.relation) {
+        const sourceFieldDef = modelDef.fields[vr.relation];
+        if (!sourceFieldDef) continue;
+        const childFilter = buildTokenFilter(sourceFieldDef.type, childFields, token, mode, models, virtualRelations);
+        if (childFilter) {
+          const mergedChild = vr.where ? {
+            AND: [
+              childFilter,
+              vr.where
+            ]
+          } : childFilter;
+          if (sourceFieldDef.array) {
+            clauses.push({
+              [vr.relation]: {
+                some: mergedChild
+              }
+            });
+          } else {
+            clauses.push({
+              [vr.relation]: mergedChild
+            });
+          }
+        }
+      } else if (vr.kind === "through" && vr.path) {
+        const [sourceField, ...restPath] = vr.path;
+        if (!sourceField) continue;
+        const sourceFieldDef = modelDef.fields[sourceField];
+        if (!sourceFieldDef) continue;
+        let currentModel2 = sourceFieldDef.type;
+        for (const segment of restPath) {
+          const m = models[currentModel2];
+          if (!m) break;
+          const f = m.fields[segment];
+          if (!f) break;
+          currentModel2 = f.type;
+        }
+        const childFilter = buildTokenFilter(currentModel2, childFields, token, mode, models, virtualRelations);
+        if (childFilter) {
+          let wrapped = childFilter;
+          for (let i = restPath.length - 1; i >= 0; i--) {
+            const seg = restPath[i];
+            wrapped = {
+              [seg]: wrapped
+            };
+          }
+          if (sourceFieldDef.array) {
+            clauses.push({
+              [sourceField]: {
+                some: wrapped
+              }
+            });
+          } else {
+            clauses.push({
+              [sourceField]: wrapped
+            });
+          }
+        }
+      }
+    }
+  }
+  if (clauses.length === 0) return void 0;
+  if (clauses.length === 1) return clauses[0];
+  return {
+    OR: clauses
+  };
+}
+__name(buildTokenFilter, "buildTokenFilter");
+function expandSearch(model, where, searchDefaults, schemaModels, virtualRelations) {
+  if (!where || !(0, import_common_helpers7.isPlainObject)(where)) return {
+    where
+  };
+  const { where: remaining, search: search2 } = extractSearch(where);
+  if (!search2) return {
+    where
+  };
+  const profile = search2.profile ? searchDefaults?.[model]?.[search2.profile] : void 0;
+  const fields = search2.fields ?? profile?.fields;
+  if (!fields) return {
+    where: remaining
+  };
+  const mode = search2.mode ?? profile?.mode ?? "contains";
+  const strategy = search2.strategy ?? profile?.strategy ?? "all";
+  const tokens = unique(search2.q.trim().split(/\s+/).map((t) => t.toLowerCase()).filter(Boolean));
+  if (tokens.length === 0) return {
+    where: remaining
+  };
+  const tokenClauses = tokens.map((t) => buildTokenFilter(model, fields, t, mode, schemaModels, virtualRelations)).filter((c) => c !== void 0);
+  if (tokenClauses.length === 0) return {
+    where: remaining
+  };
+  const searchWhere = tokenClauses.length === 1 ? tokenClauses[0] : strategy === "any" ? {
+    OR: tokenClauses
+  } : {
+    AND: tokenClauses
+  };
+  const remainingObj = remaining;
+  const hasRemaining = Object.keys(remainingObj).length > 0;
+  if (!hasRemaining) return {
+    where: searchWhere
+  };
+  return {
+    where: {
+      AND: [
+        remainingObj,
+        searchWhere
+      ]
+    }
+  };
+}
+__name(expandSearch, "expandSearch");
+
 // src/client/crud/operations/base.ts
 var CoreCrudOperations2 = [
   "findMany",
@@ -3182,9 +3400,49 @@ var BaseOperationHandler = class {
     return result;
   }
   // --- End schema plugin defaults ---
+  // --- Search expansion ---
+  applySearchExpansion(model, args) {
+    const searchDefaults = this.schema.plugins?.searchDefaults;
+    if (!searchDefaults) return args;
+    if (!args?.where) return args;
+    const schemaModels = this.schema.models;
+    if (!schemaModels) return args;
+    const virtualRelations = this.schema.plugins?.virtualRelations;
+    const { where } = expandSearch(model, args.where, searchDefaults, schemaModels, virtualRelations);
+    return {
+      ...args,
+      where
+    };
+  }
+  // --- End search expansion ---
+  applyDefaultWhere(model, args) {
+    const defaultOpt = this.client?.$options?.default?.where;
+    if (!defaultOpt) return args;
+    const config = typeof defaultOpt === "function" ? defaultOpt() : defaultOpt;
+    if (!config) return args;
+    const modelWhere = config[model] ?? config.$all;
+    if (!modelWhere || typeof modelWhere !== "object") return args;
+    let result = args ? {
+      ...args
+    } : {};
+    const userWhere = result.where ?? {};
+    const mergedWhere = {
+      ...userWhere
+    };
+    const modelFields = this.schema.models?.[model]?.fields;
+    for (const [key, value] of Object.entries(modelWhere)) {
+      if (key in userWhere) continue;
+      if (modelFields && !(key in modelFields)) continue;
+      mergedWhere[key] = value;
+    }
+    result.where = Object.keys(mergedWhere).length > 0 ? mergedWhere : void 0;
+    return result;
+  }
   async read(kysely, model, args) {
-    const defaultedArgs = this.applySchemaPluginDefaults(model, args);
-    const { args: rewrittenArgs, plan } = this.rewriteVirtualRelations(model, defaultedArgs);
+    const defaultWhereArgs = this.applyDefaultWhere(model, args);
+    const defaultedArgs = this.applySchemaPluginDefaults(model, defaultWhereArgs);
+    const searchExpandedArgs = this.applySearchExpansion(model, defaultedArgs);
+    const { args: rewrittenArgs, plan } = this.rewriteVirtualRelations(model, searchExpandedArgs);
     const query = this.buildReadQuery(model, rewrittenArgs);
     let result = [];
     const compiled = kysely.getExecutor().compileQuery(query.toOperationNode(), (0, import_kysely6.createQueryId)());
@@ -3350,7 +3608,7 @@ var BaseOperationHandler = class {
       }
     });
     const discriminatorField = getDiscriminatorField(this.schema, model);
-    (0, import_common_helpers7.invariant)(discriminatorField, `Base model "${model}" must have a discriminator field`);
+    (0, import_common_helpers8.invariant)(discriminatorField, `Base model "${model}" must have a discriminator field`);
     thisCreateFields[discriminatorField] = forModel;
     const baseEntity = await this.create(kysely, model, thisCreateFields, void 0, true);
     const idValues = extractIdFields(baseEntity, this.schema, model);
@@ -3362,8 +3620,8 @@ var BaseOperationHandler = class {
   }
   async buildFkAssignments(kysely, model, relationField, entity) {
     const parentFkFields = {};
-    (0, import_common_helpers7.invariant)(relationField, "parentField must be defined if parentModel is defined");
-    (0, import_common_helpers7.invariant)(entity, "parentEntity must be defined if parentModel is defined");
+    (0, import_common_helpers8.invariant)(relationField, "parentField must be defined if parentModel is defined");
+    (0, import_common_helpers8.invariant)(entity, "parentEntity must be defined if parentModel is defined");
     const { keyPairs } = getRelationForeignKeyFieldPairs(this.schema, model, relationField);
     for (const pair of keyPairs) {
       if (!(pair.pk in entity)) {
@@ -3392,8 +3650,8 @@ var BaseOperationHandler = class {
     const leftFirst = leftModel !== rightModel ? leftModel.localeCompare(rightModel) <= 0 : leftField.localeCompare(rightField) <= 0;
     const leftIdField = requireIdFields(this.schema, leftModel);
     const rightIdField = requireIdFields(this.schema, rightModel);
-    (0, import_common_helpers7.invariant)(leftIdField.length === 1, "many-to-many relation must have exactly one id field");
-    (0, import_common_helpers7.invariant)(rightIdField.length === 1, "many-to-many relation must have exactly one id field");
+    (0, import_common_helpers8.invariant)(leftIdField.length === 1, "many-to-many relation must have exactly one id field");
+    (0, import_common_helpers8.invariant)(rightIdField.length === 1, "many-to-many relation must have exactly one id field");
     const leftIdValue = leftEntity[leftIdField[0]];
     const rightIdValues = rightEntities.map((e) => e[rightIdField[0]]);
     if (action === "connect") {
@@ -3418,10 +3676,10 @@ var BaseOperationHandler = class {
     }
   }
   resetManyToManyRelation(kysely, model, field, parentIds) {
-    (0, import_common_helpers7.invariant)(Object.keys(parentIds).length === 1, "parentIds must have exactly one field");
+    (0, import_common_helpers8.invariant)(Object.keys(parentIds).length === 1, "parentIds must have exactly one field");
     const parentId = Object.values(parentIds)[0];
     const m2m = getManyToManyRelation(this.schema, model, field);
-    (0, import_common_helpers7.invariant)(m2m, "not a many-to-many relation");
+    (0, import_common_helpers8.invariant)(m2m, "not a many-to-many relation");
     const eb = (0, import_kysely6.expressionBuilder)();
     return kysely.deleteFrom(m2m.joinTable).where(eb(`${m2m.joinTable}.${m2m.parentFkName}`, "=", parentId)).execute();
   }
@@ -3443,7 +3701,7 @@ var BaseOperationHandler = class {
         }
         case "connect": {
           const referencedPkFields = relationField.relation.references;
-          (0, import_common_helpers7.invariant)(referencedPkFields, "relation must have fields info");
+          (0, import_common_helpers8.invariant)(referencedPkFields, "relation must have fields info");
           const extractedFks = extractFields(subPayload, referencedPkFields);
           if (Object.keys(extractedFks).length === referencedPkFields.length) {
             result = extractedFks;
@@ -3490,13 +3748,13 @@ var BaseOperationHandler = class {
       }
       switch (action) {
         case "create": {
-          for (const item of (0, import_common_helpers7.enumerate)(subPayload)) {
+          for (const item of (0, import_common_helpers8.enumerate)(subPayload)) {
             await this.create(kysely, relationModel, item, fromRelationContext);
           }
           break;
         }
         case "createMany": {
-          (0, import_common_helpers7.invariant)(relationFieldDef.array, "relation must be an array for createMany");
+          (0, import_common_helpers8.invariant)(relationFieldDef.array, "relation must be an array for createMany");
           await this.createMany(kysely, relationModel, subPayload, false, fromRelationContext);
           break;
         }
@@ -3505,7 +3763,7 @@ var BaseOperationHandler = class {
           break;
         }
         case "connectOrCreate": {
-          for (const item of (0, import_common_helpers7.enumerate)(subPayload)) {
+          for (const item of (0, import_common_helpers8.enumerate)(subPayload)) {
             const found = await this.exists(kysely, relationModel, item.where);
             if (!found) {
               await this.create(kysely, relationModel, item.create, fromRelationContext);
@@ -3535,11 +3793,11 @@ var BaseOperationHandler = class {
       }
       relationKeyPairs.push(...keyPairs);
     }
-    let createData = (0, import_common_helpers7.enumerate)(input.data).map((item) => {
+    let createData = (0, import_common_helpers8.enumerate)(input.data).map((item) => {
       const newItem = {};
       for (const [name, value] of Object.entries(item)) {
         const fieldDef = this.requireField(model, name);
-        (0, import_common_helpers7.invariant)(!fieldDef.relation, "createMany does not support relations");
+        (0, import_common_helpers8.invariant)(!fieldDef.relation, "createMany does not support relations");
         newItem[name] = this.dialect.transformInput(value, fieldDef.type, !!fieldDef.array);
       }
       if (fromRelation) {
@@ -3602,7 +3860,7 @@ var BaseOperationHandler = class {
     const thisCreateRows = [];
     const remainingFieldRows = [];
     const discriminatorField = getDiscriminatorField(this.schema, model);
-    (0, import_common_helpers7.invariant)(discriminatorField, `Base model "${model}" must have a discriminator field`);
+    (0, import_common_helpers8.invariant)(discriminatorField, `Base model "${model}" must have a discriminator field`);
     for (const createFields of createRows) {
       const thisCreateFields = {};
       const remainingFields = {};
@@ -3641,7 +3899,7 @@ var BaseOperationHandler = class {
   }
   fillGeneratedAndDefaultValues(modelDef, data) {
     const fields = modelDef.fields;
-    const values = (0, import_common_helpers7.clone)(data);
+    const values = (0, import_common_helpers8.clone)(data);
     for (const [field, fieldDef] of Object.entries(fields)) {
       if (fieldDef.originModel) {
         continue;
@@ -3732,7 +3990,7 @@ var BaseOperationHandler = class {
         const hasNonIgnoredFields = Object.keys(data).some((field) => (isScalarField(this.schema, modelDef.name, field) || isForeignKeyField(this.schema, modelDef.name, field)) && !ignoredFields.has(field));
         if (hasNonIgnoredFields) {
           if (finalData === data) {
-            finalData = (0, import_common_helpers7.clone)(data);
+            finalData = (0, import_common_helpers8.clone)(data);
           }
           finalData[fieldName] = this.dialect.transformInput(/* @__PURE__ */ new Date(), "DateTime", false);
           autoUpdatedFields.push(fieldName);
@@ -3835,7 +4093,7 @@ var BaseOperationHandler = class {
         const updatingIdFields = idFields.some((idField) => idField in updateFields);
         if (updatingIdFields) {
           const origIdValues = await loadThisEntity();
-          (0, import_common_helpers7.invariant)(origIdValues, "Original entity should have been loaded for update without RETURNING");
+          (0, import_common_helpers8.invariant)(origIdValues, "Original entity should have been loaded for update without RETURNING");
           readFilter = {
             ...origIdValues
           };
@@ -3894,7 +4152,7 @@ var BaseOperationHandler = class {
         }
       } else {
         const fromRelationFieldDef = this.requireField(fromRelation.model, fromRelation.field);
-        (0, import_common_helpers7.invariant)(fromRelationFieldDef.relation?.opposite);
+        (0, import_common_helpers8.invariant)(fromRelationFieldDef.relation?.opposite);
         parentWhere[fromRelationFieldDef.relation.opposite] = {
           some: fromRelation.ids
         };
@@ -3945,7 +4203,7 @@ var BaseOperationHandler = class {
     };
   }
   transformIncrementalUpdate(model, field, fieldDef, payload) {
-    (0, import_common_helpers7.invariant)(Object.keys(payload).length === 1, 'Only one of "set", "increment", "decrement", "multiply", or "divide" can be provided');
+    (0, import_common_helpers8.invariant)(Object.keys(payload).length === 1, 'Only one of "set", "increment", "decrement", "multiply", or "divide" can be provided');
     const key = Object.keys(payload)[0];
     const value = this.dialect.transformInput(payload[key], fieldDef.type, false);
     const eb = (0, import_kysely6.expressionBuilder)();
@@ -3955,7 +4213,7 @@ var BaseOperationHandler = class {
     });
   }
   transformScalarListUpdate(model, field, fieldDef, payload) {
-    (0, import_common_helpers7.invariant)(Object.keys(payload).length === 1, 'Only one of "set", "push" can be provided');
+    (0, import_common_helpers8.invariant)(Object.keys(payload).length === 1, 'Only one of "set", "push" can be provided');
     const key = Object.keys(payload)[0];
     const value = this.dialect.transformInput(payload[key], fieldDef.type, true);
     const eb = (0, import_kysely6.expressionBuilder)();
@@ -4115,14 +4373,14 @@ var BaseOperationHandler = class {
     for (const [key, value] of Object.entries(args)) {
       switch (key) {
         case "create": {
-          (0, import_common_helpers7.invariant)(!Array.isArray(value) || fieldDef.array, "relation must be an array if create is an array");
-          for (const item of (0, import_common_helpers7.enumerate)(value)) {
+          (0, import_common_helpers8.invariant)(!Array.isArray(value) || fieldDef.array, "relation must be an array if create is an array");
+          for (const item of (0, import_common_helpers8.enumerate)(value)) {
             await this.create(kysely, fieldModel, item, fromRelationContext);
           }
           break;
         }
         case "createMany": {
-          (0, import_common_helpers7.invariant)(fieldDef.array, "relation must be an array for createMany");
+          (0, import_common_helpers8.invariant)(fieldDef.array, "relation must be an array for createMany");
           await this.createMany(kysely, fieldModel, value, false, fromRelationContext);
           break;
         }
@@ -4139,12 +4397,12 @@ var BaseOperationHandler = class {
           break;
         }
         case "set": {
-          (0, import_common_helpers7.invariant)(fieldDef.array, "relation must be an array");
+          (0, import_common_helpers8.invariant)(fieldDef.array, "relation must be an array");
           await this.setRelation(kysely, fieldModel, value, fromRelationContext);
           break;
         }
         case "update": {
-          for (const _item of (0, import_common_helpers7.enumerate)(value)) {
+          for (const _item of (0, import_common_helpers8.enumerate)(value)) {
             const item = _item;
             let where;
             let data;
@@ -4161,7 +4419,7 @@ var BaseOperationHandler = class {
           break;
         }
         case "upsert": {
-          for (const _item of (0, import_common_helpers7.enumerate)(value)) {
+          for (const _item of (0, import_common_helpers8.enumerate)(value)) {
             const item = _item;
             const updated = await this.update(kysely, fieldModel, item.where, item.update, fromRelationContext, true, false);
             if (!updated) {
@@ -4171,7 +4429,7 @@ var BaseOperationHandler = class {
           break;
         }
         case "updateMany": {
-          for (const _item of (0, import_common_helpers7.enumerate)(value)) {
+          for (const _item of (0, import_common_helpers8.enumerate)(value)) {
             const item = _item;
             await this.updateMany(kysely, fieldModel, item.where, item.data, item.limit, false, fieldModel, fromRelationContext);
           }
@@ -4208,7 +4466,7 @@ var BaseOperationHandler = class {
     } else {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       if (ownedByModel) {
-        (0, import_common_helpers7.invariant)(_data.length === 1, "only one entity can be connected");
+        (0, import_common_helpers8.invariant)(_data.length === 1, "only one entity can be connected");
         const target = await this.readUnique(kysely, model, {
           where: _data[0]
         });
@@ -4245,7 +4503,7 @@ var BaseOperationHandler = class {
     }
   }
   async connectOrCreateRelation(kysely, model, data, fromRelation) {
-    const _data = (0, import_common_helpers7.enumerate)(data);
+    const _data = (0, import_common_helpers8.enumerate)(data);
     if (_data.length === 0) {
       return;
     }
@@ -4289,7 +4547,7 @@ var BaseOperationHandler = class {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       const eb = (0, import_kysely6.expressionBuilder)();
       if (ownedByModel) {
-        (0, import_common_helpers7.invariant)(disconnectConditions.length === 1, "only one entity can be disconnected");
+        (0, import_common_helpers8.invariant)(disconnectConditions.length === 1, "only one entity can be disconnected");
         const condition = disconnectConditions[0];
         if (condition === true) {
           for (const { fk } of keyPairs) {
@@ -4417,7 +4675,7 @@ var BaseOperationHandler = class {
     if (m2m) {
       deleteFromModel = model;
       const fieldDef = this.requireField(fromRelation.model, fromRelation.field);
-      (0, import_common_helpers7.invariant)(fieldDef.relation?.opposite);
+      (0, import_common_helpers8.invariant)(fieldDef.relation?.opposite);
       deleteResult = await this.delete(kysely, model, {
         AND: [
           {
@@ -4441,7 +4699,7 @@ var BaseOperationHandler = class {
           throw createNotFoundError(fromRelation.model);
         }
         const fieldDef = this.requireField(fromRelation.model, fromRelation.field);
-        (0, import_common_helpers7.invariant)(fieldDef.relation?.opposite);
+        (0, import_common_helpers8.invariant)(fieldDef.relation?.opposite);
         deleteResult = await this.delete(kysely, model, {
           AND: [
             // filter for parent
@@ -4474,7 +4732,7 @@ var BaseOperationHandler = class {
     }
   }
   normalizeRelationManipulationInput(model, data) {
-    return (0, import_common_helpers7.enumerate)(data).map((item) => flattenCompoundUniqueFilters(this.schema, model, item));
+    return (0, import_common_helpers8.enumerate)(data).map((item) => flattenCompoundUniqueFilters(this.schema, model, item));
   }
   // #endregion
   async delete(kysely, model, where, limit, filterModel, fieldsToReturn) {
@@ -4595,7 +4853,7 @@ var BaseOperationHandler = class {
     if (!args) {
       return;
     }
-    const newArgs = (0, import_common_helpers7.clone)(args);
+    const newArgs = (0, import_common_helpers8.clone)(args);
     this.doNormalizeArgs(newArgs);
     return newArgs;
   }
@@ -4604,7 +4862,7 @@ var BaseOperationHandler = class {
       for (const [key, value] of Object.entries(args)) {
         if (value === void 0) {
           delete args[key];
-        } else if (value && (0, import_common_helpers7.isPlainObject)(value)) {
+        } else if (value && (0, import_common_helpers8.isPlainObject)(value)) {
           this.doNormalizeArgs(value);
         }
       }
@@ -5266,11 +5524,11 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
 };
 
 // src/client/crud/validator/validator.ts
-var import_common_helpers9 = require("@zenstackhq/common-helpers");
+var import_common_helpers10 = require("@zenstackhq/common-helpers");
 var import_ts_pattern11 = require("ts-pattern");
 
 // src/client/zod/factory.ts
-var import_common_helpers8 = require("@zenstackhq/common-helpers");
+var import_common_helpers9 = require("@zenstackhq/common-helpers");
 var import_zod = require("@zenstackhq/zod");
 var import_decimal4 = __toESM(require("decimal.js"), 1);
 var import_ts_pattern10 = require("ts-pattern");
@@ -5406,10 +5664,10 @@ var ZodSchemaFactory = class {
   }
   makeFindSchema(model, operation, options) {
     const fields = {};
-    const unique = operation === "findUnique";
+    const unique2 = operation === "findUnique";
     const findOne = operation === "findUnique" || operation === "findFirst";
-    const where = this.makeWhereSchema(model, unique, false, false, options);
-    if (unique) {
+    const where = this.makeWhereSchema(model, unique2, false, false, options);
+    if (unique2) {
       fields["where"] = where;
     } else {
       fields["where"] = where.optional();
@@ -5417,7 +5675,7 @@ var ZodSchemaFactory = class {
     fields["select"] = this.makeSelectSchema(model, options).optional().nullable();
     fields["include"] = this.makeIncludeSchema(model, options).optional().nullable();
     fields["omit"] = this.makeOmitSchema(model).optional().nullable();
-    if (!unique) {
+    if (!unique2) {
       fields["skip"] = this.makeSkipSchema().optional();
       if (findOne) {
         fields["take"] = import_zod2.z.literal(1).optional();
@@ -5433,7 +5691,7 @@ var ZodSchemaFactory = class {
     result = this.refineForSelectIncludeMutuallyExclusive(result);
     result = this.refineForSelectOmitMutuallyExclusive(result);
     result = this.refineForSelectHasTruthyField(result);
-    if (!unique) {
+    if (!unique2) {
       result = result.optional();
     }
     return result;
@@ -5467,12 +5725,12 @@ var ZodSchemaFactory = class {
   }
   makeEnumSchema(_enum) {
     const enumDef = getEnum(this.schema, _enum);
-    (0, import_common_helpers8.invariant)(enumDef, `Enum "${_enum}" not found in schema`);
+    (0, import_common_helpers9.invariant)(enumDef, `Enum "${_enum}" not found in schema`);
     return import_zod2.z.enum(Object.keys(enumDef.values));
   }
   makeTypeDefSchema(type) {
     const typeDef = getTypeDef(this.schema, type);
-    (0, import_common_helpers8.invariant)(typeDef, `Type definition "${type}" not found in schema`);
+    (0, import_common_helpers9.invariant)(typeDef, `Type definition "${type}" not found in schema`);
     const schema = zLooseObject(Object.fromEntries(Object.entries(typeDef.fields).map(([field, def]) => {
       let fieldSchema = this.makeScalarSchema(def.type);
       if (def.array) {
@@ -5494,8 +5752,8 @@ var ZodSchemaFactory = class {
     });
     return finalSchema;
   }
-  makeWhereSchema(model, unique, withoutRelationFields = false, withAggregations = false, options) {
-    const uniqueFieldNames = unique ? getUniqueFields(this.schema, model).filter((uf) => (
+  makeWhereSchema(model, unique2, withoutRelationFields = false, withAggregations = false, options) {
+    const uniqueFieldNames = unique2 ? getUniqueFields(this.schema, model).filter((uf) => (
       // single-field unique
       "def" in uf
     )).map((uf) => uf.name) : void 0;
@@ -5551,12 +5809,12 @@ var ZodSchemaFactory = class {
         fields[field] = fieldSchema.optional();
       }
     }
-    if (unique) {
+    if (unique2) {
       const uniqueFields = getUniqueFields(this.schema, model);
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
           fields[uniqueField.name] = import_zod2.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => {
-            (0, import_common_helpers8.invariant)(!def.relation, "unique field cannot be a relation");
+            (0, import_common_helpers9.invariant)(!def.relation, "unique field cannot be a relation");
             let fieldSchema;
             const enumDef = getEnum(this.schema, def.type);
             if (enumDef) {
@@ -5588,7 +5846,7 @@ var ZodSchemaFactory = class {
     fields["NOT"] = this.orArray(import_zod2.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields, false, options)), true).optional();
     const baseWhere = import_zod2.z.strictObject(fields);
     let result = baseWhere;
-    if (unique) {
+    if (unique2) {
       const uniqueFields = getUniqueFields(this.schema, model);
       if (uniqueFields.length === 0) {
         throw createInternalError(`Model "${model}" has no unique fields`);
@@ -5611,7 +5869,7 @@ var ZodSchemaFactory = class {
     const optional = !!fieldInfo.optional;
     const array = !!fieldInfo.array;
     const typeDef = getTypeDef(this.schema, type);
-    (0, import_common_helpers8.invariant)(typeDef, `Type definition "${type}" not found in schema`);
+    (0, import_common_helpers9.invariant)(typeDef, `Type definition "${type}" not found in schema`);
     const candidates = [];
     if (!array) {
       const fieldSchemas = {};
@@ -5663,7 +5921,7 @@ var ZodSchemaFactory = class {
     const optional = !!fieldInfo.optional;
     const array = !!fieldInfo.array;
     const enumDef = getEnum(this.schema, enumName);
-    (0, import_common_helpers8.invariant)(enumDef, `Enum "${enumName}" not found in schema`);
+    (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(model, fieldInfo.name, baseSchema);
@@ -5956,7 +6214,7 @@ var ZodSchemaFactory = class {
     for (const plugin of this.plugins) {
       const resultConfig = plugin.result;
       if (resultConfig) {
-        const modelConfig = resultConfig[(0, import_common_helpers8.lowerCaseFirst)(model)];
+        const modelConfig = resultConfig[(0, import_common_helpers9.lowerCaseFirst)(model)];
         if (modelConfig) {
           for (const field of Object.keys(modelConfig)) {
             fields[field] = import_zod2.z.boolean().optional();
@@ -6499,7 +6757,7 @@ var ZodSchemaFactory = class {
     });
     let schema = this.mergePluginArgsSchema(baseSchema, "groupBy");
     schema = schema.refine((value) => {
-      const bys = (0, import_common_helpers8.enumerate)(value.by);
+      const bys = (0, import_common_helpers9.enumerate)(value.by);
       if (value.having && typeof value.having === "object") {
         for (const [key, val] of Object.entries(value.having)) {
           if (AggregateOperators.includes(key)) {
@@ -6519,8 +6777,8 @@ var ZodSchemaFactory = class {
       return true;
     }, 'fields in "having" must be in "by"');
     schema = schema.refine((value) => {
-      const bys = (0, import_common_helpers8.enumerate)(value.by);
-      for (const orderBy of (0, import_common_helpers8.enumerate)(value.orderBy)) {
+      const bys = (0, import_common_helpers9.enumerate)(value.by);
+      for (const orderBy of (0, import_common_helpers9.enumerate)(value.orderBy)) {
         if (orderBy && Object.keys(orderBy).filter((f) => !AggregateOperators.includes(f)).some((key) => !bys.includes(key))) {
           return false;
         }
@@ -6535,7 +6793,7 @@ var ZodSchemaFactory = class {
         continue;
       }
       if (LOGICAL_COMBINATORS.includes(key)) {
-        if ((0, import_common_helpers8.enumerate)(value).every((v) => this.onlyAggregationFields(v))) {
+        if ((0, import_common_helpers9.enumerate)(value).every((v) => this.onlyAggregationFields(v))) {
           continue;
         }
       }
@@ -6595,8 +6853,8 @@ var ZodSchemaFactory = class {
       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_helpers8.invariant)(createSchema instanceof import_zod2.ZodObject, "Plugin extended query args schema must be a Zod object");
-        (0, import_common_helpers8.invariant)(updateSchema instanceof import_zod2.ZodObject, "Plugin extended query args schema must be a Zod object");
+        (0, import_common_helpers9.invariant)(createSchema instanceof import_zod2.ZodObject, "Plugin extended query args schema must be a Zod object");
+        (0, import_common_helpers9.invariant)(updateSchema instanceof import_zod2.ZodObject, "Plugin extended query args schema must be a Zod object");
         result = createSchema.extend(updateSchema.shape);
       } else if (createSchema) {
         result = createSchema;
@@ -6617,7 +6875,7 @@ var ZodSchemaFactory = class {
     } else if ("$all" in plugin.queryArgs && plugin.queryArgs["$all"]) {
       result = plugin.queryArgs["$all"];
     }
-    (0, import_common_helpers8.invariant)(result === void 0 || result instanceof import_zod2.ZodObject, "Plugin extended query args schema must be a Zod object");
+    (0, import_common_helpers9.invariant)(result === void 0 || result instanceof import_zod2.ZodObject, "Plugin extended query args schema must be a Zod object");
     return result;
   }
   // #endregion
@@ -6671,7 +6929,7 @@ var ZodSchemaFactory = class {
       return void 0;
     }
     const modelsRecord = slicing.models;
-    const modelConfig = modelsRecord[(0, import_common_helpers8.lowerCaseFirst)(model)];
+    const modelConfig = modelsRecord[(0, import_common_helpers9.lowerCaseFirst)(model)];
     if (modelConfig?.fields) {
       const fieldConfig = modelConfig.fields[field];
       if (fieldConfig) {
@@ -7278,7 +7536,7 @@ var InputValidator = class {
       return input;
     }
     const procDef = (this.client.$schema.procedures ?? {})[proc];
-    (0, import_common_helpers9.invariant)(procDef, `Procedure "${proc}" not found in schema`);
+    (0, import_common_helpers10.invariant)(procDef, `Procedure "${proc}" not found in schema`);
     const params = Object.values(procDef.params ?? {});
     if (typeof input === "undefined") {
       if (params.length === 0) {
@@ -7539,12 +7797,12 @@ function performanceNow() {
 __name(performanceNow, "performanceNow");
 
 // src/client/executor/zenstack-query-executor.ts
-var import_common_helpers11 = require("@zenstackhq/common-helpers");
+var import_common_helpers12 = require("@zenstackhq/common-helpers");
 var import_kysely9 = require("kysely");
 var import_ts_pattern12 = require("ts-pattern");
 
 // src/client/executor/name-mapper.ts
-var import_common_helpers10 = require("@zenstackhq/common-helpers");
+var import_common_helpers11 = require("@zenstackhq/common-helpers");
 var import_kysely7 = require("kysely");
 var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
   static {
@@ -7617,7 +7875,7 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
       return super.transformInsertQuery(node, queryId);
     }
     const model = extractModelName(node.into);
-    (0, import_common_helpers10.invariant)(model, 'InsertQueryNode must have a model name in the "into" clause');
+    (0, import_common_helpers11.invariant)(model, 'InsertQueryNode must have a model name in the "into" clause');
     return this.withScope({
       model
     }, () => {
@@ -7700,7 +7958,7 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
       return super.transformUpdateQuery(node);
     }
     const model = extractModelName(innerTable);
-    (0, import_common_helpers10.invariant)(model, 'UpdateQueryNode must have a model name in the "table" clause');
+    (0, import_common_helpers11.invariant)(model, 'UpdateQueryNode must have a model name in the "table" clause');
     return this.withScope({
       model,
       alias
@@ -8004,7 +8262,7 @@ var QueryNameMapper = class extends import_kysely7.OperationNodeTransformer {
   }
   requireCurrentScope() {
     const scope = this.scopes[this.scopes.length - 1];
-    (0, import_common_helpers10.invariant)(scope, "No scope available");
+    (0, import_common_helpers11.invariant)(scope, "No scope available");
     return scope;
   }
   // #endregion
@@ -8471,7 +8729,7 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
     for (const valuesItem of values.values) {
       const rowIds = {};
       if (import_kysely9.PrimitiveValueListNode.is(valuesItem)) {
-        (0, import_common_helpers11.invariant)(valuesItem.values.length === columns.length, "Values count must match columns count");
+        (0, import_common_helpers12.invariant)(valuesItem.values.length === columns.length, "Values count must match columns count");
         for (const idField of idFields) {
           const colIndex = columns.findIndex((col) => col.column.name === idField);
           if (colIndex === -1) {
@@ -8480,7 +8738,7 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
           rowIds[idField] = valuesItem.values[colIndex];
         }
       } else {
-        (0, import_common_helpers11.invariant)(valuesItem.values.length === columns.length, "Values count must match columns count");
+        (0, import_common_helpers12.invariant)(valuesItem.values.length === columns.length, "Values count must match columns count");
         for (const idField of idFields) {
           const colIndex = columns.findIndex((col) => col.column.name === idField);
           if (colIndex === -1) {
@@ -8537,17 +8795,17 @@ In such cases, ZenStack cannot reliably determine the IDs of the mutated entitie
   }
   getMutationModel(queryNode) {
     return (0, import_ts_pattern12.match)(queryNode).when(import_kysely9.InsertQueryNode.is, (node) => {
-      (0, import_common_helpers11.invariant)(node.into, "InsertQueryNode must have an into clause");
+      (0, import_common_helpers12.invariant)(node.into, "InsertQueryNode must have an into clause");
       return node.into.table.identifier.name;
     }).when(import_kysely9.UpdateQueryNode.is, (node) => {
-      (0, import_common_helpers11.invariant)(node.table, "UpdateQueryNode must have a table");
+      (0, import_common_helpers12.invariant)(node.table, "UpdateQueryNode must have a table");
       const { node: tableNode } = stripAlias(node.table);
-      (0, import_common_helpers11.invariant)(import_kysely9.TableNode.is(tableNode), "UpdateQueryNode must use a TableNode");
+      (0, import_common_helpers12.invariant)(import_kysely9.TableNode.is(tableNode), "UpdateQueryNode must use a TableNode");
       return tableNode.table.identifier.name;
     }).when(import_kysely9.DeleteQueryNode.is, (node) => {
-      (0, import_common_helpers11.invariant)(node.from.froms.length === 1, "Delete query must have exactly one from table");
+      (0, import_common_helpers12.invariant)(node.from.froms.length === 1, "Delete query must have exactly one from table");
       const { node: tableNode } = stripAlias(node.from.froms[0]);
-      (0, import_common_helpers11.invariant)(import_kysely9.TableNode.is(tableNode), "DeleteQueryNode must use a TableNode");
+      (0, import_common_helpers12.invariant)(import_kysely9.TableNode.is(tableNode), "DeleteQueryNode must use a TableNode");
       return tableNode.table.identifier.name;
     }).otherwise((node) => {
       throw createInternalError(`Invalid query node: ${node}`);
@@ -8692,7 +8950,7 @@ __export(functions_exports, {
   search: () => search,
   startsWith: () => startsWith
 });
-var import_common_helpers12 = require("@zenstackhq/common-helpers");
+var import_common_helpers13 = require("@zenstackhq/common-helpers");
 var import_kysely10 = require("kysely");
 var import_ts_pattern13 = require("ts-pattern");
 var contains = /* @__PURE__ */ __name((eb, args, context) => textMatch(eb, args, context, "contains"), "contains");
@@ -8802,8 +9060,8 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  (0, import_common_helpers12.invariant)(import_kysely10.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
-  result = (0, import_ts_pattern13.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers12.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers12.lowerCaseFirst)(result)).otherwise(() => {
+  (0, import_common_helpers13.invariant)(import_kysely10.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
+  result = (0, import_ts_pattern13.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers13.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers13.lowerCaseFirst)(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -8814,13 +9072,13 @@ function readBoolean(expr, defaultValue) {
     return defaultValue;
   }
   const opNode = expr.toOperationNode();
-  (0, import_common_helpers12.invariant)(import_kysely10.ValueNode.is(opNode), "expression must be a literal value");
+  (0, import_common_helpers13.invariant)(import_kysely10.ValueNode.is(opNode), "expression must be a literal value");
   return !!opNode.value;
 }
 __name(readBoolean, "readBoolean");
 
 // src/client/helpers/schema-db-pusher.ts
-var import_common_helpers13 = require("@zenstackhq/common-helpers");
+var import_common_helpers14 = require("@zenstackhq/common-helpers");
 var import_kysely11 = require("kysely");
 var import_toposort = __toESM(require("toposort"), 1);
 var import_ts_pattern14 = require("ts-pattern");
@@ -8846,7 +9104,7 @@ var SchemaDbPusher = class {
                 return f.name;
               } else {
                 const mappedName = schema_exports.ExpressionUtils.getLiteralValue(mapAttr.args[0].value);
-                (0, import_common_helpers13.invariant)(mappedName && typeof mappedName === "string", `Invalid @map attribute for enum field ${f.name}`);
+                (0, import_common_helpers14.invariant)(mappedName && typeof mappedName === "string", `Invalid @map attribute for enum field ${f.name}`);
                 return mappedName;
               }
             });
@@ -8973,7 +9231,7 @@ var SchemaDbPusher = class {
   }
   addUniqueConstraint(table, modelDef) {
     for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
-      (0, import_common_helpers13.invariant)(typeof value === "object", "expecting an object");
+      (0, import_common_helpers14.invariant)(typeof value === "object", "expecting an object");
       if ("type" in value) {
         const fieldDef = modelDef.fields[key];
         if (fieldDef.unique) {
@@ -9048,7 +9306,7 @@ var SchemaDbPusher = class {
               return f.name;
             } else {
               const mappedName = schema_exports.ExpressionUtils.getLiteralValue(mapAttr.args[0].value);
-              (0, import_common_helpers13.invariant)(mappedName && typeof mappedName === "string", `Invalid @map attribute for enum field ${f.name}`);
+              (0, import_common_helpers14.invariant)(mappedName && typeof mappedName === "string", `Invalid @map attribute for enum field ${f.name}`);
               return mappedName;
             }
           });
@@ -9083,7 +9341,7 @@ var SchemaDbPusher = class {
     return fieldDef.default && schema_exports.ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "autoincrement";
   }
   addForeignKeyConstraint(table, model, fieldName, fieldDef) {
-    (0, import_common_helpers13.invariant)(fieldDef.relation, "field must be a relation");
+    (0, import_common_helpers14.invariant)(fieldDef.relation, "field must be a relation");
     if (!fieldDef.relation.fields || !fieldDef.relation.references) {
       return table;
     }
@@ -9411,7 +9669,7 @@ var ClientImpl = class _ClientImpl {
     for (const [modelName, modelDef] of Object.entries(this.$schema.models)) {
       if (modelDef.computedFields) {
         for (const fieldName of Object.keys(modelDef.computedFields)) {
-          const modelConfig = computedFieldsConfig?.[(0, import_common_helpers14.lowerCaseFirst)(modelName)] ?? computedFieldsConfig?.[modelName];
+          const modelConfig = computedFieldsConfig?.[(0, import_common_helpers15.lowerCaseFirst)(modelName)] ?? 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.`);
@@ -9443,7 +9701,7 @@ var ClientImpl = class _ClientImpl {
   }
   // implementation
   async $transaction(input, options) {
-    (0, import_common_helpers14.invariant)(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
+    (0, import_common_helpers15.invariant)(typeof input === "function" || Array.isArray(input) && input.every((p) => p.then && p.cb), "Invalid transaction input, expected a function or an array of ZenStackPromise");
     if (typeof input === "function") {
       return this.interactiveTransaction(input, options);
     } else {
@@ -9921,7 +10179,7 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
   };
   const slicing = client.$options.slicing;
   if (slicing?.models) {
-    const modelSlicing = slicing.models[(0, import_common_helpers14.lowerCaseFirst)(model)];
+    const modelSlicing = slicing.models[(0, import_common_helpers15.lowerCaseFirst)(model)];
     const allSlicing = slicing.models.$all;
     const includedOperations = modelSlicing?.includedOperations ?? allSlicing?.includedOperations;
     const excludedOperations = modelSlicing?.excludedOperations ?? allSlicing?.excludedOperations;
@@ -9972,7 +10230,7 @@ function collectExtResultFieldDefs(model, schema, plugins) {
   for (const plugin of plugins) {
     const resultConfig = plugin.result;
     if (resultConfig) {
-      const modelConfig = resultConfig[(0, import_common_helpers14.lowerCaseFirst)(model)];
+      const modelConfig = resultConfig[(0, import_common_helpers15.lowerCaseFirst)(model)];
       if (modelConfig) {
         for (const [fieldName, fieldDef] of Object.entries(modelConfig)) {
           if (getField(schema, model, fieldName)) {