velocious 1.0.721 → 1.0.723

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (56) hide show
  1. package/build/background-jobs/main.js +10 -2
  2. package/build/configuration-types.js +1 -1
  3. package/build/database/advisory-lock-reentrancy-node.js +9 -0
  4. package/build/database/advisory-lock-reentrancy.js +66 -0
  5. package/build/database/advisory-lock-runner.js +9 -12
  6. package/build/database/pool/single-multi-use.js +3 -2
  7. package/build/environment-handlers/node.js +1 -0
  8. package/build/src/background-jobs/main.d.ts.map +1 -1
  9. package/build/src/background-jobs/main.js +11 -4
  10. package/build/src/configuration-types.d.ts +2 -2
  11. package/build/src/configuration-types.js +2 -2
  12. package/build/src/database/advisory-lock-reentrancy-node.d.ts +2 -0
  13. package/build/src/database/advisory-lock-reentrancy-node.d.ts.map +1 -0
  14. package/build/src/database/advisory-lock-reentrancy-node.js +7 -0
  15. package/build/src/database/advisory-lock-reentrancy.d.ts +67 -0
  16. package/build/src/database/advisory-lock-reentrancy.d.ts.map +1 -0
  17. package/build/src/database/advisory-lock-reentrancy.js +60 -0
  18. package/build/src/database/advisory-lock-runner.d.ts +25 -33
  19. package/build/src/database/advisory-lock-runner.d.ts.map +1 -1
  20. package/build/src/database/advisory-lock-runner.js +10 -13
  21. package/build/src/database/pool/single-multi-use.d.ts.map +1 -1
  22. package/build/src/database/pool/single-multi-use.js +4 -3
  23. package/build/src/environment-handlers/node.d.ts +1 -0
  24. package/build/src/environment-handlers/node.d.ts.map +1 -1
  25. package/build/src/environment-handlers/node.js +2 -1
  26. package/build/src/sync/sync-applied-sequence-store.d.ts +27 -8
  27. package/build/src/sync/sync-applied-sequence-store.d.ts.map +1 -1
  28. package/build/src/sync/sync-applied-sequence-store.js +43 -18
  29. package/build/src/sync/sync-client.js +3 -3
  30. package/build/src/sync/sync-cursor.d.ts +30 -0
  31. package/build/src/sync/sync-cursor.d.ts.map +1 -0
  32. package/build/src/sync/sync-cursor.js +54 -0
  33. package/build/src/sync/sync-realtime-bridge.d.ts +127 -24
  34. package/build/src/sync/sync-realtime-bridge.d.ts.map +1 -1
  35. package/build/src/sync/sync-realtime-bridge.js +92 -56
  36. package/build/src/sync/sync-websocket-channel.d.ts +49 -0
  37. package/build/src/sync/sync-websocket-channel.d.ts.map +1 -1
  38. package/build/src/sync/sync-websocket-channel.js +138 -2
  39. package/build/sync/sync-applied-sequence-store.js +46 -17
  40. package/build/sync/sync-client.js +2 -2
  41. package/build/sync/sync-cursor.js +56 -0
  42. package/build/sync/sync-realtime-bridge.js +97 -51
  43. package/build/sync/sync-websocket-channel.js +153 -1
  44. package/package.json +1 -1
  45. package/src/background-jobs/main.js +10 -2
  46. package/src/configuration-types.js +1 -1
  47. package/src/database/advisory-lock-reentrancy-node.js +9 -0
  48. package/src/database/advisory-lock-reentrancy.js +66 -0
  49. package/src/database/advisory-lock-runner.js +9 -12
  50. package/src/database/pool/single-multi-use.js +3 -2
  51. package/src/environment-handlers/node.js +1 -0
  52. package/src/sync/sync-applied-sequence-store.js +46 -17
  53. package/src/sync/sync-client.js +2 -2
  54. package/src/sync/sync-cursor.js +56 -0
  55. package/src/sync/sync-realtime-bridge.js +97 -51
  56. package/src/sync/sync-websocket-channel.js +153 -1
@@ -1,8 +1,46 @@
1
1
  // @ts-check
2
2
  import VelociousWebsocketChannel from "../http-server/websocket-channel.js";
3
3
  import { VELOCIOUS_SYNC_CHANNEL } from "./sync-channel-name.js";
4
+ import { cursorFromSyncEntry, isCursorAfter } from "./sync-cursor.js";
5
+ import SyncModelChangeFeedService from "./sync-model-change-feed-service.js";
4
6
  /** Configurations whose framework sync channel has already been registered. */
5
7
  const registeredConfigurations = new WeakSet();
8
+ /** Default catch-up replay page size when the subscriber sends no `limit` param. */
9
+ const DEFAULT_REPLAY_LIMIT = 1000;
10
+ /**
11
+ * Serializes a cursor into the change-feed request params under the given prefix.
12
+ * @param {"after" | "upTo"} prefix - Request field prefix.
13
+ * @param {import("./sync-api-client-types.js").SyncCursor} cursor - Cursor to serialize.
14
+ * @returns {Record<string, string | number | null>} Serialized cursor params.
15
+ */
16
+ function cursorParams(prefix, cursor) {
17
+ if (!cursor)
18
+ return {};
19
+ return {
20
+ [`${prefix}Id`]: cursor.id,
21
+ ...(cursor.serverSequence !== null ? { [`${prefix}ServerSequence`]: cursor.serverSequence } : {}),
22
+ [`${prefix}UpdatedAt`]: cursor.updatedAt
23
+ };
24
+ }
25
+ /**
26
+ * Reads the after-cursor the subscriber declared in its subscribe params, or null
27
+ * when it sent none (a fresh subscription replays the whole scope).
28
+ * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Subscribe params.
29
+ * @returns {import("./sync-api-client-types.js").SyncCursor} Declared after-cursor, or null.
30
+ */
31
+ function cursorFromParams(params) {
32
+ const updatedAt = typeof params.afterUpdatedAt === "string" ? params.afterUpdatedAt : null;
33
+ if (!updatedAt)
34
+ return null;
35
+ const serverSequence = params.afterServerSequence === null || params.afterServerSequence === undefined
36
+ ? null
37
+ : Number(params.afterServerSequence);
38
+ return {
39
+ id: params.afterId === null || params.afterId === undefined ? null : String(params.afterId),
40
+ serverSequence,
41
+ updatedAt
42
+ };
43
+ }
6
44
  /**
7
45
  * Framework-owned websocket channel for synced resources
8
46
  * ({@link VELOCIOUS_SYNC_CHANNEL}).
@@ -21,6 +59,13 @@ export default class SyncWebsocketChannel extends VelociousWebsocketChannel {
21
59
  * @type {import("./sync-resource-base.js").SerializedChangesScope | null}
22
60
  */
