@zenstackhq/orm 3.5.2 → 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
@@ -2077,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();
@@ -2341,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,
@@ -2369,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);
     }));