velocious 1.0.487 → 1.0.489

package/build/src/sync/sync-model-change-feed-service.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Generic cursor-paginated change feed over an app-owned sync/change model.
+ *
+ * Apps provide the model and optional scoping/serialization hooks. Velocious owns
+ * cursor parsing, snapshot high-water resolution, stable ordering, page limits,
+ * and response shape for `/velocious/sync/changes` style endpoints.
+ */
+export default class SyncModelChangeFeedService {
+    /**
+     * Creates a generic sync-model change-feed service.
+     * @param {object} args - Service arguments.
+     * @param {typeof import("../database/record/index.js").default} args.modelClass - Sync/change model class.
+     * @param {Record<string, unknown>} args.params - Request params.
+     * @param {number} [args.defaultLimit] - Default page size.
+     * @param {number} [args.maxLimit] - Maximum page size.
+     * @param {(record: ?) => Record<string, unknown>} [args.serializeRecord] - Record serializer.
+     * @param {function({query: import("../database/query/model-class-query.js").default}): void} [args.scopeQuery] - Applies app-owned visibility scope.
+     */
+    constructor({ defaultLimit, maxLimit, modelClass, params, scopeQuery, serializeRecord }: {
+        modelClass: typeof import("../database/record/index.js").default;
+        params: Record<string, unknown>;
+        defaultLimit?: number | undefined;
+        maxLimit?: number | undefined;
+        serializeRecord?: ((record: unknown) => Record<string, unknown>) | undefined;
+        scopeQuery?: ((arg0: {
+            query: import("../database/query/model-class-query.js").default;
+        }) => void) | undefined;
+    });
+    defaultLimit: number;
+    maxLimit: number;
+    modelClass: typeof import("../database/record/index.js").default;
+    params: Record<string, unknown>;
+    scopeQuery: ((arg0: {
+        query: import("../database/query/model-class-query.js").default;
+    }) => void) | null;
+    serializeRecord: (record: unknown) => Record<string, unknown>;
+    /**
+     * Builds a stable change-feed page.
+     * @returns {Promise<{status: string, nextCursor: {id: string, serverSequence: number, updatedAt: string} | null, syncs: Array<Record<string, unknown>>, upToCursor: {id: string, serverSequence: number, updatedAt: string} | null}>} Change-feed page result.
+     */
+    changes(): Promise<{
+        status: string;
+        nextCursor: {
+            id: string;
+            serverSequence: number;
+            updatedAt: string;
+        } | null;
+        syncs: Array<Record<string, unknown>>;
+        upToCursor: {
+            id: string;
+            serverSequence: number;
+            updatedAt: string;
+        } | null;
+    }>;
+    /**
+     * Normalizes the requested page limit.
+     * @param {unknown} value - Raw limit param.
+     * @returns {number} Normalized page limit.
+     */
+    normalizedLimit(value: unknown): number;
+    /**
+     * Parses an optional positive integer cursor field.
+     * @param {unknown} value - Raw integer param.
+     * @param {string} name - Param name for error messages.
+     * @returns {number | null} Positive integer value, or null when omitted.
+     */
+    optionalPositiveIntegerParam(value: unknown, name: string): number | null;
+    /**
+     * Resolves the high-water cursor that bounds the current feed page.
+     * @returns {Promise<{id: string, serverSequence: number, updatedAt: string} | null>} Snapshot upper-bound cursor.
+     */
+    resolveUpToCursor(): Promise<{
+        id: string;
+        serverSequence: number;
+        updatedAt: string;
+    } | null>;
+    /**
+     * Builds the ordered and cursor-filtered page query.
+     * @param {{limit: number, upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Page query args.
+     * @returns {import("../database/query/model-class-query.js").default} Page query.
+     */
+    pageQuery({ limit, upToCursor }: {
+        limit: number;
+        upToCursor: {
+            id: string;
+            serverSequence: number;
+            updatedAt: string;
+        };
+    }): import("../database/query/model-class-query.js").default;
+    /**
+     * Builds a base query with app-owned scope applied.
+     * @returns {import("../database/query/model-class-query.js").default} Scoped base query.
+     */
+    scopedQuery(): import("../database/query/model-class-query.js").default;
+    /**
+     * Serializes a record into a transport cursor.
+     * @param {?} record - Sync/change record.
+     * @returns {{id: string, serverSequence: number, updatedAt: string}} Cursor for row.
+     */
+    cursorForRecord(record: unknown): {
+        id: string;
+        serverSequence: number;
+        updatedAt: string;
+    };
+    /**
+     * Serializes a record using the standard sync envelope shape.
+     * @param {?} record - Sync/change record.
+     * @returns {Record<string, unknown>} Default serialized row.
+     */
+    defaultSerializeRecord(record: unknown): Record<string, unknown>;
+    /**
+     * Reads and parses the record data payload.
+     * @param {?} record - Sync/change record.
+     * @returns {unknown} Parsed data value.
+     */
+    recordData(record: unknown): unknown;
+    /**
+     * Reads a value from either a record accessor method or plain property.
+     * @param {?} record - Sync/change record.
+     * @param {string} name - Camel-cased value/method name.
+     * @returns {unknown} Record value.
+     */
+    recordValue(record: unknown, name: string): unknown;
+    /**
+     * Converts a date-like value to an ISO string.
+     * @param {Date | string | null | undefined | unknown} value - Date value.
+     * @returns {string} ISO date.
+     */
+    isoDate(value: Date | string | null | undefined | unknown): string;
+}
+//# sourceMappingURL=sync-model-change-feed-service.d.ts.map

