velocious 1.0.488 → 1.0.492

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

@@ -0,0 +1,380 @@
+// @ts-check
+import { forcedFunction } from "typanic";
+import Configuration from "../configuration.js";
+import { serializedScopeFromQuery } from "./query-scope.js";
+import SyncApiClient from "./sync-api-client.js";
+import SyncScopeStore from "./sync-scope-store.js";
+import { currentSyncClient, setCurrentSyncClient } from "./sync-client-registry.js";
+let clientCounter = 0;
+/** @type {{create: "afterCreate", update: "afterUpdate", destroy: "afterDestroy"}} */
+const TRACKED_CALLBACK_NAMES = { create: "afterCreate", destroy: "afterDestroy", update: "afterUpdate" };
+/**
+ * Declarative client-side sync driver.
+ *
+ * Apps configure resources, transport, auth, and connectivity once; Velocious
+ * owns scope persistence, per-scope cursors, pull paging/apply, local queueing,
+ * and online-gated replay. Declare sync interest from queries:
+ *
+ *     const syncClient = new SyncClient({...})
+ *     syncClient.setCurrent()
+ *     await syncClient.sync(Event.where({partnerId}))
+ */
+export default class SyncClient {
+    /**
+     * Creates a declarative sync client.
+     * @param {import("./sync-client-types.js").SyncClientConfig} config - Sync client configuration.
+     */
+    constructor(config) {
+        if (!config || typeof config !== "object")
+            throw new Error("SyncClient requires a configuration object");
+        forcedFunction(config.postChanges, "SyncClient config.postChanges");
+        forcedFunction(config.postReplay, "SyncClient config.postReplay");
+        forcedFunction(config.authenticationToken, "SyncClient config.authenticationToken");
+        if (!config.syncModel)
+            throw new Error("SyncClient requires config.syncModel");
+        if (!config.resources || typeof config.resources !== "object" || Object.keys(config.resources).length === 0) {
+            throw new Error("SyncClient requires at least one entry in config.resources");
+        }
+        for (const [resourceType, resource] of Object.entries(config.resources)) {
+            if (!resource || typeof resource !== "object" || !resource.modelClass) {
+                throw new Error(`SyncClient resource ${resourceType} must declare a modelClass`);
+            }
+        }
+        this.config = config;
+        this._clientNumber = ++clientCounter;
+        /** @type {import("./sync-scope-store.js").default | null} */
+        this._scopeStore = config.scopeStore || null;
+        /** @type {Promise<void> | null} */
+        this._scheduledReplay = null;
+        /** @type {Record<string, import("./sync-api-client-types.js").SyncResourceConfig> | null} */
+        this._pullResourceConfigs = null;
+        /** @type {Array<{callback: (record: ?) => Promise<void>, callbackName: "afterCreate" | "afterUpdate" | "afterDestroy", modelClass: ?}>} */
+        this._trackedCallbacks = [];
+        /** @type {WeakSet<object>} */
+        this._remoteApplyRecords = new WeakSet();
+        this._started = false;
+    }
+    /**
+     * Registers automatic mutation tracking for every resource with `track` enabled:
+     * local model creates/updates/destroys queue pending sync rows and schedule an
+     * immediate replay attempt, without app-side queue calls.
+     * @returns {Promise<void>}
+     */
+    async start() {
+        if (this._started)
+            return;
+        this._started = true;
+        for (const [resourceType, resourceConfig] of Object.entries(this.config.resources)) {
+            const operations = this.trackedOperations({ resourceConfig, resourceType });
+            for (const operation of operations) {
+                const callbackName = TRACKED_CALLBACK_NAMES[operation];
+                const callback = this.trackedMutationCallback({ operation, resourceConfig });
+                resourceConfig.modelClass[callbackName](callback);
+                this._trackedCallbacks.push({ callback, callbackName, modelClass: resourceConfig.modelClass });
+            }
+        }
+    }
+    /**
+     * Unregisters all tracking callbacks (tests, sign-out, hot reload).
+     * @returns {void}
+     */
+    stop() {
+        for (const { callback, callbackName, modelClass } of this._trackedCallbacks) {
+            modelClass.unregisterLifecycleCallback(callbackName, callback);
+        }
+        this._trackedCallbacks = [];
+        this._started = false;
+    }
+    /**
+     * Resolves and validates the tracked operations for a resource config.
+     * @param {{resourceConfig: import("./sync-client-types.js").SyncClientResourceConfig, resourceType: string}} args - Resource config and name.
+     * @returns {Array<"create" | "update" | "destroy">} Tracked operations.
+     */
+    trackedOperations({ resourceConfig, resourceType }) {
+        const track = resourceConfig.track;
+        if (track === undefined || track === false)
+            return [];
+        if (track === true)
+            return ["create", "update", "destroy"];
+        if (!track || typeof track !== "object" || !Array.isArray(track.operations) || track.operations.length === 0) {
+            throw new Error(`SyncClient resource ${resourceType} track must be true or {operations: [...]}`);
+        }
+        for (const operation of track.operations) {
+            if (!(operation in TRACKED_CALLBACK_NAMES)) {
+                throw new Error(`SyncClient resource ${resourceType} track.operations must be create/update/destroy, got: ${String(operation)}`);
+            }
+        }
+        return track.operations;
+    }
+    /**
+     * Builds the lifecycle callback queueing one tracked mutation.
+     * @param {{operation: "create" | "update" | "destroy", resourceConfig: import("./sync-client-types.js").SyncClientResourceConfig}} args - Operation and resource config.
+     * @returns {(record: ?) => Promise<void>} Lifecycle callback.
+     */
+    trackedMutationCallback({ operation, resourceConfig }) {
+        return async (record) => {
+            if (this.isRemoteApply(record))
+                return;
+            await SyncApiClient.queueLocalSync({
+                booleanAttributes: resourceConfig.booleanAttributes || [],
+                data: resourceConfig.trackedData ? resourceConfig.trackedData({ operation, record }) : undefined,
+                localOnlyAttributes: resourceConfig.localOnlyAttributes || [],
+                resource: record,
+                syncModel: this.config.syncModel,
+                syncType: this.defaultSyncType({ operation, record, resourceConfig })
+            });
+            this.scheduleReplay();
+        };
+    }
+    /**
+     * Whether a record is currently being written by pull-apply (echo suppression).
+     * @param {?} record - Local model record.
+     * @returns {boolean} Whether the record write originates from a remote change.
+     */
+    isRemoteApply(record) {
+        return this._remoteApplyRecords.has(record);
+    }
+    /**
+     * Registers this client as the app's current sync client.
+     * @returns {void}
+     */
+    setCurrent() {
+        setCurrentSyncClient(this);
+    }
+    /**
+     * Returns the app's current sync client.
+     * @returns {SyncClient} Current sync client.
+     */
+    static current() {
+        return /** @type {SyncClient} */ (currentSyncClient());
+    }
+    /**
+     * Declares (or re-activates) a sync scope from a model query and pulls it when online.
+     * @param {import("../database/query/model-class-query.js").default<?>} query - Query declaring the sync scope.
+     * @returns {Promise<{scope: import("./sync-client-types.js").SerializedSyncScope, pulled: import("./sync-api-client-types.js").SyncChangesResult | null}>} Declared scope and pull result (null while offline).
+     */
+    async sync(query) {
+        const scope = serializedScopeFromQuery(query);
+        const scopeStore = this.scopeStore();
+        const scopeRow = await scopeStore.findOrCreateScope(scope);
+        if (!scopeRow.cursorPayload && this.config.legacyCursor) {
+            const legacyCursorPayload = await this.config.legacyCursor({ scope });
+            const legacyCursor = SyncApiClient.syncCursorFromPayload(legacyCursorPayload);
+            if (legacyCursor)
+                await scopeStore.saveCursor(scopeRow, legacyCursor);
+        }
+        return { pulled: await this.pull(), scope };
+    }
+    /**
+     * Deactivates the sync scope declared by a model query.
+     * @param {import("../database/query/model-class-query.js").default<?>} query - Query whose scope should stop syncing.
+     * @returns {Promise<void>}
+     */
+    async unsync(query) {
+        await this.scopeStore().deactivate(serializedScopeFromQuery(query));
+    }
+    /**
+     * Pulls changes for every active scope with per-scope cursors (single-flighted, online-gated).
+     * @returns {Promise<import("./sync-api-client-types.js").SyncChangesResult | null>} Combined pull result, or null while offline.
+     */
+    async pull() {
+        if (!(await this.isOnline()))
+            return null;
+        /** @type {import("./sync-api-client-types.js").SyncChangesResult | null} */
+        let combinedResult = null;
+        await SyncApiClient.singleFlight(`velocious-sync-client-pull-${this._clientNumber}`, async () => {
+            const authenticationToken = await this.config.authenticationToken();
+            const scopeStore = this.scopeStore();
+            const pullResourceConfigs = this.pullResourceConfigs();
+            const applier = SyncApiClient.resourceApplier(pullResourceConfigs, (record) => {
+                this._remoteApplyRecords.add(record);
+                return () => this._remoteApplyRecords.delete(record);
+            });
+            /**
+             * Applies one pulled change, failing loudly instead of silently skipping unconfigured resources.
+             * @param {import("./sync-api-client-types.js").SyncChangeEnvelope} sync - Pulled change.
+             * @returns {Promise<import("./sync-api-client-types.js").SyncChangeApplyResult>} Apply result.
+             */
+            const applySync = async (sync) => {
+                const resourceType = sync.resourceType();
+                if (!resourceType || !pullResourceConfigs[resourceType]) {
+                    throw new Error(`No sync resource with pull attributes configured for pulled change: ${String(resourceType)}`);
+                }
+                return await applier(sync);
+            };
+            const result = {
+                changed: false,
+                pages: 0,
+                resourceChanged: /** @type {Record<string, boolean>} */ ({}),
+                resourceCounts: /** @type {Record<string, number>} */ ({}),
+                syncedCount: 0
+            };
+            for (const scopeRow of await scopeStore.activeScopes()) {
+                const scopeResult = await SyncApiClient.pullChanges({
+                    applySync,
+                    authenticationToken,
+                    batchSize: this.config.batchSize,
+                    loadCursor: async () => await scopeStore.loadCursor(scopeRow),
+                    postChanges: async (payload) => await this.config.postChanges({
+                        ...payload,
+                        scope: { conditions: scopeRow.conditions, resourceType: scopeRow.resourceType }
+                    }),
+                    saveCursor: async (cursor) => await scopeStore.saveCursor(scopeRow, cursor)
+                });
+                result.changed ||= scopeResult.changed;
+                result.pages += scopeResult.pages;
+                result.syncedCount += scopeResult.syncedCount;
+                for (const [resourceType, count] of Object.entries(scopeResult.resourceCounts)) {
+                    result.resourceCounts[resourceType] = (result.resourceCounts[resourceType] || 0) + count;
+                }
+                for (const [resourceType, changed] of Object.entries(scopeResult.resourceChanged)) {
+                    result.resourceChanged[resourceType] ||= changed;
+                }
+            }
+            combinedResult = result;
+        });
+        return combinedResult;
+    }
+    /**
+     * Queues a local model change as a pending sync row and schedules an immediate
+     * replay attempt (kept pending while offline or when the backend rejects it).
+     * @param {{resource: ?, data?: Record<string, ?>, syncType?: string}} args - Queue args.
+     * @returns {Promise<?>} Pending local sync row.
+     */
+    async queue({ data, resource, syncType }) {
+        const resourceConfig = this.resourceConfigFor(resource);
+        const syncRow = await SyncApiClient.queueLocalSync({
+            booleanAttributes: resourceConfig.booleanAttributes || [],
+            data,
+            localOnlyAttributes: resourceConfig.localOnlyAttributes || [],
+            resource,
+            syncModel: this.config.syncModel,
+            syncType: syncType ?? this.defaultSyncType({ operation: "update", record: resource, resourceConfig })
+        });
+        this.scheduleReplay();
+        return syncRow;
+    }
+    /**
+     * Drains pending local sync rows to the backend (single-flighted, online-gated).
+     * Rows are only marked successful after the backend acknowledges them.
+     * @returns {Promise<void>}
+     */
+    async replayPending() {
+        if (!(await this.isOnline()))
+            return;
+        await SyncApiClient.singleFlight(`velocious-sync-client-replay-${this._clientNumber}`, async () => {
+            await SyncApiClient.replayLocalSyncs({
+                authenticationToken: await this.config.authenticationToken(),
+                batchSize: this.config.batchSize,
+                postReplay: this.config.postReplay,
+                syncModel: this.config.syncModel
+            });
+        });
+    }
+    /**
+     * Schedules a background replay attempt without blocking the caller.
+     * Failures go to config.onError (or rethrow when none is configured).
+     * @returns {void}
+     */
+    scheduleReplay() {
+        this._scheduledReplay = (async () => {
+            try {
+                await this.replayPending();
+            }
+            catch (error) {
+                this.reportError(/** @type {Error} */ (error));
+            }
+        })();
+    }
+    /**
+     * Awaits the last scheduled background replay (useful in tests and shutdown flows).
+     * @returns {Promise<void>}
+     */
+    async waitForScheduledReplay() {
+        if (this._scheduledReplay)
+            await this._scheduledReplay;
+    }
+    /**
+     * Reports a background sync failure.
+     * @param {Error} error - Background failure.
+     * @returns {void}
+     */
+    reportError(error) {
+        if (this.config.onError) {
+            this.config.onError(error);
+            return;
+        }
+        throw error;
+    }
+    /**
+     * Resolves connectivity through the configured gate.
+     * @returns {Promise<boolean>} Whether the backend is considered reachable.
+     */
+    async isOnline() {
+        if (!this.config.isOnline)
+            return true;
+        return (await this.config.isOnline()) !== false;
+    }
+    /**
+     * Returns the scope store backing declared scopes and cursors.
+     * @returns {import("./sync-scope-store.js").default} Scope store.
+     */
+    scopeStore() {
+        this._scopeStore ||= new SyncScopeStore({ configuration: this.config.configuration || Configuration.current() });
+        return this._scopeStore;
+    }
+    /**
+     * Resolves the declared resource config for a local record.
+     * @param {?} resource - Local model record.
+     * @returns {import("./sync-client-types.js").SyncClientResourceConfig} Declared resource config.
+     */
+    resourceConfigFor(resource) {
+        const modelClass = resource?.constructor;
+        if (typeof modelClass?.getModelName !== "function") {
+            throw new Error(`Sync resources must be model records with a static getModelName(), got: ${String(resource)}`);
+        }
+        const resourceType = modelClass.getModelName();
+        const resourceConfig = this.config.resources[resourceType];
+        if (!resourceConfig)
+            throw new Error(`No sync resource configured for: ${resourceType}`);
+        return resourceConfig;
+    }
+    /**
+     * Resolves the sync type for a mutation through the resource config.
+     * @param {{operation: "create" | "update" | "destroy", record: ?, resourceConfig: import("./sync-client-types.js").SyncClientResourceConfig}} args - Mutation args.
+     * @returns {string} Sync type.
+     */
+    defaultSyncType({ operation, record, resourceConfig }) {
+        if (resourceConfig.syncType)
+            return resourceConfig.syncType({ operation, record });
+        if (operation === "destroy")
+            return "delete";
+        return operation;
+    }
+    /**
+     * Derives the pull-apply resource configs from the declared resources.
+     * @returns {Record<string, import("./sync-api-client-types.js").SyncResourceConfig>} Pull-apply resource configs.
+     */
+    pullResourceConfigs() {
+        this._pullResourceConfigs ||= /** @type {Record<string, import("./sync-api-client-types.js").SyncResourceConfig>} */ (Object.fromEntries(Object.entries(this.config.resources)
+            .filter(([, resource]) => Boolean(resource.attributes))
+            .map(([resourceType, resource]) => [resourceType, {
+                afterApply: resource.afterApply,
+                attributes: /** @type {import("./sync-api-client-types.js").SyncResourceConfig["attributes"]} */ (resource.attributes),
+                enabled: true,
+                findRecord: resource.findRecord,
+                findRecordForDelete: resource.findRecordForDelete,
+                modelClass: resource.modelClass
+            }])));
+        return this._pullResourceConfigs;
+    }
+}
+/**
+ * Declares a sync scope on the current sync client.
+ * @param {import("../database/query/model-class-query.js").default<?>} query - Query declaring the sync scope.
+ * @returns {Promise<{scope: import("./sync-client-types.js").SerializedSyncScope, pulled: import("./sync-api-client-types.js").SyncChangesResult | null}>} Declared scope and pull result.
+ */
+export async function sync(query) {
+    return await SyncClient.current().sync(query);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-client.js","sourceRoot":"","sources":["../../../src/sync/sync-client.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {forcedFunction} from \"typanic\"\n\nimport Configuration from \"../configuration.js\"\n\nimport {serializedScopeFromQuery} from \"./query-scope.js\"\nimport SyncApiClient from \"./sync-api-client.js\"\nimport SyncScopeStore from \"./sync-scope-store.js\"\nimport {currentSyncClient, setCurrentSyncClient} from \"./sync-client-registry.js\"\n\nlet clientCounter = 0\n\n/** @type {{create: \"afterCreate\", update: \"afterUpdate\", destroy: \"afterDestroy\"}} */\nconst TRACKED_CALLBACK_NAMES = {create: \"afterCreate\", destroy: \"afterDestroy\", update: \"afterUpdate\"}\n\n/**\n * Declarative client-side sync driver.\n *\n * Apps configure resources, transport, auth, and connectivity once; Velocious\n * owns scope persistence, per-scope cursors, pull paging/apply, local queueing,\n * and online-gated replay. Declare sync interest from queries:\n *\n *     const syncClient = new SyncClient({...})\n *     syncClient.setCurrent()\n *     await syncClient.sync(Event.where({partnerId}))\n */\nexport default class SyncClient {\n  /**\n   * Creates a declarative sync client.\n   * @param {import(\"./sync-client-types.js\").SyncClientConfig} config - Sync client configuration.\n   */\n  constructor(config) {\n    if (!config || typeof config !== \"object\") throw new Error(\"SyncClient requires a configuration object\")\n\n    forcedFunction(config.postChanges, \"SyncClient config.postChanges\")\n    forcedFunction(config.postReplay, \"SyncClient config.postReplay\")\n    forcedFunction(config.authenticationToken, \"SyncClient config.authenticationToken\")\n\n    if (!config.syncModel) throw new Error(\"SyncClient requires config.syncModel\")\n    if (!config.resources || typeof config.resources !== \"object\" || Object.keys(config.resources).length === 0) {\n      throw new Error(\"SyncClient requires at least one entry in config.resources\")\n    }\n\n    for (const [resourceType, resource] of Object.entries(config.resources)) {\n      if (!resource || typeof resource !== \"object\" || !resource.modelClass) {\n        throw new Error(`SyncClient resource ${resourceType} must declare a modelClass`)\n      }\n    }\n\n    this.config = config\n    this._clientNumber = ++clientCounter\n    /** @type {import(\"./sync-scope-store.js\").default | null} */\n    this._scopeStore = config.scopeStore || null\n    /** @type {Promise<void> | null} */\n    this._scheduledReplay = null\n    /** @type {Record<string, import(\"./sync-api-client-types.js\").SyncResourceConfig> | null} */\n    this._pullResourceConfigs = null\n    /** @type {Array<{callback: (record: ?) => Promise<void>, callbackName: \"afterCreate\" | \"afterUpdate\" | \"afterDestroy\", modelClass: ?}>} */\n    this._trackedCallbacks = []\n    /** @type {WeakSet<object>} */\n    this._remoteApplyRecords = new WeakSet()\n    this._started = false\n  }\n\n  /**\n   * Registers automatic mutation tracking for every resource with `track` enabled:\n   * local model creates/updates/destroys queue pending sync rows and schedule an\n   * immediate replay attempt, without app-side queue calls.\n   * @returns {Promise<void>}\n   */\n  async start() {\n    if (this._started) return\n\n    this._started = true\n\n    for (const [resourceType, resourceConfig] of Object.entries(this.config.resources)) {\n      const operations = this.trackedOperations({resourceConfig, resourceType})\n\n      for (const operation of operations) {\n        const callbackName = TRACKED_CALLBACK_NAMES[operation]\n        const callback = this.trackedMutationCallback({operation, resourceConfig})\n\n        resourceConfig.modelClass[callbackName](callback)\n        this._trackedCallbacks.push({callback, callbackName, modelClass: resourceConfig.modelClass})\n      }\n    }\n  }\n\n  /**\n   * Unregisters all tracking callbacks (tests, sign-out, hot reload).\n   * @returns {void}\n   */\n  stop() {\n    for (const {callback, callbackName, modelClass} of this._trackedCallbacks) {\n      modelClass.unregisterLifecycleCallback(callbackName, callback)\n    }\n\n    this._trackedCallbacks = []\n    this._started = false\n  }\n\n  /**\n   * Resolves and validates the tracked operations for a resource config.\n   * @param {{resourceConfig: import(\"./sync-client-types.js\").SyncClientResourceConfig, resourceType: string}} args - Resource config and name.\n   * @returns {Array<\"create\" | \"update\" | \"destroy\">} Tracked operations.\n   */\n  trackedOperations({resourceConfig, resourceType}) {\n    const track = resourceConfig.track\n\n    if (track === undefined || track === false) return []\n    if (track === true) return [\"create\", \"update\", \"destroy\"]\n\n    if (!track || typeof track !== \"object\" || !Array.isArray(track.operations) || track.operations.length === 0) {\n      throw new Error(`SyncClient resource ${resourceType} track must be true or {operations: [...]}`)\n    }\n\n    for (const operation of track.operations) {\n      if (!(operation in TRACKED_CALLBACK_NAMES)) {\n        throw new Error(`SyncClient resource ${resourceType} track.operations must be create/update/destroy, got: ${String(operation)}`)\n      }\n    }\n\n    return track.operations\n  }\n\n  /**\n   * Builds the lifecycle callback queueing one tracked mutation.\n   * @param {{operation: \"create\" | \"update\" | \"destroy\", resourceConfig: import(\"./sync-client-types.js\").SyncClientResourceConfig}} args - Operation and resource config.\n   * @returns {(record: ?) => Promise<void>} Lifecycle callback.\n   */\n  trackedMutationCallback({operation, resourceConfig}) {\n    return async (record) => {\n      if (this.isRemoteApply(record)) return\n\n      await SyncApiClient.queueLocalSync({\n        booleanAttributes: resourceConfig.booleanAttributes || [],\n        data: resourceConfig.trackedData ? resourceConfig.trackedData({operation, record}) : undefined,\n        localOnlyAttributes: resourceConfig.localOnlyAttributes || [],\n        resource: record,\n        syncModel: this.config.syncModel,\n        syncType: this.defaultSyncType({operation, record, resourceConfig})\n      })\n\n      this.scheduleReplay()\n    }\n  }\n\n  /**\n   * Whether a record is currently being written by pull-apply (echo suppression).\n   * @param {?} record - Local model record.\n   * @returns {boolean} Whether the record write originates from a remote change.\n   */\n  isRemoteApply(record) {\n    return this._remoteApplyRecords.has(record)\n  }\n\n  /**\n   * Registers this client as the app's current sync client.\n   * @returns {void}\n   */\n  setCurrent() {\n    setCurrentSyncClient(this)\n  }\n\n  /**\n   * Returns the app's current sync client.\n   * @returns {SyncClient} Current sync client.\n   */\n  static current() {\n    return /** @type {SyncClient} */ (currentSyncClient())\n  }\n\n  /**\n   * Declares (or re-activates) a sync scope from a model query and pulls it when online.\n   * @param {import(\"../database/query/model-class-query.js\").default<?>} query - Query declaring the sync scope.\n   * @returns {Promise<{scope: import(\"./sync-client-types.js\").SerializedSyncScope, pulled: import(\"./sync-api-client-types.js\").SyncChangesResult | null}>} Declared scope and pull result (null while offline).\n   */\n  async sync(query) {\n    const scope = serializedScopeFromQuery(query)\n    const scopeStore = this.scopeStore()\n    const scopeRow = await scopeStore.findOrCreateScope(scope)\n\n    if (!scopeRow.cursorPayload && this.config.legacyCursor) {\n      const legacyCursorPayload = await this.config.legacyCursor({scope})\n      const legacyCursor = SyncApiClient.syncCursorFromPayload(legacyCursorPayload)\n\n      if (legacyCursor) await scopeStore.saveCursor(scopeRow, legacyCursor)\n    }\n\n    return {pulled: await this.pull(), scope}\n  }\n\n  /**\n   * Deactivates the sync scope declared by a model query.\n   * @param {import(\"../database/query/model-class-query.js\").default<?>} query - Query whose scope should stop syncing.\n   * @returns {Promise<void>}\n   */\n  async unsync(query) {\n    await this.scopeStore().deactivate(serializedScopeFromQuery(query))\n  }\n\n  /**\n   * Pulls changes for every active scope with per-scope cursors (single-flighted, online-gated).\n   * @returns {Promise<import(\"./sync-api-client-types.js\").SyncChangesResult | null>} Combined pull result, or null while offline.\n   */\n  async pull() {\n    if (!(await this.isOnline())) return null\n\n    /** @type {import(\"./sync-api-client-types.js\").SyncChangesResult | null} */\n    let combinedResult = null\n\n    await SyncApiClient.singleFlight(`velocious-sync-client-pull-${this._clientNumber}`, async () => {\n      const authenticationToken = await this.config.authenticationToken()\n      const scopeStore = this.scopeStore()\n      const pullResourceConfigs = this.pullResourceConfigs()\n      const applier = SyncApiClient.resourceApplier(pullResourceConfigs, (record) => {\n        this._remoteApplyRecords.add(record)\n\n        return () => this._remoteApplyRecords.delete(record)\n      })\n      /**\n       * Applies one pulled change, failing loudly instead of silently skipping unconfigured resources.\n       * @param {import(\"./sync-api-client-types.js\").SyncChangeEnvelope} sync - Pulled change.\n       * @returns {Promise<import(\"./sync-api-client-types.js\").SyncChangeApplyResult>} Apply result.\n       */\n      const applySync = async (sync) => {\n        const resourceType = sync.resourceType()\n\n        if (!resourceType || !pullResourceConfigs[resourceType]) {\n          throw new Error(`No sync resource with pull attributes configured for pulled change: ${String(resourceType)}`)\n        }\n\n        return await applier(sync)\n      }\n      const result = {\n        changed: false,\n        pages: 0,\n        resourceChanged: /** @type {Record<string, boolean>} */ ({}),\n        resourceCounts: /** @type {Record<string, number>} */ ({}),\n        syncedCount: 0\n      }\n\n      for (const scopeRow of await scopeStore.activeScopes()) {\n        const scopeResult = await SyncApiClient.pullChanges({\n          applySync,\n          authenticationToken,\n          batchSize: this.config.batchSize,\n          loadCursor: async () => await scopeStore.loadCursor(scopeRow),\n          postChanges: async (payload) => await this.config.postChanges({\n            ...payload,\n            scope: {conditions: scopeRow.conditions, resourceType: scopeRow.resourceType}\n          }),\n          saveCursor: async (cursor) => await scopeStore.saveCursor(scopeRow, cursor)\n        })\n\n        result.changed ||= scopeResult.changed\n        result.pages += scopeResult.pages\n        result.syncedCount += scopeResult.syncedCount\n\n        for (const [resourceType, count] of Object.entries(scopeResult.resourceCounts)) {\n          result.resourceCounts[resourceType] = (result.resourceCounts[resourceType] || 0) + count\n        }\n        for (const [resourceType, changed] of Object.entries(scopeResult.resourceChanged)) {\n          result.resourceChanged[resourceType] ||= changed\n        }\n      }\n\n      combinedResult = result\n    })\n\n    return combinedResult\n  }\n\n  /**\n   * Queues a local model change as a pending sync row and schedules an immediate\n   * replay attempt (kept pending while offline or when the backend rejects it).\n   * @param {{resource: ?, data?: Record<string, ?>, syncType?: string}} args - Queue args.\n   * @returns {Promise<?>} Pending local sync row.\n   */\n  async queue({data, resource, syncType}) {\n    const resourceConfig = this.resourceConfigFor(resource)\n    const syncRow = await SyncApiClient.queueLocalSync({\n      booleanAttributes: resourceConfig.booleanAttributes || [],\n      data,\n      localOnlyAttributes: resourceConfig.localOnlyAttributes || [],\n      resource,\n      syncModel: this.config.syncModel,\n      syncType: syncType ?? this.defaultSyncType({operation: \"update\", record: resource, resourceConfig})\n    })\n\n    this.scheduleReplay()\n\n    return syncRow\n  }\n\n  /**\n   * Drains pending local sync rows to the backend (single-flighted, online-gated).\n   * Rows are only marked successful after the backend acknowledges them.\n   * @returns {Promise<void>}\n   */\n  async replayPending() {\n    if (!(await this.isOnline())) return\n\n    await SyncApiClient.singleFlight(`velocious-sync-client-replay-${this._clientNumber}`, async () => {\n      await SyncApiClient.replayLocalSyncs({\n        authenticationToken: await this.config.authenticationToken(),\n        batchSize: this.config.batchSize,\n        postReplay: this.config.postReplay,\n        syncModel: this.config.syncModel\n      })\n    })\n  }\n\n  /**\n   * Schedules a background replay attempt without blocking the caller.\n   * Failures go to config.onError (or rethrow when none is configured).\n   * @returns {void}\n   */\n  scheduleReplay() {\n    this._scheduledReplay = (async () => {\n      try {\n        await this.replayPending()\n      } catch (error) {\n        this.reportError(/** @type {Error} */ (error))\n      }\n    })()\n  }\n\n  /**\n   * Awaits the last scheduled background replay (useful in tests and shutdown flows).\n   * @returns {Promise<void>}\n   */\n  async waitForScheduledReplay() {\n    if (this._scheduledReplay) await this._scheduledReplay\n  }\n\n  /**\n   * Reports a background sync failure.\n   * @param {Error} error - Background failure.\n   * @returns {void}\n   */\n  reportError(error) {\n    if (this.config.onError) {\n      this.config.onError(error)\n      return\n    }\n\n    throw error\n  }\n\n  /**\n   * Resolves connectivity through the configured gate.\n   * @returns {Promise<boolean>} Whether the backend is considered reachable.\n   */\n  async isOnline() {\n    if (!this.config.isOnline) return true\n\n    return (await this.config.isOnline()) !== false\n  }\n\n  /**\n   * Returns the scope store backing declared scopes and cursors.\n   * @returns {import(\"./sync-scope-store.js\").default} Scope store.\n   */\n  scopeStore() {\n    this._scopeStore ||= new SyncScopeStore({configuration: this.config.configuration || Configuration.current()})\n\n    return this._scopeStore\n  }\n\n  /**\n   * Resolves the declared resource config for a local record.\n   * @param {?} resource - Local model record.\n   * @returns {import(\"./sync-client-types.js\").SyncClientResourceConfig} Declared resource config.\n   */\n  resourceConfigFor(resource) {\n    const modelClass = resource?.constructor\n\n    if (typeof modelClass?.getModelName !== \"function\") {\n      throw new Error(`Sync resources must be model records with a static getModelName(), got: ${String(resource)}`)\n    }\n\n    const resourceType = modelClass.getModelName()\n    const resourceConfig = this.config.resources[resourceType]\n\n    if (!resourceConfig) throw new Error(`No sync resource configured for: ${resourceType}`)\n\n    return resourceConfig\n  }\n\n  /**\n   * Resolves the sync type for a mutation through the resource config.\n   * @param {{operation: \"create\" | \"update\" | \"destroy\", record: ?, resourceConfig: import(\"./sync-client-types.js\").SyncClientResourceConfig}} args - Mutation args.\n   * @returns {string} Sync type.\n   */\n  defaultSyncType({operation, record, resourceConfig}) {\n    if (resourceConfig.syncType) return resourceConfig.syncType({operation, record})\n    if (operation === \"destroy\") return \"delete\"\n\n    return operation\n  }\n\n  /**\n   * Derives the pull-apply resource configs from the declared resources.\n   * @returns {Record<string, import(\"./sync-api-client-types.js\").SyncResourceConfig>} Pull-apply resource configs.\n   */\n  pullResourceConfigs() {\n    this._pullResourceConfigs ||= /** @type {Record<string, import(\"./sync-api-client-types.js\").SyncResourceConfig>} */ (Object.fromEntries(\n      Object.entries(this.config.resources)\n        .filter(([, resource]) => Boolean(resource.attributes))\n        .map(([resourceType, resource]) => [resourceType, {\n          afterApply: resource.afterApply,\n          attributes: /** @type {import(\"./sync-api-client-types.js\").SyncResourceConfig[\"attributes\"]} */ (resource.attributes),\n          enabled: true,\n          findRecord: resource.findRecord,\n          findRecordForDelete: resource.findRecordForDelete,\n          modelClass: resource.modelClass\n        }])\n    ))\n\n    return this._pullResourceConfigs\n  }\n}\n\n/**\n * Declares a sync scope on the current sync client.\n * @param {import(\"../database/query/model-class-query.js\").default<?>} query - Query declaring the sync scope.\n * @returns {Promise<{scope: import(\"./sync-client-types.js\").SerializedSyncScope, pulled: import(\"./sync-api-client-types.js\").SyncChangesResult | null}>} Declared scope and pull result.\n */\nexport async function sync(query) {\n  return await SyncClient.current().sync(query)\n}\n"]}

