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

package/dist/plugins/policy/index.cjs

@@ -1,3478 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/plugins/policy/index.ts
-var policy_exports = {};
-__export(policy_exports, {
-  PolicyPlugin: () => PolicyPlugin,
-  RejectedByPolicyError: () => RejectedByPolicyError,
-  RejectedByPolicyReason: () => RejectedByPolicyReason
-});
-module.exports = __toCommonJS(policy_exports);
-
-// src/client/client-impl.ts
-var import_common_helpers12 = require("@zenstackhq/common-helpers");
-var import_kysely13 = require("kysely");
-
-// src/client/crud/operations/aggregate.ts
-var import_kysely5 = require("kysely");
-var import_ts_pattern7 = require("ts-pattern");
-
-// src/client/query-utils.ts
-var import_common_helpers = require("@zenstackhq/common-helpers");
-var import_ts_pattern = require("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);
-    (0, import_common_helpers.invariant)(modelIdFields.length === 1, "Only single-field ID is supported for many-to-many relation");
-    const otherIdFields = requireIdFields(schema, fieldDef.type);
-    (0, import_common_helpers.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 (0, import_ts_pattern.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
-var import_cuid2 = require("@paralleldrive/cuid2");
-var import_common_helpers6 = require("@zenstackhq/common-helpers");
-var import_kysely4 = require("kysely");
-var import_nanoid = require("nanoid");
-var import_ts_pattern6 = require("ts-pattern");
-var import_ulid = require("ulid");
-var uuid = __toESM(require("uuid"), 1);
-
-// src/utils/clone.ts
-var import_common_helpers2 = require("@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
-var import_ts_pattern5 = require("ts-pattern");
-
-// src/client/crud/dialects/postgresql.ts
-var import_common_helpers4 = require("@zenstackhq/common-helpers");
-var import_decimal = __toESM(require("decimal.js"), 1);
-var import_kysely2 = require("kysely");
-var import_ts_pattern3 = require("ts-pattern");
-
-// src/client/crud/dialects/base-dialect.ts
-var import_common_helpers3 = require("@zenstackhq/common-helpers");
-var import_kysely = require("kysely");
-var import_ts_pattern2 = require("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) => import_kysely.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 = (0, import_kysely.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 (0, import_ts_pattern2.match)(key).with("AND", () => this.and(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("OR", () => this.or(eb, ...enumerate(payload).map((subPayload) => this.buildFilter(eb, model, modelAlias, subPayload)))).with("NOT", () => eb.not(this.buildCompositeFilter(eb, model, modelAlias, "AND", payload))).exhaustive();
-  }
-  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(import_kysely.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(import_kysely.sql.ref(left), "=", import_kysely.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(import_kysely.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);
-        (0, import_common_helpers3.invariant)(modelIdFields.length === 1, "many-to-many relation must have exactly one id field");
-        const relationIdFields = requireIdFields(this.schema, relationModel);
-        (0, import_common_helpers3.invariant)(relationIdFields.length === 1, "many-to-many relation must have exactly one id field");
-        return eb2(import_kysely.sql.ref(`${relationFilterSelectAlias}.${relationIdFields[0]}`), "in", eb2.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(import_kysely.sql.ref(`${m2m.joinTable}.${m2m.parentFkName}`), "=", import_kysely.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(import_kysely.sql.ref(`${modelAlias}.${fk}`), "=", import_kysely.sql.ref(`${relationFilterSelectAlias}.${pk}`)));
-          } else {
-            result2 = this.and(eb2, result2, eb2(import_kysely.sql.ref(`${modelAlias}.${pk}`), "=", import_kysely.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 (0, import_ts_pattern2.match)(fieldDef.type).with("String", () => this.buildStringFilter(eb, fieldRef, payload)).with(import_ts_pattern2.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 || !(0, import_common_helpers3.isPlainObject)(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 = (0, import_ts_pattern2.match)(op).with("equals", () => rhs === null ? eb(lhs, "is", null) : eb(lhs, "=", rhs)).with("in", () => {
-        (0, import_common_helpers3.invariant)(Array.isArray(rhs), "right hand side must be an array");
-        if (rhs.length === 0) {
-          return this.false(eb);
-        } else {
-          return eb(lhs, "in", rhs);
-        }
-      }).with("notIn", () => {
-        (0, import_common_helpers3.invariant)(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(import_ts_pattern2.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 = (0, import_ts_pattern2.match)(key).with("contains", () => mode === "insensitive" ? eb(fieldRef, "ilike", import_kysely.sql.val(`%${value}%`)) : eb(fieldRef, "like", import_kysely.sql.val(`%${value}%`))).with("startsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", import_kysely.sql.val(`${value}%`)) : eb(fieldRef, "like", import_kysely.sql.val(`${value}%`))).with("endsWith", () => mode === "insensitive" ? eb(fieldRef, "ilike", import_kysely.sql.val(`%${value}`)) : eb(fieldRef, "like", import_kysely.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 : import_kysely.sql.val(value);
-    }
-    if (typeof value === "string") {
-      return eb.fn("lower", [
-        import_kysely.sql.val(value)
-      ]);
-    } else if (Array.isArray(value)) {
-      return value.map((v) => this.prepStringCasing(eb, v, mode));
-    } else {
-      return value === null ? null : import_kysely.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)) {
-          (0, import_common_helpers3.invariant)(value && typeof value === "object", `invalid orderBy value for field "${field}"`);
-          for (const [k, v] of Object.entries(value)) {
-            (0, import_common_helpers3.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-            result = result.orderBy((eb) => aggregate(eb, this.fieldRef(model, k, eb, modelAlias), field), import_kysely.sql.raw(this.negateSort(v, negated)));
-          }
-          continue;
-        }
-        switch (field) {
-          case "_count": {
-            (0, import_common_helpers3.invariant)(value && typeof value === "object", 'invalid orderBy value for field "_count"');
-            for (const [k, v] of Object.entries(value)) {
-              (0, import_common_helpers3.invariant)(v === "asc" || v === "desc", `invalid orderBy value for field "${field}"`);
-              result = result.orderBy((eb) => eb.fn.count(this.fieldRef(model, k, eb, modelAlias)), import_kysely.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, (0, import_kysely.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, import_kysely.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) {
-              (0, import_common_helpers3.invariant)(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(import_kysely.sql.ref(left), "=", import_kysely.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(import_kysely.sql.ref(left), "=", import_kysely.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(import_kysely.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 (0, import_ts_pattern3.match)(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 (0, import_ts_pattern3.match)(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;
-    }
-    (0, import_common_helpers4.invariant)(typeof value === "string" || typeof value === "number", `Expected string or number, got ${typeof value}`);
-    return BigInt(value);
-  }
-  transformDecimal(value) {
-    if (value instanceof import_decimal.default) {
-      return value;
-    }
-    (0, import_common_helpers4.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal.default, `Expected string, number or Decimal, got ${typeof value}`);
-    return new import_decimal.default(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);
-      (0, import_common_helpers4.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
-      (0, import_common_helpers4.invariant)(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(import_kysely2.sql.ref(left), "=", import_kysely2.sql.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(import_kysely2.sql`jsonb_agg(jsonb_build_object(${import_kysely2.sql.join(objArgs)}))`, import_kysely2.sql`'[]'::jsonb`).as("$data");
-      } else {
-        return import_kysely2.sql`jsonb_build_object(${import_kysely2.sql.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) => [
-        import_kysely2.sql.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]) => [
-        import_kysely2.sql.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 [
-            import_kysely2.sql.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 [
-            import_kysely2.sql.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]) => [
-        import_kysely2.sql.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]) => [
-      import_kysely2.sql.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 = (0, import_ts_pattern3.match)(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
-var import_common_helpers5 = require("@zenstackhq/common-helpers");
-var import_decimal2 = __toESM(require("decimal.js"), 1);
-var import_kysely3 = require("kysely");
-var import_ts_pattern4 = require("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 (0, import_ts_pattern4.match)(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 (0, import_ts_pattern4.match)(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 import_decimal2.default) {
-      return value;
-    }
-    (0, import_common_helpers5.invariant)(typeof value === "string" || typeof value === "number" || value instanceof import_decimal2.default, `Expected string, number or Decimal, got ${typeof value}`);
-    return new import_decimal2.default(value);
-  }
-  transformOutputBigInt(value) {
-    if (typeof value === "bigint") {
-      return value;
-    }
-    (0, import_common_helpers5.invariant)(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) => [
-          import_kysely3.sql.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]) => [
-          import_kysely3.sql.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 [
-              import_kysely3.sql.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 [
-                import_kysely3.sql.lit(field),
-                subJson
-              ];
-            } else {
-              return [
-                import_kysely3.sql.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 [
-            import_kysely3.sql.lit(field),
-            subJson
-          ];
-        }).flatMap((v) => v));
-      }
-      if (relationFieldDef.array) {
-        return eb.fn.coalesce(import_kysely3.sql`json_group_array(json_object(${import_kysely3.sql.join(objArgs)}))`, import_kysely3.sql`json_array()`).as("$data");
-      } else {
-        return import_kysely3.sql`json_object(${import_kysely3.sql.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);
-      (0, import_common_helpers5.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
-      (0, import_common_helpers5.invariant)(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]) => [
-      import_kysely3.sql.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 (0, import_ts_pattern4.match)(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 (0, import_ts_pattern5.match)(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
-var import_kysely6 = require("kysely");
-
-// src/client/crud/operations/create.ts
-var import_ts_pattern8 = require("ts-pattern");
-
-// src/client/crud/operations/delete.ts
-var import_ts_pattern9 = require("ts-pattern");
-
-// src/client/crud/operations/group-by.ts
-var import_kysely7 = require("kysely");
-var import_ts_pattern10 = require("ts-pattern");
-
-// src/client/crud/operations/update.ts
-var import_ts_pattern11 = require("ts-pattern");
-
-// src/client/crud/validator.ts
-var import_common_helpers7 = require("@zenstackhq/common-helpers");
-var import_decimal3 = __toESM(require("decimal.js"), 1);
-var import_json_stable_stringify = __toESM(require("json-stable-stringify"), 1);
-var import_ts_pattern12 = require("ts-pattern");
-var import_zod = require("zod");
-
-// src/utils/zod-utils.ts
-var import_v3 = require("zod-validation-error/v3");
-var import_v4 = require("zod-validation-error/v4");
-
-// src/client/executor/zenstack-query-executor.ts
-var import_common_helpers9 = require("@zenstackhq/common-helpers");
-var import_kysely10 = require("kysely");
-var import_ts_pattern13 = require("ts-pattern");
-
-// src/client/kysely-utils.ts
-var import_kysely8 = require("kysely");
-function extractFieldName(node) {
-  if (import_kysely8.ReferenceNode.is(node) && import_kysely8.ColumnNode.is(node.column)) {
-    return node.column.column.name;
-  } else if (import_kysely8.ColumnNode.is(node)) {
-    return node.column.name;
-  } else {
-    return void 0;
-  }
-}
-__name(extractFieldName, "extractFieldName");
-
-// src/client/executor/name-mapper.ts
-var import_common_helpers8 = require("@zenstackhq/common-helpers");
-var import_kysely9 = require("kysely");
-
-// src/client/functions.ts
-var import_common_helpers10 = require("@zenstackhq/common-helpers");
-var import_kysely11 = require("kysely");
-var import_ts_pattern14 = require("ts-pattern");
-
-// src/client/helpers/schema-db-pusher.ts
-var import_common_helpers11 = require("@zenstackhq/common-helpers");
-var import_kysely12 = require("kysely");
-var import_toposort = __toESM(require("toposort"), 1);
-var import_ts_pattern15 = require("ts-pattern");
-
-// src/client/index.ts
-var import_kysely14 = require("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
-var import_common_helpers16 = require("@zenstackhq/common-helpers");
-var import_kysely19 = require("kysely");
-
-// src/plugins/policy/policy-handler.ts
-var import_common_helpers15 = require("@zenstackhq/common-helpers");
-var import_kysely18 = require("kysely");
-var import_ts_pattern19 = require("ts-pattern");
-
-// src/utils/expression-utils.ts
-var import_ts_pattern16 = require("ts-pattern");
-var ExpressionVisitor = class {
-  static {
-    __name(this, "ExpressionVisitor");
-  }
-  visit(expr2) {
-    (0, import_ts_pattern16.match)(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
-var import_kysely15 = require("kysely");
-var DefaultOperationNodeVisitor = class extends import_kysely15.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
-var import_common_helpers14 = require("@zenstackhq/common-helpers");
-var import_kysely17 = require("kysely");
-var import_ts_pattern18 = require("ts-pattern");
-
-// src/plugins/policy/expression-evaluator.ts
-var import_common_helpers13 = require("@zenstackhq/common-helpers");
-var import_ts_pattern17 = require("ts-pattern");
-var ExpressionEvaluator = class {
-  static {
-    __name(this, "ExpressionEvaluator");
-  }
-  evaluate(expression, context) {
-    const result = (0, import_ts_pattern17.match)(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 (0, import_ts_pattern17.match)(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 (0, import_ts_pattern17.match)(expr2.op).with("==", () => left === right).with("!=", () => left !== right).with(">", () => left > right).with(">=", () => left >= right).with("<", () => left < right).with("<=", () => left <= right).with("&&", () => left && right).with("||", () => left || right).with("in", () => {
-      const _right = right ?? [];
-      (0, import_common_helpers13.invariant)(Array.isArray(_right), 'expected array for "in" operator');
-      return _right.includes(left);
-    }).exhaustive();
-  }
-  evaluateCollectionPredicate(expr2, context) {
-    const op = expr2.op;
-    (0, import_common_helpers13.invariant)(op === "?" || op === "!" || op === "^", 'expected "?" or "!" or "^" operator');
-    const left = this.evaluate(expr2.left, context);
-    if (!left) {
-      return false;
-    }
-    (0, import_common_helpers13.invariant)(Array.isArray(left), "expected array");
-    return (0, import_ts_pattern17.match)(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
-var import_kysely16 = require("kysely");
-function trueNode(dialect) {
-  return import_kysely16.ValueNode.createImmediate(dialect.transformPrimitive(true, "Boolean", false));
-}
-__name(trueNode, "trueNode");
-function falseNode(dialect) {
-  return import_kysely16.ValueNode.createImmediate(dialect.transformPrimitive(false, "Boolean", false));
-}
-__name(falseNode, "falseNode");
-function isTrueNode(node) {
-  return import_kysely16.ValueNode.is(node) && (node.value === true || node.value === 1);
-}
-__name(isTrueNode, "isTrueNode");
-function isFalseNode(node) {
-  return import_kysely16.ValueNode.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) => import_kysely16.AndNode.create(wrapParensIf(acc, import_kysely16.OrNode.is), wrapParensIf(node, import_kysely16.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) => import_kysely16.OrNode.create(wrapParensIf(acc, import_kysely16.AndNode.is), wrapParensIf(node, import_kysely16.AndNode.is)));
-}
-__name(disjunction, "disjunction");
-function logicalNot(dialect, node) {
-  if (isTrueNode(node)) {
-    return falseNode(dialect);
-  }
-  if (isFalseNode(node)) {
-    return trueNode(dialect);
-  }
-  return import_kysely16.UnaryOperationNode.create(import_kysely16.OperatorNode.create("not"), wrapParensIf(node, (n) => import_kysely16.AndNode.is(n) || import_kysely16.OrNode.is(n)));
-}
-__name(logicalNot, "logicalNot");
-function wrapParensIf(node, predicate) {
-  return predicate(node) ? import_kysely16.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 import_kysely16.BinaryOperationNode.create(
-    // coalesce so null is treated as false
-    import_kysely16.FunctionNode.create("coalesce", [
-      node,
-      falseNode(dialect)
-    ]),
-    import_kysely16.OperatorNode.create("="),
-    falseNode(dialect)
-  );
-}
-__name(buildIsFalse, "buildIsFalse");
-function getTableName(node) {
-  if (!node) {
-    return node;
-  }
-  if (import_kysely16.TableNode.is(node)) {
-    return node.table.identifier.name;
-  } else if (import_kysely16.AliasNode.is(node)) {
-    return getTableName(node.node);
-  } else if (import_kysely16.ReferenceNode.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 import_kysely17.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 import_kysely17.WhereNode.create(memberFilter ?? trueNode(this.dialect));
-    }
-    if (!memberFilter) {
-      return where;
-    }
-    return import_kysely17.WhereNode.create(conjunction(this.dialect, [
-      where.where,
-      memberFilter
-    ]));
-  }
-  _null() {
-    return import_kysely17.ValueNode.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 (import_kysely17.ValueListNode.is(right)) {
-          return import_kysely17.BinaryOperationNode.create(left, import_kysely17.OperatorNode.create("in"), right);
-        } else {
-          return import_kysely17.BinaryOperationNode.create(left, import_kysely17.OperatorNode.create("="), import_kysely17.FunctionNode.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 import_kysely17.BinaryOperationNode.create(left, this.transformOperator(op), right);
-    }
-  }
-  transformNullCheck(expr2, operator) {
-    (0, import_common_helpers14.invariant)(operator === "==" || operator === "!=", 'operator must be "==" or "!=" for null comparison');
-    if (import_kysely17.ValueNode.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 === "==" ? import_kysely17.BinaryOperationNode.create(expr2, import_kysely17.OperatorNode.create("is"), import_kysely17.ValueNode.createImmediate(null)) : import_kysely17.BinaryOperationNode.create(expr2, import_kysely17.OperatorNode.create("is not"), import_kysely17.ValueNode.createImmediate(null));
-    }
-  }
-  normalizeBinaryOperationOperands(expr2, context) {
-    let normalizedLeft = expr2.left;
-    if (this.isRelationField(expr2.left, context.model)) {
-      (0, import_common_helpers14.invariant)(ExpressionUtils.isNull(expr2.right), "only null comparison is supported for relation field");
-      const leftRelDef = this.getFieldDefFromFieldRef(expr2.left, context.model);
-      (0, import_common_helpers14.invariant)(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)) {
-      (0, import_common_helpers14.invariant)(ExpressionUtils.isNull(expr2.left), "only null comparison is supported for relation field");
-      const rightRelDef = this.getFieldDefFromFieldRef(expr2.right, context.model);
-      (0, import_common_helpers14.invariant)(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) {
-    (0, import_common_helpers14.invariant)(expr2.op === "?" || expr2.op === "!" || expr2.op === "^", 'expected "?" or "!" or "^" operator');
-    if (this.isAuthCall(expr2.left) || this.isAuthMember(expr2.left)) {
-      const value = new ExpressionEvaluator().evaluate(expr2, {
-        auth: this.auth
-      });
-      return this.transformValue(value, "Boolean");
-    }
-    (0, import_common_helpers14.invariant)(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) {
-      (0, import_common_helpers14.invariant)(fieldDef.relation, `field is not a relation: ${JSON.stringify(expr2.left)}`);
-      newContextModel = fieldDef.type;
-    } else {
-      (0, import_common_helpers14.invariant)(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 = import_kysely17.FunctionNode.create("count", [
-      import_kysely17.ValueNode.createImmediate(1)
-    ]);
-    const predicateResult = (0, import_ts_pattern18.match)(expr2.op).with("?", () => import_kysely17.BinaryOperationNode.create(count, import_kysely17.OperatorNode.create(">"), import_kysely17.ValueNode.createImmediate(0))).with("!", () => import_kysely17.BinaryOperationNode.create(count, import_kysely17.OperatorNode.create("="), import_kysely17.ValueNode.createImmediate(0))).with("^", () => import_kysely17.BinaryOperationNode.create(count, import_kysely17.OperatorNode.create("="), import_kysely17.ValueNode.createImmediate(0))).exhaustive();
-    return this.transform(expr2.left, {
-      ...context,
-      memberSelect: import_kysely17.SelectionNode.create(import_kysely17.AliasNode.create(predicateResult, import_kysely17.IdentifierNode.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);
-      (0, import_common_helpers14.invariant)(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 import_kysely17.ValueNode.create(this.dialect.transformPrimitive(value, type, false) ?? null);
-    }
-  }
-  _unary(expr2, context) {
-    (0, import_common_helpers14.invariant)(expr2.op === "!", 'only "!" operator is supported');
-    return logicalNot(this.dialect, this.transform(expr2.operand, context));
-  }
-  transformOperator(op) {
-    const mappedOp = (0, import_ts_pattern18.match)(op).with("==", () => "=").otherwise(() => op);
-    return import_kysely17.OperatorNode.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 = (0, import_kysely17.expressionBuilder)();
-    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)) {
-      (0, import_common_helpers14.invariant)(context.operation === "post-update", "before() can only be used in post-update policy");
-      (0, import_common_helpers14.invariant)(expr2.members.length === 1, "before() can only be followed by a scalar field access");
-      return import_kysely17.ReferenceNode.create(import_kysely17.ColumnNode.create(expr2.members[0]), import_kysely17.TableNode.create("$before"));
-    }
-    (0, import_common_helpers14.invariant)(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);
-    }
-    (0, import_common_helpers14.invariant)(import_kysely17.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: [
-              import_kysely17.SelectionNode.create(import_kysely17.AliasNode.create(currNode, import_kysely17.IdentifierNode.create(members[i + 1])))
-            ]
-          };
-        } else {
-          currNode = {
-            ...relation,
-            where: this.mergeWhere(relation.where, memberFilter),
-            selections: memberSelect ? [
-              memberSelect
-            ] : relation.selections
-          };
-        }
-      } else {
-        (0, import_common_helpers14.invariant)(i === members.length - 1, "plain field access must be the last segment");
-        (0, import_common_helpers14.invariant)(!currNode, "plain field access must be the last segment");
-        currNode = import_kysely17.ColumnNode.create(member);
-      }
-    }
-    return {
-      ...receiver,
-      selections: [
-        import_kysely17.SelectionNode.create(import_kysely17.AliasNode.create(currNode, import_kysely17.IdentifierNode.create("$t")))
-      ]
-    };
-  }
-  valueMemberAccess(receiver, expr2, receiverType) {
-    if (!receiver) {
-      return import_kysely17.ValueNode.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 }) => import_kysely17.BinaryOperationNode.create(import_kysely17.ReferenceNode.create(import_kysely17.ColumnNode.create(fk), import_kysely17.TableNode.create(context.alias ?? fromModel)), import_kysely17.OperatorNode.create("="), import_kysely17.ReferenceNode.create(import_kysely17.ColumnNode.create(pk), import_kysely17.TableNode.create(relationModel)))));
-    } else {
-      condition = conjunction(this.dialect, keyPairs.map(({ fk, pk }) => import_kysely17.BinaryOperationNode.create(import_kysely17.ReferenceNode.create(import_kysely17.ColumnNode.create(pk), import_kysely17.TableNode.create(context.alias ?? fromModel)), import_kysely17.OperatorNode.create("="), import_kysely17.ReferenceNode.create(import_kysely17.ColumnNode.create(fk), import_kysely17.TableNode.create(relationModel)))));
-    }
-    return {
-      kind: "SelectQueryNode",
-      from: import_kysely17.FromNode.create([
-        import_kysely17.TableNode.create(relationModel)
-      ]),
-      where: import_kysely17.WhereNode.create(condition)
-    };
-  }
-  transformManyToManyRelationAccess(m2m, context) {
-    const eb = (0, import_kysely17.expressionBuilder)();
-    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 import_kysely17.ReferenceNode.create(import_kysely17.ColumnNode.create(column), import_kysely17.TableNode.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 import_kysely17.ValueNode.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 import_kysely18.OperationNodeTransformer {
-  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 (import_kysely18.InsertQueryNode.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 = import_kysely18.UpdateQueryNode.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 = (0, import_kysely18.expressionBuilder)();
-      const beforeUpdateTable = beforeUpdateInfo ? {
-        kind: "SelectQueryNode",
-        from: import_kysely18.FromNode.create([
-          import_kysely18.ParensNode.create(import_kysely18.ValuesNode.create(beforeUpdateInfo.rows.map((r) => import_kysely18.PrimitiveValueListNode.create(beforeUpdateInfo.fields.map((f) => r[f])))))
-        ]),
-        selections: beforeUpdateInfo.fields.map((name, index) => {
-          const def = requireField(this.client.$schema, mutationModel, name);
-          const castedColumnRef = import_kysely18.sql`CAST(${eb.ref(`column${index + 1}`)} as ${import_kysely18.sql.raw(this.dialect.getFieldSqlType(def))})`.as(name);
-          return import_kysely18.SelectionNode.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 import_kysely18.ExpressionWrapper(conjunction(this.dialect, [
-        idConditions,
-        postUpdateFilter
-      ]))).$if(!!beforeUpdateInfo, (qb) => qb.leftJoin(() => new import_kysely18.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: import_kysely18.FromNode.create([
-        import_kysely18.TableNode.create(model)
-      ]),
-      where,
-      selections: [
-        ...beforeUpdateAccessFields.map((f) => import_kysely18.SelectionNode.create(import_kysely18.ColumnNode.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)) {
-          (0, import_common_helpers15.invariant)(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 = import_kysely18.WhereNode.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: import_kysely18.FromNode.create([
-        node.table
-      ]),
-      selections: [
-        import_kysely18.SelectionNode.createSelectAll()
-      ],
-      where: import_kysely18.WhereNode.create(filter)
-    };
-    return {
-      ...node,
-      table: import_kysely18.AliasNode.create(import_kysely18.ParensNode.create(nestedSelect), import_kysely18.IdentifierNode.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: import_kysely18.WhereNode.create(conjunction(this.dialect, [
-            onConflict.updateWhere.where,
-            filter
-          ]))
-        };
-      } else {
-        onConflict = {
-          ...onConflict,
-          updateWhere: import_kysely18.WhereNode.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 = import_kysely18.ReturningNode.create(idFields.map((f) => import_kysely18.SelectionNode.create(import_kysely18.ColumnNode.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 = import_kysely18.ReturningNode.create(idFields.map((f) => import_kysely18.SelectionNode.create(import_kysely18.ColumnNode.create(f))));
-    }
-    return {
-      ...result,
-      where: import_kysely18.WhereNode.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: import_kysely18.WhereNode.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) => import_kysely18.SelectAllNode.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);
-    (0, import_common_helpers15.invariant)(m2m);
-    (0, import_common_helpers15.invariant)(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];
-    (0, import_common_helpers15.invariant)(import_kysely18.ValueNode.is(aNode) && import_kysely18.ValueNode.is(bNode), "A and B values must be ValueNode");
-    const aValue = aNode.value;
-    const bValue = bNode.value;
-    (0, import_common_helpers15.invariant)(aValue !== null && aValue !== void 0, "A value cannot be null or undefined");
-    (0, import_common_helpers15.invariant)(bValue !== null && bValue !== void 0, "B value cannot be null or undefined");
-    const eb = (0, import_kysely18.expressionBuilder)();
-    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 import_kysely18.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 import_kysely18.ExpressionWrapper(filterB).as("$t"));
-    const queryNode = {
-      kind: "SelectQueryNode",
-      selections: [
-        import_kysely18.SelectionNode.create(import_kysely18.AliasNode.create(queryA.toOperationNode(), import_kysely18.IdentifierNode.create("$conditionA"))),
-        import_kysely18.SelectionNode.create(import_kysely18.AliasNode.create(queryB.toOperationNode(), import_kysely18.IdentifierNode.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(import_kysely18.ValueNode.createImmediate(null));
-      }
-    }
-    const eb = (0, import_kysely18.expressionBuilder)();
-    const constTable = {
-      kind: "SelectQueryNode",
-      from: import_kysely18.FromNode.create([
-        import_kysely18.AliasNode.create(import_kysely18.ParensNode.create(import_kysely18.ValuesNode.create([
-          import_kysely18.ValueListNode.create(allValues)
-        ])), import_kysely18.IdentifierNode.create("$t"))
-      ]),
-      selections: allFields.map(([name, def], index) => {
-        const castedColumnRef = import_kysely18.sql`CAST(${eb.ref(`column${index + 1}`)} as ${import_kysely18.sql.raw(this.dialect.getFieldSqlType(def))})`.as(name);
-        return import_kysely18.SelectionNode.create(castedColumnRef.toOperationNode());
-      })
-    };
-    const filter = this.buildPolicyFilter(model, void 0, "create");
-    const preCreateCheck = {
-      kind: "SelectQueryNode",
-      from: import_kysely18.FromNode.create([
-        import_kysely18.AliasNode.create(constTable, import_kysely18.IdentifierNode.create(model))
-      ]),
-      selections: [
-        import_kysely18.SelectionNode.create(import_kysely18.AliasNode.create(import_kysely18.BinaryOperationNode.create(import_kysely18.FunctionNode.create("COUNT", [
-          import_kysely18.ValueNode.createImmediate(1)
-        ]), import_kysely18.OperatorNode.create(">"), import_kysely18.ValueNode.createImmediate(0)), import_kysely18.IdentifierNode.create("$condition")))
-      ],
-      where: import_kysely18.WhereNode.create(filter)
-    };
-    const result = await proceed(preCreateCheck);
-    if (!result.rows[0]?.$condition) {
-      throw new RejectedByPolicyError(model);
-    }
-  }
-  unwrapCreateValueRows(node, model, fields, isManyToManyJoinTable) {
-    if (import_kysely18.ValuesNode.is(node)) {
-      return node.values.map((v) => this.unwrapCreateValueRow(v.values, model, fields, isManyToManyJoinTable));
-    } else if (import_kysely18.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) {
-    (0, import_common_helpers15.invariant)(data.length === fields.length, "data length must match fields length");
-    const result = [];
-    for (let i = 0; i < data.length; i++) {
-      const item = data[i];
-      if (typeof item === "object" && item && "kind" in item) {
-        const fieldDef = requireField(this.client.$schema, model, fields[i]);
-        (0, import_common_helpers15.invariant)(item.kind === "ValueNode", "expecting a ValueNode");
-        result.push({
-          node: import_kysely18.ValueNode.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: import_kysely18.RawNode.createWithSql(this.dialect.buildArrayLiteralSQL(value)),
-            raw: value
-          });
-        } else {
-          result.push({
-            node: import_kysely18.ValueNode.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: import_kysely18.FromNode.create([
-        import_kysely18.TableNode.create(mutationModel)
-      ]),
-      where: import_kysely18.WhereNode.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) => import_kysely18.BinaryOperationNode.create(import_kysely18.ReferenceNode.create(import_kysely18.ColumnNode.create(field), import_kysely18.TableNode.create(table)), import_kysely18.OperatorNode.create("="), import_kysely18.ValueNode.create(row[field]))))));
-  }
-  getMutationModel(node) {
-    const r = (0, import_ts_pattern19.match)(node).when(import_kysely18.InsertQueryNode.is, (node2) => ({
-      mutationModel: getTableName(node2.into),
-      alias: void 0
-    })).when(import_kysely18.UpdateQueryNode.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(import_kysely18.DeleteQueryNode.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 import_kysely18.SelectQueryNode.is(node) || import_kysely18.InsertQueryNode.is(node) || import_kysely18.UpdateQueryNode.is(node) || import_kysely18.DeleteQueryNode.is(node);
-  }
-  isMutationQueryNode(node) {
-    return import_kysely18.InsertQueryNode.is(node) || import_kysely18.UpdateQueryNode.is(node) || import_kysely18.DeleteQueryNode.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 (import_kysely18.TableNode.is(node)) {
-      return {
-        model: node.table.identifier.name
-      };
-    }
-    if (import_kysely18.AliasNode.is(node)) {
-      const inner = this.extractTableName(node.node);
-      if (!inner) {
-        return void 0;
-      }
-      return {
-        model: inner.model,
-        alias: import_kysely18.IdentifierNode.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) => {
-      (0, import_common_helpers15.invariant)(ExpressionUtils.isLiteral(expr2), "expecting a literal");
-      (0, import_common_helpers15.invariant)(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);
-          (0, import_common_helpers15.invariant)(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 = (0, import_kysely18.expressionBuilder)();
-    const joinTable = alias ?? tableName;
-    const aQuery = eb.selectFrom(m2m.firstModel).whereRef(`${m2m.firstModel}.${m2m.firstIdField}`, "=", `${joinTable}.A`).select(() => new import_kysely18.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 import_kysely18.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 }) => {
-  (0, import_common_helpers16.invariant)(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) {
-    (0, import_common_helpers16.invariant)(import_kysely19.ValueNode.is(arg2Node) && typeof arg2Node.value === "string", '"operation" parameter must be a string literal when provided');
-    (0, import_common_helpers16.invariant)(CRUD.includes(arg2Node.value), '"operation" parameter must be one of "create", "read", "update", "delete"');
-  }
-  const fieldName = extractFieldName(arg1Node);
-  (0, import_common_helpers16.invariant)(fieldName, 'Failed to extract field name from the first argument of "check" function');
-  const fieldDef = requireField(client.$schema, model, fieldName);
-  (0, import_common_helpers16.invariant)(fieldDef.relation, `Field "${fieldName}" is not a relation field in model "${model}"`);
-  (0, import_common_helpers16.invariant)(!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 import_kysely19.ExpressionWrapper(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);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PolicyPlugin,
-  RejectedByPolicyError,
-  RejectedByPolicyReason
-});
-//# sourceMappingURL=index.cjs.map