@objectstack/driver-sql 9.9.1 → 9.10.0

package/dist/index.mjs

@@ -11,9 +11,12 @@ var JSON_COLUMN_TYPES = /* @__PURE__ */ new Set([
   "json",
   "object",
   "array",
+  "record",
   "image",
   "file",
   "avatar",
+  "video",
+  "audio",
   "location",
   "address",
   "composite",
@@ -23,6 +26,18 @@ var JSON_COLUMN_TYPES = /* @__PURE__ */ new Set([
   "repeater",
   "vector"
 ]);
+var NUMERIC_SCALAR_TYPES = /* @__PURE__ */ new Set([
+  "integer",
+  "int",
+  "float",
+  "number",
+  "currency",
+  "percent",
+  "summary",
+  "rating",
+  "slider",
+  "progress"
+]);
 var SqlDriver = class {
   constructor(config) {
     // IDataDriver metadata
@@ -30,6 +45,7 @@ var SqlDriver = class {
     this.version = "1.0.0";
     this.jsonFields = {};
     this.booleanFields = {};
+    this.numericFields = {};
     this.dateFields = {};
     this.datetimeFields = {};
     this.tablesWithTimestamps = /* @__PURE__ */ new Set();
@@ -810,6 +826,7 @@ var SqlDriver = class {
       const tableName = StorageNameMapping.resolveTableName(obj);
       const jsonCols = [];
       const booleanCols = [];
+      const numericCols = [];
       const autoNumberCols = [];
       const tenancyDecl = obj?.tenancy;
       let tenantField = null;
@@ -829,9 +846,12 @@ var SqlDriver = class {
           if (this.isJsonField(type, field)) {
             jsonCols.push(name);
           }
-          if (type === "boolean") {
+          if (type === "boolean" || type === "toggle") {
             booleanCols.push(name);
           }
+          if (NUMERIC_SCALAR_TYPES.has(type) && !field.multiple) {
+            numericCols.push(name);
+          }
           if (type === "date") {
             ((_a = this.dateFields)[tableName] ?? (_a[tableName] = /* @__PURE__ */ new Set())).add(name);
           }
@@ -850,6 +870,7 @@ var SqlDriver = class {
       }
       this.jsonFields[tableName] = jsonCols;
       this.booleanFields[tableName] = booleanCols;
+      this.numericFields[tableName] = numericCols;
       this.autoNumberFields[tableName] = autoNumberCols;
       this.tenantFieldByTable[tableName] = tenantField;
       let exists = await this.knex.schema.hasTable(tableName);
@@ -1201,11 +1222,35 @@ var SqlDriver = class {
       return null;
     };
     if (isDatetime) {
+      if (!this.isSqlite) return value;
       const ms = toMs(value);
       return ms == null ? value : ms;
     }
     return this.toDateOnly(value);
   }
+  /**
+   * Public, dialect-correct temporal filter-value coercion for callers that
+   * build SQL *outside* the normal `find()`/`applyFilters()` path — chiefly the
+   * analytics native-SQL strategy, which compiles a raw `SELECT … WHERE col >= $N`
+   * and binds the value directly, bypassing `coerceFilterValue`.
+   *
+   * Given a logical object (table) name, a field name and a filter value
+   * (typically an ISO date/datetime string from a dashboard relative-date
+   * token like `{12_months_ago}`), this returns the value in the column's
+   * on-disk storage form:
+   *   - SQLite `Field.datetime` → epoch milliseconds (INTEGER), so the
+   *     comparison matches the stored integer rather than failing a
+   *     TEXT-vs-INTEGER affinity compare.
+   *   - `Field.date` (any dialect)   → `YYYY-MM-DD` text.
+   *   - Native-timestamp dialects / non-temporal fields → value unchanged.
+   *
+   * This is a thin, intentionally narrow wrapper over the same `coerceFilterValue`
+   * the driver already uses, so there is exactly one source of truth for the
+   * storage convention and the analytics path can never drift from CRUD.
+   */
+  temporalFilterValue(objectName, field, value) {
+    return this.coerceFilterValue(objectName, field, value);
+  }
   applyFilters(builder, filters) {
     if (!filters) return;
     const table = this.tableNameForBuilder(builder);
@@ -1427,9 +1472,23 @@ var SqlDriver = class {
       case "number":
       case "currency":
       case "percent":
+      // `rating`/`slider`/`progress` are authored as numeric scalars (a star
+      // count, a slider position, a percent-of-completion). Without an explicit
+      // case they fell to `default → table.string`, giving the column TEXT
+      // affinity so SQLite coerced the written number to a string ('4' not 4) —
+      // a silent type-fidelity leak the value-loss tests didn't catch. REAL
+      // affinity round-trips them as JS numbers (#field-zoo).
+      case "rating":
+      case "slider":
+      case "progress":
         col = table.float(name);
         break;
+      // `toggle` is a boolean rendered as a switch. Same leak as above (TEXT
+      // affinity stored '1'); a boolean column gives NUMERIC affinity and the
+      // `booleanFields` read-coercion below converts the stored 1/0 back to a
+      // real JS boolean.
       case "boolean":
+      case "toggle":
         col = table.boolean(name);
         break;
       case "date":
@@ -1441,22 +1500,6 @@ var SqlDriver = class {
       case "time":
         col = table.time(name);
         break;
-      case "json":
-      case "object":
-      case "array":
-      case "image":
-      case "file":
-      case "avatar":
-      case "location":
-      case "address":
-      case "composite":
-      case "multiselect":
-      case "checkboxes":
-      case "tags":
-      case "repeater":
-      case "vector":
-        col = table.json(name);
-        break;
       case "lookup":
         col = table.string(name);
         if (field.reference_to) {
@@ -1474,7 +1517,7 @@ var SqlDriver = class {
         return;
       // Virtual — no column
       default:
-        col = table.string(name);
+        col = JSON_COLUMN_TYPES.has(type) ? table.json(name) : table.string(name);
     }
     if (col) {
       if (field.unique) col.unique();
@@ -1639,6 +1682,16 @@ var SqlDriver = class {
           }
         }
       }
+      const numericFields = this.numericFields[object];
+      if (numericFields && numericFields.length > 0) {
+        for (const field of numericFields) {
+          const v = data[field];
+          if (typeof v === "string" && v.trim() !== "") {
+            const n = Number(v);
+            if (!Number.isNaN(n)) data[field] = n;
+          }
+        }
+      }
     }
     const dateFields = this.dateFields[object];
     if (dateFields && dateFields.size > 0) {