velocious 1.0.487 → 1.0.488

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

@@ -0,0 +1,307 @@
+// @ts-check
+import { optionalInteger } from "typanic";
+/** @typedef {import("./sync-api-client-types.js").SyncChangeApplyResult} SyncChangeApplyResult */
+/** @typedef {import("./sync-api-client-types.js").SyncChangeEnvelope} SyncChangeEnvelope */
+/** @typedef {import("./sync-api-client-types.js").SyncChangesRequest} SyncChangesRequest */
+/** @typedef {import("./sync-api-client-types.js").SyncChangesResponse} SyncChangesResponse */
+/** @typedef {import("./sync-api-client-types.js").SyncChangesResult} SyncChangesResult */
+/** @typedef {import("./sync-api-client-types.js").SyncCursor} SyncCursor */
+/** @typedef {import("./sync-api-client-types.js").SyncReplayItem} SyncReplayItem */
+/** @typedef {import("./sync-api-client-types.js").SyncReplayResponse} SyncReplayResponse */
+/** @typedef {import("./sync-api-client-types.js").SyncResourceConfig} SyncResourceConfig */
+/**
+ * Generic client-side helper for replaying pending sync envelopes through the
+ * framework-owned `/velocious/sync/replay` endpoint. Apps provide only local
+ * persistence/auth hooks.
+ */
+export default class SyncApiClient {
+    /**
+     * Pulls backend sync changes in stable pages, applies them locally, and stores
+     * the acknowledged cursor. Apps provide only auth, persistence, transport, and
+     * resource policy hooks.
+     * @param {object} args - Pull args.
+     * @param {string} args.authenticationToken - Auth token to send with change requests.
+     * @param {number} [args.batchSize] - Max syncs per request. Defaults to 100.
+     * @param {() => Promise<SyncCursor | string | null | undefined>} args.loadCursor - Loads the persisted local cursor.
+     * @param {(cursor: SyncCursor) => Promise<void>} args.saveCursor - Persists the final acknowledged cursor.
+     * @param {(payload: SyncChangesRequest) => Promise<SyncChangesResponse>} args.postChanges - Posts one changes request.
+     * @param {(sync: SyncChangeEnvelope) => Promise<SyncChangeApplyResult>} args.applySync - Applies one normalized sync row locally.
+     * @param {(progress: {pages: number, syncedCount: number}) => void} [args.onProgress] - Progress callback.
+     * @returns {Promise<SyncChangesResult>} Pull result.
+     */
+    static async pullChanges(args) {
+        let afterCursor = this.syncCursorFromPayload(await args.loadCursor());
+        let upToCursor = null;
+        let pages = 0;
+        let syncedCount = 0;
+        let changed = false;
+        const resourceCounts = /** @type {Record<string, number>} */ ({});
+        const resourceChanged = /** @type {Record<string, boolean>} */ ({});
+        const batchSize = this.normalizedBatchSize(args.batchSize);
+        while (true) {
+            const changesResponse = await this.changesPage({ ...args, afterCursor, batchSize, upToCursor });
+            const syncs = changesResponse.syncs;
+            if (!upToCursor)
+                upToCursor = changesResponse.upToCursor;
+            if (syncs.length === 0)
+                break;
+            pages += 1;
+            for (const sync of syncs) {
+                const applyResult = await args.applySync(sync);
+                const resourceType = applyResult.resourceType ?? sync.resourceType();
+                changed ||= applyResult.changed === true;
+                syncedCount += 1;
+                if (resourceType) {
+                    resourceCounts[resourceType] = (resourceCounts[resourceType] || 0) + 1;
+                    resourceChanged[resourceType] ||= applyResult.changed === true;
+                }
+            }
+            afterCursor = changesResponse.nextCursor;
+            if (args.onProgress)
+                args.onProgress({ pages, syncedCount });
+            if (syncs.length < batchSize)
+                break;
+        }
+        if (afterCursor)
+            await args.saveCursor(afterCursor);
+        return { changed, pages, resourceChanged, resourceCounts, syncedCount };
+    }
+    /**
+     * Fetches and validates one backend sync changes page.
+     * @param {object} args - Page args.
+     * @param {SyncCursor} args.afterCursor - Last acknowledged cursor.
+     * @param {string} args.authenticationToken - Auth token.
+     * @param {number} args.batchSize - Page size.
+     * @param {(payload: SyncChangesRequest) => Promise<SyncChangesResponse>} args.postChanges - Changes poster.
+     * @param {SyncCursor} args.upToCursor - Snapshot upper-bound cursor.
+     * @returns {Promise<{nextCursor: SyncCursor, syncs: SyncChangeEnvelope[], upToCursor: SyncCursor}>} Normalized changes page.
+     */
+    static async changesPage({ afterCursor, authenticationToken, batchSize, postChanges, upToCursor }) {
+        const response = await postChanges({
+            authenticationToken,
+            limit: batchSize,
+            ...this.cursorPayload("after", afterCursor),
+            ...this.cursorPayload("upTo", upToCursor)
+        });
+        this.ensureSuccessfulChangesResponse(response);
+        const syncs = /** @type {unknown[]} */ (response.syncs);
+        return {
+            nextCursor: this.syncCursorFromPayload(response.nextCursor ?? null),
+            syncs: syncs.map((syncPayload) => this.syncEnvelopeFromPayload(syncPayload)),
+            upToCursor: this.syncCursorFromPayload(response.upToCursor ?? null)
+        };
+    }
+    /**
+     * Checks API response status and shape for change-feed pulls.
+     * @param {SyncChangesResponse} response - Changes response.
+     * @returns {void}
+     */
+    static ensureSuccessfulChangesResponse(response) {
+        if (response.status === "error")
+            throw new Error(response.errorMessage || "Sync changes failed");
+        if (!Array.isArray(response.syncs))
+            throw new Error("Sync changes response missing syncs");
+    }
+    /**
+     * Converts a cursor into request params with the given prefix.
+     * @param {"after" | "upTo"} prefix - Request field prefix.
+     * @param {SyncCursor} cursor - Cursor to serialize.
+     * @returns {Record<string, string | number | null>} Request params.
+     */
+    static cursorPayload(prefix, cursor) {
+        if (!cursor)
+            return {};
+        return {
+            [`${prefix}Id`]: cursor.id,
+            ...(cursor.serverSequence ? { [`${prefix}ServerSequence`]: cursor.serverSequence } : {}),
+            [`${prefix}UpdatedAt`]: cursor.updatedAt
+        };
+    }
+    /**
+     * Parses a persisted or response cursor payload.
+     * @param {SyncCursor | string | Record<string, ?> | null | undefined} payload - Cursor payload.
+     * @returns {SyncCursor} Parsed cursor.
+     */
+    static syncCursorFromPayload(payload) {
+        if (!payload)
+            return null;
+        if (typeof payload === "string") {
+            try {
+                return this.syncCursorFromPayload(JSON.parse(payload));
+            }
+            catch (_error) {
+                return { id: null, serverSequence: null, updatedAt: payload };
+            }
+        }
+        if (typeof payload !== "object" || Array.isArray(payload))
+            return null;
+        const updatedAt = typeof payload.updatedAt === "string" ? payload.updatedAt : null;
+        if (!updatedAt)
+            return null;
+        return {
+            id: payload.id === null || payload.id === undefined ? null : String(payload.id),
+            serverSequence: optionalInteger(payload.serverSequence === "" ? null : payload.serverSequence),
+            updatedAt
+        };
+    }
+    /**
+     * Builds a normalized sync row adapter.
+     * @param {?} payload - Raw sync payload.
+     * @returns {SyncChangeEnvelope} Sync row adapter.
+     */
+    static syncEnvelopeFromPayload(payload) {
+        if (!payload || typeof payload !== "object" || Array.isArray(payload))
+            throw new Error("Sync changes entry must be an object");
+        const syncPayload = /** @type {Record<string, ?>} */ (payload);
+        return {
+            data: () => syncPayload.data,
+            id: () => syncPayload.id,
+            resourceId: () => syncPayload.resourceId,
+            resourceType: () => syncPayload.resourceType === null || syncPayload.resourceType === undefined ? null : String(syncPayload.resourceType),
+            syncType: () => syncPayload.syncType === null || syncPayload.syncType === undefined ? "" : String(syncPayload.syncType)
+        };
+    }
+    /**
+     * Builds an app-configured resource applier for pulled sync rows. The sync
+     * mechanics stay here; apps only declare which models/attributes/hooks are
+     * allowed for each resource type.
+     * @param {Record<string, SyncResourceConfig>} resources - Resource policy map.
+     * @returns {(sync: SyncChangeEnvelope) => Promise<SyncChangeApplyResult>} Sync apply callback.
+     */
+    static resourceApplier(resources) {
+        return async (sync) => await this.applyResourceSync({ resources, sync });
+    }
+    /**
+     * Applies one sync row using declarative resource policy.
+     * @param {{resources: Record<string, SyncResourceConfig>, sync: SyncChangeEnvelope}} args - Apply args.
+     * @returns {Promise<SyncChangeApplyResult>} Apply result.
+     */
+    static async applyResourceSync({ resources, sync }) {
+        const resourceType = sync.resourceType();
+        const resource = resourceType ? resources[resourceType] : undefined;
+        if (!resource || !resource.enabled)
+            return { changed: false, resourceType };
+        if (sync.syncType() === "delete") {
+            return { changed: await this.destroySyncedResource({ resource, sync }), resourceType };
+        }
+        const data = this.syncData(sync);
+        const record = resource.findRecord ? await resource.findRecord({ data, resourceId: sync.resourceId(), sync }) : await resource.modelClass.findOrInitializeBy({ id: data.id ?? sync.resourceId() });
+        const attributes = await resource.attributes({ data, record, sync });
+        let changed = false;
+        record.assign(attributes);
+        if (record.isChanged()) {
+            await record.save();
+            changed = true;
+        }
+        if (resource.afterApply) {
+            const hookChanged = await resource.afterApply({ attributes, data, record, sync });
+            changed ||= hookChanged === true;
+        }
+        return { changed, resourceType };
+    }
+    /**
+     * Destroys a synced resource via its declared model policy.
+     * @param {{resource: SyncResourceConfig, sync: SyncChangeEnvelope}} args - Destroy args.
+     * @returns {Promise<boolean>} Whether a local row was destroyed.
+     */
+    static async destroySyncedResource({ resource, sync }) {
+        const id = sync.resourceId();
+        const record = resource.findRecordForDelete ? await resource.findRecordForDelete({ resourceId: id, sync }) : await resource.modelClass.findBy({ id });
+        if (!record)
+            return false;
+        await record.destroy();
+        return true;
+    }
+    /**
+     * Parses the embedded sync data JSON/object.
+     * @param {SyncChangeEnvelope} sync - Sync row.
+     * @returns {Record<string, unknown>} Sync data object.
+     */
+    static syncData(sync) {
+        const data = sync.data();
+        if (!data)
+            throw new Error(`Sync ${sync.id()} is missing data`);
+        if (typeof data === "string")
+            return /** @type {Record<string, unknown>} */ (JSON.parse(data));
+        if (typeof data === "object" && !Array.isArray(data))
+            return /** @type {Record<string, unknown>} */ (data);
+        throw new Error(`Sync ${sync.id()} has invalid data`);
+    }
+    /**
+     * Drains pending sync records in stable order and marks acknowledged rows.
+     * @param {object} args - Replay args.
+     * @param {string} args.authenticationToken - Auth token to send with replay requests.
+     * @param {number} [args.batchSize] - Max syncs per request. Defaults to 100.
+     * @param {() => Promise<Array<unknown>>} args.pendingSyncs - Loads pending local sync rows in replay order.
+     * @param {(sync: unknown) => string | number | null | undefined} args.syncId - Returns the local sync id.
+     * @param {(sync: unknown) => Record<string, ?>} args.syncPayload - Builds the API sync envelope.
+     * @param {(payload: {authenticationToken: string, syncs: Array<Record<string, ?>>}) => Promise<SyncReplayResponse>} args.postReplay - Posts one replay request.
+     * @param {(sync: unknown, response: SyncReplayItem) => Promise<void>} args.markSuccessful - Marks one sync as successful locally.
+     * @returns {Promise<void>} Resolves after all batches are replayed.
+     */
+    static async replayPending(args) {
+        const pendingSyncs = await args.pendingSyncs();
+        const batchSize = this.normalizedBatchSize(args.batchSize);
+        for (let offset = 0; offset < pendingSyncs.length; offset += batchSize) {
+            await this.replayBatch({ ...args, pendingSyncs: pendingSyncs.slice(offset, offset + batchSize) });
+        }
+    }
+    /**
+     * Replays one batch of syncs.
+     * @param {object} args - Replay args.
+     * @param {string} args.authenticationToken - Auth token.
+     * @param {Array<unknown>} args.pendingSyncs - Batch syncs.
+     * @param {(sync: unknown) => string | number | null | undefined} args.syncId - Sync id getter.
+     * @param {(sync: unknown) => Record<string, ?>} args.syncPayload - Payload builder.
+     * @param {(payload: {authenticationToken: string, syncs: Array<Record<string, ?>>}) => Promise<SyncReplayResponse>} args.postReplay - Replay poster.
+     * @param {(sync: unknown, response: SyncReplayItem) => Promise<void>} args.markSuccessful - Success hook.
+     * @returns {Promise<void>} Resolves after the batch is acknowledged.
+     */
+    static async replayBatch(args) {
+        const { authenticationToken, markSuccessful, pendingSyncs, postReplay, syncId, syncPayload } = args;
+        if (pendingSyncs.length === 0)
+            return;
+        const syncsById = new Map();
+        for (const sync of pendingSyncs) {
+            const id = syncId(sync);
+            if (id !== undefined && id !== null)
+                syncsById.set(String(id), sync);
+        }
+        const response = await postReplay({
+            authenticationToken,
+            syncs: pendingSyncs.map((sync) => syncPayload(sync))
+        });
+        this.ensureSuccessfulResponse(response);
+        for (const syncResponse of response.syncs || []) {
+            const sync = syncsById.get(String(syncResponse.id));
+            if (!sync)
+                continue;
+            if (syncResponse.syncState !== "successful") {
+                throw new Error(`Invalid sync state returned for sync ${String(syncResponse.id)}: ${String(syncResponse.syncState)}`);
+            }
+            await markSuccessful(sync, syncResponse);
+        }
+    }
+    /**
+     * Checks API response status and shape.
+     * @param {SyncReplayResponse} response - Replay response.
+     * @returns {void}
+     */
+    static ensureSuccessfulResponse(response) {
+        if (response.status === "error")
+            throw new Error(response.errorMessage || "Sync failed");
+        if (!Array.isArray(response.syncs))
+            throw new Error("Sync response missing syncs");
+    }
+    /**
+     * Normalizes a positive batch size.
+     * @param {number | undefined} batchSize - Batch size.
+     * @returns {number} Positive batch size.
+     */
+    static normalizedBatchSize(batchSize) {
+        if (typeof batchSize !== "number" || !Number.isFinite(batchSize) || batchSize < 1)
+            return 100;
+        return Math.floor(batchSize);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-api-client.js","sourceRoot":"","sources":["../../../src/sync/sync-api-client.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {optionalInteger} from \"typanic\"\n\n/** @typedef {import(\"./sync-api-client-types.js\").SyncChangeApplyResult} SyncChangeApplyResult */\n/** @typedef {import(\"./sync-api-client-types.js\").SyncChangeEnvelope} SyncChangeEnvelope */\n/** @typedef {import(\"./sync-api-client-types.js\").SyncChangesRequest} SyncChangesRequest */\n/** @typedef {import(\"./sync-api-client-types.js\").SyncChangesResponse} SyncChangesResponse */\n/** @typedef {import(\"./sync-api-client-types.js\").SyncChangesResult} SyncChangesResult */\n/** @typedef {import(\"./sync-api-client-types.js\").SyncCursor} SyncCursor */\n/** @typedef {import(\"./sync-api-client-types.js\").SyncReplayItem} SyncReplayItem */\n/** @typedef {import(\"./sync-api-client-types.js\").SyncReplayResponse} SyncReplayResponse */\n/** @typedef {import(\"./sync-api-client-types.js\").SyncResourceConfig} SyncResourceConfig */\n\n/**\n * Generic client-side helper for replaying pending sync envelopes through the\n * framework-owned `/velocious/sync/replay` endpoint. Apps provide only local\n * persistence/auth hooks.\n */\nexport default class SyncApiClient {\n  /**\n   * Pulls backend sync changes in stable pages, applies them locally, and stores\n   * the acknowledged cursor. Apps provide only auth, persistence, transport, and\n   * resource policy hooks.\n   * @param {object} args - Pull args.\n   * @param {string} args.authenticationToken - Auth token to send with change requests.\n   * @param {number} [args.batchSize] - Max syncs per request. Defaults to 100.\n   * @param {() => Promise<SyncCursor | string | null | undefined>} args.loadCursor - Loads the persisted local cursor.\n   * @param {(cursor: SyncCursor) => Promise<void>} args.saveCursor - Persists the final acknowledged cursor.\n   * @param {(payload: SyncChangesRequest) => Promise<SyncChangesResponse>} args.postChanges - Posts one changes request.\n   * @param {(sync: SyncChangeEnvelope) => Promise<SyncChangeApplyResult>} args.applySync - Applies one normalized sync row locally.\n   * @param {(progress: {pages: number, syncedCount: number}) => void} [args.onProgress] - Progress callback.\n   * @returns {Promise<SyncChangesResult>} Pull result.\n   */\n  static async pullChanges(args) {\n    let afterCursor = this.syncCursorFromPayload(await args.loadCursor())\n    let upToCursor = null\n    let pages = 0\n    let syncedCount = 0\n    let changed = false\n    const resourceCounts = /** @type {Record<string, number>} */ ({})\n    const resourceChanged = /** @type {Record<string, boolean>} */ ({})\n    const batchSize = this.normalizedBatchSize(args.batchSize)\n\n    while (true) {\n      const changesResponse = await this.changesPage({...args, afterCursor, batchSize, upToCursor})\n      const syncs = changesResponse.syncs\n\n      if (!upToCursor) upToCursor = changesResponse.upToCursor\n      if (syncs.length === 0) break\n\n      pages += 1\n\n      for (const sync of syncs) {\n        const applyResult = await args.applySync(sync)\n        const resourceType = applyResult.resourceType ?? sync.resourceType()\n\n        changed ||= applyResult.changed === true\n        syncedCount += 1\n\n        if (resourceType) {\n          resourceCounts[resourceType] = (resourceCounts[resourceType] || 0) + 1\n          resourceChanged[resourceType] ||= applyResult.changed === true\n        }\n      }\n\n      afterCursor = changesResponse.nextCursor\n\n      if (args.onProgress) args.onProgress({pages, syncedCount})\n      if (syncs.length < batchSize) break\n    }\n\n    if (afterCursor) await args.saveCursor(afterCursor)\n\n    return {changed, pages, resourceChanged, resourceCounts, syncedCount}\n  }\n\n  /**\n   * Fetches and validates one backend sync changes page.\n   * @param {object} args - Page args.\n   * @param {SyncCursor} args.afterCursor - Last acknowledged cursor.\n   * @param {string} args.authenticationToken - Auth token.\n   * @param {number} args.batchSize - Page size.\n   * @param {(payload: SyncChangesRequest) => Promise<SyncChangesResponse>} args.postChanges - Changes poster.\n   * @param {SyncCursor} args.upToCursor - Snapshot upper-bound cursor.\n   * @returns {Promise<{nextCursor: SyncCursor, syncs: SyncChangeEnvelope[], upToCursor: SyncCursor}>} Normalized changes page.\n   */\n  static async changesPage({afterCursor, authenticationToken, batchSize, postChanges, upToCursor}) {\n    const response = await postChanges({\n      authenticationToken,\n      limit: batchSize,\n      ...this.cursorPayload(\"after\", afterCursor),\n      ...this.cursorPayload(\"upTo\", upToCursor)\n    })\n\n    this.ensureSuccessfulChangesResponse(response)\n\n    const syncs = /** @type {unknown[]} */ (response.syncs)\n\n    return {\n      nextCursor: this.syncCursorFromPayload(response.nextCursor ?? null),\n      syncs: syncs.map((syncPayload) => this.syncEnvelopeFromPayload(syncPayload)),\n      upToCursor: this.syncCursorFromPayload(response.upToCursor ?? null)\n    }\n  }\n\n  /**\n   * Checks API response status and shape for change-feed pulls.\n   * @param {SyncChangesResponse} response - Changes response.\n   * @returns {void}\n   */\n  static ensureSuccessfulChangesResponse(response) {\n    if (response.status === \"error\") throw new Error(response.errorMessage || \"Sync changes failed\")\n    if (!Array.isArray(response.syncs)) throw new Error(\"Sync changes response missing syncs\")\n  }\n\n  /**\n   * Converts a cursor into request params with the given prefix.\n   * @param {\"after\" | \"upTo\"} prefix - Request field prefix.\n   * @param {SyncCursor} cursor - Cursor to serialize.\n   * @returns {Record<string, string | number | null>} Request params.\n   */\n  static cursorPayload(prefix, cursor) {\n    if (!cursor) return {}\n\n    return {\n      [`${prefix}Id`]: cursor.id,\n      ...(cursor.serverSequence ? {[`${prefix}ServerSequence`]: cursor.serverSequence} : {}),\n      [`${prefix}UpdatedAt`]: cursor.updatedAt\n    }\n  }\n\n  /**\n   * Parses a persisted or response cursor payload.\n   * @param {SyncCursor | string | Record<string, ?> | null | undefined} payload - Cursor payload.\n   * @returns {SyncCursor} Parsed cursor.\n   */\n  static syncCursorFromPayload(payload) {\n    if (!payload) return null\n\n    if (typeof payload === \"string\") {\n      try {\n        return this.syncCursorFromPayload(JSON.parse(payload))\n      } catch (_error) {\n        return {id: null, serverSequence: null, updatedAt: payload}\n      }\n    }\n\n    if (typeof payload !== \"object\" || Array.isArray(payload)) return null\n\n    const updatedAt = typeof payload.updatedAt === \"string\" ? payload.updatedAt : null\n\n    if (!updatedAt) return null\n\n    return {\n      id: payload.id === null || payload.id === undefined ? null : String(payload.id),\n      serverSequence: optionalInteger(payload.serverSequence === \"\" ? null : payload.serverSequence),\n      updatedAt\n    }\n  }\n\n  /**\n   * Builds a normalized sync row adapter.\n   * @param {?} payload - Raw sync payload.\n   * @returns {SyncChangeEnvelope} Sync row adapter.\n   */\n  static syncEnvelopeFromPayload(payload) {\n    if (!payload || typeof payload !== \"object\" || Array.isArray(payload)) throw new Error(\"Sync changes entry must be an object\")\n\n    const syncPayload = /** @type {Record<string, ?>} */ (payload)\n\n    return {\n      data: () => syncPayload.data,\n      id: () => syncPayload.id,\n      resourceId: () => syncPayload.resourceId,\n      resourceType: () => syncPayload.resourceType === null || syncPayload.resourceType === undefined ? null : String(syncPayload.resourceType),\n      syncType: () => syncPayload.syncType === null || syncPayload.syncType === undefined ? \"\" : String(syncPayload.syncType)\n    }\n  }\n\n  /**\n   * Builds an app-configured resource applier for pulled sync rows. The sync\n   * mechanics stay here; apps only declare which models/attributes/hooks are\n   * allowed for each resource type.\n   * @param {Record<string, SyncResourceConfig>} resources - Resource policy map.\n   * @returns {(sync: SyncChangeEnvelope) => Promise<SyncChangeApplyResult>} Sync apply callback.\n   */\n  static resourceApplier(resources) {\n    return async (sync) => await this.applyResourceSync({resources, sync})\n  }\n\n  /**\n   * Applies one sync row using declarative resource policy.\n   * @param {{resources: Record<string, SyncResourceConfig>, sync: SyncChangeEnvelope}} args - Apply args.\n   * @returns {Promise<SyncChangeApplyResult>} Apply result.\n   */\n  static async applyResourceSync({resources, sync}) {\n    const resourceType = sync.resourceType()\n    const resource = resourceType ? resources[resourceType] : undefined\n\n    if (!resource || !resource.enabled) return {changed: false, resourceType}\n\n    if (sync.syncType() === \"delete\") {\n      return {changed: await this.destroySyncedResource({resource, sync}), resourceType}\n    }\n\n    const data = this.syncData(sync)\n    const record = resource.findRecord ? await resource.findRecord({data, resourceId: sync.resourceId(), sync}) : await resource.modelClass.findOrInitializeBy({id: data.id ?? sync.resourceId()})\n    const attributes = await resource.attributes({data, record, sync})\n    let changed = false\n\n    record.assign(attributes)\n\n    if (record.isChanged()) {\n      await record.save()\n      changed = true\n    }\n\n    if (resource.afterApply) {\n      const hookChanged = await resource.afterApply({attributes, data, record, sync})\n\n      changed ||= hookChanged === true\n    }\n\n    return {changed, resourceType}\n  }\n\n  /**\n   * Destroys a synced resource via its declared model policy.\n   * @param {{resource: SyncResourceConfig, sync: SyncChangeEnvelope}} args - Destroy args.\n   * @returns {Promise<boolean>} Whether a local row was destroyed.\n   */\n  static async destroySyncedResource({resource, sync}) {\n    const id = sync.resourceId()\n    const record = resource.findRecordForDelete ? await resource.findRecordForDelete({resourceId: id, sync}) : await resource.modelClass.findBy({id})\n\n    if (!record) return false\n\n    await record.destroy()\n    return true\n  }\n\n  /**\n   * Parses the embedded sync data JSON/object.\n   * @param {SyncChangeEnvelope} sync - Sync row.\n   * @returns {Record<string, unknown>} Sync data object.\n   */\n  static syncData(sync) {\n    const data = sync.data()\n\n    if (!data) throw new Error(`Sync ${sync.id()} is missing data`)\n    if (typeof data === \"string\") return /** @type {Record<string, unknown>} */ (JSON.parse(data))\n    if (typeof data === \"object\" && !Array.isArray(data)) return /** @type {Record<string, unknown>} */ (data)\n\n    throw new Error(`Sync ${sync.id()} has invalid data`)\n  }\n\n  /**\n   * Drains pending sync records in stable order and marks acknowledged rows.\n   * @param {object} args - Replay args.\n   * @param {string} args.authenticationToken - Auth token to send with replay requests.\n   * @param {number} [args.batchSize] - Max syncs per request. Defaults to 100.\n   * @param {() => Promise<Array<unknown>>} args.pendingSyncs - Loads pending local sync rows in replay order.\n   * @param {(sync: unknown) => string | number | null | undefined} args.syncId - Returns the local sync id.\n   * @param {(sync: unknown) => Record<string, ?>} args.syncPayload - Builds the API sync envelope.\n   * @param {(payload: {authenticationToken: string, syncs: Array<Record<string, ?>>}) => Promise<SyncReplayResponse>} args.postReplay - Posts one replay request.\n   * @param {(sync: unknown, response: SyncReplayItem) => Promise<void>} args.markSuccessful - Marks one sync as successful locally.\n   * @returns {Promise<void>} Resolves after all batches are replayed.\n   */\n  static async replayPending(args) {\n    const pendingSyncs = await args.pendingSyncs()\n    const batchSize = this.normalizedBatchSize(args.batchSize)\n\n    for (let offset = 0; offset < pendingSyncs.length; offset += batchSize) {\n      await this.replayBatch({...args, pendingSyncs: pendingSyncs.slice(offset, offset + batchSize)})\n    }\n  }\n\n  /**\n   * Replays one batch of syncs.\n   * @param {object} args - Replay args.\n   * @param {string} args.authenticationToken - Auth token.\n   * @param {Array<unknown>} args.pendingSyncs - Batch syncs.\n   * @param {(sync: unknown) => string | number | null | undefined} args.syncId - Sync id getter.\n   * @param {(sync: unknown) => Record<string, ?>} args.syncPayload - Payload builder.\n   * @param {(payload: {authenticationToken: string, syncs: Array<Record<string, ?>>}) => Promise<SyncReplayResponse>} args.postReplay - Replay poster.\n   * @param {(sync: unknown, response: SyncReplayItem) => Promise<void>} args.markSuccessful - Success hook.\n   * @returns {Promise<void>} Resolves after the batch is acknowledged.\n   */\n  static async replayBatch(args) {\n    const {authenticationToken, markSuccessful, pendingSyncs, postReplay, syncId, syncPayload} = args\n\n    if (pendingSyncs.length === 0) return\n\n    const syncsById = new Map()\n\n    for (const sync of pendingSyncs) {\n      const id = syncId(sync)\n\n      if (id !== undefined && id !== null) syncsById.set(String(id), sync)\n    }\n\n    const response = await postReplay({\n      authenticationToken,\n      syncs: pendingSyncs.map((sync) => syncPayload(sync))\n    })\n\n    this.ensureSuccessfulResponse(response)\n\n    for (const syncResponse of response.syncs || []) {\n      const sync = syncsById.get(String(syncResponse.id))\n\n      if (!sync) continue\n      if (syncResponse.syncState !== \"successful\") {\n        throw new Error(`Invalid sync state returned for sync ${String(syncResponse.id)}: ${String(syncResponse.syncState)}`)\n      }\n\n      await markSuccessful(sync, syncResponse)\n    }\n  }\n\n  /**\n   * Checks API response status and shape.\n   * @param {SyncReplayResponse} response - Replay response.\n   * @returns {void}\n   */\n  static ensureSuccessfulResponse(response) {\n    if (response.status === \"error\") throw new Error(response.errorMessage || \"Sync failed\")\n    if (!Array.isArray(response.syncs)) throw new Error(\"Sync response missing syncs\")\n  }\n\n  /**\n   * Normalizes a positive batch size.\n   * @param {number | undefined} batchSize - Batch size.\n   * @returns {number} Positive batch size.\n   */\n  static normalizedBatchSize(batchSize) {\n    if (typeof batchSize !== \"number\" || !Number.isFinite(batchSize) || batchSize < 1) return 100\n\n    return Math.floor(batchSize)\n  }\n}\n"]}

