@zenstackhq/runtime 3.0.0-alpha.2 → 3.0.0-alpha.21

package/dist/plugins/{policy.js → policy/index.js}

@@ -14,34 +14,130 @@ var RejectedByPolicyError = class extends Error {
 };
 
 // src/plugins/policy/policy-handler.ts
+import { invariant as invariant6 } from "@zenstackhq/common-helpers";
 import { AliasNode as AliasNode3, BinaryOperationNode as BinaryOperationNode3, ColumnNode as ColumnNode2, DeleteQueryNode, FromNode as FromNode2, IdentifierNode as IdentifierNode2, InsertQueryNode, OperationNodeTransformer, OperatorNode as OperatorNode3, PrimitiveValueListNode, RawNode, ReturningNode, SelectionNode as SelectionNode2, SelectQueryNode as SelectQueryNode2, TableNode as TableNode3, UpdateQueryNode, ValueNode as ValueNode3, ValuesNode, WhereNode as WhereNode2 } from "kysely";
-import invariant6 from "tiny-invariant";
-import { match as match7 } from "ts-pattern";
+import { match as match8 } from "ts-pattern";
 
 // src/client/crud/dialects/index.ts
-import { match as match4 } from "ts-pattern";
+import { match as match5 } from "ts-pattern";
 
 // src/client/crud/dialects/postgresql.ts
+import { invariant as invariant2 } from "@zenstackhq/common-helpers";
 import { sql as sql2 } from "kysely";
-import invariant2 from "tiny-invariant";
-import { match as match2 } from "ts-pattern";
+import { match as match3 } from "ts-pattern";
+
+// src/client/constants.ts
+var DELEGATE_JOINED_FIELD_PREFIX = "$delegate$";
+var LOGICAL_COMBINATORS = [
+  "AND",
+  "OR",
+  "NOT"
+];
+var AGGREGATE_OPERATORS = [
+  "_count",
+  "_sum",
+  "_avg",
+  "_min",
+  "_max"
+];
+
+// src/client/query-utils.ts
+import { match } from "ts-pattern";
+
+// src/schema/expression.ts
+var ExpressionUtils = {
+  literal: /* @__PURE__ */ __name((value) => {
+    return {
+      kind: "literal",
+      value
+    };
+  }, "literal"),
+  array: /* @__PURE__ */ __name((items) => {
+    return {
+      kind: "array",
+      items
+    };
+  }, "array"),
+  call: /* @__PURE__ */ __name((functionName, args) => {
+    return {
+      kind: "call",
+      function: functionName,
+      args
+    };
+  }, "call"),
+  binary: /* @__PURE__ */ __name((left, op, right) => {
+    return {
+      kind: "binary",
+      op,
+      left,
+      right
+    };
+  }, "binary"),
+  unary: /* @__PURE__ */ __name((op, operand) => {
+    return {
+      kind: "unary",
+      op,
+      operand
+    };
+  }, "unary"),
+  field: /* @__PURE__ */ __name((field) => {
+    return {
+      kind: "field",
+      field
+    };
+  }, "field"),
+  member: /* @__PURE__ */ __name((receiver, members) => {
+    return {
+      kind: "member",
+      receiver,
+      members
+    };
+  }, "member"),
+  _this: /* @__PURE__ */ __name(() => {
+    return {
+      kind: "this"
+    };
+  }, "_this"),
+  _null: /* @__PURE__ */ __name(() => {
+    return {
+      kind: "null"
+    };
+  }, "_null"),
+  and: /* @__PURE__ */ __name((expr2, ...expressions) => {
+    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "&&", exp), expr2);
+  }, "and"),
+  or: /* @__PURE__ */ __name((expr2, ...expressions) => {
+    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "||", exp), expr2);
+  }, "or"),
+  is: /* @__PURE__ */ __name((value, kind) => {
+    return !!value && typeof value === "object" && "kind" in value && value.kind === kind;
+  }, "is"),
+  isLiteral: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "literal"), "isLiteral"),
+  isArray: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "array"), "isArray"),
+  isCall: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "call"), "isCall"),
+  isNull: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "null"), "isNull"),
+  isThis: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "this"), "isThis"),
+  isUnary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "unary"), "isUnary"),
+  isBinary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "binary"), "isBinary"),
+  isField: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "field"), "isField"),
+  isMember: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "member"), "isMember")
+};
 
 // src/client/errors.ts
 var QueryError = class extends Error {
   static {
     __name(this, "QueryError");
   }
-  constructor(message) {
-    super(message);
+  constructor(message, cause) {
+    super(message, {
+      cause
+    });
   }
 };
 var InternalError = class extends Error {
   static {
     __name(this, "InternalError");
   }
-  constructor(message) {
-    super(message);
-  }
 };
 
 // src/client/query-utils.ts
@@ -52,7 +148,7 @@ __name(getModel, "getModel");
 function requireModel(schema, model) {
   const matchedName = Object.keys(schema.models).find((k) => k.toLowerCase() === model.toLowerCase());
   if (!matchedName) {
-    throw new QueryError(`Model "${model}" not found`);
+    throw new QueryError(`Model "${model}" not found in schema`);
   }
   return schema.models[matchedName];
 }
@@ -115,6 +211,16 @@ function getRelationForeignKeyFieldPairs(schema, model, relationField) {
   }
 }
 __name(getRelationForeignKeyFieldPairs, "getRelationForeignKeyFieldPairs");
+function isRelationField(schema, model, field) {
+  const fieldDef = getField(schema, model, field);
+  return !!fieldDef?.relation;
+}
+__name(isRelationField, "isRelationField");
+function isInheritedField(schema, model, field) {
+  const fieldDef = getField(schema, model, field);
+  return !!fieldDef?.originModel;
+}
+__name(isInheritedField, "isInheritedField");
 function getUniqueFields(schema, model) {
   const modelDef = requireModel(schema, model);
   const result = [];
@@ -151,7 +257,7 @@ function buildFieldRef(schema, model, field, options, eb, modelAlias) {
       computer = computedFields?.[model]?.[field];
     }
     if (!computer) {
-      throw new QueryError(`Computed field "${field}" implementation not provided`);
+      throw new QueryError(`Computed field "${field}" implementation not provided for model "${model}"`);
     }
     return computer(eb);
   }
@@ -228,11 +334,28 @@ function flattenCompoundUniqueFilters(schema, model, filter) {
   return result;
 }
 __name(flattenCompoundUniqueFilters, "flattenCompoundUniqueFilters");
+function getDelegateDescendantModels(schema, model, collected = /* @__PURE__ */ new Set()) {
+  const subModels = Object.values(schema.models).filter((m) => m.baseModel === model);
+  subModels.forEach((def) => {
+    if (!collected.has(def)) {
+      collected.add(def);
+      getDelegateDescendantModels(schema, def.name, collected);
+    }
+  });
+  return [
+    ...collected
+  ];
+}
+__name(getDelegateDescendantModels, "getDelegateDescendantModels");
+function aggregate(eb, expr2, op) {
+  return match(op).with("_count", () => eb.fn.count(expr2)).with("_sum", () => eb.fn.sum(expr2)).with("_avg", () => eb.fn.avg(expr2)).with("_min", () => eb.fn.min(expr2)).with("_max", () => eb.fn.max(expr2)).exhaustive();
+}
+__name(aggregate, "aggregate");
 
 // src/client/crud/dialects/base.ts
