@zenstackhq/runtime 3.0.0-beta.8 → 3.0.0-beta.9

package/dist/plugins/policy/index.js

@@ -1,3441 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
-// src/client/client-impl.ts
-import { invariant as invariant11 } from "@zenstackhq/common-helpers";
-import { CompiledQuery, DefaultConnectionProvider, DefaultQueryExecutor as DefaultQueryExecutor2, Kysely, Log, sql as sql9, Transaction } from "kysely";
-
-// src/client/crud/operations/aggregate.ts
-import { sql as sql5 } from "kysely";
-import { match as match7 } from "ts-pattern";
-
-// src/client/query-utils.ts
-import { invariant } from "@zenstackhq/common-helpers";
-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"),
-  not: /* @__PURE__ */ __name((expr2) => {
-    return ExpressionUtils.unary("!", expr2);
-  }, "not"),
-  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"),
-  getLiteralValue: /* @__PURE__ */ __name((expr2) => {
-    return ExpressionUtils.isLiteral(expr2) ? expr2.value : void 0;
-  }, "getLiteralValue")
-};
-
-// src/client/errors.ts
-var ZenStackError = class extends Error {
-  static {
-    __name(this, "ZenStackError");
-  }
-};
-var QueryError = class extends ZenStackError {
-  static {
-    __name(this, "QueryError");
-  }
-  constructor(message, cause) {
-    super(message, {
-      cause
-    });
-  }
-};
-var InternalError = class extends ZenStackError {
-  static {
-    __name(this, "InternalError");
-  }
-};
-
-// src/client/query-utils.ts
-function getModel(schema, model) {
-  return Object.values(schema.models).find((m) => m.name.toLowerCase() === model.toLowerCase());
-}
-__name(getModel, "getModel");
-function getTypeDef(schema, type) {
-  return schema.typeDefs?.[type];
-}
-__name(getTypeDef, "getTypeDef");
-function requireModel(schema, model) {
-  const modelDef = getModel(schema, model);
-  if (!modelDef) {
-    throw new QueryError(`Model "${model}" not found in schema`);
-  }
-  return modelDef;
-}
-__name(requireModel, "requireModel");
-function getField(schema, model, field) {
-  const modelDef = getModel(schema, model);
-  return modelDef?.fields[field];
-}
-__name(getField, "getField");
-function requireField(schema, modelOrType, field) {
-  const modelDef = getModel(schema, modelOrType);
-  if (modelDef) {
-    if (!modelDef.fields[field]) {
-      throw new QueryError(`Field "${field}" not found in model "${modelOrType}"`);
-    } else {
-      return modelDef.fields[field];
-    }
-  }
-  const typeDef = getTypeDef(schema, modelOrType);
-  if (typeDef) {
-    if (!typeDef.fields[field]) {
-      throw new QueryError(`Field "${field}" not found in type "${modelOrType}"`);
-    } else {
-      return typeDef.fields[field];
-    }
-  }
-  throw new QueryError(`Model or type "${modelOrType}" not found in schema`);
-}
-__name(requireField, "requireField");
-function requireIdFields(schema, model) {
-  const modelDef = requireModel(schema, model);
-  const result = modelDef?.idFields;
-  if (!result) {
-    throw new InternalError(`Model "${model}" does not have ID field(s)`);
-  }
-  return result;
-}
-__name(requireIdFields, "requireIdFields");
-function getRelationForeignKeyFieldPairs(schema, model, relationField) {
-  const fieldDef = requireField(schema, model, relationField);
-  if (!fieldDef?.relation) {
-    throw new InternalError(`Field "${relationField}" is not a relation`);
-  }
-  if (fieldDef.relation.fields) {
-    if (!fieldDef.relation.references) {
-      throw new InternalError(`Relation references not defined for field "${relationField}"`);
-    }
-    return {
-      keyPairs: fieldDef.relation.fields.map((f, i) => ({
-        fk: f,
-        pk: fieldDef.relation.references[i]
-      })),
-      ownedByModel: true
-    };
-  } else {
-    if (!fieldDef.relation.opposite) {
-      throw new InternalError(`Opposite relation not defined for field "${relationField}"`);
-    }
-    const oppositeField = requireField(schema, fieldDef.type, fieldDef.relation.opposite);
-    if (!oppositeField.relation) {
-      throw new InternalError(`Field "${fieldDef.relation.opposite}" is not a relation`);
-    }
-    if (!oppositeField.relation.fields) {
-      throw new InternalError(`Relation fields not defined for field "${relationField}"`);
-    }
-    if (!oppositeField.relation.references) {
-      throw new InternalError(`Relation references not defined for field "${relationField}"`);
-    }
-    return {
-      keyPairs: oppositeField.relation.fields.map((f, i) => ({
-        fk: f,
-        pk: oppositeField.relation.references[i]
-      })),
-      ownedByModel: false
-    };
-  }
-}
-__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 = [];
-  for (const [key, value] of Object.entries(modelDef.uniqueFields)) {
-    if (typeof value !== "object") {
-      throw new InternalError(`Invalid unique field definition for "${key}"`);
-    }
-    if (typeof value.type === "string") {
-      result.push({
-        name: key,
-        def: requireField(schema, model, key)
-      });
-    } else {
-      result.push({
-        name: key,
-        defs: Object.fromEntries(Object.keys(value).map((k) => [
-          k,
-          requireField(schema, model, k)
-        ]))
-      });
-    }
-  }
-  return result;
-}
-__name(getUniqueFields, "getUniqueFields");
-function buildFieldRef(schema, model, field, options, eb, modelAlias, inlineComputedField = true) {
-  const fieldDef = requireField(schema, model, field);
-  if (!fieldDef.computed) {
-    return eb.ref(modelAlias ? `${modelAlias}.${field}` : field);
-  } else {
-    if (!inlineComputedField) {
-      return eb.ref(modelAlias ? `${modelAlias}.${field}` : field);
-    }
-    let computer;
-    if ("computedFields" in options) {
-      const computedFields = options.computedFields;
-      computer = computedFields?.[model]?.[field];
-    }
-    if (!computer) {
-      throw new QueryError(`Computed field "${field}" implementation not provided for model "${model}"`);
-    }
-    return computer(eb, {
-      modelAlias
-    });
-  }
-}
-__name(buildFieldRef, "buildFieldRef");
-function isEnum(schema, type) {
-  return !!schema.enums?.[type];
-}
-__name(isEnum, "isEnum");
-function buildJoinPairs(schema, model, modelAlias, relationField, relationModelAlias) {
-  const { keyPairs, ownedByModel } = getRelationForeignKeyFieldPairs(schema, model, relationField);
-  return keyPairs.map(({ fk, pk }) => {
-    if (ownedByModel) {
-      return [
-        `${relationModelAlias}.${pk}`,
-        `${modelAlias}.${fk}`
-      ];
-    } else {
-      return [
-        `${relationModelAlias}.${fk}`,
-        `${modelAlias}.${pk}`
-      ];
-    }
-  });
-}
-__name(buildJoinPairs, "buildJoinPairs");
-function makeDefaultOrderBy(schema, model) {
-  const idFields = requireIdFields(schema, model);
-  return idFields.map((f) => ({
-    [f]: "asc"
-  }));
-}
-__name(makeDefaultOrderBy, "makeDefaultOrderBy");
-function getManyToManyRelation(schema, model, field) {
-  const fieldDef = requireField(schema, model, field);
-  if (!fieldDef.array || !fieldDef.relation?.opposite) {
-    return void 0;
-  }
-  const oppositeFieldDef = requireField(schema, fieldDef.type, fieldDef.relation.opposite);
-  if (oppositeFieldDef.array) {
-    const sortedModelNames = [
-      model,
-      fieldDef.type
-    ].sort();
-    let orderedFK;
-    if (model !== fieldDef.type) {
-      orderedFK = sortedModelNames[0] === model ? [
-        "A",
-        "B"
-      ] : [
-        "B",
-        "A"
-      ];
-    } else {
-      const sortedFieldNames = [
-        field,
-        oppositeFieldDef.name
-      ].sort();
-      orderedFK = sortedFieldNames[0] === field ? [
-        "A",
-        "B"
-      ] : [
-        "B",
-        "A"
-      ];
-    }
-    const modelIdFields = requireIdFields(schema, model);
-    invariant(modelIdFields.length === 1, "Only single-field ID is supported for many-to-many relation");
-    const otherIdFields = requireIdFields(schema, fieldDef.type);
-    invariant(otherIdFields.length === 1, "Only single-field ID is supported for many-to-many relation");
-    return {
-      parentFkName: orderedFK[0],
-      parentPKName: modelIdFields[0],
-      otherModel: fieldDef.type,
-      otherField: fieldDef.relation.opposite,
-      otherFkName: orderedFK[1],
-      otherPKName: otherIdFields[0],
-      joinTable: fieldDef.relation.name ? `_${fieldDef.relation.name}` : `_${sortedModelNames[0]}To${sortedModelNames[1]}`
-    };
-  } else {
-    return void 0;
-  }
-}
-__name(getManyToManyRelation, "getManyToManyRelation");
-function flattenCompoundUniqueFilters(schema, model, filter) {
-  if (typeof filter !== "object" || !filter) {
-    return filter;
-  }
-  const uniqueFields = getUniqueFields(schema, model);
-  const compoundUniques = uniqueFields.filter((u) => "defs" in u);
-  if (compoundUniques.length === 0) {
-    return filter;
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(filter)) {
-    if (compoundUniques.some(({ name }) => name === key)) {
-      Object.assign(result, value);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-__name(flattenCompoundUniqueFilters, "flattenCompoundUniqueFilters");
-function ensureArray(value) {
-  if (Array.isArray(value)) {
-    return value;
-  } else {
-    return [
-      value
-    ];
-  }
-}
-__name(ensureArray, "ensureArray");
-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/operations/base.ts
-import { createId } from "@paralleldrive/cuid2";
-import { invariant as invariant5, isPlainObject as isPlainObject3 } from "@zenstackhq/common-helpers";
-import { expressionBuilder as expressionBuilder2, sql as sql4 } from "kysely";
-import { nanoid } from "nanoid";
-import { match as match6 } from "ts-pattern";
-import { ulid } from "ulid";
-import * as uuid from "uuid";
-
-// src/utils/clone.ts
-import { isPlainObject } from "@zenstackhq/common-helpers";
-
-// src/utils/enumerate.ts
-function enumerate(x) {
-  if (x === null || x === void 0) {
-    return [];
-  } else if (Array.isArray(x)) {
-    return x;
-  } else {
-    return [
-      x
-    ];
-  }
-}
-__name(enumerate, "enumerate");
-
-// 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/contract.ts
-var CRUD = [
-  "create",
-  "read",
-  "update",
-  "delete"
-];
-var CRUD_EXT = [
-  ...CRUD,
-  "post-update"
-];
-
-// src/client/crud/dialects/index.ts
-import { match as match5 } from "ts-pattern";
-
-// src/client/crud/dialects/postgresql.ts
-import { invariant as invariant3 } from "@zenstackhq/common-helpers";
-import Decimal from "decimal.js";
-import { sql as sql2 } from "kysely";
-import { match as match3 } from "ts-pattern";
-
-// src/client/crud/dialects/base-dialect.ts
-import { invariant as invariant2, isPlainObject as isPlainObject2 } from "@zenstackhq/common-helpers";
-import { expressionBuilder, sql } from "kysely";
-import { match as match2, P } from "ts-pattern";
-var BaseCrudDialect = class {
-  static {
-    __name(this, "BaseCrudDialect");
-  }
-  schema;
-  options;
-  constructor(schema, options) {
-    this.schema = schema;
-    this.options = options;
-  }
-  transformPrimitive(value, _type, _forArrayField) {
-    return value;
-  }
-  transformOutput(value, _type) {
-    return value;
-  }
-  // #region common query builders
-  buildSelectModel(eb, model, modelAlias) {
-    const modelDef = requireModel(this.schema, model);
-    let result = eb.selectFrom(model === modelAlias ? model : `${model} as ${modelAlias}`);
-    let joinBase = modelDef.baseModel;
-    while (joinBase) {
-      result = this.buildDelegateJoin(model, modelAlias, joinBase, result);
-      joinBase = requireModel(this.schema, joinBase).baseModel;
-    }
-    return result;
-  }
-  buildFilterSortTake(model, args, query, modelAlias) {
-    let result = query;
-    if (args.where) {
-      result = result.where((eb) => this.buildFilter(eb, model, modelAlias, args?.where));
-    }
-    let negateOrderBy = false;
-    const skip = args.skip;
-    let take = args.take;
-    if (take !== void 0 && take < 0) {
-      negateOrderBy = true;
-      take = -take;
-    }
-    result = this.buildSkipTake(result, skip, take);
-    result = this.buildOrderBy(result, model, modelAlias, args.orderBy, skip !== void 0 || take !== void 0, negateOrderBy);
-    if ("distinct" in args && args.distinct) {
-      const distinct = ensureArray(args.distinct);
-      if (this.supportsDistinctOn) {
-        result = result.distinctOn(distinct.map((f) => sql.ref(`${modelAlias}.${f}`)));
-      } else {
-        throw new QueryError(`"distinct" is not supported by "${this.schema.provider.type}" provider`);
-      }
-    }
-    if (args.cursor) {
-      result = this.buildCursorFilter(model, result, args.cursor, args.orderBy, negateOrderBy, modelAlias);
-    }
-    return result;
-  }
-  buildFilter(eb, model, modelAlias, where) {
-    if (where === true || where === void 0) {
-      return this.true(eb);
-    }
-    if (where === false) {
-      return this.false(eb);
-    }
-    let result = this.true(eb);
-    const _where = flattenCompoundUniqueFilters(this.schema, model, where);
-    for (const [key, payload] of Object.entries(_where)) {
-      if (payload === void 0) {
-        continue;
-      }
-      if (key.startsWith("$")) {
-        continue;
-      }
-      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 {
-        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") {
-      result = this.and(eb, result, _where["$expr"](eb));
-    }
-    return result;
-  }
-  buildCursorFilter(model, query, cursor, orderBy, negateOrderBy, modelAlias) {
-    const _orderBy = orderBy ?? makeDefaultOrderBy(this.schema, model);
-    const orderByItems = ensureArray(_orderBy).flatMap((obj) => Object.entries(obj));
-    const eb = expressionBuilder();
-    const subQueryAlias = `${model}$cursor$sub`;
-    const cursorFilter = this.buildFilter(eb, model, subQueryAlias, cursor);
-    let result = query;
-    const filters = [];
-    for (let i = orderByItems.length - 1; i >= 0; i--) {
-      const andFilters = [];
-      for (let j = 0; j <= i; j++) {
-        const [field, order] = orderByItems[j];
-        const _order = negateOrderBy ? order === "asc" ? "desc" : "asc" : order;
-        const op = j === i ? _order === "asc" ? ">=" : "<=" : "=";
-        andFilters.push(eb(eb.ref(`${modelAlias}.${field}`), op, this.buildSelectModel(eb, model, subQueryAlias).select(`${subQueryAlias}.${field}`).where(cursorFilter)));
-      }
-      filters.push(eb.and(andFilters));
-    }
-    result = result.where((eb2) => eb2.or(filters));
-    return result;
-  }
-  isLogicalCombinator(key) {
-    return LOGICAL_COMBINATORS.includes(key);
-  }
-  buildCompositeFilter(eb, model, modelAlias, key, payload) {
-    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) {
-      return this.buildToOneRelationFilter(eb, model, modelAlias, field, fieldDef, payload);
-    } else {
-      return this.buildToManyRelationFilter(eb, model, modelAlias, field, fieldDef, payload);
-    }
-  }
-  buildToOneRelationFilter(eb, model, modelAlias, field, fieldDef, payload) {
-    if (payload === null) {
-      const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, model, field);
-      if (ownedByModel && !fieldDef.originModel) {
-        return this.and(eb, ...keyPairs.map(({ fk }) => eb(sql.ref(`${modelAlias}.${fk}`), "is", null)));
-      } else {
-        return this.buildToOneRelationFilter(eb, model, modelAlias, field, fieldDef, {
-          is: null
-        });
-      }
-    }
-    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 = [];
-    if ("is" in payload || "isNot" in payload) {
-      if ("is" in payload) {
-        if (payload.is === null) {
-          conditions.push(eb(joinSelect, "=", 0));
-        } else {
-          conditions.push(eb(joinSelect.where(() => this.buildFilter(eb, fieldDef.type, joinAlias, payload.is)), ">", 0));
-        }
-      }
-      if ("isNot" in payload) {
-        if (payload.isNot === null) {
-          conditions.push(eb(joinSelect, ">", 0));
-        } else {
-          conditions.push(this.or(
-            eb,
-            // is null
-            eb(joinSelect, "=", 0),
-            // found one that matches the filter
-            eb(joinSelect.where(() => this.buildFilter(eb, fieldDef.type, joinAlias, payload.isNot)), "=", 0)
-          ));
-        }
-      }
-    } else {
-      conditions.push(eb(joinSelect.where(() => this.buildFilter(eb, fieldDef.type, joinAlias, payload)), ">", 0));
-    }
-    return this.and(eb, ...conditions);
-  }
-  buildToManyRelationFilter(eb, model, modelAlias, field, fieldDef, payload) {
-    if (payload === null) {
-      return eb(sql.ref(`${modelAlias}.${field}`), "is", null);
-    }
-    const relationModel = fieldDef.type;
-    const relationFilterSelectAlias = `${modelAlias}$${field}$filter`;
-    const buildPkFkWhereRefs = /* @__PURE__ */ __name((eb2) => {
-      const m2m = getManyToManyRelation(this.schema, model, field);
-      if (m2m) {
-        const modelIdFields = requireIdFields(this.schema, model);
-        invariant2(modelIdFields.length === 1, "many-to-many relation must have exactly one id field");
-        const relationIdFields = requireIdFields(this.schema, relationModel);
-        invariant2(relationIdFields.length === 1, "many-to-many relation must have exactly one id field");
-        return eb2(sql.ref(`${relationFilterSelectAlias}.${relationIdFields[0]}`), "in", eb2.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(sql.ref(`${m2m.joinTable}.${m2m.parentFkName}`), "=", sql.ref(`${modelAlias}.${modelIdFields[0]}`)));
-      } else {
-        const relationKeyPairs = getRelationForeignKeyFieldPairs(this.schema, model, field);
-        let result2 = this.true(eb2);
-        for (const { fk, pk } of relationKeyPairs.keyPairs) {
-          if (relationKeyPairs.ownedByModel) {
-            result2 = this.and(eb2, result2, eb2(sql.ref(`${modelAlias}.${fk}`), "=", sql.ref(`${relationFilterSelectAlias}.${pk}`)));
-          } else {
-            result2 = this.and(eb2, result2, eb2(sql.ref(`${modelAlias}.${pk}`), "=", sql.ref(`${relationFilterSelectAlias}.${fk}`)));
-          }
-        }
-        return result2;
-      }
-    }, "buildPkFkWhereRefs");
-    let result = this.true(eb);
-    for (const [key, subPayload] of Object.entries(payload)) {
-      if (!subPayload) {
-        continue;
-      }
-      switch (key) {
-        case "some": {
-          result = this.and(eb, result, eb(this.buildSelectModel(eb, relationModel, relationFilterSelectAlias).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationFilterSelectAlias, subPayload)), ">", 0));
-          break;
-        }
-        case "every": {
-          result = this.and(eb, result, eb(this.buildSelectModel(eb, relationModel, relationFilterSelectAlias).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => eb1.not(this.buildFilter(eb1, relationModel, relationFilterSelectAlias, subPayload))), "=", 0));
-          break;
-        }
-        case "none": {
-          result = this.and(eb, result, eb(this.buildSelectModel(eb, relationModel, relationFilterSelectAlias).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationFilterSelectAlias, subPayload)), "=", 0));
-          break;
-        }
-      }
-    }
-    return result;
-  }
-  buildArrayFilter(eb, fieldRef, fieldDef, payload) {
-    const clauses = [];
-    const fieldType = fieldDef.type;
-    for (const [key, _value] of Object.entries(payload)) {
-      if (_value === void 0) {
-        continue;
-      }
-      const value = this.transformPrimitive(_value, fieldType, !!fieldDef.array);
-      switch (key) {
-        case "equals": {
-          clauses.push(this.buildLiteralFilter(eb, fieldRef, fieldType, eb.val(value)));
-          break;
-        }
-        case "has": {
-          clauses.push(eb(fieldRef, "@>", eb.val([
-            value
-          ])));
-          break;
-        }
-        case "hasEvery": {
-          clauses.push(eb(fieldRef, "@>", eb.val(value)));
-          break;
-        }
-        case "hasSome": {
-          clauses.push(eb(fieldRef, "&&", eb.val(value)));
-          break;
-        }
-        case "isEmpty": {
-          clauses.push(eb(fieldRef, value === true ? "=" : "!=", eb.val([])));
-          break;
-        }
-        default: {
-          throw new InternalError(`Invalid array filter key: ${key}`);
-        }
-      }
-    }
-    return this.and(eb, ...clauses);
-  }
-  buildPrimitiveFilter(eb, fieldRef, fieldDef, payload) {
-    if (payload === null) {
-      return eb(fieldRef, "is", null);
-    }
-    if (isEnum(this.schema, fieldDef.type)) {
-      return this.buildEnumFilter(eb, fieldRef, fieldDef, payload);
-    }
-    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, false) : rhs);
-  }
-  buildStandardFilter(eb, type, payload, lhs, getRhs, recurse, throwIfInvalid = false, onlyForKeys = void 0, excludeKeys = []) {
-    if (payload === null || !isPlainObject2(payload)) {
-      return {
-        conditions: [
-          this.buildLiteralFilter(eb, lhs, type, payload)
-        ],
-        consumedKeys: []
-      };
-    }
-    const conditions = [];
-    const consumedKeys = [];
-    for (const [op, value] of Object.entries(payload)) {
-      if (onlyForKeys && !onlyForKeys.includes(op)) {
-        continue;
-      }
-      if (excludeKeys.includes(op)) {
-        continue;
-      }
-      const rhs = Array.isArray(value) ? value.map(getRhs) : getRhs(value);
-      const condition = match2(op).with("equals", () => rhs === null ? eb(lhs, "is", null) : eb(lhs, "=", rhs)).with("in", () => {
-        invariant2(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", () => {
-        invariant2(Array.isArray(rhs), "right hand side must be an array");
-        if (rhs.length === 0) {
-          return this.true(eb);
-        } 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))).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 {
-          return void 0;
-        }
-      });
-      if (condition) {
-        conditions.push(condition);
-        consumedKeys.push(op);
-      }
-    }
-    return {
-      conditions,
-      consumedKeys
-    };
-  }
-  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, 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 = 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);
-        }
-      }
-    }
-    return this.and(eb, ...conditions);
-  }
-  prepStringCasing(eb, value, mode) {
-    if (!mode || mode === "default") {
-      return value === null ? value : sql.val(value);
-    }
-    if (typeof value === "string") {
-      return eb.fn("lower", [
-        sql.val(value)
-      ]);
-    } else if (Array.isArray(value)) {
-      return value.map((v) => this.prepStringCasing(eb, v, mode));
-    } else {
-      return value === null ? null : sql.val(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, 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, 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, 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",
-      "not"
-    ]);
-    return this.and(eb, ...conditions.conditions);
-  }
-  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",
-      "not"
-    ]);
-    return this.and(eb, ...conditions.conditions);
-  }
-  buildOrderBy(query, model, modelAlias, orderBy, useDefaultIfEmpty, negated) {
-    if (!orderBy) {
-      if (useDefaultIfEmpty) {
-        orderBy = makeDefaultOrderBy(this.schema, model);
-      } else {
-        return query;
-      }
-    }
-    let result = query;
-    enumerate(orderBy).forEach((orderBy2) => {
-      for (const [field, value] of Object.entries(orderBy2)) {
-        if (!value) {
-          continue;
-        }
-        if ([
-          "_count",
-          "_avg",
-          "_sum",
-          "_min",
-          "_max"
-        ].includes(field)) {
-          invariant2(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
-          for (const [k, v] of Object.entries(value)) {
-            invariant2(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-            result = result.orderBy((eb) => aggregate(eb, this.fieldRef(model, k, eb, modelAlias), field), sql.raw(this.negateSort(v, negated)));
-          }
-          continue;
-        }
-        switch (field) {
-          case "_count": {
-            invariant2(value && typeof value === "object", 'invalid orderBy value for field "_count"');
-            for (const [k, v] of Object.entries(value)) {
-              invariant2(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-              result = result.orderBy((eb) => eb.fn.count(this.fieldRef(model, k, eb, modelAlias)), sql.raw(this.negateSort(v, negated)));
-            }
-            continue;
-          }
-          default:
-            break;
-        }
-        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(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(fieldRef, sql.raw(`${this.negateSort(value.sort, negated)} nulls ${value.nulls}`));
-          }
-        } else {
-          const relationModel = fieldDef.type;
-          if (fieldDef.array) {
-            if (typeof value !== "object") {
-              throw new QueryError(`invalid orderBy value for field "${field}"`);
-            }
-            if ("_count" in value) {
-              invariant2(value._count === "asc" || value._count === "desc", 'invalid orderBy value for field "_count"');
-              const sort = this.negateSort(value._count, negated);
-              result = result.orderBy((eb) => {
-                const subQueryAlias = `${modelAlias}$orderBy$${field}$count`;
-                let subQuery = this.buildSelectModel(eb, relationModel, subQueryAlias);
-                const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, subQueryAlias);
-                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"));
-                return subQuery;
-              }, sort);
-            }
-          } else {
-            result = result.leftJoin(relationModel, (join) => {
-              const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, relationModel);
-              return join.on((eb) => this.and(eb, ...joinPairs.map(([left, right]) => eb(sql.ref(left), "=", sql.ref(right)))));
-            });
-            result = this.buildOrderBy(result, fieldDef.type, relationModel, value, false, negated);
-          }
-        }
-      }
-    });
-    return result;
-  }
-  buildSelectAllFields(model, query, omit, modelAlias) {
-    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, modelAlias, field);
-    }
-    const descendants = getDelegateDescendantModels(this.schema, model);
-    for (const subModel of descendants) {
-      result = this.buildDelegateJoin(model, modelAlias, 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;
-  }
-  buildModelSelect(eb, model, subQueryAlias, payload, selectAllFields) {
-    let subQuery = this.buildSelectModel(eb, model, subQueryAlias);
-    if (selectAllFields) {
-      subQuery = this.buildSelectAllFields(model, subQuery, typeof payload === "object" ? payload?.omit : void 0, subQueryAlias);
-    }
-    if (payload && typeof payload === "object") {
-      subQuery = this.buildFilterSortTake(model, payload, subQuery, subQueryAlias);
-    }
-    return subQuery;
-  }
-  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, thisModelAlias, otherModelAlias, query) {
-    const idFields = requireIdFields(this.schema, thisModel);
-    query = query.leftJoin(otherModelAlias, (qb) => {
-      for (const idField of idFields) {
-        qb = qb.onRef(`${thisModelAlias}.${idField}`, "=", `${otherModelAlias}.${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;
-      let fieldCountQuery;
-      const m2m = getManyToManyRelation(this.schema, model, field);
-      if (m2m) {
-        fieldCountQuery = eb.selectFrom(fieldModel).innerJoin(m2m.joinTable, (join) => join.onRef(`${m2m.joinTable}.${m2m.otherFkName}`, "=", `${fieldModel}.${m2m.otherPKName}`).onRef(`${m2m.joinTable}.${m2m.parentFkName}`, "=", `${parentAlias}.${m2m.parentPKName}`)).select(eb.fn.countAll().as(`_count$${field}`));
-      } else {
-        fieldCountQuery = eb.selectFrom(fieldModel).select(eb.fn.countAll().as(`_count$${field}`));
-        const joinPairs = buildJoinPairs(this.schema, model, parentAlias, field, fieldModel);
-        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", false));
-  }
-  false(eb) {
-    return eb.lit(this.transformPrimitive(false, "Boolean", false));
-  }
-  isTrue(expression) {
-    const node = expression.toOperationNode();
-    if (node.kind !== "ValueNode") {
-      return false;
-    }
-    return node.value === true || node.value === 1;
-  }
-  isFalse(expression) {
-    const node = expression.toOperationNode();
-    if (node.kind !== "ValueNode") {
-      return false;
-    }
-    return node.value === false || node.value === 0;
-  }
-  and(eb, ...args) {
-    const nonTrueArgs = args.filter((arg) => !this.isTrue(arg));
-    if (nonTrueArgs.length === 0) {
-      return this.true(eb);
-    } else if (nonTrueArgs.length === 1) {
-      return nonTrueArgs[0];
-    } else {
-      return eb.and(nonTrueArgs);
-    }
-  }
-  or(eb, ...args) {
-    const nonFalseArgs = args.filter((arg) => !this.isFalse(arg));
-    if (nonFalseArgs.length === 0) {
-      return this.false(eb);
-    } else if (nonFalseArgs.length === 1) {
-      return nonFalseArgs[0];
-    } else {
-      return eb.or(nonFalseArgs);
-    }
-  }
-  not(eb, ...args) {
-    return eb.not(this.and(eb, ...args));
-  }
-  fieldRef(model, field, eb, modelAlias, inlineComputedField = true) {
-    return buildFieldRef(this.schema, model, field, this.options, eb, modelAlias, inlineComputedField);
-  }
-  canJoinWithoutNestedSelect(modelDef, payload) {
-    if (modelDef.computedFields) {
-      return false;
-    }
-    if (modelDef.baseModel || modelDef.isDelegate) {
-      return false;
-    }
-    if (typeof payload === "object" && (payload.orderBy || payload.skip !== void 0 || payload.take !== void 0 || payload.cursor || payload.distinct)) {
-      return false;
-    }
-    return true;
-  }
-};
-
-// src/client/crud/dialects/postgresql.ts
-var PostgresCrudDialect = class extends BaseCrudDialect {
-  static {
-    __name(this, "PostgresCrudDialect");
-  }
-  constructor(schema, options) {
-    super(schema, options);
-  }
-  get provider() {
-    return "postgresql";
-  }
-  transformPrimitive(value, type, forArrayField) {
-    if (value === void 0) {
-      return value;
-    }
-    if (Array.isArray(value)) {
-      if (type === "Json" && !forArrayField) {
-        return JSON.stringify(value);
-      } else {
-        return value.map((v) => this.transformPrimitive(v, type, false));
-      }
-    } else {
-      return match3(type).with("DateTime", () => value instanceof Date ? value.toISOString() : typeof value === "string" ? new Date(value).toISOString() : value).with("Decimal", () => value !== null ? value.toString() : value).otherwise(() => value);
-    }
-  }
-  transformOutput(value, type) {
-    if (value === null || value === void 0) {
-      return value;
-    }
-    return match3(type).with("DateTime", () => this.transformOutputDate(value)).with("Bytes", () => this.transformOutputBytes(value)).with("BigInt", () => this.transformOutputBigInt(value)).with("Decimal", () => this.transformDecimal(value)).otherwise(() => super.transformOutput(value, type));
-  }
-  transformOutputBigInt(value) {
-    if (typeof value === "bigint") {
-      return value;
-    }
-    invariant3(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
-    return BigInt(value);
-  }
-  transformDecimal(value) {
-    if (value instanceof Decimal) {
-      return value;
-    }
-    invariant3(typeof value === "string" || typeof value === "number" || value instanceof Decimal, `Expected string, number or Decimal, got ${typeof value}`);
-    return new Decimal(value);
-  }
-  transformOutputDate(value) {
-    if (typeof value === "string") {
-      return new Date(value);
-    } else if (value instanceof Date && this.options.fixPostgresTimezone !== false) {
-      return new Date(value.getTime() - value.getTimezoneOffset() * 60 * 1e3);
-    } else {
-      return value;
-    }
-  }
-  transformOutputBytes(value) {
-    return Buffer.isBuffer(value) ? Uint8Array.from(value) : value;
-  }
-  buildRelationSelection(query, model, relationField, parentAlias, payload) {
-    const relationResultName = `${parentAlias}$${relationField}`;
-    const joinedQuery = this.buildRelationJSON(model, query, relationField, parentAlias, payload, relationResultName);
-    return joinedQuery.select(`${relationResultName}.$data as ${relationField}`);
-  }
-  buildRelationJSON(model, qb, relationField, parentAlias, payload, resultName) {
-    const relationFieldDef = requireField(this.schema, model, relationField);
-    const relationModel = relationFieldDef.type;
-    return qb.leftJoinLateral((eb) => {
-      const relationSelectName = `${resultName}$sub`;
-      const relationModelDef = requireModel(this.schema, relationModel);
-      let tbl;
-      if (this.canJoinWithoutNestedSelect(relationModelDef, payload)) {
-        tbl = this.buildModelSelect(eb, relationModel, relationSelectName, payload, false);
-        tbl = this.buildRelationJoinFilter(tbl, model, relationField, relationModel, relationSelectName, parentAlias);
-      } else {
-        tbl = eb.selectFrom(() => {
-          let subQuery = this.buildModelSelect(eb, relationModel, `${relationSelectName}$t`, payload, true);
-          subQuery = this.buildRelationJoinFilter(subQuery, model, relationField, relationModel, `${relationSelectName}$t`, parentAlias);
-          return subQuery.as(relationSelectName);
-        });
-      }
-      tbl = this.buildRelationObjectSelect(relationModel, relationSelectName, relationFieldDef, tbl, payload, resultName);
-      tbl = this.buildRelationJoins(tbl, relationModel, relationSelectName, payload, resultName);
-      return tbl.as(resultName);
-    }, (join) => join.onTrue());
-  }
-  buildRelationJoinFilter(query, model, relationField, relationModel, relationModelAlias, parentAlias) {
-    const m2m = getManyToManyRelation(this.schema, model, relationField);
-    if (m2m) {
-      const parentIds = requireIdFields(this.schema, model);
-      const relationIds = requireIdFields(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");
-      query = query.where((eb) => eb(eb.ref(`${relationModelAlias}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentAlias}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
-    } else {
-      const joinPairs = buildJoinPairs(this.schema, model, parentAlias, relationField, relationModelAlias);
-      query = query.where((eb) => this.and(eb, ...joinPairs.map(([left, right]) => eb(sql2.ref(left), "=", sql2.ref(right)))));
-    }
-    return query;
-  }
-  buildRelationObjectSelect(relationModel, relationModelAlias, relationFieldDef, qb, payload, parentResultName) {
-    qb = qb.select((eb) => {
-      const objArgs = this.buildRelationObjectArgs(relationModel, relationModelAlias, eb, payload, parentResultName);
-      if (relationFieldDef.array) {
-        return eb.fn.coalesce(sql2`jsonb_agg(jsonb_build_object(${sql2.join(objArgs)}))`, sql2`'[]'::jsonb`).as("$data");
-      } else {
-        return sql2`jsonb_build_object(${sql2.join(objArgs)})`.as("$data");
-      }
-    });
-    return qb;
-  }
-  buildRelationObjectArgs(relationModel, relationModelAlias, eb, payload, parentResultName) {
-    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),
-        this.fieldRef(relationModel, field, eb, relationModelAlias, false)
-      ]).flatMap((v) => v));
-    } else if (payload.select) {
-      objArgs.push(...Object.entries(payload.select).filter(([, value]) => value).map(([field, value]) => {
-        if (field === "_count") {
-          const subJson = this.buildCountJson(relationModel, eb, relationModelAlias, value);
-          return [
-            sql2.lit(field),
-            subJson
-          ];
-        } else {
-          const fieldDef = requireField(this.schema, relationModel, field);
-          const fieldValue = fieldDef.relation ? eb.ref(`${parentResultName}$${field}.$data`) : this.fieldRef(relationModel, field, eb, relationModelAlias, false);
-          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),
-        // reference the synthesized JSON field
-        eb.ref(`${parentResultName}$${field}.$data`)
-      ]).flatMap((v) => v));
-    }
-    return objArgs;
-  }
-  buildRelationJoins(query, relationModel, relationModelAlias, payload, parentResultName) {
-    let result = query;
-    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, relationModelAlias, value, `${parentResultName}$${field}`);
-        });
-      }
-    }
-    return result;
-  }
-  buildSkipTake(query, skip, take) {
-    if (take !== void 0) {
-      query = query.limit(take);
-    }
-    if (skip !== void 0) {
-      query = query.offset(skip);
-    }
-    return query;
-  }
-  buildJsonObject(eb, value) {
-    return eb.fn("jsonb_build_object", Object.entries(value).flatMap(([key, value2]) => [
-      sql2.lit(key),
-      value2
-    ]));
-  }
-  get supportsUpdateWithLimit() {
-    return false;
-  }
-  get supportsDeleteWithLimit() {
-    return false;
-  }
-  get supportsDistinctOn() {
-    return true;
-  }
-  buildArrayLength(eb, array) {
-    return eb.fn("array_length", [
-      array
-    ]);
-  }
-  buildArrayLiteralSQL(values) {
-    if (values.length === 0) {
-      return "{}";
-    } else {
-      return `ARRAY[${values.map((v) => typeof v === "string" ? `'${v}'` : v)}]`;
-    }
-  }
-  get supportInsertWithDefault() {
-    return true;
-  }
-  getFieldSqlType(fieldDef) {
-    if (fieldDef.relation) {
-      throw new QueryError("Cannot get SQL type of a relation field");
-    }
-    let result;
-    if (this.schema.enums?.[fieldDef.type]) {
-      result = "text";
-    } else {
-      result = match3(fieldDef.type).with("String", () => "text").with("Boolean", () => "boolean").with("Int", () => "integer").with("BigInt", () => "bigint").with("Float", () => "double precision").with("Decimal", () => "decimal").with("DateTime", () => "timestamp").with("Bytes", () => "bytea").with("Json", () => "jsonb").otherwise(() => "text");
-    }
-    if (fieldDef.array) {
-      result += "[]";
-    }
-    return result;
-  }
-  getStringCasingBehavior() {
-    return {
-      supportsILike: true,
-      likeCaseSensitive: true
-    };
-  }
-};
-
-// src/client/crud/dialects/sqlite.ts
-import { invariant as invariant4 } from "@zenstackhq/common-helpers";
-import Decimal2 from "decimal.js";
-import { sql as sql3 } from "kysely";
-import { match as match4 } from "ts-pattern";
-var SqliteCrudDialect = class extends BaseCrudDialect {
-  static {
-    __name(this, "SqliteCrudDialect");
-  }
-  get provider() {
-    return "sqlite";
-  }
-  transformPrimitive(value, type, _forArrayField) {
-    if (value === void 0) {
-      return value;
-    }
-    if (Array.isArray(value)) {
-      return value.map((v) => this.transformPrimitive(v, type, false));
-    } else {
-      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() : typeof value === "string" ? new Date(value).toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).with("Json", () => JSON.stringify(value)).otherwise(() => value);
-      }
-    }
-  }
-  transformOutput(value, type) {
-    if (value === null || value === void 0) {
-      return value;
-    } else if (this.schema.typeDefs && type in this.schema.typeDefs) {
-      return this.transformOutputJson(value);
-    } else {
-      return match4(type).with("Boolean", () => this.transformOutputBoolean(value)).with("DateTime", () => this.transformOutputDate(value)).with("Bytes", () => this.transformOutputBytes(value)).with("Decimal", () => this.transformOutputDecimal(value)).with("BigInt", () => this.transformOutputBigInt(value)).with("Json", () => this.transformOutputJson(value)).otherwise(() => super.transformOutput(value, type));
-    }
-  }
-  transformOutputDecimal(value) {
-    if (value instanceof Decimal2) {
-      return value;
-    }
-    invariant4(typeof value === "string" || typeof value === "number" || value instanceof Decimal2, `Expected string, number or Decimal, got ${typeof value}`);
-    return new Decimal2(value);
-  }
-  transformOutputBigInt(value) {
-    if (typeof value === "bigint") {
-      return value;
-    }
-    invariant4(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
-    return BigInt(value);
-  }
-  transformOutputBoolean(value) {
-    return !!value;
-  }
-  transformOutputDate(value) {
-    if (typeof value === "number") {
-      return new Date(value);
-    } else if (typeof value === "string") {
-      return new Date(value);
-    } else {
-      return value;
-    }
-  }
-  transformOutputBytes(value) {
-    return Buffer.isBuffer(value) ? Uint8Array.from(value) : value;
-  }
-  transformOutputJson(value) {
-    if (typeof value === "string") {
-      try {
-        return JSON.parse(value);
-      } catch (e) {
-        throw new QueryError("Invalid JSON returned", e);
-      }
-    }
-    return value;
-  }
-  buildRelationSelection(query, model, relationField, parentAlias, payload) {
-    return query.select((eb) => this.buildRelationJSON(model, eb, relationField, parentAlias, payload).as(relationField));
-  }
-  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 = `${parentAlias}$${relationField}`;
-    let tbl;
-    if (this.canJoinWithoutNestedSelect(relationModelDef, payload)) {
-      tbl = this.buildModelSelect(eb, relationModel, subQueryName, payload, false);
-      tbl = this.buildRelationJoinFilter(tbl, model, relationField, subQueryName, parentAlias);
-    } else {
-      tbl = eb.selectFrom(() => {
-        const selectModelAlias = `${parentAlias}$${relationField}$sub`;
-        let selectModelQuery = this.buildModelSelect(eb, relationModel, selectModelAlias, payload, true);
-        selectModelQuery = this.buildRelationJoinFilter(selectModelQuery, model, relationField, selectModelAlias, parentAlias);
-        return selectModelQuery.as(subQueryName);
-      });
-    }
-    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),
-          this.fieldRef(relationModel, field, eb, subQueryName, false)
-        ]).flatMap((v) => v));
-      } else if (payload.select) {
-        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 [
-              sql3.lit(field),
-              subJson
-            ];
-          } else {
-            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, subQueryName, false)
-              ];
-            }
-          }
-        }).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, `${parentAlias}$${relationField}`, value);
-          return [
-            sql3.lit(field),
-            subJson
-          ];
-        }).flatMap((v) => v));
-      }
-      if (relationFieldDef.array) {
-        return eb.fn.coalesce(sql3`json_group_array(json_object(${sql3.join(objArgs)}))`, sql3`json_array()`).as("$data");
-      } else {
-        return sql3`json_object(${sql3.join(objArgs)})`.as("$data");
-      }
-    });
-    return tbl;
-  }
-  buildRelationJoinFilter(selectModelQuery, model, relationField, relationModelAlias, parentAlias) {
-    const fieldDef = requireField(this.schema, model, relationField);
-    const relationModel = fieldDef.type;
-    const m2m = getManyToManyRelation(this.schema, model, relationField);
-    if (m2m) {
-      const parentIds = requireIdFields(this.schema, model);
-      const relationIds = requireIdFields(this.schema, relationModel);
-      invariant4(parentIds.length === 1, "many-to-many relation must have exactly one id field");
-      invariant4(relationIds.length === 1, "many-to-many relation must have exactly one id field");
-      selectModelQuery = selectModelQuery.where((eb) => eb(eb.ref(`${relationModelAlias}.${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) {
-          selectModelQuery = selectModelQuery.whereRef(`${relationModelAlias}.${pk}`, "=", `${parentAlias}.${fk}`);
-        } else {
-          selectModelQuery = selectModelQuery.whereRef(`${relationModelAlias}.${fk}`, "=", `${parentAlias}.${pk}`);
-        }
-      });
-    }
-    return selectModelQuery;
-  }
-  buildSkipTake(query, skip, take) {
-    if (take !== void 0) {
-      query = query.limit(take);
-    }
-    if (skip !== void 0) {
-      query = query.offset(skip);
-      if (take === void 0) {
-        query = query.limit(-1);
-      }
-    }
-    return query;
-  }
-  buildJsonObject(eb, value) {
-    return eb.fn("json_object", Object.entries(value).flatMap(([key, value2]) => [
-      sql3.lit(key),
-      value2
-    ]));
-  }
-  get supportsUpdateWithLimit() {
-    return false;
-  }
-  get supportsDeleteWithLimit() {
-    return false;
-  }
-  get supportsDistinctOn() {
-    return false;
-  }
-  buildArrayLength(eb, array) {
-    return eb.fn("json_array_length", [
-      array
-    ]);
-  }
-  buildArrayLiteralSQL(_values) {
-    throw new Error("SQLite does not support array literals");
-  }
-  get supportInsertWithDefault() {
-    return false;
-  }
-  getFieldSqlType(fieldDef) {
-    if (fieldDef.relation) {
-      throw new QueryError("Cannot get SQL type of a relation field");
-    }
-    if (fieldDef.array) {
-      throw new QueryError("SQLite does not support scalar list type");
-    }
-    if (this.schema.enums?.[fieldDef.type]) {
-      return "text";
-    }
-    return match4(fieldDef.type).with("String", () => "text").with("Boolean", () => "integer").with("Int", () => "integer").with("BigInt", () => "integer").with("Float", () => "real").with("Decimal", () => "decimal").with("DateTime", () => "numeric").with("Bytes", () => "blob").with("Json", () => "jsonb").otherwise(() => "text");
-  }
-  getStringCasingBehavior() {
-    return {
-      supportsILike: false,
-      likeCaseSensitive: false
-    };
-  }
-};
-
-// src/client/crud/dialects/index.ts
-function getCrudDialect(schema, options) {
-  return match5(schema.provider.type).with("sqlite", () => new SqliteCrudDialect(schema, options)).with("postgresql", () => new PostgresCrudDialect(schema, options)).exhaustive();
-}
-__name(getCrudDialect, "getCrudDialect");
-
-// src/client/crud/operations/count.ts
-import { sql as sql6 } from "kysely";
-
-// src/client/crud/operations/create.ts
-import { match as match8 } from "ts-pattern";
-
-// src/client/crud/operations/delete.ts
-import { match as match9 } from "ts-pattern";
-
-// src/client/crud/operations/group-by.ts
-import { expressionBuilder as expressionBuilder3 } from "kysely";
-import { match as match10 } from "ts-pattern";
-
-// src/client/crud/operations/update.ts
-import { match as match11 } from "ts-pattern";
-
-// src/client/crud/validator.ts
-import { invariant as invariant6 } from "@zenstackhq/common-helpers";
-import Decimal3 from "decimal.js";
-import stableStringify from "json-stable-stringify";
-import { match as match12, P as P2 } from "ts-pattern";
-import { z } from "zod";
-
-// src/utils/zod-utils.ts
-import { fromError as fromError3 } from "zod-validation-error/v3";
-import { fromError as fromError4 } from "zod-validation-error/v4";
-
-// src/client/executor/zenstack-query-executor.ts
-import { invariant as invariant8 } from "@zenstackhq/common-helpers";
-import { AndNode, DefaultQueryExecutor, DeleteQueryNode, InsertQueryNode, ReturningNode, SelectionNode as SelectionNode2, SingleConnectionProvider, TableNode as TableNode3, UpdateQueryNode, WhereNode } from "kysely";
-import { match as match13 } from "ts-pattern";
-
-// src/client/kysely-utils.ts
-import { AliasNode, ColumnNode, ReferenceNode, TableNode } from "kysely";
-function extractFieldName(node) {
-  if (ReferenceNode.is(node) && ColumnNode.is(node.column)) {
-    return node.column.column.name;
-  } else if (ColumnNode.is(node)) {
-    return node.column.name;
-  } else {
-    return void 0;
-  }
-}
-__name(extractFieldName, "extractFieldName");
-
-// src/client/executor/name-mapper.ts
-import { invariant as invariant7 } from "@zenstackhq/common-helpers";
-import { AliasNode as AliasNode2, ColumnNode as ColumnNode2, FromNode, IdentifierNode, OperationNodeTransformer, ReferenceNode as ReferenceNode2, SelectAllNode, SelectionNode, TableNode as TableNode2 } from "kysely";
-
-// src/client/functions.ts
-import { invariant as invariant9, lowerCaseFirst, upperCaseFirst } from "@zenstackhq/common-helpers";
-import { sql as sql7, ValueNode } from "kysely";
-import { match as match14 } from "ts-pattern";
-
-// src/client/helpers/schema-db-pusher.ts
-import { invariant as invariant10 } from "@zenstackhq/common-helpers";
-import { sql as sql8 } from "kysely";
-import toposort from "toposort";
-import { match as match15 } from "ts-pattern";
-
-// src/client/index.ts
-import { sql as sql10 } from "kysely";
-
-// src/plugins/policy/errors.ts
-var RejectedByPolicyReason = /* @__PURE__ */ function(RejectedByPolicyReason2) {
-  RejectedByPolicyReason2["NO_ACCESS"] = "no-access";
-  RejectedByPolicyReason2["CANNOT_READ_BACK"] = "cannot-read-back";
-  RejectedByPolicyReason2["OTHER"] = "other";
-  return RejectedByPolicyReason2;
-}({});
-var RejectedByPolicyError = class extends ZenStackError {
-  static {
-    __name(this, "RejectedByPolicyError");
-  }
-  model;
-  reason;
-  constructor(model, reason = "no-access", message) {
-    super(message ?? `Operation rejected by policy${model ? ": " + model : ""}`), this.model = model, this.reason = reason;
-  }
-};
-
-// src/plugins/policy/functions.ts
-import { invariant as invariant15 } from "@zenstackhq/common-helpers";
-import { ExpressionWrapper as ExpressionWrapper2, ValueNode as ValueNode5 } from "kysely";
-
-// src/plugins/policy/policy-handler.ts
-import { invariant as invariant14 } from "@zenstackhq/common-helpers";
-import { AliasNode as AliasNode5, BinaryOperationNode as BinaryOperationNode3, ColumnNode as ColumnNode4, DeleteQueryNode as DeleteQueryNode2, expressionBuilder as expressionBuilder5, ExpressionWrapper, FromNode as FromNode3, FunctionNode as FunctionNode3, IdentifierNode as IdentifierNode3, InsertQueryNode as InsertQueryNode2, OperationNodeTransformer as OperationNodeTransformer2, OperatorNode as OperatorNode3, ParensNode as ParensNode2, PrimitiveValueListNode, RawNode, ReferenceNode as ReferenceNode5, ReturningNode as ReturningNode2, SelectAllNode as SelectAllNode2, SelectionNode as SelectionNode4, SelectQueryNode as SelectQueryNode2, sql as sql11, TableNode as TableNode6, UpdateQueryNode as UpdateQueryNode2, ValueListNode as ValueListNode2, ValueNode as ValueNode4, ValuesNode, WhereNode as WhereNode3 } from "kysely";
-import { match as match19 } from "ts-pattern";
-
-// src/utils/expression-utils.ts
-import { match as match16 } from "ts-pattern";
-var ExpressionVisitor = class {
-  static {
-    __name(this, "ExpressionVisitor");
-  }
-  visit(expr2) {
-    match16(expr2).with({
-      kind: "literal"
-    }, (e) => this.visitLiteral(e)).with({
-      kind: "array"
-    }, (e) => this.visitArray(e)).with({
-      kind: "field"
-    }, (e) => this.visitField(e)).with({
-      kind: "member"
-    }, (e) => this.visitMember(e)).with({
-      kind: "binary"
-    }, (e) => this.visitBinary(e)).with({
-      kind: "unary"
-    }, (e) => this.visitUnary(e)).with({
-      kind: "call"
-    }, (e) => this.visitCall(e)).with({
-      kind: "this"
-    }, (e) => this.visitThis(e)).with({
-      kind: "null"
-    }, (e) => this.visitNull(e)).exhaustive();
-  }
-  visitLiteral(_e) {
-  }
-  visitArray(e) {
-    e.items.forEach((item) => this.visit(item));
-  }
-  visitField(_e) {
-  }
-  visitMember(e) {
-    this.visit(e.receiver);
-  }
-  visitBinary(e) {
-    this.visit(e.left);
-    this.visit(e.right);
-  }
-  visitUnary(e) {
-    this.visit(e.operand);
-  }
-  visitCall(e) {
-    e.args?.forEach((arg) => this.visit(arg));
-  }
-  visitThis(_e) {
-  }
-  visitNull(_e) {
-  }
-};
-
-// src/utils/default-operation-node-visitor.ts
-import { OperationNodeVisitor } from "kysely";
-var DefaultOperationNodeVisitor = class extends OperationNodeVisitor {
-  static {
-    __name(this, "DefaultOperationNodeVisitor");
-  }
-  defaultVisit(node) {
-    Object.values(node).forEach((value) => {
-      if (!value) {
-        return;
-      }
-      if (Array.isArray(value)) {
-        value.forEach((el) => this.defaultVisit(el));
-      }
-      if (typeof value === "object" && "kind" in value && typeof value.kind === "string") {
-        this.visitNode(value);
-      }
-    });
-  }
-  visitSelectQuery(node) {
-    this.defaultVisit(node);
-  }
-  visitSelection(node) {
-    this.defaultVisit(node);
-  }
-  visitColumn(node) {
-    this.defaultVisit(node);
-  }
-  visitAlias(node) {
-    this.defaultVisit(node);
-  }
-  visitTable(node) {
-    this.defaultVisit(node);
-  }
-  visitFrom(node) {
-    this.defaultVisit(node);
-  }
-  visitReference(node) {
-    this.defaultVisit(node);
-  }
-  visitAnd(node) {
-    this.defaultVisit(node);
-  }
-  visitOr(node) {
-    this.defaultVisit(node);
-  }
-  visitValueList(node) {
-    this.defaultVisit(node);
-  }
-  visitParens(node) {
-    this.defaultVisit(node);
-  }
-  visitJoin(node) {
-    this.defaultVisit(node);
-  }
-  visitRaw(node) {
-    this.defaultVisit(node);
-  }
-  visitWhere(node) {
-    this.defaultVisit(node);
-  }
-  visitInsertQuery(node) {
-    this.defaultVisit(node);
-  }
-  visitDeleteQuery(node) {
-    this.defaultVisit(node);
-  }
-  visitReturning(node) {
-    this.defaultVisit(node);
-  }
-  visitCreateTable(node) {
-    this.defaultVisit(node);
-  }
-  visitAddColumn(node) {
-    this.defaultVisit(node);
-  }
-  visitColumnDefinition(node) {
-    this.defaultVisit(node);
-  }
-  visitDropTable(node) {
-    this.defaultVisit(node);
-  }
-  visitOrderBy(node) {
-    this.defaultVisit(node);
-  }
-  visitOrderByItem(node) {
-    this.defaultVisit(node);
-  }
-  visitGroupBy(node) {
-    this.defaultVisit(node);
-  }
-  visitGroupByItem(node) {
-    this.defaultVisit(node);
-  }
-  visitUpdateQuery(node) {
-    this.defaultVisit(node);
-  }
-  visitColumnUpdate(node) {
-    this.defaultVisit(node);
-  }
-  visitLimit(node) {
-    this.defaultVisit(node);
-  }
-  visitOffset(node) {
-    this.defaultVisit(node);
-  }
-  visitOnConflict(node) {
-    this.defaultVisit(node);
-  }
-  visitOnDuplicateKey(node) {
-    this.defaultVisit(node);
-  }
-  visitCheckConstraint(node) {
-    this.defaultVisit(node);
-  }
-  visitDataType(node) {
-    this.defaultVisit(node);
-  }
-  visitSelectAll(node) {
-    this.defaultVisit(node);
-  }
-  visitIdentifier(node) {
-    this.defaultVisit(node);
-  }
-  visitSchemableIdentifier(node) {
-    this.defaultVisit(node);
-  }
-  visitValue(node) {
-    this.defaultVisit(node);
-  }
-  visitPrimitiveValueList(node) {
-    this.defaultVisit(node);
-  }
-  visitOperator(node) {
-    this.defaultVisit(node);
-  }
-  visitCreateIndex(node) {
-    this.defaultVisit(node);
-  }
-  visitDropIndex(node) {
-    this.defaultVisit(node);
-  }
-  visitList(node) {
-    this.defaultVisit(node);
-  }
-  visitPrimaryKeyConstraint(node) {
-    this.defaultVisit(node);
-  }
-  visitUniqueConstraint(node) {
-    this.defaultVisit(node);
-  }
-  visitReferences(node) {
-    this.defaultVisit(node);
-  }
-  visitWith(node) {
-    this.defaultVisit(node);
-  }
-  visitCommonTableExpression(node) {
-    this.defaultVisit(node);
-  }
-  visitCommonTableExpressionName(node) {
-    this.defaultVisit(node);
-  }
-  visitHaving(node) {
-    this.defaultVisit(node);
-  }
-  visitCreateSchema(node) {
-    this.defaultVisit(node);
-  }
-  visitDropSchema(node) {
-    this.defaultVisit(node);
-  }
-  visitAlterTable(node) {
-    this.defaultVisit(node);
-  }
-  visitDropColumn(node) {
-    this.defaultVisit(node);
-  }
-  visitRenameColumn(node) {
-    this.defaultVisit(node);
-  }
-  visitAlterColumn(node) {
-    this.defaultVisit(node);
-  }
-  visitModifyColumn(node) {
-    this.defaultVisit(node);
-  }
-  visitAddConstraint(node) {
-    this.defaultVisit(node);
-  }
-  visitDropConstraint(node) {
-    this.defaultVisit(node);
-  }
-  visitForeignKeyConstraint(node) {
-    this.defaultVisit(node);
-  }
-  visitCreateView(node) {
-    this.defaultVisit(node);
-  }
-  visitDropView(node) {
-    this.defaultVisit(node);
-  }
-  visitGenerated(node) {
-    this.defaultVisit(node);
-  }
-  visitDefaultValue(node) {
-    this.defaultVisit(node);
-  }
-  visitOn(node) {
-    this.defaultVisit(node);
-  }
-  visitValues(node) {
-    this.defaultVisit(node);
-  }
-  visitSelectModifier(node) {
-    this.defaultVisit(node);
-  }
-  visitCreateType(node) {
-    this.defaultVisit(node);
-  }
-  visitDropType(node) {
-    this.defaultVisit(node);
-  }
-  visitExplain(node) {
-    this.defaultVisit(node);
-  }
-  visitDefaultInsertValue(node) {
-    this.defaultVisit(node);
-  }
-  visitAggregateFunction(node) {
-    this.defaultVisit(node);
-  }
-  visitOver(node) {
-    this.defaultVisit(node);
-  }
-  visitPartitionBy(node) {
-    this.defaultVisit(node);
-  }
-  visitPartitionByItem(node) {
-    this.defaultVisit(node);
-  }
-  visitSetOperation(node) {
-    this.defaultVisit(node);
-  }
-  visitBinaryOperation(node) {
-    this.defaultVisit(node);
-  }
-  visitUnaryOperation(node) {
-    this.defaultVisit(node);
-  }
-  visitUsing(node) {
-    this.defaultVisit(node);
-  }
-  visitFunction(node) {
-    this.defaultVisit(node);
-  }
-  visitCase(node) {
-    this.defaultVisit(node);
-  }
-  visitWhen(node) {
-    this.defaultVisit(node);
-  }
-  visitJSONReference(node) {
-    this.defaultVisit(node);
-  }
-  visitJSONPath(node) {
-    this.defaultVisit(node);
-  }
-  visitJSONPathLeg(node) {
-    this.defaultVisit(node);
-  }
-  visitJSONOperatorChain(node) {
-    this.defaultVisit(node);
-  }
-  visitTuple(node) {
-    this.defaultVisit(node);
-  }
-  visitMergeQuery(node) {
-    this.defaultVisit(node);
-  }
-  visitMatched(node) {
-    this.defaultVisit(node);
-  }
-  visitAddIndex(node) {
-    this.defaultVisit(node);
-  }
-  visitCast(node) {
-    this.defaultVisit(node);
-  }
-  visitFetch(node) {
-    this.defaultVisit(node);
-  }
-  visitTop(node) {
-    this.defaultVisit(node);
-  }
-  visitOutput(node) {
-    this.defaultVisit(node);
-  }
-};
-
-// src/plugins/policy/column-collector.ts
-var ColumnCollector = class extends DefaultOperationNodeVisitor {
-  static {
-    __name(this, "ColumnCollector");
-  }
-  columns = [];
-  collect(node) {
-    this.columns = [];
-    this.visitNode(node);
-    return this.columns;
-  }
-  visitColumn(node) {
-    if (!this.columns.includes(node.column.name)) {
-      this.columns.push(node.column.name);
-    }
-  }
-};
-
-// src/plugins/policy/expression-transformer.ts
-import { invariant as invariant13 } from "@zenstackhq/common-helpers";
-import { AliasNode as AliasNode4, BinaryOperationNode as BinaryOperationNode2, ColumnNode as ColumnNode3, expressionBuilder as expressionBuilder4, FromNode as FromNode2, FunctionNode as FunctionNode2, IdentifierNode as IdentifierNode2, OperatorNode as OperatorNode2, ReferenceNode as ReferenceNode4, SelectionNode as SelectionNode3, SelectQueryNode, TableNode as TableNode5, ValueListNode, ValueNode as ValueNode3, WhereNode as WhereNode2 } from "kysely";
-import { match as match18 } from "ts-pattern";
-
-// src/plugins/policy/expression-evaluator.ts
-import { invariant as invariant12 } from "@zenstackhq/common-helpers";
-import { match as match17 } from "ts-pattern";
-var ExpressionEvaluator = class {
-  static {
-    __name(this, "ExpressionEvaluator");
-  }
-  evaluate(expression, context) {
-    const result = match17(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) {
-    if (expr2.function === "auth") {
-      return context.auth;
-    } else {
-      throw new Error(`Unsupported call expression function: ${expr2.function}`);
-    }
-  }
-  evaluateUnary(expr2, context) {
-    return match17(expr2.op).with("!", () => !this.evaluate(expr2.operand, context)).exhaustive();
-  }
-  evaluateMember(expr2, context) {
-    let val = this.evaluate(expr2.receiver, context);
-    for (const member of expr2.members) {
-      val = val?.[member];
-    }
-    return val;
-  }
-  evaluateLiteral(expr2) {
-    return expr2.value;
-  }
-  evaluateField(expr2, context) {
-    return context.thisValue?.[expr2.field];
-  }
-  evaluateArray(expr2, context) {
-    return expr2.items.map((item) => this.evaluate(item, context));
-  }
-  evaluateBinary(expr2, context) {
-    if (expr2.op === "?" || expr2.op === "!" || expr2.op === "^") {
-      return this.evaluateCollectionPredicate(expr2, context);
-    }
-    const left = this.evaluate(expr2.left, context);
-    const right = this.evaluate(expr2.right, context);
-    return match17(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 ?? [];
-      invariant12(Array.isArray(_right), 'expected array for "in" operator');
-      return _right.includes(left);
-    }).exhaustive();
-  }
-  evaluateCollectionPredicate(expr2, context) {
-    const op = expr2.op;
-    invariant12(op === "?" || op === "!" || op === "^", 'expected "?" or "!" or "^" operator');
-    const left = this.evaluate(expr2.left, context);
-    if (!left) {
-      return false;
-    }
-    invariant12(Array.isArray(left), "expected array");
-    return match17(op).with("?", () => left.some((item) => this.evaluate(expr2.right, {
-      ...context,
-      thisValue: item
-    }))).with("!", () => left.every((item) => this.evaluate(expr2.right, {
-      ...context,
-      thisValue: item
-    }))).with("^", () => !left.some((item) => this.evaluate(expr2.right, {
-      ...context,
-      thisValue: item
-    }))).exhaustive();
-  }
-};
-
-// src/plugins/policy/utils.ts
-import { AliasNode as AliasNode3, AndNode as AndNode2, BinaryOperationNode, FunctionNode, OperatorNode, OrNode, ParensNode, ReferenceNode as ReferenceNode3, TableNode as TableNode4, UnaryOperationNode, ValueNode as ValueNode2 } from "kysely";
-function trueNode(dialect) {
-  return ValueNode2.createImmediate(dialect.transformPrimitive(true, "Boolean", false));
-}
-__name(trueNode, "trueNode");
-function falseNode(dialect) {
-  return ValueNode2.createImmediate(dialect.transformPrimitive(false, "Boolean", false));
-}
-__name(falseNode, "falseNode");
-function isTrueNode(node) {
-  return ValueNode2.is(node) && (node.value === true || node.value === 1);
-}
-__name(isTrueNode, "isTrueNode");
-function isFalseNode(node) {
-  return ValueNode2.is(node) && (node.value === false || node.value === 0);
-}
-__name(isFalseNode, "isFalseNode");
-function conjunction(dialect, nodes) {
-  if (nodes.length === 0) {
-    return trueNode(dialect);
-  }
-  if (nodes.length === 1) {
-    return nodes[0];
-  }
-  if (nodes.some(isFalseNode)) {
-    return falseNode(dialect);
-  }
-  const items = nodes.filter((n) => !isTrueNode(n));
-  if (items.length === 0) {
-    return trueNode(dialect);
-  }
-  return items.reduce((acc, node) => AndNode2.create(wrapParensIf(acc, OrNode.is), wrapParensIf(node, OrNode.is)));
-}
-__name(conjunction, "conjunction");
-function disjunction(dialect, nodes) {
-  if (nodes.length === 0) {
-    return falseNode(dialect);
-  }
-  if (nodes.length === 1) {
-    return nodes[0];
-  }
-  if (nodes.some(isTrueNode)) {
-    return trueNode(dialect);
-  }
-  const items = nodes.filter((n) => !isFalseNode(n));
-  if (items.length === 0) {
-    return falseNode(dialect);
-  }
-  return items.reduce((acc, node) => OrNode.create(wrapParensIf(acc, AndNode2.is), wrapParensIf(node, AndNode2.is)));
-}
-__name(disjunction, "disjunction");
-function logicalNot(dialect, node) {
-  if (isTrueNode(node)) {
-    return falseNode(dialect);
-  }
-  if (isFalseNode(node)) {
-    return trueNode(dialect);
-  }
-  return UnaryOperationNode.create(OperatorNode.create("not"), wrapParensIf(node, (n) => AndNode2.is(n) || OrNode.is(n)));
-}
-__name(logicalNot, "logicalNot");
-function wrapParensIf(node, predicate) {
-  return predicate(node) ? ParensNode.create(node) : node;
-}
-__name(wrapParensIf, "wrapParensIf");
-function buildIsFalse(node, dialect) {
-  if (isFalseNode(node)) {
-    return trueNode(dialect);
-  } else if (isTrueNode(node)) {
-    return falseNode(dialect);
-  }
-  return BinaryOperationNode.create(
-    // coalesce so null is treated as false
-    FunctionNode.create("coalesce", [
-      node,
-      falseNode(dialect)
-    ]),
-    OperatorNode.create("="),
-    falseNode(dialect)
-  );
-}
-__name(buildIsFalse, "buildIsFalse");
-function getTableName(node) {
-  if (!node) {
-    return node;
-  }
-  if (TableNode4.is(node)) {
-    return node.table.identifier.name;
-  } else if (AliasNode3.is(node)) {
-    return getTableName(node.node);
-  } else if (ReferenceNode3.is(node) && node.table) {
-    return getTableName(node.table);
-  }
-  return void 0;
-}
-__name(getTableName, "getTableName");
-function isBeforeInvocation(expr2) {
-  return ExpressionUtils.isCall(expr2) && expr2.function === "before";
-}
-__name(isBeforeInvocation, "isBeforeInvocation");
-
-// src/plugins/policy/expression-transformer.ts
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
-function _ts_metadata(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata, "_ts_metadata");
-var expressionHandlers = /* @__PURE__ */ new Map();
-function expr(kind) {
-  return function(_target, _propertyKey, descriptor) {
-    if (!expressionHandlers.get(kind)) {
-      expressionHandlers.set(kind, descriptor);
-    }
-    return descriptor;
-  };
-}
-__name(expr, "expr");
-var ExpressionTransformer = class {
-  static {
-    __name(this, "ExpressionTransformer");
-  }
-  client;
-  dialect;
-  constructor(client) {
-    this.client = client;
-    this.dialect = getCrudDialect(this.schema, this.clientOptions);
-  }
-  get schema() {
-    return this.client.$schema;
-  }
-  get clientOptions() {
-    return this.client.$options;
-  }
-  get auth() {
-    return this.client.$auth;
-  }
-  get authType() {
-    if (!this.schema.authType) {
-      throw new InternalError('Schema does not have an "authType" specified');
-    }
-    return this.schema.authType;
-  }
-  transform(expression, context) {
-    const handler = expressionHandlers.get(expression.kind);
-    if (!handler) {
-      throw new Error(`Unsupported expression kind: ${expression.kind}`);
-    }
-    return handler.value.call(this, expression, context);
-  }
-  _literal(expr2) {
-    return this.transformValue(expr2.value, typeof expr2.value === "string" ? "String" : typeof expr2.value === "boolean" ? "Boolean" : "Int");
-  }
-  _array(expr2, context) {
-    return ValueListNode.create(expr2.items.map((item) => this.transform(item, context)));
-  }
-  _field(expr2, context) {
-    const fieldDef = requireField(this.schema, context.model, expr2.field);
-    if (!fieldDef.relation) {
-      return this.createColumnRef(expr2.field, context);
-    } else {
-      const { memberFilter, memberSelect, ...restContext } = context;
-      const relation = this.transformRelationAccess(expr2.field, fieldDef.type, restContext);
-      return {
-        ...relation,
-        where: this.mergeWhere(relation.where, memberFilter),
-        selections: memberSelect ? [
-          memberSelect
-        ] : relation.selections
-      };
-    }
-  }
-  mergeWhere(where, memberFilter) {
-    if (!where) {
-      return WhereNode2.create(memberFilter ?? trueNode(this.dialect));
-    }
-    if (!memberFilter) {
-      return where;
-    }
-    return WhereNode2.create(conjunction(this.dialect, [
-      where.where,
-      memberFilter
-    ]));
-  }
-  _null() {
-    return ValueNode3.createImmediate(null);
-  }
-  _binary(expr2, context) {
-    if (expr2.op === "&&") {
-      return conjunction(this.dialect, [
-        this.transform(expr2.left, context),
-        this.transform(expr2.right, context)
-      ]);
-    } else if (expr2.op === "||") {
-      return disjunction(this.dialect, [
-        this.transform(expr2.left, context),
-        this.transform(expr2.right, context)
-      ]);
-    }
-    if (this.isAuthCall(expr2.left) || this.isAuthCall(expr2.right)) {
-      return this.transformAuthBinary(expr2, context);
-    }
-    const op = expr2.op;
-    if (op === "?" || op === "!" || op === "^") {
-      return this.transformCollectionPredicate(expr2, context);
-    }
-    const { normalizedLeft, normalizedRight } = this.normalizeBinaryOperationOperands(expr2, context);
-    const left = this.transform(normalizedLeft, context);
-    const right = this.transform(normalizedRight, context);
-    if (op === "in") {
-      if (this.isNullNode(left)) {
-        return this.transformValue(false, "Boolean");
-      } else {
-        if (ValueListNode.is(right)) {
-          return BinaryOperationNode2.create(left, OperatorNode2.create("in"), right);
-        } else {
-          return BinaryOperationNode2.create(left, OperatorNode2.create("="), FunctionNode2.create("any", [
-            right
-          ]));
-        }
-      }
-    }
-    if (this.isNullNode(right)) {
-      return this.transformNullCheck(left, expr2.op);
-    } else if (this.isNullNode(left)) {
-      return this.transformNullCheck(right, expr2.op);
-    } else {
-      return BinaryOperationNode2.create(left, this.transformOperator(op), right);
-    }
-  }
-  transformNullCheck(expr2, operator) {
-    invariant13(operator === "==" || operator === "!=", 'operator must be "==" or "!=" for null comparison');
-    if (ValueNode3.is(expr2)) {
-      if (expr2.value === null) {
-        return operator === "==" ? trueNode(this.dialect) : falseNode(this.dialect);
-      } else {
-        return operator === "==" ? falseNode(this.dialect) : trueNode(this.dialect);
-      }
-    } else {
-      return operator === "==" ? BinaryOperationNode2.create(expr2, OperatorNode2.create("is"), ValueNode3.createImmediate(null)) : BinaryOperationNode2.create(expr2, OperatorNode2.create("is not"), ValueNode3.createImmediate(null));
-    }
-  }
-  normalizeBinaryOperationOperands(expr2, context) {
-    let normalizedLeft = expr2.left;
-    if (this.isRelationField(expr2.left, context.model)) {
-      invariant13(ExpressionUtils.isNull(expr2.right), "only null comparison is supported for relation field");
-      const leftRelDef = this.getFieldDefFromFieldRef(expr2.left, context.model);
-      invariant13(leftRelDef, "failed to get relation field definition");
-      const idFields = requireIdFields(this.schema, leftRelDef.type);
-      normalizedLeft = this.makeOrAppendMember(normalizedLeft, idFields[0]);
-    }
-    let normalizedRight = expr2.right;
-    if (this.isRelationField(expr2.right, context.model)) {
-      invariant13(ExpressionUtils.isNull(expr2.left), "only null comparison is supported for relation field");
-      const rightRelDef = this.getFieldDefFromFieldRef(expr2.right, context.model);
-      invariant13(rightRelDef, "failed to get relation field definition");
-      const idFields = requireIdFields(this.schema, rightRelDef.type);
-      normalizedRight = this.makeOrAppendMember(normalizedRight, idFields[0]);
-    }
-    return {
-      normalizedLeft,
-      normalizedRight
-    };
-  }
-  transformCollectionPredicate(expr2, context) {
-    invariant13(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");
-    }
-    invariant13(ExpressionUtils.isField(expr2.left) || ExpressionUtils.isMember(expr2.left), "left operand must be field or member access");
-    let newContextModel;
-    const fieldDef = this.getFieldDefFromFieldRef(expr2.left, context.model);
-    if (fieldDef) {
-      invariant13(fieldDef.relation, `field is not a relation: ${JSON.stringify(expr2.left)}`);
-      newContextModel = fieldDef.type;
-    } else {
-      invariant13(ExpressionUtils.isMember(expr2.left) && ExpressionUtils.isField(expr2.left.receiver), "left operand must be member access with field receiver");
-      const fieldDef2 = requireField(this.schema, context.model, expr2.left.receiver.field);
-      newContextModel = fieldDef2.type;
-      for (const member of expr2.left.members) {
-        const memberDef = requireField(this.schema, newContextModel, member);
-        newContextModel = memberDef.type;
-      }
-    }
-    let predicateFilter = this.transform(expr2.right, {
-      ...context,
-      model: newContextModel,
-      alias: void 0
-    });
-    if (expr2.op === "!") {
-      predicateFilter = logicalNot(this.dialect, predicateFilter);
-    }
-    const count = FunctionNode2.create("count", [
-      ValueNode3.createImmediate(1)
-    ]);
-    const predicateResult = match18(expr2.op).with("?", () => BinaryOperationNode2.create(count, OperatorNode2.create(">"), ValueNode3.createImmediate(0))).with("!", () => BinaryOperationNode2.create(count, OperatorNode2.create("="), ValueNode3.createImmediate(0))).with("^", () => BinaryOperationNode2.create(count, OperatorNode2.create("="), ValueNode3.createImmediate(0))).exhaustive();
-    return this.transform(expr2.left, {
-      ...context,
-      memberSelect: SelectionNode3.create(AliasNode4.create(predicateResult, IdentifierNode2.create("$t"))),
-      memberFilter: predicateFilter
-    });
-  }
-  transformAuthBinary(expr2, context) {
-    if (expr2.op !== "==" && expr2.op !== "!=") {
-      throw new QueryError(`Unsupported operator for \`auth()\` in policy of model "${context.model}": ${expr2.op}`);
-    }
-    let authExpr;
-    let other;
-    if (this.isAuthCall(expr2.left)) {
-      authExpr = expr2.left;
-      other = expr2.right;
-    } else {
-      authExpr = expr2.right;
-      other = expr2.left;
-    }
-    if (ExpressionUtils.isNull(other)) {
-      return this.transformValue(expr2.op === "==" ? !this.auth : !!this.auth, "Boolean");
-    } else {
-      const authModel = getModel(this.schema, this.authType);
-      if (!authModel) {
-        throw new QueryError(`Unsupported use of \`auth()\` in policy of model "${context.model}", comparing with \`auth()\` is only possible when auth type is a model`);
-      }
-      const idFields = Object.values(authModel.fields).filter((f) => f.id).map((f) => f.name);
-      invariant13(idFields.length > 0, "auth type model must have at least one id field");
-      const conditions = idFields.map((fieldName) => ExpressionUtils.binary(ExpressionUtils.member(authExpr, [
-        fieldName
-      ]), "==", this.makeOrAppendMember(other, fieldName)));
-      let result = this.buildAnd(conditions);
-      if (expr2.op === "!=") {
-        result = this.buildLogicalNot(result);
-      }
-      return this.transform(result, context);
-    }
-  }
-  makeOrAppendMember(other, fieldName) {
-    if (ExpressionUtils.isMember(other)) {
-      return ExpressionUtils.member(other.receiver, [
-        ...other.members,
-        fieldName
-      ]);
-    } else {
-      return ExpressionUtils.member(other, [
-        fieldName
-      ]);
-    }
-  }
-  transformValue(value, type) {
-    if (value === true) {
-      return trueNode(this.dialect);
-    } else if (value === false) {
-      return falseNode(this.dialect);
-    } else {
-      return ValueNode3.create(this.dialect.transformPrimitive(value, type, false) ?? null);
-    }
-  }
-  _unary(expr2, context) {
-    invariant13(expr2.op === "!", 'only "!" operator is supported');
-    return logicalNot(this.dialect, this.transform(expr2.operand, context));
-  }
-  transformOperator(op) {
-    const mappedOp = match18(op).with("==", () => "=").otherwise(() => op);
-    return OperatorNode2.create(mappedOp);
-  }
-  _call(expr2, context) {
-    const result = this.transformCall(expr2, context);
-    return result.toOperationNode();
-  }
-  transformCall(expr2, context) {
-    const func = this.getFunctionImpl(expr2.function);
-    if (!func) {
-      throw new QueryError(`Function not implemented: ${expr2.function}`);
-    }
-    const eb = expressionBuilder4();
-    return func(eb, (expr2.args ?? []).map((arg) => this.transformCallArg(eb, arg, context)), {
-      client: this.client,
-      dialect: this.dialect,
-      model: context.model,
-      modelAlias: context.alias ?? context.model,
-      operation: context.operation
-    });
-  }
-  getFunctionImpl(functionName) {
-    let func = this.clientOptions.functions?.[functionName];
-    if (!func) {
-      for (const plugin of this.clientOptions.plugins ?? []) {
-        if (plugin.functions?.[functionName]) {
-          func = plugin.functions[functionName];
-          break;
-        }
-      }
-    }
-    return func;
-  }
-  transformCallArg(eb, arg, context) {
-    if (ExpressionUtils.isLiteral(arg)) {
-      return eb.val(arg.value);
-    }
-    if (ExpressionUtils.isField(arg)) {
-      return eb.ref(arg.field);
-    }
-    if (ExpressionUtils.isCall(arg)) {
-      return this.transformCall(arg, context);
-    }
-    if (this.isAuthMember(arg)) {
-      const valNode = this.valueMemberAccess(this.auth, arg, this.authType);
-      return valNode ? eb.val(valNode.value) : eb.val(null);
-    }
-    throw new InternalError(`Unsupported argument expression: ${arg.kind}`);
-  }
-  _member(expr2, context) {
-    if (this.isAuthCall(expr2.receiver)) {
-      return this.valueMemberAccess(this.auth, expr2, this.authType);
-    }
-    if (isBeforeInvocation(expr2.receiver)) {
-      invariant13(context.operation === "post-update", "before() can only be used in post-update policy");
-      invariant13(expr2.members.length === 1, "before() can only be followed by a scalar field access");
-      return ReferenceNode4.create(ColumnNode3.create(expr2.members[0]), TableNode5.create("$before"));
-    }
-    invariant13(ExpressionUtils.isField(expr2.receiver) || ExpressionUtils.isThis(expr2.receiver), 'expect receiver to be field expression or "this"');
-    let members = expr2.members;
-    let receiver;
-    const { memberFilter, memberSelect, ...restContext } = context;
-    if (ExpressionUtils.isThis(expr2.receiver)) {
-      if (expr2.members.length === 1) {
-        return this._field(ExpressionUtils.field(expr2.members[0]), context);
-      } else {
-        const firstMemberFieldDef = requireField(this.schema, context.model, expr2.members[0]);
-        receiver = this.transformRelationAccess(expr2.members[0], firstMemberFieldDef.type, restContext);
-        members = expr2.members.slice(1);
-      }
-    } else {
-      receiver = this.transform(expr2.receiver, restContext);
-    }
-    invariant13(SelectQueryNode.is(receiver), "expected receiver to be select query");
-    let startType;
-    if (ExpressionUtils.isField(expr2.receiver)) {
-      const receiverField = requireField(this.schema, context.model, expr2.receiver.field);
-      startType = receiverField.type;
-    } else {
-      startType = context.model;
-    }
-    const memberFields = [];
-    let currType = startType;
-    for (const member of members) {
-      const fieldDef = requireField(this.schema, currType, member);
-      memberFields.push({
-        fieldDef,
-        fromModel: currType
-      });
-      currType = fieldDef.type;
-    }
-    let currNode = void 0;
-    for (let i = members.length - 1; i >= 0; i--) {
-      const member = members[i];
-      const { fieldDef, fromModel } = memberFields[i];
-      if (fieldDef.relation) {
-        const relation = this.transformRelationAccess(member, fieldDef.type, {
-          ...restContext,
-          model: fromModel,
-          alias: void 0
-        });
-        if (currNode) {
-          currNode = {
-            ...relation,
-            selections: [
-              SelectionNode3.create(AliasNode4.create(currNode, IdentifierNode2.create(members[i + 1])))
-            ]
-          };
-        } else {
-          currNode = {
-            ...relation,
-            where: this.mergeWhere(relation.where, memberFilter),
-            selections: memberSelect ? [
-              memberSelect
-            ] : relation.selections
-          };
-        }
-      } else {
-        invariant13(i === members.length - 1, "plain field access must be the last segment");
-        invariant13(!currNode, "plain field access must be the last segment");
-        currNode = ColumnNode3.create(member);
-      }
-    }
-    return {
-      ...receiver,
-      selections: [
-        SelectionNode3.create(AliasNode4.create(currNode, IdentifierNode2.create("$t")))
-      ]
-    };
-  }
-  valueMemberAccess(receiver, expr2, receiverType) {
-    if (!receiver) {
-      return ValueNode3.createImmediate(null);
-    }
-    if (expr2.members.length !== 1) {
-      throw new Error(`Only single member access is supported`);
-    }
-    const field = expr2.members[0];
-    const fieldDef = requireField(this.schema, receiverType, field);
-    const fieldValue = receiver[field] ?? null;
-    return this.transformValue(fieldValue, fieldDef.type);
-  }
-  transformRelationAccess(field, relationModel, context) {
-    const m2m = getManyToManyRelation(this.schema, context.model, field);
-    if (m2m) {
-      return this.transformManyToManyRelationAccess(m2m, context);
-    }
-    const fromModel = context.model;
-    const { keyPairs, ownedByModel } = getRelationForeignKeyFieldPairs(this.schema, fromModel, field);
-    let condition;
-    if (ownedByModel) {
-      condition = conjunction(this.dialect, keyPairs.map(({ fk, pk }) => BinaryOperationNode2.create(ReferenceNode4.create(ColumnNode3.create(fk), TableNode5.create(context.alias ?? fromModel)), OperatorNode2.create("="), ReferenceNode4.create(ColumnNode3.create(pk), TableNode5.create(relationModel)))));
-    } else {
-      condition = conjunction(this.dialect, keyPairs.map(({ fk, pk }) => BinaryOperationNode2.create(ReferenceNode4.create(ColumnNode3.create(pk), TableNode5.create(context.alias ?? fromModel)), OperatorNode2.create("="), ReferenceNode4.create(ColumnNode3.create(fk), TableNode5.create(relationModel)))));
-    }
-    return {
-      kind: "SelectQueryNode",
-      from: FromNode2.create([
-        TableNode5.create(relationModel)
-      ]),
-      where: WhereNode2.create(condition)
-    };
-  }
-  transformManyToManyRelationAccess(m2m, context) {
-    const eb = expressionBuilder4();
-    const relationQuery = eb.selectFrom(m2m.otherModel).innerJoin(m2m.joinTable, (join) => join.onRef(`${m2m.otherModel}.${m2m.otherPKName}`, "=", `${m2m.joinTable}.${m2m.otherFkName}`).onRef(`${m2m.joinTable}.${m2m.parentFkName}`, "=", `${context.alias ?? context.model}.${m2m.parentPKName}`));
-    return relationQuery.toOperationNode();
-  }
-  createColumnRef(column, context) {
-    return ReferenceNode4.create(ColumnNode3.create(column), TableNode5.create(context.alias ?? context.model));
-  }
-  isAuthCall(value) {
-    return ExpressionUtils.isCall(value) && value.function === "auth";
-  }
-  isAuthMember(expr2) {
-    return ExpressionUtils.isMember(expr2) && this.isAuthCall(expr2.receiver);
-  }
-  isNullNode(node) {
-    return ValueNode3.is(node) && node.value === null;
-  }
-  buildLogicalNot(result) {
-    return ExpressionUtils.unary("!", result);
-  }
-  buildAnd(conditions) {
-    if (conditions.length === 0) {
-      return ExpressionUtils.literal(true);
-    } else if (conditions.length === 1) {
-      return conditions[0];
-    } else {
-      return conditions.reduce((acc, condition) => ExpressionUtils.binary(acc, "&&", condition));
-    }
-  }
-  isRelationField(expr2, model) {
-    const fieldDef = this.getFieldDefFromFieldRef(expr2, model);
-    return !!fieldDef?.relation;
-  }
-  getFieldDefFromFieldRef(expr2, model) {
-    if (ExpressionUtils.isField(expr2)) {
-      return requireField(this.schema, model, expr2.field);
-    } else if (ExpressionUtils.isMember(expr2) && expr2.members.length === 1 && ExpressionUtils.isThis(expr2.receiver)) {
-      return requireField(this.schema, model, expr2.members[0]);
-    } else {
-      return void 0;
-    }
-  }
-};
-_ts_decorate([
-  expr("literal"),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof LiteralExpression === "undefined" ? Object : LiteralExpression
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ExpressionTransformer.prototype, "_literal", null);
-_ts_decorate([
-  expr("array"),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof ArrayExpression === "undefined" ? Object : ArrayExpression,
-    typeof ExpressionTransformerContext === "undefined" ? Object : ExpressionTransformerContext
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ExpressionTransformer.prototype, "_array", null);
-_ts_decorate([
-  expr("field"),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof FieldExpression === "undefined" ? Object : FieldExpression,
-    typeof ExpressionTransformerContext === "undefined" ? Object : ExpressionTransformerContext
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ExpressionTransformer.prototype, "_field", null);
-_ts_decorate([
-  expr("null"),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", []),
-  _ts_metadata("design:returntype", void 0)
-], ExpressionTransformer.prototype, "_null", null);
-_ts_decorate([
-  expr("binary"),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof BinaryExpression === "undefined" ? Object : BinaryExpression,
-    typeof ExpressionTransformerContext === "undefined" ? Object : ExpressionTransformerContext
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ExpressionTransformer.prototype, "_binary", null);
-_ts_decorate([
-  expr("unary"),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof UnaryExpression === "undefined" ? Object : UnaryExpression,
-    typeof ExpressionTransformerContext === "undefined" ? Object : ExpressionTransformerContext
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ExpressionTransformer.prototype, "_unary", null);
-_ts_decorate([
-  expr("call"),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof CallExpression === "undefined" ? Object : CallExpression,
-    typeof ExpressionTransformerContext === "undefined" ? Object : ExpressionTransformerContext
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ExpressionTransformer.prototype, "_call", null);
-_ts_decorate([
-  expr("member"),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    typeof MemberExpression === "undefined" ? Object : MemberExpression,
-    typeof ExpressionTransformerContext === "undefined" ? Object : ExpressionTransformerContext
-  ]),
-  _ts_metadata("design:returntype", void 0)
-], ExpressionTransformer.prototype, "_member", null);
-
-// src/plugins/policy/policy-handler.ts
-var PolicyHandler = class extends OperationNodeTransformer2 {
-  static {
-    __name(this, "PolicyHandler");
-  }
-  client;
-  dialect;
-  constructor(client) {
-    super(), this.client = client;
-    this.dialect = getCrudDialect(this.client.$schema, this.client.$options);
-  }
-  get kysely() {
-    return this.client.$qb;
-  }
-  async handle(node, proceed) {
-    if (!this.isCrudQueryNode(node)) {
-      throw new RejectedByPolicyError(void 0, RejectedByPolicyReason.OTHER, "non-CRUD queries are not allowed");
-    }
-    if (!this.isMutationQueryNode(node)) {
-      return proceed(this.transformNode(node));
-    }
-    const { mutationModel } = this.getMutationModel(node);
-    if (InsertQueryNode2.is(node)) {
-      const isManyToManyJoinTable = this.isManyToManyJoinTable(mutationModel);
-      let needCheckPreCreate = true;
-      if (!isManyToManyJoinTable) {
-        const constCondition = this.tryGetConstantPolicy(mutationModel, "create");
-        if (constCondition === true) {
-          needCheckPreCreate = false;
-        } else if (constCondition === false) {
-          throw new RejectedByPolicyError(mutationModel);
-        }
-      }
-      if (needCheckPreCreate) {
-        await this.enforcePreCreatePolicy(node, mutationModel, isManyToManyJoinTable, proceed);
-      }
-    }
-    const hasPostUpdatePolicies = UpdateQueryNode2.is(node) && this.hasPostUpdatePolicies(mutationModel);
-    let beforeUpdateInfo;
-    if (hasPostUpdatePolicies) {
-      beforeUpdateInfo = await this.loadBeforeUpdateEntities(mutationModel, node.where, proceed);
-    }
-    const result = await proceed(this.transformNode(node));
-    if (hasPostUpdatePolicies && result.rows.length > 0) {
-      const idConditions = this.buildIdConditions(mutationModel, result.rows);
-      const postUpdateFilter = this.buildPolicyFilter(mutationModel, void 0, "post-update");
-      const eb = expressionBuilder5();
-      const beforeUpdateTable = beforeUpdateInfo ? {
-        kind: "SelectQueryNode",
-        from: FromNode3.create([
-          ParensNode2.create(ValuesNode.create(beforeUpdateInfo.rows.map((r) => PrimitiveValueListNode.create(beforeUpdateInfo.fields.map((f) => r[f])))))
-        ]),
-        selections: beforeUpdateInfo.fields.map((name, index) => {
-          const def = requireField(this.client.$schema, mutationModel, name);
-          const castedColumnRef = sql11`CAST(${eb.ref(`column${index + 1}`)} as ${sql11.raw(this.dialect.getFieldSqlType(def))})`.as(name);
-          return SelectionNode4.create(castedColumnRef.toOperationNode());
-        })
-      } : void 0;
-      const postUpdateQuery = eb.selectFrom(mutationModel).select(() => [
-        eb(eb.fn("COUNT", [
-          eb.lit(1)
-        ]), "=", result.rows.length).as("$condition")
-      ]).where(() => new ExpressionWrapper(conjunction(this.dialect, [
-        idConditions,
-        postUpdateFilter
-      ]))).$if(!!beforeUpdateInfo, (qb) => qb.leftJoin(() => new ExpressionWrapper(beforeUpdateTable).as("$before"), (join) => {
-        const idFields = requireIdFields(this.client.$schema, mutationModel);
-        return idFields.reduce((acc, f) => acc.onRef(`${mutationModel}.${f}`, "=", `$before.${f}`), join);
-      }));
-      const postUpdateResult = await proceed(postUpdateQuery.toOperationNode());
-      if (!postUpdateResult.rows[0]?.$condition) {
-        throw new RejectedByPolicyError(mutationModel, RejectedByPolicyReason.NO_ACCESS, "some or all updated rows failed to pass post-update policy check");
-      }
-    }
-    if (!node.returning || this.onlyReturningId(node)) {
-      return this.postProcessMutationResult(result, node);
-    } else {
-      const readBackResult = await this.processReadBack(node, result, proceed);
-      if (readBackResult.rows.length !== result.rows.length) {
-        throw new RejectedByPolicyError(mutationModel, RejectedByPolicyReason.CANNOT_READ_BACK, "result is not allowed to be read back");
-      }
-      return readBackResult;
-    }
-  }
-  // correction to kysely mutation result may be needed because we might have added
-  // returning clause to the query and caused changes to the result shape
-  postProcessMutationResult(result, node) {
-    if (node.returning) {
-      return result;
-    } else {
-      return {
-        ...result,
-        rows: [],
-        numAffectedRows: result.numAffectedRows ?? BigInt(result.rows.length)
-      };
-    }
-  }
-  hasPostUpdatePolicies(model) {
-    const policies = this.getModelPolicies(model, "post-update");
-    return policies.length > 0;
-  }
-  async loadBeforeUpdateEntities(model, where, proceed) {
-    const beforeUpdateAccessFields = this.getFieldsAccessForBeforeUpdatePolicies(model);
-    if (!beforeUpdateAccessFields || beforeUpdateAccessFields.length === 0) {
-      return void 0;
-    }
-    const query = {
-      kind: "SelectQueryNode",
-      from: FromNode3.create([
-        TableNode6.create(model)
-      ]),
-      where,
-      selections: [
-        ...beforeUpdateAccessFields.map((f) => SelectionNode4.create(ColumnNode4.create(f)))
-      ]
-    };
-    const result = await proceed(query);
-    return {
-      fields: beforeUpdateAccessFields,
-      rows: result.rows
-    };
-  }
-  getFieldsAccessForBeforeUpdatePolicies(model) {
-    const policies = this.getModelPolicies(model, "post-update");
-    if (policies.length === 0) {
-      return void 0;
-    }
-    const fields = /* @__PURE__ */ new Set();
-    const fieldCollector = new class extends ExpressionVisitor {
-      visitMember(e) {
-        if (isBeforeInvocation(e.receiver)) {
-          invariant14(e.members.length === 1, "before() can only be followed by a scalar field access");
-          fields.add(e.members[0]);
-        }
-        super.visitMember(e);
-      }
-    }();
-    for (const policy of policies) {
-      fieldCollector.visit(policy.condition);
-    }
-    if (fields.size === 0) {
-      return void 0;
-    }
-    requireIdFields(this.client.$schema, model).forEach((f) => fields.add(f));
-    return Array.from(fields).sort();
-  }
-  // #region overrides
-  transformSelectQuery(node) {
-    let whereNode = this.transformNode(node.where);
-    const policyFilter = this.createPolicyFilterForFrom(node.from);
-    if (policyFilter) {
-      whereNode = WhereNode3.create(whereNode?.where ? conjunction(this.dialect, [
-        whereNode.where,
-        policyFilter
-      ]) : policyFilter);
-    }
-    const baseResult = super.transformSelectQuery({
-      ...node,
-      where: void 0
-    });
-    return {
-      ...baseResult,
-      where: whereNode
-    };
-  }
-  transformJoin(node) {
-    const table = this.extractTableName(node.table);
-    if (!table) {
-      return super.transformJoin(node);
-    }
-    const filter = this.buildPolicyFilter(table.model, table.alias, "read");
-    const nestedSelect = {
-      kind: "SelectQueryNode",
-      from: FromNode3.create([
-        node.table
-      ]),
-      selections: [
-        SelectionNode4.createSelectAll()
-      ],
-      where: WhereNode3.create(filter)
-    };
-    return {
-      ...node,
-      table: AliasNode5.create(ParensNode2.create(nestedSelect), IdentifierNode3.create(table.alias ?? table.model))
-    };
-  }
-  transformInsertQuery(node) {
-    let onConflict = node.onConflict;
-    if (onConflict?.updates) {
-      const { mutationModel, alias } = this.getMutationModel(node);
-      const filter = this.buildPolicyFilter(mutationModel, alias, "update");
-      if (onConflict.updateWhere) {
-        onConflict = {
-          ...onConflict,
-          updateWhere: WhereNode3.create(conjunction(this.dialect, [
-            onConflict.updateWhere.where,
-            filter
-          ]))
-        };
-      } else {
-        onConflict = {
-          ...onConflict,
-          updateWhere: WhereNode3.create(filter)
-        };
-      }
-    }
-    const processedNode = onConflict ? {
-      ...node,
-      onConflict
-    } : node;
-    const result = super.transformInsertQuery(processedNode);
-    let returning = result.returning;
-    if (returning) {
-      const { mutationModel } = this.getMutationModel(node);
-      const idFields = requireIdFields(this.client.$schema, mutationModel);
-      returning = ReturningNode2.create(idFields.map((f) => SelectionNode4.create(ColumnNode4.create(f))));
-    }
-    return {
-      ...result,
-      returning
-    };
-  }
-  transformUpdateQuery(node) {
-    const result = super.transformUpdateQuery(node);
-    const { mutationModel, alias } = this.getMutationModel(node);
-    let filter = this.buildPolicyFilter(mutationModel, alias, "update");
-    if (node.from) {
-      const joinFilter = this.createPolicyFilterForFrom(node.from);
-      if (joinFilter) {
-        filter = conjunction(this.dialect, [
-          filter,
-          joinFilter
-        ]);
-      }
-    }
-    let returning = result.returning;
-    if (returning || this.hasPostUpdatePolicies(mutationModel)) {
-      const idFields = requireIdFields(this.client.$schema, mutationModel);
-      returning = ReturningNode2.create(idFields.map((f) => SelectionNode4.create(ColumnNode4.create(f))));
-    }
-    return {
-      ...result,
-      where: WhereNode3.create(result.where ? conjunction(this.dialect, [
-        result.where.where,
-        filter
-      ]) : filter),
-      returning
-    };
-  }
-  transformDeleteQuery(node) {
-    const result = super.transformDeleteQuery(node);
-    const { mutationModel, alias } = this.getMutationModel(node);
-    let filter = this.buildPolicyFilter(mutationModel, alias, "delete");
-    if (node.using) {
-      const joinFilter = this.createPolicyFilterForTables(node.using.tables);
-      if (joinFilter) {
-        filter = conjunction(this.dialect, [
-          filter,
-          joinFilter
-        ]);
-      }
-    }
-    return {
-      ...result,
-      where: WhereNode3.create(result.where ? conjunction(this.dialect, [
-        result.where.where,
-        filter
-      ]) : filter)
-    };
-  }
-  // #endregion
-  // #region helpers
-  onlyReturningId(node) {
-    if (!node.returning) {
-      return true;
-    }
-    const { mutationModel } = this.getMutationModel(node);
-    const idFields = requireIdFields(this.client.$schema, mutationModel);
-    if (node.returning.selections.some((s) => SelectAllNode2.is(s.selection))) {
-      const modelDef = requireModel(this.client.$schema, mutationModel);
-      if (Object.keys(modelDef.fields).some((f) => !idFields.includes(f))) {
-        return false;
-      } else {
-        return true;
-      }
-    }
-    const collector = new ColumnCollector();
-    const selectedColumns = collector.collect(node.returning);
-    return selectedColumns.every((c) => idFields.includes(c));
-  }
-  async enforcePreCreatePolicy(node, mutationModel, isManyToManyJoinTable, proceed) {
-    const fields = node.columns?.map((c) => c.column.name) ?? [];
-    const valueRows = node.values ? this.unwrapCreateValueRows(node.values, mutationModel, fields, isManyToManyJoinTable) : [
-      []
-    ];
-    for (const values of valueRows) {
-      if (isManyToManyJoinTable) {
-        await this.enforcePreCreatePolicyForManyToManyJoinTable(mutationModel, fields, values.map((v) => v.node), proceed);
-      } else {
-        await this.enforcePreCreatePolicyForOne(mutationModel, fields, values.map((v) => v.node), proceed);
-      }
-    }
-  }
-  async enforcePreCreatePolicyForManyToManyJoinTable(tableName, fields, values, proceed) {
-    const m2m = this.resolveManyToManyJoinTable(tableName);
-    invariant14(m2m);
-    invariant14(fields.includes("A") && fields.includes("B"), "many-to-many join table must have A and B fk fields");
-    const aIndex = fields.indexOf("A");
-    const aNode = values[aIndex];
-    const bIndex = fields.indexOf("B");
-    const bNode = values[bIndex];
-    invariant14(ValueNode4.is(aNode) && ValueNode4.is(bNode), "A and B values must be ValueNode");
-    const aValue = aNode.value;
-    const bValue = bNode.value;
-    invariant14(aValue !== null && aValue !== void 0, "A value cannot be null or undefined");
-    invariant14(bValue !== null && bValue !== void 0, "B value cannot be null or undefined");
-    const eb = expressionBuilder5();
-    const filterA = this.buildPolicyFilter(m2m.firstModel, void 0, "update");
-    const queryA = eb.selectFrom(m2m.firstModel).where(eb(eb.ref(`${m2m.firstModel}.${m2m.firstIdField}`), "=", aValue)).select(() => new ExpressionWrapper(filterA).as("$t"));
-    const filterB = this.buildPolicyFilter(m2m.secondModel, void 0, "update");
-    const queryB = eb.selectFrom(m2m.secondModel).where(eb(eb.ref(`${m2m.secondModel}.${m2m.secondIdField}`), "=", bValue)).select(() => new ExpressionWrapper(filterB).as("$t"));
-    const queryNode = {
-      kind: "SelectQueryNode",
-      selections: [
-        SelectionNode4.create(AliasNode5.create(queryA.toOperationNode(), IdentifierNode3.create("$conditionA"))),
-        SelectionNode4.create(AliasNode5.create(queryB.toOperationNode(), IdentifierNode3.create("$conditionB")))
-      ]
-    };
-    const result = await proceed(queryNode);
-    if (!result.rows[0]?.$conditionA) {
-      throw new RejectedByPolicyError(m2m.firstModel, RejectedByPolicyReason.CANNOT_READ_BACK, `many-to-many relation participant model "${m2m.firstModel}" not updatable`);
-    }
-    if (!result.rows[0]?.$conditionB) {
-      throw new RejectedByPolicyError(m2m.secondModel, RejectedByPolicyReason.NO_ACCESS, `many-to-many relation participant model "${m2m.secondModel}" not updatable`);
-    }
-  }
-  async enforcePreCreatePolicyForOne(model, fields, values, proceed) {
-    const allFields = Object.entries(requireModel(this.client.$schema, model).fields).filter(([, def]) => !def.relation);
-    const allValues = [];
-    for (const [name, _def] of allFields) {
-      const index = fields.indexOf(name);
-      if (index >= 0) {
-        allValues.push(values[index]);
-      } else {
-        allValues.push(ValueNode4.createImmediate(null));
-      }
-    }
-    const eb = expressionBuilder5();
-    const constTable = {
-      kind: "SelectQueryNode",
-      from: FromNode3.create([
-        AliasNode5.create(ParensNode2.create(ValuesNode.create([
-          ValueListNode2.create(allValues)
-        ])), IdentifierNode3.create("$t"))
-      ]),
-      selections: allFields.map(([name, def], index) => {
-        const castedColumnRef = sql11`CAST(${eb.ref(`column${index + 1}`)} as ${sql11.raw(this.dialect.getFieldSqlType(def))})`.as(name);
-        return SelectionNode4.create(castedColumnRef.toOperationNode());
-      })
-    };
-    const filter = this.buildPolicyFilter(model, void 0, "create");
-    const preCreateCheck = {
-      kind: "SelectQueryNode",
-      from: FromNode3.create([
-        AliasNode5.create(constTable, IdentifierNode3.create(model))
-      ]),
-      selections: [
-        SelectionNode4.create(AliasNode5.create(BinaryOperationNode3.create(FunctionNode3.create("COUNT", [
-          ValueNode4.createImmediate(1)
-        ]), OperatorNode3.create(">"), ValueNode4.createImmediate(0)), IdentifierNode3.create("$condition")))
-      ],
-      where: WhereNode3.create(filter)
-    };
-    const result = await proceed(preCreateCheck);
-    if (!result.rows[0]?.$condition) {
-      throw new RejectedByPolicyError(model);
-    }
-  }
-  unwrapCreateValueRows(node, model, fields, isManyToManyJoinTable) {
-    if (ValuesNode.is(node)) {
-      return node.values.map((v) => this.unwrapCreateValueRow(v.values, model, fields, isManyToManyJoinTable));
-    } else if (PrimitiveValueListNode.is(node)) {
-      return [
-        this.unwrapCreateValueRow(node.values, model, fields, isManyToManyJoinTable)
-      ];
-    } else {
-      throw new InternalError(`Unexpected node kind: ${node.kind} for unwrapping create values`);
-    }
-  }
-  unwrapCreateValueRow(data, model, fields, isImplicitManyToManyJoinTable) {
-    invariant14(data.length === fields.length, "data length must match fields length");
-    const result = [];
-    for (let i = 0; i < data.length; i++) {
-      const item = data[i];
-      if (typeof item === "object" && item && "kind" in item) {
-        const fieldDef = requireField(this.client.$schema, model, fields[i]);
-        invariant14(item.kind === "ValueNode", "expecting a ValueNode");
-        result.push({
-          node: ValueNode4.create(this.dialect.transformPrimitive(item.value, fieldDef.type, !!fieldDef.array)),
-          raw: item.value
-        });
-      } else {
-        let value = item;
-        if (!isImplicitManyToManyJoinTable) {
-          const fieldDef = requireField(this.client.$schema, model, fields[i]);
-          value = this.dialect.transformPrimitive(item, fieldDef.type, !!fieldDef.array);
-        }
-        if (Array.isArray(value)) {
-          result.push({
-            node: RawNode.createWithSql(this.dialect.buildArrayLiteralSQL(value)),
-            raw: value
-          });
-        } else {
-          result.push({
-            node: ValueNode4.create(value),
-            raw: value
-          });
-        }
-      }
-    }
-    return result;
-  }
-  tryGetConstantPolicy(model, operation) {
-    const policies = this.getModelPolicies(model, operation);
-    if (!policies.some((p) => p.kind === "allow")) {
-      return false;
-    } else if (
-      // unconditional deny
-      policies.some((p) => p.kind === "deny" && this.isTrueExpr(p.condition))
-    ) {
-      return false;
-    } else if (
-      // unconditional allow
-      !policies.some((p) => p.kind === "deny") && policies.some((p) => p.kind === "allow" && this.isTrueExpr(p.condition))
-    ) {
-      return true;
-    } else {
-      return void 0;
-    }
-  }
-  isTrueExpr(expr2) {
-    return ExpressionUtils.isLiteral(expr2) && expr2.value === true;
-  }
-  async processReadBack(node, result, proceed) {
-    if (result.rows.length === 0) {
-      return result;
-    }
-    if (!this.isMutationQueryNode(node) || !node.returning) {
-      return result;
-    }
-    const { mutationModel } = this.getMutationModel(node);
-    const idConditions = this.buildIdConditions(mutationModel, result.rows);
-    const policyFilter = this.buildPolicyFilter(mutationModel, void 0, "read");
-    const select = {
-      kind: "SelectQueryNode",
-      from: FromNode3.create([
-        TableNode6.create(mutationModel)
-      ]),
-      where: WhereNode3.create(conjunction(this.dialect, [
-        idConditions,
-        policyFilter
-      ])),
-      selections: node.returning.selections
-    };
-    const selectResult = await proceed(select);
-    return selectResult;
-  }
-  buildIdConditions(table, rows) {
-    const idFields = requireIdFields(this.client.$schema, table);
-    return disjunction(this.dialect, rows.map((row) => conjunction(this.dialect, idFields.map((field) => BinaryOperationNode3.create(ReferenceNode5.create(ColumnNode4.create(field), TableNode6.create(table)), OperatorNode3.create("="), ValueNode4.create(row[field]))))));
-  }
-  getMutationModel(node) {
-    const r = match19(node).when(InsertQueryNode2.is, (node2) => ({
-      mutationModel: getTableName(node2.into),
-      alias: void 0
-    })).when(UpdateQueryNode2.is, (node2) => {
-      if (!node2.table) {
-        throw new QueryError("Update query must have a table");
-      }
-      const r2 = this.extractTableName(node2.table);
-      return r2 ? {
-        mutationModel: r2.model,
-        alias: r2.alias
-      } : void 0;
-    }).when(DeleteQueryNode2.is, (node2) => {
-      if (node2.from.froms.length !== 1) {
-        throw new QueryError("Only one from table is supported for delete");
-      }
-      const r2 = this.extractTableName(node2.from.froms[0]);
-      return r2 ? {
-        mutationModel: r2.model,
-        alias: r2.alias
-      } : void 0;
-    }).exhaustive();
-    if (!r) {
-      throw new InternalError(`Unable to get table name for query node: ${node}`);
-    }
-    return r;
-  }
-  isCrudQueryNode(node) {
-    return SelectQueryNode2.is(node) || InsertQueryNode2.is(node) || UpdateQueryNode2.is(node) || DeleteQueryNode2.is(node);
-  }
-  isMutationQueryNode(node) {
-    return InsertQueryNode2.is(node) || UpdateQueryNode2.is(node) || DeleteQueryNode2.is(node);
-  }
-  buildPolicyFilter(model, alias, operation) {
-    const m2mFilter = this.getModelPolicyFilterForManyToManyJoinTable(model, alias, operation);
-    if (m2mFilter) {
-      return m2mFilter;
-    }
-    const policies = this.getModelPolicies(model, operation);
-    const allows = policies.filter((policy) => policy.kind === "allow").map((policy) => this.compilePolicyCondition(model, alias, operation, policy));
-    const denies = policies.filter((policy) => policy.kind === "deny").map((policy) => this.compilePolicyCondition(model, alias, operation, policy));
-    let combinedPolicy;
-    if (allows.length === 0) {
-      if (operation === "post-update") {
-        combinedPolicy = trueNode(this.dialect);
-      } else {
-        combinedPolicy = falseNode(this.dialect);
-      }
-    } else {
-      combinedPolicy = disjunction(this.dialect, allows);
-    }
-    if (denies.length !== 0) {
-      const combinedDenies = conjunction(this.dialect, denies.map((d) => buildIsFalse(d, this.dialect)));
-      combinedPolicy = conjunction(this.dialect, [
-        combinedPolicy,
-        combinedDenies
-      ]);
-    }
-    return combinedPolicy;
-  }
-  extractTableName(node) {
-    if (TableNode6.is(node)) {
-      return {
-        model: node.table.identifier.name
-      };
-    }
-    if (AliasNode5.is(node)) {
-      const inner = this.extractTableName(node.node);
-      if (!inner) {
-        return void 0;
-      }
-      return {
-        model: inner.model,
-        alias: IdentifierNode3.is(node.alias) ? node.alias.name : void 0
-      };
-    } else {
-      return void 0;
-    }
-  }
-  createPolicyFilterForFrom(node) {
-    if (!node) {
-      return void 0;
-    }
-    return this.createPolicyFilterForTables(node.froms);
-  }
-  createPolicyFilterForTables(tables) {
-    return tables.reduce((acc, table) => {
-      const extractResult = this.extractTableName(table);
-      if (extractResult) {
-        const { model, alias } = extractResult;
-        const filter = this.buildPolicyFilter(model, alias, "read");
-        return acc ? conjunction(this.dialect, [
-          acc,
-          filter
-        ]) : filter;
-      }
-      return acc;
-    }, void 0);
-  }
-  compilePolicyCondition(model, alias, operation, policy) {
-    return new ExpressionTransformer(this.client).transform(policy.condition, {
-      model,
-      alias,
-      operation
-    });
-  }
-  getModelPolicies(model, operation) {
-    const modelDef = requireModel(this.client.$schema, model);
-    const result = [];
-    const extractOperations = /* @__PURE__ */ __name((expr2) => {
-      invariant14(ExpressionUtils.isLiteral(expr2), "expecting a literal");
-      invariant14(typeof expr2.value === "string", "expecting a string literal");
-      return expr2.value.split(",").filter((v) => !!v).map((v) => v.trim());
-    }, "extractOperations");
-    if (modelDef.attributes) {
-      result.push(...modelDef.attributes.filter((attr) => attr.name === "@@allow" || attr.name === "@@deny").map((attr) => ({
-        kind: attr.name === "@@allow" ? "allow" : "deny",
-        operations: extractOperations(attr.args[0].value),
-        condition: attr.args[1].value
-      })).filter((policy) => operation !== "post-update" && policy.operations.includes("all") || policy.operations.includes(operation)));
-    }
-    return result;
-  }
-  resolveManyToManyJoinTable(tableName) {
-    for (const model of Object.values(this.client.$schema.models)) {
-      for (const field of Object.values(model.fields)) {
-        const m2m = getManyToManyRelation(this.client.$schema, model.name, field.name);
-        if (m2m?.joinTable === tableName) {
-          const sortedRecord = [
-            {
-              model: model.name,
-              field: field.name
-            },
-            {
-              model: m2m.otherModel,
-              field: m2m.otherField
-            }
-          ].sort(this.manyToManySorter);
-          const firstIdFields = requireIdFields(this.client.$schema, sortedRecord[0].model);
-          const secondIdFields = requireIdFields(this.client.$schema, sortedRecord[1].model);
-          invariant14(firstIdFields.length === 1 && secondIdFields.length === 1, "only single-field id is supported for implicit many-to-many join table");
-          return {
-            firstModel: sortedRecord[0].model,
-            firstField: sortedRecord[0].field,
-            firstIdField: firstIdFields[0],
-            secondModel: sortedRecord[1].model,
-            secondField: sortedRecord[1].field,
-            secondIdField: secondIdFields[0]
-          };
-        }
-      }
-    }
-    return void 0;
-  }
-  manyToManySorter(a, b) {
-    return a.model !== b.model ? a.model.localeCompare(b.model) : a.field.localeCompare(b.field);
-  }
-  isManyToManyJoinTable(tableName) {
-    return !!this.resolveManyToManyJoinTable(tableName);
-  }
-  getModelPolicyFilterForManyToManyJoinTable(tableName, alias, operation) {
-    const m2m = this.resolveManyToManyJoinTable(tableName);
-    if (!m2m) {
-      return void 0;
-    }
-    const checkForOperation = operation === "read" ? "read" : "update";
-    const eb = expressionBuilder5();
-    const joinTable = alias ?? tableName;
-    const aQuery = eb.selectFrom(m2m.firstModel).whereRef(`${m2m.firstModel}.${m2m.firstIdField}`, "=", `${joinTable}.A`).select(() => new ExpressionWrapper(this.buildPolicyFilter(m2m.firstModel, void 0, checkForOperation)).as("$conditionA"));
-    const bQuery = eb.selectFrom(m2m.secondModel).whereRef(`${m2m.secondModel}.${m2m.secondIdField}`, "=", `${joinTable}.B`).select(() => new ExpressionWrapper(this.buildPolicyFilter(m2m.secondModel, void 0, checkForOperation)).as("$conditionB"));
-    return eb.and([
-      aQuery,
-      bQuery
-    ]).toOperationNode();
-  }
-};
-
-// src/plugins/policy/functions.ts
-var check = /* @__PURE__ */ __name((eb, args, { client, model, modelAlias, operation }) => {
-  invariant15(args.length === 1 || args.length === 2, '"check" function requires 1 or 2 arguments');
-  const arg1Node = args[0].toOperationNode();
-  const arg2Node = args.length === 2 ? args[1].toOperationNode() : void 0;
-  if (arg2Node) {
-    invariant15(ValueNode5.is(arg2Node) && typeof arg2Node.value === "string", '"operation" parameter must be a string literal when provided');
-    invariant15(CRUD.includes(arg2Node.value), '"operation" parameter must be one of "create", "read", "update", "delete"');
-  }
-  const fieldName = extractFieldName(arg1Node);
-  invariant15(fieldName, 'Failed to extract field name from the first argument of "check" function');
-  const fieldDef = requireField(client.$schema, model, fieldName);
-  invariant15(fieldDef.relation, `Field "${fieldName}" is not a relation field in model "${model}"`);
-  invariant15(!fieldDef.array, `Field "${fieldName}" is a to-many relation, which is not supported by "check"`);
-  const relationModel = fieldDef.type;
-  const op = arg2Node ? arg2Node.value : operation;
-  const policyHandler = new PolicyHandler(client);
-  const joinPairs = buildJoinPairs(client.$schema, model, modelAlias, fieldName, relationModel);
-  const joinCondition = joinPairs.length === 1 ? eb(eb.ref(joinPairs[0][0]), "=", eb.ref(joinPairs[0][1])) : eb.and(joinPairs.map(([left, right]) => eb(eb.ref(left), "=", eb.ref(right))));
-  const policyCondition = policyHandler.buildPolicyFilter(relationModel, void 0, op);
-  const result = eb.selectFrom(relationModel).where(joinCondition).select(new ExpressionWrapper2(policyCondition).as("$condition"));
-  return result;
-}, "check");
-
-// src/plugins/policy/plugin.ts
-var PolicyPlugin = class {
-  static {
-    __name(this, "PolicyPlugin");
-  }
-  get id() {
-    return "policy";
-  }
-  get name() {
-    return "Access Policy";
-  }
-  get description() {
-    return "Enforces access policies defined in the schema.";
-  }
-  get functions() {
-    return {
-      check
-    };
-  }
-  onKyselyQuery({ query, client, proceed }) {
-    const handler = new PolicyHandler(client);
-    return handler.handle(query, proceed);
-  }
-};
-export {
-  PolicyPlugin,
-  RejectedByPolicyError,
-  RejectedByPolicyReason
-};
-//# sourceMappingURL=index.js.map