@zenstackhq/runtime 3.0.0-alpha.27 → 3.0.0-alpha.29

package/dist/plugins/policy/index.d.cts

@@ -1,5 +1,5 @@
 import * as kysely from 'kysely';
-import { R as RuntimePlugin, V as OnKyselyQueryArgs } from '../../contract-c8GpEAl3.cjs';
+import { R as RuntimePlugin, V as OnKyselyQueryArgs } from '../../contract-B8DJmviN.cjs';
 import { SchemaDef } from '@zenstackhq/sdk/schema';
 import 'decimal.js';
 

package/dist/plugins/policy/index.d.ts

@@ -1,5 +1,5 @@
 import * as kysely from 'kysely';
-import { R as RuntimePlugin, V as OnKyselyQueryArgs } from '../../contract-c8GpEAl3.js';
+import { R as RuntimePlugin, V as OnKyselyQueryArgs } from '../../contract-B8DJmviN.js';
 import { SchemaDef } from '@zenstackhq/sdk/schema';
 import 'decimal.js';
 

package/dist/plugins/policy/index.js

@@ -262,7 +262,9 @@ function buildFieldRef(schema, model, field, options, eb, modelAlias, inlineComp
     if (!computer) {
       throw new QueryError(`Computed field "${field}" implementation not provided for model "${model}"`);
     }
-    return computer(eb);
+    return computer(eb, {
+      currentModel: modelAlias
+    });
   }
 }
 __name(buildFieldRef, "buildFieldRef");
