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

package/dist/{contract-c8GpEAl3.d.cts → contract-B8DJmviN.d.cts}

@@ -531,8 +531,8 @@ declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
     protected readonly options: ClientOptions<Schema>;
     constructor(schema: Schema, options: ClientOptions<Schema>);
     transformPrimitive(value: unknown, _type: BuiltinType, _forArrayField: boolean): unknown;
-    buildSelectModel(eb: ExpressionBuilder<any, any>, model: string): SelectQueryBuilder<any, any, {}>;
-    buildFilterSortTake(model: GetModels<Schema>, args: FindArgs<Schema, GetModels<Schema>, true>, query: SelectQueryBuilder<any, any, {}>): SelectQueryBuilder<any, any, {}>;
+    buildSelectModel(eb: ExpressionBuilder<any, any>, model: string, modelAlias: string): SelectQueryBuilder<any, any, {}>;
+    buildFilterSortTake(model: GetModels<Schema>, args: FindArgs<Schema, GetModels<Schema>, true>, query: SelectQueryBuilder<any, any, {}>, modelAlias: string): SelectQueryBuilder<any, any, {}>;
     buildFilter(eb: ExpressionBuilder<any, any>, model: string, modelAlias: string, where: boolean | object | undefined): Expression<SqlBool>;
     private buildCursorFilter;
     private isLogicalCombinator;
@@ -552,9 +552,9 @@ declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
     private buildBytesFilter;
     private buildEnumFilter;
     buildOrderBy(query: SelectQueryBuilder<any, any, any>, model: string, modelAlias: string, orderBy: OrArray<OrderBy<Schema, GetModels<Schema>, boolean, boolean>> | undefined, useDefaultIfEmpty: boolean, negated: boolean): SelectQueryBuilder<any, any, any>;
-    buildSelectAllFields(model: string, query: SelectQueryBuilder<any, any, any>, omit?: Record<string, boolean | undefined>): SelectQueryBuilder<any, any, any>;
+    buildSelectAllFields(model: string, query: SelectQueryBuilder<any, any, any>, omit: Record<string, boolean | undefined> | undefined, modelAlias: string): SelectQueryBuilder<any, any, any>;
     buildSelectField(query: SelectQueryBuilder<any, any, any>, model: string, modelAlias: string, field: string): SelectQueryBuilder<any, any, any>;
-    buildDelegateJoin(thisModel: string, otherModel: string, query: SelectQueryBuilder<any, any, any>): SelectQueryBuilder<any, any, any>;
+    buildDelegateJoin(thisModel: string, thisModelAlias: string, otherModelAlias: string, query: SelectQueryBuilder<any, any, any>): SelectQueryBuilder<any, any, any>;
     buildCountJson(model: string, eb: ExpressionBuilder<any, any>, parentAlias: string, payload: any): ExpressionWrapper<any, any, unknown>;
     private negateSort;
     true(eb: ExpressionBuilder<any, any>): Expression<SqlBool>;
