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

package/dist/index.d.cts

@@ -1,11 +1,11 @@
-import { C as ClientConstructor } from './contract-c8GpEAl3.cjs';
-export { K as AggregateArgs, L as AggregateResult, B as BatchResult, i as BooleanFilter, h as BytesFilter, c as ClientContract, d as ClientOptions, G as CountArgs, H as CountResult, u as CreateArgs, w as CreateManyAndReturnArgs, v as CreateManyArgs, D as DateTimeFilter, A as DeleteArgs, E as DeleteManyArgs, F as FindArgs, s as FindFirstArgs, r as FindManyArgs, t as FindUniqueArgs, P as GroupByArgs, Q as GroupByResult, I as IncludeInput, J as JsonArray, a as JsonObject, b as JsonValue, M as ModelResult, k as NullsOrder, N as NumberFilter, m as OmitInput, O as OrderBy, n as SelectIncludeOmit, o as SelectInput, q as SelectSubset, S as SimplifiedModelResult, j as SortOrder, g as StringFilter, p as Subset, T as ToKysely, f as TypeDefResult, U as UpdateArgs, y as UpdateManyAndReturnArgs, x as UpdateManyArgs, z as UpsertArgs, W as WhereInput, l as WhereUniqueInput, e as definePlugin } from './contract-c8GpEAl3.cjs';
+import { C as ClientConstructor } from './contract-B8DJmviN.cjs';
+export { K as AggregateArgs, L as AggregateResult, B as BatchResult, i as BooleanFilter, h as BytesFilter, c as ClientContract, d as ClientOptions, G as CountArgs, H as CountResult, u as CreateArgs, w as CreateManyAndReturnArgs, v as CreateManyArgs, D as DateTimeFilter, A as DeleteArgs, E as DeleteManyArgs, F as FindArgs, s as FindFirstArgs, r as FindManyArgs, t as FindUniqueArgs, P as GroupByArgs, Q as GroupByResult, I as IncludeInput, J as JsonArray, a as JsonObject, b as JsonValue, M as ModelResult, k as NullsOrder, N as NumberFilter, m as OmitInput, O as OrderBy, n as SelectIncludeOmit, o as SelectInput, q as SelectSubset, S as SimplifiedModelResult, j as SortOrder, g as StringFilter, p as Subset, T as ToKysely, f as TypeDefResult, U as UpdateArgs, y as UpdateManyAndReturnArgs, x as UpdateManyArgs, z as UpsertArgs, W as WhereInput, l as WhereUniqueInput, e as definePlugin } from './contract-B8DJmviN.cjs';
 import 'decimal.js';
 import '@zenstackhq/sdk/schema';
 import 'kysely';
 
 /**
- * ZenStack client.
+ * ZenStack ORM client.
  */
 declare const ZenStackClient: ClientConstructor;
 

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { C as ClientConstructor } from './contract-c8GpEAl3.js';
-export { K as AggregateArgs, L as AggregateResult, B as BatchResult, i as BooleanFilter, h as BytesFilter, c as ClientContract, d as ClientOptions, G as CountArgs, H as CountResult, u as CreateArgs, w as CreateManyAndReturnArgs, v as CreateManyArgs, D as DateTimeFilter, A as DeleteArgs, E as DeleteManyArgs, F as FindArgs, s as FindFirstArgs, r as FindManyArgs, t as FindUniqueArgs, P as GroupByArgs, Q as GroupByResult, I as IncludeInput, J as JsonArray, a as JsonObject, b as JsonValue, M as ModelResult, k as NullsOrder, N as NumberFilter, m as OmitInput, O as OrderBy, n as SelectIncludeOmit, o as SelectInput, q as SelectSubset, S as SimplifiedModelResult, j as SortOrder, g as StringFilter, p as Subset, T as ToKysely, f as TypeDefResult, U as UpdateArgs, y as UpdateManyAndReturnArgs, x as UpdateManyArgs, z as UpsertArgs, W as WhereInput, l as WhereUniqueInput, e as definePlugin } from './contract-c8GpEAl3.js';
+import { C as ClientConstructor } from './contract-B8DJmviN.js';
+export { K as AggregateArgs, L as AggregateResult, B as BatchResult, i as BooleanFilter, h as BytesFilter, c as ClientContract, d as ClientOptions, G as CountArgs, H as CountResult, u as CreateArgs, w as CreateManyAndReturnArgs, v as CreateManyArgs, D as DateTimeFilter, A as DeleteArgs, E as DeleteManyArgs, F as FindArgs, s as FindFirstArgs, r as FindManyArgs, t as FindUniqueArgs, P as GroupByArgs, Q as GroupByResult, I as IncludeInput, J as JsonArray, a as JsonObject, b as JsonValue, M as ModelResult, k as NullsOrder, N as NumberFilter, m as OmitInput, O as OrderBy, n as SelectIncludeOmit, o as SelectInput, q as SelectSubset, S as SimplifiedModelResult, j as SortOrder, g as StringFilter, p as Subset, T as ToKysely, f as TypeDefResult, U as UpdateArgs, y as UpdateManyAndReturnArgs, x as UpdateManyArgs, z as UpsertArgs, W as WhereInput, l as WhereUniqueInput, e as definePlugin } from './contract-B8DJmviN.js';
 import 'decimal.js';
 import '@zenstackhq/sdk/schema';
 import 'kysely';
 
 /**
- * ZenStack client.
+ * ZenStack ORM client.
  */
 declare const ZenStackClient: ClientConstructor;
 

