@zenstackhq/runtime 3.0.0-alpha.31 → 3.0.0-alpha.33

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-5Wcmlo5v.cjs';
+import { R as RuntimePlugin, V as OnKyselyQueryArgs } from '../../contract-CusA0mQO.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-5Wcmlo5v.js';
+import { R as RuntimePlugin, V as OnKyselyQueryArgs } from '../../contract-CusA0mQO.js';
 import { SchemaDef } from '@zenstackhq/sdk/schema';
 import 'decimal.js';
 

package/dist/plugins/policy/index.js

@@ -120,7 +120,10 @@ var ExpressionUtils = {
   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")
+  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
@@ -911,6 +914,16 @@ var BaseCrudDialect = class {
     }
     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) {
@@ -1008,6 +1021,18 @@ var BaseCrudDialect = class {
   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
@@ -1033,52 +1058,58 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     }
   }
   buildRelationSelection(query, model, relationField, parentAlias, payload) {
-    const joinedQuery = this.buildRelationJSON(model, query, relationField, parentAlias, payload);
-    return joinedQuery.select(`${parentAlias}$${relationField}.$j as ${relationField}`);
+    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, parentName, payload) {
+  buildRelationJSON(model, qb, relationField, parentAlias, payload, resultName) {
     const relationFieldDef = requireField(this.schema, model, relationField);
     const relationModel = relationFieldDef.type;
     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, 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, subQueryAlias);
-        }
-        const m2m = getManyToManyRelation(this.schema, model, relationField);
-        if (m2m) {
-          const parentIds = getIdFields(this.schema, model);
-          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(`${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, 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, joinTableName, relationField, relationFieldDef, result, payload, parentName);
-      result = this.buildRelationJoins(relationModel, relationField, result, payload, parentName);
-      return result.as(joinTableName);
+      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());
   }
-  buildRelationObjectSelect(relationModel, relationModelAlias, relationField, relationFieldDef, qb, payload, parentName) {
+  buildRelationJoinFilter(query, model, relationField, relationModel, relationModelAlias, parentAlias) {
+    const m2m = getManyToManyRelation(this.schema, model, relationField);
+    if (m2m) {
+      const parentIds = getIdFields(this.schema, model);
+      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");
+      query = query.where((eb) => eb(eb.ref(`${relationModelAlias}.${relationIds[0]}`), "in", eb.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(`${parentAlias}.${parentIds[0]}`, "=", `${m2m.joinTable}.${m2m.parentFkName}`)));
+    } else {
+      const joinPairs = buildJoinPairs(this.schema, model, parentAlias, relationField, relationModelAlias);
+      query = query.where((eb) => this.and(eb, ...joinPairs.map(([left, right]) => eb(sql2.ref(left), "=", sql2.ref(right)))));
+    }
+    return query;
+  }
+  buildRelationObjectSelect(relationModel, relationModelAlias, relationFieldDef, qb, payload, parentResultName) {
     qb = qb.select((eb) => {
-      const objArgs = this.buildRelationObjectArgs(relationModel, relationModelAlias, relationField, eb, payload, parentName);
+      const objArgs = this.buildRelationObjectArgs(relationModel, relationModelAlias, eb, payload, parentResultName);
       if (relationFieldDef.array) {
-        return eb.fn.coalesce(sql2`jsonb_agg(jsonb_build_object(${sql2.join(objArgs)}))`, sql2`'[]'::jsonb`).as("$j");
+        return eb.fn.coalesce(sql2`jsonb_agg(jsonb_build_object(${sql2.join(objArgs)}))`, sql2`'[]'::jsonb`).as("$data");
       } else {
-        return sql2`jsonb_build_object(${sql2.join(objArgs)})`.as("$j");
+        return sql2`jsonb_build_object(${sql2.join(objArgs)})`.as("$data");
       }
     });
     return qb;
   }
-  buildRelationObjectArgs(relationModel, relationModelAlias, relationField, eb, payload, parentAlias) {
+  buildRelationObjectArgs(relationModel, relationModelAlias, eb, payload, parentResultName) {
     const relationModelDef = requireModel(this.schema, relationModel);
     const objArgs = [];
     const descendantModels = getDelegateDescendantModels(this.schema, relationModel);
@@ -1096,14 +1127,14 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
     } 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);
+          const subJson = this.buildCountJson(relationModel, eb, relationModelAlias, value);
           return [
             sql2.lit(field),
             subJson
           ];
         } else {
           const fieldDef = requireField(this.schema, relationModel, field);
-          const fieldValue = fieldDef.relation ? eb.ref(`${parentAlias}$${relationField}$${field}.$j`) : this.fieldRef(relationModel, field, eb, void 0, false);
+          const fieldValue = fieldDef.relation ? eb.ref(`${parentResultName}$${field}.$data`) : this.fieldRef(relationModel, field, eb, relationModelAlias, false);
           return [
             sql2.lit(field),
             fieldValue
@@ -1115,18 +1146,18 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
       objArgs.push(...Object.entries(payload.include).filter(([, value]) => value).map(([field]) => [
         sql2.lit(field),
         // reference the synthesized JSON field
-        eb.ref(`${parentAlias}$${relationField}$${field}.$j`)
+        eb.ref(`${parentResultName}$${field}.$data`)
       ]).flatMap((v) => v));
     }
     return objArgs;
   }
-  buildRelationJoins(relationModel, relationField, qb, payload, parentName) {
-    let result = qb;
+  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, `${parentName}$${relationField}`, value);
+          result = this.buildRelationJSON(relationModel, result, field, relationModelAlias, value, `${parentResultName}$${field}`);
         });
       }
     }
@@ -1206,32 +1237,18 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
     const relationModel = relationFieldDef.type;
     const relationModelDef = requireModel(this.schema, relationModel);
     const subQueryName = `${parentAlias}$${relationField}`;
-    let tbl = eb.selectFrom(() => {
-      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, subQueryAlias);
-      }
-      const m2m = getManyToManyRelation(this.schema, model, relationField);
-      if (m2m) {
-        const parentIds = getIdFields(this.schema, model);
-        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(`${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(`${subQueryAlias}.${pk}`, "=", `${parentAlias}.${fk}`);
-          } else {
-            subQuery = subQuery.whereRef(`${subQueryAlias}.${fk}`, "=", `${parentAlias}.${pk}`);
-          }
-        });
-      }
-      return subQuery.as(subQueryName);
-    });
+    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);
@@ -1244,7 +1261,7 @@ var SqliteCrudDialect = 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]) => [
           sql3.lit(field),
-          this.fieldRef(relationModel, field, eb, void 0, false)
+          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]) => {
@@ -1265,7 +1282,7 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
             } else {
               return [
                 sql3.lit(field),
-                this.fieldRef(relationModel, field, eb, void 0, false)
+                this.fieldRef(relationModel, field, eb, subQueryName, false)
               ];
             }
           }
@@ -1281,13 +1298,35 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
         }).flatMap((v) => v));
       }
       if (relationFieldDef.array) {
-        return eb.fn.coalesce(sql3`json_group_array(json_object(${sql3.join(objArgs)}))`, sql3`json_array()`).as("$j");
+        return eb.fn.coalesce(sql3`json_group_array(json_object(${sql3.join(objArgs)}))`, sql3`json_array()`).as("$data");
       } else {
-        return sql3`json_object(${sql3.join(objArgs)})`.as("data");
+        return sql3`json_object(${sql3.join(objArgs)})`.as("$data");
       }
     });
     return tbl;
   }
+  buildRelationJoinFilter(selectModelQuery, model, relationField, relationModelAlias, parentAlias) {
+    const fieldDef = requireField(this.schema, model, relationField);
+    const relationModel = fieldDef.type;
+    const m2m = getManyToManyRelation(this.schema, model, relationField);
+    if (m2m) {
+      const parentIds = getIdFields(this.schema, model);
+      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");
+      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);