@zenstackhq/runtime 3.0.0-alpha.4 → 3.0.0-alpha.7

package/dist/index.cjs

@@ -36,6 +36,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/client/client-impl.ts
+var import_common_helpers12 = require("@zenstackhq/common-helpers");
 var import_kysely16 = require("kysely");
 var import_ts_pattern19 = require("ts-pattern");
 
@@ -310,9 +311,9 @@ __name(safeJSONStringify, "safeJSONStringify");
 
 // src/client/crud/operations/base.ts
 var import_cuid2 = require("@paralleldrive/cuid2");
+var import_common_helpers8 = require("@zenstackhq/common-helpers");
 var import_kysely8 = require("kysely");
 var import_nanoid = require("nanoid");
-var import_tiny_invariant7 = __toESM(require("tiny-invariant"), 1);
 var import_ts_pattern8 = require("ts-pattern");
 var import_ulid = require("ulid");
 var uuid = __toESM(require("uuid"), 1);
@@ -330,21 +331,21 @@ var RejectedByPolicyError = class extends Error {
 };
 
 // src/plugins/policy/policy-handler.ts
+var import_common_helpers6 = require("@zenstackhq/common-helpers");
 var import_kysely7 = require("kysely");
-var import_tiny_invariant6 = __toESM(require("tiny-invariant"), 1);
 var import_ts_pattern7 = require("ts-pattern");
 
 // src/client/crud/dialects/index.ts
 var import_ts_pattern4 = require("ts-pattern");
 
 // src/client/crud/dialects/postgresql.ts
+var import_common_helpers2 = require("@zenstackhq/common-helpers");
 var import_kysely2 = require("kysely");
-var import_tiny_invariant2 = __toESM(require("tiny-invariant"), 1);
 var import_ts_pattern2 = require("ts-pattern");
 
 // src/client/crud/dialects/base.ts
+var import_common_helpers = require("@zenstackhq/common-helpers");
 var import_kysely = require("kysely");
-var import_tiny_invariant = __toESM(require("tiny-invariant"), 1);
 var import_ts_pattern = require("ts-pattern");
 
 // src/utils/enumerate.ts