package/build/src/sync/sync-envelope-replay-service.d.ts

@@ -10,19 +10,32 @@
 export default class SyncEnvelopeReplayService {
     /**
      * Creates a sync envelope replay service.
+     *
+     * When a sync model is given, `findExistingReplaySync` and
+     * `persistReplayMutation` get model-backed default implementations. The sync
+     * model must expose `findBy`/`create` statics plus instance
+     * `assign`/`save`/`clientUpdatedAt` and `advanceServerSequence` (the
+     * change-feed sequence contract), and the actor returned from
+     * `authenticateReplay` must expose an `id()` method.
      * @param {object} [args] - Constructor arguments.
      * @param {{debug?: (...args: Array<unknown>) => void, warn?: (...args: Array<unknown>) => void}} [args.logger] - Logger used for normalization warnings.
+     * @param {?} [args.syncModel] - Sync/change model enabling model-backed default hooks.
+     * @param {string} [args.actorForeignKeyColumn] - Sync model column linking rows to the replay actor.
      */
     constructor(args?: {
         logger?: {
             debug?: (...args: Array<unknown>) => void;
             warn?: (...args: Array<unknown>) => void;
         } | undefined;
+        syncModel?: unknown;
+        actorForeignKeyColumn?: string | undefined;
     });
     logger: {
         debug?: (...args: Array<unknown>) => void;
         warn?: (...args: Array<unknown>) => void;
     };
+    syncModel: any;
+    actorForeignKeyColumn: string;
     /**
      * Replays a sync batch.
      * @param {Record<string, ?>} params - Request params carrying authentication and syncs.
@@ -106,14 +119,23 @@ export default class SyncEnvelopeReplayService {
     }>;
     /**
      * Loads the previously stored sync/change row for stale-client comparison.
-     * @param {{actor: ?, context: Record<string, ?>, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} _args - Actor, batch context, and mutation.
+     *
+     * Defaults to a sync-model lookup by actor and resource identity when a sync
+     * model is configured; otherwise apps override this hook.
+     * @param {{actor: ?, context: Record<string, ?>, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} args - Actor, batch context, and mutation.
      * @returns {Promise<?>} Existing sync row.
      */
-    findExistingReplaySync(_args: {
+    findExistingReplaySync({ actor, mutation }: {
         actor: unknown;
         context: Record<string, unknown>;
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
     }): Promise<unknown>;
+    /**
+     * Resolves the persisted actor id used by model-backed default hooks.
+     * @param {?} actor - Actor returned from authenticateReplay.
+     * @returns {?} Actor id.
+     */
+    replayActorId(actor: unknown): unknown;
     /**
      * Returns whether a normalized mutation should be applied to domain models.
      * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} args - Actor, batch context, existing sync row, and mutation.
@@ -155,10 +177,13 @@ export default class SyncEnvelopeReplayService {
     }): Promise<unknown>;
     /**
      * Persists one normalized mutation into the app sync/change store.
-     * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation, shouldApply: boolean}} _args - Replay persistence arguments.
+     *
+     * Defaults to a stale-guarded sync-model upsert (with server re-sequencing on
+     * updates) when a sync model is configured; otherwise apps override this hook.
+     * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation, shouldApply: boolean}} args - Replay persistence arguments.
      * @returns {Promise<void>}
      */
-    persistReplayMutation(_args: {
+    persistReplayMutation({ actor, existingSync, mutation }: {
         actor: unknown;
         context: Record<string, unknown>;
         existingSync: unknown;
@@ -166,6 +191,15 @@ export default class SyncEnvelopeReplayService {
         mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
         shouldApply: boolean;
     }): Promise<void>;
+    /**
+     * Builds the sync-model attributes persisted by the model-backed default.
+     * @param {{actor: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation}} args - Actor and mutation.
+     * @returns {Record<string, ?>} Sync row attributes.
+     */
+    replayPersistAttributes({ actor, mutation }: {
+        actor: unknown;
+        mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation;
+    }): Record<string, unknown>;
     /**
      * Runs side effects after a successful mutation replay and persistence.
      * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import("./sync-envelope-replay-service.js").SyncReplayMutation, shouldApply: boolean}} _args - Replay side-effect arguments.

package/build/src/sync/sync-envelope-replay-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sync-envelope-replay-service.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-envelope-replay-service.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"sync-envelope-replay-service.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-envelope-replay-service.js"],"names":[],"mappings":"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"}