velocious 1.0.489 → 1.0.492

package/build/src/sync/sync-envelope-replay-service.js

@@ -11,11 +11,25 @@
 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 = {}) {
         this.logger = args.logger || console;
+        this.syncModel = args.syncModel || null;
+        this.actorForeignKeyColumn = args.actorForeignKeyColumn || "authentication_token_id";
+        if (args.actorForeignKeyColumn !== undefined && (typeof args.actorForeignKeyColumn !== "string" || args.actorForeignKeyColumn.length < 1)) {
+            throw new Error(`actorForeignKeyColumn must be a non-blank string, got: ${String(args.actorForeignKeyColumn)}`);
+        }
     }
     /**
      * Replays a sync batch.
@@ -153,11 +167,31 @@ 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.
      */
-    async findExistingReplaySync(_args) {
-        return null;
+    async findExistingReplaySync({ actor, mutation }) {
+        if (!this.syncModel)
+            return null;
+        return await this.syncModel.findBy({
+            [this.actorForeignKeyColumn]: this.replayActorId(actor),
+            resource_id: mutation.resourceId,
+            resource_type: mutation.resourceType
+        });
+    }
+    /**
+     * Resolves the persisted actor id used by model-backed default hooks.
+     * @param {?} actor - Actor returned from authenticateReplay.
+     * @returns {?} Actor id.
+     */
+    replayActorId(actor) {
+        if (!actor || typeof actor !== "object" || typeof actor.id !== "function") {
+            throw new Error("SyncEnvelopeReplayService model-backed defaults require an actor with an id() method from authenticateReplay");
+        }
+        return actor.id();
     }
     /**
      * Returns whether a normalized mutation should be applied to domain models.
@@ -205,10 +239,43 @@ export default class SyncEnvelopeReplayService {
     }
     /**
      * 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>}
      */
-    async persistReplayMutation(_args) { }
+    async persistReplayMutation({ actor, existingSync, mutation }) {
+        if (!this.syncModel)
+            return;
+        const attributes = this.replayPersistAttributes({ actor, mutation });
+        if (existingSync) {
+            const existingClientUpdatedAt = this.existingReplaySyncClientUpdatedAt(existingSync);
+            if (existingClientUpdatedAt && mutation.clientUpdatedAt <= existingClientUpdatedAt)
+                return;
+            existingSync.assign(attributes);
+            await existingSync.advanceServerSequence();
+            await existingSync.save();
+        }
+        else {
+            await this.syncModel.create(attributes);
+        }
+    }
+    /**
+     * 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 }) {
+        return {
+            [this.actorForeignKeyColumn]: this.replayActorId(actor),
+            client_updated_at: mutation.clientUpdatedAt,
+            data: mutation.serializedData,
+            resource_id: mutation.resourceId,
+            resource_type: mutation.resourceType,
+            sync_type: mutation.syncType
+        };
+    }
     /**
      * 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.
@@ -226,4 +293,4 @@ export default class SyncEnvelopeReplayService {
  * @property {string} serializedData - JSON serialized mutation payload.
  * @property {string} syncType - Sync operation type.
  */
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-envelope-replay-service.js","sourceRoot":"","sources":["../../../src/sync/sync-envelope-replay-service.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Replays client sync envelopes through project supplied authentication,\n * authorization, application, and persistence hooks.\n *\n * This is intentionally transport/model agnostic: Velocious owns the generic\n * replay loop, normalization, stale-client comparison, and per-sync result\n * shape while each app owns its token lookup, model handlers, and\n * domain authorization rules.\n */\nexport default class SyncEnvelopeReplayService {\n  /**\n   * Creates a sync envelope replay service.\n   * @param {object} [args] - Constructor arguments.\n   * @param {{debug?: (...args: Array<unknown>) => void, warn?: (...args: Array<unknown>) => void}} [args.logger] - Logger used for normalization warnings.\n   */\n  constructor(args = {}) {\n    this.logger = args.logger || console\n  }\n\n  /**\n   * Replays a sync batch.\n   * @param {Record<string, ?>} params - Request params carrying authentication and syncs.\n   * @returns {Promise<{syncs: Array<Record<string, ?>>, status?: string, errorCode?: string, errorMessage?: string}>} Replay response.\n   */\n  async replay(params) {\n    const actorResult = await this.authenticateReplay(params)\n\n    if (!actorResult.authenticated) {\n      return {\n        syncs: [],\n        status: \"error\",\n        errorCode: actorResult.errorCode,\n        errorMessage: actorResult.errorMessage\n      }\n    }\n\n    const syncResponses = []\n    const context = await this.buildReplayContext({actor: actorResult.actor, params})\n\n    for (const rawSync of this.replaySyncs(params)) {\n      const normalizedResult = this.normalizeReplaySync(rawSync)\n\n      if (!normalizedResult.ok) {\n        syncResponses.push(normalizedResult.response)\n        continue\n      }\n\n      const mutation = normalizedResult.mutation\n      const accessResult = await this.authorizeReplayMutation({actor: actorResult.actor, context, mutation})\n\n      if (!accessResult.allowed) {\n        syncResponses.push({\n          id: mutation.id,\n          syncState: \"failed\",\n          reason: accessResult.reason || \"access-denied\"\n        })\n        continue\n      }\n\n      const existingSync = await this.findExistingReplaySync({actor: actorResult.actor, context, mutation})\n      const shouldApply = await this.shouldApplyReplayMutation({actor: actorResult.actor, context, existingSync, mutation})\n      const applyResult = shouldApply\n        ? await this.applyReplayMutation({actor: actorResult.actor, context, existingSync, mutation})\n        : await this.skippedReplayMutation({actor: actorResult.actor, context, existingSync, mutation})\n\n      await this.persistReplayMutation({actor: actorResult.actor, context, existingSync, applyResult, mutation, shouldApply})\n      await this.afterReplayMutation({actor: actorResult.actor, context, existingSync, applyResult, mutation, shouldApply})\n\n      syncResponses.push({id: mutation.id, syncState: \"successful\"})\n    }\n\n    return {syncs: syncResponses}\n  }\n\n  /**\n   * Authenticates the sync batch actor.\n   * @param {Record<string, ?>} _params - Request params.\n   * @returns {Promise<{authenticated: true, actor: ?} | {authenticated: false, errorCode: string, errorMessage: string}>} Auth result.\n   */\n  async authenticateReplay(_params) {\n    throw new Error(\"SyncEnvelopeReplayService.authenticateReplay must be implemented\")\n  }\n\n  /**\n   * Builds per-batch mutable context for caches shared across sync items.\n   * @param {{actor: ?, params: Record<string, ?>}} _args - Actor and request params.\n   * @returns {Promise<Record<string, ?>>} Replay context.\n   */\n  async buildReplayContext(_args) {\n    return {}\n  }\n\n  /**\n   * Returns raw sync entries from request params.\n   * @param {Record<string, ?>} params - Request params.\n   * @returns {Array<?>} Raw sync entries.\n   */\n  replaySyncs(params) {\n    return Array.isArray(params.syncs) ? params.syncs : []\n  }\n\n  /**\n   * Normalizes one sync entry.\n   * @param {?} rawSync - Raw sync entry.\n   * @returns {{ok: true, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation} | {ok: false, response: Record<string, ?>}} Normalized mutation or failed response.\n   */\n  normalizeReplaySync(rawSync) {\n    if (!rawSync || typeof rawSync !== \"object\" || Array.isArray(rawSync)) {\n      return {ok: false, response: {id: undefined, syncState: \"failed\", reason: \"invalid-sync\"}}\n    }\n\n    const sync = /** @type {Record<string, ?>} */ (rawSync)\n    const {clientUpdatedAt, data, id, resourceId, resourceType, syncType} = sync\n\n    if (typeof resourceType !== \"string\" || resourceType.length < 1 || resourceId === undefined || resourceId === null || typeof syncType !== \"string\" || syncType.length < 1) {\n      return {ok: false, response: {id, syncState: \"failed\", reason: \"invalid-resource-id\"}}\n    }\n\n    const resourceIdString = String(resourceId)\n    let clientUpdatedAtDate = typeof clientUpdatedAt === \"string\" || clientUpdatedAt instanceof Date ? new Date(clientUpdatedAt) : new Date()\n\n    if (Number.isNaN(clientUpdatedAtDate.getTime())) clientUpdatedAtDate = new Date()\n\n    const normalizedDataResult = this.normalizeReplaySyncData({data, id, resourceId: resourceIdString, resourceType})\n\n    if (!normalizedDataResult.ok) return normalizedDataResult\n\n    return {\n      ok: true,\n      mutation: {\n        clientUpdatedAt: clientUpdatedAtDate,\n        data: normalizedDataResult.data,\n        id,\n        resourceId: resourceIdString,\n        resourceType,\n        serializedData: JSON.stringify(normalizedDataResult.data),\n        syncType\n      }\n    }\n  }\n\n  /**\n   * Normalizes one sync data payload.\n   * @param {{data: ?, id: ?, resourceId: string, resourceType: string}} args - Sync payload normalization arguments.\n   * @returns {{ok: true, data: Record<string, ?>} | {ok: false, response: Record<string, ?>}} Normalized payload or failed response.\n   */\n  normalizeReplaySyncData({data, id, resourceId, resourceType}) {\n    if (data === undefined || data === null) return {ok: true, data: {}}\n\n    if (typeof data === \"string\") {\n      try {\n        const parsedData = JSON.parse(data)\n\n        if (!parsedData || typeof parsedData !== \"object\" || Array.isArray(parsedData)) return {ok: true, data: {}}\n\n        return {ok: true, data: /** @type {Record<string, ?>} */ (parsedData)}\n      } catch (error) {\n        this.logger.warn?.(\"Invalid sync data JSON\", {error, id, resourceId, resourceType})\n        return {ok: false, response: {id, syncState: \"failed\", reason: \"invalid-data\"}}\n      }\n    }\n\n    if (typeof data !== \"object\" || Array.isArray(data)) return {ok: true, data: {}}\n\n    return {ok: true, data: JSON.parse(JSON.stringify(data))}\n  }\n\n  /**\n   * Authorizes one normalized mutation.\n   * @param {{actor: ?, context: Record<string, ?>, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} _args - Actor, batch context, and mutation.\n   * @returns {Promise<{allowed: boolean, reason?: string}>} Access result.\n   */\n  async authorizeReplayMutation(_args) {\n    return {allowed: true}\n  }\n\n  /**\n   * Loads the previously stored sync/change row for stale-client comparison.\n   * @param {{actor: ?, context: Record<string, ?>, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} _args - Actor, batch context, and mutation.\n   * @returns {Promise<?>} Existing sync row.\n   */\n  async findExistingReplaySync(_args) {\n    return null\n  }\n\n  /**\n   * Returns whether a normalized mutation should be applied to domain models.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} args - Actor, batch context, existing sync row, and mutation.\n   * @returns {Promise<boolean>} Whether to apply the mutation.\n   */\n  async shouldApplyReplayMutation({existingSync, mutation}) {\n    const existingClientUpdatedAt = this.existingReplaySyncClientUpdatedAt(existingSync)\n\n    return !existingClientUpdatedAt || mutation.clientUpdatedAt > existingClientUpdatedAt\n  }\n\n  /**\n   * Resolves the client timestamp from an existing sync row.\n   * @param {?} existingSync - Existing sync row.\n   * @returns {Date | null} Existing client timestamp.\n   */\n  existingReplaySyncClientUpdatedAt(existingSync) {\n    if (!existingSync || typeof existingSync !== \"object\") return null\n\n    const syncRecord = /** @type {Record<string, ?>} */ (existingSync)\n    const value = typeof syncRecord.clientUpdatedAt === \"function\"\n      ? syncRecord.clientUpdatedAt()\n      : syncRecord.clientUpdatedAt\n\n    if (value instanceof Date) return value\n\n    if (typeof value !== \"string\") return null\n\n    const parsedValue = new Date(value)\n\n    return Number.isNaN(parsedValue.getTime()) ? null : parsedValue\n  }\n\n  /**\n   * Applies one normalized mutation to domain models.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} _args - Actor, batch context, existing sync row, and mutation.\n   * @returns {Promise<?>} Project-specific apply result.\n   */\n  async applyReplayMutation(_args) {\n    return null\n  }\n\n  /**\n   * Resolves an apply result for stale mutations that should not touch domain models.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} _args - Actor, batch context, existing sync row, and mutation.\n   * @returns {Promise<?>} Project-specific apply result.\n   */\n  async skippedReplayMutation(_args) {\n    return null\n  }\n\n  /**\n   * Persists one normalized mutation into the app sync/change store.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation, shouldApply: boolean}} _args - Replay persistence arguments.\n   * @returns {Promise<void>}\n   */\n  async persistReplayMutation(_args) {}\n\n  /**\n   * Runs side effects after a successful mutation replay and persistence.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation, shouldApply: boolean}} _args - Replay side-effect arguments.\n   * @returns {Promise<void>}\n   */\n  async afterReplayMutation(_args) {}\n}\n\n/**\n * @typedef {object} SyncReplayMutation\n * @property {Date} clientUpdatedAt - Client-side mutation timestamp.\n * @property {Record<string, ?>} data - Parsed mutation payload.\n * @property {?} id - Client sync row id for per-sync responses.\n * @property {string} resourceId - Resource id as a string.\n * @property {string} resourceType - Resource/model name.\n * @property {string} serializedData - JSON serialized mutation payload.\n * @property {string} syncType - Sync operation type.\n */\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-envelope-replay-service.js","sourceRoot":"","sources":["../../../src/sync/sync-envelope-replay-service.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Replays client sync envelopes through project supplied authentication,\n * authorization, application, and persistence hooks.\n *\n * This is intentionally transport/model agnostic: Velocious owns the generic\n * replay loop, normalization, stale-client comparison, and per-sync result\n * shape while each app owns its token lookup, model handlers, and\n * domain authorization rules.\n */\nexport default class SyncEnvelopeReplayService {\n  /**\n   * Creates a sync envelope replay service.\n   *\n   * When a sync model is given, `findExistingReplaySync` and\n   * `persistReplayMutation` get model-backed default implementations. The sync\n   * model must expose `findBy`/`create` statics plus instance\n   * `assign`/`save`/`clientUpdatedAt` and `advanceServerSequence` (the\n   * change-feed sequence contract), and the actor returned from\n   * `authenticateReplay` must expose an `id()` method.\n   * @param {object} [args] - Constructor arguments.\n   * @param {{debug?: (...args: Array<unknown>) => void, warn?: (...args: Array<unknown>) => void}} [args.logger] - Logger used for normalization warnings.\n   * @param {?} [args.syncModel] - Sync/change model enabling model-backed default hooks.\n   * @param {string} [args.actorForeignKeyColumn] - Sync model column linking rows to the replay actor.\n   */\n  constructor(args = {}) {\n    this.logger = args.logger || console\n    this.syncModel = args.syncModel || null\n    this.actorForeignKeyColumn = args.actorForeignKeyColumn || \"authentication_token_id\"\n\n    if (args.actorForeignKeyColumn !== undefined && (typeof args.actorForeignKeyColumn !== \"string\" || args.actorForeignKeyColumn.length < 1)) {\n      throw new Error(`actorForeignKeyColumn must be a non-blank string, got: ${String(args.actorForeignKeyColumn)}`)\n    }\n  }\n\n  /**\n   * Replays a sync batch.\n   * @param {Record<string, ?>} params - Request params carrying authentication and syncs.\n   * @returns {Promise<{syncs: Array<Record<string, ?>>, status?: string, errorCode?: string, errorMessage?: string}>} Replay response.\n   */\n  async replay(params) {\n    const actorResult = await this.authenticateReplay(params)\n\n    if (!actorResult.authenticated) {\n      return {\n        syncs: [],\n        status: \"error\",\n        errorCode: actorResult.errorCode,\n        errorMessage: actorResult.errorMessage\n      }\n    }\n\n    const syncResponses = []\n    const context = await this.buildReplayContext({actor: actorResult.actor, params})\n\n    for (const rawSync of this.replaySyncs(params)) {\n      const normalizedResult = this.normalizeReplaySync(rawSync)\n\n      if (!normalizedResult.ok) {\n        syncResponses.push(normalizedResult.response)\n        continue\n      }\n\n      const mutation = normalizedResult.mutation\n      const accessResult = await this.authorizeReplayMutation({actor: actorResult.actor, context, mutation})\n\n      if (!accessResult.allowed) {\n        syncResponses.push({\n          id: mutation.id,\n          syncState: \"failed\",\n          reason: accessResult.reason || \"access-denied\"\n        })\n        continue\n      }\n\n      const existingSync = await this.findExistingReplaySync({actor: actorResult.actor, context, mutation})\n      const shouldApply = await this.shouldApplyReplayMutation({actor: actorResult.actor, context, existingSync, mutation})\n      const applyResult = shouldApply\n        ? await this.applyReplayMutation({actor: actorResult.actor, context, existingSync, mutation})\n        : await this.skippedReplayMutation({actor: actorResult.actor, context, existingSync, mutation})\n\n      await this.persistReplayMutation({actor: actorResult.actor, context, existingSync, applyResult, mutation, shouldApply})\n      await this.afterReplayMutation({actor: actorResult.actor, context, existingSync, applyResult, mutation, shouldApply})\n\n      syncResponses.push({id: mutation.id, syncState: \"successful\"})\n    }\n\n    return {syncs: syncResponses}\n  }\n\n  /**\n   * Authenticates the sync batch actor.\n   * @param {Record<string, ?>} _params - Request params.\n   * @returns {Promise<{authenticated: true, actor: ?} | {authenticated: false, errorCode: string, errorMessage: string}>} Auth result.\n   */\n  async authenticateReplay(_params) {\n    throw new Error(\"SyncEnvelopeReplayService.authenticateReplay must be implemented\")\n  }\n\n  /**\n   * Builds per-batch mutable context for caches shared across sync items.\n   * @param {{actor: ?, params: Record<string, ?>}} _args - Actor and request params.\n   * @returns {Promise<Record<string, ?>>} Replay context.\n   */\n  async buildReplayContext(_args) {\n    return {}\n  }\n\n  /**\n   * Returns raw sync entries from request params.\n   * @param {Record<string, ?>} params - Request params.\n   * @returns {Array<?>} Raw sync entries.\n   */\n  replaySyncs(params) {\n    return Array.isArray(params.syncs) ? params.syncs : []\n  }\n\n  /**\n   * Normalizes one sync entry.\n   * @param {?} rawSync - Raw sync entry.\n   * @returns {{ok: true, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation} | {ok: false, response: Record<string, ?>}} Normalized mutation or failed response.\n   */\n  normalizeReplaySync(rawSync) {\n    if (!rawSync || typeof rawSync !== \"object\" || Array.isArray(rawSync)) {\n      return {ok: false, response: {id: undefined, syncState: \"failed\", reason: \"invalid-sync\"}}\n    }\n\n    const sync = /** @type {Record<string, ?>} */ (rawSync)\n    const {clientUpdatedAt, data, id, resourceId, resourceType, syncType} = sync\n\n    if (typeof resourceType !== \"string\" || resourceType.length < 1 || resourceId === undefined || resourceId === null || typeof syncType !== \"string\" || syncType.length < 1) {\n      return {ok: false, response: {id, syncState: \"failed\", reason: \"invalid-resource-id\"}}\n    }\n\n    const resourceIdString = String(resourceId)\n    let clientUpdatedAtDate = typeof clientUpdatedAt === \"string\" || clientUpdatedAt instanceof Date ? new Date(clientUpdatedAt) : new Date()\n\n    if (Number.isNaN(clientUpdatedAtDate.getTime())) clientUpdatedAtDate = new Date()\n\n    const normalizedDataResult = this.normalizeReplaySyncData({data, id, resourceId: resourceIdString, resourceType})\n\n    if (!normalizedDataResult.ok) return normalizedDataResult\n\n    return {\n      ok: true,\n      mutation: {\n        clientUpdatedAt: clientUpdatedAtDate,\n        data: normalizedDataResult.data,\n        id,\n        resourceId: resourceIdString,\n        resourceType,\n        serializedData: JSON.stringify(normalizedDataResult.data),\n        syncType\n      }\n    }\n  }\n\n  /**\n   * Normalizes one sync data payload.\n   * @param {{data: ?, id: ?, resourceId: string, resourceType: string}} args - Sync payload normalization arguments.\n   * @returns {{ok: true, data: Record<string, ?>} | {ok: false, response: Record<string, ?>}} Normalized payload or failed response.\n   */\n  normalizeReplaySyncData({data, id, resourceId, resourceType}) {\n    if (data === undefined || data === null) return {ok: true, data: {}}\n\n    if (typeof data === \"string\") {\n      try {\n        const parsedData = JSON.parse(data)\n\n        if (!parsedData || typeof parsedData !== \"object\" || Array.isArray(parsedData)) return {ok: true, data: {}}\n\n        return {ok: true, data: /** @type {Record<string, ?>} */ (parsedData)}\n      } catch (error) {\n        this.logger.warn?.(\"Invalid sync data JSON\", {error, id, resourceId, resourceType})\n        return {ok: false, response: {id, syncState: \"failed\", reason: \"invalid-data\"}}\n      }\n    }\n\n    if (typeof data !== \"object\" || Array.isArray(data)) return {ok: true, data: {}}\n\n    return {ok: true, data: JSON.parse(JSON.stringify(data))}\n  }\n\n  /**\n   * Authorizes one normalized mutation.\n   * @param {{actor: ?, context: Record<string, ?>, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} _args - Actor, batch context, and mutation.\n   * @returns {Promise<{allowed: boolean, reason?: string}>} Access result.\n   */\n  async authorizeReplayMutation(_args) {\n    return {allowed: true}\n  }\n\n  /**\n   * Loads the previously stored sync/change row for stale-client comparison.\n   *\n   * Defaults to a sync-model lookup by actor and resource identity when a sync\n   * model is configured; otherwise apps override this hook.\n   * @param {{actor: ?, context: Record<string, ?>, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} args - Actor, batch context, and mutation.\n   * @returns {Promise<?>} Existing sync row.\n   */\n  async findExistingReplaySync({actor, mutation}) {\n    if (!this.syncModel) return null\n\n    return await this.syncModel.findBy({\n      [this.actorForeignKeyColumn]: this.replayActorId(actor),\n      resource_id: mutation.resourceId,\n      resource_type: mutation.resourceType\n    })\n  }\n\n  /**\n   * Resolves the persisted actor id used by model-backed default hooks.\n   * @param {?} actor - Actor returned from authenticateReplay.\n   * @returns {?} Actor id.\n   */\n  replayActorId(actor) {\n    if (!actor || typeof actor !== \"object\" || typeof actor.id !== \"function\") {\n      throw new Error(\"SyncEnvelopeReplayService model-backed defaults require an actor with an id() method from authenticateReplay\")\n    }\n\n    return actor.id()\n  }\n\n  /**\n   * Returns whether a normalized mutation should be applied to domain models.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} args - Actor, batch context, existing sync row, and mutation.\n   * @returns {Promise<boolean>} Whether to apply the mutation.\n   */\n  async shouldApplyReplayMutation({existingSync, mutation}) {\n    const existingClientUpdatedAt = this.existingReplaySyncClientUpdatedAt(existingSync)\n\n    return !existingClientUpdatedAt || mutation.clientUpdatedAt > existingClientUpdatedAt\n  }\n\n  /**\n   * Resolves the client timestamp from an existing sync row.\n   * @param {?} existingSync - Existing sync row.\n   * @returns {Date | null} Existing client timestamp.\n   */\n  existingReplaySyncClientUpdatedAt(existingSync) {\n    if (!existingSync || typeof existingSync !== \"object\") return null\n\n    const syncRecord = /** @type {Record<string, ?>} */ (existingSync)\n    const value = typeof syncRecord.clientUpdatedAt === \"function\"\n      ? syncRecord.clientUpdatedAt()\n      : syncRecord.clientUpdatedAt\n\n    if (value instanceof Date) return value\n\n    if (typeof value !== \"string\") return null\n\n    const parsedValue = new Date(value)\n\n    return Number.isNaN(parsedValue.getTime()) ? null : parsedValue\n  }\n\n  /**\n   * Applies one normalized mutation to domain models.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} _args - Actor, batch context, existing sync row, and mutation.\n   * @returns {Promise<?>} Project-specific apply result.\n   */\n  async applyReplayMutation(_args) {\n    return null\n  }\n\n  /**\n   * Resolves an apply result for stale mutations that should not touch domain models.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} _args - Actor, batch context, existing sync row, and mutation.\n   * @returns {Promise<?>} Project-specific apply result.\n   */\n  async skippedReplayMutation(_args) {\n    return null\n  }\n\n  /**\n   * Persists one normalized mutation into the app sync/change store.\n   *\n   * Defaults to a stale-guarded sync-model upsert (with server re-sequencing on\n   * updates) when a sync model is configured; otherwise apps override this hook.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation, shouldApply: boolean}} args - Replay persistence arguments.\n   * @returns {Promise<void>}\n   */\n  async persistReplayMutation({actor, existingSync, mutation}) {\n    if (!this.syncModel) return\n\n    const attributes = this.replayPersistAttributes({actor, mutation})\n\n    if (existingSync) {\n      const existingClientUpdatedAt = this.existingReplaySyncClientUpdatedAt(existingSync)\n\n      if (existingClientUpdatedAt && mutation.clientUpdatedAt <= existingClientUpdatedAt) return\n\n      existingSync.assign(attributes)\n      await existingSync.advanceServerSequence()\n      await existingSync.save()\n    } else {\n      await this.syncModel.create(attributes)\n    }\n  }\n\n  /**\n   * Builds the sync-model attributes persisted by the model-backed default.\n   * @param {{actor: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation}} args - Actor and mutation.\n   * @returns {Record<string, ?>} Sync row attributes.\n   */\n  replayPersistAttributes({actor, mutation}) {\n    return {\n      [this.actorForeignKeyColumn]: this.replayActorId(actor),\n      client_updated_at: mutation.clientUpdatedAt,\n      data: mutation.serializedData,\n      resource_id: mutation.resourceId,\n      resource_type: mutation.resourceType,\n      sync_type: mutation.syncType\n    }\n  }\n\n  /**\n   * Runs side effects after a successful mutation replay and persistence.\n   * @param {{actor: ?, context: Record<string, ?>, existingSync: ?, applyResult: ?, mutation: import(\"./sync-envelope-replay-service.js\").SyncReplayMutation, shouldApply: boolean}} _args - Replay side-effect arguments.\n   * @returns {Promise<void>}\n   */\n  async afterReplayMutation(_args) {}\n}\n\n/**\n * @typedef {object} SyncReplayMutation\n * @property {Date} clientUpdatedAt - Client-side mutation timestamp.\n * @property {Record<string, ?>} data - Parsed mutation payload.\n * @property {?} id - Client sync row id for per-sync responses.\n * @property {string} resourceId - Resource id as a string.\n * @property {string} resourceType - Resource/model name.\n * @property {string} serializedData - JSON serialized mutation payload.\n * @property {string} syncType - Sync operation type.\n */\n"]}

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

@@ -0,0 +1,98 @@
+/**
+ * Optional client-declared sync scope carried on a changes request.
+ * @typedef {object} SerializedChangesScope
+ * @property {Record<string, ?>} conditions - Plain attribute conditions from the client query.
+ * @property {string} resourceType - Client resource/model name the scope was declared for.
+ */
+/**
+ * Base resource for Velocious sync endpoints.
+ *
+ * Velocious owns the changes/replay orchestration (scope parsing, feed paging,
+ * replay delegation, response shape) while apps subclass and only declare
+ * authorization, feed scoping, and their replay service.
+ * @template {typeof import("../database/record/index.js").default} [TModelClass=typeof import("../database/record/index.js").default]
+ * @augments {FrontendModelBaseResource<TModelClass>}
+ */
+export default class SyncResourceBase<TModelClass extends typeof import("../database/record/index.js").default = typeof import("../database/record/index.js").default> extends FrontendModelBaseResource<TModelClass> {
+    /**
+     * Returns a stable change-feed page after app authorization.
+     * @returns {Promise<Record<string, ?>>} Change-feed page result.
+     */
+    changes(): Promise<Record<string, unknown>>;
+    /**
+     * Replays client sync envelopes through the app replay service.
+     * @returns {Promise<Record<string, ?>>} Replay result with per-sync states.
+     */
+    replay(): Promise<Record<string, unknown>>;
+    /**
+     * Parses the optional client-declared scope from request params.
+     * @param {Record<string, ?>} params - Request params.
+     * @returns {SerializedChangesScope | null} Parsed scope, or null when the client sent none.
+     */
+    changesScope(params: Record<string, unknown>): SerializedChangesScope | null;
+    /**
+     * Builds the change-feed service serving this changes request.
+     * @param {{params: Record<string, ?>, scope: SerializedChangesScope | null}} args - Request params and parsed scope.
+     * @returns {{changes: () => Promise<Record<string, ?>>}} Change-feed service.
+     */
+    changeFeedService({ params, scope }: {
+        params: Record<string, unknown>;
+        scope: SerializedChangesScope | null;
+    }): {
+        changes: () => Promise<Record<string, unknown>>;
+    };
+    /**
+     * Builds the app replay service handling this replay request.
+     * @returns {import("./sync-envelope-replay-service.js").default} Replay service instance.
+     */
+    buildReplayService(): import("./sync-envelope-replay-service.js").default;
+    /**
+     * Returns constructor args for the app replay service.
+     * @returns {Record<string, ?>} Replay service constructor args.
+     */
+    replayServiceArgs(): Record<string, unknown>;
+    /**
+     * Returns the sync model class backing the change feed.
+     * @returns {typeof import("../database/record/index.js").default} Sync model class.
+     */
+    syncModelClass(): typeof import("../database/record/index.js").default;
+    /**
+     * Authorizes the current context for reading the requested changes.
+     * @param {{params: Record<string, ?>, scope: SerializedChangesScope | null}} _args - Request params and parsed scope.
+     * @returns {Promise<void>} Resolves when access is allowed; throws otherwise.
+     */
+    authorizeChanges(_args: {
+        params: Record<string, unknown>;
+        scope: SerializedChangesScope | null;
+    }): Promise<void>;
+    /**
+     * Applies app visibility scoping onto the change-feed query.
+     * @param {{params: Record<string, ?>, query: import("../database/query/model-class-query.js").default, scope: SerializedChangesScope | null}} _args - Request params, feed query, and parsed scope.
+     * @returns {void}
+     */
+    scopeChangesQuery(_args: {
+        params: Record<string, unknown>;
+        query: import("../database/query/model-class-query.js").default;
+        scope: SerializedChangesScope | null;
+    }): void;
+    /**
+     * Returns the app replay service class handling replay mutations.
+     * @returns {typeof import("./sync-envelope-replay-service.js").default} Replay service class.
+     */
+    replayServiceClass(): typeof import("./sync-envelope-replay-service.js").default;
+}
+/**
+ * Optional client-declared sync scope carried on a changes request.
+ */
+export type SerializedChangesScope = {
+    /**
+     * - Plain attribute conditions from the client query.
+     */
+    conditions: Record<string, unknown>;
+    /**
+     * - Client resource/model name the scope was declared for.
+     */
+    resourceType: string;
+};
+import FrontendModelBaseResource from "../frontend-model-resource/base-resource.js";
+//# sourceMappingURL=sync-resource-base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sync-resource-base.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-resource-base.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AAEH;;;;;;;;GAQG;AACH,sCAHqE,WAAW,SAAnE,cAAe,6BAA6B,EAAE,OAAQ;IAIjE;;;OAGG;IACH,WAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAStC;IAED;;;OAGG;IACH,UAFa,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAQtC;IAED;;;;OAIG;IACH,qBAHW,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GACf,sBAAsB,GAAG,IAAI,CAoBzC;IAED;;;;OAIG;IACH,qCAHW;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAC,GAC/D;QAAC,OAAO,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC,CAAA;KAAC,CAQvD;IAED;;;OAGG;IACH,sBAFa,OAAO,mCAAmC,EAAE,OAAO,CAM/D;IAED;;;OAGG;IACH,qBAFa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAI7B;IAED;;;OAGG;IACH,kBAFa,cAAc,6BAA6B,EAAE,OAAO,CAQhE;IAED;;;;OAIG;IACH,wBAHW;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAC,GAC/D,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;OAIG;IACH,yBAHW;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,CAAC;QAAC,KAAK,EAAE,OAAO,wCAAwC,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAA;KAAC,GAChI,IAAI,CAIhB;IAED;;;OAGG;IACH,sBAFa,cAAc,mCAAmC,EAAE,OAAO,CAItE;CACF;;;;;;;;gBApIa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;;;;kBACjB,MAAM;;sCAPkB,6CAA6C"}

package/build/src/sync/sync-resource-base.js

@@ -0,0 +1,122 @@
+// @ts-check
+import { forcedNonBlankStringParam } from "typanic";
+import FrontendModelBaseResource from "../frontend-model-resource/base-resource.js";
+import SyncModelChangeFeedService from "./sync-model-change-feed-service.js";
+/**
+ * Optional client-declared sync scope carried on a changes request.
+ * @typedef {object} SerializedChangesScope
+ * @property {Record<string, ?>} conditions - Plain attribute conditions from the client query.
+ * @property {string} resourceType - Client resource/model name the scope was declared for.
+ */
+/**
+ * Base resource for Velocious sync endpoints.
+ *
+ * Velocious owns the changes/replay orchestration (scope parsing, feed paging,
+ * replay delegation, response shape) while apps subclass and only declare
+ * authorization, feed scoping, and their replay service.
+ * @template {typeof import("../database/record/index.js").default} [TModelClass=typeof import("../database/record/index.js").default]
+ * @augments {FrontendModelBaseResource<TModelClass>}
+ */
+export default class SyncResourceBase extends FrontendModelBaseResource {
+    /**
+     * Returns a stable change-feed page after app authorization.
+     * @returns {Promise<Record<string, ?>>} Change-feed page result.
+     */
+    async changes() {
+        const params = this.params();
+        const scope = this.changesScope(params);
+        await this.authorizeChanges({ params, scope });
+        return await this.changeFeedService({ params, scope }).changes();
+    }
+    /**
+     * Replays client sync envelopes through the app replay service.
+     * @returns {Promise<Record<string, ?>>} Replay result with per-sync states.
+     */
+    async replay() {
+        const result = await this.buildReplayService().replay(this.params());
+        if (result.status === "error")
+            return result;
+        return { status: "success", syncs: result.syncs };
+    }
+    /**
+     * Parses the optional client-declared scope from request params.
+     * @param {Record<string, ?>} params - Request params.
+     * @returns {SerializedChangesScope | null} Parsed scope, or null when the client sent none.
+     */
+    changesScope(params) {
+        const scope = params.scope;
+        if (scope === undefined || scope === null)
+            return null;
+        if (typeof scope !== "object" || Array.isArray(scope)) {
+            throw new Error(`Sync changes scope must be an object, got: ${String(scope)}`);
+        }
+        const scopeParams = /** @type {Record<string, ?>} */ (scope);
+        const resourceType = forcedNonBlankStringParam(scopeParams, "resourceType");
+        const conditions = scopeParams.conditions;
+        if (!conditions || typeof conditions !== "object" || Array.isArray(conditions)) {
+            throw new Error(`Sync changes scope.conditions must be an object, got: ${String(conditions)}`);
+        }
+        return { conditions: /** @type {Record<string, ?>} */ (conditions), resourceType };
+    }
+    /**
+     * Builds the change-feed service serving this changes request.
+     * @param {{params: Record<string, ?>, scope: SerializedChangesScope | null}} args - Request params and parsed scope.
+     * @returns {{changes: () => Promise<Record<string, ?>>}} Change-feed service.
+     */
+    changeFeedService({ params, scope }) {
+        return new SyncModelChangeFeedService({
+            modelClass: this.syncModelClass(),
+            params,
+            scopeQuery: ({ query }) => this.scopeChangesQuery({ params, query, scope })
+        });
+    }
+    /**
+     * Builds the app replay service handling this replay request.
+     * @returns {import("./sync-envelope-replay-service.js").default} Replay service instance.
+     */
+    buildReplayService() {
+        const ReplayServiceClass = this.replayServiceClass();
+        return new ReplayServiceClass(this.replayServiceArgs());
+    }
+    /**
+     * Returns constructor args for the app replay service.
+     * @returns {Record<string, ?>} Replay service constructor args.
+     */
+    replayServiceArgs() {
+        return {};
+    }
+    /**
+     * Returns the sync model class backing the change feed.
+     * @returns {typeof import("../database/record/index.js").default} Sync model class.
+     */
+    syncModelClass() {
+        const modelClass = /** @type {typeof SyncResourceBase} */ (this.constructor).ModelClass;
+        if (!modelClass)
+            throw new Error(`${this.constructor.name} must define static ModelClass`);
+        return modelClass;
+    }
+    /**
+     * Authorizes the current context for reading the requested changes.
+     * @param {{params: Record<string, ?>, scope: SerializedChangesScope | null}} _args - Request params and parsed scope.
+     * @returns {Promise<void>} Resolves when access is allowed; throws otherwise.
+     */
+    async authorizeChanges(_args) {
+        throw new Error("SyncResourceBase#authorizeChanges must be implemented");
+    }
+    /**
+     * Applies app visibility scoping onto the change-feed query.
+     * @param {{params: Record<string, ?>, query: import("../database/query/model-class-query.js").default, scope: SerializedChangesScope | null}} _args - Request params, feed query, and parsed scope.
+     * @returns {void}
+     */
+    scopeChangesQuery(_args) {
+        throw new Error("SyncResourceBase#scopeChangesQuery must be implemented");
+    }
+    /**
+     * Returns the app replay service class handling replay mutations.
+     * @returns {typeof import("./sync-envelope-replay-service.js").default} Replay service class.
+     */
+    replayServiceClass() {
+        throw new Error("SyncResourceBase#replayServiceClass must be implemented");
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-resource-base.js","sourceRoot":"","sources":["../../../src/sync/sync-resource-base.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {forcedNonBlankStringParam} from \"typanic\"\n\nimport FrontendModelBaseResource from \"../frontend-model-resource/base-resource.js\"\nimport SyncModelChangeFeedService from \"./sync-model-change-feed-service.js\"\n\n/**\n * Optional client-declared sync scope carried on a changes request.\n * @typedef {object} SerializedChangesScope\n * @property {Record<string, ?>} conditions - Plain attribute conditions from the client query.\n * @property {string} resourceType - Client resource/model name the scope was declared for.\n */\n\n/**\n * Base resource for Velocious sync endpoints.\n *\n * Velocious owns the changes/replay orchestration (scope parsing, feed paging,\n * replay delegation, response shape) while apps subclass and only declare\n * authorization, feed scoping, and their replay service.\n * @template {typeof import(\"../database/record/index.js\").default} [TModelClass=typeof import(\"../database/record/index.js\").default]\n * @augments {FrontendModelBaseResource<TModelClass>}\n */\nexport default class SyncResourceBase extends FrontendModelBaseResource {\n  /**\n   * Returns a stable change-feed page after app authorization.\n   * @returns {Promise<Record<string, ?>>} Change-feed page result.\n   */\n  async changes() {\n    const params = this.params()\n    const scope = this.changesScope(params)\n\n    await this.authorizeChanges({params, scope})\n\n    return await this.changeFeedService({params, scope}).changes()\n  }\n\n  /**\n   * Replays client sync envelopes through the app replay service.\n   * @returns {Promise<Record<string, ?>>} Replay result with per-sync states.\n   */\n  async replay() {\n    const result = await this.buildReplayService().replay(this.params())\n\n    if (result.status === \"error\") return result\n\n    return {status: \"success\", syncs: result.syncs}\n  }\n\n  /**\n   * Parses the optional client-declared scope from request params.\n   * @param {Record<string, ?>} params - Request params.\n   * @returns {SerializedChangesScope | null} Parsed scope, or null when the client sent none.\n   */\n  changesScope(params) {\n    const scope = params.scope\n\n    if (scope === undefined || scope === null) return null\n\n    if (typeof scope !== \"object\" || Array.isArray(scope)) {\n      throw new Error(`Sync changes scope must be an object, got: ${String(scope)}`)\n    }\n\n    const scopeParams = /** @type {Record<string, ?>} */ (scope)\n    const resourceType = forcedNonBlankStringParam(scopeParams, \"resourceType\")\n    const conditions = scopeParams.conditions\n\n    if (!conditions || typeof conditions !== \"object\" || Array.isArray(conditions)) {\n      throw new Error(`Sync changes scope.conditions must be an object, got: ${String(conditions)}`)\n    }\n\n    return {conditions: /** @type {Record<string, ?>} */ (conditions), resourceType}\n  }\n\n  /**\n   * Builds the change-feed service serving this changes request.\n   * @param {{params: Record<string, ?>, scope: SerializedChangesScope | null}} args - Request params and parsed scope.\n   * @returns {{changes: () => Promise<Record<string, ?>>}} Change-feed service.\n   */\n  changeFeedService({params, scope}) {\n    return new SyncModelChangeFeedService({\n      modelClass: this.syncModelClass(),\n      params,\n      scopeQuery: ({query}) => this.scopeChangesQuery({params, query, scope})\n    })\n  }\n\n  /**\n   * Builds the app replay service handling this replay request.\n   * @returns {import(\"./sync-envelope-replay-service.js\").default} Replay service instance.\n   */\n  buildReplayService() {\n    const ReplayServiceClass = this.replayServiceClass()\n\n    return new ReplayServiceClass(this.replayServiceArgs())\n  }\n\n  /**\n   * Returns constructor args for the app replay service.\n   * @returns {Record<string, ?>} Replay service constructor args.\n   */\n  replayServiceArgs() {\n    return {}\n  }\n\n  /**\n   * Returns the sync model class backing the change feed.\n   * @returns {typeof import(\"../database/record/index.js\").default} Sync model class.\n   */\n  syncModelClass() {\n    const modelClass = /** @type {typeof SyncResourceBase} */ (this.constructor).ModelClass\n\n    if (!modelClass) throw new Error(`${this.constructor.name} must define static ModelClass`)\n\n    return modelClass\n  }\n\n  /**\n   * Authorizes the current context for reading the requested changes.\n   * @param {{params: Record<string, ?>, scope: SerializedChangesScope | null}} _args - Request params and parsed scope.\n   * @returns {Promise<void>} Resolves when access is allowed; throws otherwise.\n   */\n  async authorizeChanges(_args) {\n    throw new Error(\"SyncResourceBase#authorizeChanges must be implemented\")\n  }\n\n  /**\n   * Applies app visibility scoping onto the change-feed query.\n   * @param {{params: Record<string, ?>, query: import(\"../database/query/model-class-query.js\").default, scope: SerializedChangesScope | null}} _args - Request params, feed query, and parsed scope.\n   * @returns {void}\n   */\n  scopeChangesQuery(_args) {\n    throw new Error(\"SyncResourceBase#scopeChangesQuery must be implemented\")\n  }\n\n  /**\n   * Returns the app replay service class handling replay mutations.\n   * @returns {typeof import(\"./sync-envelope-replay-service.js\").default} Replay service class.\n   */\n  replayServiceClass() {\n    throw new Error(\"SyncResourceBase#replayServiceClass must be implemented\")\n  }\n}\n"]}

package/build/src/sync/sync-scope-store.d.ts

@@ -0,0 +1,128 @@
+/**
+ * @typedef {object} SyncScopeRow
+ * @property {Record<string, ?>} conditions - Scope attribute conditions.
+ * @property {string | null} cursorPayload - Persisted cursor JSON payload.
+ * @property {string} id - Scope row id.
+ * @property {string} resourceType - Scope resource/model name.
+ * @property {string} scopeDigest - Fixed-size deterministic digest of the canonical scope key.
+ * @property {string} state - Scope state ("active" or "removed").
+ */
+/**
+ * Framework-owned local persistence for declared sync scopes and their cursors.
+ *
+ * Backed by an auto-created `velocious_sync_scopes` table on the configured
+ * database, with a process-local memory fallback when no database is
+ * configured (mirroring the server change-feed store).
+ */
+export default class SyncScopeStore {
+    /**
+     * Creates a sync scope store.
+     * @param {object} args - Options.
+     * @param {import("../configuration.js").default} args.configuration - Configuration owning the database.
+     * @param {string} [args.databaseIdentifier] - Database identifier.
+     */
+    constructor({ configuration, databaseIdentifier }: {
+        configuration: import("../configuration.js").default;
+        databaseIdentifier?: string | undefined;
+    });
+    configuration: import("../configuration.js").default;
+    databaseIdentifier: string;
+    /** @type {Map<string, SyncScopeRow>} */
+    _memoryScopes: Map<string, SyncScopeRow>;
+    _isReady: boolean;
+    /** @type {Promise<void> | null} */
+    _readyPromise: Promise<void> | null;
+    /**
+     * Ensures the backing table exists.
+     * @returns {Promise<void>} Resolves when ready.
+     */
+    ensureReady(): Promise<void>;
+    /**
+     * Finds or creates the scope row for a serialized scope, reactivating removed scopes.
+     * @param {import("./sync-client-types.js").SerializedSyncScope} scope - Serialized sync scope.
+     * @returns {Promise<SyncScopeRow>} Persisted scope row.
+     */
+    findOrCreateScope(scope: import("./sync-client-types.js").SerializedSyncScope): Promise<SyncScopeRow>;
+    /**
+     * Returns all active scope rows.
+     * @returns {Promise<SyncScopeRow[]>} Active scope rows.
+     */
+    activeScopes(): Promise<SyncScopeRow[]>;
+    /**
+     * Loads the persisted cursor payload for a scope row.
+     * @param {SyncScopeRow} scopeRow - Scope row.
+     * @returns {Promise<string | null>} Cursor JSON payload.
+     */
+    loadCursor(scopeRow: SyncScopeRow): Promise<string | null>;
+    /**
+     * Persists the acknowledged cursor for a scope row.
+     * @param {SyncScopeRow} scopeRow - Scope row.
+     * @param {import("./sync-api-client-types.js").SyncCursor} cursor - Acknowledged cursor.
+     * @returns {Promise<void>}
+     */
+    saveCursor(scopeRow: SyncScopeRow, cursor: import("./sync-api-client-types.js").SyncCursor): Promise<void>;
+    /**
+     * Deactivates the scope row for a serialized scope.
+     * @param {import("./sync-client-types.js").SerializedSyncScope} scope - Serialized sync scope.
+     * @returns {Promise<void>}
+     */
+    deactivate(scope: import("./sync-client-types.js").SerializedSyncScope): Promise<void>;
+    /**
+     * Whether the store runs without a configured database.
+     * @returns {boolean} Whether memory storage is used.
+     */
+    _usesMemoryStorage(): boolean;
+    /**
+     * Runs a callback with a database connection.
+     * @template Result
+     * @param {(db: import("../database/drivers/base.js").default) => Promise<Result>} callback - Database callback.
+     * @returns {Promise<Result>} Callback result.
+     */
+    _withDb<Result>(callback: (db: import("../database/drivers/base.js").default) => Promise<Result>): Promise<Result>;
+    /**
+     * Ensures the scopes table exists.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @returns {Promise<void>}
+     */
+    _ensureScopesTable(db: import("../database/drivers/base.js").default): Promise<void>;
+    /**
+     * Resolves a scope row by its digest.
+     * @param {import("../database/drivers/base.js").default} db - Database connection.
+     * @param {string} digest - Fixed-size scope digest.
+     * @returns {Promise<SyncScopeRow | null>} Scope row or null.
+     */
+    _rowByScopeDigest(db: import("../database/drivers/base.js").default, digest: string): Promise<SyncScopeRow | null>;
+    /**
+     * Normalizes a raw scope table row.
+     * @param {Record<string, ?>} row - Raw table row.
+     * @returns {SyncScopeRow} Normalized scope row.
+     */
+    _normalizeScopeRow(row: Record<string, unknown>): SyncScopeRow;
+}
+export type SyncScopeRow = {
+    /**
+     * - Scope attribute conditions.
+     */
+    conditions: Record<string, unknown>;
+    /**
+     * - Persisted cursor JSON payload.
+     */
+    cursorPayload: string | null;
+    /**
+     * - Scope row id.
+     */
+    id: string;
+    /**
+     * - Scope resource/model name.
+     */
+    resourceType: string;
+    /**
+     * - Fixed-size deterministic digest of the canonical scope key.
+     */
+    scopeDigest: string;
+    /**
+     * - Scope state ("active" or "removed").
+     */
+    state: string;
+};
+//# sourceMappingURL=sync-scope-store.d.ts.map

package/build/src/sync/sync-scope-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-scope-store.d.ts","sourceRoot":"","sources":["../../../src/sync/sync-scope-store.js"],"names":[],"mappings":"AAqBA;;;;;;;;GAQG;AAEH;;;;;;GAMG;AACH;IACE;;;;;OAKG;IACH,mDAHG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QACvB,kBAAkB;KAC1C,EASA;IAPC,qDAAkC;IAClC,2BAA4C;IAC5C,wCAAwC;IACxC,eADW,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CACN;IAC9B,kBAAqB;IACrB,mCAAmC;IACnC,eADW,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CACN;IAG3B;;;OAGG;IACH,eAFa,OAAO,CAAC,IAAI,CAAC,CAsBzB;IAED;;;;OAIG;IACH,yBAHW,OAAO,wBAAwB,EAAE,mBAAmB,GAClD,OAAO,CAAC,YAAY,CAAC,CA8DjC;IAED;;;OAGG;IACH,gBAFa,OAAO,CAAC,YAAY,EAAE,CAAC,CAmBnC;IAED;;;;OAIG;IACH,qBAHW,YAAY,GACV,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAclC;IAED;;;;;OAKG;IACH,qBAJW,YAAY,UACZ,OAAO,4BAA4B,EAAE,UAAU,GAC7C,OAAO,CAAC,IAAI,CAAC,CAyBzB;IAED;;;;OAIG;IACH,kBAHW,OAAO,wBAAwB,EAAE,mBAAmB,GAClD,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED;;;OAGG;IACH,sBAFa,OAAO,CAQnB;IAED;;;;;OAKG;IACH,QAJa,MAAM,YACR,CAAC,EAAE,EAAE,OAAO,6BAA6B,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,GACpE,OAAO,CAAC,MAAM,CAAC,CAU3B;IAED;;;;OAIG;IACH,uBAHW,OAAO,6BAA6B,EAAE,OAAO,GAC3C,OAAO,CAAC,IAAI,CAAC,CAiBzB;IAED;;;;;OAKG;IACH,sBAJW,OAAO,6BAA6B,EAAE,OAAO,UAC7C,MAAM,GACJ,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAWxC;IAED;;;;OAIG;IACH,wBAHW,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC,GACf,YAAY,CAWxB;CACF;;;;;gBA/Sa,MAAM,CAAC,MAAM,EAAE,OAAC,CAAC;;;;mBACjB,MAAM,GAAG,IAAI;;;;QACb,MAAM;;;;kBACN,MAAM;;;;iBACN,MAAM;;;;WACN,MAAM"}