package/build/src/sync/sync-model-change-feed-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-model-change-feed-service.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-model-change-feed-service.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH;IACE;;;;;;;;;OASG;IACH,yFAPG;QAAmE,UAAU,EAArE,cAAc,6BAA6B,EAAE,OAAO;QACtB,MAAM,EAApC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QACT,YAAY;QACZ,QAAQ;QACwB,eAAe,aAApD,OAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QACmD,UAAU,WAA1F;YAAC,KAAK,EAAE,OAAO,wCAAwC,EAAE,OAAO,CAAA;SAAC,KAAG,IAAI;KAC3F,EAQA;IANC,qBAAgC;IAChC,iBAAwB;IACxB,iEAA4B;IAC5B,gCAAoB;IACpB,oBAPkB;QAAC,KAAK,EAAE,OAAO,wCAAwC,EAAE,OAAO,CAAA;KAAC,KAAG,IAAI,SAOtD;IACpC,0BATkB,OAAC,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAS4C;IAG7F;;;OAGG;IACH,WAFa,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAC,EAAE,EAAE,MAAM,CAAC;YAAC,cAAc,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAC,GAAG,IAAI,CAAC;QAAC,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;QAAC,UAAU,EAAE;YAAC,EAAE,EAAE,MAAM,CAAC;YAAC,cAAc,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAC,GAAG,IAAI,CAAA;KAAC,CAAC,CAkBpO;IAED;;;;OAIG;IACH,uBAHW,OAAO,GACL,MAAM,CAYlB;IAED;;;;;OAKG;IACH,oCAJW,OAAO,QACP,MAAM,GACJ,MAAM,GAAG,IAAI,CAYzB;IAED;;;OAGG;IACH,qBAFa,OAAO,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,GAAG,IAAI,CAAC,CA0BnF;IAED;;;;OAIG;IACH,iCAHW;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAC,EAAE,EAAE,MAAM,CAAC;YAAC,cAAc,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,GAClF,OAAO,wCAAwC,EAAE,OAAO,CA8BpE;IAED;;;OAGG;IACH,eAFa,OAAO,wCAAwC,EAAE,OAAO,CAQpE;IAED;;;;OAIG;IACH,wBAHW,OAAC,GACC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAC,CAInE;IAED;;;;OAIG;IACH,+BAHW,OAAC,GACC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAanC;IAED;;;;OAIG;IACH,mBAHW,OAAC,GACC,OAAO,CASnB;IAED;;;;;OAKG;IACH,oBAJW,OAAC,QACD,MAAM,GACJ,OAAO,CAgBnB;IAED;;;;OAIG;IACH,eAHW,IAAI,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,GACxC,MAAM,CAUlB;CACF"}

