@zenstackhq/runtime 3.0.0-alpha.11 → 3.0.0-alpha.13

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

@@ -26,6 +26,88 @@ import { invariant as invariant2 } from "@zenstackhq/common-helpers";
 import { sql as sql2 } from "kysely";
 import { match as match2 } from "ts-pattern";
 
+// src/client/constants.ts
+var DELEGATE_JOINED_FIELD_PREFIX = "$delegate$";
+
+// src/schema/expression.ts
+var ExpressionUtils = {
+  literal: /* @__PURE__ */ __name((value) => {
+    return {
+      kind: "literal",
+      value
+    };
+  }, "literal"),
+  array: /* @__PURE__ */ __name((items) => {
+    return {
+      kind: "array",
+      items
+    };
+  }, "array"),
+  call: /* @__PURE__ */ __name((functionName, args) => {
+    return {
+      kind: "call",
+      function: functionName,
+      args
+    };
+  }, "call"),
+  binary: /* @__PURE__ */ __name((left, op, right) => {
+    return {
+      kind: "binary",
+      op,
+      left,
+      right
+    };
+  }, "binary"),
+  unary: /* @__PURE__ */ __name((op, operand) => {
+    return {
+      kind: "unary",
+      op,
+      operand
+    };
+  }, "unary"),
+  field: /* @__PURE__ */ __name((field) => {
+    return {
+      kind: "field",
+      field
+    };
+  }, "field"),
+  member: /* @__PURE__ */ __name((receiver, members) => {
+    return {
+      kind: "member",
+      receiver,
+      members
+    };
+  }, "member"),
+  _this: /* @__PURE__ */ __name(() => {
+    return {
+      kind: "this"
+    };
+  }, "_this"),
+  _null: /* @__PURE__ */ __name(() => {
+    return {
+      kind: "null"
+    };
+  }, "_null"),
+  and: /* @__PURE__ */ __name((expr2, ...expressions) => {
+    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "&&", exp), expr2);
+  }, "and"),
+  or: /* @__PURE__ */ __name((expr2, ...expressions) => {
+    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "||", exp), expr2);
+  }, "or"),
+  is: /* @__PURE__ */ __name((value, kind) => {
+    return !!value && typeof value === "object" && "kind" in value && value.kind === kind;
+  }, "is"),
+  isLiteral: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "literal"), "isLiteral"),
+  isArray: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "array"), "isArray"),
+  isCall: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "call"), "isCall"),
+  isNull: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "null"), "isNull"),
+  isThis: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "this"), "isThis"),
+  isUnary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "unary"), "isUnary"),
+  isBinary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "binary"), "isBinary"),
+  isField: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "field"), "isField"),
+  isMember: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "member"), "isMember")
+};
+
 // src/client/errors.ts
 var QueryError = class extends Error {
   static {
@@ -44,10 +126,6 @@ var InternalError = class extends Error {
 };
 
 // src/client/query-utils.ts
-function getModel(schema, model) {
-  return schema.models[model];
-}
-__name(getModel, "getModel");
 function requireModel(schema, model) {
   const matchedName = Object.keys(schema.models).find((k) => k.toLowerCase() === model.toLowerCase());
   if (!matchedName) {
@@ -56,11 +134,6 @@ function requireModel(schema, model) {
   return schema.models[matchedName];
 }
 __name(requireModel, "requireModel");
-function getField(schema, model, field) {
-  const modelDef = getModel(schema, model);
-  return modelDef?.fields[field];
-}
-__name(getField, "getField");
 function requireField(schema, model, field) {
   const modelDef = requireModel(schema, model);
   if (!modelDef.fields[field]) {
@@ -119,6 +192,11 @@ function isRelationField(schema, model, field) {
   return !!fieldDef.relation;
 }
 __name(isRelationField, "isRelationField");
+function isInheritedField(schema, model, field) {
+  const fieldDef = requireField(schema, model, field);
+  return !!fieldDef.originModel;
+}
+__name(isInheritedField, "isInheritedField");
 function getUniqueFields(schema, model) {
   const modelDef = requireModel(schema, model);
   const result = [];
@@ -232,6 +310,19 @@ function flattenCompoundUniqueFilters(schema, model, filter) {
   return result;
 }
 __name(flattenCompoundUniqueFilters, "flattenCompoundUniqueFilters");
+function getDelegateDescendantModels(schema, model, collected = /* @__PURE__ */ new Set()) {
+  const subModels = Object.values(schema.models).filter((m) => m.baseModel === model);
+  subModels.forEach((def) => {
+    if (!collected.has(def)) {
+      collected.add(def);
+      getDelegateDescendantModels(schema, def.name, collected);
+    }
+  });
+  return [
+    ...collected
+  ];
+}
+__name(getDelegateDescendantModels, "getDelegateDescendantModels");
 
 // src/client/crud/dialects/base.ts
 import { invariant, isPlainObject } from "@zenstackhq/common-helpers";
@@ -266,6 +357,17 @@ var BaseCrudDialect = class {
   transformPrimitive(value, _type, _forArrayField) {
     return value;
   }
+  // #region common query builders
+  buildSelectModel(eb, model) {
+    const modelDef = requireModel(this.schema, model);
+    let result = eb.selectFrom(model);
+    let joinBase = modelDef.baseModel;
+    while (joinBase) {
+      result = this.buildDelegateJoin(model, joinBase, result);
+      joinBase = requireModel(this.schema, joinBase).baseModel;
+    }
+    return result;
+  }
   buildFilter(eb, model, modelAlias, where) {
     if (where === true || where === void 0) {
       return this.true(eb);
@@ -289,10 +391,13 @@ var BaseCrudDialect = class {
       const fieldDef = requireField(this.schema, model, key);
       if (fieldDef.relation) {
         result = this.and(eb, result, this.buildRelationFilter(eb, model, modelAlias, key, fieldDef, payload));
-      } else if (fieldDef.array) {
-        result = this.and(eb, result, this.buildArrayFilter(eb, model, modelAlias, key, fieldDef, payload));
       } else {
-        result = this.and(eb, result, this.buildPrimitiveFilter(eb, model, modelAlias, key, fieldDef, payload));
+        const fieldRef = buildFieldRef(this.schema, fieldDef.originModel ?? model, key, this.options, 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") {
@@ -310,19 +415,26 @@ var BaseCrudDialect = class {
       return this.buildToManyRelationFilter(eb, model, modelAlias, field, fieldDef, payload);
     }
   }
-  buildToOneRelationFilter(eb, model, table, field, fieldDef, payload) {
+  buildToOneRelationFilter(eb, model, modelAlias, field, fieldDef, payload) {
     if (payload === null) {
       const { ownedByModel, keyPairs } = getRelationForeignKeyFieldPairs(this.schema, model, field);
-      if (ownedByModel) {
-        return this.and(eb, ...keyPairs.map(({ fk }) => eb(sql.ref(`${table}.${fk}`), "is", null)));
+      if (ownedByModel && !fieldDef.originModel) {
+        return this.and(eb, ...keyPairs.map(({ fk }) => eb(sql.ref(`${modelAlias}.${fk}`), "is", null)));
       } else {
-        return this.buildToOneRelationFilter(eb, model, table, field, fieldDef, {
+        return this.buildToOneRelationFilter(eb, model, modelAlias, field, fieldDef, {
           is: null
         });
       }
     }
-    const joinAlias = `${table}$${field}`;
-    const joinPairs = buildJoinPairs(this.schema, model, table, field, joinAlias);
+    const joinAlias = `${modelAlias}$${field}`;
+    const joinPairs = buildJoinPairs(
+      this.schema,
+      model,
+      // if field is from a base, use the base model to join
+      fieldDef.originModel ?? modelAlias,
+      field,
+      joinAlias
+    );
     const filterResultField = `${field}$filter`;
     const joinSelect = eb.selectFrom(`${fieldDef.type} as ${joinAlias}`).where(() => this.and(eb, ...joinPairs.map(([left, right]) => eb(sql.ref(left), "=", sql.ref(right))))).select(() => eb.fn.count(eb.lit(1)).as(filterResultField));
     const conditions = [];
@@ -383,25 +495,24 @@ var BaseCrudDialect = class {
       }
       switch (key) {
         case "some": {
-          result = this.and(eb, result, eb(eb.selectFrom(relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), ">", 0));
+          result = this.and(eb, result, eb(this.buildSelectModel(eb, relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), ">", 0));
           break;
         }
         case "every": {
-          result = this.and(eb, result, eb(eb.selectFrom(relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("count")).where(buildPkFkWhereRefs(eb)).where((eb1) => eb1.not(this.buildFilter(eb1, relationModel, relationModel, subPayload))), "=", 0));
+          result = this.and(eb, result, eb(this.buildSelectModel(eb, relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => eb1.not(this.buildFilter(eb1, relationModel, relationModel, subPayload))), "=", 0));
           break;
         }
         case "none": {
-          result = this.and(eb, result, eb(eb.selectFrom(relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), "=", 0));
+          result = this.and(eb, result, eb(this.buildSelectModel(eb, relationModel).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationModel, subPayload)), "=", 0));
           break;
         }
       }
     }
     return result;
   }
-  buildArrayFilter(eb, model, modelAlias, field, fieldDef, payload) {
+  buildArrayFilter(eb, fieldRef, fieldDef, payload) {
     const clauses = [];
     const fieldType = fieldDef.type;
-    const fieldRef = buildFieldRef(this.schema, model, field, this.options, eb, modelAlias);
     for (const [key, _value] of Object.entries(payload)) {
       if (_value === void 0) {
         continue;
@@ -437,14 +548,14 @@ var BaseCrudDialect = class {
     }
     return this.and(eb, ...clauses);
   }
-  buildPrimitiveFilter(eb, model, modelAlias, field, fieldDef, payload) {
+  buildPrimitiveFilter(eb, fieldRef, fieldDef, payload) {
     if (payload === null) {
-      return eb(sql.ref(`${modelAlias}.${field}`), "is", null);
+      return eb(fieldRef, "is", null);
     }
     if (isEnum(this.schema, fieldDef.type)) {
-      return this.buildEnumFilter(eb, modelAlias, field, fieldDef, payload);
+      return this.buildEnumFilter(eb, fieldRef, fieldDef, payload);
     }
-    return match(fieldDef.type).with("String", () => this.buildStringFilter(eb, modelAlias, field, payload)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(eb, model, modelAlias, field, type, payload)).with("Boolean", () => this.buildBooleanFilter(eb, modelAlias, field, payload)).with("DateTime", () => this.buildDateTimeFilter(eb, modelAlias, field, payload)).with("Bytes", () => this.buildBytesFilter(eb, modelAlias, field, payload)).with("Json", () => {
+    return match(fieldDef.type).with("String", () => this.buildStringFilter(eb, fieldRef, payload)).with(P.union("Int", "Float", "Decimal", "BigInt"), (type) => this.buildNumberFilter(eb, fieldRef, type, payload)).with("Boolean", () => this.buildBooleanFilter(eb, fieldRef, payload)).with("DateTime", () => this.buildDateTimeFilter(eb, fieldRef, payload)).with("Bytes", () => this.buildBytesFilter(eb, fieldRef, payload)).with("Json", () => {
       throw new InternalError("JSON filters are not supported yet");
     }).with("Unsupported", () => {
       throw new QueryError(`Unsupported field cannot be used in filters`);
@@ -500,9 +611,7 @@ var BaseCrudDialect = class {
       consumedKeys
     };
   }
-  buildStringFilter(eb, table, field, payload) {
-    const fieldDef = getField(this.schema, table, field);
-    let fieldRef = fieldDef?.computed ? sql.ref(field) : sql.ref(`${table}.${field}`);
+  buildStringFilter(eb, fieldRef, payload) {
     let insensitive = false;
     if (payload && typeof payload === "object" && "mode" in payload && payload.mode === "insensitive") {
       insensitive = true;
@@ -510,7 +619,7 @@ var BaseCrudDialect = class {
         fieldRef
       ]);
     }
-    const { conditions, consumedKeys } = this.buildStandardFilter(eb, "String", payload, fieldRef, (value) => this.prepStringCasing(eb, value, insensitive), (value) => this.buildStringFilter(eb, table, field, value));
+    const { conditions, consumedKeys } = this.buildStandardFilter(eb, "String", payload, fieldRef, (value) => this.prepStringCasing(eb, value, insensitive), (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)) {
@@ -537,23 +646,23 @@ var BaseCrudDialect = class {
       return value === null ? null : sql.lit(value);
     }
   }
-  buildNumberFilter(eb, model, table, field, type, payload) {
-    const { conditions } = this.buildStandardFilter(eb, type, payload, buildFieldRef(this.schema, model, field, this.options, eb), (value) => this.transformPrimitive(value, type, false), (value) => this.buildNumberFilter(eb, model, table, field, type, value));
+  buildNumberFilter(eb, fieldRef, type, payload) {
+    const { conditions } = this.buildStandardFilter(eb, type, payload, fieldRef, (value) => this.transformPrimitive(value, type, false), (value) => this.buildNumberFilter(eb, fieldRef, type, value));
     return this.and(eb, ...conditions);
   }
-  buildBooleanFilter(eb, table, field, payload) {
-    const { conditions } = this.buildStandardFilter(eb, "Boolean", payload, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Boolean", false), (value) => this.buildBooleanFilter(eb, table, field, value), true, [
+  buildBooleanFilter(eb, fieldRef, payload) {
+    const { conditions } = this.buildStandardFilter(eb, "Boolean", payload, fieldRef, (value) => this.transformPrimitive(value, "Boolean", false), (value) => this.buildBooleanFilter(eb, fieldRef, value), true, [
       "equals",
       "not"
     ]);
     return this.and(eb, ...conditions);
   }
-  buildDateTimeFilter(eb, table, field, payload) {
-    const { conditions } = this.buildStandardFilter(eb, "DateTime", payload, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "DateTime", false), (value) => this.buildDateTimeFilter(eb, table, field, value), true);
+  buildDateTimeFilter(eb, fieldRef, payload) {
+    const { conditions } = this.buildStandardFilter(eb, "DateTime", payload, fieldRef, (value) => this.transformPrimitive(value, "DateTime", false), (value) => this.buildDateTimeFilter(eb, fieldRef, value), true);
     return this.and(eb, ...conditions);
   }
-  buildBytesFilter(eb, table, field, payload) {
-    const conditions = this.buildStandardFilter(eb, "Bytes", payload, sql.ref(`${table}.${field}`), (value) => this.transformPrimitive(value, "Bytes", false), (value) => this.buildBytesFilter(eb, table, field, value), true, [
+  buildBytesFilter(eb, fieldRef, payload) {
+    const conditions = this.buildStandardFilter(eb, "Bytes", payload, fieldRef, (value) => this.transformPrimitive(value, "Bytes", false), (value) => this.buildBytesFilter(eb, fieldRef, value), true, [
       "equals",
       "in",
       "notIn",
@@ -561,8 +670,8 @@ var BaseCrudDialect = class {
     ]);
     return this.and(eb, ...conditions.conditions);
   }
-  buildEnumFilter(eb, table, field, fieldDef, payload) {
-    const conditions = this.buildStandardFilter(eb, "String", payload, sql.ref(`${table}.${field}`), (value) => value, (value) => this.buildEnumFilter(eb, table, field, fieldDef, value), true, [
+  buildEnumFilter(eb, fieldRef, fieldDef, payload) {
+    const conditions = this.buildStandardFilter(eb, "String", payload, fieldRef, (value) => value, (value) => this.buildEnumFilter(eb, fieldRef, fieldDef, value), true, [
       "equals",
       "in",
       "notIn",
@@ -629,7 +738,7 @@ var BaseCrudDialect = class {
               invariant(value._count === "asc" || value._count === "desc", 'invalid orderBy value for field "_count"');
               const sort = this.negateSort(value._count, negated);
               result = result.orderBy((eb) => {
-                let subQuery = eb.selectFrom(relationModel);
+                let subQuery = this.buildSelectModel(eb, relationModel);
                 const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, relationModel);
                 subQuery = subQuery.where(() => this.and(eb, ...joinPairs.map(([left, right]) => eb(sql.ref(left), "=", sql.ref(right)))));
                 subQuery = subQuery.select(() => eb.fn.count(eb.lit(1)).as("_count"));
@@ -648,6 +757,56 @@ var BaseCrudDialect = class {
     });
     return result;
   }
+  buildSelectAllFields(model, query, omit) {
+    const modelDef = requireModel(this.schema, model);
+    let result = query;
+    for (const field of Object.keys(modelDef.fields)) {
+      if (isRelationField(this.schema, model, field)) {
+        continue;
+      }
+      if (omit?.[field] === true) {
+        continue;
+      }
+      result = this.buildSelectField(result, model, model, field);
+    }
+    const descendants = getDelegateDescendantModels(this.schema, model);
+    for (const subModel of descendants) {
+      result = this.buildDelegateJoin(model, subModel.name, result);
+      result = result.select((eb) => {
+        const jsonObject = {};
+        for (const field of Object.keys(subModel.fields)) {
+          if (isRelationField(this.schema, subModel.name, field) || isInheritedField(this.schema, subModel.name, field)) {
+            continue;
+          }
+          jsonObject[field] = eb.ref(`${subModel.name}.${field}`);
+        }
+        return this.buildJsonObject(eb, jsonObject).as(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`);
+      });
+    }
+    return result;
+  }
+  buildSelectField(query, model, modelAlias, field) {
+    const fieldDef = requireField(this.schema, model, field);
+    if (fieldDef.computed) {
+      return query.select((eb) => buildFieldRef(this.schema, model, field, this.options, eb).as(field));
+    } else if (!fieldDef.originModel) {
+      return query.select(sql.ref(`${modelAlias}.${field}`).as(field));
+    } else {
+      return this.buildSelectField(query, fieldDef.originModel, fieldDef.originModel, field);
+    }
+  }
+  buildDelegateJoin(thisModel, otherModel, query) {
+    const idFields = getIdFields(this.schema, thisModel);
+    query = query.leftJoin(otherModel, (qb) => {
+      for (const idField of idFields) {
+        qb = qb.onRef(`${thisModel}.${idField}`, "=", `${otherModel}.${idField}`);
+      }
+      return qb;
+    });
+    return query;
+  }
+  // #endregion
+  // #region utils
   negateSort(sort, negated) {
     return negated ? sort === "asc" ? "desc" : "asc" : sort;
   }
@@ -729,7 +888,8 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
       const joinTableName = `${parentName}$${relationField}`;
       let result = eb.selectFrom(`${relationModel} as ${joinTableName}`);
       result = eb.selectFrom(() => {
-        let subQuery = eb.selectFrom(`${relationModel}`).selectAll();
+        let subQuery = this.buildSelectModel(eb, relationModel);
+        subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0);
         if (payload && typeof payload === "object") {
           if (payload.where) {
             subQuery = subQuery.where((eb2) => this.buildFilter(eb2, relationModel, relationModel, payload.where));
@@ -776,6 +936,13 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
   buildRelationObjectArgs(relationModel, relationField, eb, payload, parentName) {
     const relationModelDef = requireModel(this.schema, relationModel);
     const objArgs = [];
+    const descendantModels = getDelegateDescendantModels(this.schema, relationModel);
+    if (descendantModels.length > 0) {
+      objArgs.push(...descendantModels.map((subModel) => [
+        sql2.lit(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`),
+        eb.ref(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`)
+      ]).flatMap((v) => v));
+    }
     if (payload === true || !payload.select) {
       objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !(typeof payload === "object" && payload.omit?.[name] === true)).map(([field]) => [
         sql2.lit(field),
@@ -868,7 +1035,11 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     if (Array.isArray(value)) {
       return value.map((v) => this.transformPrimitive(v, type, false));
     } else {
-      return match3(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).with("Json", () => JSON.stringify(value)).otherwise(() => value);
+      if (this.schema.typeDefs && type in this.schema.typeDefs) {
+        return JSON.stringify(value);
+      } else {
+        return match3(type).with("Boolean", () => value ? 1 : 0).with("DateTime", () => value instanceof Date ? value.toISOString() : value).with("Decimal", () => value.toString()).with("Bytes", () => Buffer.from(value)).with("Json", () => JSON.stringify(value)).otherwise(() => value);
+      }
     }
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
@@ -880,7 +1051,8 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     const relationModelDef = requireModel(this.schema, relationModel);
     const subQueryName = `${parentName}$${relationField}`;
     let tbl = eb.selectFrom(() => {
-      let subQuery = eb.selectFrom(relationModel).selectAll();
+      let subQuery = this.buildSelectModel(eb, relationModel);
+      subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0);
       if (payload && typeof payload === "object") {
         if (payload.where) {
           subQuery = subQuery.where((eb2) => this.buildFilter(eb2, relationModel, relationModel, payload.where));
@@ -916,6 +1088,13 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     });
     tbl = tbl.select(() => {
       const objArgs = [];
+      const descendantModels = getDelegateDescendantModels(this.schema, relationModel);
+      if (descendantModels.length > 0) {
+        objArgs.push(...descendantModels.map((subModel) => [
+          sql3.lit(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`),
+          eb.ref(`${DELEGATE_JOINED_FIELD_PREFIX}${subModel.name}`)
+        ]).flatMap((v) => v));
+      }
       if (payload === true || !payload.select) {
         objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !(typeof payload === "object" && payload.omit?.[name] === true)).map(([field]) => [
           sql3.lit(field),
@@ -998,85 +1177,6 @@ function getCrudDialect(schema, options) {
 }
 __name(getCrudDialect, "getCrudDialect");
 
-// src/schema/expression.ts
-var ExpressionUtils = {
-  literal: /* @__PURE__ */ __name((value) => {
-    return {
-      kind: "literal",
-      value
-    };
-  }, "literal"),
-  array: /* @__PURE__ */ __name((items) => {
-    return {
-      kind: "array",
-      items
-    };
-  }, "array"),
-  call: /* @__PURE__ */ __name((functionName, args) => {
-    return {
-      kind: "call",
-      function: functionName,
-      args
-    };
-  }, "call"),
-  binary: /* @__PURE__ */ __name((left, op, right) => {
-    return {
-      kind: "binary",
-      op,
-      left,
-      right
-    };
-  }, "binary"),
-  unary: /* @__PURE__ */ __name((op, operand) => {
-    return {
-      kind: "unary",
-      op,
-      operand
-    };
-  }, "unary"),
-  field: /* @__PURE__ */ __name((field) => {
-    return {
-      kind: "field",
-      field
-    };
-  }, "field"),
-  member: /* @__PURE__ */ __name((receiver, members) => {
-    return {
-      kind: "member",
-      receiver,
-      members
-    };
-  }, "member"),
-  _this: /* @__PURE__ */ __name(() => {
-    return {
-      kind: "this"
-    };
-  }, "_this"),
-  _null: /* @__PURE__ */ __name(() => {
-    return {
-      kind: "null"
-    };
-  }, "_null"),
-  and: /* @__PURE__ */ __name((expr2, ...expressions) => {
-    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "&&", exp), expr2);
-  }, "and"),
-  or: /* @__PURE__ */ __name((expr2, ...expressions) => {
-    return expressions.reduce((acc, exp) => ExpressionUtils.binary(acc, "||", exp), expr2);
-  }, "or"),
-  is: /* @__PURE__ */ __name((value, kind) => {
-    return !!value && typeof value === "object" && "kind" in value && value.kind === kind;
-  }, "is"),
-  isLiteral: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "literal"), "isLiteral"),
-  isArray: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "array"), "isArray"),
-  isCall: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "call"), "isCall"),
-  isNull: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "null"), "isNull"),
-  isThis: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "this"), "isThis"),
-  isUnary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "unary"), "isUnary"),
-  isBinary: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "binary"), "isBinary"),
-  isField: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "field"), "isField"),
-  isMember: /* @__PURE__ */ __name((value) => ExpressionUtils.is(value, "member"), "isMember")
-};
-
 // src/utils/default-operation-node-visitor.ts
 import { OperationNodeVisitor } from "kysely";
 var DefaultOperationNodeVisitor = class extends OperationNodeVisitor {
@@ -2325,4 +2425,4 @@ export {
   PolicyPlugin,
   RejectedByPolicyError
 };
-//# sourceMappingURL=policy.js.map
+//# sourceMappingURL=index.js.map