@@ -777,10 +777,6 @@ type ClientOptions<Schema extends SchemaDef> = {
      * Logging configuration.
      */
     log?: KyselyConfig['log'];
-    /**
-     * Debug mode.
-     */
-    debug?: boolean;
 } & (HasComputedFields<Schema> extends true ? {
     /**
      * Computed field definitions.

package/dist/{contract-c8GpEAl3.d.ts → contract-B8DJmviN.d.ts}

@@ -531,8 +531,8 @@ declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
     protected readonly options: ClientOptions<Schema>;
     constructor(schema: Schema, options: ClientOptions<Schema>);
     transformPrimitive(value: unknown, _type: BuiltinType, _forArrayField: boolean): unknown;
-    buildSelectModel(eb: ExpressionBuilder<any, any>, model: string): SelectQueryBuilder<any, any, {}>;
-    buildFilterSortTake(model: GetModels<Schema>, args: FindArgs<Schema, GetModels<Schema>, true>, query: SelectQueryBuilder<any, any, {}>): SelectQueryBuilder<any, any, {}>;
+    buildSelectModel(eb: ExpressionBuilder<any, any>, model: string, modelAlias: string): SelectQueryBuilder<any, any, {}>;
+    buildFilterSortTake(model: GetModels<Schema>, args: FindArgs<Schema, GetModels<Schema>, true>, query: SelectQueryBuilder<any, any, {}>, modelAlias: string): SelectQueryBuilder<any, any, {}>;
     buildFilter(eb: ExpressionBuilder<any, any>, model: string, modelAlias: string, where: boolean | object | undefined): Expression<SqlBool>;
     private buildCursorFilter;
     private isLogicalCombinator;
@@ -552,9 +552,9 @@ declare abstract class BaseCrudDialect<Schema extends SchemaDef> {
     private buildBytesFilter;
     private buildEnumFilter;
     buildOrderBy(query: SelectQueryBuilder<any, any, any>, model: string, modelAlias: string, orderBy: OrArray<OrderBy<Schema, GetModels<Schema>, boolean, boolean>> | undefined, useDefaultIfEmpty: boolean, negated: boolean): SelectQueryBuilder<any, any, any>;
-    buildSelectAllFields(model: string, query: SelectQueryBuilder<any, any, any>, omit?: Record<string, boolean | undefined>): SelectQueryBuilder<any, any, any>;
+    buildSelectAllFields(model: string, query: SelectQueryBuilder<any, any, any>, omit: Record<string, boolean | undefined> | undefined, modelAlias: string): SelectQueryBuilder<any, any, any>;
     buildSelectField(query: SelectQueryBuilder<any, any, any>, model: string, modelAlias: string, field: string): SelectQueryBuilder<any, any, any>;
-    buildDelegateJoin(thisModel: string, otherModel: string, query: SelectQueryBuilder<any, any, any>): SelectQueryBuilder<any, any, any>;
+    buildDelegateJoin(thisModel: string, thisModelAlias: string, otherModelAlias: string, query: SelectQueryBuilder<any, any, any>): SelectQueryBuilder<any, any, any>;
     buildCountJson(model: string, eb: ExpressionBuilder<any, any>, parentAlias: string, payload: any): ExpressionWrapper<any, any, unknown>;
     private negateSort;
     true(eb: ExpressionBuilder<any, any>): Expression<SqlBool>;
@@ -777,10 +777,6 @@ type ClientOptions<Schema extends SchemaDef> = {
      * Logging configuration.
      */
     log?: KyselyConfig['log'];
-    /**
-     * Debug mode.
-     */
-    debug?: boolean;
 } & (HasComputedFields<Schema> extends true ? {
     /**
      * Computed field definitions.

package/dist/index.cjs

@@ -321,7 +321,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");
@@ -372,11 +374,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 {
@@ -455,7 +479,6 @@ var import_cuid2 = require("@paralleldrive/cuid2");
 var import_common_helpers8 = require("@zenstackhq/common-helpers");
 var import_kysely8 = require("kysely");
 var import_nanoid = require("nanoid");
-var import_node_util = require("util");
 var import_ts_pattern9 = require("ts-pattern");
 var import_ulid = require("ulid");
 var uuid = __toESM(require("uuid"), 1);
@@ -540,20 +563,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;
@@ -563,17 +586,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) => import_kysely.sql.ref(`${model}.${f}`)));
+        result = result.distinctOn(distinct.map((f) => import_kysely.sql.ref(`${modelAlias}.${f}`)));
       } else {
         throw new QueryError(`"distinct" is not supported by "${this.schema.provider.type}" provider`);
       }
     }
     if (args.cursor) {
-      result = this.buildCursorFilter(model, result, args.cursor, args.orderBy, negateOrderBy);
+      result = this.buildCursorFilter(model, result, args.cursor, args.orderBy, negateOrderBy, modelAlias);
     }
     return result;
   }
@@ -614,11 +637,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 = (0, import_kysely.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--) {
@@ -627,7 +651,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));
     }
@@ -696,25 +720,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(import_kysely.sql.ref(`${table}.${field}`), "is", null);
+      return eb(import_kysely.sql.ref(`${modelAlias}.${field}`), "is", null);
     }
     const relationModel = fieldDef.type;
+    const relationFilterSelectAlias = `${modelAlias}$${field}$filter`;
     const buildPkFkWhereRefs = /* @__PURE__ */ __name((eb2) => {
       const m2m = getManyToManyRelation(this.schema, model, field);
       if (m2m) {
         const modelIdField = getIdFields(this.schema, model)[0];
         const relationIdField = getIdFields(this.schema, relationModel)[0];
-        return eb2(import_kysely.sql.ref(`${relationModel}.${relationIdField}`), "in", eb2.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(import_kysely.sql.ref(`${m2m.joinTable}.${m2m.parentFkName}`), "=", import_kysely.sql.ref(`${table}.${modelIdField}`)));
+        return eb2(import_kysely.sql.ref(`${relationFilterSelectAlias}.${relationIdField}`), "in", eb2.selectFrom(m2m.joinTable).select(`${m2m.joinTable}.${m2m.otherFkName}`).whereRef(import_kysely.sql.ref(`${m2m.joinTable}.${m2m.parentFkName}`), "=", import_kysely.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(import_kysely.sql.ref(`${table}.${fk}`), "=", import_kysely.sql.ref(`${relationModel}.${pk}`)));
+            result2 = this.and(eb2, result2, eb2(import_kysely.sql.ref(`${modelAlias}.${fk}`), "=", import_kysely.sql.ref(`${relationFilterSelectAlias}.${pk}`)));
           } else {
-            result2 = this.and(eb2, result2, eb2(import_kysely.sql.ref(`${table}.${pk}`), "=", import_kysely.sql.ref(`${relationModel}.${fk}`)));
+            result2 = this.and(eb2, result2, eb2(import_kysely.sql.ref(`${modelAlias}.${pk}`), "=", import_kysely.sql.ref(`${relationFilterSelectAlias}.${fk}`)));
           }
         }
         return result2;
@@ -727,15 +752,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;
         }
       }
@@ -978,8 +1003,9 @@ var BaseCrudDialect = class {
               (0, import_common_helpers.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(import_kysely.sql.ref(left), "=", import_kysely.sql.ref(right)))));
                 subQuery = subQuery.select(() => eb.fn.count(eb.lit(1)).as("_count"));
                 return subQuery;
@@ -997,7 +1023,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)) {
@@ -1007,11 +1033,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)) {
@@ -1035,11 +1061,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;
     });