@@ -305,11 +307,33 @@ function getManyToManyRelation(schema, model, field) {
       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"
+      ];
+    }
     return {
-      parentFkName: sortedModelNames[0] === model ? "A" : "B",
+      parentFkName: orderedFK[0],
       otherModel: fieldDef.type,
       otherField: fieldDef.relation.opposite,
-      otherFkName: sortedModelNames[0] === fieldDef.type ? "A" : "B",
+      otherFkName: orderedFK[1],
       joinTable: fieldDef.relation.name ? `_${fieldDef.relation.name}` : `_${sortedModelNames[0]}To${sortedModelNames[1]}`
     };
   } else {
@@ -399,20 +423,20 @@ var BaseCrudDialect = class {
     return value;
   }
   // #region common query builders
-  buildSelectModel(eb, model) {
+  buildSelectModel(eb, model, modelAlias) {
     const modelDef = requireModel(this.schema, model);
-    let result = eb.selectFrom(model);
+    let result = eb.selectFrom(model === modelAlias ? model : `${model} as ${modelAlias}`);
     let joinBase = modelDef.baseModel;
     while (joinBase) {
-      result = this.buildDelegateJoin(model, joinBase, result);
+      result = this.buildDelegateJoin(model, modelAlias, joinBase, result);
       joinBase = requireModel(this.schema, joinBase).baseModel;
     }
     return result;
   }
-  buildFilterSortTake(model, args, query) {
+  buildFilterSortTake(model, args, query, modelAlias) {
     let result = query;
     if (args.where) {
-      result = result.where((eb) => this.buildFilter(eb, model, model, args?.where));
+      result = result.where((eb) => this.buildFilter(eb, model, modelAlias, args?.where));
     }
     let negateOrderBy = false;
     const skip = args.skip;
@@ -422,17 +446,17 @@ var BaseCrudDialect = class {
       take = -take;
     }
     result = this.buildSkipTake(result, skip, take);
-    result = this.buildOrderBy(result, model, model, args.orderBy, skip !== void 0 || take !== void 0, negateOrderBy);
+    result = this.buildOrderBy(result, model, modelAlias, args.orderBy, skip !== void 0 || take !== void 0, negateOrderBy);
     if ("distinct" in args && args.distinct) {
       const distinct = ensureArray(args.distinct);
       if (this.supportsDistinctOn) {
-        result = result.distinctOn(distinct.map((f) => sql.ref(`${model}.${f}`)));
+        result = result.distinctOn(distinct.map((f) => sql.ref(`${modelAlias}.${f}`)));
       } else {
         throw new QueryError(`"distinct" is not supported by "${this.schema.provider.type}" provider`);
       }
     }
     if (args.cursor) {
-      result = this.buildCursorFilter(model, result, args.cursor, args.orderBy, negateOrderBy);
+      result = this.buildCursorFilter(model, result, args.cursor, args.orderBy, negateOrderBy, modelAlias);
     }
     return result;
   }
@@ -473,11 +497,12 @@ var BaseCrudDialect = class {
     }
     return result;
   }
-  buildCursorFilter(model, query, cursor, orderBy, negateOrderBy) {
+  buildCursorFilter(model, query, cursor, orderBy, negateOrderBy, modelAlias) {
     const _orderBy = orderBy ?? makeDefaultOrderBy(this.schema, model);
     const orderByItems = ensureArray(_orderBy).flatMap((obj) => Object.entries(obj));
     const eb = expressionBuilder();
-    const cursorFilter = this.buildFilter(eb, model, model, cursor);
+    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--) {
@@ -486,7 +511,7 @@ var BaseCrudDialect = class {
         const [field, order] = orderByItems[j];
         const _order = negateOrderBy ? order === "asc" ? "desc" : "asc" : order;
         const op = j === i ? _order === "asc" ? ">=" : "<=" : "=";
-        andFilters.push(eb(eb.ref(`${model}.${field}`), op, eb.selectFrom(model).select(`${model}.${field}`).where(cursorFilter)));
+        andFilters.push(eb(eb.ref(`${modelAlias}.${field}`), op, this.buildSelectModel(eb, model, subQueryAlias).select(`${subQueryAlias}.${field}`).where(cursorFilter)));
       }
       filters.push(eb.and(andFilters));
     }
@@ -555,25 +580,26 @@ var BaseCrudDialect = class {
     }
     return this.and(eb, ...conditions);
   }
-  buildToManyRelationFilter(eb, model, table, field, fieldDef, payload) {
+  buildToManyRelationFilter(eb, model, modelAlias, field, fieldDef, payload) {
     if (payload === null) {
-      return eb(sql.ref(`${table}.${field}`), "is", null);
+      return eb(sql.ref(`${modelAlias}.${field}`), "is", null);
     }
     const relationModel = fieldDef.type;
+    const relationFilterSelectAlias = `${modelAlias}$${field}$filter`;
     const buildPkFkWhereRefs = /* @__PURE__ */ __name((eb2) => {
       const m2m = getManyToManyRelation(this.schema, model, field);
       if (m2m) {
         const modelIdField = getIdFields(this.schema, model)[0];
         const relationIdField = getIdFields(this.schema, relationModel)[0];
-        return eb2(sql.ref(`${relationModel}.${relationIdField}`), "in", eb2.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(sql.ref(`${m2m.joinTable}.${m2m.parentFkName}`), "=", sql.ref(`${table}.${modelIdField}`)));
+        return eb2(sql.ref(`${relationFilterSelectAlias}.${relationIdField}`), "in", eb2.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(sql.ref(`${m2m.joinTable}.${m2m.parentFkName}`), "=", sql.ref(`${modelAlias}.${modelIdField}`)));
       } else {
         const relationKeyPairs = getRelationForeignKeyFieldPairs(this.schema, model, field);
         let result2 = this.true(eb2);
         for (const { fk, pk } of relationKeyPairs.keyPairs) {
           if (relationKeyPairs.ownedByModel) {
-            result2 = this.and(eb2, result2, eb2(sql.ref(`${table}.${fk}`), "=", sql.ref(`${relationModel}.${pk}`)));
+            result2 = this.and(eb2, result2, eb2(sql.ref(`${modelAlias}.${fk}`), "=", sql.ref(`${relationFilterSelectAlias}.${pk}`)));
           } else {
-            result2 = this.and(eb2, result2, eb2(sql.ref(`${table}.${pk}`), "=", sql.ref(`${relationModel}.${fk}`)));
+            result2 = this.and(eb2, result2, eb2(sql.ref(`${modelAlias}.${pk}`), "=", sql.ref(`${relationFilterSelectAlias}.${fk}`)));
           }
         }
         return result2;
@@ -586,15 +612,15 @@ var BaseCrudDialect = class {
       }
       switch (key) {
         case "some": {
-          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));
+          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).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, 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).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, relationFilterSelectAlias).select((eb1) => eb1.fn.count(eb1.lit(1)).as("$count")).where(buildPkFkWhereRefs(eb)).where((eb1) => this.buildFilter(eb1, relationModel, relationFilterSelectAlias, subPayload)), "=", 0));
           break;
         }
       }