package/build/src/sync/sync-model-change-feed-service.js

@@ -0,0 +1,212 @@
+// @ts-check
+import VelociousError from "../velocious-error.js";
+/**
+ * Generic cursor-paginated change feed over an app-owned sync/change model.
+ *
+ * Apps provide the model and optional scoping/serialization hooks. Velocious owns
+ * cursor parsing, snapshot high-water resolution, stable ordering, page limits,
+ * and response shape for `/velocious/sync/changes` style endpoints.
+ */
+export default class SyncModelChangeFeedService {
+    /**
+     * Creates a generic sync-model change-feed service.
+     * @param {object} args - Service arguments.
+     * @param {typeof import("../database/record/index.js").default} args.modelClass - Sync/change model class.
+     * @param {Record<string, unknown>} args.params - Request params.
+     * @param {number} [args.defaultLimit] - Default page size.
+     * @param {number} [args.maxLimit] - Maximum page size.
+     * @param {(record: ?) => Record<string, unknown>} [args.serializeRecord] - Record serializer.
+     * @param {function({query: import("../database/query/model-class-query.js").default}): void} [args.scopeQuery] - Applies app-owned visibility scope.
+     */
+    constructor({ defaultLimit = 1000, maxLimit = 1000, modelClass, params, scopeQuery, serializeRecord }) {
+        this.defaultLimit = defaultLimit;
+        this.maxLimit = maxLimit;
+        this.modelClass = modelClass;
+        this.params = params;
+        this.scopeQuery = scopeQuery || null;
+        this.serializeRecord = serializeRecord || ((record) => this.defaultSerializeRecord(record));
+    }
+    /**
+     * Builds a stable change-feed page.
+     * @returns {Promise<{status: string, nextCursor: {id: string, serverSequence: number, updatedAt: string} | null, syncs: Array<Record<string, unknown>>, upToCursor: {id: string, serverSequence: number, updatedAt: string} | null}>} Change-feed page result.
+     */
+    async changes() {
+        const limit = this.normalizedLimit(this.params.limit);
+        const upToCursor = await this.resolveUpToCursor();
+        if (!upToCursor)
+            return { status: "success", nextCursor: null, syncs: [], upToCursor: null };
+        const query = this.pageQuery({ limit, upToCursor });
+        const records = await query.toArray();
+        const nextCursor = records.length > 0 ? this.cursorForRecord(records[records.length - 1]) : upToCursor;
+        return {
+            status: "success",
+            nextCursor,
+            syncs: records.map((record) => this.serializeRecord(record)),
+            upToCursor
+        };
+    }
+    /**
+     * Normalizes the requested page limit.
+     * @param {unknown} value - Raw limit param.
+     * @returns {number} Normalized page limit.
+     */
+    normalizedLimit(value) {
+        if (value === undefined || value === null || value === "")
+            return this.defaultLimit;
+        const limit = Number(value);
+        if (!Number.isSafeInteger(limit) || limit <= 0) {
+            throw VelociousError.safe("Sync changes limit must be a positive integer.", { code: "sync-invalid-changes-limit" });
+        }
+        return Math.min(limit, this.maxLimit);
+    }
+    /**
+     * Parses an optional positive integer cursor field.
+     * @param {unknown} value - Raw integer param.
+     * @param {string} name - Param name for error messages.
+     * @returns {number | null} Positive integer value, or null when omitted.
+     */
+    optionalPositiveIntegerParam(value, name) {
+        if (value === undefined || value === null || value === "")
+            return null;
+        const integer = Number(value);
+        if (!Number.isSafeInteger(integer) || integer <= 0) {
+            throw VelociousError.safe(`${name} must be a positive integer.`, { code: "sync-invalid-changes-cursor" });
+        }
+        return integer;
+    }
+    /**
+     * Resolves the high-water cursor that bounds the current feed page.
+     * @returns {Promise<{id: string, serverSequence: number, updatedAt: string} | null>} Snapshot upper-bound cursor.
+     */
+    async resolveUpToCursor() {
+        const upToServerSequence = this.optionalPositiveIntegerParam(this.params.upToServerSequence, "upToServerSequence");
+        if (upToServerSequence !== null && typeof this.params.upToUpdatedAt === "string" && typeof this.params.upToId === "string") {
+            return { id: this.params.upToId, serverSequence: upToServerSequence, updatedAt: this.params.upToUpdatedAt };
+        }
+        if (typeof this.params.upToUpdatedAt === "string" && typeof this.params.upToId === "string") {
+            const upToRecord = await this.modelClass.findBy({ id: this.params.upToId });
+            if (upToRecord)
+                return this.cursorForRecord(upToRecord);
+        }
+        const query = this.scopedQuery();
+        const table = query.driver.quoteTable(this.modelClass.tableName());
+        const serverSequenceColumn = query.driver.quoteColumn("server_sequence");
+        const latestRecords = await query
+            .order(`${table}.${serverSequenceColumn} DESC`)
+            .limit(1)
+            .toArray();
+        if (latestRecords.length === 0)
+            return null;
+        return this.cursorForRecord(latestRecords[0]);
+    }
+    /**
+     * Builds the ordered and cursor-filtered page query.
+     * @param {{limit: number, upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Page query args.
+     * @returns {import("../database/query/model-class-query.js").default} Page query.
+     */
+    pageQuery({ limit, upToCursor }) {
+        const query = this.scopedQuery();
+        const driver = query.driver;
+        const table = driver.quoteTable(this.modelClass.tableName());
+        const serverSequenceColumn = `${table}.${driver.quoteColumn("server_sequence")}`;
+        const updatedAtColumn = `${table}.${driver.quoteColumn("updated_at")}`;
+        const idColumn = `${table}.${driver.quoteColumn("id")}`;
+        query
+            .where(`${serverSequenceColumn} <= ${driver.quote(upToCursor.serverSequence)}`)
+            .order(`${serverSequenceColumn} ASC`)
+            .limit(limit);
+        const afterServerSequence = this.optionalPositiveIntegerParam(this.params.afterServerSequence, "afterServerSequence");
+        if (afterServerSequence !== null) {
+            query.where(`${serverSequenceColumn} > ${driver.quote(afterServerSequence)}`);
+        }
+        else if (typeof this.params.afterUpdatedAt === "string" && this.params.afterUpdatedAt !== "") {
+            const isPagingExistingSnapshot = typeof this.params.upToUpdatedAt === "string" && this.params.upToUpdatedAt !== "" && typeof this.params.upToId === "string" && this.params.upToId !== "";
+            if (isPagingExistingSnapshot && typeof this.params.afterId === "string" && this.params.afterId !== "") {
+                query.where(`(${updatedAtColumn} > ${driver.quote(this.params.afterUpdatedAt)} OR (${updatedAtColumn} = ${driver.quote(this.params.afterUpdatedAt)} AND ${idColumn} > ${driver.quote(this.params.afterId)}))`);
+            }
+            else {
+                query.where(`${updatedAtColumn} >= ${driver.quote(this.params.afterUpdatedAt)}`);
+            }
+        }
+        return query;
+    }
+    /**
+     * Builds a base query with app-owned scope applied.
+     * @returns {import("../database/query/model-class-query.js").default} Scoped base query.
+     */
+    scopedQuery() {
+        const query = this.modelClass.where({});
+        if (this.scopeQuery)
+            this.scopeQuery({ query });
+        return query;
+    }
+    /**
+     * Serializes a record into a transport cursor.
+     * @param {?} record - Sync/change record.
+     * @returns {{id: string, serverSequence: number, updatedAt: string}} Cursor for row.
+     */
+    cursorForRecord(record) {
+        return { id: String(this.recordValue(record, "id")), serverSequence: Number(this.recordValue(record, "serverSequence")), updatedAt: this.isoDate(this.recordValue(record, "updatedAt")) };
+    }
+    /**
+     * Serializes a record using the standard sync envelope shape.
+     * @param {?} record - Sync/change record.
+     * @returns {Record<string, unknown>} Default serialized row.
+     */
+    defaultSerializeRecord(record) {
+        return {
+            data: this.recordData(record),
+            eventId: this.recordValue(record, "eventId"),
+            id: this.recordValue(record, "id"),
+            resourceId: this.recordValue(record, "resourceId"),
+            resourceType: this.recordValue(record, "resourceType"),
+            serverSequence: this.recordValue(record, "serverSequence"),
+            syncType: this.recordValue(record, "syncType"),
+            updatedAt: this.isoDate(this.recordValue(record, "updatedAt"))
+        };
+    }
+    /**
+     * Reads and parses the record data payload.
+     * @param {?} record - Sync/change record.
+     * @returns {unknown} Parsed data value.
+     */
+    recordData(record) {
+        const data = this.recordValue(record, "data");
+        if (data === "" || data === null || data === undefined)
+            return null;
+        if (typeof data !== "string")
+            return data;
+        return JSON.parse(data);
+    }
+    /**
+     * Reads a value from either a record accessor method or plain property.
+     * @param {?} record - Sync/change record.
+     * @param {string} name - Camel-cased value/method name.
+     * @returns {unknown} Record value.
+     */
+    recordValue(record, name) {
+        if (!record || typeof record !== "object") {
+            throw new Error("Sync changes row must be an object.");
+        }
+        const recordObject = /** @type {Record<string, ?>} */ (record);
+        const method = recordObject[name];
+        const value = typeof method === "function" ? method.call(record) : method;
+        if (value === undefined) {
+            throw new Error(`Sync changes row is missing ${name}.`);
+        }
+        return value;
+    }
+    /**
+     * Converts a date-like value to an ISO string.
+     * @param {Date | string | null | undefined | unknown} value - Date value.
+     * @returns {string} ISO date.
+     */
+    isoDate(value) {
+        const date = value instanceof Date ? value : new Date(typeof value === "string" || typeof value === "number" ? value : 0);
+        if (Number.isNaN(date.getTime())) {
+            throw VelociousError.safe("Sync changes row has an invalid updated_at value.", { code: "sync-invalid-changes-row" });
+        }
+        return date.toISOString();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-model-change-feed-service.js","sourceRoot":"","sources":["../../../src/sync/sync-model-change-feed-service.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport VelociousError from \"../velocious-error.js\"\n\n/**\n * Generic cursor-paginated change feed over an app-owned sync/change model.\n *\n * Apps provide the model and optional scoping/serialization hooks. Velocious owns\n * cursor parsing, snapshot high-water resolution, stable ordering, page limits,\n * and response shape for `/velocious/sync/changes` style endpoints.\n */\nexport default class SyncModelChangeFeedService {\n  /**\n   * Creates a generic sync-model change-feed service.\n   * @param {object} args - Service arguments.\n   * @param {typeof import(\"../database/record/index.js\").default} args.modelClass - Sync/change model class.\n   * @param {Record<string, unknown>} args.params - Request params.\n   * @param {number} [args.defaultLimit] - Default page size.\n   * @param {number} [args.maxLimit] - Maximum page size.\n   * @param {(record: ?) => Record<string, unknown>} [args.serializeRecord] - Record serializer.\n   * @param {function({query: import(\"../database/query/model-class-query.js\").default}): void} [args.scopeQuery] - Applies app-owned visibility scope.\n   */\n  constructor({defaultLimit = 1000, maxLimit = 1000, modelClass, params, scopeQuery, serializeRecord}) {\n    this.defaultLimit = defaultLimit\n    this.maxLimit = maxLimit\n    this.modelClass = modelClass\n    this.params = params\n    this.scopeQuery = scopeQuery || null\n    this.serializeRecord = serializeRecord || ((record) => this.defaultSerializeRecord(record))\n  }\n\n  /**\n   * Builds a stable change-feed page.\n   * @returns {Promise<{status: string, nextCursor: {id: string, serverSequence: number, updatedAt: string} | null, syncs: Array<Record<string, unknown>>, upToCursor: {id: string, serverSequence: number, updatedAt: string} | null}>} Change-feed page result.\n   */\n  async changes() {\n    const limit = this.normalizedLimit(this.params.limit)\n    const upToCursor = await this.resolveUpToCursor()\n\n    if (!upToCursor) return {status: \"success\", nextCursor: null, syncs: [], upToCursor: null}\n\n    const query = this.pageQuery({limit, upToCursor})\n    const records = await query.toArray()\n    const nextCursor = records.length > 0 ? this.cursorForRecord(records[records.length - 1]) : upToCursor\n\n    return {\n      status: \"success\",\n      nextCursor,\n      syncs: records.map((record) => this.serializeRecord(record)),\n      upToCursor\n    }\n  }\n\n  /**\n   * Normalizes the requested page limit.\n   * @param {unknown} value - Raw limit param.\n   * @returns {number} Normalized page limit.\n   */\n  normalizedLimit(value) {\n    if (value === undefined || value === null || value === \"\") return this.defaultLimit\n\n    const limit = Number(value)\n\n    if (!Number.isSafeInteger(limit) || limit <= 0) {\n      throw VelociousError.safe(\"Sync changes limit must be a positive integer.\", {code: \"sync-invalid-changes-limit\"})\n    }\n\n    return Math.min(limit, this.maxLimit)\n  }\n\n  /**\n   * Parses an optional positive integer cursor field.\n   * @param {unknown} value - Raw integer param.\n   * @param {string} name - Param name for error messages.\n   * @returns {number | null} Positive integer value, or null when omitted.\n   */\n  optionalPositiveIntegerParam(value, name) {\n    if (value === undefined || value === null || value === \"\") return null\n\n    const integer = Number(value)\n\n    if (!Number.isSafeInteger(integer) || integer <= 0) {\n      throw VelociousError.safe(`${name} must be a positive integer.`, {code: \"sync-invalid-changes-cursor\"})\n    }\n\n    return integer\n  }\n\n  /**\n   * Resolves the high-water cursor that bounds the current feed page.\n   * @returns {Promise<{id: string, serverSequence: number, updatedAt: string} | null>} Snapshot upper-bound cursor.\n   */\n  async resolveUpToCursor() {\n    const upToServerSequence = this.optionalPositiveIntegerParam(this.params.upToServerSequence, \"upToServerSequence\")\n\n    if (upToServerSequence !== null && typeof this.params.upToUpdatedAt === \"string\" && typeof this.params.upToId === \"string\") {\n      return {id: this.params.upToId, serverSequence: upToServerSequence, updatedAt: this.params.upToUpdatedAt}\n    }\n\n    if (typeof this.params.upToUpdatedAt === \"string\" && typeof this.params.upToId === \"string\") {\n      const upToRecord = await this.modelClass.findBy({id: this.params.upToId})\n\n      if (upToRecord) return this.cursorForRecord(upToRecord)\n    }\n\n    const query = this.scopedQuery()\n    const table = query.driver.quoteTable(this.modelClass.tableName())\n    const serverSequenceColumn = query.driver.quoteColumn(\"server_sequence\")\n    const latestRecords = await query\n      .order(`${table}.${serverSequenceColumn} DESC`)\n      .limit(1)\n      .toArray()\n\n    if (latestRecords.length === 0) return null\n\n    return this.cursorForRecord(latestRecords[0])\n  }\n\n  /**\n   * Builds the ordered and cursor-filtered page query.\n   * @param {{limit: number, upToCursor: {id: string, serverSequence: number, updatedAt: string}}} args - Page query args.\n   * @returns {import(\"../database/query/model-class-query.js\").default} Page query.\n   */\n  pageQuery({limit, upToCursor}) {\n    const query = this.scopedQuery()\n    const driver = query.driver\n    const table = driver.quoteTable(this.modelClass.tableName())\n    const serverSequenceColumn = `${table}.${driver.quoteColumn(\"server_sequence\")}`\n    const updatedAtColumn = `${table}.${driver.quoteColumn(\"updated_at\")}`\n    const idColumn = `${table}.${driver.quoteColumn(\"id\")}`\n\n    query\n      .where(`${serverSequenceColumn} <= ${driver.quote(upToCursor.serverSequence)}`)\n      .order(`${serverSequenceColumn} ASC`)\n      .limit(limit)\n\n    const afterServerSequence = this.optionalPositiveIntegerParam(this.params.afterServerSequence, \"afterServerSequence\")\n\n    if (afterServerSequence !== null) {\n      query.where(`${serverSequenceColumn} > ${driver.quote(afterServerSequence)}`)\n    } else if (typeof this.params.afterUpdatedAt === \"string\" && this.params.afterUpdatedAt !== \"\") {\n      const isPagingExistingSnapshot = typeof this.params.upToUpdatedAt === \"string\" && this.params.upToUpdatedAt !== \"\" && typeof this.params.upToId === \"string\" && this.params.upToId !== \"\"\n\n      if (isPagingExistingSnapshot && typeof this.params.afterId === \"string\" && this.params.afterId !== \"\") {\n        query.where(`(${updatedAtColumn} > ${driver.quote(this.params.afterUpdatedAt)} OR (${updatedAtColumn} = ${driver.quote(this.params.afterUpdatedAt)} AND ${idColumn} > ${driver.quote(this.params.afterId)}))`)\n      } else {\n        query.where(`${updatedAtColumn} >= ${driver.quote(this.params.afterUpdatedAt)}`)\n      }\n    }\n\n    return query\n  }\n\n  /**\n   * Builds a base query with app-owned scope applied.\n   * @returns {import(\"../database/query/model-class-query.js\").default} Scoped base query.\n   */\n  scopedQuery() {\n    const query = this.modelClass.where({})\n\n    if (this.scopeQuery) this.scopeQuery({query})\n\n    return query\n  }\n\n  /**\n   * Serializes a record into a transport cursor.\n   * @param {?} record - Sync/change record.\n   * @returns {{id: string, serverSequence: number, updatedAt: string}} Cursor for row.\n   */\n  cursorForRecord(record) {\n    return {id: String(this.recordValue(record, \"id\")), serverSequence: Number(this.recordValue(record, \"serverSequence\")), updatedAt: this.isoDate(this.recordValue(record, \"updatedAt\"))}\n  }\n\n  /**\n   * Serializes a record using the standard sync envelope shape.\n   * @param {?} record - Sync/change record.\n   * @returns {Record<string, unknown>} Default serialized row.\n   */\n  defaultSerializeRecord(record) {\n    return {\n      data: this.recordData(record),\n      eventId: this.recordValue(record, \"eventId\"),\n      id: this.recordValue(record, \"id\"),\n      resourceId: this.recordValue(record, \"resourceId\"),\n      resourceType: this.recordValue(record, \"resourceType\"),\n      serverSequence: this.recordValue(record, \"serverSequence\"),\n      syncType: this.recordValue(record, \"syncType\"),\n      updatedAt: this.isoDate(this.recordValue(record, \"updatedAt\"))\n    }\n  }\n\n  /**\n   * Reads and parses the record data payload.\n   * @param {?} record - Sync/change record.\n   * @returns {unknown} Parsed data value.\n   */\n  recordData(record) {\n    const data = this.recordValue(record, \"data\")\n\n    if (data === \"\" || data === null || data === undefined) return null\n    if (typeof data !== \"string\") return data\n\n    return JSON.parse(data)\n  }\n\n  /**\n   * Reads a value from either a record accessor method or plain property.\n   * @param {?} record - Sync/change record.\n   * @param {string} name - Camel-cased value/method name.\n   * @returns {unknown} Record value.\n   */\n  recordValue(record, name) {\n    if (!record || typeof record !== \"object\") {\n      throw new Error(\"Sync changes row must be an object.\")\n    }\n\n    const recordObject = /** @type {Record<string, ?>} */ (record)\n    const method = recordObject[name]\n    const value = typeof method === \"function\" ? method.call(record) : method\n\n    if (value === undefined) {\n      throw new Error(`Sync changes row is missing ${name}.`)\n    }\n\n    return value\n  }\n\n  /**\n   * Converts a date-like value to an ISO string.\n   * @param {Date | string | null | undefined | unknown} value - Date value.\n   * @returns {string} ISO date.\n   */\n  isoDate(value) {\n    const date = value instanceof Date ? value : new Date(typeof value === \"string\" || typeof value === \"number\" ? value : 0)\n\n    if (Number.isNaN(date.getTime())) {\n      throw VelociousError.safe(\"Sync changes row has an invalid updated_at value.\", {code: \"sync-invalid-changes-row\"})\n    }\n\n    return date.toISOString()\n  }\n}\n\n"]}