23
61
  _scope = null;
62
+ /**
63
+ * Cursor of the last sync entry delivered to this subscription, advanced by
64
+ * live broadcasts and catch-up replay so a resume replays only the rows missed
65
+ * while the socket was down.
66
+ * @type {import("./sync-api-client-types.js").SyncCursor}
67
+ */
68
+ _deliveredCursor = null;
24
69
  /**
25
70
  * Registers the framework sync channel on a configuration declaring a
26
71
  * `sync.api` block (guarded so repeated server boots with the same
@@ -154,11 +199,14 @@ export default class SyncWebsocketChannel extends VelociousWebsocketChannel {
154
199
  async deliverBroadcast(body, meta) {
155
200
  if (!this._isUserScope()) {
156
201
  this.sendMessage(body, meta);
202
+ this._trackDeliveredCursor(body);
157
203
  return;
158
204
  }
159
205
  const deliverableBody = await this._userScopeDeliverableBody(body);
160
- if (deliverableBody !== null)
206
+ if (deliverableBody !== null) {
161
207
  this.sendMessage(deliverableBody, meta);
208
+ this._trackDeliveredCursor(deliverableBody);
209
+ }
162
210
  }
163
211
  /**
164
212
  * Whether this subscription is a user scope: authorized with empty conditions
@@ -221,6 +269,94 @@ export default class SyncWebsocketChannel extends VelociousWebsocketChannel {
221
269
  return { ...envelope, syncs: deliverableSyncs };
222
270
  return deliverableSyncs[0];
223
271
  }
272
+ /**
273
+ * Replays the catch-up backlog to this subscriber once its subscription is
274
+ * authorized: pages the scoped change feed from the cursor the client declared
275
+ * in its subscribe params and sends each page as a standard sync envelope, then
276
+ * live broadcasts continue from there. A fresh subscription with no cursor
277
+ * replays the whole authorized scope.
278
+ * @returns {Promise<void>}
279
+ */
280
+ async subscribed() {
281
+ if (!this._scope)
282
+ return;
283
+ await this._replayFrom(cursorFromParams(this.params));
284
+ }
285
+ /**
286
+ * Replays rows missed while the socket was down, resuming from the cursor of
287
+ * the last entry this subscription delivered instead of re-reading the whole
288
+ * scope from the subscribe-time cursor.
289
+ * @returns {Promise<void>}
290
+ */
291
+ async onResume() {
292
+ if (!this._scope)
293
+ return;
294
+ await this._replayFrom(this._deliveredCursor ?? cursorFromParams(this.params));
295
+ }
296
+ /**
297
+ * Pages the scoped change feed from a cursor and delivers each page to this
298
+ * subscriber as a `{echoOrigin, syncs}` envelope. The snapshot high-water is
299
+ * resolved once and pinned across pages so rows arriving mid-replay are left to
300
+ * the live broadcast path instead of looping the replay. The delivered cursor
301
+ * advances so a later resume resumes from here.
302
+ * @param {import("./sync-api-client-types.js").SyncCursor} afterCursor - Cursor to replay after.
303
+ * @returns {Promise<void>}
304
+ */
305
+ async _replayFrom(afterCursor) {
306
+ const configuration = this.session.configuration;
307
+ const scope = this._scope;
308
+ await configuration.ensureConnections({ name: `${VELOCIOUS_SYNC_CHANNEL} catch-up replay` }, async () => {
309
+ const resource = await this.buildSyncResource();
310
+ const limit = this._replayLimit(resource);
311
+ /** @type {import("./sync-api-client-types.js").SyncCursor} */
312
+ let upToCursor = null;
313
+ while (true) {
314
+ const page = await resource.changeFeedService({
315
+ params: { ...this.params, ...cursorParams("after", afterCursor), ...(upToCursor ? cursorParams("upTo", upToCursor) : {}) },
316
+ scope
317
+ }).changes();
318
+ if (!upToCursor)
319
+ upToCursor = page.upToCursor;
320
+ if (page.syncs.length === 0)
321
+ break;
322
+ await this.deliverBroadcast({ echoOrigin: null, syncs: page.syncs });
323
+ afterCursor = page.nextCursor;
324
+ if (afterCursor)
325
+ this._deliveredCursor = afterCursor;
326
+ if (page.syncs.length < limit)
327
+ break;
328
+ }
329
+ });
330
+ }
331
+ /**
332
+ * Resolves the catch-up replay page size from the subscriber's `limit` param
333
+ * (defaulting to {@link DEFAULT_REPLAY_LIMIT}).
334
+ * @param {import("./sync-resource-base.js").default} resource - Authorizing sync resource.
335
+ * @returns {number} Replay page size.
336
+ */
337
+ _replayLimit(resource) {
338
+ return new SyncModelChangeFeedService({ modelClass: resource.syncModelClass(), params: this.params }).normalizedLimit(this.params.limit);
339
+ }
340
+ /**
341
+ * Advances the delivered-cursor watermark from a delivered envelope so a resume
342
+ * resumes after the newest row actually sent to this subscriber. Broadcasts may
343
+ * arrive out of order across resources, so each entry only advances the
344
+ * watermark when it is later than the current one.
345
+ * @param {import("../http-server/websocket-channel.js").WebsocketJsonValue} body - Delivered envelope.
346
+ * @returns {void}
347
+ */
348
+ _trackDeliveredCursor(body) {
349
+ if (!body || typeof body !== "object" || Array.isArray(body))
350
+ return;
351
+ const envelope = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (body);
352
+ const syncs = Array.isArray(envelope.syncs) ? envelope.syncs : [envelope];
353
+ for (const entry of syncs) {
354
+ const syncEntry = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (entry);
355
+ const cursor = cursorFromSyncEntry(syncEntry);
356
+ if (cursor && isCursorAfter(cursor, this._deliveredCursor))
357
+ this._deliveredCursor = cursor;
358
+ }
359
+ }
224
360
  /**
225
361
  * Returns the authorized scope for debug snapshots.
226
362
  * @returns {Record<string, ReturnType<typeof JSON.parse>>} Debug-safe subscription details.
@@ -229,4 +365,4 @@ export default class SyncWebsocketChannel extends VelociousWebsocketChannel {
229
365
  return { scope: this._scope, userScope: this._isUserScope() };
230
366
  }
231
367
  }
232
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-websocket-channel.js","sourceRoot":"","sources":["../../../src/sync/sync-websocket-channel.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport VelociousWebsocketChannel from \"../http-server/websocket-channel.js\"\nimport {VELOCIOUS_SYNC_CHANNEL} from \"./sync-channel-name.js\"\n\n/** Configurations whose framework sync channel has already been registered. */\nconst registeredConfigurations = new WeakSet()\n\n/**\n * Framework-owned websocket channel for synced resources\n * ({@link VELOCIOUS_SYNC_CHANNEL}).\n *\n * Subscribe params mirror a declared pull scope — `{resourceType, conditions}`\n * plus the client-injected `authenticationToken` — and subscribe-time\n * authorization delegates to the app sync resource's existing\n * `authorizeChanges({params, scope})` (the `sync.api.resourceClass`), so apps\n * hook in through the authorization they already declared instead of writing\n * their own channel classes. Broadcast routing matches the publisher's\n * scoping params against the subscription's scope conditions.\n */\nexport default class SyncWebsocketChannel extends VelociousWebsocketChannel {\n  /**\n   * Scope the subscription was authorized for, set by {@link SyncWebsocketChannel#canSubscribe}.\n   * @type {import(\"./sync-resource-base.js\").SerializedChangesScope | null}\n   */\n  _scope = null\n\n  /**\n   * Registers the framework sync channel on a configuration declaring a\n   * `sync.api` block (guarded so repeated server boots with the same\n   * configuration register it only once). No-op without `sync.api` — the\n   * channel authorizes through the app's sync resource class.\n   * @param {import(\"../configuration.js\").default} configuration - Configuration instance.\n   * @returns {void}\n   */\n  static registerFromConfiguration(configuration) {\n    if (!configuration.getSyncConfiguration().api || registeredConfigurations.has(configuration)) return\n\n    registeredConfigurations.add(configuration)\n    configuration.registerWebsocketChannel(VELOCIOUS_SYNC_CHANNEL, this)\n  }\n\n  /**\n   * Authorizes the subscription through the app sync resource: the subscribe\n   * params are parsed into the same serialized scope the changes endpoint\n   * consumes and passed to the resource's `authorizeChanges({params, scope})`.\n   * Denials and malformed scopes throw, rejecting the subscription.\n   * @returns {Promise<boolean>} Whether the subscription is allowed.\n   */\n  async canSubscribe() {\n    const resource = await this.buildSyncResource()\n    const scope = resource.changesScope({scope: {conditions: this.params.conditions, resourceType: this.params.resourceType, resourceTypes: this.params.resourceTypes}})\n\n    await resource.authorizeChanges({params: this.params, scope})\n\n    this._scope = scope\n\n    return true\n  }\n\n  /**\n   * Builds the app sync resource authorizing this subscription, mirroring the\n   * sync transport controller's resource construction with the ability\n   * resolved from the subscribe params (which carry the client-injected\n   * authenticationToken).\n   * @returns {Promise<import(\"./sync-resource-base.js\").default>} App sync resource instance.\n   */\n  async buildSyncResource() {\n    const configuration = this.session.configuration\n    const api = configuration.getSyncConfiguration().api\n\n    if (!api) {\n      throw new Error(`The ${VELOCIOUS_SYNC_CHANNEL} channel requires a sync.api configuration block with the app's sync resource class`)\n    }\n\n    // Narrows the configured resource class to the sync resource contract\n    // (changesScope/authorizeChanges) the sync.api validation requires.\n    const ResourceClass = /** @type {typeof import(\"./sync-resource-base.js\").default} */ (api.resourceClass)\n    // Narrows the websocket subscribe params to the resource params contract.\n    const params = /** @type {import(\"../configuration-types.js\").VelociousParams} */ (/** @type {unknown} */ (this.params))\n    const request = this.session.upgradeRequest\n    const ability = await configuration.resolveAbility({params, request})\n\n    return new ResourceClass({\n      ability,\n      configuration,\n      context: {\n        ...(ability?.getContext() || {}),\n        params,\n        request\n      },\n      locals: ability?.getLocals() || {},\n      modelClass: ResourceClass.ModelClass,\n      modelName: ResourceClass.ModelClass?.name,\n      params,\n      resourceConfiguration: /** @type {import(\"../configuration-types.js\").FrontendModelResourceConfiguration} */ ({\n        attributes: ResourceClass.attributes || {},\n        sync: {enabled: true}\n      })\n    })\n  }\n\n  /**\n   * Routes a publisher broadcast to this subscription when the published\n   * resource type equals the type the subscription was authorized for and the\n   * scoping params satisfy every scope condition: each condition key must be\n   * present in the broadcast params and match by string comparison (array\n   * conditions match by membership). Broadcasts without a resource type and\n   * conditions the publisher's scoping params do not carry never match, so a\n   * subscription cannot receive changes outside its authorized scope.\n   *\n   * The all-types (user) scope declares no single resource type - it subscribes\n   * once for every type it can apply, listed in `scope.resourceTypes` - so it\n   * matches a broadcast of any of those types. Types outside that list are\n   * dropped here, by this cheap check, and never reach the per-delivery access\n   * re-check in {@link SyncWebsocketChannel#_userScopeDeliverableBody}: that\n   * re-check checks out a database connection and runs a query per matched\n   * broadcast, so matching every type would put DB work on every broadcast for\n   * every subscribed device. A broadcast carrying no resource type at all still\n   * never matches.\n   * @param {import(\"../http-server/websocket-channel.js\").WebsocketJsonValue} broadcastParams - Publisher scoping params (the published resourceType plus the change's scope-partition values).\n   * @returns {boolean} Whether the broadcast belongs to this subscription's scope.\n   */\n  matches(broadcastParams) {\n    const scope = this._scope\n\n    if (!scope) return false\n\n    const scopingParams = broadcastParams && typeof broadcastParams === \"object\" && !Array.isArray(broadcastParams)\n      ? /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (broadcastParams)\n      : {}\n\n    if (!Object.hasOwn(scopingParams, \"resourceType\")) return false\n\n    if (scope.resourceType === null) {\n      if (scope.resourceTypes && !scope.resourceTypes.some((resourceType) => resourceType === String(scopingParams.resourceType))) return false\n    } else if (String(scopingParams.resourceType) !== String(scope.resourceType)) {\n      return false\n    }\n\n    for (const [conditionName, conditionValue] of Object.entries(scope.conditions)) {\n      if (!Object.hasOwn(scopingParams, conditionName)) return false\n\n      const scopingValue = scopingParams[conditionName]\n\n      if (Array.isArray(conditionValue)) {\n        if (!conditionValue.some((value) => String(value) === String(scopingValue))) return false\n      } else if (String(conditionValue) !== String(scopingValue)) {\n        return false\n      }\n    }\n\n    return true\n  }\n\n  /**\n   * Delivers a matched broadcast. Scoped subscriptions (with explicit\n   * conditions) already routed through {@link SyncWebsocketChannel#matches}, so\n   * the change is in scope and delivers unchanged. User-scope subscriptions\n   * (empty conditions, \"everything my ability can see\") match every broadcast\n   * of the resource type, so each published change is re-checked against the\n   * subscriber's ability at fan-out through the app sync resource's\n   * `changeDeliverable`; only accessible changes are delivered, and a broadcast\n   * with no accessible change is dropped.\n   * @param {import(\"../http-server/websocket-channel.js\").WebsocketJsonValue} body - Broadcast body (sync envelope).\n   * @param {{eventId?: string}} [meta] - Optional event metadata.\n   * @returns {Promise<void>}\n   */\n  async deliverBroadcast(body, meta) {\n    if (!this._isUserScope()) {\n      this.sendMessage(body, meta)\n\n      return\n    }\n\n    const deliverableBody = await this._userScopeDeliverableBody(body)\n\n    if (deliverableBody !== null) this.sendMessage(deliverableBody, meta)\n  }\n\n  /**\n   * Whether this subscription is a user scope: authorized with empty conditions\n   * (\"everything my ability can see\").\n   * @returns {boolean} Whether the subscription is a user scope.\n   */\n  _isUserScope() {\n    return Boolean(this._scope) && Object.keys(/** @type {import(\"./sync-resource-base.js\").SerializedChangesScope} */ (this._scope).conditions).length === 0\n  }\n\n  /**\n   * Filters a user-scope broadcast to the sync entries the subscriber's ability\n   * can access, re-checking each through the app sync resource's\n   * `changeDeliverable`. Returns the broadcast narrowed to accessible entries,\n   * or null when none are accessible. Non-envelope bodies and entries without a\n   * resource id are dropped (fail closed).\n   * @param {import(\"../http-server/websocket-channel.js\").WebsocketJsonValue} body - Broadcast body.\n   * @returns {Promise<import(\"../http-server/websocket-channel.js\").WebsocketJsonValue | null>} Deliverable body, or null.\n   */\n  async _userScopeDeliverableBody(body) {\n    if (!body || typeof body !== \"object\" || Array.isArray(body)) return null\n\n    const envelope = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (body)\n    const scope = /** @type {import(\"./sync-resource-base.js\").SerializedChangesScope} */ (this._scope)\n    /** @type {Array<Record<string, ReturnType<typeof JSON.parse>>>} */\n    const syncs = Array.isArray(envelope.syncs) ? envelope.syncs : [envelope]\n    const configuration = this.session.configuration\n    /** @type {Array<Record<string, ReturnType<typeof JSON.parse>>>} */\n    const deliverableSyncs = []\n\n    // Broadcast fan-out runs through `withoutCurrentConnectionContexts` (see\n    // Configuration#_broadcastToChannelLocal), so there is no ambient database\n    // connection here. Resolve the resource's ability and run the per-delivery\n    // access query inside a checked-out connection context, mirroring how other\n    // broadcast-time DB work (the frontend-model channel) obtains connections.\n    await configuration.ensureConnections({name: `${VELOCIOUS_SYNC_CHANNEL} user-scope delivery access check`}, async () => {\n      const resource = await this.buildSyncResource()\n\n      for (const sync of syncs) {\n        const resourceId = sync?.resourceId\n        const resourceType = sync?.resourceType ?? scope.resourceType\n\n        if (resourceId === undefined || resourceId === null) continue\n\n        // Pass the complete broadcast entry through so the app's\n        // changeDeliverable can authorize by exact-row identity (immutable\n        // sync-row id, actor-specific metadata) — concurrent targeted and\n        // shared broadcasts for the same resource identity authorize\n        // independently. Only resourceId/resourceType are normalized to\n        // strings, on a copy so the published entry is never mutated.\n        const syncEntry = {\n          ...sync,\n          resourceId: String(resourceId),\n          resourceType: String(resourceType)\n        }\n\n        if (await resource.changeDeliverable({params: this.params, scope, sync: syncEntry})) {\n          deliverableSyncs.push(sync)\n        }\n      }\n    })\n\n    if (deliverableSyncs.length === 0) return null\n    if (Array.isArray(envelope.syncs)) return {...envelope, syncs: deliverableSyncs}\n\n    return deliverableSyncs[0]\n  }\n\n  /**\n   * Returns the authorized scope for debug snapshots.\n   * @returns {Record<string, ReturnType<typeof JSON.parse>>} Debug-safe subscription details.\n   */\n  debugSnapshot() {\n    return {scope: this._scope, userScope: this._isUserScope()}\n  }\n}\n"]}
368
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync-websocket-channel.js","sourceRoot":"","sources":["../../../src/sync/sync-websocket-channel.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport VelociousWebsocketChannel from \"../http-server/websocket-channel.js\"\nimport {VELOCIOUS_SYNC_CHANNEL} from \"./sync-channel-name.js\"\nimport {cursorFromSyncEntry, isCursorAfter} from \"./sync-cursor.js\"\nimport SyncModelChangeFeedService from \"./sync-model-change-feed-service.js\"\n\n/** Configurations whose framework sync channel has already been registered. */\nconst registeredConfigurations = new WeakSet()\n\n/** Default catch-up replay page size when the subscriber sends no `limit` param. */\nconst DEFAULT_REPLAY_LIMIT = 1000\n\n/**\n * Serializes a cursor into the change-feed request params under the given prefix.\n * @param {\"after\" | \"upTo\"} prefix - Request field prefix.\n * @param {import(\"./sync-api-client-types.js\").SyncCursor} cursor - Cursor to serialize.\n * @returns {Record<string, string | number | null>} Serialized cursor params.\n */\nfunction cursorParams(prefix, cursor) {\n  if (!cursor) return {}\n\n  return {\n    [`${prefix}Id`]: cursor.id,\n    ...(cursor.serverSequence !== null ? {[`${prefix}ServerSequence`]: cursor.serverSequence} : {}),\n    [`${prefix}UpdatedAt`]: cursor.updatedAt\n  }\n}\n\n/**\n * Reads the after-cursor the subscriber declared in its subscribe params, or null\n * when it sent none (a fresh subscription replays the whole scope).\n * @param {Record<string, ReturnType<typeof JSON.parse>>} params - Subscribe params.\n * @returns {import(\"./sync-api-client-types.js\").SyncCursor} Declared after-cursor, or null.\n */\nfunction cursorFromParams(params) {\n  const updatedAt = typeof params.afterUpdatedAt === \"string\" ? params.afterUpdatedAt : null\n\n  if (!updatedAt) return null\n\n  const serverSequence = params.afterServerSequence === null || params.afterServerSequence === undefined\n    ? null\n    : Number(params.afterServerSequence)\n\n  return {\n    id: params.afterId === null || params.afterId === undefined ? null : String(params.afterId),\n    serverSequence,\n    updatedAt\n  }\n}\n\n/**\n * Framework-owned websocket channel for synced resources\n * ({@link VELOCIOUS_SYNC_CHANNEL}).\n *\n * Subscribe params mirror a declared pull scope — `{resourceType, conditions}`\n * plus the client-injected `authenticationToken` — and subscribe-time\n * authorization delegates to the app sync resource's existing\n * `authorizeChanges({params, scope})` (the `sync.api.resourceClass`), so apps\n * hook in through the authorization they already declared instead of writing\n * their own channel classes. Broadcast routing matches the publisher's\n * scoping params against the subscription's scope conditions.\n */\nexport default class SyncWebsocketChannel extends VelociousWebsocketChannel {\n  /**\n   * Scope the subscription was authorized for, set by {@link SyncWebsocketChannel#canSubscribe}.\n   * @type {import(\"./sync-resource-base.js\").SerializedChangesScope | null}\n   */\n  _scope = null\n\n  /**\n   * Cursor of the last sync entry delivered to this subscription, advanced by\n   * live broadcasts and catch-up replay so a resume replays only the rows missed\n   * while the socket was down.\n   * @type {import(\"./sync-api-client-types.js\").SyncCursor}\n   */\n  _deliveredCursor = null\n\n  /**\n   * Registers the framework sync channel on a configuration declaring a\n   * `sync.api` block (guarded so repeated server boots with the same\n   * configuration register it only once). No-op without `sync.api` — the\n   * channel authorizes through the app's sync resource class.\n   * @param {import(\"../configuration.js\").default} configuration - Configuration instance.\n   * @returns {void}\n   */\n  static registerFromConfiguration(configuration) {\n    if (!configuration.getSyncConfiguration().api || registeredConfigurations.has(configuration)) return\n\n    registeredConfigurations.add(configuration)\n    configuration.registerWebsocketChannel(VELOCIOUS_SYNC_CHANNEL, this)\n  }\n\n  /**\n   * Authorizes the subscription through the app sync resource: the subscribe\n   * params are parsed into the same serialized scope the changes endpoint\n   * consumes and passed to the resource's `authorizeChanges({params, scope})`.\n   * Denials and malformed scopes throw, rejecting the subscription.\n   * @returns {Promise<boolean>} Whether the subscription is allowed.\n   */\n  async canSubscribe() {\n    const resource = await this.buildSyncResource()\n    const scope = resource.changesScope({scope: {conditions: this.params.conditions, resourceType: this.params.resourceType, resourceTypes: this.params.resourceTypes}})\n\n    await resource.authorizeChanges({params: this.params, scope})\n\n    this._scope = scope\n\n    return true\n  }\n\n  /**\n   * Builds the app sync resource authorizing this subscription, mirroring the\n   * sync transport controller's resource construction with the ability\n   * resolved from the subscribe params (which carry the client-injected\n   * authenticationToken).\n   * @returns {Promise<import(\"./sync-resource-base.js\").default>} App sync resource instance.\n   */\n  async buildSyncResource() {\n    const configuration = this.session.configuration\n    const api = configuration.getSyncConfiguration().api\n\n    if (!api) {\n      throw new Error(`The ${VELOCIOUS_SYNC_CHANNEL} channel requires a sync.api configuration block with the app's sync resource class`)\n    }\n\n    // Narrows the configured resource class to the sync resource contract\n    // (changesScope/authorizeChanges) the sync.api validation requires.\n    const ResourceClass = /** @type {typeof import(\"./sync-resource-base.js\").default} */ (api.resourceClass)\n    // Narrows the websocket subscribe params to the resource params contract.\n    const params = /** @type {import(\"../configuration-types.js\").VelociousParams} */ (/** @type {unknown} */ (this.params))\n    const request = this.session.upgradeRequest\n    const ability = await configuration.resolveAbility({params, request})\n\n    return new ResourceClass({\n      ability,\n      configuration,\n      context: {\n        ...(ability?.getContext() || {}),\n        params,\n        request\n      },\n      locals: ability?.getLocals() || {},\n      modelClass: ResourceClass.ModelClass,\n      modelName: ResourceClass.ModelClass?.name,\n      params,\n      resourceConfiguration: /** @type {import(\"../configuration-types.js\").FrontendModelResourceConfiguration} */ ({\n        attributes: ResourceClass.attributes || {},\n        sync: {enabled: true}\n      })\n    })\n  }\n\n  /**\n   * Routes a publisher broadcast to this subscription when the published\n   * resource type equals the type the subscription was authorized for and the\n   * scoping params satisfy every scope condition: each condition key must be\n   * present in the broadcast params and match by string comparison (array\n   * conditions match by membership). Broadcasts without a resource type and\n   * conditions the publisher's scoping params do not carry never match, so a\n   * subscription cannot receive changes outside its authorized scope.\n   *\n   * The all-types (user) scope declares no single resource type - it subscribes\n   * once for every type it can apply, listed in `scope.resourceTypes` - so it\n   * matches a broadcast of any of those types. Types outside that list are\n   * dropped here, by this cheap check, and never reach the per-delivery access\n   * re-check in {@link SyncWebsocketChannel#_userScopeDeliverableBody}: that\n   * re-check checks out a database connection and runs a query per matched\n   * broadcast, so matching every type would put DB work on every broadcast for\n   * every subscribed device. A broadcast carrying no resource type at all still\n   * never matches.\n   * @param {import(\"../http-server/websocket-channel.js\").WebsocketJsonValue} broadcastParams - Publisher scoping params (the published resourceType plus the change's scope-partition values).\n   * @returns {boolean} Whether the broadcast belongs to this subscription's scope.\n   */\n  matches(broadcastParams) {\n    const scope = this._scope\n\n    if (!scope) return false\n\n    const scopingParams = broadcastParams && typeof broadcastParams === \"object\" && !Array.isArray(broadcastParams)\n      ? /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (broadcastParams)\n      : {}\n\n    if (!Object.hasOwn(scopingParams, \"resourceType\")) return false\n\n    if (scope.resourceType === null) {\n      if (scope.resourceTypes && !scope.resourceTypes.some((resourceType) => resourceType === String(scopingParams.resourceType))) return false\n    } else if (String(scopingParams.resourceType) !== String(scope.resourceType)) {\n      return false\n    }\n\n    for (const [conditionName, conditionValue] of Object.entries(scope.conditions)) {\n      if (!Object.hasOwn(scopingParams, conditionName)) return false\n\n      const scopingValue = scopingParams[conditionName]\n\n      if (Array.isArray(conditionValue)) {\n        if (!conditionValue.some((value) => String(value) === String(scopingValue))) return false\n      } else if (String(conditionValue) !== String(scopingValue)) {\n        return false\n      }\n    }\n\n    return true\n  }\n\n  /**\n   * Delivers a matched broadcast. Scoped subscriptions (with explicit\n   * conditions) already routed through {@link SyncWebsocketChannel#matches}, so\n   * the change is in scope and delivers unchanged. User-scope subscriptions\n   * (empty conditions, \"everything my ability can see\") match every broadcast\n   * of the resource type, so each published change is re-checked against the\n   * subscriber's ability at fan-out through the app sync resource's\n   * `changeDeliverable`; only accessible changes are delivered, and a broadcast\n   * with no accessible change is dropped.\n   * @param {import(\"../http-server/websocket-channel.js\").WebsocketJsonValue} body - Broadcast body (sync envelope).\n   * @param {{eventId?: string}} [meta] - Optional event metadata.\n   * @returns {Promise<void>}\n   */\n  async deliverBroadcast(body, meta) {\n    if (!this._isUserScope()) {\n      this.sendMessage(body, meta)\n      this._trackDeliveredCursor(body)\n\n      return\n    }\n\n    const deliverableBody = await this._userScopeDeliverableBody(body)\n\n    if (deliverableBody !== null) {\n      this.sendMessage(deliverableBody, meta)\n      this._trackDeliveredCursor(deliverableBody)\n    }\n  }\n\n  /**\n   * Whether this subscription is a user scope: authorized with empty conditions\n   * (\"everything my ability can see\").\n   * @returns {boolean} Whether the subscription is a user scope.\n   */\n  _isUserScope() {\n    return Boolean(this._scope) && Object.keys(/** @type {import(\"./sync-resource-base.js\").SerializedChangesScope} */ (this._scope).conditions).length === 0\n  }\n\n  /**\n   * Filters a user-scope broadcast to the sync entries the subscriber's ability\n   * can access, re-checking each through the app sync resource's\n   * `changeDeliverable`. Returns the broadcast narrowed to accessible entries,\n   * or null when none are accessible. Non-envelope bodies and entries without a\n   * resource id are dropped (fail closed).\n   * @param {import(\"../http-server/websocket-channel.js\").WebsocketJsonValue} body - Broadcast body.\n   * @returns {Promise<import(\"../http-server/websocket-channel.js\").WebsocketJsonValue | null>} Deliverable body, or null.\n   */\n  async _userScopeDeliverableBody(body) {\n    if (!body || typeof body !== \"object\" || Array.isArray(body)) return null\n\n    const envelope = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (body)\n    const scope = /** @type {import(\"./sync-resource-base.js\").SerializedChangesScope} */ (this._scope)\n    /** @type {Array<Record<string, ReturnType<typeof JSON.parse>>>} */\n    const syncs = Array.isArray(envelope.syncs) ? envelope.syncs : [envelope]\n    const configuration = this.session.configuration\n    /** @type {Array<Record<string, ReturnType<typeof JSON.parse>>>} */\n    const deliverableSyncs = []\n\n    // Broadcast fan-out runs through `withoutCurrentConnectionContexts` (see\n    // Configuration#_broadcastToChannelLocal), so there is no ambient database\n    // connection here. Resolve the resource's ability and run the per-delivery\n    // access query inside a checked-out connection context, mirroring how other\n    // broadcast-time DB work (the frontend-model channel) obtains connections.\n    await configuration.ensureConnections({name: `${VELOCIOUS_SYNC_CHANNEL} user-scope delivery access check`}, async () => {\n      const resource = await this.buildSyncResource()\n\n      for (const sync of syncs) {\n        const resourceId = sync?.resourceId\n        const resourceType = sync?.resourceType ?? scope.resourceType\n\n        if (resourceId === undefined || resourceId === null) continue\n\n        // Pass the complete broadcast entry through so the app's\n        // changeDeliverable can authorize by exact-row identity (immutable\n        // sync-row id, actor-specific metadata) — concurrent targeted and\n        // shared broadcasts for the same resource identity authorize\n        // independently. Only resourceId/resourceType are normalized to\n        // strings, on a copy so the published entry is never mutated.\n        const syncEntry = {\n          ...sync,\n          resourceId: String(resourceId),\n          resourceType: String(resourceType)\n        }\n\n        if (await resource.changeDeliverable({params: this.params, scope, sync: syncEntry})) {\n          deliverableSyncs.push(sync)\n        }\n      }\n    })\n\n    if (deliverableSyncs.length === 0) return null\n    if (Array.isArray(envelope.syncs)) return {...envelope, syncs: deliverableSyncs}\n\n    return deliverableSyncs[0]\n  }\n\n  /**\n   * Replays the catch-up backlog to this subscriber once its subscription is\n   * authorized: pages the scoped change feed from the cursor the client declared\n   * in its subscribe params and sends each page as a standard sync envelope, then\n   * live broadcasts continue from there. A fresh subscription with no cursor\n   * replays the whole authorized scope.\n   * @returns {Promise<void>}\n   */\n  async subscribed() {\n    if (!this._scope) return\n\n    await this._replayFrom(cursorFromParams(this.params))\n  }\n\n  /**\n   * Replays rows missed while the socket was down, resuming from the cursor of\n   * the last entry this subscription delivered instead of re-reading the whole\n   * scope from the subscribe-time cursor.\n   * @returns {Promise<void>}\n   */\n  async onResume() {\n    if (!this._scope) return\n\n    await this._replayFrom(this._deliveredCursor ?? cursorFromParams(this.params))\n  }\n\n  /**\n   * Pages the scoped change feed from a cursor and delivers each page to this\n   * subscriber as a `{echoOrigin, syncs}` envelope. The snapshot high-water is\n   * resolved once and pinned across pages so rows arriving mid-replay are left to\n   * the live broadcast path instead of looping the replay. The delivered cursor\n   * advances so a later resume resumes from here.\n   * @param {import(\"./sync-api-client-types.js\").SyncCursor} afterCursor - Cursor to replay after.\n   * @returns {Promise<void>}\n   */\n  async _replayFrom(afterCursor) {\n    const configuration = this.session.configuration\n    const scope = this._scope\n\n    await configuration.ensureConnections({name: `${VELOCIOUS_SYNC_CHANNEL} catch-up replay`}, async () => {\n      const resource = await this.buildSyncResource()\n      const limit = this._replayLimit(resource)\n      /** @type {import(\"./sync-api-client-types.js\").SyncCursor} */\n      let upToCursor = null\n\n      while (true) {\n        const page = await resource.changeFeedService({\n          params: {...this.params, ...cursorParams(\"after\", afterCursor), ...(upToCursor ? cursorParams(\"upTo\", upToCursor) : {})},\n          scope\n        }).changes()\n\n        if (!upToCursor) upToCursor = page.upToCursor\n\n        if (page.syncs.length === 0) break\n\n        await this.deliverBroadcast({echoOrigin: null, syncs: page.syncs})\n\n        afterCursor = page.nextCursor\n        if (afterCursor) this._deliveredCursor = afterCursor\n\n        if (page.syncs.length < limit) break\n      }\n    })\n  }\n\n  /**\n   * Resolves the catch-up replay page size from the subscriber's `limit` param\n   * (defaulting to {@link DEFAULT_REPLAY_LIMIT}).\n   * @param {import(\"./sync-resource-base.js\").default} resource - Authorizing sync resource.\n   * @returns {number} Replay page size.\n   */\n  _replayLimit(resource) {\n    return new SyncModelChangeFeedService({modelClass: resource.syncModelClass(), params: this.params}).normalizedLimit(this.params.limit)\n  }\n\n  /**\n   * Advances the delivered-cursor watermark from a delivered envelope so a resume\n   * resumes after the newest row actually sent to this subscriber. Broadcasts may\n   * arrive out of order across resources, so each entry only advances the\n   * watermark when it is later than the current one.\n   * @param {import(\"../http-server/websocket-channel.js\").WebsocketJsonValue} body - Delivered envelope.\n   * @returns {void}\n   */\n  _trackDeliveredCursor(body) {\n    if (!body || typeof body !== \"object\" || Array.isArray(body)) return\n\n    const envelope = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (body)\n    const syncs = Array.isArray(envelope.syncs) ? envelope.syncs : [envelope]\n\n    for (const entry of syncs) {\n      const syncEntry = /** @type {Record<string, ReturnType<typeof JSON.parse>>} */ (entry)\n      const cursor = cursorFromSyncEntry(syncEntry)\n\n      if (cursor && isCursorAfter(cursor, this._deliveredCursor)) this._deliveredCursor = cursor\n    }\n  }\n\n  /**\n   * Returns the authorized scope for debug snapshots.\n   * @returns {Record<string, ReturnType<typeof JSON.parse>>} Debug-safe subscription details.\n   */\n  debugSnapshot() {\n    return {scope: this._scope, userScope: this._isUserScope()}\n  }\n}\n"]}
@@ -69,9 +69,10 @@ export default class SyncAppliedSequenceStore {
69
69
 
70
70
  /**
71
71
  * Ensures the backing table exists.
72
+ * @param {{operation?: import("../database/operation.js").default | null}} [args] - Optional caller-owned operation.
72
73
  * @returns {Promise<void>} Resolves when ready.
73
74
  */
74
- async ensureReady() {
75
+ async ensureReady({operation} = {}) {
75
76
  if (this._isReady) return
76
77
 
77
78
  if (this._usesMemoryStorage()) {
@@ -79,43 +80,43 @@ export default class SyncAppliedSequenceStore {
79
80
  return
80
81
  }
81
82
 
82
- await this._withDb(async (db) => await this._ensureReadyWithDb(db))
83
+ await this._withDb(async (db) => await this._ensureReadyWithDb(db), operation)
83
84
  }
84
85
 
85
86
  /**
86
87
  * Returns the highest server sequence already applied to a record.
87
- * @param {{resourceType: string, resourceId: string}} identity - Resource identity.
88
+ * @param {{resourceType: string, resourceId: string, operation?: import("../database/operation.js").default | null}} identity - Resource identity and optional caller-owned operation.
88
89
  * @returns {Promise<number | null>} Applied sequence, or null when none is recorded.
89
90
  */
90
- async lastAppliedSequence(identity) {
91
- await this.ensureReady()
91
+ async lastAppliedSequence({resourceId, resourceType, operation}) {
92
+ await this.ensureReady({operation})
92
93
 
93
94
  if (this._usesMemoryStorage()) {
94
- return this._memorySequences.get(memoryKey(identity)) ?? null
95
+ return this._memorySequences.get(memoryKey({resourceId, resourceType})) ?? null
95
96
  }
96
97
 
97
98
  return await this._withDb(async (db) => {
98
- const row = await this._rowByResource(db, identity)
99
+ const row = await this._rowByResource(db, {resourceId, resourceType})
99
100
 
100
101
  return row ? row.serverSequence : null
101
- })
102
+ }, operation)
102
103
  }
103
104
 
104
105
  /**
105
106
  * Records a successfully applied server sequence for a record, keeping only
106
107
  * the highest value. Writes for the same record are serialized in-process so
107
108
  * concurrent pull/realtime applies cannot move the watermark backwards.
108
- * @param {{resourceType: string, resourceId: string, serverSequence: number}} args - Applied change identity and sequence.
109
+ * @param {{resourceType: string, resourceId: string, serverSequence: number, operation?: import("../database/operation.js").default | null}} args - Applied change identity, sequence and optional caller-owned operation.
109
110
  * @returns {Promise<void>} Resolves when recorded.
110
111
  */
111
- async recordAppliedSequence({resourceId, resourceType, serverSequence}) {
112
- await this.ensureReady()
112
+ async recordAppliedSequence({resourceId, resourceType, serverSequence, operation}) {
113
+ await this.ensureReady({operation})
113
114
 
114
115
  const identity = {resourceId, resourceType}
115
116
  const key = memoryKey(identity)
116
117
  const previousWrite = this._writeQueues.get(key) || Promise.resolve()
117
118
  const write = previousWrite
118
- .then(async () => await this._recordSequential({identity, key, serverSequence}))
119
+ .then(async () => await this._recordSequential({identity, key, operation, serverSequence}))
119
120
  .finally(() => {
120
121
  if (this._writeQueues.get(key) === write) this._writeQueues.delete(key)
121
122
  })
@@ -126,11 +127,11 @@ export default class SyncAppliedSequenceStore {
126
127
 
127
128
  /**
128
129
  * Applies one serialized watermark write.
129
- * @param {{identity: {resourceType: string, resourceId: string}, key: string, serverSequence: number}} args - Write args.
130
+ * @param {{identity: {resourceType: string, resourceId: string}, key: string, serverSequence: number, operation?: import("../database/operation.js").default | null}} args - Write args.
130
131
  * @returns {Promise<void>} Resolves when written.
131
132
  */
132
- async _recordSequential({identity, key, serverSequence}) {
133
- const currentSequence = await this.lastAppliedSequence(identity)
133
+ async _recordSequential({identity, key, serverSequence, operation}) {
134
+ const currentSequence = await this.lastAppliedSequence({resourceType: identity.resourceType, resourceId: identity.resourceId, operation})
134
135
 
135
136
  if (currentSequence !== null && currentSequence >= serverSequence) return
136
137
 
@@ -153,7 +154,7 @@ export default class SyncAppliedSequenceStore {
153
154
  tableName: TABLE_NAME,
154
155
  updateColumns: ["server_sequence", "updated_at"]
155
156
  })
156
- })
157
+ }, operation)
157
158
  }
158
159
 
159
160
  /**
@@ -227,11 +228,23 @@ export default class SyncAppliedSequenceStore {
227
228
 
228
229
  /**
229
230
  * Runs a callback with a database connection.
231
+ *
232
+ * A caller that already owns an operation on this store's physical database
233
+ * must hand it in: taking a second checkout from the same physical database
234
+ * would queue behind the operation the caller is running inside and wait
235
+ * behind itself.
230
236
  * @template Result
231
237
  * @param {(db: import("../database/drivers/base.js").default) => Promise<Result>} callback - Database callback.
238
+ * @param {import("../database/operation.js").default | null} [operation] - Caller-owned operation to run on.
232
239
  * @returns {Promise<Result>} Callback result.
233
240
  */
234
- async _withDb(callback) {
241
+ async _withDb(callback, operation) {
242
+ if (operation) {
243
+ this.assertOperationOwnership(operation)
244
+
245
+ return await callback(operation.connection())
246
+ }
247
+
235
248
  if (this.tenantHandle) {
236
249
  return await this.tenantHandle.databaseOperation({databaseIdentifier: this.databaseIdentifier, name: "Tenant sync applied-sequence store"}, async (operation) => {
237
250
  return await callback(operation.connection())
@@ -247,6 +260,22 @@ export default class SyncAppliedSequenceStore {
247
260
  })
248
261
  }
249
262
 
263
+ /**
264
+ * Fails closed when a caller hands in an operation that does not belong to this store's database.
265
+ * @param {import("../database/operation.js").default} operation - Caller-owned operation.
266
+ * @returns {void} Nothing when the operation matches the store.
267
+ * @throws {Error} When the operation belongs to another database or another physical tenant database.
268
+ */
269
+ assertOperationOwnership(operation) {
270
+ if (operation.databaseIdentifier() !== this.databaseIdentifier) {
271
+ throw new Error(`Sync applied-sequence store operation belongs to another database: ${operation.databaseIdentifier()}`)
272
+ }
273
+
274
+ if (this.tenantHandle && operation.databaseIdentity() !== this.storeIdentity) {
275
+ throw new Error(`Sync applied-sequence store operation belongs to another physical database: ${operation.databaseIdentity()}`)
276
+ }
277
+ }
278
+
250
279
  /**
251
280
  * Ensures the applied-sequences table exists.
252
281
  * @param {import("../database/drivers/base.js").default} db - Database connection.
@@ -861,7 +861,7 @@ export default class SyncClient {
861
861
  const appliedSequences = this.appliedSequenceStore()
862
862
 
863
863
  if (serverSequence !== null) {
864
- const lastAppliedSequence = await appliedSequences.lastAppliedSequence({resourceId, resourceType})
864
+ const lastAppliedSequence = await appliedSequences.lastAppliedSequence({resourceId, resourceType, operation})
865
865
 
866
866
  if (lastAppliedSequence !== null && serverSequence <= lastAppliedSequence) {
867
867
  return {changed: false, resourceType}
@@ -888,7 +888,7 @@ export default class SyncClient {
888
888
  const result = await applier(sync)
889
889
 
890
890
  if (serverSequence !== null) {
891
- await appliedSequences.recordAppliedSequence({resourceId, resourceType, serverSequence})
891
+ await appliedSequences.recordAppliedSequence({resourceId, resourceType, serverSequence, operation})
892
892
  }
893
893
 
894
894
  return result
@@ -0,0 +1,56 @@
1
+ // @ts-check
2
+
3
+ /**
4
+ * @module sync-cursor
5
+ *
6
+ * Shared cursor helpers for the sync change feed: building a cursor from a
7
+ * serialized sync entry and ordering two cursors under the feed's stable order
8
+ * (server sequence when present, else updated-at then id). The server channel
9
+ * advances its per-subscription replay watermark with these across out-of-order
10
+ * live broadcasts, and the realtime bridge advances the persisted scope cursor
11
+ * monotonically on pushed changes.
12
+ */
13
+
14
+ /** @typedef {import("./sync-api-client-types.js").SyncCursor} SyncCursor */
15
+
16
+ /**
17
+ * Builds a cursor from a serialized sync entry, or null when the entry carries
18
+ * no cursor identity (no updated-at).
19
+ * @param {Record<string, ReturnType<typeof JSON.parse>>} entry - Serialized sync entry.
20
+ * @returns {SyncCursor} Cursor for the entry, or null.
21
+ */
22
+ export function cursorFromSyncEntry(entry) {
23
+ const updatedAt = entry.updatedAt
24
+
25
+ if (typeof updatedAt !== "string" || updatedAt === "") return null
26
+
27
+ return {
28
+ id: entry.id === null || entry.id === undefined ? null : String(entry.id),
29
+ serverSequence: typeof entry.serverSequence === "number" ? entry.serverSequence : null,
30
+ updatedAt
31
+ }
32
+ }
33
+
34
+ /**
35
+ * Whether one cursor is strictly later than another under the change-feed order.
36
+ * A sequenced cursor is always later than an unsequenced one; both sequenced
37
+ * cursors order by server sequence; both unsequenced cursors order by updated-at
38
+ * then id.
39
+ * @param {SyncCursor} candidate - Candidate cursor.
40
+ * @param {SyncCursor} current - Current cursor.
41
+ * @returns {boolean} Whether the candidate is later.
42
+ */
43
+ export function isCursorAfter(candidate, current) {
44
+ if (!candidate) return false
45
+ if (!current) return true
46
+
47
+ if (candidate.serverSequence !== null && current.serverSequence !== null) {
48
+ return candidate.serverSequence > current.serverSequence
49
+ }
50
+ if (candidate.serverSequence !== null) return true
51
+ if (current.serverSequence !== null) return false
52
+
53
+ if (candidate.updatedAt !== current.updatedAt) return candidate.updatedAt > current.updatedAt
54
+
55
+ return (candidate.id ?? "") > (current.id ?? "")
56
+ }