package/build/src/sync/sync-api-controller.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Generic `/velocious/sync` transport controller.
+ *
+ * Apps provide a sync resource class; Velocious owns endpoint shape and
+ * rendering. The app resource owns auth, scoping, and domain-specific
+ * replay/change hooks.
+ */
+export default class SyncApiController extends Controller {
+    /**
+     * Builds a sync API controller class bound to the given resource.
+     * @param {import("../configuration-types.js").FrontendModelResourceClassType} ResourceClass - Sync resource class.
+     * @returns {typeof SyncApiController} Controller class for the resource.
+     */
+    static withSyncResourceClass(ResourceClass: import("../configuration-types.js").FrontendModelResourceClassType): typeof SyncApiController;
+    /**
+     * Mounts the standard Velocious sync endpoints into a route configuration.
+     * @param {{configuration?: import("../configuration.js").default, at?: string, syncResourceClass?: import("../configuration-types.js").FrontendModelResourceClassType}} args - Mount args.
+     * @returns {void}
+     */
+    static mountInto(args: {
+        configuration?: import("../configuration.js").default;
+        at?: string;
+        syncResourceClass?: import("../configuration-types.js").FrontendModelResourceClassType;
+    }): void;
+    /**
+     * Normalizes a sync mount path.
+     * @param {string} at - Mount path.
+     * @returns {string} Normalized mount path without trailing slash.
+     */
+    static normalizedMountPath(at: string): string;
+    /**
+     * Renders a replay response from the configured sync resource.
+     * @returns {Promise<void>}
+     */
+    replay(): Promise<void>;
+    /**
+     * Renders a change-feed response from the configured sync resource.
+     * @returns {Promise<void>}
+     */
+    changes(): Promise<void>;
+    /**
+     * Builds the sync resource that backs the transport endpoint.
+     * @param {Record<string, unknown>} params - Request params/body.
+     * @returns {FrontendModelBaseResource} Sync resource instance.
+     */
+    syncResource(params: Record<string, unknown>): FrontendModelBaseResource;
+    /**
+     * Returns the app-provided sync resource class.
+     * @returns {import("../configuration-types.js").FrontendModelResourceClassType} Sync resource class.
+     */
+    syncResourceClass(): import("../configuration-types.js").FrontendModelResourceClassType;
+    /**
+     * Raises a configuration error for subclasses that do not provide a resource.
+     * @returns {import("../configuration-types.js").FrontendModelResourceClassType} Sync resource class.
+     */
+    missingSyncResourceClass(): import("../configuration-types.js").FrontendModelResourceClassType;
+    /** Raises a configuration error for subclasses that do not provide a resource. */
+    raiseMissingSyncResourceClass(): void;
+    /**
+     * Returns the model class exposed by the sync resource.
+     * @returns {typeof import("../database/record/index.js").default} Sync model class.
+     */
+    syncModelClass(): typeof import("../database/record/index.js").default;
+    /**
+     * Returns the model name used to initialize the resource.
+     * @returns {string} Sync model name.
+     */
+    syncModelName(): string;
+    /**
+     * Builds the minimal resource configuration needed by the sync resource.
+     * @param {import("../configuration-types.js").FrontendModelResourceClassType} ResourceClass - Sync resource class.
+     * @returns {import("../configuration-types.js").FrontendModelResourceConfiguration} Resource configuration.
+     */
+    syncResourceConfiguration(ResourceClass: import("../configuration-types.js").FrontendModelResourceClassType): import("../configuration-types.js").FrontendModelResourceConfiguration;
+}
+import Controller from "../controller.js";
+import FrontendModelBaseResource from "../frontend-model-resource/base-resource.js";
+//# sourceMappingURL=sync-api-controller.d.ts.map