package/dist/index.js

@@ -286,7 +286,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");
@@ -337,11 +339,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 {
@@ -420,7 +444,6 @@ import { createId } from "@paralleldrive/cuid2";
 import { invariant as invariant7, isPlainObject as isPlainObject3 } from "@zenstackhq/common-helpers";
 import { expressionBuilder as expressionBuilder3, sql as sql4 } from "kysely";
 import { nanoid } from "nanoid";
-import { inspect } from "util";
 import { match as match9 } from "ts-pattern";
 import { ulid } from "ulid";
 import * as uuid from "uuid";
@@ -505,20 +528,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;
@@ -528,17 +551,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;
   }
@@ -579,11 +602,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--) {
@@ -592,7 +616,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));
     }
@@ -661,25 +685,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;
@@ -692,15 +717,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;
         }
       }
@@ -943,8 +968,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;
@@ -962,7 +988,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)) {
@@ -972,11 +998,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)) {
@@ -1000,11 +1026,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;
     });
@@ -1121,11 +1147,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) {
@@ -1133,21 +1160,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 {
@@ -1156,7 +1183,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);
@@ -1169,7 +1196,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]) => {
@@ -1285,10 +1312,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) {
@@ -1296,14 +1324,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}`);
           }
         });
       }
@@ -2729,14 +2757,14 @@ var BaseOperationHandler = class {
     return this.executeQueryTakeFirst(kysely, query, "exists");
   }
   async read(kysely, model, args) {
-    let query = this.dialect.buildSelectModel(expressionBuilder3(), model);
+    let query = this.dialect.buildSelectModel(expressionBuilder3(), model, model);
     if (args) {
-      query = this.dialect.buildFilterSortTake(model, args, query);
+      query = this.dialect.buildFilterSortTake(model, args, query, model);
     }
     if (args && "select" in args && args.select) {
       query = this.buildFieldSelection(model, query, args.select, model);
     } else {
-      query = this.dialect.buildSelectAllFields(model, query, args?.omit);
+      query = this.dialect.buildSelectAllFields(model, query, args?.omit, model);
     }
     if (args && "include" in args && args.include) {
       query = this.buildFieldSelection(model, query, args.include, model);
@@ -2754,11 +2782,7 @@ var BaseOperationHandler = class {
       const r = await kysely.getExecutor().executeQuery(compiled, queryId);
       result = r.rows;
     } catch (err) {
-      let message = `Failed to execute query: ${err}, sql: ${compiled.sql}`;
-      if (this.options.debug) {
-        message += `, parameters: 
-${compiled.parameters.map((p) => inspect(p)).join("\n")}`;
-      }
+      const message = `Failed to execute query: ${err}, sql: ${compiled.sql}`;
       throw new QueryError(message, err);
     }
     return result;
@@ -2926,7 +2950,12 @@ ${compiled.parameters.map((p) => inspect(p)).join("\n")}`;
         field: rightField,
         entity: rightEntity
       }
-    ].sort((a, b) => a.model.localeCompare(b.model));
+    ].sort((a, b) => (
+      // the implement m2m join table's "A", "B" fk fields' order is determined
+      // by model name's sort order, and when identical (for self-relations),
+      // field name's sort order
+      a.model !== b.model ? a.model.localeCompare(b.model) : a.field.localeCompare(b.field)
+    ));
     const firstIds = getIdFields(this.schema, sortedRecords[0].model);
     const secondIds = getIdFields(this.schema, sortedRecords[1].model);
     invariant7(firstIds.length === 1, "many-to-many relation must have exactly one id field");