@@ -1156,11 +1182,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) {
@@ -1168,21 +1195,21 @@ var PostgresCrudDialect = class extends BaseCrudDialect {
           const relationIds = getIdFields(this.schema, relationModel);
           (0, import_common_helpers2.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
           (0, import_common_helpers2.invariant)(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(import_kysely2.sql.ref(left), "=", import_kysely2.sql.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(import_kysely2.sql`jsonb_agg(jsonb_build_object(${import_kysely2.sql.join(objArgs)}))`, import_kysely2.sql`'[]'::jsonb`).as("$j");
       } else {
@@ -1191,7 +1218,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);
@@ -1204,7 +1231,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]) => [
         import_kysely2.sql.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]) => {
@@ -1320,10 +1347,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) {
@@ -1331,14 +1359,14 @@ var SqliteCrudDialect = class extends BaseCrudDialect {
         const relationIds = getIdFields(this.schema, relationModel);
         (0, import_common_helpers3.invariant)(parentIds.length === 1, "many-to-many relation must have exactly one id field");
         (0, import_common_helpers3.invariant)(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}`);
           }
         });
       }
@@ -2764,14 +2792,14 @@ var BaseOperationHandler = class {
     return this.executeQueryTakeFirst(kysely, query, "exists");
   }
   async read(kysely, model, args) {
-    let query = this.dialect.buildSelectModel((0, import_kysely8.expressionBuilder)(), model);
+    let query = this.dialect.buildSelectModel((0, import_kysely8.expressionBuilder)(), 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);
@@ -2789,11 +2817,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) => (0, import_node_util.inspect)(p)).join("\n")}`;
-      }
+      const message = `Failed to execute query: ${err}, sql: ${compiled.sql}`;
       throw new QueryError(message, err);
     }
     return result;
@@ -2961,7 +2985,12 @@ ${compiled.parameters.map((p) => (0, import_node_util.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);
     (0, import_common_helpers8.invariant)(firstIds.length === 1, "many-to-many relation must have exactly one id field");
@@ -3466,7 +3495,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.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,
@@ -3884,7 +3913,7 @@ ${compiled.parameters.map((p) => (0, import_node_util.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({
@@ -4020,7 +4049,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") {
@@ -4130,7 +4159,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) {
@@ -5633,7 +5662,6 @@ __name(performanceNow, "performanceNow");
 // src/client/executor/zenstack-query-executor.ts
 var import_kysely13 = require("kysely");
 var import_nanoid2 = require("nanoid");
-var import_node_util2 = require("util");
 var import_ts_pattern16 = require("ts-pattern");
 
 // src/client/executor/name-mapper.ts
@@ -5941,11 +5969,7 @@ var ZenStackQueryExecutor = class _ZenStackQueryExecutor extends import_kysely13
         };
       });
     } catch (err) {
-      let message = `Failed to execute query: ${err}, sql: ${compiled.sql}`;
-      if (this.options.debug) {
-        message += `, parameters: 
-${compiled.parameters.map((p) => (0, import_node_util2.inspect)(p)).join("\n")}`;
-      }
+      const message = `Failed to execute query: ${err}, sql: ${compiled.sql}`;
       throw new QueryError(message, err);
     }
   }