package/build/src/sync/sync-api-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-api-controller.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-api-controller.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH;IAsDE;;;;OAIG;IACH,4CAHW,OAAO,2BAA2B,EAAE,8BAA8B,GAChE,OAAO,iBAAiB,CAYpC;IAED;;;;OAIG;IACH,uBAHW;QAAC,aAAa,CAAC,EAAE,OAAO,qBAAqB,EAAE,OAAO,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,iBAAiB,CAAC,EAAE,OAAO,2BAA2B,EAAE,8BAA8B,CAAA;KAAC,GAC1J,IAAI,CAahB;IAED;;;;OAIG;IACH,+BAHW,MAAM,GACJ,MAAM,CAQlB;IAnGD;;;OAGG;IACH,UAFa,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;OAGG;IACH,WAFa,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;;OAIG;IACH,qBAHW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACrB,yBAAyB,CAoBrC;IAED;;;OAGG;IACH,qBAFa,OAAO,2BAA2B,EAAE,8BAA8B,CAI9E;IAkDD;;;OAGG;IACH,4BAFa,OAAO,2BAA2B,EAAE,8BAA8B,CAI9E;IAED,kFAAkF;IAClF,sCAEC;IAED;;;OAGG;IACH,kBAFa,cAAc,6BAA6B,EAAE,OAAO,CAShE;IAED;;;OAGG;IACH,iBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,yCAHW,OAAO,2BAA2B,EAAE,8BAA8B,GAChE,OAAO,2BAA2B,EAAE,kCAAkC,CAOlF;CACF;uBA7JsB,kBAAkB;sCACH,6CAA6C"}

