velocious 1.0.493 → 1.0.495

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"}

package/build/src/sync/sync-attribute-normalizer.js

@@ -0,0 +1,172 @@
+// @ts-check
+import { snakeCaseKey } from "typanic";
+/**
+ * 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 = "error" }) {
+    if (!attributes || typeof attributes != "object")
+        throw new Error(`normalizeAttributesWithSchema requires an attributes object, got: ${String(attributes)}`);
+    if (typeof errorFactory != "function")
+        throw new Error("normalizeAttributesWithSchema requires an errorFactory function");
+    if (!schema || typeof schema != "object")
+        throw new Error(`normalizeAttributesWithSchema requires a schema object, got: ${String(schema)}`);
+    if (unknownAttributes != "error" && unknownAttributes != "ignore") {
+        throw new Error(`normalizeAttributesWithSchema unknownAttributes must be "error" or "ignore", got: ${String(unknownAttributes)}`);
+    }
+    /** @type {Record<string, ?>} */
+    const normalized = {};
+    /** @type {Set<string>} */
+    const knownInputKeys = new Set();
+    for (const [attributeName, entry] of Object.entries(schema)) {
+        const column = entry.column ?? snakeCaseKey(attributeName);
+        const inputKeys = column == attributeName ? [attributeName] : [column, attributeName];
+        for (const inputKey of inputKeys) {
+            knownInputKeys.add(inputKey);
+            if (!Object.prototype.hasOwnProperty.call(attributes, inputKey))
+                continue;
+            normalized[column] = normalizeAttributeValue({ attributeName, entry, errorFactory, value: attributes[inputKey] });
+        }
+    }
+    if (unknownAttributes == "error") {
+        for (const inputKey of Object.keys(attributes)) {
+            if (!knownInputKeys.has(inputKey)) {
+                throw errorFactory(`Unknown attribute: ${inputKey}.`, { code: "sync-unknown-attribute" });
+            }
+        }
+    }
+    return normalized;
+}
+/**
+ * Normalizes one present attribute value per its schema entry.
+ * @param {object} args - Options.
+ * @param {string} args.attributeName - camelCase attribute name.
+ * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.
+ * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.
+ * @param {?} args.value - Raw value.
+ * @returns {?} Normalized value.
+ */
+function normalizeAttributeValue({ attributeName, entry, errorFactory, value }) {
+    const label = entry.label ?? attributeName;
+    if (entry.type == "string")
+        return normalizeString({ entry, errorFactory, label, value });
+    if (entry.type == "date")
+        return normalizeDate({ entry, errorFactory, label, value });
+    if (entry.type == "json")
+        return normalizeJson({ entry, errorFactory, label, value });
+    if (entry.type == "raw")
+        return value;
+    throw new Error(`Unknown sync attribute schema type for ${attributeName}: ${String(entry.type)}`);
+}
+/**
+ * Normalizes a string attribute: trims, rejects blank required values after trimming, maps empty optional values to null and bounds the trimmed length.
+ * @param {object} args - Options.
+ * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.
+ * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.
+ * @param {string} args.label - Message/code label.
+ * @param {?} args.value - Raw value.
+ * @returns {string | null} Normalized string.
+ */
+function normalizeString({ entry, errorFactory, label, value }) {
+    const requiredError = () => errorFactory(entry.requiredMessage ?? `${label} is required.`, { code: `sync-${label}-required` });
+    if (value === null || value === undefined || value === "") {
+        if (entry.required)
+            throw requiredError();
+        return null;
+    }
+    const stringValue = String(value).trim();
+    if (stringValue === "") {
+        if (entry.required)
+            throw requiredError();
+        return null;
+    }
+    if (entry.maxLength !== undefined && stringValue.length > entry.maxLength) {
+        throw errorFactory(entry.tooLongMessage ?? `${label} is too long (maximum is ${entry.maxLength} characters).`, { code: `sync-${label}-too-long` });
+    }
+    return stringValue;
+}
+/**
+ * Normalizes a date attribute: Date instances pass through, strings/numbers are parsed and invalid or missing-required values are rejected.
+ * @param {object} args - Options.
+ * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.
+ * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.
+ * @param {string} args.label - Message/code label.
+ * @param {?} args.value - Raw value.
+ * @returns {Date | null} Normalized date.
+ */
+function normalizeDate({ entry, errorFactory, label, value }) {
+    if (!entry.required && (value === null || value === undefined || value === ""))
+        return null;
+    const dateValue = value instanceof Date ? value : typeof value == "string" || typeof value == "number" ? new Date(value) : null;
+    if (!dateValue || Number.isNaN(dateValue.getTime())) {
+        throw errorFactory(entry.invalidMessage ?? `${label} must be a valid datetime.`, { code: `sync-${label}-invalid-datetime` });
+    }
+    return dateValue;
+}
+/**
+ * Normalizes a json attribute: empty values become null, objects pass through, strings must parse as JSON and other types are rejected.
+ * @param {object} args - Options.
+ * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.
+ * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.
+ * @param {string} args.label - Message/code label.
+ * @param {?} args.value - Raw value.
+ * @returns {?} Normalized json value.
+ */
+function normalizeJson({ entry, errorFactory, label, value }) {
+    if (value === null || value === undefined || value === "")
+        return null;
+    if (typeof value == "object")
+        return value;
+    if (typeof value == "string") {
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            throw errorFactory(entry.invalidJsonMessage ?? `${label} must be valid JSON.`, {
+                cause: /** @type {Error} */ (error),
+                code: `sync-${label}-invalid-json`
+            });
+        }
+    }
+    throw errorFactory(entry.invalidMessage ?? `${label} must be an object or JSON string.`, { code: `sync-${label}-invalid` });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-attribute-normalizer.js","sourceRoot":"","sources":["../../../src/sync/sync-attribute-normalizer.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {snakeCaseKey} from \"typanic\"\n\n/**\n * Builds the error thrown for a failed sync attribute validation.\n * @callback SyncAttributeErrorFactory\n * @param {string} message - Human-readable validation message.\n * @param {{cause?: Error, code: string}} details - Stable machine-readable code and optional cause.\n * @returns {Error} Error to throw.\n */\n\n/**\n * Declarative validation schema for one writable sync attribute.\n *\n * Keys are camelCase attribute names; each attribute also accepts its\n * snake_case column key on input (the camelCase key wins when both are given)\n * and is written under the snake_case column key on output. Error messages\n * default to `<label> ...` phrasings with `sync-<label>-...` codes, where the\n * label defaults to the camelCase attribute name; apps pin exact messages per\n * attribute through the `*Message` overrides.\n * @typedef {object} SyncAttributeSchemaEntry\n * @property {\"date\" | \"json\" | \"raw\" | \"string\"} type - Attribute value type.\n * @property {boolean} [required] - Whether present blank/absent values are rejected (strings reject blank-after-trim, dates reject null).\n * @property {number} [maxLength] - Maximum string length, checked after trimming.\n * @property {string} [label] - Label used in derived messages and codes.\n * @property {string} [column] - Output column key. Defaults to the snake_cased attribute name.\n * @property {string} [requiredMessage] - Pinned message for required rejections.\n * @property {string} [tooLongMessage] - Pinned message for too-long rejections.\n * @property {string} [invalidMessage] - Pinned message for invalid dates and non-object/non-string json values.\n * @property {string} [invalidJsonMessage] - Pinned message for unparseable json strings.\n */\n\n/**\n * Normalizes writable sync attributes against a declarative schema.\n *\n * Only present keys are validated, so required attributes may be absent —\n * create defaults own that concern. Input keys not declared in the schema are\n * rejected by default so misspelled or read-only attributes fail loudly\n * instead of being silently discarded (`unknownAttributes: \"ignore\"` opts\n * out). Validation failures throw through the given error factory so apps\n * control the raised error class.\n * @param {object} args - Options.\n * @param {Record<string, ?>} args.attributes - Raw incoming attributes (camelCase and/or snake_case keys).\n * @param {SyncAttributeErrorFactory} args.errorFactory - Maps validation failures to thrown errors.\n * @param {Record<string, SyncAttributeSchemaEntry>} args.schema - Attribute schema keyed by camelCase attribute name.\n * @param {\"error\" | \"ignore\"} [args.unknownAttributes] - Unknown input-key handling. Defaults to \"error\".\n * @returns {Record<string, ?>} Normalized values keyed by snake_case column names.\n */\nexport default function normalizeAttributesWithSchema({attributes, errorFactory, schema, unknownAttributes = \"error\"}) {\n  if (!attributes || typeof attributes != \"object\") throw new Error(`normalizeAttributesWithSchema requires an attributes object, got: ${String(attributes)}`)\n  if (typeof errorFactory != \"function\") throw new Error(\"normalizeAttributesWithSchema requires an errorFactory function\")\n  if (!schema || typeof schema != \"object\") throw new Error(`normalizeAttributesWithSchema requires a schema object, got: ${String(schema)}`)\n  if (unknownAttributes != \"error\" && unknownAttributes != \"ignore\") {\n    throw new Error(`normalizeAttributesWithSchema unknownAttributes must be \"error\" or \"ignore\", got: ${String(unknownAttributes)}`)\n  }\n\n  /** @type {Record<string, ?>} */\n  const normalized = {}\n  /** @type {Set<string>} */\n  const knownInputKeys = new Set()\n\n  for (const [attributeName, entry] of Object.entries(schema)) {\n    const column = entry.column ?? snakeCaseKey(attributeName)\n    const inputKeys = column == attributeName ? [attributeName] : [column, attributeName]\n\n    for (const inputKey of inputKeys) {\n      knownInputKeys.add(inputKey)\n\n      if (!Object.prototype.hasOwnProperty.call(attributes, inputKey)) continue\n\n      normalized[column] = normalizeAttributeValue({attributeName, entry, errorFactory, value: attributes[inputKey]})\n    }\n  }\n\n  if (unknownAttributes == \"error\") {\n    for (const inputKey of Object.keys(attributes)) {\n      if (!knownInputKeys.has(inputKey)) {\n        throw errorFactory(`Unknown attribute: ${inputKey}.`, {code: \"sync-unknown-attribute\"})\n      }\n    }\n  }\n\n  return normalized\n}\n\n/**\n * Normalizes one present attribute value per its schema entry.\n * @param {object} args - Options.\n * @param {string} args.attributeName - camelCase attribute name.\n * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.\n * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.\n * @param {?} args.value - Raw value.\n * @returns {?} Normalized value.\n */\nfunction normalizeAttributeValue({attributeName, entry, errorFactory, value}) {\n  const label = entry.label ?? attributeName\n\n  if (entry.type == \"string\") return normalizeString({entry, errorFactory, label, value})\n  if (entry.type == \"date\") return normalizeDate({entry, errorFactory, label, value})\n  if (entry.type == \"json\") return normalizeJson({entry, errorFactory, label, value})\n  if (entry.type == \"raw\") return value\n\n  throw new Error(`Unknown sync attribute schema type for ${attributeName}: ${String(entry.type)}`)\n}\n\n/**\n * Normalizes a string attribute: trims, rejects blank required values after trimming, maps empty optional values to null and bounds the trimmed length.\n * @param {object} args - Options.\n * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.\n * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.\n * @param {string} args.label - Message/code label.\n * @param {?} args.value - Raw value.\n * @returns {string | null} Normalized string.\n */\nfunction normalizeString({entry, errorFactory, label, value}) {\n  const requiredError = () => errorFactory(entry.requiredMessage ?? `${label} is required.`, {code: `sync-${label}-required`})\n\n  if (value === null || value === undefined || value === \"\") {\n    if (entry.required) throw requiredError()\n\n    return null\n  }\n\n  const stringValue = String(value).trim()\n\n  if (stringValue === \"\") {\n    if (entry.required) throw requiredError()\n\n    return null\n  }\n\n  if (entry.maxLength !== undefined && stringValue.length > entry.maxLength) {\n    throw errorFactory(entry.tooLongMessage ?? `${label} is too long (maximum is ${entry.maxLength} characters).`, {code: `sync-${label}-too-long`})\n  }\n\n  return stringValue\n}\n\n/**\n * Normalizes a date attribute: Date instances pass through, strings/numbers are parsed and invalid or missing-required values are rejected.\n * @param {object} args - Options.\n * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.\n * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.\n * @param {string} args.label - Message/code label.\n * @param {?} args.value - Raw value.\n * @returns {Date | null} Normalized date.\n */\nfunction normalizeDate({entry, errorFactory, label, value}) {\n  if (!entry.required && (value === null || value === undefined || value === \"\")) return null\n\n  const dateValue = value instanceof Date ? value : typeof value == \"string\" || typeof value == \"number\" ? new Date(value) : null\n\n  if (!dateValue || Number.isNaN(dateValue.getTime())) {\n    throw errorFactory(entry.invalidMessage ?? `${label} must be a valid datetime.`, {code: `sync-${label}-invalid-datetime`})\n  }\n\n  return dateValue\n}\n\n/**\n * Normalizes a json attribute: empty values become null, objects pass through, strings must parse as JSON and other types are rejected.\n * @param {object} args - Options.\n * @param {SyncAttributeSchemaEntry} args.entry - Schema entry.\n * @param {SyncAttributeErrorFactory} args.errorFactory - Error factory.\n * @param {string} args.label - Message/code label.\n * @param {?} args.value - Raw value.\n * @returns {?} Normalized json value.\n */\nfunction normalizeJson({entry, errorFactory, label, value}) {\n  if (value === null || value === undefined || value === \"\") return null\n  if (typeof value == \"object\") return value\n\n  if (typeof value == \"string\") {\n    try {\n      return JSON.parse(value)\n    } catch (error) {\n      throw errorFactory(entry.invalidJsonMessage ?? `${label} must be valid JSON.`, {\n        cause: /** @type {Error} */ (error),\n        code: `sync-${label}-invalid-json`\n      })\n    }\n  }\n\n  throw errorFactory(entry.invalidMessage ?? `${label} must be an object or JSON string.`, {code: `sync-${label}-invalid`})\n}\n"]}

