@objectstack/driver-sql 6.0.0 → 6.2.0

package/dist/index.mjs

@@ -12,6 +12,8 @@ var SqlDriver = class {
     this.version = "1.0.0";
     this.jsonFields = {};
     this.booleanFields = {};
+    this.dateFields = {};
+    this.datetimeFields = {};
     this.tablesWithTimestamps = /* @__PURE__ */ new Set();
     /**
      * Autonumber field configs per table, captured during initObjects.
@@ -746,6 +748,7 @@ var SqlDriver = class {
    * Batch-initialise tables from an array of object definitions.
    */
   async initObjects(objects) {
+    var _a, _b;
     await this.ensureDatabaseExists();
     for (const obj of objects) {
       const tableName = StorageNameMapping.resolveTableName(obj);
@@ -773,6 +776,12 @@ var SqlDriver = class {
           if (type === "boolean") {
             booleanCols.push(name);
           }
+          if (type === "date") {
+            ((_a = this.dateFields)[tableName] ?? (_a[tableName] = /* @__PURE__ */ new Set())).add(name);
+          }
+          if (type === "datetime") {
+            ((_b = this.datetimeFields)[tableName] ?? (_b[tableName] = /* @__PURE__ */ new Set())).add(name);
+          }
           if (type === "auto_number" || type === "autonumber") {
             const fmt = typeof field.format === "string" && field.format ? field.format : "{0000}";
             const m = fmt.match(/\{(0+)\}/);
@@ -960,19 +969,83 @@ var SqlDriver = class {
     );
   }
   // ── Filter helpers ──────────────────────────────────────────────────────────
+  /**
+   * Resolve the underlying table name for a Knex query builder so we can
+   * look up column type metadata (date/datetime maps populated during
+   * `initObjects`). Returns null when the builder is not table-scoped yet.
+   */
+  tableNameForBuilder(builder) {
+    const t = builder?._single?.table;
+    if (typeof t === "string") return t;
+    return null;
+  }
+  /**
+   * Normalise a filter value for a single column so the comparison the
+   * driver sends to SQLite matches the on-disk representation.
+   *
+   * The platform stores `Field.datetime()` values as INTEGER milliseconds
+   * (the result of passing a JS `Date` through better-sqlite3) but date
+   * macros like `{last_quarter_start}` expand to an ISO `YYYY-MM-DD` string
+   * client-side. Without coercion the SQL becomes `published_at >= '2026-…'`
+   * which collapses to a TEXT-vs-INTEGER affinity compare and never
+   * matches. We translate the ISO/Date/numeric inputs into the storage
+   * type so the comparison works.
+   *
+   * For `Field.date()` we keep ISO TEXT but normalise Date objects to
+   * `YYYY-MM-DD` for the same reason.
+   */
+  coerceFilterValue(table, field, value) {
+    if (value == null || !table) return value;
+    if (Array.isArray(value)) return value.map((v) => this.coerceFilterValue(table, field, v));
+    const isDatetime = this.datetimeFields[table]?.has(field);
+    const isDate = this.dateFields[table]?.has(field);
+    if (!isDatetime && !isDate) return value;
+    const toMs = (v) => {
+      if (v instanceof Date) return v.getTime();
+      if (typeof v === "number" && Number.isFinite(v)) return v;
+      if (typeof v === "string") {
+        const trimmed = v.trim();
+        if (trimmed === "") return null;
+        if (/^-?\d+$/.test(trimmed)) {
+          const n2 = Number(trimmed);
+          if (Number.isFinite(n2)) return n2;
+        }
+        const iso = /^\d{4}-\d{2}-\d{2}$/.test(trimmed) ? `${trimmed}T00:00:00.000Z` : trimmed;
+        const n = Date.parse(iso);
+        return Number.isFinite(n) ? n : null;
+      }
+      return null;
+    };
+    if (isDatetime) {
+      const ms = toMs(value);
+      return ms == null ? value : ms;
+    }
+    if (value instanceof Date) {
+      const y = value.getUTCFullYear();
+      const m = String(value.getUTCMonth() + 1).padStart(2, "0");
+      const d = String(value.getUTCDate()).padStart(2, "0");
+      return `${y}-${m}-${d}`;
+    }
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (/^\d{4}-\d{2}-\d{2}/.test(trimmed)) return trimmed.slice(0, 10);
+    }
+    return value;
+  }
   applyFilters(builder, filters) {
     if (!filters) return;
+    const table = this.tableNameForBuilder(builder);
     if (!Array.isArray(filters) && typeof filters === "object") {
       const hasMongoOperators = Object.keys(filters).some(
         (k) => k.startsWith("$") || typeof filters[k] === "object" && filters[k] !== null && Object.keys(filters[k]).some((op) => op.startsWith("$"))
       );
       if (hasMongoOperators) {
-        this.applyFilterCondition(builder, filters);
+        this.applyFilterCondition(builder, filters, "and", table);
         return;
       }
       for (const [key, value] of Object.entries(filters)) {
         if (["limit", "offset", "fields", "orderBy"].includes(key)) continue;
-        builder.where(key, value);
+        builder.where(key, this.coerceFilterValue(table, key, value));
       }
       return;
     }
@@ -989,6 +1062,7 @@ var SqlDriver = class {
         const isCriterion = typeof fieldRaw === "string" && typeof op === "string";
         if (isCriterion) {
           const field = this.mapSortField(fieldRaw);
+          const coerced = this.coerceFilterValue(table, field, value);
           const apply = (b) => {
             const method = nextJoin === "or" ? "orWhere" : "where";
             const methodIn = nextJoin === "or" ? "orWhereIn" : "whereIn";
@@ -999,19 +1073,19 @@ var SqlDriver = class {
             }
             switch (op) {
               case "=":
-                b[method](field, value);
+                b[method](field, coerced);
                 break;
               case "!=":
-                b[method](field, "<>", value);
+                b[method](field, "<>", coerced);
                 break;
               case "in":
-                b[methodIn](field, value);
+                b[methodIn](field, coerced);
                 break;
               case "nin":
-                b[methodNotIn](field, value);
+                b[methodNotIn](field, coerced);
                 break;
               default:
-                b[method](field, op, value);
+                b[method](field, op, coerced);
             }
           };
           apply(builder);
@@ -1025,14 +1099,15 @@ var SqlDriver = class {
       }
     }
   }
-  applyFilterCondition(builder, condition, logicalOp = "and") {
+  applyFilterCondition(builder, condition, logicalOp = "and", tableHint) {
     if (!condition || typeof condition !== "object") return;
+    const table = tableHint ?? this.tableNameForBuilder(builder);
     for (const [key, value] of Object.entries(condition)) {
       if (key === "$and" && Array.isArray(value)) {
         builder.where((qb) => {
           for (const sub of value) {
             qb.where((subQb) => {
-              this.applyFilterCondition(subQb, sub, "and");
+              this.applyFilterCondition(subQb, sub, "and", table);
             });
           }
         });
@@ -1041,7 +1116,7 @@ var SqlDriver = class {
         builder[method]((qb) => {
           for (const sub of value) {
             qb.orWhere((subQb) => {
-              this.applyFilterCondition(subQb, sub, "or");
+              this.applyFilterCondition(subQb, sub, "or", table);
             });
           }
         });
@@ -1049,46 +1124,47 @@ var SqlDriver = class {
         const field = this.mapSortField(key);
         for (const [op, opValue] of Object.entries(value)) {
           const method = logicalOp === "or" ? "orWhere" : "where";
+          const coerced = this.coerceFilterValue(table, field, opValue);
           switch (op) {
             case "$eq":
-              builder[method](field, opValue);
+              builder[method](field, coerced);
               break;
             case "$ne":
-              builder[method](field, "<>", opValue);
+              builder[method](field, "<>", coerced);
               break;
             case "$gt":
-              builder[method](field, ">", opValue);
+              builder[method](field, ">", coerced);
               break;
             case "$gte":
-              builder[method](field, ">=", opValue);
+              builder[method](field, ">=", coerced);
               break;
             case "$lt":
-              builder[method](field, "<", opValue);
+              builder[method](field, "<", coerced);
               break;
             case "$lte":
-              builder[method](field, "<=", opValue);
+              builder[method](field, "<=", coerced);
               break;
             case "$in": {
               const mIn = logicalOp === "or" ? "orWhereIn" : "whereIn";
-              builder[mIn](field, opValue);
+              builder[mIn](field, coerced);
               break;
             }
             case "$nin": {
               const mNotIn = logicalOp === "or" ? "orWhereNotIn" : "whereNotIn";
-              builder[mNotIn](field, opValue);
+              builder[mNotIn](field, coerced);
               break;
             }
             case "$contains":
               builder[method](field, "like", `%${opValue}%`);
               break;
             default:
-              builder[method](field, opValue);
+              builder[method](field, coerced);
           }
         }
       } else {
         const field = this.mapSortField(key);
         const method = logicalOp === "or" ? "orWhere" : "where";
-        builder[method](field, value);
+        builder[method](field, this.coerceFilterValue(table, field, value));
       }
     }
   }