@@ -3431,7 +3460,7 @@ ${compiled.parameters.map((p) => inspect(p)).join("\n")}`;
     } else {
       query = query.where((eb) => eb(eb.refTuple(
         ...this.buildIdFieldRefs(kysely, model)
-      ), "in", this.dialect.buildSelectModel(eb, filterModel).where(this.dialect.buildFilter(eb, filterModel, filterModel, where)).select(this.buildIdFieldRefs(kysely, filterModel)).$if(limit !== void 0, (qb) => qb.limit(limit))));
+      ), "in", this.dialect.buildSelectModel(eb, filterModel, filterModel).where(this.dialect.buildFilter(eb, filterModel, filterModel, where)).select(this.buildIdFieldRefs(kysely, filterModel)).$if(limit !== void 0, (qb) => qb.limit(limit))));
     }
     query = query.modifyEnd(this.makeContextComment({
       model,
@@ -3849,7 +3878,7 @@ ${compiled.parameters.map((p) => inspect(p)).join("\n")}`;
     } else {
       query = query.where((eb) => eb(eb.refTuple(
         ...this.buildIdFieldRefs(kysely, model)
-      ), "in", this.dialect.buildSelectModel(eb, filterModel).where((eb2) => this.dialect.buildFilter(eb2, filterModel, filterModel, where)).select(this.buildIdFieldRefs(kysely, filterModel)).$if(limit !== void 0, (qb) => qb.limit(limit))));
+      ), "in", this.dialect.buildSelectModel(eb, filterModel, filterModel).where((eb2) => this.dialect.buildFilter(eb2, filterModel, filterModel, where)).select(this.buildIdFieldRefs(kysely, filterModel)).$if(limit !== void 0, (qb) => qb.limit(limit))));
     }
     await this.processDelegateRelationDelete(kysely, modelDef, where, limit);
     query = query.modifyEnd(this.makeContextComment({
@@ -3985,7 +4014,7 @@ var AggregateOperationHandler = class extends BaseOperationHandler {
     const normalizedArgs = this.normalizeArgs(args);
     const parsedArgs = this.inputValidator.validateAggregateArgs(this.model, normalizedArgs);
     let query = this.kysely.selectFrom((eb) => {
-      let subQuery = this.dialect.buildSelectModel(eb, this.model).where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, parsedArgs?.where));
+      let subQuery = this.dialect.buildSelectModel(eb, this.model, this.model).where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, parsedArgs?.where));
       const selectedFields = [];
       for (const [key, value] of Object.entries(parsedArgs)) {
         if (key.startsWith("_") && value && typeof value === "object") {
@@ -4095,7 +4124,7 @@ var CountOperationHandler = class extends BaseOperationHandler {
     const parsedArgs = this.inputValidator.validateCountArgs(this.model, normalizedArgs);
     const subQueryName = "$sub";
     let query = this.kysely.selectFrom((eb) => {
-      let subQuery = this.dialect.buildSelectModel(eb, this.model).where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, parsedArgs?.where));
+      let subQuery = this.dialect.buildSelectModel(eb, this.model, this.model).where((eb1) => this.dialect.buildFilter(eb1, this.model, this.model, parsedArgs?.where));
       if (parsedArgs?.select && typeof parsedArgs.select === "object") {
         for (const [key, value] of Object.entries(parsedArgs.select)) {
           if (key !== "_all" && value === true) {
@@ -5598,7 +5627,6 @@ __name(performanceNow, "performanceNow");
 // src/client/executor/zenstack-query-executor.ts
 import { AndNode as AndNode2, DefaultQueryExecutor, DeleteQueryNode as DeleteQueryNode2, InsertQueryNode as InsertQueryNode2, ReturningNode as ReturningNode3, SelectionNode as SelectionNode4, UpdateQueryNode as UpdateQueryNode2, WhereNode as WhereNode3 } from "kysely";
 import { nanoid as nanoid2 } from "nanoid";
-import { inspect as inspect2 } from "util";
 import { match as match16 } from "ts-pattern";
 
 // src/client/executor/name-mapper.ts
@@ -5906,11 +5934,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends DefaultQueryExe
         };
       });
     } catch (err) {
-      let message = `Failed to execute query: ${err}, sql: ${compiled.sql}`;
-      if (this.options.debug) {
-        message += `, parameters: 
-${compiled.parameters.map((p) => inspect2(p)).join("\n")}`;
-      }
+      const message = `Failed to execute query: ${err}, sql: ${compiled.sql}`;
       throw new QueryError(message, err);
     }
   }