-import { sql } from "kysely";
-import invariant from "tiny-invariant";
-import { match, P } from "ts-pattern";
+import { invariant, isPlainObject } from "@zenstackhq/common-helpers";
+import { expressionBuilder, sql } from "kysely";
+import { match as match2, P } from "ts-pattern";
 
 // src/utils/enumerate.ts
 function enumerate(x) {
@@ -249,7 +372,6 @@ function enumerate(x) {
 __name(enumerate, "enumerate");
 
 // src/client/crud/dialects/base.ts
-import { isPlainObject } from "is-plain-object";
 var BaseCrudDialect = class {
   static {
     __name(this, "BaseCrudDialect");
@@ -260,9 +382,20 @@ var BaseCrudDialect = class {
     this.schema = schema;
     this.options = options;
   }
-  transformPrimitive(value, _type) {
+  transformPrimitive(value, _type, _forArrayField) {
     return value;
   }
+  // #region common query builders
+  buildSelectModel(eb, model) {
+    const modelDef = requireModel(this.schema, model);
+    let result = eb.selectFrom(model);
+    let joinBase = modelDef.baseModel;
+    while (joinBase) {
+      result = this.buildDelegateJoin(model, joinBase, result);
+      joinBase = requireModel(this.schema, joinBase).baseModel;
+    }
+    return result;
+  }
   buildFilter(eb, model, modelAlias, where) {
     if (where === true || where === void 0) {
       return this.true(eb);
@@ -279,17 +412,20 @@ var BaseCrudDialect = class {
       if (key.startsWith("$")) {
         continue;
       }
-      if (key === "AND" || key === "OR" || key === "NOT") {
+      if (this.isLogicalCombinator(key)) {
         result = this.and(eb, result, this.buildCompositeFilter(eb, model, modelAlias, key, payload));
         continue;
       }
       const fieldDef = requireField(this.schema, model, key);
       if (fieldDef.relation) {
         result = this.and(eb, result, this.buildRelationFilter(eb, model, modelAlias, key, fieldDef, payload));
-      } else if (fieldDef.array) {
-        result = this.and(eb, result, this.buildArrayFilter(eb, model, modelAlias, key, fieldDef, payload));
       } else {
-        result = this.and(eb, result, this.buildPrimitiveFilter(eb, model, modelAlias, key, fieldDef, payload));
+        const fieldRef = this.fieldRef(fieldDef.originModel ?? model, key, eb, fieldDef.originModel ?? modelAlias);
+        if (fieldDef.array) {
+          result = this.and(eb, result, this.buildArrayFilter(eb, fieldRef, fieldDef, payload));
+        } else {
+          result = this.and(eb, result, this.buildPrimitiveFilter(eb, fieldRef, fieldDef, payload));
+        }
       }
     }
     if ("$expr" in _where && typeof _where["$expr"] === "function") {
@@ -297,8 +433,11 @@ var BaseCrudDialect = class {
     }
     return result;
   }
+  isLogicalCombinator(key) {
+    return LOGICAL_COMBINATORS.includes(key);
+  }
   buildCompositeFilter(eb, model, modelAlias, key, payload) {
-    return match(key).with("AND", () => this.and(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("OR", () => this.or(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("NOT", () => eb.not(this.buildCompositeFilter(eb, model, modelAlias, "AND", payload))).exhaustive();
+    return match2(key).with("AND", () => this.and(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("OR", () => this.or(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("NOT", () => eb.not(this.buildCompositeFilter(eb, model, modelAlias, "AND", payload))).exhaustive();
   }
   buildRelationFilter(eb, model, modelAlias, field, fieldDef, payload) {
     if (!fieldDef.array) {
@@ -307,19 +446,26 @@ var BaseCrudDialect = class {
       return this.buildToManyRelationFilter(eb, model, modelAlias, field, fieldDef, payload);
     }
   }
-  buildToOneRelationFilter(eb, model, table, field, fieldDef, payload) {
+  buildToOneRelationFilter(eb, model, modelAlias, field, fieldDef, payload) {
     if (payload === null) {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, model, field);
-      if (ownedByModel) {
-        return this.and(eb, ...keyPairs.map(({ fk }) => eb(sql.ref(`${table}.${fk}`), "is", null)));
+      if (ownedByModel && !fieldDef.originModel) {
+        return this.and(eb, ...keyPairs.map(({ fk }) => eb(sql.ref(`${modelAlias}.${fk}`), "is", null)));
       } else {
-        return this.buildToOneRelationFilter(eb, model, table, field, fieldDef, {
+        return this.buildToOneRelationFilter(eb, model, modelAlias, field, fieldDef, {
           is: null
         });
       }
     }
-    const joinAlias = `${table}$${field}`;
-    const joinPairs = buildJoinPairs(this.schema, model, table, field, joinAlias);
+    const joinAlias = `${modelAlias}$${field}`;
+    const joinPairs = buildJoinPairs(
+      this.schema,
+      model,
+      // if field is from a base, use the base model to join
+      fieldDef.originModel ?? modelAlias,
+      field,
+      joinAlias
+    );
     const filterResultField = `${field}$filter`;
     const joinSelect = eb.selectFrom(`${fieldDef.type} as ${joinAlias}`).where(() => this.and(eb, ...joinPairs.map(([left, right]) => eb(sql.ref(left), "=", sql.ref(right))))).select(() => eb.fn.count(eb.lit(1)).as(filterResultField));
     const conditions = [];
@@ -380,30 +526,29 @@ var BaseCrudDialect = class {
       }
       switch (key) {
         case "some": {
-          result = this.and(eb, result, eb(eb.selectFrom(relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), ">", 0));
+          result = this.and(eb, result, eb(this.buildSelectModel(eb, relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), ">", 0));
           break;
         }
         case "every": {
-          result = this.and(eb, result, eb(eb.selectFrom(relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("count")).where(buildPkFkWhereRefs(eb)).where((eb1) => eb1.not(this.buildFilter(eb1, relationModel, relationModel, subPayload))), "=", 0));
+          result = this.and(eb, result, eb(this.buildSelectModel(eb, relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => eb1.not(this.buildFilter(eb1, relationModel, relationModel, subPayload))), "=", 0));
           break;
         }
         case "none": {
-          result = this.and(eb, result, eb(eb.selectFrom(relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), "=", 0));
+          result = this.and(eb, result, eb(this.buildSelectModel(eb, relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), "=", 0));
           break;
         }
       }
     }
     return result;
   }
-  buildArrayFilter(eb, model, modelAlias, field, fieldDef, payload) {
+  buildArrayFilter(eb, fieldRef, fieldDef, payload) {
     const clauses = [];
     const fieldType = fieldDef.type;
-    const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb, modelAlias);
     for (const [key, _value] of Object.entries(payload)) {
       if (_value === void 0) {
         continue;
       }
-      const value = this.transformPrimitive(_value, fieldType);
+      const value = this.transformPrimitive(_value, fieldType, !!fieldDef.array);
       switch (key) {
         case "equals": {
           clauses.push(this.buildLiteralFilter(eb, fieldRef, fieldType, eb.val(value)));
@@ -434,19 +579,23 @@ var BaseCrudDialect = class {
     }
     return this.and(eb, ...clauses);
   }
-  buildPrimitiveFilter(eb, model, modelAlias, field, fieldDef, payload) {
+  buildPrimitiveFilter(eb, fieldRef, fieldDef, payload) {
     if (payload === null) {
-      return eb(sql.ref(`${modelAlias}.${field}`), "is", null);
+      return eb(fieldRef, "is", null);
     }
     if (isEnum(this.schema, fieldDef.type)) {
-      return this.buildEnumFilter(eb, modelAlias, field, fieldDef, payload);
+      return this.buildEnumFilter(eb, fieldRef, fieldDef, payload);
     }
-    return match(fieldDef.type).with("String", () => this.buildStringFilter(eb, modelAlias, field, payload)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(eb, model, modelAlias, field, type, payload)).with("Boolean", () => this.buildBooleanFilter(eb, modelAlias, field, payload)).with("DateTime", () => this.buildDateTimeFilter(eb, modelAlias, field, payload)).with("Bytes", () => this.buildBytesFilter(eb, modelAlias, field, payload)).exhaustive();
+    return match2(fieldDef.type).with("String", () => this.buildStringFilter(eb, fieldRef, payload)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(eb, fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(eb, fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(eb, fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(eb, fieldRef, payload)).with("Json", () => {
+      throw new InternalError("JSON filters are not supported yet");
+    }).with("Unsupported", () => {
+      throw new QueryError(`Unsupported field cannot be used in filters`);
+    }).exhaustive();
   }
   buildLiteralFilter(eb, lhs, type, rhs) {
-    return eb(lhs, "=", rhs !== null && rhs !== void 0 ? this.transformPrimitive(rhs, type) : rhs);
+    return eb(lhs, "=", rhs !== null && rhs !== void 0 ? this.transformPrimitive(rhs, type, false) : rhs);
   }
-  buildStandardFilter(eb, type, payload, lhs, getRhs, recurse, throwIfInvalid = false, onlyForKeys = void 0) {
+  buildStandardFilter(eb, type, payload, lhs, getRhs, recurse, throwIfInvalid = false, onlyForKeys = void 0, excludeKeys = []) {
     if (payload === null || !isPlainObject(payload)) {
       return {
         conditions: [
@@ -461,8 +610,11 @@ var BaseCrudDialect = class {
       if (onlyForKeys && !onlyForKeys.includes(op)) {
         continue;
       }
+      if (excludeKeys.includes(op)) {
+        continue;
+      }
       const rhs = Array.isArray(value) ? value.map(getRhs) : getRhs(value);
-      const condition = match(op).with("equals", () => rhs === null ? eb(lhs, "is", null) : eb(lhs, "=", rhs)).with("in", () => {
+      const condition = match2(op).with("equals", () => rhs === null ? eb(lhs, "is", null) : eb(lhs, "=", rhs)).with("in", () => {
         invariant(Array.isArray(rhs), "right hand side must be an array");
         if (rhs.length === 0) {
           return this.false(eb);
@@ -476,7 +628,11 @@ var BaseCrudDialect = class {
         } else {
           return eb.not(eb(lhs, "in", rhs));
         }
-      }).with("lt", () => eb(lhs, "<", rhs)).with("lte", () => eb(lhs, "<=", rhs)).with("gt", () => eb(lhs, ">", rhs)).with("gte", () => eb(lhs, ">=", rhs)).with("not", () => eb.not(recurse(value))).otherwise(() => {
+      }).with("lt", () => eb(lhs, "<", rhs)).with("lte", () => eb(lhs, "<=", rhs)).with("gt", () => eb(lhs, ">", rhs)).with("gte", () => eb(lhs, ">=", rhs)).with("not", () => eb.not(recurse(value))).with(P.union(...AGGREGATE_OPERATORS), (op2) => {
+        const innerResult = this.buildStandardFilter(eb, type, value, aggregate(eb, lhs, op2), getRhs, recurse, throwIfInvalid);
+        consumedKeys.push(...innerResult.consumedKeys);
+        return this.and(eb, ...innerResult.conditions);
+      }).otherwise(() => {
         if (throwIfInvalid) {
           throw new QueryError(`Invalid filter key: ${op}`);
         } else {
@@ -493,24 +649,21 @@ var BaseCrudDialect = class {
       consumedKeys
     };
   }
-  buildStringFilter(eb, table, field, payload) {
-    const fieldDef = getField(this.schema, table, field);
-    let fieldRef = fieldDef?.computed ? sql.ref(field) : sql.ref(`${table}.${field}`);
-    let insensitive = false;
-    if (payload && typeof payload === "object" && "mode" in payload && payload.mode === "insensitive") {
-      insensitive = true;
-      fieldRef = eb.fn("lower", [
-        fieldRef
-      ]);
+  buildStringFilter(eb, fieldRef, payload) {
+    let mode;
+    if (payload && typeof payload === "object" && "mode" in payload) {
+      mode = payload.mode;
     }
-    const { conditions, consumedKeys } = this.buildStandardFilter(eb, "String", payload, fieldRef, (value) => this.prepStringCasing(eb, value, insensitive), (value) => this.buildStringFilter(eb, table, field, value));
+    const { conditions, consumedKeys } = this.buildStandardFilter(eb, "String", payload, mode === "insensitive" ? eb.fn("lower", [
+      fieldRef
+    ]) : fieldRef, (value) => this.prepStringCasing(eb, value, mode), (value) => this.buildStringFilter(eb, fieldRef, value));
     if (payload && typeof payload === "object") {
       for (const [key, value] of Object.entries(payload)) {
         if (key === "mode" || consumedKeys.includes(key)) {
           continue;
         }
-        const condition = match(key).with("contains", () => insensitive ? eb(fieldRef, "ilike", sql.lit(`%${value}%`)) : eb(fieldRef, "like", sql.lit(`%${value}%`))).with("startsWith", () => insensitive ? eb(fieldRef, "ilike", sql.lit(`${value}%`)) : eb(fieldRef, "like", sql.lit(`${value}%`))).with("endsWith", () => insensitive ? eb(fieldRef, "ilike", sql.lit(`%${value}`)) : eb(fieldRef, "like", sql.lit(`%${value}`))).otherwise(() => {
-          throw new Error(`Invalid string filter key: ${key}`);
+        const condition = match2(key).with("contains", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`%${value}%`)) : eb(fieldRef, "like", sql.val(`%${value}%`))).with("startsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`${value}%`)) : eb(fieldRef, "like", sql.val(`${value}%`))).with("endsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", sql.val(`%${value}`)) : eb(fieldRef, "like", sql.val(`%${value}`))).otherwise(() => {
+          throw new QueryError(`Invalid string filter key: ${key}`);
         });
         if (condition) {
           conditions.push(condition);
@@ -519,34 +672,37 @@ var BaseCrudDialect = class {
     }
     return this.and(eb, ...conditions);
   }
-  prepStringCasing(eb, value, toLower = true) {
+  prepStringCasing(eb, value, mode) {
+    if (!mode || mode === "default") {
+      return value === null ? value : sql.val(value);
+    }
     if (typeof value === "string") {
-      return toLower ? eb.fn("lower", [
-        sql.lit(value)
-      ]) : sql.lit(value);
+      return eb.fn("lower", [
+        sql.val(value)
+      ]);
     } else if (Array.isArray(value)) {
-      return value.map((v) => this.prepStringCasing(eb, v, toLower));
+      return value.map((v) => this.prepStringCasing(eb, v, mode));
     } else {
-      return value === null ? null : sql.lit(value);
+      return value === null ? null : sql.val(value);
     }
   }
-  buildNumberFilter(eb, model, table, field, type, payload) {
-    const { conditions } = this.buildStandardFilter(eb, type, payload, buildFieldRef(this.schema, model, field, this.options, eb), (value) => this.transformPrimitive(value, type), (value) => this.buildNumberFilter(eb, model, table, field, type, value));
+  buildNumberFilter(eb, fieldRef, type, payload) {
+    const { conditions } = this.buildStandardFilter(eb, type, payload, fieldRef, (value) => this.transformPrimitive(value, type, false), (value) => this.buildNumberFilter(eb, fieldRef, type, value));
     return this.and(eb, ...conditions);
   }
-  buildBooleanFilter(eb, table, field, payload) {
-    const { conditions } = this.buildStandardFilter(eb, "Boolean", payload, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Boolean"), (value) => this.buildBooleanFilter(eb, table, field, value), true, [
+  buildBooleanFilter(eb, fieldRef, payload) {
+    const { conditions } = this.buildStandardFilter(eb, "Boolean", payload, fieldRef, (value) => this.transformPrimitive(value, "Boolean", false), (value) => this.buildBooleanFilter(eb, fieldRef, value), true, [
       "equals",
       "not"
     ]);
     return this.and(eb, ...conditions);
   }
-  buildDateTimeFilter(eb, table, field, payload) {
-    const { conditions } = this.buildStandardFilter(eb, "DateTime", payload, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "DateTime"), (value) => this.buildDateTimeFilter(eb, table, field, value), true);
+  buildDateTimeFilter(eb, fieldRef, payload) {
+    const { conditions } = this.buildStandardFilter(eb, "DateTime", payload, fieldRef, (value) => this.transformPrimitive(value, "DateTime", false), (value) => this.buildDateTimeFilter(eb, fieldRef, value), true);
     return this.and(eb, ...conditions);
   }
-  buildBytesFilter(eb, table, field, payload) {
-    const conditions = this.buildStandardFilter(eb, "Bytes", payload, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Bytes"), (value) => this.buildBytesFilter(eb, table, field, value), true, [
+  buildBytesFilter(eb, fieldRef, payload) {
+    const conditions = this.buildStandardFilter(eb, "Bytes", payload, fieldRef, (value) => this.transformPrimitive(value, "Bytes", false), (value) => this.buildBytesFilter(eb, fieldRef, value), true, [
       "equals",
       "in",
       "notIn",
@@ -554,8 +710,8 @@ var BaseCrudDialect = class {
     ]);
     return this.and(eb, ...conditions.conditions);
   }
-  buildEnumFilter(eb, table, field, fieldDef, payload) {
-    const conditions = this.buildStandardFilter(eb, "String", payload, sql.ref(`${table}.${field}`), (value) => value, (value) => this.buildEnumFilter(eb, table, field, fieldDef, value), true, [
+  buildEnumFilter(eb, fieldRef, fieldDef, payload) {
+    const conditions = this.buildStandardFilter(eb, "String", payload, fieldRef, (value) => value, (value) => this.buildEnumFilter(eb, fieldRef, fieldDef, value), true, [
       "equals",
       "in",
       "notIn",
@@ -587,9 +743,7 @@ var BaseCrudDialect = class {
           invariant(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
           for (const [k, v] of Object.entries(value)) {
             invariant(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-            result = result.orderBy((eb) => eb.fn(field.slice(1), [
-              sql.ref(k)
-            ]), sql.raw(this.negateSort(v, negated)));
+            result = result.orderBy((eb) => aggregate(eb, this.fieldRef(model, k, eb, modelAlias), field), sql.raw(this.negateSort(v, negated)));
           }
           continue;
         }
@@ -598,7 +752,7 @@ var BaseCrudDialect = class {
             invariant(value && typeof value === "object", 'invalid orderBy value for field "_count"');
             for (const [k, v] of Object.entries(value)) {
               invariant(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-              result = result.orderBy((eb) => eb.fn.count(sql.ref(k)), sql.raw(this.negateSort(v, negated)));
+              result = result.orderBy((eb) => eb.fn.count(this.fieldRef(model, k, eb, modelAlias)), sql.raw(this.negateSort(v, negated)));
             }
             continue;
           }
@@ -607,10 +761,11 @@ var BaseCrudDialect = class {
         }
         const fieldDef = requireField(this.schema, model, field);
         if (!fieldDef.relation) {
+          const fieldRef = this.fieldRef(model, field, expressionBuilder(), modelAlias);
           if (value === "asc" || value === "desc") {
-            result = result.orderBy(sql.ref(`${modelAlias}.${field}`), this.negateSort(value, negated));
+            result = result.orderBy(fieldRef, this.negateSort(value, negated));
           } else if (value && typeof value === "object" && "nulls" in value && "sort" in value && (value.sort === "asc" || value.sort === "desc") && (value.nulls === "first" || value.nulls === "last")) {
-            result = result.orderBy(sql.ref(`${modelAlias}.${field}`), sql.raw(`${this.negateSort(value.sort, negated)} nulls ${value.nulls}`));
+            result = result.orderBy(fieldRef, sql.raw(`${this.negateSort(value.sort, negated)} nulls ${value.nulls}`));
           }
         } else {
           const relationModel = fieldDef.type;
@@ -622,7 +777,7 @@ var BaseCrudDialect = class {
               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);
+                let subQuery = this.buildSelectModel(eb, relationModel);
                 const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, relationModel);
                 subQuery = subQuery.where(() => this.and(eb, ...joinPairs.map(([left, right]) => eb(sql.ref(left), "=", sql.ref(right)))));
                 subQuery = subQuery.select(() => eb.fn.count(eb.lit(1)).as("_count"));
@@ -641,14 +796,90 @@ var BaseCrudDialect = class {
     });
     return result;
   }
+  buildSelectAllFields(model, query, omit) {
+    const modelDef = requireModel(this.schema, model);
+    let result = query;
+    for (const field of Object.keys(modelDef.fields)) {
+      if (isRelationField(this.schema, model, field)) {
+        continue;
+      }
+      if (omit?.[field] === true) {
+        continue;
+      }
+      result = this.buildSelectField(result, model, model, field);
+    }
+    const descendants = getDelegateDescendantModels(this.schema, model);
+    for (const subModel of descendants) {
+      result = this.buildDelegateJoin(model, subModel.name, result);
+      result = result.select((eb) => {
+        const jsonObject = {};
+        for (const field of Object.keys(subModel.fields)) {
+          if (isRelationField(this.schema, subModel.name, field) || isInheritedField(this.schema, subModel.name, field)) {
+            continue;
+          }
+          jsonObject[field] = eb.ref(`${subModel.name}.${field}`);
+        }
+        return this.buildJsonObject(eb, jsonObject).as(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`);
+      });
+    }
+    return result;
+  }
+  buildSelectField(query, model, modelAlias, field) {
+    const fieldDef = requireField(this.schema, model, field);
+    if (fieldDef.computed) {
+      return query.select((eb) => this.fieldRef(model, field, eb, modelAlias).as(field));
+    } else if (!fieldDef.originModel) {
+      return query.select(sql.ref(`${modelAlias}.${field}`).as(field));
+    } else {
+      return this.buildSelectField(query, fieldDef.originModel, fieldDef.originModel, field);
+    }
+  }
+  buildDelegateJoin(thisModel, otherModel, query) {
+    const idFields = getIdFields(this.schema, thisModel);
+    query = query.leftJoin(otherModel, (qb) => {
+      for (const idField of idFields) {
+        qb = qb.onRef(`${thisModel}.${idField}`, "=", `${otherModel}.${idField}`);
+      }
+      return qb;
+    });
+    return query;
+  }
+  buildCountJson(model, eb, parentAlias, payload) {
+    const modelDef = requireModel(this.schema, model);
+    const toManyRelations = Object.entries(modelDef.fields).filter(([, field]) => field.relation && field.array);
+    const selections = payload === true ? {
+      select: toManyRelations.reduce((acc, [field]) => {
+        acc[field] = true;
+        return acc;
+      }, {})
+    } : payload;
+    const jsonObject = {};
+    for (const [field, value] of Object.entries(selections.select)) {
+      const fieldDef = requireField(this.schema, model, field);
+      const fieldModel = fieldDef.type;
+      const joinPairs = buildJoinPairs(this.schema, model, parentAlias, field, fieldModel);
+      let fieldCountQuery = eb.selectFrom(fieldModel).select(eb.fn.countAll().as(`_count$${field}`));
+      for (const [left, right] of joinPairs) {
+        fieldCountQuery = fieldCountQuery.whereRef(left, "=", right);
+      }
+      if (value && typeof value === "object" && "where" in value && value.where && typeof value.where === "object") {
+        const filter = this.buildFilter(eb, fieldModel, fieldModel, value.where);
+        fieldCountQuery = fieldCountQuery.where(filter);
+      }
+      jsonObject[field] = fieldCountQuery;
+    }
+    return this.buildJsonObject(eb, jsonObject);
+  }
+  // #endregion
+  // #region utils
   negateSort(sort, negated) {
     return negated ? sort === "asc" ? "desc" : "asc" : sort;
   }
   true(eb) {
-    return eb.lit(this.transformPrimitive(true, "Boolean"));
+    return eb.lit(this.transformPrimitive(true, "Boolean", false));
   }
   false(eb) {
-    return eb.lit(this.transformPrimitive(false, "Boolean"));
+    return eb.lit(this.transformPrimitive(false, "Boolean", false));
   }
   isTrue(expression) {
     const node = expression.toOperationNode();
@@ -687,6 +918,9 @@ var BaseCrudDialect = class {
   not(eb, ...args) {
     return eb.not(this.and(eb, ...args));
   }
+  fieldRef(model, field, eb, modelAlias) {
+    return buildFieldRef(this.schema, model, field, this.options, eb, modelAlias);
+  }
 };
 
 // src/client/crud/dialects/postgresql.ts
@@ -697,14 +931,18 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
   get provider() {
     return "postgresql";
   }
-  transformPrimitive(value, type) {
+  transformPrimitive(value, type, forArrayField) {
     if (value === void 0) {
       return value;
     }
     if (Array.isArray(value)) {
-      return value.map((v) => this.transformPrimitive(v, type));
+      if (type === "Json" && !forArrayField) {
+        return JSON.stringify(value);
+      } else {
+        return value.map((v) => this.transformPrimitive(v, type, false));
+      }
     } else {
-      return match2(type).with("DateTime", () => value instanceof Date ? value : typeof value === "string" ? new Date(value) : value).otherwise(() => value);
+      return match3(type).with("DateTime", () => value instanceof Date ? value : typeof value === "string" ? new Date(value) : value).with("Decimal", () => value !== null ? value.toString() : value).otherwise(() => value);
     }
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
@@ -718,7 +956,8 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
       const joinTableName = `${parentName}$${relationField}`;
       let result = eb.selectFrom(`${relationModel} as ${joinTableName}`);
       result = eb.selectFrom(() => {
-        let subQuery = eb.selectFrom(`${relationModel}`).selectAll();
+        let subQuery = this.buildSelectModel(eb, relationModel);
+        subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0);
         if (payload && typeof payload === "object") {
           if (payload.where) {
             subQuery = subQuery.where((eb2) => this.buildFilter(eb2, relationModel, relationModel, payload.where));
@@ -762,34 +1001,57 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     });
     return qb;
   }
-  buildRelationObjectArgs(relationModel, relationField, eb, payload, parentName) {
+  buildRelationObjectArgs(relationModel, relationField, eb, payload, parentAlias) {
     const relationModelDef = requireModel(this.schema, relationModel);
     const objArgs = [];
+    const descendantModels = getDelegateDescendantModels(this.schema, relationModel);
+    if (descendantModels.length > 0) {
+      objArgs.push(...descendantModels.map((subModel) => [
+        sql2.lit(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`),
+        eb.ref(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`)
+      ]).flatMap((v) => v));
+    }
     if (payload === true || !payload.select) {
       objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !(typeof payload === "object" && payload.omit?.[name] === true)).map(([field]) => [
         sql2.lit(field),
-        buildFieldRef(this.schema, relationModel, field, this.options, eb)
+        this.fieldRef(relationModel, field, eb)
       ]).flatMap((v) => v));
     } else if (payload.select) {
-      objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field]) => [
-        sql2.lit(field),
-        buildFieldRef(this.schema, relationModel, field, this.options, eb)
-      ]).flatMap((v) => v));
+      objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field, value]) => {
+        if (field === "_count") {
+          const subJson = this.buildCountJson(relationModel, eb, `${parentAlias}$${relationField}`, value);
+          return [
+            sql2.lit(field),
+            subJson
+          ];
+        } else {
+          const fieldDef = requireField(this.schema, relationModel, field);
+          const fieldValue = fieldDef.relation ? eb.ref(`${parentAlias}$${relationField}$${field}.$j`) : this.fieldRef(relationModel, field, eb);
+          return [
+            sql2.lit(field),
+            fieldValue
+          ];
+        }
+      }).flatMap((v) => v));
     }
     if (typeof payload === "object" && payload.include && typeof payload.include === "object") {
       objArgs.push(...Object.entries(payload.include).filter(([, value]) => value).map(([field]) => [
         sql2.lit(field),
-        eb.ref(`${parentName}$${relationField}$${field}.$j`)
+        // reference the synthesized JSON field
+        eb.ref(`${parentAlias}$${relationField}$${field}.$j`)
       ]).flatMap((v) => v));
     }
     return objArgs;
   }
-  buildRelationJoins(model, relationField, qb, payload, parentName) {
+  buildRelationJoins(relationModel, relationField, qb, payload, parentName) {
     let result = qb;
-    if (typeof payload === "object" && payload.include && typeof payload.include === "object") {
-      Object.entries(payload.include).filter(([, value]) => value).forEach(([field, value]) => {
-        result = this.buildRelationJSON(model, result, field, `${parentName}$${relationField}`, value);
-      });
+    if (typeof payload === "object") {
+      const selectInclude = payload.include ?? payload.select;
+      if (selectInclude && typeof selectInclude === "object") {
+        Object.entries(selectInclude).filter(([, value]) => value).filter(([field]) => isRelationField(this.schema, relationModel, field)).forEach(([field, value]) => {
+          result = this.buildRelationJSON(relationModel, result, field, `${parentName}$${relationField}`, value);
+        });
+      }
     }
     return result;
   }
@@ -829,12 +1091,15 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
       return `ARRAY[${values.map((v) => typeof v === "string" ? `'${v}'` : v)}]`;
     }
   }
+  get supportInsertWithDefault() {
+    return true;
+  }
 };
 
 // src/client/crud/dialects/sqlite.ts
+import { invariant as invariant3 } from "@zenstackhq/common-helpers";
 import { sql as sql3 } from "kysely";
-import invariant3 from "tiny-invariant";
-import { match as match3 } from "ts-pattern";
+import { match as match4 } from "ts-pattern";
 var SqliteCrudDialect = class extends BaseCrudDialect {
   static {
     __name(this, "SqliteCrudDialect");
@@ -842,26 +1107,31 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
   get provider() {
     return "sqlite";
   }
-  transformPrimitive(value, type) {
+  transformPrimitive(value, type, _forArrayField) {
     if (value === void 0) {
       return value;
     }
     if (Array.isArray(value)) {
-      return value.map((v) => this.transformPrimitive(v, type));
+      return value.map((v) => this.transformPrimitive(v, type, false));
     } else {
-      return match3(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).otherwise(() => value);
+      if (this.schema.typeDefs && type in this.schema.typeDefs) {
+        return JSON.stringify(value);
+      } else {
+        return match4(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).with("Json", () => JSON.stringify(value)).otherwise(() => value);
+      }
     }
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
     return query.select((eb) => this.buildRelationJSON(model, eb, relationField, parentAlias, payload).as(relationField));
   }
-  buildRelationJSON(model, eb, relationField, parentName, payload) {
+  buildRelationJSON(model, eb, relationField, parentAlias, payload) {
     const relationFieldDef = requireField(this.schema, model, relationField);
     const relationModel = relationFieldDef.type;
     const relationModelDef = requireModel(this.schema, relationModel);
-    const subQueryName = `${parentName}$${relationField}`;
+    const subQueryName = `${parentAlias}$${relationField}`;
     let tbl = eb.selectFrom(() => {
-      let subQuery = eb.selectFrom(relationModel).selectAll();
+      let subQuery = this.buildSelectModel(eb, relationModel);
+      subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0);
       if (payload && typeof payload === "object") {
         if (payload.where) {
           subQuery = subQuery.where((eb2) => this.buildFilter(eb2, relationModel, relationModel, payload.where));
@@ -882,14 +1152,14 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
         const relationIds = getIdFields(this.schema, relationModel);
         invariant3(parentIds.length === 1, "many-to-many relation must have exactly one id field");
         invariant3(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}`)));
+        subQuery = subQuery.where(eb(eb.ref(`${relationModel}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentAlias}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
       } else {
         const { keyPairs, ownedByModel } = getRelationForeignKeyFieldPairs(this.schema, model, relationField);
         keyPairs.forEach(({ fk, pk }) => {
           if (ownedByModel) {
-            subQuery = subQuery.whereRef(`${relationModel}.${pk}`, "=", `${parentName}.${fk}`);
+            subQuery = subQuery.whereRef(`${relationModel}.${pk}`, "=", `${parentAlias}.${fk}`);
           } else {
-            subQuery = subQuery.whereRef(`${relationModel}.${fk}`, "=", `${parentName}.${pk}`);
+            subQuery = subQuery.whereRef(`${relationModel}.${fk}`, "=", `${parentAlias}.${pk}`);
           }
         });
       }
@@ -897,31 +1167,46 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     });
     tbl = tbl.select(() => {
       const objArgs = [];
+      const descendantModels = getDelegateDescendantModels(this.schema, relationModel);
+      if (descendantModels.length > 0) {
+        objArgs.push(...descendantModels.map((subModel) => [
+          sql3.lit(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`),
+          eb.ref(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`)
+        ]).flatMap((v) => v));
+      }
       if (payload === true || !payload.select) {
         objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !(typeof payload === "object" && payload.omit?.[name] === true)).map(([field]) => [
           sql3.lit(field),
-          buildFieldRef(this.schema, relationModel, field, this.options, eb)
+          this.fieldRef(relationModel, field, eb)
         ]).flatMap((v) => v));
       } else if (payload.select) {
         objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field, value]) => {
-          const fieldDef = requireField(this.schema, relationModel, field);
-          if (fieldDef.relation) {
-            const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentName}$${relationField}`, value);
+          if (field === "_count") {
+            const subJson = this.buildCountJson(relationModel, eb, `${parentAlias}$${relationField}`, value);
             return [
               sql3.lit(field),
               subJson
             ];
           } else {
-            return [
-              sql3.lit(field),
-              buildFieldRef(this.schema, relationModel, field, this.options, eb)
-            ];
+            const fieldDef = requireField(this.schema, relationModel, field);
+            if (fieldDef.relation) {
+              const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentAlias}$${relationField}`, value);
+              return [
+                sql3.lit(field),
+                subJson
+              ];
+            } else {
+              return [
+                sql3.lit(field),
+                this.fieldRef(relationModel, field, eb)
+              ];
+            }
           }
         }).flatMap((v) => v));
       }
       if (typeof payload === "object" && payload.include && typeof payload.include === "object") {
         objArgs.push(...Object.entries(payload.include).filter(([, value]) => value).map(([field, value]) => {
-          const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentName}$${relationField}`, value);
+          const subJson = this.buildRelationJSON(relationModel, eb, field, `${parentAlias}$${relationField}`, value);
           return [
             sql3.lit(field),
             subJson
@@ -971,93 +1256,17 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
   buildArrayLiteralSQL(_values) {
     throw new Error("SQLite does not support array literals");
   }
+  get supportInsertWithDefault() {
+    return false;
+  }
 };
 
 // src/client/crud/dialects/index.ts
 function getCrudDialect(schema, options) {
-  return match4(schema.provider.type).with("sqlite", () => new SqliteCrudDialect(schema, options)).with("postgresql", () => new PostgresCrudDialect(schema, options)).exhaustive();
+  return match5(schema.provider.type).with("sqlite", () => new SqliteCrudDialect(schema, options)).with("postgresql", () => new PostgresCrudDialect(schema, options)).exhaustive();
 }
 __name(getCrudDialect, "getCrudDialect");
 
-// src/schema/expression.ts
-var ExpressionUtils = {
-  literal: /* @__PURE__ */ __name((value) => {
-    return {
-      kind: "literal",
-      value
-    };
-  }, "literal"),
-  array: /* @__PURE__ */ __name((items) => {
-    return {
-      kind: "array",
-      items
-    };
-  }, "array"),
-  call: /* @__PURE__ */ __name((functionName, args) => {
-    return {
-      kind: "call",
-      function: functionName,
-      args
-    };
-  }, "call"),
-  binary: /* @__PURE__ */ __name((left, op, right) => {
-    return {
-      kind: "binary",
-      op,
-      left,
-      right
-    };
-  }, "binary"),
-  unary: /* @__PURE__ */ __name((op, operand) => {
-    return {
-      kind: "unary",
-      op,
-      operand
-    };
-  }, "unary"),
-  field: /* @__PURE__ */ __name((field) => {
-    return {
-      kind: "field",
-      field
-    };
-  }, "field"),
-  member: /* @__PURE__ */ __name((receiver, members) => {
-    return {
-      kind: "member",
-      receiver,
-      members
-    };
-  }, "member"),
-  _this: /* @__PURE__ */ __name(() => {
-    return {
-      kind: "this"
-    };
-  }, "_this"),
-  _null: /* @__PURE__ */ __name(() => {
-    return {
-      kind: "null"
-    };
-  }, "_null"),
-  and: /* @__PURE__ */ __name((expr2, ...expressions) => {
-    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "&&", exp), expr2);
-  }, "and"),
-  or: /* @__PURE__ */ __name((expr2, ...expressions) => {
-    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "||", exp), expr2);
-  }, "or"),
-  is: /* @__PURE__ */ __name((value, kind) => {
-    return !!value && typeof value === "object" && "kind" in value && value.kind === kind;
-  }, "is"),
-  isLiteral: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "literal"), "isLiteral"),
-  isArray: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "array"), "isArray"),
-  isCall: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "call"), "isCall"),
-  isNull: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "null"), "isNull"),
-  isThis: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "this"), "isThis"),
-  isUnary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "unary"), "isUnary"),
-  isBinary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "binary"), "isBinary"),
-  isField: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "field"), "isField"),
-  isMember: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "member"), "isMember")
-};
-
 // src/utils/default-operation-node-visitor.ts
 import { OperationNodeVisitor } from "kysely";
 var DefaultOperationNodeVisitor = class extends OperationNodeVisitor {
@@ -1377,19 +1586,19 @@ var ColumnCollector = class extends DefaultOperationNodeVisitor {
 };
 
 // src/plugins/policy/expression-transformer.ts
-import { AliasNode as AliasNode2, BinaryOperationNode as BinaryOperationNode2, ColumnNode, expressionBuilder, FromNode, FunctionNode as FunctionNode2, IdentifierNode, OperatorNode as OperatorNode2, ReferenceNode as ReferenceNode2, SelectionNode, SelectQueryNode, TableNode as TableNode2, ValueListNode, ValueNode as ValueNode2, WhereNode } from "kysely";
-import invariant5 from "tiny-invariant";
-import { match as match6 } from "ts-pattern";
+import { invariant as invariant5 } from "@zenstackhq/common-helpers";
+import { AliasNode as AliasNode2, BinaryOperationNode as BinaryOperationNode2, ColumnNode, expressionBuilder as expressionBuilder2, FromNode, FunctionNode as FunctionNode2, IdentifierNode, OperatorNode as OperatorNode2, ReferenceNode as ReferenceNode2, SelectionNode, SelectQueryNode, TableNode as TableNode2, ValueListNode, ValueNode as ValueNode2, WhereNode } from "kysely";
+import { match as match7 } from "ts-pattern";
 
 // src/plugins/policy/expression-evaluator.ts
-import invariant4 from "tiny-invariant";
-import { match as match5 } from "ts-pattern";
+import { invariant as invariant4 } from "@zenstackhq/common-helpers";
+import { match as match6 } from "ts-pattern";
 var ExpressionEvaluator = class {
   static {
     __name(this, "ExpressionEvaluator");
   }
   evaluate(expression, context) {
-    const result = match5(expression).when(ExpressionUtils.isArray, (expr2) => this.evaluateArray(expr2, context)).when(ExpressionUtils.isBinary, (expr2) => this.evaluateBinary(expr2, context)).when(ExpressionUtils.isField, (expr2) => this.evaluateField(expr2, context)).when(ExpressionUtils.isLiteral, (expr2) => this.evaluateLiteral(expr2)).when(ExpressionUtils.isMember, (expr2) => this.evaluateMember(expr2, context)).when(ExpressionUtils.isUnary, (expr2) => this.evaluateUnary(expr2, context)).when(ExpressionUtils.isCall, (expr2) => this.evaluateCall(expr2, context)).when(ExpressionUtils.isThis, () => context.thisValue).when(ExpressionUtils.isNull, () => null).exhaustive();
+    const result = match6(expression).when(ExpressionUtils.isArray, (expr2) => this.evaluateArray(expr2, context)).when(ExpressionUtils.isBinary, (expr2) => this.evaluateBinary(expr2, context)).when(ExpressionUtils.isField, (expr2) => this.evaluateField(expr2, context)).when(ExpressionUtils.isLiteral, (expr2) => this.evaluateLiteral(expr2)).when(ExpressionUtils.isMember, (expr2) => this.evaluateMember(expr2, context)).when(ExpressionUtils.isUnary, (expr2) => this.evaluateUnary(expr2, context)).when(ExpressionUtils.isCall, (expr2) => this.evaluateCall(expr2, context)).when(ExpressionUtils.isThis, () => context.thisValue).when(ExpressionUtils.isNull, () => null).exhaustive();
     return result ?? null;
   }
   evaluateCall(expr2, context) {
@@ -1400,7 +1609,7 @@ var ExpressionEvaluator = class {
     }
   }
   evaluateUnary(expr2, context) {
-    return match5(expr2.op).with("!", () => !this.evaluate(expr2.operand, context)).exhaustive();
+    return match6(expr2.op).with("!", () => !this.evaluate(expr2.operand, context)).exhaustive();
   }
   evaluateMember(expr2, context) {
     let val = this.evaluate(expr2.receiver, context);
@@ -1424,7 +1633,7 @@ var ExpressionEvaluator = class {
     }
     const left = this.evaluate(expr2.left, context);
     const right = this.evaluate(expr2.right, context);
-    return match5(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", () => {
+    return match6(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 ?? [];
       invariant4(Array.isArray(_right), 'expected array for "in" operator');
       return _right.includes(left);
@@ -1438,7 +1647,7 @@ var ExpressionEvaluator = class {
       return false;
     }
     invariant4(Array.isArray(left), "expected array");
-    return match5(op).with("?", () => left.some((item) => this.evaluate(expr2.right, {
+    return match6(op).with("?", () => left.some((item) => this.evaluate(expr2.right, {
       ...context,
       thisValue: item
     }))).with("!", () => left.every((item) => this.evaluate(expr2.right, {
@@ -1454,11 +1663,11 @@ var ExpressionEvaluator = class {
 // src/plugins/policy/utils.ts
 import { AliasNode, AndNode, BinaryOperationNode, FunctionNode, OperatorNode, OrNode, ParensNode, ReferenceNode, TableNode, UnaryOperationNode, ValueNode } from "kysely";
 function trueNode(dialect) {
-  return ValueNode.createImmediate(dialect.transformPrimitive(true, "Boolean"));
+  return ValueNode.createImmediate(dialect.transformPrimitive(true, "Boolean", false));
 }
 __name(trueNode, "trueNode");
 function falseNode(dialect) {
-  return ValueNode.createImmediate(dialect.transformPrimitive(false, "Boolean"));
+  return ValueNode.createImmediate(dialect.transformPrimitive(false, "Boolean", false));
 }
 __name(falseNode, "falseNode");
 function isTrueNode(node) {
@@ -1692,7 +1901,7 @@ var ExpressionTransformer = class {
     const count = FunctionNode2.create("count", [
       ValueNode2.createImmediate(1)
     ]);
-    const predicateResult = match6(expr2.op).with("?", () => BinaryOperationNode2.create(count, OperatorNode2.create(">"), ValueNode2.createImmediate(0))).with("!", () => BinaryOperationNode2.create(count, OperatorNode2.create("="), ValueNode2.createImmediate(0))).with("^", () => BinaryOperationNode2.create(count, OperatorNode2.create("="), ValueNode2.createImmediate(0))).exhaustive();
+    const predicateResult = match7(expr2.op).with("?", () => BinaryOperationNode2.create(count, OperatorNode2.create(">"), ValueNode2.createImmediate(0))).with("!", () => BinaryOperationNode2.create(count, OperatorNode2.create("="), ValueNode2.createImmediate(0))).with("^", () => BinaryOperationNode2.create(count, OperatorNode2.create("="), ValueNode2.createImmediate(0))).exhaustive();
     return this.transform(expr2.left, {
       ...context,
       memberSelect: SelectionNode.create(AliasNode2.create(predicateResult, IdentifierNode.create("$t"))),
@@ -1716,14 +1925,14 @@ var ExpressionTransformer = class {
     }
   }
   transformValue(value, type) {
-    return ValueNode2.create(this.dialect.transformPrimitive(value, type) ?? null);
+    return ValueNode2.create(this.dialect.transformPrimitive(value, type, false) ?? null);
   }
   _unary(expr2, context) {
     invariant5(expr2.op === "!", 'only "!" operator is supported');
     return BinaryOperationNode2.create(this.transform(expr2.operand, context), this.transformOperator("!="), trueNode(this.dialect));
   }
   transformOperator(op) {
-    const mappedOp = match6(op).with("==", () => "=").otherwise(() => op);
+    const mappedOp = match7(op).with("==", () => "=").otherwise(() => op);
     return OperatorNode2.create(mappedOp);
   }
   _call(expr2, context) {
@@ -1735,7 +1944,7 @@ var ExpressionTransformer = class {
     if (!func) {
       throw new QueryError(`Function not implemented: ${expr2.function}`);
     }
-    const eb = expressionBuilder();
+    const eb = expressionBuilder2();
     return func(eb, (expr2.args ?? []).map((arg) => this.transformCallArg(eb, arg, context)), {
       dialect: this.dialect,
       model: context.model,
@@ -1959,7 +2168,7 @@ var PolicyHandler = class extends OperationNodeTransformer {
   get kysely() {
     return this.client.$qb;
   }
-  async handle(node, proceed, transaction) {
+  async handle(node, proceed) {
     if (!this.isCrudQueryNode(node)) {
       throw new RejectedByPolicyError(void 0, "non-CRUD queries are not allowed");
     }
@@ -1979,27 +2188,20 @@ var PolicyHandler = class extends OperationNodeTransformer {
     if (!mutationRequiresTransaction && !node.returning) {
       return proceed(this.transformNode(node));
     }
-    let readBackError = false;
-    const result = await transaction(async (txProceed) => {
-      if (InsertQueryNode.is(node)) {
-        await this.enforcePreCreatePolicy(node, txProceed);
-      }
-      const transformedNode = this.transformNode(node);
-      const result2 = await txProceed(transformedNode);
-      if (!this.onlyReturningId(node)) {
-        const readBackResult = await this.processReadBack(node, result2, txProceed);
-        if (readBackResult.rows.length !== result2.rows.length) {
-          readBackError = true;
-        }
-        return readBackResult;
-      } else {
-        return result2;
+    if (InsertQueryNode.is(node)) {
+      await this.enforcePreCreatePolicy(node, proceed);
+    }
+    const transformedNode = this.transformNode(node);
+    const result = await proceed(transformedNode);
+    if (!this.onlyReturningId(node)) {
+      const readBackResult = await this.processReadBack(node, result, proceed);
+      if (readBackResult.rows.length !== result.rows.length) {
+        throw new RejectedByPolicyError(mutationModel, "result is not allowed to be read back");
       }
-    });
-    if (readBackError) {
-      throw new RejectedByPolicyError(mutationModel, "result is not allowed to be read back");
+      return readBackResult;
+    } else {
+      return result;
     }
-    return result;
   }
   onlyReturningId(node) {
     if (!node.returning) {
@@ -2060,11 +2262,11 @@ var PolicyHandler = class extends OperationNodeTransformer {
       if (typeof item === "object" && item && "kind" in item) {
         invariant6(item.kind === "ValueNode", "expecting a ValueNode");
         result.push({
-          node: ValueNode3.create(this.dialect.transformPrimitive(item.value, fieldDef.type)),
+          node: ValueNode3.create(this.dialect.transformPrimitive(item.value, fieldDef.type, !!fieldDef.array)),
           raw: item.value
         });
       } else {
-        const value = this.dialect.transformPrimitive(item, fieldDef.type);
+        const value = this.dialect.transformPrimitive(item, fieldDef.type, !!fieldDef.array);
         if (Array.isArray(value)) {
           result.push({
             node: RawNode.createWithSql(this.dialect.buildArrayLiteralSQL(value)),
@@ -2133,7 +2335,7 @@ var PolicyHandler = class extends OperationNodeTransformer {
     return disjunction(this.dialect, rows.map((row) => conjunction(this.dialect, idFields.map((field) => BinaryOperationNode3.create(ColumnNode2.create(field), OperatorNode3.create("="), ValueNode3.create(row[field]))))));
   }
   getMutationModel(node) {
-    const r = match7(node).when(InsertQueryNode.is, (node2) => getTableName(node2.into)).when(UpdateQueryNode.is, (node2) => getTableName(node2.table)).when(DeleteQueryNode.is, (node2) => {
+    const r = match8(node).when(InsertQueryNode.is, (node2) => getTableName(node2.into)).when(UpdateQueryNode.is, (node2) => getTableName(node2.table)).when(DeleteQueryNode.is, (node2) => {
       if (node2.from.froms.length !== 1) {
         throw new InternalError("Only one from table is supported for delete");
       }
@@ -2295,13 +2497,22 @@ var PolicyPlugin = class {
   get description() {
     return "Enforces access policies defined in the schema.";
   }
-  onKyselyQuery({ query, client, proceed, transaction }) {
+  onKyselyQuery({
+    query,
+    client,
+    proceed
+    /*, transaction*/
+  }) {
     const handler = new PolicyHandler(client);
-    return handler.handle(query, proceed, transaction);
+    return handler.handle(
+      query,
+      proceed
+      /*, transaction*/
+    );
   }
 };
 export {
   PolicyPlugin,
   RejectedByPolicyError
 };
-//# sourceMappingURL=policy.js.map
+//# sourceMappingURL=index.js.map