@zenstackhq/orm 3.5.1 → 3.5.3

package/dist/index.cjs

@@ -1643,6 +1643,12 @@ var BaseCrudDialect = class {
   buildExistsExpression(innerQuery) {
     return this.eb.exists(innerQuery);
   }
+  /**
+   * Builds a binary comparison expression between two operands.
+   */
+  buildComparison(left, _leftFieldDef, op, right, _rightFieldDef) {
+    return this.eb(left, op, right);
+  }
 };
 
 // src/client/crud/dialects/lateral-join-dialect-base.ts
@@ -1698,13 +1704,53 @@ var LateralJoinDialectBase = class extends BaseCrudDialect {
     qb = qb.select((eb) => {
       const objArgs = this.buildRelationObjectArgs(relationModel, relationModelAlias, eb, payload, parentResultName);
       if (relationFieldDef.array) {
-        return this.buildArrayAgg(this.buildJsonObject(objArgs)).as("$data");
+        const orderBy = this.buildRelationOrderByExpressions(relationModel, relationModelAlias, payload);
+        return this.buildArrayAgg(this.buildJsonObject(objArgs), orderBy).as("$data");
       } else {
         return this.buildJsonObject(objArgs).as("$data");
       }
     });
     return qb;
   }
+  /**
+   * Extracts scalar `orderBy` clauses from the relation payload and maps them to
+   * the array-aggregation ordering format.
+   *
+   * For to-many relations aggregated into a JSON array (via lateral joins), this
+   * lets us preserve a stable ordering by passing `{ expr, sort, nulls? }` into
+   * the dialect's `buildArrayAgg` implementation.
+   */
+  buildRelationOrderByExpressions(model, modelAlias, payload) {
+    if (payload === true || !payload.orderBy) {
+      return void 0;
+    }
+    const items = [];
+    for (const orderBy of ensureArray(payload.orderBy)) {
+      for (const [field, value] of Object.entries(orderBy)) {
+        if (!value || requireField(this.schema, model, field).relation) {
+          continue;
+        }
+        const expr = this.fieldRef(model, field, modelAlias);
+        let sort = typeof value === "string" ? value : value.sort;
+        if (payload.take !== void 0 && payload.take < 0) {
+          sort = this.negateSort(sort, true);
+        }
+        if (typeof value === "string") {
+          items.push({
+            expr,
+            sort
+          });
+        } else {
+          items.push({
+            expr,
+            sort,
+            nulls: value.nulls
+          });
+        }
+      }
+    }
+    return items.length > 0 ? items : void 0;
+  }
   buildRelationObjectArgs(relationModel, relationModelAlias, eb, payload, parentResultName) {
     const relationModelDef = requireModel(this.schema, relationModel);
     const objArgs = {};
@@ -1890,7 +1936,7 @@ var MySqlCrudDialect = class extends LateralJoinDialectBase {
   buildExistsExpression(innerQuery) {
     return this.eb.exists(this.eb.selectFrom(innerQuery.as("$exists_sub")).select(this.eb.lit(1).as("_")));
   }
-  buildArrayAgg(arg) {
+  buildArrayAgg(arg, _orderBy) {
     return this.eb.fn.coalesce(import_kysely3.sql`JSON_ARRAYAGG(${arg})`, import_kysely3.sql`JSON_ARRAY()`);
   }
   buildSkipTake(query, skip, take) {
@@ -2037,6 +2083,33 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
     Bytes: "bytea",
     Json: "jsonb"
   };
+  // Maps @db.* attribute names to PostgreSQL SQL types for use in VALUES table casts
+  static dbAttributeToSqlTypeMap = {
+    "@db.Uuid": "uuid",
+    "@db.Citext": "citext",
+    "@db.Inet": "inet",
+    "@db.Bit": "bit",
+    "@db.VarBit": "varbit",
+    "@db.Xml": "xml",
+    "@db.Json": "json",
+    "@db.JsonB": "jsonb",
+    "@db.ByteA": "bytea",
+    "@db.Text": "text",
+    "@db.Char": "bpchar",
+    "@db.VarChar": "varchar",
+    "@db.Date": "date",
+    "@db.Time": "time",
+    "@db.Timetz": "timetz",
+    "@db.Timestamp": "timestamp",
+    "@db.Timestamptz": "timestamptz",
+    "@db.SmallInt": "smallint",
+    "@db.Integer": "integer",
+    "@db.BigInt": "bigint",
+    "@db.Real": "real",
+    "@db.DoublePrecision": "double precision",
+    "@db.Decimal": "decimal",
+    "@db.Boolean": "boolean"
+  };
   constructor(schema, options) {
     super(schema, options);
     this.overrideTypeParsers();
@@ -2202,8 +2275,16 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
   }
   // #endregion
   // #region other overrides
-  buildArrayAgg(arg) {
-    return this.eb.fn.coalesce(import_kysely4.sql`jsonb_agg(${arg})`, import_kysely4.sql`'[]'::jsonb`);
+  buildArrayAgg(arg, orderBy) {
+    if (!orderBy || orderBy.length === 0) {
+      return this.eb.fn.coalesce(import_kysely4.sql`jsonb_agg(${arg})`, import_kysely4.sql`'[]'::jsonb`);
+    }
+    const orderBySql = import_kysely4.sql.join(orderBy.map(({ expr, sort, nulls }) => {
+      const dir = import_kysely4.sql.raw(sort.toUpperCase());
+      const nullsSql = nulls ? import_kysely4.sql` NULLS ${import_kysely4.sql.raw(nulls.toUpperCase())}` : import_kysely4.sql``;
+      return import_kysely4.sql`${expr} ${dir}${nullsSql}`;
+    }), import_kysely4.sql.raw(", "));
+    return this.eb.fn.coalesce(import_kysely4.sql`jsonb_agg(${arg} ORDER BY ${orderBySql})`, import_kysely4.sql`'[]'::jsonb`);
   }
   buildSkipTake(query, skip, take) {
     if (take !== void 0) {
@@ -2293,13 +2374,55 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
       receiver
     ]).as("$items")).select(this.eb.lit(1).as("_")).where(buildFilter(this.eb.ref("$items.value"))));
   }
-  getSqlType(zmodelType) {
+  getSqlType(zmodelType, attributes) {
+    if (attributes) {
+      for (const attr of attributes) {
+        const mapped = _PostgresCrudDialect.dbAttributeToSqlTypeMap[attr.name];
+        if (mapped) {
+          return mapped;
+        }
+      }
+    }
     if (isEnum(this.schema, zmodelType)) {
       return "text";
     } else {
       return this.zmodelToSqlTypeMap[zmodelType] ?? "text";
     }
   }
+  // Resolves the effective SQL type for a field: the native type from any @db.* attribute,
+  // or the base ZModel SQL type if no attribute is present, or undefined if the field is unknown.
+  resolveFieldSqlType(fieldDef) {
+    if (!fieldDef) {
+      return {
+        sqlType: void 0,
+        hasDbOverride: false
+      };
+    }
+    const dbAttr = fieldDef.attributes?.find((a) => a.name.startsWith("@db."));
+    if (dbAttr) {
+      return {
+        sqlType: _PostgresCrudDialect.dbAttributeToSqlTypeMap[dbAttr.name],
+        hasDbOverride: true
+      };
+    }
+    return {
+      sqlType: this.getSqlType(fieldDef.type),
+      hasDbOverride: false
+    };
+  }
+  buildComparison(left, leftFieldDef, op, right, rightFieldDef) {
+    const leftResolved = this.resolveFieldSqlType(leftFieldDef);
+    const rightResolved = this.resolveFieldSqlType(rightFieldDef);
+    if (leftResolved.sqlType !== rightResolved.sqlType && (leftResolved.hasDbOverride || rightResolved.hasDbOverride)) {
+      if (leftResolved.hasDbOverride) {
+        left = this.eb.cast(left, import_kysely4.sql.raw(this.getSqlType(leftFieldDef.type)));
+      }
+      if (rightResolved.hasDbOverride) {
+        right = this.eb.cast(right, import_kysely4.sql.raw(this.getSqlType(rightFieldDef.type)));
+      }
+    }
+    return super.buildComparison(left, leftFieldDef, op, right, rightFieldDef);
+  }
   getStringCasingBehavior() {
     return {
       supportsILike: true,
@@ -2321,7 +2444,7 @@ var PostgresCrudDialect = class _PostgresCrudDialect extends LateralJoinDialectB
     }
     const eb = (0, import_kysely4.expressionBuilder)();
     return eb.selectFrom(import_kysely4.sql`(VALUES ${import_kysely4.sql.join(rows.map((row) => import_kysely4.sql`(${import_kysely4.sql.join(row.map((v) => import_kysely4.sql.val(v)))})`), import_kysely4.sql.raw(", "))})`.as("$values")).select(fields.map((f, i) => {
-      const mappedType = this.getSqlType(f.type);
+      const mappedType = this.getSqlType(f.type, f.attributes);
       const castType = f.array ? import_kysely4.sql`${import_kysely4.sql.raw(mappedType)}[]` : import_kysely4.sql.raw(mappedType);
       return this.eb.cast(import_kysely4.sql.ref(`$values.column${i + 1}`), castType).as(f.name);
     }));