@@ -362,7 +363,6 @@ function enumerate(x) {
 __name(enumerate, "enumerate");
 
 // src/client/crud/dialects/base.ts
-var import_is_plain_object = require("is-plain-object");
 var BaseCrudDialect = class {
   static {
     __name(this, "BaseCrudDialect");
@@ -560,7 +560,7 @@ var BaseCrudDialect = class {
     return eb(lhs, "=", rhs !== null && rhs !== void 0 ? this.transformPrimitive(rhs, type) : rhs);
   }
   buildStandardFilter(eb, type, payload, lhs, getRhs, recurse, throwIfInvalid = false, onlyForKeys = void 0) {
-    if (payload === null || !(0, import_is_plain_object.isPlainObject)(payload)) {
+    if (payload === null || !(0, import_common_helpers.isPlainObject)(payload)) {
       return {
         conditions: [
           this.buildLiteralFilter(eb, lhs, type, payload)
@@ -576,14 +576,14 @@ var BaseCrudDialect = class {
       }
       const rhs = Array.isArray(value) ? value.map(getRhs) : getRhs(value);
       const condition = (0, import_ts_pattern.match)(op).with("equals", () => rhs === null ? eb(lhs, "is", null) : eb(lhs, "=", rhs)).with("in", () => {
-        (0, import_tiny_invariant.default)(Array.isArray(rhs), "right hand side must be an array");
+        (0, import_common_helpers.invariant)(Array.isArray(rhs), "right hand side must be an array");
         if (rhs.length === 0) {
           return this.false(eb);
         } else {
           return eb(lhs, "in", rhs);
         }
       }).with("notIn", () => {
-        (0, import_tiny_invariant.default)(Array.isArray(rhs), "right hand side must be an array");
+        (0, import_common_helpers.invariant)(Array.isArray(rhs), "right hand side must be an array");
         if (rhs.length === 0) {
           return this.true(eb);
         } else {
@@ -697,9 +697,9 @@ var BaseCrudDialect = class {
           "_min",
           "_max"
         ].includes(field)) {
-          (0, import_tiny_invariant.default)(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
+          (0, import_common_helpers.invariant)(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
           for (const [k, v] of Object.entries(value)) {
-            (0, import_tiny_invariant.default)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
+            (0, import_common_helpers.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
             result = result.orderBy((eb) => eb.fn(field.slice(1), [
               import_kysely.sql.ref(k)
             ]), import_kysely.sql.raw(this.negateSort(v, negated)));
@@ -708,9 +708,9 @@ var BaseCrudDialect = class {
         }
         switch (field) {
           case "_count": {
-            (0, import_tiny_invariant.default)(value && typeof value === "object", 'invalid orderBy value for field "_count"');
+            (0, import_common_helpers.invariant)(value && typeof value === "object", 'invalid orderBy value for field "_count"');
             for (const [k, v] of Object.entries(value)) {
-              (0, import_tiny_invariant.default)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
+              (0, import_common_helpers.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
               result = result.orderBy((eb) => eb.fn.count(import_kysely.sql.ref(k)), import_kysely.sql.raw(this.negateSort(v, negated)));
             }
             continue;
@@ -732,7 +732,7 @@ var BaseCrudDialect = class {
               throw new QueryError(`invalid orderBy value for field "${field}"`);
             }
             if ("_count" in value) {
-              (0, import_tiny_invariant.default)(value._count === "asc" || value._count === "desc", 'invalid orderBy value for field "_count"');
+              (0, import_common_helpers.invariant)(value._count === "asc" || value._count === "desc", 'invalid orderBy value for field "_count"');
               const sort = this.negateSort(value._count, negated);
               result = result.orderBy((eb) => {
                 let subQuery = eb.selectFrom(relationModel);
@@ -850,8 +850,8 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
         if (m2m) {
           const parentIds = getIdFields(this.schema, model);
           const relationIds = getIdFields(this.schema, relationModel);
-          (0, import_tiny_invariant2.default)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
-          (0, import_tiny_invariant2.default)(relationIds.length === 1, "many-to-many relation must have exactly one id field");
+          (0, import_common_helpers2.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
+          (0, import_common_helpers2.invariant)(relationIds.length === 1, "many-to-many relation must have exactly one id field");
           subQuery = subQuery.where(eb(eb.ref(`${relationModel}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentName}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
         } else {
           const joinPairs = buildJoinPairs(this.schema, model, parentName, relationField, relationModel);
@@ -945,8 +945,8 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
 };
 
 // src/client/crud/dialects/sqlite.ts
+var import_common_helpers3 = require("@zenstackhq/common-helpers");
 var import_kysely3 = require("kysely");
-var import_tiny_invariant3 = __toESM(require("tiny-invariant"), 1);
 var import_ts_pattern3 = require("ts-pattern");
 var SqliteCrudDialect = class extends BaseCrudDialect {
   static {
@@ -993,8 +993,8 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
       if (m2m) {
         const parentIds = getIdFields(this.schema, model);
         const relationIds = getIdFields(this.schema, relationModel);
-        (0, import_tiny_invariant3.default)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
-        (0, import_tiny_invariant3.default)(relationIds.length === 1, "many-to-many relation must have exactly one id field");
+        (0, import_common_helpers3.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
+        (0, import_common_helpers3.invariant)(relationIds.length === 1, "many-to-many relation must have exactly one id field");
         subQuery = subQuery.where(eb(eb.ref(`${relationModel}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentName}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
       } else {
         const { keyPairs, ownedByModel } = getRelationForeignKeyFieldPairs(this.schema, model, relationField);
@@ -1490,12 +1490,12 @@ var ColumnCollector = class extends DefaultOperationNodeVisitor {
 };
 
 // src/plugins/policy/expression-transformer.ts
+var import_common_helpers5 = require("@zenstackhq/common-helpers");
 var import_kysely6 = require("kysely");
-var import_tiny_invariant5 = __toESM(require("tiny-invariant"), 1);
 var import_ts_pattern6 = require("ts-pattern");
 
 // src/plugins/policy/expression-evaluator.ts
-var import_tiny_invariant4 = __toESM(require("tiny-invariant"), 1);
+var import_common_helpers4 = require("@zenstackhq/common-helpers");
 var import_ts_pattern5 = require("ts-pattern");
 var ExpressionEvaluator = class {
   static {
@@ -1539,18 +1539,18 @@ var ExpressionEvaluator = class {
     const right = this.evaluate(expr2.right, context);
     return (0, import_ts_pattern5.match)(expr2.op).with("==", () => left === right).with("!=", () => left !== right).with(">", () => left > right).with(">=", () => left >= right).with("<", () => left < right).with("<=", () => left <= right).with("&&", () => left && right).with("||", () => left || right).with("in", () => {
       const _right = right ?? [];
-      (0, import_tiny_invariant4.default)(Array.isArray(_right), 'expected array for "in" operator');
+      (0, import_common_helpers4.invariant)(Array.isArray(_right), 'expected array for "in" operator');
       return _right.includes(left);
     }).exhaustive();
   }
   evaluateCollectionPredicate(expr2, context) {
     const op = expr2.op;
-    (0, import_tiny_invariant4.default)(op === "?" || op === "!" || op === "^", 'expected "?" or "!" or "^" operator');
+    (0, import_common_helpers4.invariant)(op === "?" || op === "!" || op === "^", 'expected "?" or "!" or "^" operator');
     const left = this.evaluate(expr2.left, context);
     if (!left) {
       return false;
     }
-    (0, import_tiny_invariant4.default)(Array.isArray(left), "expected array");
+    (0, import_common_helpers4.invariant)(Array.isArray(left), "expected array");
     return (0, import_ts_pattern5.match)(op).with("?", () => left.some((item) => this.evaluate(expr2.right, {
       ...context,
       thisValue: item
@@ -1772,20 +1772,20 @@ var ExpressionTransformer = class {
     return import_kysely6.BinaryOperationNode.create(left, this.transformOperator(op), right);
   }
   transformCollectionPredicate(expr2, context) {
-    (0, import_tiny_invariant5.default)(expr2.op === "?" || expr2.op === "!" || expr2.op === "^", 'expected "?" or "!" or "^" operator');
+    (0, import_common_helpers5.invariant)(expr2.op === "?" || expr2.op === "!" || expr2.op === "^", 'expected "?" or "!" or "^" operator');
     if (this.isAuthCall(expr2.left) || this.isAuthMember(expr2.left)) {
       const value = new ExpressionEvaluator().evaluate(expr2, {
         auth: this.auth
       });
       return this.transformValue(value, "Boolean");
     }
-    (0, import_tiny_invariant5.default)(ExpressionUtils.isField(expr2.left) || ExpressionUtils.isMember(expr2.left), "left operand must be field or member access");
+    (0, import_common_helpers5.invariant)(ExpressionUtils.isField(expr2.left) || ExpressionUtils.isMember(expr2.left), "left operand must be field or member access");
     let newContextModel;
     if (ExpressionUtils.isField(expr2.left)) {
       const fieldDef = requireField(this.schema, context.model, expr2.left.field);
       newContextModel = fieldDef.type;
     } else {
-      (0, import_tiny_invariant5.default)(ExpressionUtils.isField(expr2.left.receiver));
+      (0, import_common_helpers5.invariant)(ExpressionUtils.isField(expr2.left.receiver));
       const fieldDef = requireField(this.schema, context.model, expr2.left.receiver.field);
       newContextModel = fieldDef.type;
       for (const member of expr2.left.members) {
@@ -1832,7 +1832,7 @@ var ExpressionTransformer = class {
     return import_kysely6.ValueNode.create(this.dialect.transformPrimitive(value, type) ?? null);
   }
   _unary(expr2, context) {
-    (0, import_tiny_invariant5.default)(expr2.op === "!", 'only "!" operator is supported');
+    (0, import_common_helpers5.invariant)(expr2.op === "!", 'only "!" operator is supported');
     return import_kysely6.BinaryOperationNode.create(this.transform(expr2.operand, context), this.transformOperator("!="), trueNode(this.dialect));
   }
   transformOperator(op) {
@@ -1875,10 +1875,10 @@ var ExpressionTransformer = class {
     if (this.isAuthCall(expr2.receiver)) {
       return this.valueMemberAccess(this.auth, expr2, this.authType);
     }
-    (0, import_tiny_invariant5.default)(ExpressionUtils.isField(expr2.receiver), "expect receiver to be field expression");
+    (0, import_common_helpers5.invariant)(ExpressionUtils.isField(expr2.receiver), "expect receiver to be field expression");
     const { memberFilter, memberSelect, ...restContext } = context;
     const receiver = this.transform(expr2.receiver, restContext);
-    (0, import_tiny_invariant5.default)(import_kysely6.SelectQueryNode.is(receiver), "expected receiver to be select query");
+    (0, import_common_helpers5.invariant)(import_kysely6.SelectQueryNode.is(receiver), "expected receiver to be select query");
     const receiverField = requireField(this.schema, context.model, expr2.receiver.field);
     const memberFields = [];
     let currType = receiverField.type;
@@ -1902,7 +1902,7 @@ var ExpressionTransformer = class {
           thisEntity: void 0
         });
         if (currNode) {
-          (0, import_tiny_invariant5.default)(import_kysely6.SelectQueryNode.is(currNode), "expected select query node");
+          (0, import_common_helpers5.invariant)(import_kysely6.SelectQueryNode.is(currNode), "expected select query node");
           currNode = {
             ...relation,
             selections: [
@@ -1919,8 +1919,8 @@ var ExpressionTransformer = class {
           };
         }
       } else {
-        (0, import_tiny_invariant5.default)(i === expr2.members.length - 1, "plain field access must be the last segment");
-        (0, import_tiny_invariant5.default)(!currNode, "plain field access must be the last segment");
+        (0, import_common_helpers5.invariant)(i === expr2.members.length - 1, "plain field access must be the last segment");
+        (0, import_common_helpers5.invariant)(!currNode, "plain field access must be the last segment");
         currNode = import_kysely6.ColumnNode.create(member);
       }
     }
@@ -2165,13 +2165,13 @@ var PolicyHandler = class extends import_kysely7.OperationNodeTransformer {
     }
   }
   unwrapCreateValueRow(data, model, fields) {
-    (0, import_tiny_invariant6.default)(data.length === fields.length, "data length must match fields length");
+    (0, import_common_helpers6.invariant)(data.length === fields.length, "data length must match fields length");
     const result = [];
     for (let i = 0; i < data.length; i++) {
       const item = data[i];
       const fieldDef = requireField(this.client.$schema, model, fields[i]);
       if (typeof item === "object" && item && "kind" in item) {
-        (0, import_tiny_invariant6.default)(item.kind === "ValueNode", "expecting a ValueNode");
+        (0, import_common_helpers6.invariant)(item.kind === "ValueNode", "expecting a ValueNode");
         result.push({
           node: import_kysely7.ValueNode.create(this.dialect.transformPrimitive(item.value, fieldDef.type)),
           raw: item.value
@@ -2379,8 +2379,8 @@ var PolicyHandler = class extends import_kysely7.OperationNodeTransformer {
     const modelDef = requireModel(this.client.$schema, modelName);
     const result = [];
     const extractOperations = /* @__PURE__ */ __name((expr2) => {
-      (0, import_tiny_invariant6.default)(ExpressionUtils.isLiteral(expr2), "expecting a literal");
-      (0, import_tiny_invariant6.default)(typeof expr2.value === "string", "expecting a string literal");
+      (0, import_common_helpers6.invariant)(ExpressionUtils.isLiteral(expr2), "expecting a literal");
+      (0, import_common_helpers6.invariant)(typeof expr2.value === "string", "expecting a string literal");
       return expr2.value.split(",").filter((v) => !!v).map((v) => v.trim());
     }, "extractOperations");
     if (modelDef.attributes) {
@@ -2415,13 +2415,13 @@ var PolicyPlugin = class {
 };
 
 // src/utils/clone.ts
-var import_is_plain_object2 = require("is-plain-object");
+var import_common_helpers7 = require("@zenstackhq/common-helpers");
 function clone(value) {
   if (Array.isArray(value)) {
     return value.map((v) => clone(v));
   }
   if (typeof value === "object") {
-    if (!value || !(0, import_is_plain_object2.isPlainObject)(value)) {
+    if (!value || !(0, import_common_helpers7.isPlainObject)(value)) {
       return value;
     }
     const result = {};
@@ -2741,8 +2741,8 @@ var BaseOperationHandler = class {
   }
   buildFkAssignments(model, relationField, entity) {
     const parentFkFields = {};
-    (0, import_tiny_invariant7.default)(relationField, "parentField must be defined if parentModel is defined");
-    (0, import_tiny_invariant7.default)(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)) {
@@ -2769,8 +2769,8 @@ var BaseOperationHandler = class {
     ].sort((a, b) => a.model.localeCompare(b.model));
     const firstIds = getIdFields(this.schema, sortedRecords[0].model);
     const secondIds = getIdFields(this.schema, sortedRecords[1].model);
-    (0, import_tiny_invariant7.default)(firstIds.length === 1, "many-to-many relation must have exactly one id field");
-    (0, import_tiny_invariant7.default)(secondIds.length === 1, "many-to-many relation must have exactly one id field");
+    (0, import_common_helpers8.invariant)(firstIds.length === 1, "many-to-many relation must have exactly one id field");
+    (0, import_common_helpers8.invariant)(secondIds.length === 1, "many-to-many relation must have exactly one id field");
     if (action === "connect") {
       const result = await kysely.insertInto(joinTable).values({
         A: sortedRecords[0].entity[firstIds[0]],
@@ -2787,10 +2787,10 @@ var BaseOperationHandler = class {
     }
   }
   resetManyToManyRelation(kysely, model, field, parentIds) {
-    (0, import_tiny_invariant7.default)(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_tiny_invariant7.default)(m2m, "not a many-to-many relation");
+    (0, import_common_helpers8.invariant)(m2m, "not a many-to-many relation");
     const eb = (0, import_kysely8.expressionBuilder)();
     return kysely.deleteFrom(m2m.joinTable).where(eb(`${m2m.joinTable}.${m2m.parentFkName}`, "=", parentId)).execute();
   }
@@ -2812,7 +2812,7 @@ var BaseOperationHandler = class {
         }
         case "connect": {
           const referencedPkFields = relationField.relation.references;
-          (0, import_tiny_invariant7.default)(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;
@@ -2901,7 +2901,7 @@ var BaseOperationHandler = class {
       const newItem = {};
       for (const [name, value] of Object.entries(item)) {
         const fieldDef = this.requireField(model, name);
-        (0, import_tiny_invariant7.default)(!fieldDef.relation, "createMany does not support relations");
+        (0, import_common_helpers8.invariant)(!fieldDef.relation, "createMany does not support relations");
         newItem[name] = this.dialect.transformPrimitive(value, fieldDef.type);
       }
       if (fromRelation) {
@@ -2980,7 +2980,7 @@ var BaseOperationHandler = class {
         }
       } else {
         const fromRelationFieldDef = this.requireField(fromRelation.model, fromRelation.field);
-        (0, import_tiny_invariant7.default)(fromRelationFieldDef.relation?.opposite);
+        (0, import_common_helpers8.invariant)(fromRelationFieldDef.relation?.opposite);
         parentWhere[fromRelationFieldDef.relation.opposite] = {
           some: fromRelation.ids
         };
@@ -3070,7 +3070,7 @@ var BaseOperationHandler = class {
     }
   }
   transformIncrementalUpdate(model, field, fieldDef, payload) {
-    (0, import_tiny_invariant7.default)(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.transformPrimitive(payload[key], fieldDef.type);
     const eb = (0, import_kysely8.expressionBuilder)();
@@ -3080,7 +3080,7 @@ var BaseOperationHandler = class {
     });
   }
   transformScalarListUpdate(model, field, fieldDef, payload) {
-    (0, import_tiny_invariant7.default)(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.transformPrimitive(payload[key], fieldDef.type);
     const eb = (0, import_kysely8.expressionBuilder)();
@@ -3161,12 +3161,12 @@ var BaseOperationHandler = class {
     for (const [key, value] of Object.entries(args)) {
       switch (key) {
         case "create": {
-          (0, import_tiny_invariant7.default)(!Array.isArray(value) || fieldDef.array, "relation must be an array if create is an array");
+          (0, import_common_helpers8.invariant)(!Array.isArray(value) || fieldDef.array, "relation must be an array if create is an array");
           tasks.push(...enumerate(value).map((item) => this.create(kysely, fieldModel, item, fromRelationContext)));
           break;
         }
         case "createMany": {
-          (0, import_tiny_invariant7.default)(fieldDef.array, "relation must be an array for createMany");
+          (0, import_common_helpers8.invariant)(fieldDef.array, "relation must be an array for createMany");
           tasks.push(this.createMany(kysely, fieldModel, value, false, fromRelationContext));
           break;
         }
@@ -3183,7 +3183,7 @@ var BaseOperationHandler = class {
           break;
         }
         case "set": {
-          (0, import_tiny_invariant7.default)(fieldDef.array, "relation must be an array");
+          (0, import_common_helpers8.invariant)(fieldDef.array, "relation must be an array");
           tasks.push(this.setRelation(kysely, fieldModel, value, fromRelationContext));
           break;
         }
@@ -3252,7 +3252,7 @@ var BaseOperationHandler = class {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       let updateResult;
       if (ownedByModel) {
-        (0, import_tiny_invariant7.default)(_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]
         });
@@ -3342,7 +3342,7 @@ var BaseOperationHandler = class {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, fromRelation.model, fromRelation.field);
       const eb = (0, import_kysely8.expressionBuilder)();
       if (ownedByModel) {
-        (0, import_tiny_invariant7.default)(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];
         const query = kysely.updateTable(fromRelation.model).where(eb.and(fromRelation.ids)).$if(condition !== true, (qb) => qb.where(eb(
           // @ts-ignore
@@ -3450,7 +3450,7 @@ var BaseOperationHandler = class {
     const m2m = getManyToManyRelation(this.schema, fromRelation.model, fromRelation.field);
     if (m2m) {
       const fieldDef = this.requireField(fromRelation.model, fromRelation.field);
-      (0, import_tiny_invariant7.default)(fieldDef.relation?.opposite);
+      (0, import_common_helpers8.invariant)(fieldDef.relation?.opposite);
       deleteResult = await this.delete(kysely, model, {
         AND: [
           {
@@ -3473,7 +3473,7 @@ var BaseOperationHandler = class {
           throw new NotFoundError(model);
         }
         const fieldDef = this.requireField(fromRelation.model, fromRelation.field);
-        (0, import_tiny_invariant7.default)(fieldDef.relation?.opposite);
+        (0, import_common_helpers8.invariant)(fieldDef.relation?.opposite);
         deleteResult = await this.delete(kysely, model, {
           AND: [
             // filter for parent
@@ -3978,16 +3978,15 @@ var UpdateOperationHandler = class extends BaseOperationHandler {
 var import_decimal = __toESM(require("decimal.js"), 1);
 var import_json_stable_stringify = __toESM(require("json-stable-stringify"), 1);
 var import_ts_pattern14 = require("ts-pattern");
-var import_zod = require("zod");
+var import_v4 = require("zod/v4");
 var InputValidator = class {
   static {
     __name(this, "InputValidator");
   }
   schema;
-  schemaCache;
+  schemaCache = /* @__PURE__ */ new Map();
   constructor(schema) {
     this.schema = schema;
-    this.schemaCache = /* @__PURE__ */ new Map();
   }
   validateFindArgs(model, unique, args) {
     return this.validate(model, "find", {
@@ -4063,11 +4062,11 @@ var InputValidator = class {
     fields["distinct"] = this.makeDistinctSchema(model).optional();
     fields["cursor"] = this.makeCursorSchema(model).optional();
     if (options.collection) {
-      fields["skip"] = import_zod.z.number().int().nonnegative().optional();
-      fields["take"] = import_zod.z.number().int().optional();
+      fields["skip"] = import_v4.z.number().int().nonnegative().optional();
+      fields["take"] = import_v4.z.number().int().optional();
       fields["orderBy"] = this.orArray(this.makeOrderBySchema(model, true, false), true).optional();
     }
-    let result = import_zod.z.object(fields).strict();
+    let result = import_v4.z.object(fields).strict();
     result = this.refineForSelectIncludeMutuallyExclusive(result);
     result = this.refineForSelectOmitMutuallyExclusive(result);
     if (!options.unique) {
@@ -4076,17 +4075,17 @@ var InputValidator = class {
     return result;
   }
   makePrimitiveSchema(type) {
-    return (0, import_ts_pattern14.match)(type).with("String", () => import_zod.z.string()).with("Int", () => import_zod.z.number()).with("Float", () => import_zod.z.number()).with("Boolean", () => import_zod.z.boolean()).with("BigInt", () => import_zod.z.union([
-      import_zod.z.number(),
-      import_zod.z.bigint()
-    ])).with("Decimal", () => import_zod.z.union([
-      import_zod.z.number(),
-      import_zod.z.instanceof(import_decimal.default),
-      import_zod.z.string()
-    ])).with("DateTime", () => import_zod.z.union([
-      import_zod.z.date(),
-      import_zod.z.string().datetime()
-    ])).with("Bytes", () => import_zod.z.instanceof(Uint8Array)).otherwise(() => import_zod.z.unknown());
+    return (0, import_ts_pattern14.match)(type).with("String", () => import_v4.z.string()).with("Int", () => import_v4.z.number()).with("Float", () => import_v4.z.number()).with("Boolean", () => import_v4.z.boolean()).with("BigInt", () => import_v4.z.union([
+      import_v4.z.number(),
+      import_v4.z.bigint()
+    ])).with("Decimal", () => import_v4.z.union([
+      import_v4.z.number(),
+      import_v4.z.instanceof(import_decimal.default),
+      import_v4.z.string()
+    ])).with("DateTime", () => import_v4.z.union([
+      import_v4.z.date(),
+      import_v4.z.string().datetime()
+    ])).with("Bytes", () => import_v4.z.instanceof(Uint8Array)).otherwise(() => import_v4.z.unknown());
   }
   makeWhereSchema(model, unique, withoutRelationFields = false) {
     const modelDef = getModel(this.schema, model);
@@ -4101,21 +4100,21 @@ var InputValidator = class {
         if (withoutRelationFields) {
           continue;
         }
-        fieldSchema = import_zod.z.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
+        fieldSchema = import_v4.z.lazy(() => this.makeWhereSchema(fieldDef.type, false).optional());
         fieldSchema = this.nullableIf(fieldSchema, !fieldDef.array && !!fieldDef.optional);
         if (fieldDef.array) {
-          fieldSchema = import_zod.z.union([
+          fieldSchema = import_v4.z.union([
             fieldSchema,
-            import_zod.z.object({
+            import_v4.z.object({
               some: fieldSchema.optional(),
               every: fieldSchema.optional(),
               none: fieldSchema.optional()
             })
           ]);
         } else {
-          fieldSchema = import_zod.z.union([
+          fieldSchema = import_v4.z.union([
             fieldSchema,
-            import_zod.z.object({
+            import_v4.z.object({
               is: fieldSchema.optional(),
               isNot: fieldSchema.optional()
             })
@@ -4141,18 +4140,18 @@ var InputValidator = class {
       const uniqueFields = getUniqueFields(this.schema, model);
       for (const uniqueField of uniqueFields) {
         if ("defs" in uniqueField) {
-          fields[uniqueField.name] = import_zod.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => [
+          fields[uniqueField.name] = import_v4.z.object(Object.fromEntries(Object.entries(uniqueField.defs).map(([key, def]) => [
             key,
             this.makePrimitiveFilterSchema(def.type, !!def.optional)
           ]))).optional();
         }
       }
     }
-    fields["$expr"] = import_zod.z.function().optional();
-    fields["AND"] = this.orArray(import_zod.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    fields["OR"] = import_zod.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
-    fields["NOT"] = this.orArray(import_zod.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
-    const baseWhere = import_zod.z.object(fields).strict();
+    fields["$expr"] = import_v4.z.custom((v) => typeof v === "function").optional();
+    fields["AND"] = this.orArray(import_v4.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
+    fields["OR"] = import_v4.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)).array().optional();
+    fields["NOT"] = this.orArray(import_v4.z.lazy(() => this.makeWhereSchema(model, false, withoutRelationFields)), true).optional();
+    const baseWhere = import_v4.z.object(fields).strict();
     let result = baseWhere;
     if (unique) {
       const uniqueFields = getUniqueFields(this.schema, model);
@@ -4172,11 +4171,11 @@ var InputValidator = class {
     return result;
   }
   makeEnumFilterSchema(enumDef, optional) {
-    const baseSchema = import_zod.z.enum(Object.keys(enumDef));
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod.z.lazy(() => this.makeEnumFilterSchema(enumDef, optional)));
-    return import_zod.z.union([
+    const baseSchema = import_v4.z.enum(Object.keys(enumDef));
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_v4.z.lazy(() => this.makeEnumFilterSchema(enumDef, optional)));
+    return import_v4.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod.z.object({
+      import_v4.z.object({
         equals: components.equals,
         in: components.in,
         notIn: components.notIn,
@@ -4185,38 +4184,38 @@ var InputValidator = class {
     ]);
   }
   makeArrayFilterSchema(type) {
-    return import_zod.z.object({
+    return import_v4.z.object({
       equals: this.makePrimitiveSchema(type).array().optional(),
       has: this.makePrimitiveSchema(type).optional(),
       hasEvery: this.makePrimitiveSchema(type).array().optional(),
       hasSome: this.makePrimitiveSchema(type).array().optional(),
-      isEmpty: import_zod.z.boolean().optional()
+      isEmpty: import_v4.z.boolean().optional()
     });
   }
   makePrimitiveFilterSchema(type, optional) {
     return (0, import_ts_pattern14.match)(type).with("String", () => this.makeStringFilterSchema(optional)).with(import_ts_pattern14.P.union("Int", "Float", "Decimal", "BigInt"), (type2) => this.makeNumberFilterSchema(this.makePrimitiveSchema(type2), optional)).with("Boolean", () => this.makeBooleanFilterSchema(optional)).with("DateTime", () => this.makeDateTimeFilterSchema(optional)).with("Bytes", () => this.makeBytesFilterSchema(optional)).exhaustive();
   }
   makeDateTimeFilterSchema(optional) {
-    return this.makeCommonPrimitiveFilterSchema(import_zod.z.union([
-      import_zod.z.string().datetime(),
-      import_zod.z.date()
-    ]), optional, () => import_zod.z.lazy(() => this.makeDateTimeFilterSchema(optional)));
+    return this.makeCommonPrimitiveFilterSchema(import_v4.z.union([
+      import_v4.z.string().datetime(),
+      import_v4.z.date()
+    ]), optional, () => import_v4.z.lazy(() => this.makeDateTimeFilterSchema(optional)));
   }
   makeBooleanFilterSchema(optional) {
-    return import_zod.z.union([
-      this.nullableIf(import_zod.z.boolean(), optional),
-      import_zod.z.object({
-        equals: this.nullableIf(import_zod.z.boolean(), optional).optional(),
-        not: import_zod.z.lazy(() => this.makeBooleanFilterSchema(optional)).optional()
+    return import_v4.z.union([
+      this.nullableIf(import_v4.z.boolean(), optional),
+      import_v4.z.object({
+        equals: this.nullableIf(import_v4.z.boolean(), optional).optional(),
+        not: import_v4.z.lazy(() => this.makeBooleanFilterSchema(optional)).optional()
       })
     ]);
   }
   makeBytesFilterSchema(optional) {
-    const baseSchema = import_zod.z.instanceof(Uint8Array);
-    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_zod.z.instanceof(Uint8Array));
-    return import_zod.z.union([
+    const baseSchema = import_v4.z.instanceof(Uint8Array);
+    const components = this.makeCommonPrimitiveFilterComponents(baseSchema, optional, () => import_v4.z.instanceof(Uint8Array));
+    return import_v4.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod.z.object({
+      import_v4.z.object({
         equals: components.equals,
         in: components.in,
         notIn: components.notIn,
@@ -4238,16 +4237,16 @@ var InputValidator = class {
     };
   }
   makeCommonPrimitiveFilterSchema(baseSchema, optional, makeThis) {
-    return import_zod.z.union([
+    return import_v4.z.union([
       this.nullableIf(baseSchema, optional),
-      import_zod.z.object(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis))
+      import_v4.z.object(this.makeCommonPrimitiveFilterComponents(baseSchema, optional, makeThis))
     ]);
   }
   makeNumberFilterSchema(baseSchema, optional) {
-    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => import_zod.z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional)));
+    return this.makeCommonPrimitiveFilterSchema(baseSchema, optional, () => import_v4.z.lazy(() => this.makeNumberFilterSchema(baseSchema, optional)));
   }
   makeStringFilterSchema(optional) {
-    return this.makeCommonPrimitiveFilterSchema(import_zod.z.string(), optional, () => import_zod.z.lazy(() => this.makeStringFilterSchema(optional)));
+    return this.makeCommonPrimitiveFilterSchema(import_v4.z.string(), optional, () => import_v4.z.lazy(() => this.makeStringFilterSchema(optional)));
   }
   makeSelectSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4255,33 +4254,33 @@ var InputValidator = class {
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
-        fields[field] = import_zod.z.union([
-          import_zod.z.literal(true),
-          import_zod.z.object({
-            select: import_zod.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
-            include: import_zod.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional()
+        fields[field] = import_v4.z.union([
+          import_v4.z.literal(true),
+          import_v4.z.object({
+            select: import_v4.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
+            include: import_v4.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional()
           })
         ]).optional();
       } else {
-        fields[field] = import_zod.z.boolean().optional();
+        fields[field] = import_v4.z.boolean().optional();
       }
     }
     const toManyRelations = Object.entries(modelDef.fields).filter(([, value]) => value.relation && value.array);
     if (toManyRelations.length > 0) {
-      fields["_count"] = import_zod.z.union([
-        import_zod.z.literal(true),
-        import_zod.z.object(toManyRelations.reduce((acc, [name, fieldDef]) => ({
+      fields["_count"] = import_v4.z.union([
+        import_v4.z.literal(true),
+        import_v4.z.object(toManyRelations.reduce((acc, [name, fieldDef]) => ({
           ...acc,
-          [name]: import_zod.z.union([
-            import_zod.z.boolean(),
-            import_zod.z.object({
+          [name]: import_v4.z.union([
+            import_v4.z.boolean(),
+            import_v4.z.object({
               where: this.makeWhereSchema(fieldDef.type, false, false)
             })
           ]).optional()
         }), {}))
       ]).optional();
     }
-    return import_zod.z.object(fields).strict();
+    return import_v4.z.object(fields).strict();
   }
   makeOmitSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4289,10 +4288,10 @@ var InputValidator = class {
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation) {
-        fields[field] = import_zod.z.boolean().optional();
+        fields[field] = import_v4.z.boolean().optional();
       }
     }
-    return import_zod.z.object(fields).strict();
+    return import_v4.z.object(fields).strict();
   }
   makeIncludeSchema(model) {
     const modelDef = requireModel(this.schema, model);
@@ -4300,40 +4299,40 @@ var InputValidator = class {
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
-        fields[field] = import_zod.z.union([
-          import_zod.z.literal(true),
-          import_zod.z.object({
-            select: import_zod.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
-            include: import_zod.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional(),
-            where: import_zod.z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
+        fields[field] = import_v4.z.union([
+          import_v4.z.literal(true),
+          import_v4.z.object({
+            select: import_v4.z.lazy(() => this.makeSelectSchema(fieldDef.type)).optional(),
+            include: import_v4.z.lazy(() => this.makeIncludeSchema(fieldDef.type)).optional(),
+            where: import_v4.z.lazy(() => this.makeWhereSchema(fieldDef.type, false)).optional()
           })
         ]).optional();
       }
     }
-    return import_zod.z.object(fields).strict();
+    return import_v4.z.object(fields).strict();
   }
   makeOrderBySchema(model, withRelation, WithAggregation) {
     const modelDef = requireModel(this.schema, model);
     const fields = {};
-    const sort = import_zod.z.union([
-      import_zod.z.literal("asc"),
-      import_zod.z.literal("desc")
+    const sort = import_v4.z.union([
+      import_v4.z.literal("asc"),
+      import_v4.z.literal("desc")
     ]);
     for (const field of Object.keys(modelDef.fields)) {
       const fieldDef = requireField(this.schema, model, field);
       if (fieldDef.relation) {
         if (withRelation) {
-          fields[field] = import_zod.z.lazy(() => this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation).optional());
+          fields[field] = import_v4.z.lazy(() => this.makeOrderBySchema(fieldDef.type, withRelation, WithAggregation).optional());
         }
       } else {
         if (fieldDef.optional) {
-          fields[field] = import_zod.z.union([
+          fields[field] = import_v4.z.union([
             sort,
-            import_zod.z.object({
+            import_v4.z.object({
               sort,
-              nulls: import_zod.z.union([
-                import_zod.z.literal("first"),
-                import_zod.z.literal("last")
+              nulls: import_v4.z.union([
+                import_v4.z.literal("first"),
+                import_v4.z.literal("last")
               ])
             })
           ]).optional();
@@ -4351,15 +4350,15 @@ var InputValidator = class {
         "_max"
       ];
       for (const agg of aggregationFields) {
-        fields[agg] = import_zod.z.lazy(() => this.makeOrderBySchema(model, true, false).optional());
+        fields[agg] = import_v4.z.lazy(() => this.makeOrderBySchema(model, true, false).optional());
       }
     }
-    return import_zod.z.object(fields);
+    return import_v4.z.object(fields);
   }
   makeDistinctSchema(model) {
     const modelDef = requireModel(this.schema, model);
     const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
-    return this.orArray(import_zod.z.enum(nonRelationFields), true);
+    return this.orArray(import_v4.z.enum(nonRelationFields), true);
   }
   makeCursorSchema(model) {
     return this.makeWhereSchema(model, true, true).optional();
@@ -4368,7 +4367,7 @@ var InputValidator = class {
   // #region Create
   makeCreateSchema(model) {
     const dataSchema = this.makeCreateDataSchema(model, false);
-    const schema = import_zod.z.object({
+    const schema = import_v4.z.object({
       data: dataSchema,
       select: this.makeSelectSchema(model).optional(),
       include: this.makeIncludeSchema(model).optional(),
@@ -4381,7 +4380,7 @@ var InputValidator = class {
   }
   makeCreateManyAndReturnSchema(model) {
     const base = this.makeCreateManyDataSchema(model, []);
-    const result = base.merge(import_zod.z.object({
+    const result = base.merge(import_v4.z.object({
       select: this.makeSelectSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
     }));
@@ -4413,7 +4412,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = import_zod.z.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "create"));
+        let fieldSchema = import_v4.z.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "create"));
         if (fieldDef.optional || fieldDef.array) {
           fieldSchema = fieldSchema.optional();
         } else {
@@ -4435,10 +4434,10 @@ var InputValidator = class {
       } else {
         let fieldSchema = this.makePrimitiveSchema(fieldDef.type);
         if (fieldDef.array) {
-          fieldSchema = import_zod.z.union([
-            import_zod.z.array(fieldSchema),
-            import_zod.z.object({
-              set: import_zod.z.array(fieldSchema)
+          fieldSchema = import_v4.z.union([
+            import_v4.z.array(fieldSchema),
+            import_v4.z.object({
+              set: import_v4.z.array(fieldSchema)
             })
           ]).optional();
         }
@@ -4455,16 +4454,16 @@ var InputValidator = class {
       }
     });
     if (!hasRelation) {
-      return this.orArray(import_zod.z.object(regularAndFkFields).strict(), canBeArray);
+      return this.orArray(import_v4.z.object(regularAndFkFields).strict(), canBeArray);
     } else {
-      return import_zod.z.union([
-        import_zod.z.object(regularAndFkFields).strict(),
-        import_zod.z.object(regularAndRelationFields).strict(),
+      return import_v4.z.union([
+        import_v4.z.object(regularAndFkFields).strict(),
+        import_v4.z.object(regularAndRelationFields).strict(),
         ...canBeArray ? [
-          import_zod.z.array(import_zod.z.object(regularAndFkFields).strict())
+          import_v4.z.array(import_v4.z.object(regularAndFkFields).strict())
         ] : [],
         ...canBeArray ? [
-          import_zod.z.array(import_zod.z.object(regularAndRelationFields).strict())
+          import_v4.z.array(import_v4.z.object(regularAndRelationFields).strict())
         ] : []
       ]);
     }
@@ -4485,31 +4484,31 @@ var InputValidator = class {
         fields["disconnect"] = this.makeDisconnectDataSchema(fieldType, array).optional();
         fields["delete"] = this.makeDeleteRelationDataSchema(fieldType, array, true).optional();
       }
-      fields["update"] = array ? this.orArray(import_zod.z.object({
+      fields["update"] = array ? this.orArray(import_v4.z.object({
         where: this.makeWhereSchema(fieldType, true),
         data: this.makeUpdateDataSchema(fieldType, withoutFields)
-      }), true).optional() : import_zod.z.union([
-        import_zod.z.object({
+      }), true).optional() : import_v4.z.union([
+        import_v4.z.object({
           where: this.makeWhereSchema(fieldType, true),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }),
         this.makeUpdateDataSchema(fieldType, withoutFields)
       ]).optional();
-      fields["upsert"] = this.orArray(import_zod.z.object({
+      fields["upsert"] = this.orArray(import_v4.z.object({
         where: this.makeWhereSchema(fieldType, true),
         create: this.makeCreateDataSchema(fieldType, false, withoutFields),
         update: this.makeUpdateDataSchema(fieldType, withoutFields)
       }), true).optional();
       if (array) {
         fields["set"] = this.makeSetDataSchema(fieldType, true).optional();
-        fields["updateMany"] = this.orArray(import_zod.z.object({
+        fields["updateMany"] = this.orArray(import_v4.z.object({
           where: this.makeWhereSchema(fieldType, false, true),
           data: this.makeUpdateDataSchema(fieldType, withoutFields)
         }), true).optional();
         fields["deleteMany"] = this.makeDeleteRelationDataSchema(fieldType, true, false).optional();
       }
     }
-    return import_zod.z.object(fields).strict().refine((v) => Object.keys(v).length > 0, "At least one action is required");
+    return import_v4.z.object(fields).strict().refine((v) => Object.keys(v).length > 0, "At least one action is required");
   }
   makeSetDataSchema(model, canBeArray) {
     return this.orArray(this.makeWhereSchema(model, true), canBeArray);
@@ -4521,36 +4520,36 @@ var InputValidator = class {
     if (canBeArray) {
       return this.orArray(this.makeWhereSchema(model, true), canBeArray);
     } else {
-      return import_zod.z.union([
-        import_zod.z.boolean(),
+      return import_v4.z.union([
+        import_v4.z.boolean(),
         this.makeWhereSchema(model, false)
       ]);
     }
   }
   makeDeleteRelationDataSchema(model, toManyRelation, uniqueFilter) {
-    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : import_zod.z.union([
-      import_zod.z.boolean(),
+    return toManyRelation ? this.orArray(this.makeWhereSchema(model, uniqueFilter), true) : import_v4.z.union([
+      import_v4.z.boolean(),
       this.makeWhereSchema(model, uniqueFilter)
     ]);
   }
   makeConnectOrCreateDataSchema(model, canBeArray, withoutFields) {
     const whereSchema = this.makeWhereSchema(model, true);
     const createSchema = this.makeCreateDataSchema(model, false, withoutFields);
-    return this.orArray(import_zod.z.object({
+    return this.orArray(import_v4.z.object({
       where: whereSchema,
       create: createSchema
     }).strict(), canBeArray);
   }
   makeCreateManyDataSchema(model, withoutFields) {
-    return import_zod.z.object({
+    return import_v4.z.object({
       data: this.makeCreateDataSchema(model, true, withoutFields, true),
-      skipDuplicates: import_zod.z.boolean().optional()
+      skipDuplicates: import_v4.z.boolean().optional()
     }).strict();
   }
   // #endregion
   // #region Update
   makeUpdateSchema(model) {
-    const schema = import_zod.z.object({
+    const schema = import_v4.z.object({
       where: this.makeWhereSchema(model, true),
       data: this.makeUpdateDataSchema(model),
       select: this.makeSelectSchema(model).optional(),
@@ -4560,22 +4559,22 @@ var InputValidator = class {
     return this.refineForSelectIncludeMutuallyExclusive(schema);
   }
   makeUpdateManySchema(model) {
-    return import_zod.z.object({
+    return import_v4.z.object({
       where: this.makeWhereSchema(model, false).optional(),
       data: this.makeUpdateDataSchema(model, [], true),
-      limit: import_zod.z.number().int().nonnegative().optional()
+      limit: import_v4.z.number().int().nonnegative().optional()
     }).strict();
   }
   makeUpdateManyAndReturnSchema(model) {
     const base = this.makeUpdateManySchema(model);
-    const result = base.merge(import_zod.z.object({
+    const result = base.merge(import_v4.z.object({
       select: this.makeSelectSchema(model).optional(),
       omit: this.makeOmitSchema(model).optional()
     }));
     return this.refineForSelectOmitMutuallyExclusive(result);
   }
   makeUpsertSchema(model) {
-    const schema = import_zod.z.object({
+    const schema = import_v4.z.object({
       where: this.makeWhereSchema(model, true),
       create: this.makeCreateDataSchema(model, false),
       update: this.makeUpdateDataSchema(model),
@@ -4608,7 +4607,7 @@ var InputValidator = class {
             excludeFields.push(...oppositeFieldDef.relation.fields);
           }
         }
-        let fieldSchema = import_zod.z.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "update")).optional();
+        let fieldSchema = import_v4.z.lazy(() => this.makeRelationManipulationSchema(fieldDef, excludeFields, "update")).optional();
         if (fieldDef.optional && !fieldDef.array) {
           fieldSchema = fieldSchema.nullable();
         }
@@ -4616,22 +4615,22 @@ var InputValidator = class {
       } else {
         let fieldSchema = this.makePrimitiveSchema(fieldDef.type).optional();
         if (this.isNumericField(fieldDef)) {
-          fieldSchema = import_zod.z.union([
+          fieldSchema = import_v4.z.union([
             fieldSchema,
-            import_zod.z.object({
-              set: this.nullableIf(import_zod.z.number().optional(), !!fieldDef.optional),
-              increment: import_zod.z.number().optional(),
-              decrement: import_zod.z.number().optional(),
-              multiply: import_zod.z.number().optional(),
-              divide: import_zod.z.number().optional()
+            import_v4.z.object({
+              set: this.nullableIf(import_v4.z.number().optional(), !!fieldDef.optional),
+              increment: import_v4.z.number().optional(),
+              decrement: import_v4.z.number().optional(),
+              multiply: import_v4.z.number().optional(),
+              divide: import_v4.z.number().optional()
             }).refine((v) => Object.keys(v).length === 1, 'Only one of "set", "increment", "decrement", "multiply", or "divide" can be provided')
           ]);
         }
         if (fieldDef.array) {
-          fieldSchema = import_zod.z.union([
+          fieldSchema = import_v4.z.union([
             fieldSchema.array(),
-            import_zod.z.object({
-              set: import_zod.z.array(fieldSchema).optional(),
+            import_v4.z.object({
+              set: import_v4.z.array(fieldSchema).optional(),
               push: this.orArray(fieldSchema, true).optional()
             }).refine((v) => Object.keys(v).length === 1, 'Only one of "set", "push" can be provided')
           ]).optional();
@@ -4646,18 +4645,18 @@ var InputValidator = class {
       }
     });
     if (!hasRelation) {
-      return import_zod.z.object(regularAndFkFields).strict();
+      return import_v4.z.object(regularAndFkFields).strict();
     } else {
-      return import_zod.z.union([
-        import_zod.z.object(regularAndFkFields).strict(),
-        import_zod.z.object(regularAndRelationFields).strict()
+      return import_v4.z.union([
+        import_v4.z.object(regularAndFkFields).strict(),
+        import_v4.z.object(regularAndRelationFields).strict()
       ]);
     }
   }
   // #endregion
   // #region Delete
   makeDeleteSchema(model) {
-    const schema = import_zod.z.object({
+    const schema = import_v4.z.object({
       where: this.makeWhereSchema(model, true),
       select: this.makeSelectSchema(model).optional(),
       include: this.makeIncludeSchema(model).optional()
@@ -4665,30 +4664,30 @@ var InputValidator = class {
     return this.refineForSelectIncludeMutuallyExclusive(schema);
   }
   makeDeleteManySchema(model) {
-    return import_zod.z.object({
+    return import_v4.z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      limit: import_zod.z.number().int().nonnegative().optional()
+      limit: import_v4.z.number().int().nonnegative().optional()
     }).strict().optional();
   }
   // #endregion
   // #region Count
   makeCountSchema(model) {
-    return import_zod.z.object({
+    return import_v4.z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      skip: import_zod.z.number().int().nonnegative().optional(),
-      take: import_zod.z.number().int().optional(),
+      skip: import_v4.z.number().int().nonnegative().optional(),
+      take: import_v4.z.number().int().optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, true, false), true).optional(),
       select: this.makeCountAggregateInputSchema(model).optional()
     }).strict().optional();
   }
   makeCountAggregateInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return import_zod.z.union([
-      import_zod.z.literal(true),
-      import_zod.z.object({
-        _all: import_zod.z.literal(true).optional(),
+    return import_v4.z.union([
+      import_v4.z.literal(true),
+      import_v4.z.object({
+        _all: import_v4.z.literal(true).optional(),
         ...Object.keys(modelDef.fields).reduce((acc, field) => {
-          acc[field] = import_zod.z.literal(true).optional();
+          acc[field] = import_v4.z.literal(true).optional();
           return acc;
         }, {})
       }).strict()
@@ -4697,10 +4696,10 @@ var InputValidator = class {
   // #endregion
   // #region Aggregate
   makeAggregateSchema(model) {
-    return import_zod.z.object({
+    return import_v4.z.object({
       where: this.makeWhereSchema(model, false).optional(),
-      skip: import_zod.z.number().int().nonnegative().optional(),
-      take: import_zod.z.number().int().optional(),
+      skip: import_v4.z.number().int().nonnegative().optional(),
+      take: import_v4.z.number().int().optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, true, false), true).optional(),
       _count: this.makeCountAggregateInputSchema(model).optional(),
       _avg: this.makeSumAvgInputSchema(model).optional(),
@@ -4711,20 +4710,20 @@ var InputValidator = class {
   }
   makeSumAvgInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return import_zod.z.object(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return import_v4.z.object(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (this.isNumericField(fieldDef)) {
-        acc[field] = import_zod.z.literal(true).optional();
+        acc[field] = import_v4.z.literal(true).optional();
       }
       return acc;
     }, {}));
   }
   makeMinMaxInputSchema(model) {
     const modelDef = requireModel(this.schema, model);
-    return import_zod.z.object(Object.keys(modelDef.fields).reduce((acc, field) => {
+    return import_v4.z.object(Object.keys(modelDef.fields).reduce((acc, field) => {
       const fieldDef = requireField(this.schema, model, field);
       if (!fieldDef.relation && !fieldDef.array) {
-        acc[field] = import_zod.z.literal(true).optional();
+        acc[field] = import_v4.z.literal(true).optional();
       }
       return acc;
     }, {}));
@@ -4732,13 +4731,13 @@ var InputValidator = class {
   makeGroupBySchema(model) {
     const modelDef = requireModel(this.schema, model);
     const nonRelationFields = Object.keys(modelDef.fields).filter((field) => !modelDef.fields[field]?.relation);
-    let schema = import_zod.z.object({
+    let schema = import_v4.z.object({
       where: this.makeWhereSchema(model, false).optional(),
       orderBy: this.orArray(this.makeOrderBySchema(model, false, true), true).optional(),
-      by: this.orArray(import_zod.z.enum(nonRelationFields), true),
+      by: this.orArray(import_v4.z.enum(nonRelationFields), true),
       having: this.makeWhereSchema(model, false, true).optional(),
-      skip: import_zod.z.number().int().nonnegative().optional(),
-      take: import_zod.z.number().int().optional(),
+      skip: import_v4.z.number().int().nonnegative().optional(),
+      take: import_v4.z.number().int().optional(),
       _count: this.makeCountAggregateInputSchema(model).optional(),
       _avg: this.makeSumAvgInputSchema(model).optional(),
       _sum: this.makeSumAvgInputSchema(model).optional(),
@@ -4779,9 +4778,9 @@ var InputValidator = class {
     return nullable ? schema.nullable() : schema;
   }
   orArray(schema, canBeArray) {
-    return canBeArray ? import_zod.z.union([
+    return canBeArray ? import_v4.z.union([
       schema,
-      import_zod.z.array(schema)
+      import_v4.z.array(schema)
     ]) : schema;
   }
   isNumericField(fieldDef) {
@@ -4955,11 +4954,11 @@ var QueryNameMapper = class extends import_kysely12.OperationNodeTransformer {
     __name(this, "QueryNameMapper");
   }
   schema;
-  modelToTableMap;
-  fieldToColumnMap;
-  modelStack;
+  modelToTableMap = /* @__PURE__ */ new Map();
+  fieldToColumnMap = /* @__PURE__ */ new Map();
+  modelStack = [];
   constructor(schema) {
-    super(), this.schema = schema, this.modelToTableMap = /* @__PURE__ */ new Map(), this.fieldToColumnMap = /* @__PURE__ */ new Map(), this.modelStack = [];
+    super(), this.schema = schema;
     for (const [modelName, modelDef] of Object.entries(schema.models)) {
       const mappedName = this.getMappedName(modelDef);
       if (mappedName) {
@@ -5416,8 +5415,8 @@ __export(functions_exports, {
   search: () => search,
   startsWith: () => startsWith
 });
+var import_common_helpers9 = require("@zenstackhq/common-helpers");
 var import_kysely14 = require("kysely");
-var import_tiny_invariant8 = __toESM(require("tiny-invariant"), 1);
 var import_ts_pattern16 = require("ts-pattern");
 var contains = /* @__PURE__ */ __name((eb, args) => {
   const [field, search2, caseInsensitive = false] = args;
@@ -5523,8 +5522,8 @@ var currentOperation = /* @__PURE__ */ __name((_eb, args, { operation }) => {
 }, "currentOperation");
 function processCasing(casing, result, model) {
   const opNode = casing.toOperationNode();
-  (0, import_tiny_invariant8.default)(import_kysely14.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
-  result = (0, import_ts_pattern16.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => `${result.charAt(0).toUpperCase() + result.slice(1)}`).with("uncapitalize", () => `${result.charAt(0).toLowerCase() + result.slice(1)}`).otherwise(() => {
+  (0, import_common_helpers9.invariant)(import_kysely14.ValueNode.is(opNode) && typeof opNode.value === "string", '"casting" parameter must be a string value');
+  result = (0, import_ts_pattern16.match)(opNode.value).with("original", () => model).with("upper", () => result.toUpperCase()).with("lower", () => result.toLowerCase()).with("capitalize", () => (0, import_common_helpers9.upperCaseFirst)(result)).with("uncapitalize", () => (0, import_common_helpers9.lowerCaseFirst)(result)).otherwise(() => {
     throw new Error(`Invalid casing value: ${opNode.value}. Must be "original", "upper", "lower", "capitalize", or "uncapitalize".`);
   });
   return result;
@@ -5532,8 +5531,8 @@ function processCasing(casing, result, model) {
 __name(processCasing, "processCasing");
 
 // src/client/helpers/schema-db-pusher.ts
+var import_common_helpers10 = require("@zenstackhq/common-helpers");
 var import_kysely15 = require("kysely");
-var import_tiny_invariant9 = __toESM(require("tiny-invariant"), 1);
 var import_ts_pattern17 = require("ts-pattern");
 var SchemaDbPusher = class {
   static {
@@ -5565,7 +5564,7 @@ var SchemaDbPusher = class {
     for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) {
       if (fieldDef.relation) {
         table = this.addForeignKeyConstraint(table, model, fieldName, fieldDef);
-      } else {
+      } else if (!this.isComputedField(fieldDef)) {
         table = this.createModelField(table, fieldName, fieldDef, modelDef);
       }
     }
@@ -5573,6 +5572,9 @@ var SchemaDbPusher = class {
     table = this.addUniqueConstraint(table, modelDef);
     return table;
   }
+  isComputedField(fieldDef) {
+    return fieldDef.attributes?.some((a) => a.name === "@computed");
+  }
   addPrimaryKeyConstraint(table, model, modelDef) {
     if (modelDef.idFields.length === 1) {
       if (Object.values(modelDef.fields).some((f) => f.id)) {
@@ -5586,7 +5588,7 @@ var SchemaDbPusher = class {
   }
   addUniqueConstraint(table, modelDef) {
     for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
-      (0, import_tiny_invariant9.default)(typeof value === "object", "expecting an object");
+      (0, import_common_helpers10.invariant)(typeof value === "object", "expecting an object");
       if ("type" in value) {
         const fieldDef = modelDef.fields[key];
         if (fieldDef.unique) {
@@ -5645,7 +5647,7 @@ var SchemaDbPusher = class {
     return fieldDef.default && ExpressionUtils.isCall(fieldDef.default) && fieldDef.default.function === "autoincrement";
   }
   addForeignKeyConstraint(table, model, fieldName, fieldDef) {
-    (0, import_tiny_invariant9.default)(fieldDef.relation, "field must be a relation");
+    (0, import_common_helpers10.invariant)(fieldDef.relation, "field must be a relation");
     if (!fieldDef.relation.fields || !fieldDef.relation.references) {
       return table;
     }
@@ -5699,8 +5701,8 @@ function valueToPromise(thing) {
 __name(valueToPromise, "valueToPromise");
 
 // src/client/result-processor.ts
+var import_common_helpers11 = require("@zenstackhq/common-helpers");
 var import_decimal2 = __toESM(require("decimal.js"), 1);
-var import_tiny_invariant10 = __toESM(require("tiny-invariant"), 1);
 var import_ts_pattern18 = require("ts-pattern");
 var ResultProcessor = class {
   static {
@@ -5780,14 +5782,14 @@ var ResultProcessor = class {
     if (value instanceof import_decimal2.default) {
       return value;
     }
-    (0, import_tiny_invariant10.default)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal2.default, `Expected string, number or Decimal, got ${typeof value}`);
+    (0, import_common_helpers11.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal2.default, `Expected string, number or Decimal, got ${typeof value}`);
     return new import_decimal2.default(value);
   }
   transformBigInt(value) {
     if (typeof value === "bigint") {
       return value;
     }
-    (0, import_tiny_invariant10.default)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
+    (0, import_common_helpers11.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
     return BigInt(value);
   }
   transformBoolean(value) {
@@ -5934,12 +5936,19 @@ var ClientImpl = class _ClientImpl {
     const newOptions = {
       ...this.options,
       plugins: [
-        ...this.options?.plugins ?? [],
+        ...this.options.plugins ?? [],
         plugin
       ]
     };
     return new _ClientImpl(this.schema, newOptions, this);
   }
+  $unuse(pluginId) {
+    const newOptions = {
+      ...this.options,
+      plugins: this.options.plugins?.filter((p) => p.id !== pluginId)
+    };
+    return new _ClientImpl(this.schema, newOptions, this);
+  }
   $unuseAll() {
     const newOptions = {
       ...this.options,
@@ -5995,22 +6004,31 @@ function createModelCrudHandler(client, model, inputValidator, resultProcessor)
         }
         return result;
       }, "proceed");
-      const context = {
-        client,
-        model,
-        operation,
-        queryArgs: args
-      };
       const plugins = [
         ...client.$options.plugins ?? []
       ];
       for (const plugin of plugins) {
-        if (plugin.onQuery) {
-          const _proceed = proceed;
-          proceed = /* @__PURE__ */ __name(() => plugin.onQuery({
-            ...context,
-            proceed: _proceed
-          }), "proceed");
+        if (plugin.onQuery && typeof plugin.onQuery === "object") {
+          for (const [_model, modelHooks] of Object.entries(plugin.onQuery)) {
+            if (_model === (0, import_common_helpers12.lowerCaseFirst)(model) || _model === "$allModels") {
+              if (modelHooks && typeof modelHooks === "object") {
+                for (const [op, opHooks] of Object.entries(modelHooks)) {
+                  if (op === operation || op === "$allOperations") {
+                    if (typeof opHooks === "function") {
+                      const _proceed = proceed;
+                      proceed = /* @__PURE__ */ __name(() => opHooks({
+                        client,
+                        model,
+                        operation,
+                        args,
+                        query: _proceed
+                      }), "proceed");
+                    }
+                  }
+                }
+              }
+            }
+          }
         }
       }
       return proceed(args);