velocious 1.0.492 → 1.0.494

package/build/src/database/query/insert-base.js

@@ -116,7 +116,7 @@ export default class VelociousDatabaseQueryInsertBase {
                 sql += " VALUES ";
                 sql += this._valuesSql(Object.values(this.data));
             }
-            else if (driver.getType() == "sqlite" || driver.getType() == "mssql") {
+            else if (driver.getType() == "sqlite" || driver.getType() == "mssql" || driver.getType() == "pgsql") {
                 sql += " DEFAULT VALUES";
             }
             else if (driver.getType() == "mysql") {
@@ -148,4 +148,4 @@ export default class VelociousDatabaseQueryInsertBase {
         return sql;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"insert-base.js","sourceRoot":"","sources":["../../../../src/database/query/insert-base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport restArgsError from \"../../utils/rest-args-error.js\"\n\nexport default class VelociousDatabaseQueryInsertBase {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {Record<string, ?>} [args.data] - Data payload.\n   * @param {import(\"../drivers/base.js\").default} args.driver - Database driver instance.\n   * @param {string} args.tableName - Table name.\n   * @param {Array<string>} [args.columns] - Column names.\n   * @param {boolean} [args.multiple] - Whether multiple.\n   * @param {string[]} [args.returnLastInsertedColumnNames] - Return last inserted column names.\n   * @param {Array<Array<?>>} [args.rows] - Rows to insert.\n   */\n  constructor({columns, data, driver, multiple, tableName, returnLastInsertedColumnNames, rows, ...restArgs}) {\n    if (!driver) throw new Error(\"No driver given to insert base\")\n    if (!tableName) throw new Error(`Invalid table name given to insert base: ${tableName}`)\n\n    restArgsError(restArgs)\n\n    this.columns = columns\n    this.data = data\n    this.driver = driver\n    this.multiple = multiple\n    this.returnLastInsertedColumnNames = returnLastInsertedColumnNames\n    this.rows = rows\n    this.tableName = tableName\n  }\n\n  /**\n   * Runs get options.\n   * @returns {import(\"../query-parser/options.js\").default} - The options options.\n   */\n  getOptions() {\n    return this.driver.options()\n  }\n\n  /**\n   * Runs format value.\n   * @param {?} value - Value to format.\n   * @returns {string | number} - SQL literal.\n   */\n  formatValue(value) {\n    if (value === null) return \"NULL\"\n\n    return this.getOptions().quote(value)\n  }\n\n  /**\n   * Runs to sql.\n   * @returns {string} SQL statement\n   */\n  toSql() {\n    const {driver} = this\n\n    let sql = `INSERT INTO ${driver.quoteTable(this.tableName)}`\n    let count = 0\n    let columns, lastInsertedSQL\n\n    if (this.returnLastInsertedColumnNames) {\n      if (driver.getType() == \"mssql\") {\n        lastInsertedSQL = ` OUTPUT `\n\n        for (let i = 0; i < this.returnLastInsertedColumnNames.length; i++) {\n          const columnName = this.returnLastInsertedColumnNames[i]\n\n          if (i > 0) {\n            lastInsertedSQL += \", \"\n          }\n\n          lastInsertedSQL += ` INSERTED.${driver.quoteColumn(columnName)}`\n        }\n\n        if (this.data && Object.keys(this.data).length <= 0) {\n          sql += lastInsertedSQL\n        }\n      } else if (driver.getType() == \"mysql\" || driver.getType() == \"pgsql\" || (driver.getType() == \"sqlite\" && driver.supportsInsertIntoReturning())) {\n        lastInsertedSQL = \" RETURNING \"\n\n        for (let i = 0; i < this.returnLastInsertedColumnNames.length; i++) {\n          const columnName = this.returnLastInsertedColumnNames[i]\n\n          if (i > 0) {\n            lastInsertedSQL += \", \"\n          }\n\n          lastInsertedSQL += ` ${driver.quoteColumn(columnName)}`\n        }\n      }\n    }\n\n    if (this.columns && this.rows) {\n      columns = this.columns\n    } else if (this.data) {\n      columns = Object.keys(this.data)\n    } else {\n      throw new Error(\"Neither 'column' and 'rows' or data was given\")\n    }\n\n    if (columns.length > 0) {\n      sql += \" (\"\n\n      for (const columnName of columns) {\n        if (count > 0) sql += \", \"\n\n        sql += driver.quoteColumn(columnName)\n        count++\n      }\n\n      sql += \")\"\n    }\n\n    if (this.returnLastInsertedColumnNames && driver.getType() == \"mssql\" && this.data && Object.keys(this.data).length > 0) {\n      sql += lastInsertedSQL\n    }\n\n    if (this.columns && this.rows) {\n      if (this.rows.length > 0) {\n        sql += \" VALUES \"\n      }\n\n      let count = 0\n\n      for (const row of this.rows) {\n        if (count >= 1) sql += \", \"\n\n        count++\n        sql += this._valuesSql(row)\n      }\n    } else {\n      if (this.data && Object.keys(this.data).length > 0) {\n        sql += \" VALUES \"\n        sql += this._valuesSql(Object.values(this.data))\n      } else if (driver.getType() == \"sqlite\" || driver.getType() == \"mssql\") {\n        sql += \" DEFAULT VALUES\"\n      } else if (driver.getType() == \"mysql\") {\n        sql += \" () VALUES ()\"\n      }\n    }\n\n    if (this.returnLastInsertedColumnNames) {\n      if (driver.getType() == \"pgsql\" || driver.getType() == \"mysql\" || (driver.getType() == \"sqlite\" && driver.supportsInsertIntoReturning())) {\n        sql += lastInsertedSQL\n      }\n    }\n\n    return sql\n  }\n\n  /**\n   * Runs values sql.\n   * @param {Array<?>} data - Data payload.\n   * @returns {string} - SQL string.\n   */\n  _valuesSql(data) {\n    let count = 0\n    let sql = \"(\"\n\n    for (const value of data) {\n      if (count > 0) sql += \", \"\n\n      sql += this.formatValue(value)\n      count++\n    }\n\n    sql += \")\"\n\n    return sql\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"insert-base.js","sourceRoot":"","sources":["../../../../src/database/query/insert-base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport restArgsError from \"../../utils/rest-args-error.js\"\n\nexport default class VelociousDatabaseQueryInsertBase {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {Record<string, ?>} [args.data] - Data payload.\n   * @param {import(\"../drivers/base.js\").default} args.driver - Database driver instance.\n   * @param {string} args.tableName - Table name.\n   * @param {Array<string>} [args.columns] - Column names.\n   * @param {boolean} [args.multiple] - Whether multiple.\n   * @param {string[]} [args.returnLastInsertedColumnNames] - Return last inserted column names.\n   * @param {Array<Array<?>>} [args.rows] - Rows to insert.\n   */\n  constructor({columns, data, driver, multiple, tableName, returnLastInsertedColumnNames, rows, ...restArgs}) {\n    if (!driver) throw new Error(\"No driver given to insert base\")\n    if (!tableName) throw new Error(`Invalid table name given to insert base: ${tableName}`)\n\n    restArgsError(restArgs)\n\n    this.columns = columns\n    this.data = data\n    this.driver = driver\n    this.multiple = multiple\n    this.returnLastInsertedColumnNames = returnLastInsertedColumnNames\n    this.rows = rows\n    this.tableName = tableName\n  }\n\n  /**\n   * Runs get options.\n   * @returns {import(\"../query-parser/options.js\").default} - The options options.\n   */\n  getOptions() {\n    return this.driver.options()\n  }\n\n  /**\n   * Runs format value.\n   * @param {?} value - Value to format.\n   * @returns {string | number} - SQL literal.\n   */\n  formatValue(value) {\n    if (value === null) return \"NULL\"\n\n    return this.getOptions().quote(value)\n  }\n\n  /**\n   * Runs to sql.\n   * @returns {string} SQL statement\n   */\n  toSql() {\n    const {driver} = this\n\n    let sql = `INSERT INTO ${driver.quoteTable(this.tableName)}`\n    let count = 0\n    let columns, lastInsertedSQL\n\n    if (this.returnLastInsertedColumnNames) {\n      if (driver.getType() == \"mssql\") {\n        lastInsertedSQL = ` OUTPUT `\n\n        for (let i = 0; i < this.returnLastInsertedColumnNames.length; i++) {\n          const columnName = this.returnLastInsertedColumnNames[i]\n\n          if (i > 0) {\n            lastInsertedSQL += \", \"\n          }\n\n          lastInsertedSQL += ` INSERTED.${driver.quoteColumn(columnName)}`\n        }\n\n        if (this.data && Object.keys(this.data).length <= 0) {\n          sql += lastInsertedSQL\n        }\n      } else if (driver.getType() == \"mysql\" || driver.getType() == \"pgsql\" || (driver.getType() == \"sqlite\" && driver.supportsInsertIntoReturning())) {\n        lastInsertedSQL = \" RETURNING \"\n\n        for (let i = 0; i < this.returnLastInsertedColumnNames.length; i++) {\n          const columnName = this.returnLastInsertedColumnNames[i]\n\n          if (i > 0) {\n            lastInsertedSQL += \", \"\n          }\n\n          lastInsertedSQL += ` ${driver.quoteColumn(columnName)}`\n        }\n      }\n    }\n\n    if (this.columns && this.rows) {\n      columns = this.columns\n    } else if (this.data) {\n      columns = Object.keys(this.data)\n    } else {\n      throw new Error(\"Neither 'column' and 'rows' or data was given\")\n    }\n\n    if (columns.length > 0) {\n      sql += \" (\"\n\n      for (const columnName of columns) {\n        if (count > 0) sql += \", \"\n\n        sql += driver.quoteColumn(columnName)\n        count++\n      }\n\n      sql += \")\"\n    }\n\n    if (this.returnLastInsertedColumnNames && driver.getType() == \"mssql\" && this.data && Object.keys(this.data).length > 0) {\n      sql += lastInsertedSQL\n    }\n\n    if (this.columns && this.rows) {\n      if (this.rows.length > 0) {\n        sql += \" VALUES \"\n      }\n\n      let count = 0\n\n      for (const row of this.rows) {\n        if (count >= 1) sql += \", \"\n\n        count++\n        sql += this._valuesSql(row)\n      }\n    } else {\n      if (this.data && Object.keys(this.data).length > 0) {\n        sql += \" VALUES \"\n        sql += this._valuesSql(Object.values(this.data))\n      } else if (driver.getType() == \"sqlite\" || driver.getType() == \"mssql\" || driver.getType() == \"pgsql\") {\n        sql += \" DEFAULT VALUES\"\n      } else if (driver.getType() == \"mysql\") {\n        sql += \" () VALUES ()\"\n      }\n    }\n\n    if (this.returnLastInsertedColumnNames) {\n      if (driver.getType() == \"pgsql\" || driver.getType() == \"mysql\" || (driver.getType() == \"sqlite\" && driver.supportsInsertIntoReturning())) {\n        sql += lastInsertedSQL\n      }\n    }\n\n    return sql\n  }\n\n  /**\n   * Runs values sql.\n   * @param {Array<?>} data - Data payload.\n   * @returns {string} - SQL string.\n   */\n  _valuesSql(data) {\n    let count = 0\n    let sql = \"(\"\n\n    for (const value of data) {\n      if (count > 0) sql += \", \"\n\n      sql += this.formatValue(value)\n      count++\n    }\n\n    sql += \")\"\n\n    return sql\n  }\n}\n"]}

package/build/src/sync/server-sequence-allocator.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Wires server sequencing onto a sync model class: registers a beforeCreate
+ * lifecycle callback assigning the next sequence when the record has none, and
+ * defines an `advance<Column>()` instance method (when the model does not
+ * already define one) that re-sequences the record through the allocator.
+ *
+ * The sequence is always written through the model's generated typed setter
+ * (for example `setServerSequence`), so the model must expose the generated
+ * `set<Column>`/`has<Column>` accessors for the column.
+ * @template {typeof import("../database/record/index.js").default} TModelClass
+ * @param {TModelClass} ModelClass - Sync model class to sequence.
+ * @param {object} args - Options.
+ * @param {ServerSequenceAllocator} args.allocator - Allocator providing sequence values.
+ * @param {string} [args.column] - Sequence attribute name.
+ * @returns {TModelClass} The given model class.
+ */
+export function withServerSequence<TModelClass extends typeof import("../database/record/index.js").default>(ModelClass: TModelClass, { allocator, column }: {
+    allocator: ServerSequenceAllocator;
+    column?: string | undefined;
+}): TModelClass;
+/**
+ * Allocates monotonically increasing server sync sequences from an
+ * AUTO_INCREMENT id table: every allocation inserts a row and returns the
+ * driver's last-insert id, so sequences stay unique and increasing across
+ * processes sharing the same database.
+ *
+ * Backed by an auto-created `velocious_server_sequences` table on the
+ * configured database, with a process-local memory counter fallback when no
+ * database is configured (mirroring the sync scope store). Apps with an
+ * existing sequence table (for example a bare `id`-only AUTO_INCREMENT table)
+ * point `tableName` at it and pass `insertData: {}` to insert empty rows.
+ */
+export default class ServerSequenceAllocator {
+    /**
+     * Creates a server sequence allocator.
+     * @param {object} [args] - Options.
+     * @param {import("../configuration.js").default} [args.configuration] - Configuration owning the database. Defaults to the current configuration, resolved lazily per allocation.
+     * @param {string} [args.databaseIdentifier] - Database identifier.
+     * @param {Record<string, ?>} [args.insertData] - Row payload inserted per allocation. Defaults to `{created_at: new Date()}` matching the auto-created table; pass `{}` for bare id-only tables.
+     * @param {string} [args.tableName] - Sequence table name.
+     */
+    constructor({ configuration, databaseIdentifier, insertData, tableName }?: {
+        configuration?: Configuration | undefined;
+        databaseIdentifier?: string | undefined;
+        insertData?: Record<string, any> | undefined;
+        tableName?: string | undefined;
+    });
+    configuration: Configuration | undefined;
+    databaseIdentifier: string;
+    insertData: Record<string, any> | undefined;
+    tableName: string;
+    _memorySequence: number;
+    _isReady: boolean;
+    /** @type {Promise<void> | null} */
+    _readyPromise: Promise<void> | null;
+    /**
+     * Allocates the next monotonically increasing sequence.
+     *
+     * Allocations serialize through a module-level queue per database+table so
+     * parallel `next()` calls - including calls from other allocator instances
+     * sharing the same table and connection - cannot interleave their insert
+     * and last-insert-id reads and hand out duplicate sequences.
+     * @returns {Promise<number>} Next sequence value.
+     */
+    next(): Promise<number>;
+    /**
+     * Ensures the backing table exists.
+     * @returns {Promise<void>} Resolves when ready.
+     */
+    ensureReady(): Promise<void>;
+    /**
+     * Allocates one sequence value after queueing.
+     * @returns {Promise<number>} Allocated sequence value.
+     */
+    _allocateNext(): Promise<number>;
+    /**
+     * Builds the row payload inserted per allocation.
+     * @returns {Record<string, ?>} Insert payload.
+     */
+    _insertPayload(): Record<string, unknown>;
+    /**
+     * Resolves the configuration owning the sequence table.
+     * @returns {import("../configuration.js").default} Resolved configuration.
+     */
+    _getConfiguration(): import("../configuration.js").default;
+    /**
+     * Whether the allocator runs without a configured database.
+     * @returns {boolean} Whether memory storage is used.
+     */
+    _usesMemoryStorage(): boolean;
+    /**
+     * Runs a callback with a database connection.
+     * @template Result
+     * @param {(db: import("../database/drivers/base.js").default) => Promise<Result>} callback - Database callback.
+     * @returns {Promise<Result>} Callback result.
+     */
+    _withDb<Result>(callback: (db: import("../database/drivers/base.js").default) => Promise<Result>): Promise<Result>;
+    /**
+     * Ensures the sequences table exists.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @returns {Promise<boolean>} Whether the table had to be created.
+     */
+    _ensureSequencesTable(db: import("../database/drivers/base.js").default): Promise<boolean>;
+}
+import Configuration from "../configuration.js";
+//# sourceMappingURL=server-sequence-allocator.d.ts.map

package/build/src/sync/server-sequence-allocator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-sequence-allocator.d.ts","sourceRoot":"","sources":["../../../src/sync/server-sequence-allocator.js"],"names":[],"mappings":"AA+LA;;;;;;;;;;;;;;;GAeG;AACH,mCAPoE,WAAW,SAAlE,cAAe,6BAA6B,EAAE,OAAQ,cACxD,WAAW,yBAEnB;IAAsC,SAAS,EAAvC,uBAAuB;IACT,MAAM;CAC5B,GAAU,WAAW,CAwCvB;AAzOD;;;;;;;;;;;GAWG;AACH;IACE;;;;;;;OAOG;IACH,2EALG;QAAqD,aAAa;QAC5C,kBAAkB;QACP,UAAU;QACrB,SAAS;KACjC,EAUA;IARC,yCAAkC;IAClC,2BAA4C;IAC5C,4CAA4B;IAC5B,kBAA0B;IAC1B,wBAAwB;IACxB,kBAAqB;IACrB,mCAAmC;IACnC,eADW,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CACN;IAG3B;;;;;;;;OAQG;IACH,QAFa,OAAO,CAAC,MAAM,CAAC,CAU3B;IAED;;;OAGG;IACH,eAFa,OAAO,CAAC,IAAI,CAAC,CA6BzB;IAED;;;OAGG;IACH,iBAFa,OAAO,CAAC,MAAM,CAAC,CA4B3B;IAED;;;OAGG;IACH,kBAFa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAI7B;IAED;;;OAGG;IACH,qBAFa,OAAO,qBAAqB,EAAE,OAAO,CAIjD;IAED;;;OAGG;IACH,sBAFa,OAAO,CAQnB;IAED;;;;;OAKG;IACH,QAJa,MAAM,YACR,CAAC,EAAE,EAAE,OAAO,6BAA6B,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,GACpE,OAAO,CAAC,MAAM,CAAC,CAU3B;IAED;;;;OAIG;IACH,0BAHW,OAAO,6BAA6B,EAAE,OAAO,GAC3C,OAAO,CAAC,OAAO,CAAC,CAa5B;CACF;0BA3LyB,qBAAqB"}

package/build/src/sync/server-sequence-allocator.js

@@ -0,0 +1,220 @@
+// @ts-check
+import Configuration from "../configuration.js";
+import TableData from "../database/table-data/index.js";
+/**
+ * Allocation queues per database+table, serializing insert/last-insert-id
+ * pairs across all allocator instances in this process.
+ * @type {Map<string, Promise<void>>}
+ */
+const allocationQueues = new Map();
+/**
+ * Allocates monotonically increasing server sync sequences from an
+ * AUTO_INCREMENT id table: every allocation inserts a row and returns the
+ * driver's last-insert id, so sequences stay unique and increasing across
+ * processes sharing the same database.
+ *
+ * Backed by an auto-created `velocious_server_sequences` table on the
+ * configured database, with a process-local memory counter fallback when no
+ * database is configured (mirroring the sync scope store). Apps with an
+ * existing sequence table (for example a bare `id`-only AUTO_INCREMENT table)
+ * point `tableName` at it and pass `insertData: {}` to insert empty rows.
+ */
+export default class ServerSequenceAllocator {
+    /**
+     * Creates a server sequence allocator.
+     * @param {object} [args] - Options.
+     * @param {import("../configuration.js").default} [args.configuration] - Configuration owning the database. Defaults to the current configuration, resolved lazily per allocation.
+     * @param {string} [args.databaseIdentifier] - Database identifier.
+     * @param {Record<string, ?>} [args.insertData] - Row payload inserted per allocation. Defaults to `{created_at: new Date()}` matching the auto-created table; pass `{}` for bare id-only tables.
+     * @param {string} [args.tableName] - Sequence table name.
+     */
+    constructor({ configuration, databaseIdentifier = "default", insertData, tableName = "velocious_server_sequences" } = {}) {
+        this.configuration = configuration;
+        this.databaseIdentifier = databaseIdentifier;
+        this.insertData = insertData;
+        this.tableName = tableName;
+        this._memorySequence = 0;
+        this._isReady = false;
+        /** @type {Promise<void> | null} */
+        this._readyPromise = null;
+    }
+    /**
+     * Allocates the next monotonically increasing sequence.
+     *
+     * Allocations serialize through a module-level queue per database+table so
+     * parallel `next()` calls - including calls from other allocator instances
+     * sharing the same table and connection - cannot interleave their insert
+     * and last-insert-id reads and hand out duplicate sequences.
+     * @returns {Promise<number>} Next sequence value.
+     */
+    async next() {
+        const queueKey = `${this.databaseIdentifier}::${this.tableName}`;
+        const previousAllocation = allocationQueues.get(queueKey) ?? Promise.resolve();
+        const allocation = previousAllocation.then(() => this._allocateNext());
+        allocationQueues.set(queueKey, allocation.then(() => undefined, () => undefined));
+        return await allocation;
+    }
+    /**
+     * Ensures the backing table exists.
+     * @returns {Promise<void>} Resolves when ready.
+     */
+    async ensureReady() {
+        if (this._isReady)
+            return;
+        if (this._usesMemoryStorage()) {
+            this._isReady = true;
+            return;
+        }
+        if (this._readyPromise)
+            return await this._readyPromise;
+        this._readyPromise = this._withDb(async (db) => {
+            const created = await this._ensureSequencesTable(db);
+            // DDL joins any transaction already open on this connection (the mixin's
+            // beforeCreate allocation always runs inside the record save transaction),
+            // and on transactional-DDL databases (MSSQL, PostgreSQL, SQLite) a rollback
+            // of that outer transaction removes the just-created table again. Only
+            // cache readiness when the table was not created inside an active
+            // transaction; otherwise the next allocation re-verifies the table.
+            if (!created || !db.insideTransaction())
+                this._isReady = true;
+        });
+        try {
+            await this._readyPromise;
+        }
+        finally {
+            if (!this._isReady)
+                this._readyPromise = null;
+        }
+    }
+    /**
+     * Allocates one sequence value after queueing.
+     * @returns {Promise<number>} Allocated sequence value.
+     */
+    async _allocateNext() {
+        await this.ensureReady();
+        if (this._usesMemoryStorage()) {
+            return ++this._memorySequence;
+        }
+        return await this._withDb(async (db) => {
+            // The allocated id must be returned by the insert statement itself (OUTPUT
+            // INSERTED/RETURNING), like the record create path does: MSSQL's
+            // SCOPE_IDENTITY() only sees inserts from the same batch/scope, so reading
+            // the last-insert id as a separate query always returns NULL there. Drivers
+            // without insert-returning support (older SQLite) keep the reliable
+            // connection-scoped last-insert-id fallback.
+            const insertSql = db.insertSql({
+                data: this._insertPayload(),
+                returnLastInsertedColumnNames: ["id"],
+                tableName: this.tableName
+            });
+            const insertResult = await db.query(insertSql);
+            const insertedId = Array.isArray(insertResult) ? insertResult[0]?.id : undefined;
+            if (insertedId !== undefined && insertedId !== null)
+                return Number(insertedId);
+            return Number(await db.lastInsertID());
+        });
+    }
+    /**
+     * Builds the row payload inserted per allocation.
+     * @returns {Record<string, ?>} Insert payload.
+     */
+    _insertPayload() {
+        return this.insertData ?? { created_at: new Date() };
+    }
+    /**
+     * Resolves the configuration owning the sequence table.
+     * @returns {import("../configuration.js").default} Resolved configuration.
+     */
+    _getConfiguration() {
+        return this.configuration ?? Configuration.current();
+    }
+    /**
+     * Whether the allocator runs without a configured database.
+     * @returns {boolean} Whether memory storage is used.
+     */
+    _usesMemoryStorage() {
+        try {
+            return !this._getConfiguration().getDatabaseConfiguration()[this.databaseIdentifier];
+        }
+        catch {
+            return true;
+        }
+    }
+    /**
+     * Runs a callback with a database connection.
+     * @template Result
+     * @param {(db: import("../database/drivers/base.js").default) => Promise<Result>} callback - Database callback.
+     * @returns {Promise<Result>} Callback result.
+     */
+    async _withDb(callback) {
+        return await this._getConfiguration().ensureConnections({ name: "Server sequence allocator" }, async (dbs) => {
+            const db = dbs[this.databaseIdentifier];
+            if (!db)
+                throw new Error(`No database connection available for identifier: ${this.databaseIdentifier}`);
+            return await callback(db);
+        });
+    }
+    /**
+     * Ensures the sequences table exists.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @returns {Promise<boolean>} Whether the table had to be created.
+     */
+    async _ensureSequencesTable(db) {
+        if (await db.tableExists(this.tableName))
+            return false;
+        const table = new TableData(this.tableName, { ifNotExists: true });
+        table.bigint("id", { autoIncrement: true, null: false, primaryKey: true });
+        table.datetime("created_at", { null: false });
+        await db.createTable(table);
+        return true;
+    }
+}
+/**
+ * Wires server sequencing onto a sync model class: registers a beforeCreate
+ * lifecycle callback assigning the next sequence when the record has none, and
+ * defines an `advance<Column>()` instance method (when the model does not
+ * already define one) that re-sequences the record through the allocator.
+ *
+ * The sequence is always written through the model's generated typed setter
+ * (for example `setServerSequence`), so the model must expose the generated
+ * `set<Column>`/`has<Column>` accessors for the column.
+ * @template {typeof import("../database/record/index.js").default} TModelClass
+ * @param {TModelClass} ModelClass - Sync model class to sequence.
+ * @param {object} args - Options.
+ * @param {ServerSequenceAllocator} args.allocator - Allocator providing sequence values.
+ * @param {string} [args.column] - Sequence attribute name.
+ * @returns {TModelClass} The given model class.
+ */
+export function withServerSequence(ModelClass, { allocator, column = "serverSequence" }) {
+    if (!(allocator instanceof ServerSequenceAllocator)) {
+        throw new Error(`withServerSequence requires a ServerSequenceAllocator, got: ${String(allocator)}`);
+    }
+    const upperColumn = `${column.charAt(0).toUpperCase()}${column.slice(1)}`;
+    const advanceMethodName = `advance${upperColumn}`;
+    const hasMethodName = `has${upperColumn}`;
+    const setterMethodName = `set${upperColumn}`;
+    // Narrows the prototype to dynamic method access for the configured column name.
+    const prototype = /** @type {Record<string, ?>} */ (ModelClass.prototype);
+    if (typeof prototype[setterMethodName] != "function" || typeof prototype[hasMethodName] != "function") {
+        throw new Error(`withServerSequence requires generated ${setterMethodName} and ${hasMethodName} accessors on ${ModelClass.name}`);
+    }
+    if (typeof prototype[advanceMethodName] != "function") {
+        /**
+         * Assigns the next server-side sequence.
+         * @this {Record<string, ?>}
+         * @returns {Promise<void>}
+         */
+        prototype[advanceMethodName] = async function advanceServerSequenceThroughAllocator() {
+            this[setterMethodName](await allocator.next());
+        };
+    }
+    ModelClass.beforeCreate(async (record) => {
+        // Narrows the record to dynamic method access for the configured column name.
+        const dynamicRecord = /** @type {Record<string, ?>} */ ( /** @type {?} */(record));
+        if (dynamicRecord[hasMethodName]())
+            return;
+        await dynamicRecord[advanceMethodName]();
+    });
+    return ModelClass;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server-sequence-allocator.js","sourceRoot":"","sources":["../../../src/sync/server-sequence-allocator.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Configuration from \"../configuration.js\"\nimport TableData from \"../database/table-data/index.js\"\n\n/**\n * Allocation queues per database+table, serializing insert/last-insert-id\n * pairs across all allocator instances in this process.\n * @type {Map<string, Promise<void>>}\n */\nconst allocationQueues = new Map()\n\n/**\n * Allocates monotonically increasing server sync sequences from an\n * AUTO_INCREMENT id table: every allocation inserts a row and returns the\n * driver's last-insert id, so sequences stay unique and increasing across\n * processes sharing the same database.\n *\n * Backed by an auto-created `velocious_server_sequences` table on the\n * configured database, with a process-local memory counter fallback when no\n * database is configured (mirroring the sync scope store). Apps with an\n * existing sequence table (for example a bare `id`-only AUTO_INCREMENT table)\n * point `tableName` at it and pass `insertData: {}` to insert empty rows.\n */\nexport default class ServerSequenceAllocator {\n  /**\n   * Creates a server sequence allocator.\n   * @param {object} [args] - Options.\n   * @param {import(\"../configuration.js\").default} [args.configuration] - Configuration owning the database. Defaults to the current configuration, resolved lazily per allocation.\n   * @param {string} [args.databaseIdentifier] - Database identifier.\n   * @param {Record<string, ?>} [args.insertData] - Row payload inserted per allocation. Defaults to `{created_at: new Date()}` matching the auto-created table; pass `{}` for bare id-only tables.\n   * @param {string} [args.tableName] - Sequence table name.\n   */\n  constructor({configuration, databaseIdentifier = \"default\", insertData, tableName = \"velocious_server_sequences\"} = {}) {\n    this.configuration = configuration\n    this.databaseIdentifier = databaseIdentifier\n    this.insertData = insertData\n    this.tableName = tableName\n    this._memorySequence = 0\n    this._isReady = false\n    /** @type {Promise<void> | null} */\n    this._readyPromise = null\n  }\n\n  /**\n   * Allocates the next monotonically increasing sequence.\n   *\n   * Allocations serialize through a module-level queue per database+table so\n   * parallel `next()` calls - including calls from other allocator instances\n   * sharing the same table and connection - cannot interleave their insert\n   * and last-insert-id reads and hand out duplicate sequences.\n   * @returns {Promise<number>} Next sequence value.\n   */\n  async next() {\n    const queueKey = `${this.databaseIdentifier}::${this.tableName}`\n    const previousAllocation = allocationQueues.get(queueKey) ?? Promise.resolve()\n    const allocation = previousAllocation.then(() => this._allocateNext())\n\n    allocationQueues.set(queueKey, allocation.then(() => undefined, () => undefined))\n\n    return await allocation\n  }\n\n  /**\n   * Ensures the backing table exists.\n   * @returns {Promise<void>} Resolves when ready.\n   */\n  async ensureReady() {\n    if (this._isReady) return\n\n    if (this._usesMemoryStorage()) {\n      this._isReady = true\n      return\n    }\n\n    if (this._readyPromise) return await this._readyPromise\n\n    this._readyPromise = this._withDb(async (db) => {\n      const created = await this._ensureSequencesTable(db)\n\n      // DDL joins any transaction already open on this connection (the mixin's\n      // beforeCreate allocation always runs inside the record save transaction),\n      // and on transactional-DDL databases (MSSQL, PostgreSQL, SQLite) a rollback\n      // of that outer transaction removes the just-created table again. Only\n      // cache readiness when the table was not created inside an active\n      // transaction; otherwise the next allocation re-verifies the table.\n      if (!created || !db.insideTransaction()) this._isReady = true\n    })\n\n    try {\n      await this._readyPromise\n    } finally {\n      if (!this._isReady) this._readyPromise = null\n    }\n  }\n\n  /**\n   * Allocates one sequence value after queueing.\n   * @returns {Promise<number>} Allocated sequence value.\n   */\n  async _allocateNext() {\n    await this.ensureReady()\n\n    if (this._usesMemoryStorage()) {\n      return ++this._memorySequence\n    }\n\n    return await this._withDb(async (db) => {\n      // The allocated id must be returned by the insert statement itself (OUTPUT\n      // INSERTED/RETURNING), like the record create path does: MSSQL's\n      // SCOPE_IDENTITY() only sees inserts from the same batch/scope, so reading\n      // the last-insert id as a separate query always returns NULL there. Drivers\n      // without insert-returning support (older SQLite) keep the reliable\n      // connection-scoped last-insert-id fallback.\n      const insertSql = db.insertSql({\n        data: this._insertPayload(),\n        returnLastInsertedColumnNames: [\"id\"],\n        tableName: this.tableName\n      })\n      const insertResult = await db.query(insertSql)\n      const insertedId = Array.isArray(insertResult) ? insertResult[0]?.id : undefined\n\n      if (insertedId !== undefined && insertedId !== null) return Number(insertedId)\n\n      return Number(await db.lastInsertID())\n    })\n  }\n\n  /**\n   * Builds the row payload inserted per allocation.\n   * @returns {Record<string, ?>} Insert payload.\n   */\n  _insertPayload() {\n    return this.insertData ?? {created_at: new Date()}\n  }\n\n  /**\n   * Resolves the configuration owning the sequence table.\n   * @returns {import(\"../configuration.js\").default} Resolved configuration.\n   */\n  _getConfiguration() {\n    return this.configuration ?? Configuration.current()\n  }\n\n  /**\n   * Whether the allocator runs without a configured database.\n   * @returns {boolean} Whether memory storage is used.\n   */\n  _usesMemoryStorage() {\n    try {\n      return !this._getConfiguration().getDatabaseConfiguration()[this.databaseIdentifier]\n    } catch {\n      return true\n    }\n  }\n\n  /**\n   * Runs a callback with a database connection.\n   * @template Result\n   * @param {(db: import(\"../database/drivers/base.js\").default) => Promise<Result>} callback - Database callback.\n   * @returns {Promise<Result>} Callback result.\n   */\n  async _withDb(callback) {\n    return await this._getConfiguration().ensureConnections({name: \"Server sequence allocator\"}, async (dbs) => {\n      const db = dbs[this.databaseIdentifier]\n\n      if (!db) throw new Error(`No database connection available for identifier: ${this.databaseIdentifier}`)\n\n      return await callback(db)\n    })\n  }\n\n  /**\n   * Ensures the sequences table exists.\n   * @param {import(\"../database/drivers/base.js\").default} db - Database connection.\n   * @returns {Promise<boolean>} Whether the table had to be created.\n   */\n  async _ensureSequencesTable(db) {\n    if (await db.tableExists(this.tableName)) return false\n\n    const table = new TableData(this.tableName, {ifNotExists: true})\n\n    table.bigint(\"id\", {autoIncrement: true, null: false, primaryKey: true})\n    table.datetime(\"created_at\", {null: false})\n\n    await db.createTable(table)\n\n    return true\n  }\n}\n\n/**\n * Wires server sequencing onto a sync model class: registers a beforeCreate\n * lifecycle callback assigning the next sequence when the record has none, and\n * defines an `advance<Column>()` instance method (when the model does not\n * already define one) that re-sequences the record through the allocator.\n *\n * The sequence is always written through the model's generated typed setter\n * (for example `setServerSequence`), so the model must expose the generated\n * `set<Column>`/`has<Column>` accessors for the column.\n * @template {typeof import(\"../database/record/index.js\").default} TModelClass\n * @param {TModelClass} ModelClass - Sync model class to sequence.\n * @param {object} args - Options.\n * @param {ServerSequenceAllocator} args.allocator - Allocator providing sequence values.\n * @param {string} [args.column] - Sequence attribute name.\n * @returns {TModelClass} The given model class.\n */\nexport function withServerSequence(ModelClass, {allocator, column = \"serverSequence\"}) {\n  if (!(allocator instanceof ServerSequenceAllocator)) {\n    throw new Error(`withServerSequence requires a ServerSequenceAllocator, got: ${String(allocator)}`)\n  }\n\n  const upperColumn = `${column.charAt(0).toUpperCase()}${column.slice(1)}`\n  const advanceMethodName = `advance${upperColumn}`\n  const hasMethodName = `has${upperColumn}`\n  const setterMethodName = `set${upperColumn}`\n\n  // Narrows the prototype to dynamic method access for the configured column name.\n  const prototype = /** @type {Record<string, ?>} */ (ModelClass.prototype)\n\n  if (typeof prototype[setterMethodName] != \"function\" || typeof prototype[hasMethodName] != \"function\") {\n    throw new Error(`withServerSequence requires generated ${setterMethodName} and ${hasMethodName} accessors on ${ModelClass.name}`)\n  }\n\n  if (typeof prototype[advanceMethodName] != \"function\") {\n    /**\n     * Assigns the next server-side sequence.\n     * @this {Record<string, ?>}\n     * @returns {Promise<void>}\n     */\n    prototype[advanceMethodName] = async function advanceServerSequenceThroughAllocator() {\n      this[setterMethodName](await allocator.next())\n    }\n  }\n\n  ModelClass.beforeCreate(async (record) => {\n    // Narrows the record to dynamic method access for the configured column name.\n    const dynamicRecord = /** @type {Record<string, ?>} */ (/** @type {?} */ (record))\n\n    if (dynamicRecord[hasMethodName]()) return\n\n    await dynamicRecord[advanceMethodName]()\n  })\n\n  return ModelClass\n}\n"]}

package/build/src/sync/sync-attribute-normalizer.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Builds the error thrown for a failed sync attribute validation.
+ * @callback SyncAttributeErrorFactory
+ * @param {string} message - Human-readable validation message.
+ * @param {{cause?: Error, code: string}} details - Stable machine-readable code and optional cause.
+ * @returns {Error} Error to throw.
+ */
+/**
+ * Declarative validation schema for one writable sync attribute.
+ *
+ * Keys are camelCase attribute names; each attribute also accepts its
+ * snake_case column key on input (the camelCase key wins when both are given)
+ * and is written under the snake_case column key on output. Error messages
+ * default to `<label> ...` phrasings with `sync-<label>-...` codes, where the
+ * label defaults to the camelCase attribute name; apps pin exact messages per
+ * attribute through the `*Message` overrides.
+ * @typedef {object} SyncAttributeSchemaEntry
+ * @property {"date" | "json" | "raw" | "string"} type - Attribute value type.
+ * @property {boolean} [required] - Whether present blank/absent values are rejected (strings reject blank-after-trim, dates reject null).
+ * @property {number} [maxLength] - Maximum string length, checked after trimming.
+ * @property {string} [label] - Label used in derived messages and codes.
+ * @property {string} [column] - Output column key. Defaults to the snake_cased attribute name.
+ * @property {string} [requiredMessage] - Pinned message for required rejections.
+ * @property {string} [tooLongMessage] - Pinned message for too-long rejections.
+ * @property {string} [invalidMessage] - Pinned message for invalid dates and non-object/non-string json values.
+ * @property {string} [invalidJsonMessage] - Pinned message for unparseable json strings.
+ */
+/**
+ * Normalizes writable sync attributes against a declarative schema.
+ *
+ * Only present keys are validated, so required attributes may be absent —
+ * create defaults own that concern. Input keys not declared in the schema are
+ * rejected by default so misspelled or read-only attributes fail loudly
+ * instead of being silently discarded (`unknownAttributes: "ignore"` opts
+ * out). Validation failures throw through the given error factory so apps
+ * control the raised error class.
+ * @param {object} args - Options.
+ * @param {Record<string, ?>} args.attributes - Raw incoming attributes (camelCase and/or snake_case keys).
+ * @param {SyncAttributeErrorFactory} args.errorFactory - Maps validation failures to thrown errors.
+ * @param {Record<string, SyncAttributeSchemaEntry>} args.schema - Attribute schema keyed by camelCase attribute name.
+ * @param {"error" | "ignore"} [args.unknownAttributes] - Unknown input-key handling. Defaults to "error".
+ * @returns {Record<string, ?>} Normalized values keyed by snake_case column names.
+ */
+export default function normalizeAttributesWithSchema({ attributes, errorFactory, schema, unknownAttributes }: {
+    attributes: Record<string, unknown>;
+    errorFactory: SyncAttributeErrorFactory;
+    schema: Record<string, SyncAttributeSchemaEntry>;
+    unknownAttributes?: "error" | "ignore" | undefined;
+}): Record<string, unknown>;
+/**
+ * Builds the error thrown for a failed sync attribute validation.
+ */
+export type SyncAttributeErrorFactory = (message: string, details: {
+    cause?: Error;
+    code: string;
+}) => Error;
+/**
+ * Declarative validation schema for one writable sync attribute.
+ *
+ * Keys are camelCase attribute names; each attribute also accepts its
+ * snake_case column key on input (the camelCase key wins when both are given)
+ * and is written under the snake_case column key on output. Error messages
+ * default to `<label> ...` phrasings with `sync-<label>-...` codes, where the
+ * label defaults to the camelCase attribute name; apps pin exact messages per
+ * attribute through the `*Message` overrides.
+ */
+export type SyncAttributeSchemaEntry = {
+    /**
+     * - Attribute value type.
+     */
+    type: "date" | "json" | "raw" | "string";
+    /**
+     * - Whether present blank/absent values are rejected (strings reject blank-after-trim, dates reject null).
+     */
+    required?: boolean | undefined;
+    /**
+     * - Maximum string length, checked after trimming.
+     */
+    maxLength?: number | undefined;
+    /**
+     * - Label used in derived messages and codes.
+     */
+    label?: string | undefined;
+    /**
+     * - Output column key. Defaults to the snake_cased attribute name.
+     */
+    column?: string | undefined;
+    /**
+     * - Pinned message for required rejections.
+     */
+    requiredMessage?: string | undefined;
+    /**
+     * - Pinned message for too-long rejections.
+     */
+    tooLongMessage?: string | undefined;
+    /**
+     * - Pinned message for invalid dates and non-object/non-string json values.
+     */
+    invalidMessage?: string | undefined;
+    /**
+     * - Pinned message for unparseable json strings.
+     */
+    invalidJsonMessage?: string | undefined;
+};
+//# sourceMappingURL=sync-attribute-normalizer.d.ts.map

package/build/src/sync/sync-attribute-normalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-attribute-normalizer.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-attribute-normalizer.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,+GANG;IAAgC,UAAU,EAAlC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;IACe,YAAY,EAA5C,yBAAyB;IACsB,MAAM,EAArD,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC;IACd,iBAAiB;CACnD,GAAU,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAqC7B;;;;kDA7EU,MAAM,WACN;IAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,KAC3B,KAAK;;;;;;;;;;;;;;;UAaJ,MAAM,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ"}