@@ -837,8 +863,9 @@ 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 = this.buildSelectModel(eb, relationModel);
-                const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, relationModel);
+                const subQueryAlias = `${modelAlias}$orderBy$${field}$count`;
+                let subQuery = this.buildSelectModel(eb, relationModel, subQueryAlias);
+                const joinPairs = buildJoinPairs(this.schema, model, modelAlias, field, subQueryAlias);
                 subQuery = subQuery.where(() => this.and(eb, ...joinPairs.map(([left, right]) => eb(sql.ref(left), "=", sql.ref(right)))));
                 subQuery = subQuery.select(() => eb.fn.count(eb.lit(1)).as("_count"));
                 return subQuery;
@@ -856,7 +883,7 @@ var BaseCrudDialect = class {
     });
     return result;
   }
-  buildSelectAllFields(model, query, omit) {
+  buildSelectAllFields(model, query, omit, modelAlias) {
     const modelDef = requireModel(this.schema, model);
     let result = query;
     for (const field of Object.keys(modelDef.fields)) {
@@ -866,11 +893,11 @@ var BaseCrudDialect = class {
       if (omit?.[field] === true) {
         continue;
       }
-      result = this.buildSelectField(result, model, model, field);
+      result = this.buildSelectField(result, model, modelAlias, field);
     }
     const descendants = getDelegateDescendantModels(this.schema, model);
     for (const subModel of descendants) {
-      result = this.buildDelegateJoin(model, subModel.name, result);
+      result = this.buildDelegateJoin(model, modelAlias, subModel.name, result);
       result = result.select((eb) => {
         const jsonObject = {};
         for (const field of Object.keys(subModel.fields)) {
@@ -894,11 +921,11 @@ var BaseCrudDialect = class {
       return this.buildSelectField(query, fieldDef.originModel, fieldDef.originModel, field);
     }
   }
-  buildDelegateJoin(thisModel, otherModel, query) {
+  buildDelegateJoin(thisModel, thisModelAlias, otherModelAlias, query) {
     const idFields = getIdFields(this.schema, thisModel);
-    query = query.leftJoin(otherModel, (qb) => {
+    query = query.leftJoin(otherModelAlias, (qb) => {
       for (const idField of idFields) {
-        qb = qb.onRef(`${thisModel}.${idField}`, "=", `${otherModel}.${idField}`);
+        qb = qb.onRef(`${thisModelAlias}.${idField}`, "=", `${otherModelAlias}.${idField}`);
       }
       return qb;
     });
@@ -1015,11 +1042,12 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     return qb.leftJoinLateral((eb) => {
       const joinTableName = `${parentName}$${relationField}`;
       let result = eb.selectFrom(`${relationModel} as ${joinTableName}`);
+      const subQueryAlias = `${relationModel}$${relationField}$sub`;
       result = eb.selectFrom(() => {
-        let subQuery = this.buildSelectModel(eb, relationModel);
-        subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0);
+        let subQuery = this.buildSelectModel(eb, relationModel, subQueryAlias);
+        subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0, subQueryAlias);
         if (payload && typeof payload === "object") {
-          subQuery = this.buildFilterSortTake(relationModel, payload, subQuery);
+          subQuery = this.buildFilterSortTake(relationModel, payload, subQuery, subQueryAlias);
         }
         const m2m = getManyToManyRelation(this.schema, model, relationField);
         if (m2m) {
@@ -1027,21 +1055,21 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
           const relationIds = getIdFields(this.schema, relationModel);
           invariant2(parentIds.length === 1, "many-to-many relation must have exactly one id field");
           invariant2(relationIds.length === 1, "many-to-many relation must have exactly one id field");
-          subQuery = subQuery.where(eb(eb.ref(`${relationModel}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentName}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
+          subQuery = subQuery.where(eb(eb.ref(`${subQueryAlias}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentName}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
         } else {
-          const joinPairs = buildJoinPairs(this.schema, model, parentName, relationField, relationModel);
+          const joinPairs = buildJoinPairs(this.schema, model, parentName, relationField, subQueryAlias);
           subQuery = subQuery.where((eb2) => this.and(eb2, ...joinPairs.map(([left, right]) => eb2(sql2.ref(left), "=", sql2.ref(right)))));
         }
         return subQuery.as(joinTableName);
       });
-      result = this.buildRelationObjectSelect(relationModel, relationField, relationFieldDef, result, payload, parentName);
+      result = this.buildRelationObjectSelect(relationModel, joinTableName, relationField, relationFieldDef, result, payload, parentName);
       result = this.buildRelationJoins(relationModel, relationField, result, payload, parentName);
       return result.as(joinTableName);
     }, (join) => join.onTrue());
   }
-  buildRelationObjectSelect(relationModel, relationField, relationFieldDef, qb, payload, parentName) {
+  buildRelationObjectSelect(relationModel, relationModelAlias, relationField, relationFieldDef, qb, payload, parentName) {
     qb = qb.select((eb) => {
-      const objArgs = this.buildRelationObjectArgs(relationModel, relationField, eb, payload, parentName);
+      const objArgs = this.buildRelationObjectArgs(relationModel, relationModelAlias, relationField, eb, payload, parentName);
       if (relationFieldDef.array) {
         return eb.fn.coalesce(sql2`jsonb_agg(jsonb_build_object(${sql2.join(objArgs)}))`, sql2`'[]'::jsonb`).as("$j");
       } else {
@@ -1050,7 +1078,7 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     });
     return qb;
   }
-  buildRelationObjectArgs(relationModel, relationField, eb, payload, parentAlias) {
+  buildRelationObjectArgs(relationModel, relationModelAlias, relationField, eb, payload, parentAlias) {
     const relationModelDef = requireModel(this.schema, relationModel);
     const objArgs = [];
     const descendantModels = getDelegateDescendantModels(this.schema, relationModel);
@@ -1063,7 +1091,7 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     if (payload === true || !payload.select) {
       objArgs.push(...Object.entries(relationModelDef.fields).filter(([, value]) => !value.relation).filter(([name]) => !(typeof payload === "object" && payload.omit?.[name] === true)).map(([field]) => [
         sql2.lit(field),
-        this.fieldRef(relationModel, field, eb, void 0, false)
+        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]) => {
@@ -1179,10 +1207,11 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     const relationModelDef = requireModel(this.schema, relationModel);
     const subQueryName = `${parentAlias}$${relationField}`;
     let tbl = eb.selectFrom(() => {
-      let subQuery = this.buildSelectModel(eb, relationModel);
-      subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0);
+      const subQueryAlias = `${parentAlias}$${relationField}$sub`;
+      let subQuery = this.buildSelectModel(eb, relationModel, subQueryAlias);
+      subQuery = this.buildSelectAllFields(relationModel, subQuery, typeof payload === "object" ? payload?.omit : void 0, subQueryAlias);
       if (payload && typeof payload === "object") {
-        subQuery = this.buildFilterSortTake(relationModel, payload, subQuery);
+        subQuery = this.buildFilterSortTake(relationModel, payload, subQuery, subQueryAlias);
       }
       const m2m = getManyToManyRelation(this.schema, model, relationField);
       if (m2m) {
@@ -1190,14 +1219,14 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
         const relationIds = getIdFields(this.schema, relationModel);
         invariant3(parentIds.length === 1, "many-to-many relation must have exactly one id field");
         invariant3(relationIds.length === 1, "many-to-many relation must have exactly one id field");
-        subQuery = subQuery.where(eb(eb.ref(`${relationModel}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentAlias}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
+        subQuery = subQuery.where(eb(eb.ref(`${subQueryAlias}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentAlias}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
       } else {
         const { keyPairs, ownedByModel } = getRelationForeignKeyFieldPairs(this.schema, model, relationField);
         keyPairs.forEach(({ fk, pk }) => {
           if (ownedByModel) {
-            subQuery = subQuery.whereRef(`${relationModel}.${pk}`, "=", `${parentAlias}.${fk}`);
+            subQuery = subQuery.whereRef(`${subQueryAlias}.${pk}`, "=", `${parentAlias}.${fk}`);
           } else {
-            subQuery = subQuery.whereRef(`${relationModel}.${fk}`, "=", `${parentAlias}.${pk}`);
+            subQuery = subQuery.whereRef(`${subQueryAlias}.${fk}`, "=", `${parentAlias}.${pk}`);
           }
         });
       }