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.
- package/build/background-jobs/main.js +10 -2
- package/build/configuration-types.js +1 -1
- package/build/database/advisory-lock-reentrancy-node.js +9 -0
- package/build/database/advisory-lock-reentrancy.js +66 -0
- package/build/database/advisory-lock-runner.js +9 -12
- package/build/database/pool/single-multi-use.js +3 -2
- package/build/environment-handlers/node.js +1 -0
- package/build/src/background-jobs/main.d.ts.map +1 -1
- package/build/src/background-jobs/main.js +11 -4
- package/build/src/configuration-types.d.ts +2 -2
- package/build/src/configuration-types.js +2 -2
- package/build/src/database/advisory-lock-reentrancy-node.d.ts +2 -0
- package/build/src/database/advisory-lock-reentrancy-node.d.ts.map +1 -0
- package/build/src/database/advisory-lock-reentrancy-node.js +7 -0
- package/build/src/database/advisory-lock-reentrancy.d.ts +67 -0
- package/build/src/database/advisory-lock-reentrancy.d.ts.map +1 -0
- package/build/src/database/advisory-lock-reentrancy.js +60 -0
- package/build/src/database/advisory-lock-runner.d.ts +25 -33
- package/build/src/database/advisory-lock-runner.d.ts.map +1 -1
- package/build/src/database/advisory-lock-runner.js +10 -13
- package/build/src/database/pool/single-multi-use.d.ts.map +1 -1
- package/build/src/database/pool/single-multi-use.js +4 -3
- package/build/src/environment-handlers/node.d.ts +1 -0
- package/build/src/environment-handlers/node.d.ts.map +1 -1
- package/build/src/environment-handlers/node.js +2 -1
- package/build/src/sync/sync-applied-sequence-store.d.ts +27 -8
- package/build/src/sync/sync-applied-sequence-store.d.ts.map +1 -1
- package/build/src/sync/sync-applied-sequence-store.js +43 -18
- package/build/src/sync/sync-client.js +3 -3
- package/build/src/sync/sync-cursor.d.ts +30 -0
- package/build/src/sync/sync-cursor.d.ts.map +1 -0
- package/build/src/sync/sync-cursor.js +54 -0
- package/build/src/sync/sync-realtime-bridge.d.ts +127 -24
- package/build/src/sync/sync-realtime-bridge.d.ts.map +1 -1
- package/build/src/sync/sync-realtime-bridge.js +92 -56
- package/build/src/sync/sync-websocket-channel.d.ts +49 -0
- package/build/src/sync/sync-websocket-channel.d.ts.map +1 -1
- package/build/src/sync/sync-websocket-channel.js +138 -2
- package/build/sync/sync-applied-sequence-store.js +46 -17
- package/build/sync/sync-client.js +2 -2
- package/build/sync/sync-cursor.js +56 -0
- package/build/sync/sync-realtime-bridge.js +97 -51
- package/build/sync/sync-websocket-channel.js +153 -1
- package/package.json +1 -1
- package/src/background-jobs/main.js +10 -2
- package/src/configuration-types.js +1 -1
- package/src/database/advisory-lock-reentrancy-node.js +9 -0
- package/src/database/advisory-lock-reentrancy.js +66 -0
- package/src/database/advisory-lock-runner.js +9 -12
- package/src/database/pool/single-multi-use.js +3 -2
- package/src/environment-handlers/node.js +1 -0
- package/src/sync/sync-applied-sequence-store.js +46 -17
- package/src/sync/sync-client.js +2 -2
- package/src/sync/sync-cursor.js +56 -0
- package/src/sync/sync-realtime-bridge.js +97 -51
- 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(
|
|
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(
|
|
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,
|
|
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
|
|
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
|
+
}
|