package/build/src/sync/sync-resource-base.d.ts

@@ -14,6 +14,54 @@
  * @augments {FrontendModelBaseResource<TModelClass>}
  */
 export default class SyncResourceBase<TModelClass extends typeof import("../database/record/index.js").default = typeof import("../database/record/index.js").default> extends FrontendModelBaseResource<TModelClass> {
+    /**
+     * Declarative quick-search text columns. When declared, an index search on
+     * the pseudo-column `quickSearch` expands to an OR of LIKE conditions over
+     * these root-table columns instead of hitting the controller default.
+     * @type {string[] | null} */
+    static quickSearchColumns: string[] | null;
+    /**
+     * Declarative writable-attribute schema consumed by
+     * {@link SyncResourceBase#normalizeWritableAttributes}, keyed by camelCase
+     * attribute name.
+     * @type {Record<string, import("./sync-attribute-normalizer.js").SyncAttributeSchemaEntry> | null} */
+    static writableAttributes: Record<string, import("./sync-attribute-normalizer.js").SyncAttributeSchemaEntry> | null;
+    /**
+     * Expands a `quickSearch` pseudo-column search into an OR of LIKE conditions
+     * over the declared {@link SyncResourceBase.quickSearchColumns}.
+     * @param {object} args - Search args.
+     * @param {import("../frontend-model-resource/base-resource.js").FrontendModelResourceAnyQuery} args.query - Query to filter.
+     * @param {import("../frontend-model-resource/base-resource.js").FrontendModelResourceSearch} args.search - Search payload.
+     * @returns {boolean} Whether the search was handled as a quick search.
+     */
+    applyQuickSearch({ query, search }: {
+        query: import("../frontend-model-resource/base-resource.js").FrontendModelResourceAnyQuery;
+        search: import("../frontend-model-resource/base-resource.js").FrontendModelResourceSearch;
+    }): boolean;
+    /**
+     * Normalizes incoming writable attributes through the declared
+     * {@link SyncResourceBase.writableAttributes} schema: camelCase and
+     * snake_case input keys are accepted, values are validated per type and the
+     * normalized values are written under snake_case column keys. Validation
+     * failures throw client-safe errors built by
+     * {@link SyncResourceBase#writableAttributeError}.
+     * @param {Record<string, ?>} attributes - Raw incoming attributes.
+     * @param {{unknownAttributes?: "error" | "ignore"}} [options] - Unknown input-key handling. Defaults to "error".
+     * @returns {Record<string, ?>} Normalized attributes keyed by column names.
+     */
+    normalizeWritableAttributes(attributes: Record<string, unknown>, options?: {
+        unknownAttributes?: "error" | "ignore";
+    }): Record<string, unknown>;
+    /**
+     * Builds the client-safe error thrown for a failed writable-attribute validation.
+     * @param {string} message - Human-readable validation message.
+     * @param {{cause?: Error, code: string}} details - Stable machine-readable code and optional cause.
+     * @returns {Error} Client-safe error.
+     */
+    writableAttributeError(message: string, { cause, code }: {
+        cause?: Error;
+        code: string;
+    }): Error;
     /**
      * Returns a stable change-feed page after app authorization.
      * @returns {Promise<Record<string, ?>>} Change-feed page result.

package/build/src/sync/sync-resource-base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync-resource-base.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-resource-base.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AAEH;;;;;;;;GAQG;AACH,sCAHqE,WAAW,SAAnE,cAAe,6BAA6B,EAAE,OAAQ;IAIjE;;;OAGG;IACH,WAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAStC;IAED;;;OAGG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAQtC;IAED;;;;OAIG;IACH,qBAHW,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GACf,sBAAsB,GAAG,IAAI,CAoBzC;IAED;;;;OAIG;IACH,qCAHW;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAC,GAC/D;QAAC,OAAO,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAAA;KAAC,CAQvD;IAED;;;OAGG;IACH,sBAFa,OAAO,mCAAmC,EAAE,OAAO,CAM/D;IAED;;;OAGG;IACH,qBAFa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAI7B;IAED;;;OAGG;IACH,kBAFa,cAAc,6BAA6B,EAAE,OAAO,CAQhE;IAED;;;;OAIG;IACH,wBAHW;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAC,GAC/D,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;OAIG;IACH,yBAHW;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,KAAK,EAAE,OAAO,wCAAwC,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAC,GAChI,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,cAAc,mCAAmC,EAAE,OAAO,CAItE;CACF;;;;;;;;gBApIa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;;;;kBACjB,MAAM;;sCAPkB,6CAA6C"}
+{"version":3,"file":"sync-resource-base.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-resource-base.js"],"names":[],"mappings":"AAWA;;;;;GAKG;AAEH;;;;;;;;GAQG;AACH,sCAHqE,WAAW,SAAnE,cAAe,6BAA6B,EAAE,OAAQ;IAIjE;;;;iCAI6B;IAC7B,2BADU,MAAM,EAAE,GAAG,IAAI,CACO;IAEhC;;;;0GAIsG;IACtG,2BADU,MAAM,CAAC,MAAM,EAAE,OAAO,gCAAgC,EAAE,wBAAwB,CAAC,GAAG,IAAI,CAClE;IAgBhC;;;;;;;OAOG;IACH,oCAJG;QAAkG,KAAK,EAA/F,OAAO,6CAA6C,EAAE,6BAA6B;QACK,MAAM,EAA9F,OAAO,6CAA6C,EAAE,2BAA2B;KACzF,GAAU,OAAO,CA6BnB;IAED;;;;;;;;;;OAUG;IACH,wCAJW,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,YACjB;QAAC,iBAAiB,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAA;KAAC,GACtC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAa7B;IAED;;;;;OAKG;IACH,gCAJW,MAAM,mBACN;QAAC,KAAK,CAAC,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,GAC3B,KAAK,CAIjB;IAED;;;OAGG;IACH,WAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAStC;IAED;;;OAGG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAQtC;IAED;;;;OAIG;IACH,qBAHW,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GACf,sBAAsB,GAAG,IAAI,CAoBzC;IAED;;;;OAIG;IACH,qCAHW;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAC,GAC/D;QAAC,OAAO,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAAA;KAAC,CAQvD;IAED;;;OAGG;IACH,sBAFa,OAAO,mCAAmC,EAAE,OAAO,CAM/D;IAED;;;OAGG;IACH,qBAFa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAI7B;IAED;;;OAGG;IACH,kBAFa,cAAc,6BAA6B,EAAE,OAAO,CAQhE;IAED;;;;OAIG;IACH,wBAHW;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAC,GAC/D,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;OAIG;IACH,yBAHW;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,KAAK,EAAE,OAAO,wCAAwC,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAC,GAChI,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,cAAc,mCAAmC,EAAE,OAAO,CAItE;CACF;;;;;;;;gBAvOa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;;;;kBACjB,MAAM;;sCAXkB,6CAA6C"}