package/build/sync/sync-api-client-types.js

@@ -0,0 +1,77 @@
+// @ts-check
+
+/**
+ * @module sync-api-client-types
+ */
+
+/** @typedef {{id: string | null, serverSequence: number | null, updatedAt: string} | null} SyncCursor */
+
+/**
+ * @typedef {object} SyncChangeEnvelope
+ * @property {() => unknown} data - Sync data payload.
+ * @property {() => unknown} id - Sync row identifier.
+ * @property {() => unknown} resourceId - Resource identifier.
+ * @property {() => string | null} resourceType - Resource type name.
+ * @property {() => string} syncType - Sync operation type.
+ */
+
+/**
+ * @typedef {object} SyncChangeApplyResult
+ * @property {boolean} changed - Whether the local store changed.
+ * @property {string | null} [resourceType] - Applied resource type override.
+ */
+
+/**
+ * @typedef {object} SyncResourceConfig
+ * @property {(args: {attributes: Record<string, unknown>, data: Record<string, unknown>, record: ?, sync: SyncChangeEnvelope}) => Promise<boolean | void> | boolean | void} [afterApply] - Optional post-save hook.
+ * @property {(args: {data: Record<string, unknown>, record: ?, sync: SyncChangeEnvelope}) => Promise<Record<string, unknown>> | Record<string, unknown>} attributes - Allowed attributes builder.
+ * @property {boolean} enabled - Whether this resource is sync-enabled.
+ * @property {(args: {data: Record<string, unknown>, resourceId: unknown, sync: SyncChangeEnvelope}) => Promise<?> | ?} [findRecord] - Optional upsert finder.
+ * @property {(args: {resourceId: unknown, sync: SyncChangeEnvelope}) => Promise<?> | ?} [findRecordForDelete] - Optional destroy finder.
+ * @property {?} modelClass - Velocious model class.
+ */
+
+/**
+ * @typedef {object} SyncChangesRequest
+ * @property {string} authenticationToken - Auth token.
+ * @property {string | null} [afterId] - Last seen row id.
+ * @property {number} [afterServerSequence] - Last seen server sequence.
+ * @property {string} [afterUpdatedAt] - Last seen timestamp.
+ * @property {number} limit - Page size.
+ * @property {string | null} [upToId] - Snapshot upper-bound row id.
+ * @property {number} [upToServerSequence] - Snapshot upper-bound server sequence.
+ * @property {string} [upToUpdatedAt] - Snapshot upper-bound timestamp.
+ */
+
+/**
+ * @typedef {object} SyncChangesResponse
+ * @property {string} [errorMessage] - Error message.
+ * @property {SyncCursor | Record<string, ?>} [nextCursor] - Next cursor.
+ * @property {string} [status] - Response status.
+ * @property {Array<unknown>} [syncs] - Sync rows.
+ * @property {SyncCursor | Record<string, ?>} [upToCursor] - Snapshot upper-bound cursor.
+ */
+
+/**
+ * @typedef {object} SyncChangesResult
+ * @property {boolean} changed - Whether any local record changed.
+ * @property {number} pages - Applied page count.
+ * @property {Record<string, boolean>} resourceChanged - Changed flags by resource type.
+ * @property {Record<string, number>} resourceCounts - Applied counts by resource type.
+ * @property {number} syncedCount - Applied row count.
+ */
+
+/**
+ * @typedef {object} SyncReplayItem
+ * @property {string | number} id - Sync id.
+ * @property {string} syncState - Replay state.
+ */
+
+/**
+ * @typedef {object} SyncReplayResponse
+ * @property {string} [errorMessage] - Error message.
+ * @property {string} [status] - Response status.
+ * @property {Array<SyncReplayItem>} [syncs] - Replay results.
+ */
+
+export {}