package/build/src/sync/sync-api-controller.js

@@ -0,0 +1,142 @@
+// @ts-check
+import Controller from "../controller.js";
+import FrontendModelBaseResource from "../frontend-model-resource/base-resource.js";
+/**
+ * Generic `/velocious/sync` transport controller.
+ *
+ * Apps provide a sync resource class; Velocious owns endpoint shape and
+ * rendering. The app resource owns auth, scoping, and domain-specific
+ * replay/change hooks.
+ */
+export default class SyncApiController extends Controller {
+    /**
+     * Renders a replay response from the configured sync resource.
+     * @returns {Promise<void>}
+     */
+    async replay() {
+        const resource = /** @type {FrontendModelBaseResource & {replay: () => Promise<unknown>}} */ (this.syncResource(this.params()));
+        await this.render({ json: /** @type {object} */ (await resource.replay()) });
+    }
+    /**
+     * Renders a change-feed response from the configured sync resource.
+     * @returns {Promise<void>}
+     */
+    async changes() {
+        const resource = /** @type {FrontendModelBaseResource & {changes: () => Promise<unknown>}} */ (this.syncResource(this.params()));
+        await this.render({ json: /** @type {object} */ (await resource.changes()) });
+    }
+    /**
+     * Builds the sync resource that backs the transport endpoint.
+     * @param {Record<string, unknown>} params - Request params/body.
+     * @returns {FrontendModelBaseResource} Sync resource instance.
+     */
+    syncResource(params) {
+        const ResourceClass = this.syncResourceClass();
+        const ability = this.currentAbility();
+        return new ResourceClass({
+            ability,
+            controller: /** @type {import("../frontend-model-resource/base-resource.js").FrontendModelResourceController} */ ( /** @type {unknown} */(this)),
+            context: {
+                ...(ability?.getContext() || {}),
+                params: this.params(),
+                request: this.request()
+            },
+            locals: ability?.getLocals() || {},
+            modelClass: this.syncModelClass(),
+            modelName: this.syncModelName(),
+            params: /** @type {import("../configuration-types.js").VelociousParams} */ ( /** @type {unknown} */(params)),
+            resourceConfiguration: this.syncResourceConfiguration(ResourceClass)
+        });
+    }
+    /**
+     * Returns the app-provided sync resource class.
+     * @returns {import("../configuration-types.js").FrontendModelResourceClassType} Sync resource class.
+     */
+    syncResourceClass() {
+        return this.missingSyncResourceClass();
+    }
+    /**
+     * Builds a sync API controller class bound to the given resource.
+     * @param {import("../configuration-types.js").FrontendModelResourceClassType} ResourceClass - Sync resource class.
+     * @returns {typeof SyncApiController} Controller class for the resource.
+     */
+    static withSyncResourceClass(ResourceClass) {
+        return class ConfiguredSyncApiController extends this {
+            /**
+             * Returns the configured sync resource class.
+             * @returns {import("../configuration-types.js").FrontendModelResourceClassType} Sync resource class.
+             */
+            syncResourceClass() {
+                return ResourceClass;
+            }
+        };
+    }
+    /**
+     * Mounts the standard Velocious sync endpoints into a route configuration.
+     * @param {{configuration?: import("../configuration.js").default, at?: string, syncResourceClass?: import("../configuration-types.js").FrontendModelResourceClassType}} args - Mount args.
+     * @returns {void}
+     */
+    static mountInto(args) {
+        const { configuration, syncResourceClass } = args;
+        const ControllerClass = syncResourceClass ? this.withSyncResourceClass(syncResourceClass) : this;
+        const at = this.normalizedMountPath(args.at || "/velocious/sync");
+        if (!configuration)
+            throw new Error("SyncApiController.mountInto requires configuration");
+        configuration.routes((routes) => {
+            routes.post(`${at}/changes`, { to: [ControllerClass, "changes"] });
+            routes.post(`${at}/replay`, { to: [ControllerClass, "replay"] });
+        });
+    }
+    /**
+     * Normalizes a sync mount path.
+     * @param {string} at - Mount path.
+     * @returns {string} Normalized mount path without trailing slash.
+     */
+    static normalizedMountPath(at) {
+        if (typeof at !== "string" || !at.startsWith("/")) {
+            throw new Error(`SyncApiController mount path must start with '/', got: ${String(at)}`);
+        }
+        return at.replace(/\/+$/u, "") || "/";
+    }
+    /**
+     * Raises a configuration error for subclasses that do not provide a resource.
+     * @returns {import("../configuration-types.js").FrontendModelResourceClassType} Sync resource class.
+     */
+    missingSyncResourceClass() {
+        return /** @type {typeof FrontendModelBaseResource} */ ( /** @type {unknown} */(this.raiseMissingSyncResourceClass()));
+    }
+    /** Raises a configuration error for subclasses that do not provide a resource. */
+    raiseMissingSyncResourceClass() {
+        throw new Error("SyncApiController.syncResourceClass must be implemented");
+    }
+    /**
+     * Returns the model class exposed by the sync resource.
+     * @returns {typeof import("../database/record/index.js").default} Sync model class.
+     */
+    syncModelClass() {
+        const ResourceClass = this.syncResourceClass();
+        const modelClass = ResourceClass.ModelClass;
+        if (!modelClass)
+            throw new Error("Sync resource class must define static ModelClass");
+        return modelClass;
+    }
+    /**
+     * Returns the model name used to initialize the resource.
+     * @returns {string} Sync model name.
+     */
+    syncModelName() {
+        return this.syncModelClass().name;
+    }
+    /**
+     * Builds the minimal resource configuration needed by the sync resource.
+     * @param {import("../configuration-types.js").FrontendModelResourceClassType} ResourceClass - Sync resource class.
+     * @returns {import("../configuration-types.js").FrontendModelResourceConfiguration} Resource configuration.
+     */
+    syncResourceConfiguration(ResourceClass) {
+        return /** @type {import("../configuration-types.js").FrontendModelResourceConfiguration} */ ({
+            attributes: ResourceClass.attributes || {},
+            sync: { enabled: true }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-api-controller.js","sourceRoot":"","sources":["../../../src/sync/sync-api-controller.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Controller from \"../controller.js\"\nimport FrontendModelBaseResource from \"../frontend-model-resource/base-resource.js\"\n\n/**\n * Generic `/velocious/sync` transport controller.\n *\n * Apps provide a sync resource class; Velocious owns endpoint shape and\n * rendering. The app resource owns auth, scoping, and domain-specific\n * replay/change hooks.\n */\nexport default class SyncApiController extends Controller {\n  /**\n   * Renders a replay response from the configured sync resource.\n   * @returns {Promise<void>}\n   */\n  async replay() {\n    const resource = /** @type {FrontendModelBaseResource & {replay: () => Promise<unknown>}} */ (this.syncResource(this.params()))\n\n    await this.render({json: /** @type {object} */ (await resource.replay())})\n  }\n\n  /**\n   * Renders a change-feed response from the configured sync resource.\n   * @returns {Promise<void>}\n   */\n  async changes() {\n    const resource = /** @type {FrontendModelBaseResource & {changes: () => Promise<unknown>}} */ (this.syncResource(this.params()))\n\n    await this.render({json: /** @type {object} */ (await resource.changes())})\n  }\n\n  /**\n   * Builds the sync resource that backs the transport endpoint.\n   * @param {Record<string, unknown>} params - Request params/body.\n   * @returns {FrontendModelBaseResource} Sync resource instance.\n   */\n  syncResource(params) {\n    const ResourceClass = this.syncResourceClass()\n    const ability = this.currentAbility()\n\n    return new ResourceClass({\n      ability,\n      controller: /** @type {import(\"../frontend-model-resource/base-resource.js\").FrontendModelResourceController} */ (/** @type {unknown} */ (this)),\n      context: {\n        ...(ability?.getContext() || {}),\n        params: this.params(),\n        request: this.request()\n      },\n      locals: ability?.getLocals() || {},\n      modelClass: this.syncModelClass(),\n      modelName: this.syncModelName(),\n      params: /** @type {import(\"../configuration-types.js\").VelociousParams} */ (/** @type {unknown} */ (params)),\n      resourceConfiguration: this.syncResourceConfiguration(ResourceClass)\n    })\n  }\n\n  /**\n   * Returns the app-provided sync resource class.\n   * @returns {import(\"../configuration-types.js\").FrontendModelResourceClassType} Sync resource class.\n   */\n  syncResourceClass() {\n    return this.missingSyncResourceClass()\n  }\n\n  /**\n   * Builds a sync API controller class bound to the given resource.\n   * @param {import(\"../configuration-types.js\").FrontendModelResourceClassType} ResourceClass - Sync resource class.\n   * @returns {typeof SyncApiController} Controller class for the resource.\n   */\n  static withSyncResourceClass(ResourceClass) {\n    return class ConfiguredSyncApiController extends this {\n      /**\n       * Returns the configured sync resource class.\n       * @returns {import(\"../configuration-types.js\").FrontendModelResourceClassType} Sync resource class.\n       */\n      syncResourceClass() {\n        return ResourceClass\n      }\n    }\n  }\n\n  /**\n   * Mounts the standard Velocious sync endpoints into a route configuration.\n   * @param {{configuration?: import(\"../configuration.js\").default, at?: string, syncResourceClass?: import(\"../configuration-types.js\").FrontendModelResourceClassType}} args - Mount args.\n   * @returns {void}\n   */\n  static mountInto(args) {\n    const {configuration, syncResourceClass} = args\n    const ControllerClass = syncResourceClass ? this.withSyncResourceClass(syncResourceClass) : this\n    const at = this.normalizedMountPath(args.at || \"/velocious/sync\")\n\n    if (!configuration) throw new Error(\"SyncApiController.mountInto requires configuration\")\n\n    configuration.routes((routes) => {\n      routes.post(`${at}/changes`, {to: [ControllerClass, \"changes\"]})\n      routes.post(`${at}/replay`, {to: [ControllerClass, \"replay\"]})\n    })\n  }\n\n  /**\n   * Normalizes a sync mount path.\n   * @param {string} at - Mount path.\n   * @returns {string} Normalized mount path without trailing slash.\n   */\n  static normalizedMountPath(at) {\n    if (typeof at !== \"string\" || !at.startsWith(\"/\")) {\n      throw new Error(`SyncApiController mount path must start with '/', got: ${String(at)}`)\n    }\n\n    return at.replace(/\\/+$/u, \"\") || \"/\"\n  }\n\n  /**\n   * Raises a configuration error for subclasses that do not provide a resource.\n   * @returns {import(\"../configuration-types.js\").FrontendModelResourceClassType} Sync resource class.\n   */\n  missingSyncResourceClass() {\n    return /** @type {typeof FrontendModelBaseResource} */ (/** @type {unknown} */ (this.raiseMissingSyncResourceClass()))\n  }\n\n  /** Raises a configuration error for subclasses that do not provide a resource. */\n  raiseMissingSyncResourceClass() {\n    throw new Error(\"SyncApiController.syncResourceClass must be implemented\")\n  }\n\n  /**\n   * Returns the model class exposed by the sync resource.\n   * @returns {typeof import(\"../database/record/index.js\").default} Sync model class.\n   */\n  syncModelClass() {\n    const ResourceClass = this.syncResourceClass()\n    const modelClass = ResourceClass.ModelClass\n\n    if (!modelClass) throw new Error(\"Sync resource class must define static ModelClass\")\n\n    return modelClass\n  }\n\n  /**\n   * Returns the model name used to initialize the resource.\n   * @returns {string} Sync model name.\n   */\n  syncModelName() {\n    return this.syncModelClass().name\n  }\n\n  /**\n   * Builds the minimal resource configuration needed by the sync resource.\n   * @param {import(\"../configuration-types.js\").FrontendModelResourceClassType} ResourceClass - Sync resource class.\n   * @returns {import(\"../configuration-types.js\").FrontendModelResourceConfiguration} Resource configuration.\n   */\n  syncResourceConfiguration(ResourceClass) {\n    return /** @type {import(\"../configuration-types.js\").FrontendModelResourceConfiguration} */ ({\n      attributes: ResourceClass.attributes || {},\n      sync: {enabled: true}\n    })\n  }\n}\n\n"]}