@objectstack/driver-sql 9.9.1 → 9.11.0

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { SchemaMode, QueryAST, DriverOptions } from '@objectstack/spec/data';
+import { AutonumberToken, SchemaMode, QueryAST, DriverOptions } from '@objectstack/spec/data';
 import { IDataDriver } from '@objectstack/spec/contracts';
 import knex, { Knex } from 'knex';
 
@@ -98,6 +98,7 @@ declare class SqlDriver implements IDataDriver {
     protected config: Knex.Config;
     protected jsonFields: Record<string, string[]>;
     protected booleanFields: Record<string, string[]>;
+    protected numericFields: Record<string, string[]>;
     protected dateFields: Record<string, Set<string>>;
     protected datetimeFields: Record<string, Set<string>>;
     protected tablesWithTimestamps: Set<string>;
@@ -118,12 +119,19 @@ declare class SqlDriver implements IDataDriver {
     protected autoNumberFields: Record<string, Array<{
         name: string;
         format: string;
-        prefix: string;
-        padWidth: number;
+        tokens: AutonumberToken[];
         tenantField: string | null;
     }>>;
     /** Whether the sequences table has been ensured this process. */
     protected sequencesTableReady: boolean;
+    /**
+     * Whether `_objectstack_sequences` is the current `key_hash`-keyed shape.
+     * Set on a fresh create or a successful in-place migration. If a legacy table
+     * could NOT be migrated, this stays false: fixed-prefix sequences (empty
+     * scope) keep working via the legacy `(object, tenant_id, field)` key, while a
+     * per-scope write raises an actionable error rather than corrupting counters.
+     */
+    protected sequencesHasKeyHash: boolean;
     /** In-flight ensure promise; deduplicates concurrent first calls. */
     protected sequencesTableEnsurePromise: Promise<void> | null;
     /**
@@ -213,8 +221,34 @@ declare class SqlDriver implements IDataDriver {
     /**
      * Ensure the sequence-counter table exists. Idempotent and cheap after
      * the first call (cached via `sequencesTableReady`).
+     *
+     * The row key is `key_hash` — a SHA-256 of `(object, tenant_id, field, scope)`
+     * where `scope` is the rendered autonumber prefix (date/field tokens before
+     * the `{0000}` slot), so a new day/group/parent starts a fresh counter. A
+     * single 64-char hashed primary key (rather than the four raw columns, which
+     * blow past MySQL's 3072-byte index limit under utf8mb4 and bound how long a
+     * `{field}` scope may be) keys every dialect uniformly and lets `scope` be a
+     * generous non-indexed column. Fixed-prefix formats use the empty scope and
+     * keep their single global counter (backward compatible).
      */
     protected ensureSequencesTable(): Promise<void>;
+    /** SHA-256 of the composite counter key — the table's single-column PK. */
+    protected sequenceKeyHash(object: string, tenantId: string, field: string, scope: string): string;
+    /** Create the current `key_hash`-keyed sequences table shape. */
+    protected createSequencesTable(table: string): Promise<void>;
+    /**
+     * Migrate a pre-existing `_objectstack_sequences` table to the current
+     * `key_hash`-keyed shape. Handles both the original 3-column table (no
+     * `scope`) and an interim 4-column `(object, tenant_id, field, scope)` table:
+     * every legacy row is read, its `key_hash` computed in app code (no portable
+     * SQL hash exists), and re-inserted into a freshly built table that then
+     * replaces the original. Idempotent — a no-op once `key_hash` is present.
+     *
+     * If the rebuild fails, `sequencesHasKeyHash` stays false: fixed-prefix
+     * sequences keep working via the legacy key and per-scope writes error
+     * actionably (see getNextSequenceValue), rather than corrupting data.
+     */
+    protected ensureSequencesKeyHashShape(): Promise<void>;
     /**
      * Bootstrap helper: scan the data table for the highest numeric suffix
      * matching `prefix` (optionally scoped to a tenant). Used the first time
@@ -236,12 +270,14 @@ declare class SqlDriver implements IDataDriver {
      * Gaps are tolerated by design — a rolled-back insert "burns" a number,
      * matching standard sequence semantics.
      */
-    protected getNextSequenceValue(object: string, tableName: string, field: string, prefix: string, tenantField: string | null, tenantId: string | null, parentTrx?: Knex.Transaction): Promise<number>;
+    protected getNextSequenceValue(object: string, tableName: string, field: string, prefix: string, tenantField: string | null, tenantId: string | null, parentTrx?: Knex.Transaction, scope?: string): Promise<number>;
     /**
-     * For each `auto_number` field on the object that the caller did not
-     * provide a value for, reserve the next sequence value scoped to the
-     * record's tenant (or globally if the object has no tenant field) and
-     * render `prefix + zero-padded(value)`.
+     * For each `auto_number` field the caller left empty, render the format and
+     * reserve the next counter value. The counter is scoped to the rendered
+     * prefix (date tokens like `{YYYYMMDD}` in the request's business timezone,
+     * plus `{field}` interpolation from the row), so it resets per period/group;
+     * the full rendered prefix bootstraps the counter from existing data, and the
+     * tenant scopes it for isolation.
      */
     protected fillAutoNumberFields(object: string, row: Record<string, any>, options?: DriverOptions): Promise<void>;
     update(object: string, id: string | number, data: Record<string, any>, options?: DriverOptions): Promise<any>;
@@ -429,6 +465,27 @@ declare class SqlDriver implements IDataDriver {
      * `YYYY-MM-DD` for the same reason.
      */
     protected coerceFilterValue(table: string | null, field: string, value: any): any;
+    /**
+     * 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: string, field: string, value: any): any;
     protected applyFilters(builder: Knex.QueryBuilder, filters: any): void;
     /**
      * Apply a `contains` substring match as a parameterized `LIKE '%…%'`, escaping

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { SchemaMode, QueryAST, DriverOptions } from '@objectstack/spec/data';
+import { AutonumberToken, SchemaMode, QueryAST, DriverOptions } from '@objectstack/spec/data';
 import { IDataDriver } from '@objectstack/spec/contracts';
 import knex, { Knex } from 'knex';
 
@@ -98,6 +98,7 @@ declare class SqlDriver implements IDataDriver {
     protected config: Knex.Config;
     protected jsonFields: Record<string, string[]>;
     protected booleanFields: Record<string, string[]>;
+    protected numericFields: Record<string, string[]>;
     protected dateFields: Record<string, Set<string>>;
     protected datetimeFields: Record<string, Set<string>>;
     protected tablesWithTimestamps: Set<string>;
@@ -118,12 +119,19 @@ declare class SqlDriver implements IDataDriver {
     protected autoNumberFields: Record<string, Array<{
         name: string;
         format: string;
-        prefix: string;
-        padWidth: number;
+        tokens: AutonumberToken[];
         tenantField: string | null;
     }>>;
     /** Whether the sequences table has been ensured this process. */
     protected sequencesTableReady: boolean;
+    /**
+     * Whether `_objectstack_sequences` is the current `key_hash`-keyed shape.
+     * Set on a fresh create or a successful in-place migration. If a legacy table
+     * could NOT be migrated, this stays false: fixed-prefix sequences (empty
+     * scope) keep working via the legacy `(object, tenant_id, field)` key, while a
+     * per-scope write raises an actionable error rather than corrupting counters.
+     */
+    protected sequencesHasKeyHash: boolean;
     /** In-flight ensure promise; deduplicates concurrent first calls. */
     protected sequencesTableEnsurePromise: Promise<void> | null;
     /**
@@ -213,8 +221,34 @@ declare class SqlDriver implements IDataDriver {
     /**
      * Ensure the sequence-counter table exists. Idempotent and cheap after
      * the first call (cached via `sequencesTableReady`).
+     *
+     * The row key is `key_hash` — a SHA-256 of `(object, tenant_id, field, scope)`
+     * where `scope` is the rendered autonumber prefix (date/field tokens before
+     * the `{0000}` slot), so a new day/group/parent starts a fresh counter. A
+     * single 64-char hashed primary key (rather than the four raw columns, which
+     * blow past MySQL's 3072-byte index limit under utf8mb4 and bound how long a
+     * `{field}` scope may be) keys every dialect uniformly and lets `scope` be a
+     * generous non-indexed column. Fixed-prefix formats use the empty scope and
+     * keep their single global counter (backward compatible).
      */
     protected ensureSequencesTable(): Promise<void>;
+    /** SHA-256 of the composite counter key — the table's single-column PK. */
+    protected sequenceKeyHash(object: string, tenantId: string, field: string, scope: string): string;
+    /** Create the current `key_hash`-keyed sequences table shape. */
+    protected createSequencesTable(table: string): Promise<void>;
+    /**
+     * Migrate a pre-existing `_objectstack_sequences` table to the current
+     * `key_hash`-keyed shape. Handles both the original 3-column table (no
+     * `scope`) and an interim 4-column `(object, tenant_id, field, scope)` table:
+     * every legacy row is read, its `key_hash` computed in app code (no portable
+     * SQL hash exists), and re-inserted into a freshly built table that then
+     * replaces the original. Idempotent — a no-op once `key_hash` is present.
+     *
+     * If the rebuild fails, `sequencesHasKeyHash` stays false: fixed-prefix
+     * sequences keep working via the legacy key and per-scope writes error
+     * actionably (see getNextSequenceValue), rather than corrupting data.
+     */
+    protected ensureSequencesKeyHashShape(): Promise<void>;
     /**
      * Bootstrap helper: scan the data table for the highest numeric suffix
      * matching `prefix` (optionally scoped to a tenant). Used the first time
@@ -236,12 +270,14 @@ declare class SqlDriver implements IDataDriver {
      * Gaps are tolerated by design — a rolled-back insert "burns" a number,
      * matching standard sequence semantics.
      */
-    protected getNextSequenceValue(object: string, tableName: string, field: string, prefix: string, tenantField: string | null, tenantId: string | null, parentTrx?: Knex.Transaction): Promise<number>;
+    protected getNextSequenceValue(object: string, tableName: string, field: string, prefix: string, tenantField: string | null, tenantId: string | null, parentTrx?: Knex.Transaction, scope?: string): Promise<number>;
     /**
-     * For each `auto_number` field on the object that the caller did not
-     * provide a value for, reserve the next sequence value scoped to the
-     * record's tenant (or globally if the object has no tenant field) and
-     * render `prefix + zero-padded(value)`.
+     * For each `auto_number` field the caller left empty, render the format and
+     * reserve the next counter value. The counter is scoped to the rendered
+     * prefix (date tokens like `{YYYYMMDD}` in the request's business timezone,
+     * plus `{field}` interpolation from the row), so it resets per period/group;
+     * the full rendered prefix bootstraps the counter from existing data, and the
+     * tenant scopes it for isolation.
      */
     protected fillAutoNumberFields(object: string, row: Record<string, any>, options?: DriverOptions): Promise<void>;
     update(object: string, id: string | number, data: Record<string, any>, options?: DriverOptions): Promise<any>;
@@ -429,6 +465,27 @@ declare class SqlDriver implements IDataDriver {
      * `YYYY-MM-DD` for the same reason.
      */
     protected coerceFilterValue(table: string | null, field: string, value: any): any;
+    /**
+     * 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: string, field: string, value: any): any;
     protected applyFilters(builder: Knex.QueryBuilder, filters: any): void;
     /**
      * Apply a `contains` substring match as a parameterized `LIKE '%…%'`, escaping

package/dist/index.js

@@ -36,6 +36,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/sql-driver.ts
+var import_data = require("@objectstack/spec/data");
 var import_system = require("@objectstack/spec/system");
 var import_shared = require("@objectstack/spec/shared");
 var import_knex = __toESM(require("knex"));
@@ -48,9 +49,12 @@ var JSON_COLUMN_TYPES = /* @__PURE__ */ new Set([
   "json",
   "object",
   "array",
+  "record",
   "image",
   "file",
   "avatar",
+  "video",
+  "audio",
   "location",
   "address",
   "composite",
@@ -60,6 +64,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
@@ -67,6 +83,7 @@ var SqlDriver = class {
     this.version = "1.0.0";
     this.jsonFields = {};
     this.booleanFields = {};
+    this.numericFields = {};
     this.dateFields = {};
     this.datetimeFields = {};
     this.tablesWithTimestamps = /* @__PURE__ */ new Set();
@@ -87,6 +104,14 @@ var SqlDriver = class {
     this.autoNumberFields = {};
     /** Whether the sequences table has been ensured this process. */
     this.sequencesTableReady = false;
+    /**
+     * Whether `_objectstack_sequences` is the current `key_hash`-keyed shape.
+     * Set on a fresh create or a successful in-place migration. If a legacy table
+     * could NOT be migrated, this stays false: fixed-prefix sequences (empty
+     * scope) keep working via the legacy `(object, tenant_id, field)` key, while a
+     * per-scope write raises an actionable error rather than corrupting counters.
+     */
+    this.sequencesHasKeyHash = false;
     /** In-flight ensure promise; deduplicates concurrent first calls. */
     this.sequencesTableEnsurePromise = null;
     /**
@@ -394,6 +419,15 @@ var SqlDriver = class {
   /**
    * Ensure the sequence-counter table exists. Idempotent and cheap after
    * the first call (cached via `sequencesTableReady`).
+   *
+   * The row key is `key_hash` — a SHA-256 of `(object, tenant_id, field, scope)`
+   * where `scope` is the rendered autonumber prefix (date/field tokens before
+   * the `{0000}` slot), so a new day/group/parent starts a fresh counter. A
+   * single 64-char hashed primary key (rather than the four raw columns, which
+   * blow past MySQL's 3072-byte index limit under utf8mb4 and bound how long a
+   * `{field}` scope may be) keys every dialect uniformly and lets `scope` be a
+   * generous non-indexed column. Fixed-prefix formats use the empty scope and
+   * keep their single global counter (backward compatible).
    */
   async ensureSequencesTable() {
     if (this.sequencesTableReady) return;
@@ -405,18 +439,15 @@ var SqlDriver = class {
       const exists = await this.knex.schema.hasTable(SEQUENCES_TABLE);
       if (!exists) {
         try {
-          await this.knex.schema.createTable(SEQUENCES_TABLE, (t) => {
-            t.string("object").notNullable();
-            t.string("tenant_id").notNullable();
-            t.string("field").notNullable();
-            t.bigInteger("last_value").notNullable().defaultTo(0);
-            t.timestamp("updated_at").defaultTo(this.knex.fn.now());
-            t.primary(["object", "tenant_id", "field"]);
-          });
+          await this.createSequencesTable(SEQUENCES_TABLE);
+          this.sequencesHasKeyHash = true;
         } catch (err) {
           const stillMissing = !await this.knex.schema.hasTable(SEQUENCES_TABLE);
           if (stillMissing) throw err;
+          await this.ensureSequencesKeyHashShape();
         }
+      } else {
+        await this.ensureSequencesKeyHashShape();
       }
       this.sequencesTableReady = true;
     })();
@@ -426,6 +457,71 @@ var SqlDriver = class {
       this.sequencesTableEnsurePromise = null;
     }
   }
+  /** SHA-256 of the composite counter key — the table's single-column PK. */
+  sequenceKeyHash(object, tenantId, field, scope) {
+    return (0, import_node_crypto.createHash)("sha256").update(`${object}${tenantId}${field}${scope}`).digest("hex");
+  }
+  /** Create the current `key_hash`-keyed sequences table shape. */
+  async createSequencesTable(table) {
+    await this.knex.schema.createTable(table, (t) => {
+      t.string("key_hash", 64).notNullable().primary();
+      t.string("object").notNullable();
+      t.string("tenant_id").notNullable();
+      t.string("field").notNullable();
+      t.string("scope", 1024).notNullable().defaultTo("");
+      t.bigInteger("last_value").notNullable().defaultTo(0);
+      t.timestamp("updated_at").defaultTo(this.knex.fn.now());
+    });
+  }
+  /**
+   * Migrate a pre-existing `_objectstack_sequences` table to the current
+   * `key_hash`-keyed shape. Handles both the original 3-column table (no
+   * `scope`) and an interim 4-column `(object, tenant_id, field, scope)` table:
+   * every legacy row is read, its `key_hash` computed in app code (no portable
+   * SQL hash exists), and re-inserted into a freshly built table that then
+   * replaces the original. Idempotent — a no-op once `key_hash` is present.
+   *
+   * If the rebuild fails, `sequencesHasKeyHash` stays false: fixed-prefix
+   * sequences keep working via the legacy key and per-scope writes error
+   * actionably (see getNextSequenceValue), rather than corrupting data.
+   */
+  async ensureSequencesKeyHashShape() {
+    if (await this.knex.schema.hasColumn(SEQUENCES_TABLE, "key_hash")) {
+      this.sequencesHasKeyHash = true;
+      return;
+    }
+    const hasScope = await this.knex.schema.hasColumn(SEQUENCES_TABLE, "scope");
+    const TMP = `${SEQUENCES_TABLE}__rebuild`;
+    try {
+      const rows = await this.knex(SEQUENCES_TABLE).select("*");
+      await this.knex.schema.dropTableIfExists(TMP);
+      await this.createSequencesTable(TMP);
+      const migrated = rows.map((r) => {
+        const scope = hasScope && r.scope != null ? String(r.scope) : "";
+        return {
+          key_hash: this.sequenceKeyHash(String(r.object), String(r.tenant_id), String(r.field), scope),
+          object: r.object,
+          tenant_id: r.tenant_id,
+          field: r.field,
+          scope,
+          last_value: r.last_value ?? 0,
+          updated_at: r.updated_at ?? this.knex.fn.now()
+        };
+      });
+      if (migrated.length > 0) await this.knex(TMP).insert(migrated);
+      await this.knex.schema.dropTable(SEQUENCES_TABLE);
+      await this.knex.schema.renameTable(TMP, SEQUENCES_TABLE);
+      this.sequencesHasKeyHash = true;
+    } catch (err) {
+      this.sequencesHasKeyHash = false;
+      await this.knex.schema.dropTableIfExists(TMP).catch(() => {
+      });
+      this.logger.warn(
+        `[autonumber] Failed to migrate ${SEQUENCES_TABLE} to the key_hash shape. Fixed-prefix autonumbers keep working; date/{field}/per-parent formats will error until the table is migrated.`,
+        { error: String(err) }
+      );
+    }
+  }
   /**
    * Bootstrap helper: scan the data table for the highest numeric suffix
    * matching `prefix` (optionally scoped to a tenant). Used the first time
@@ -463,10 +559,16 @@ var SqlDriver = class {
    * Gaps are tolerated by design — a rolled-back insert "burns" a number,
    * matching standard sequence semantics.
    */
-  async getNextSequenceValue(object, tableName, field, prefix, tenantField, tenantId, parentTrx) {
+  async getNextSequenceValue(object, tableName, field, prefix, tenantField, tenantId, parentTrx, scope = "") {
     await this.ensureSequencesTable();
     const resolvedTenantId = tenantField && tenantId ? String(tenantId) : GLOBAL_TENANT;
-    const key = { object: tableName, tenant_id: resolvedTenantId, field };
+    if (scope !== "" && !this.sequencesHasKeyHash) {
+      throw new Error(
+        `Cannot generate a per-scope autonumber for "${object}.${field}": the ${SEQUENCES_TABLE} table is still the legacy shape. Migrate it to the key_hash shape before using date/{field}/per-parent formats.`
+      );
+    }
+    const key = this.sequencesHasKeyHash ? { key_hash: this.sequenceKeyHash(tableName, resolvedTenantId, field, scope) } : { object: tableName, tenant_id: resolvedTenantId, field };
+    const insertRow = this.sequencesHasKeyHash ? { ...key, object: tableName, tenant_id: resolvedTenantId, field, scope } : { ...key };
     const runner = parentTrx ?? this.knex;
     return runner.transaction(async (trx) => {
       let existing;
@@ -486,7 +588,7 @@ var SqlDriver = class {
         );
         const initial = seedMax + 1;
         try {
-          await trx(SEQUENCES_TABLE).insert({ ...key, last_value: initial });
+          await trx(SEQUENCES_TABLE).insert({ ...insertRow, last_value: initial });
           return initial;
         } catch (err) {
           existing = await trx(SEQUENCES_TABLE).where(key).forUpdate().first();
@@ -499,31 +601,43 @@ var SqlDriver = class {
     });
   }
   /**
-   * For each `auto_number` field on the object that the caller did not
-   * provide a value for, reserve the next sequence value scoped to the
-   * record's tenant (or globally if the object has no tenant field) and
-   * render `prefix + zero-padded(value)`.
+   * For each `auto_number` field the caller left empty, render the format and
+   * reserve the next counter value. The counter is scoped to the rendered
+   * prefix (date tokens like `{YYYYMMDD}` in the request's business timezone,
+   * plus `{field}` interpolation from the row), so it resets per period/group;
+   * the full rendered prefix bootstraps the counter from existing data, and the
+   * tenant scopes it for isolation.
    */
   async fillAutoNumberFields(object, row, options) {
     const tableName = import_system.StorageNameMapping.resolveTableName({ name: object });
     const cfgs = this.autoNumberFields[tableName] || this.autoNumberFields[object];
     if (!cfgs || cfgs.length === 0) return;
     const parentTrx = options?.transaction;
+    const timezone = options?.timezone;
+    const now = /* @__PURE__ */ new Date();
     for (const cfg of cfgs) {
       if (row[cfg.name] !== void 0 && row[cfg.name] !== null && row[cfg.name] !== "") continue;
+      const missing = (0, import_data.missingFieldValues)(cfg.tokens, row);
+      if (missing.length > 0) {
+        throw new Error(
+          `Cannot generate autonumber "${object}.${cfg.name}" (format "${cfg.format}"): referenced field(s) [${missing.join(", ")}] are empty on the record. Fields interpolated into an autonumber format must be set before the record is created.`
+        );
+      }
       const rowTenant = cfg.tenantField ? row[cfg.tenantField] : void 0;
       const optTenant = options?.tenantId;
       const tenantId = rowTenant != null && rowTenant !== "" ? String(rowTenant) : optTenant != null && optTenant !== "" ? String(optTenant) : null;
+      const probe = (0, import_data.renderAutonumber)({ tokens: cfg.tokens, seq: 0, record: row, now, timezone });
       const next = await this.getNextSequenceValue(
         object,
         tableName,
         cfg.name,
-        cfg.prefix,
+        probe.prefix,
         cfg.tenantField,
         tenantId,
-        parentTrx
+        parentTrx,
+        probe.scope
       );
-      row[cfg.name] = `${cfg.prefix}${String(next).padStart(cfg.padWidth, "0")}`;
+      row[cfg.name] = (0, import_data.renderAutonumber)({ tokens: cfg.tokens, seq: next, record: row, now, timezone }).value;
     }
   }
   async update(object, id, data, options) {
@@ -847,6 +961,7 @@ var SqlDriver = class {
       const tableName = import_system.StorageNameMapping.resolveTableName(obj);
       const jsonCols = [];
       const booleanCols = [];
+      const numericCols = [];
       const autoNumberCols = [];
       const tenancyDecl = obj?.tenancy;
       let tenantField = null;
@@ -866,9 +981,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);
           }
@@ -878,15 +996,14 @@ var SqlDriver = class {
           if (type === "auto_number" || type === "autonumber") {
             const rawFmt = typeof field.autonumberFormat === "string" && field.autonumberFormat ? field.autonumberFormat : typeof field.format === "string" && field.format ? field.format : "";
             const fmt = rawFmt || "{0000}";
-            const m = fmt.match(/\{(0+)\}/);
-            const padWidth = m ? m[1].length : 4;
-            const prefix = m ? fmt.slice(0, m.index ?? 0) : fmt;
-            autoNumberCols.push({ name, format: fmt, prefix, padWidth, tenantField });
+            const tokens = (0, import_data.parseAutonumberFormat)(fmt);
+            autoNumberCols.push({ name, format: fmt, tokens, tenantField });
           }
         }
       }
       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);
@@ -1238,11 +1355,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);
@@ -1464,9 +1605,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":
@@ -1478,22 +1633,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) {
@@ -1511,7 +1650,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();
@@ -1676,6 +1815,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) {