@dxos/feed 0.8.4-main.bc674ce → 0.8.4-main.ef1bc66f44

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 (45) hide show
  1. package/README.md +7 -2
  2. package/dist/lib/neutral/chunk-Q5PE2Q5P.mjs +735 -0
  3. package/dist/lib/neutral/chunk-Q5PE2Q5P.mjs.map +7 -0
  4. package/dist/lib/neutral/index.mjs +17 -0
  5. package/dist/lib/neutral/meta.json +1 -0
  6. package/dist/lib/neutral/testing/index.mjs +173 -0
  7. package/dist/lib/neutral/testing/index.mjs.map +7 -0
  8. package/dist/types/src/errors.d.ts +79 -0
  9. package/dist/types/src/errors.d.ts.map +1 -0
  10. package/dist/types/src/feed-store.d.ts +68 -9
  11. package/dist/types/src/feed-store.d.ts.map +1 -1
  12. package/dist/types/src/index.d.ts +3 -1
  13. package/dist/types/src/index.d.ts.map +1 -1
  14. package/dist/types/src/sync-client.d.ts +53 -0
  15. package/dist/types/src/sync-client.d.ts.map +1 -0
  16. package/dist/types/src/sync-server.d.ts +27 -0
  17. package/dist/types/src/sync-server.d.ts.map +1 -0
  18. package/dist/types/src/testing/index.d.ts +1 -1
  19. package/dist/types/src/testing/index.d.ts.map +1 -1
  20. package/dist/types/src/testing/test-builder.d.ts +78 -0
  21. package/dist/types/src/testing/test-builder.d.ts.map +1 -0
  22. package/dist/types/tsconfig.tsbuildinfo +1 -1
  23. package/package.json +16 -13
  24. package/src/errors.ts +33 -0
  25. package/src/feed-store.test.ts +283 -35
  26. package/src/feed-store.ts +479 -132
  27. package/src/index.ts +3 -1
  28. package/src/sync-client.ts +188 -0
  29. package/src/sync-server.ts +92 -0
  30. package/src/sync.test.ts +151 -91
  31. package/src/testing/index.ts +1 -1
  32. package/src/testing/test-builder.ts +223 -0
  33. package/dist/lib/browser/index.mjs +0 -342
  34. package/dist/lib/browser/index.mjs.map +0 -7
  35. package/dist/lib/browser/meta.json +0 -1
  36. package/dist/lib/browser/testing/index.mjs +0 -1
  37. package/dist/lib/node-esm/index.mjs +0 -344
  38. package/dist/lib/node-esm/index.mjs.map +0 -7
  39. package/dist/lib/node-esm/meta.json +0 -1
  40. package/dist/lib/node-esm/testing/index.mjs +0 -2
  41. package/dist/lib/node-esm/testing/index.mjs.map +0 -7
  42. package/dist/types/src/protocol.d.ts +0 -120
  43. package/dist/types/src/protocol.d.ts.map +0 -1
  44. package/src/protocol.ts +0 -110
  45. /package/dist/lib/{browser/testing → neutral}/index.mjs.map +0 -0
@@ -0,0 +1,735 @@
1
+ // src/errors.ts
2
+ import { BaseError } from "@dxos/errors";
3
+ var DuplicateBlockPositionError = class extends BaseError.extend("DuplicateBlockPositionError") {
4
+ constructor(args) {
5
+ super(`Non-unique block position detected (feedId=${args.feedId} position=${args.position}).`);
6
+ }
7
+ };
8
+ var DuplicateBlockLamportTimestampError = class extends BaseError.extend("DuplicateBlockLamportTimestampError") {
9
+ constructor(args) {
10
+ super(`Non-unique block Lamport timestamp detected (feedId=${args.feedId} actorId=${args.actorId} sequence=${args.sequence}).`);
11
+ }
12
+ };
13
+ var PositionConflictError = class extends BaseError.extend("PositionConflictError") {
14
+ constructor(args) {
15
+ super(`Block already has position ${args.currentPosition}, cannot set to ${args.requestedPosition} (feedId=${args.feedId} actorId=${args.actorId} sequence=${args.sequence}).`);
16
+ }
17
+ };
18
+
19
+ // src/feed-store.ts
20
+ import * as SqlClient from "@effect/sql/SqlClient";
21
+ import * as Effect from "effect/Effect";
22
+ import { Event } from "@dxos/async";
23
+ import { assertArgument } from "@dxos/invariant";
24
+ import { FeedProtocol } from "@dxos/protocols";
25
+ import { SqlTransaction } from "@dxos/sql-sqlite";
26
+ var FeedCursor = FeedProtocol.FeedCursor;
27
+ var isWellKnownNamespace = FeedProtocol.isWellKnownNamespace;
28
+ var FeedStore = class {
29
+ #options;
30
+ constructor(options) {
31
+ this.#options = options;
32
+ }
33
+ /**
34
+ * Emits after successful block append operations.
35
+ */
36
+ onNewBlocks = new Event();
37
+ /**
38
+ * Creates required feed store tables and indexes if they do not exist.
39
+ */
40
+ migrate = Effect.fn("FeedStore.migrate")(() => Effect.gen(function* () {
41
+ const sql = yield* SqlClient.SqlClient;
42
+ yield* sql`CREATE TABLE IF NOT EXISTS feeds (
43
+ feedPrivateId INTEGER PRIMARY KEY AUTOINCREMENT,
44
+ spaceId TEXT NOT NULL,
45
+ feedId TEXT NOT NULL,
46
+ feedNamespace TEXT
47
+ )`;
48
+ yield* sql`CREATE UNIQUE INDEX IF NOT EXISTS idx_feeds_spaceId_feedId ON feeds(spaceId, feedId)`;
49
+ yield* sql`CREATE TABLE IF NOT EXISTS blocks (
50
+ insertionId INTEGER PRIMARY KEY AUTOINCREMENT,
51
+ feedPrivateId INTEGER NOT NULL,
52
+ position INTEGER,
53
+ sequence INTEGER NOT NULL,
54
+ actorId TEXT NOT NULL,
55
+ prevSequence INTEGER,
56
+ prevActorId TEXT,
57
+ timestamp INTEGER NOT NULL,
58
+ data BLOB NOT NULL,
59
+ FOREIGN KEY(feedPrivateId) REFERENCES feeds(feedPrivateId)
60
+ )`;
61
+ yield* sql`CREATE UNIQUE INDEX IF NOT EXISTS idx_blocks_feedPrivateId_position ON blocks(feedPrivateId, position)`;
62
+ yield* sql`CREATE UNIQUE INDEX IF NOT EXISTS idx_blocks_feedPrivateId_sequence_actorId ON blocks(feedPrivateId, sequence, actorId)`;
63
+ yield* sql`CREATE TABLE IF NOT EXISTS subscriptions (
64
+ subscriptionId TEXT PRIMARY KEY,
65
+ expiresAt INTEGER NOT NULL,
66
+ feedPrivateIds TEXT NOT NULL -- JSON array
67
+ )`;
68
+ yield* sql`CREATE TABLE IF NOT EXISTS cursor_tokens (
69
+ spaceId TEXT PRIMARY KEY,
70
+ token TEXT NOT NULL
71
+ )`;
72
+ yield* sql`CREATE TABLE IF NOT EXISTS sync_state (
73
+ spaceId TEXT NOT NULL,
74
+ feedNamespace TEXT NOT NULL,
75
+ lastPulledPosition INTEGER NOT NULL DEFAULT -1,
76
+ PRIMARY KEY (spaceId, feedNamespace)
77
+ )`;
78
+ }).pipe(Effect.withSpan("FeedStore.migrate")));
79
+ /**
80
+ * Ensures a feed row exists and returns its internal feed ID.
81
+ */
82
+ #ensureFeed = Effect.fn("Feed.ensureFeed")((spaceId, feedId, namespace) => Effect.gen(this, function* () {
83
+ const sql = yield* SqlClient.SqlClient;
84
+ const rows = yield* sql`
85
+ SELECT feedPrivateId FROM feeds WHERE spaceId = ${spaceId} AND feedId = ${feedId}
86
+ `;
87
+ if (rows.length > 0) return rows[0].feedPrivateId;
88
+ const newRows = yield* sql`
89
+ INSERT INTO feeds (spaceId, feedId, feedNamespace) VALUES (${spaceId}, ${feedId}, ${namespace}) RETURNING feedPrivateId
90
+ `;
91
+ return newRows[0].feedPrivateId;
92
+ }).pipe(Effect.withSpan("FeedStore.ensureFeed")));
93
+ /**
94
+ * Ensures cursor token exists for a space and returns it.
95
+ */
96
+ #ensureCursorToken = Effect.fn("Feed.ensureCursorToken")((spaceId) => Effect.gen(this, function* () {
97
+ const sql = yield* SqlClient.SqlClient;
98
+ const rows = yield* sql`SELECT token FROM cursor_tokens WHERE spaceId = ${spaceId}`;
99
+ if (rows.length > 0) return rows[0].token;
100
+ const token = crypto.randomUUID().replace(/-/g, "").slice(0, 6);
101
+ yield* sql`INSERT INTO cursor_tokens (spaceId, token) VALUES (${spaceId}, ${token})`;
102
+ return token;
103
+ }).pipe(Effect.withSpan("FeedStore.ensureCursorToken")));
104
+ /**
105
+ * Queries feed blocks by feed IDs or subscription with cursor/position pagination.
106
+ */
107
+ query = Effect.fn("Feed.query")((request) => Effect.gen(this, function* () {
108
+ const sql = yield* SqlClient.SqlClient;
109
+ let feedIds = [];
110
+ let cursorInsertionId = -1;
111
+ let cursorToken;
112
+ if (!request.spaceId) {
113
+ return yield* Effect.die(new Error("spaceId is required"));
114
+ }
115
+ if ((request.position !== void 0 ? 1 : 0) + (request.cursor !== void 0 ? 1 : 0) + (request.unpositionedOnly === true ? 1 : 0) > 1) {
116
+ return yield* Effect.die(new Error("Only one of position, cursor, or unpositionedOnly can be used"));
117
+ }
118
+ if (request.cursor) {
119
+ const { token, insertionId } = decodeCursor(request.cursor);
120
+ if (!token || insertionId === void 0 || isNaN(insertionId)) {
121
+ return yield* Effect.die(new Error(`Invalid cursor format`));
122
+ }
123
+ cursorToken = token;
124
+ cursorInsertionId = insertionId;
125
+ }
126
+ const validCursorToken = yield* this.#ensureCursorToken(request.spaceId);
127
+ if (request.cursor && cursorToken !== validCursorToken) {
128
+ return yield* Effect.die(new Error(`Cursor token mismatch`));
129
+ }
130
+ const position = request.position ?? -1;
131
+ if (request.query && "subscriptionId" in request.query) {
132
+ const rows2 = yield* sql`
133
+ SELECT feedPrivateIds, expiresAt FROM subscriptions WHERE subscriptionId = ${request.query.subscriptionId}
134
+ `;
135
+ if (rows2.length > 0) {
136
+ const { feedPrivateIds, expiresAt } = rows2[0];
137
+ if (Date.now() <= expiresAt) {
138
+ const privateIds = JSON.parse(feedPrivateIds);
139
+ if (privateIds.length > 0) {
140
+ const feedRows = yield* sql`
141
+ SELECT feedId FROM feeds WHERE feedPrivateId IN ${sql.in(privateIds)}
142
+ `;
143
+ feedIds = feedRows.map((r) => r.feedId);
144
+ }
145
+ }
146
+ }
147
+ } else if (request.query && "feedIds" in request.query) {
148
+ feedIds = [
149
+ ...request.query.feedIds
150
+ ];
151
+ } else {
152
+ feedIds = void 0;
153
+ }
154
+ if (feedIds !== void 0 && feedIds.length === 0) {
155
+ return {
156
+ requestId: request.requestId,
157
+ blocks: [],
158
+ nextCursor: encodeCursor(validCursorToken, -1),
159
+ hasMore: false
160
+ };
161
+ }
162
+ const query = sql`
163
+ SELECT blocks.*, feeds.feedId, feeds.feedNamespace
164
+ FROM blocks
165
+ JOIN feeds ON blocks.feedPrivateId = feeds.feedPrivateId
166
+ WHERE 1=1
167
+ ${feedIds !== void 0 ? sql`AND feeds.feedId IN ${sql.in(feedIds)}` : sql``}
168
+ ${request.spaceId ? sql`AND feeds.spaceId = ${request.spaceId}` : sql``}
169
+ ${sql`AND feeds.feedNamespace = ${request.feedNamespace}`}
170
+ `;
171
+ const filter = request.cursor ? sql`AND blocks.insertionId > ${cursorInsertionId}` : request.unpositionedOnly ? sql`AND blocks.position IS NULL` : sql`AND (blocks.position > ${position} OR blocks.position IS NULL)`;
172
+ const orderBy = request.cursor ? sql`ORDER BY blocks.insertionId ASC` : sql`ORDER BY blocks.position ASC NULLS LAST`;
173
+ const requestLimit = request.limit;
174
+ const queryLimit = requestLimit != null ? requestLimit + 1 : void 0;
175
+ const rows = yield* sql`
176
+ ${query}
177
+ ${filter}
178
+ ${orderBy}
179
+ ${queryLimit != null ? sql`LIMIT ${queryLimit}` : sql``}
180
+ `;
181
+ const hasMore = requestLimit != null && rows.length > requestLimit;
182
+ const slice = hasMore ? rows.slice(0, requestLimit) : rows;
183
+ const blocks = slice.map((row) => ({
184
+ ...row,
185
+ // Have to clone buffer otherwise we get empty Uint8Array.
186
+ data: new Uint8Array(row.data)
187
+ }));
188
+ let nextCursor = request.cursor ?? encodeCursor(validCursorToken, -1);
189
+ if (blocks.length > 0 && request.spaceId) {
190
+ const lastBlock = blocks[blocks.length - 1];
191
+ if (lastBlock.insertionId !== void 0) {
192
+ nextCursor = encodeCursor(validCursorToken, lastBlock.insertionId);
193
+ }
194
+ }
195
+ return {
196
+ requestId: request.requestId,
197
+ blocks,
198
+ nextCursor,
199
+ hasMore
200
+ };
201
+ }).pipe(Effect.withSpan("FeedStore.query")));
202
+ /**
203
+ * Creates a subscription and stores the resolved internal feed IDs.
204
+ */
205
+ subscribe = Effect.fn("Feed.subscribe")((request) => Effect.gen(this, function* () {
206
+ const sql = yield* SqlClient.SqlClient;
207
+ const ttl = 60 * 60 * 1e3;
208
+ const subscriptionId = crypto.randomUUID();
209
+ const expiresAt = Date.now() + ttl;
210
+ if (!request.spaceId) {
211
+ return yield* Effect.die(new Error("spaceId required for subscribe"));
212
+ }
213
+ const feedPrivateIds = yield* Effect.forEach(request.feedIds, (feedId) => this.#ensureFeed(request.spaceId, feedId), {
214
+ concurrency: "unbounded"
215
+ });
216
+ yield* sql`
217
+ INSERT INTO subscriptions (subscriptionId, expiresAt, feedPrivateIds)
218
+ VALUES (${subscriptionId}, ${expiresAt}, ${JSON.stringify(feedPrivateIds)})
219
+ `;
220
+ return {
221
+ requestId: request.requestId,
222
+ subscriptionId,
223
+ expiresAt
224
+ };
225
+ }).pipe(Effect.withSpan("FeedStore.subscribe")));
226
+ /**
227
+ * Get the last pulled position for the given space and namespace.
228
+ * Returns -1 if no sync state exists yet.
229
+ */
230
+ getSyncState = (opts) => Effect.gen(this, function* () {
231
+ const sql = yield* SqlClient.SqlClient;
232
+ const rows = yield* sql`
233
+ SELECT lastPulledPosition FROM sync_state
234
+ WHERE spaceId = ${opts.spaceId} AND feedNamespace = ${opts.feedNamespace}
235
+ `;
236
+ return rows[0]?.lastPulledPosition ?? -1;
237
+ }).pipe(Effect.withSpan("FeedStore.getSyncState"));
238
+ /**
239
+ * Update the last pulled position for the given space and namespace.
240
+ */
241
+ setSyncState = (opts) => Effect.gen(this, function* () {
242
+ const sql = yield* SqlClient.SqlClient;
243
+ yield* sql`
244
+ INSERT INTO sync_state (spaceId, feedNamespace, lastPulledPosition)
245
+ VALUES (${opts.spaceId}, ${opts.feedNamespace}, ${opts.lastPulledPosition})
246
+ ON CONFLICT (spaceId, feedNamespace) DO UPDATE SET lastPulledPosition = ${opts.lastPulledPosition}
247
+ `;
248
+ }).pipe(Effect.withSpan("FeedStore.setSyncState"));
249
+ /**
250
+ * Validates that appended blocks do not introduce position or Lamport conflicts.
251
+ */
252
+ #validateAppendBlocks = Effect.fn("FeedStore.validateAppendBlocks")((blocks, feedPrivateIds) => Effect.gen(this, function* () {
253
+ const sql = yield* SqlClient.SqlClient;
254
+ const positionFeedIdByKey = /* @__PURE__ */ new Map();
255
+ const lamportFeedIdByKey = /* @__PURE__ */ new Map();
256
+ for (const block of blocks) {
257
+ const feedPrivateId = feedPrivateIds.get(block.feedId);
258
+ if (!this.#options.assignPositions && block.position != null) {
259
+ const positionKey = `${feedPrivateId}|${block.position}`;
260
+ if (positionFeedIdByKey.has(positionKey)) {
261
+ yield* Effect.fail(new DuplicateBlockPositionError({
262
+ feedId: block.feedId,
263
+ position: block.position
264
+ }));
265
+ }
266
+ positionFeedIdByKey.set(positionKey, block.feedId);
267
+ }
268
+ const lamportKey = `${feedPrivateId}|${block.actorId}|${block.sequence}`;
269
+ if (lamportFeedIdByKey.has(lamportKey)) {
270
+ yield* Effect.fail(new DuplicateBlockLamportTimestampError({
271
+ feedId: block.feedId,
272
+ actorId: block.actorId,
273
+ sequence: block.sequence
274
+ }));
275
+ }
276
+ lamportFeedIdByKey.set(lamportKey, block.feedId);
277
+ }
278
+ const lamportConditions = blocks.map((block) => {
279
+ const feedPrivateId = feedPrivateIds.get(block.feedId);
280
+ return sql`(feedPrivateId = ${feedPrivateId} AND actorId = ${block.actorId} AND sequence = ${block.sequence})`;
281
+ });
282
+ if (lamportConditions.length > 0) {
283
+ const existingLamports = yield* sql`
284
+ SELECT feedPrivateId, actorId, sequence
285
+ FROM blocks
286
+ WHERE ${sql.or(lamportConditions)}
287
+ LIMIT 1
288
+ `;
289
+ const lamportConflict = existingLamports[0];
290
+ if (lamportConflict) {
291
+ const key = `${lamportConflict.feedPrivateId}|${lamportConflict.actorId}|${lamportConflict.sequence}`;
292
+ yield* Effect.fail(new DuplicateBlockLamportTimestampError({
293
+ feedId: lamportFeedIdByKey.get(key),
294
+ actorId: lamportConflict.actorId,
295
+ sequence: lamportConflict.sequence
296
+ }));
297
+ }
298
+ }
299
+ if (!this.#options.assignPositions) {
300
+ const positionedBlocks = blocks.filter((block) => block.position != null);
301
+ const positionConditions = positionedBlocks.map((block) => {
302
+ const feedPrivateId = feedPrivateIds.get(block.feedId);
303
+ return sql`(feedPrivateId = ${feedPrivateId} AND position = ${block.position})`;
304
+ });
305
+ if (positionConditions.length > 0) {
306
+ const existingPositions = yield* sql`
307
+ SELECT feedPrivateId, position
308
+ FROM blocks
309
+ WHERE position IS NOT NULL
310
+ AND (${sql.or(positionConditions)})
311
+ LIMIT 1
312
+ `;
313
+ const positionConflict = existingPositions[0];
314
+ if (positionConflict) {
315
+ const key = `${positionConflict.feedPrivateId}|${positionConflict.position}`;
316
+ yield* Effect.fail(new DuplicateBlockPositionError({
317
+ feedId: positionFeedIdByKey.get(key),
318
+ position: positionConflict.position
319
+ }));
320
+ }
321
+ }
322
+ }
323
+ }));
324
+ /**
325
+ * Appends blocks for a space/namespace and optionally assigns global positions.
326
+ */
327
+ append = (request) => Effect.gen(this, function* () {
328
+ if (!request.spaceId) {
329
+ return yield* Effect.die(new Error("spaceId required for append"));
330
+ }
331
+ assertArgument(isWellKnownNamespace(request.feedNamespace), "request.feedNamespace", "specified well-known namespace");
332
+ for (const block of request.blocks) {
333
+ assertArgument(block.feedId, "block.feedId", "feedId is required");
334
+ }
335
+ const sqlTransaction = yield* SqlTransaction.SqlTransaction;
336
+ const positions = yield* sqlTransaction.withTransaction(Effect.gen(this, function* () {
337
+ const sql = yield* SqlClient.SqlClient;
338
+ const feedKeys = /* @__PURE__ */ new Map();
339
+ for (const block of request.blocks) {
340
+ const key = block.feedId;
341
+ if (!feedKeys.has(key)) {
342
+ feedKeys.set(key, {
343
+ feedId: block.feedId
344
+ });
345
+ }
346
+ }
347
+ const feedPrivateIds = /* @__PURE__ */ new Map();
348
+ yield* Effect.forEach([
349
+ ...feedKeys.entries()
350
+ ], ([key, { feedId }]) => Effect.gen(this, function* () {
351
+ const id = yield* this.#ensureFeed(request.spaceId, feedId, request.feedNamespace);
352
+ feedPrivateIds.set(key, id);
353
+ }), {
354
+ concurrency: "unbounded"
355
+ });
356
+ yield* this.#validateAppendBlocks(request.blocks, feedPrivateIds);
357
+ const maxPositions = /* @__PURE__ */ new Map();
358
+ if (this.#options.assignPositions) {
359
+ const maxPosResult = yield* sql`
360
+ SELECT MAX(position) as maxPos
361
+ FROM blocks
362
+ JOIN feeds ON blocks.feedPrivateId = feeds.feedPrivateId
363
+ WHERE feeds.spaceId = ${request.spaceId} AND feeds.feedNamespace = ${request.feedNamespace}
364
+ `;
365
+ maxPositions.set(request.feedNamespace, maxPosResult[0]?.maxPos ?? -1);
366
+ }
367
+ const positions2 = [];
368
+ for (const block of request.blocks) {
369
+ const key = block.feedId;
370
+ const feedPrivateId = feedPrivateIds.get(key);
371
+ let positionToInsert = null;
372
+ if (this.#options.assignPositions) {
373
+ const currentMax = maxPositions.get(request.feedNamespace);
374
+ positionToInsert = currentMax + 1;
375
+ maxPositions.set(request.feedNamespace, positionToInsert);
376
+ positions2.push(positionToInsert);
377
+ } else if (block.position != null) {
378
+ positionToInsert = block.position;
379
+ }
380
+ yield* sql`
381
+ INSERT INTO blocks (
382
+ feedPrivateId, position, sequence, actorId,
383
+ prevSequence, prevActorId, timestamp, data
384
+ ) VALUES (
385
+ ${feedPrivateId}, ${positionToInsert}, ${block.sequence}, ${block.actorId},
386
+ ${block.prevSequence}, ${block.prevActorId}, ${block.timestamp}, ${block.data}
387
+ ) ON CONFLICT DO NOTHING
388
+ `;
389
+ }
390
+ return positions2;
391
+ }));
392
+ this.onNewBlocks.emit();
393
+ return {
394
+ requestId: request.requestId,
395
+ positions
396
+ };
397
+ }).pipe(Effect.withSpan("FeedStore.append"));
398
+ /**
399
+ * Creates local blocks with sequential predecessors and appends grouped batches.
400
+ */
401
+ appendLocal = Effect.fn("Feed.appendLocal")((messages) => Effect.gen(this, function* () {
402
+ const sql = yield* SqlClient.SqlClient;
403
+ const feedKeys = /* @__PURE__ */ new Map();
404
+ for (const msg of messages) {
405
+ const key = `${msg.spaceId}|${msg.feedNamespace}|${msg.feedId}`;
406
+ if (!feedKeys.has(key)) {
407
+ feedKeys.set(key, {
408
+ spaceId: msg.spaceId,
409
+ feedId: msg.feedId,
410
+ feedNamespace: msg.feedNamespace
411
+ });
412
+ }
413
+ }
414
+ const feedPrivateIds = /* @__PURE__ */ new Map();
415
+ yield* Effect.forEach([
416
+ ...feedKeys.entries()
417
+ ], ([key, { spaceId, feedId, feedNamespace }]) => Effect.gen(this, function* () {
418
+ const id = yield* this.#ensureFeed(spaceId, feedId, feedNamespace);
419
+ feedPrivateIds.set(key, id);
420
+ }), {
421
+ concurrency: "unbounded"
422
+ });
423
+ const lastSeqs = /* @__PURE__ */ new Map();
424
+ for (const [key] of feedKeys) {
425
+ const feedPrivateId = feedPrivateIds.get(key);
426
+ const lastBlockResult = yield* sql`
427
+ SELECT sequence, actorId FROM blocks
428
+ WHERE feedPrivateId = ${feedPrivateId}
429
+ ORDER BY sequence DESC
430
+ LIMIT 1
431
+ `;
432
+ lastSeqs.set(key, lastBlockResult[0] ?? null);
433
+ }
434
+ const currentSeqs = /* @__PURE__ */ new Map();
435
+ const blocks = [];
436
+ const blocksBySpaceNamespace = /* @__PURE__ */ new Map();
437
+ for (const msg of messages) {
438
+ const key = `${msg.spaceId}|${msg.feedNamespace}|${msg.feedId}`;
439
+ let sequence;
440
+ let prevSequence;
441
+ let prevActorId;
442
+ const inFlight = currentSeqs.get(key);
443
+ if (inFlight) {
444
+ sequence = inFlight.sequence + 1;
445
+ prevSequence = inFlight.sequence;
446
+ prevActorId = inFlight.actorId;
447
+ } else {
448
+ const lastBlock = lastSeqs.get(key);
449
+ sequence = (lastBlock?.sequence ?? -1) + 1;
450
+ prevSequence = lastBlock?.sequence ?? null;
451
+ prevActorId = lastBlock?.actorId ?? null;
452
+ }
453
+ const block = {
454
+ feedId: msg.feedId,
455
+ actorId: this.#options.localActorId,
456
+ sequence,
457
+ prevActorId,
458
+ prevSequence,
459
+ timestamp: Date.now(),
460
+ data: msg.data,
461
+ position: null
462
+ };
463
+ blocks.push(block);
464
+ currentSeqs.set(key, {
465
+ sequence,
466
+ actorId: this.#options.localActorId
467
+ });
468
+ const spaceNamespaceKey = `${msg.spaceId}|${msg.feedNamespace}`;
469
+ if (!blocksBySpaceNamespace.has(spaceNamespaceKey)) {
470
+ blocksBySpaceNamespace.set(spaceNamespaceKey, {
471
+ spaceId: msg.spaceId,
472
+ feedNamespace: msg.feedNamespace,
473
+ blocks: []
474
+ });
475
+ }
476
+ blocksBySpaceNamespace.get(spaceNamespaceKey).blocks.push(block);
477
+ }
478
+ for (const { spaceId, feedNamespace, blocks: blocks2 } of blocksBySpaceNamespace.values()) {
479
+ yield* this.append({
480
+ requestId: "local-append",
481
+ blocks: blocks2,
482
+ spaceId,
483
+ feedNamespace
484
+ });
485
+ }
486
+ return blocks;
487
+ }).pipe(Effect.withSpan("FeedStore.appendLocal")));
488
+ /**
489
+ * Sets positions for existing blocks while preventing conflicting reassignments.
490
+ */
491
+ setPosition = (request) => Effect.gen(this, function* () {
492
+ const sql = yield* SqlClient.SqlClient;
493
+ for (const block of request.blocks) {
494
+ const existing = yield* sql`
495
+ SELECT position FROM blocks
496
+ WHERE feedPrivateId = (
497
+ SELECT feedPrivateId FROM feeds
498
+ WHERE spaceId = ${request.spaceId} AND feedId = ${block.feedId} AND feedNamespace = ${block.feedNamespace}
499
+ )
500
+ AND actorId = ${block.actorId} AND sequence = ${block.sequence}
501
+ `;
502
+ const current = existing[0];
503
+ if (current?.position != null && current.position !== block.position) {
504
+ yield* Effect.fail(new PositionConflictError({
505
+ feedId: block.feedId,
506
+ actorId: block.actorId,
507
+ sequence: block.sequence,
508
+ currentPosition: current.position,
509
+ requestedPosition: block.position
510
+ }));
511
+ }
512
+ yield* sql`
513
+ UPDATE blocks SET position = ${block.position}
514
+ WHERE feedPrivateId = (
515
+ SELECT feedPrivateId FROM feeds
516
+ WHERE spaceId = ${request.spaceId} AND feedId = ${block.feedId} AND feedNamespace = ${block.feedNamespace}
517
+ )
518
+ AND actorId = ${block.actorId} AND sequence = ${block.sequence}
519
+ `;
520
+ }
521
+ }).pipe(Effect.withSpan("FeedStore.setPosition"));
522
+ };
523
+ var encodeCursor = (token, insertionId) => FeedCursor.make(`${token}|${insertionId}`);
524
+ var decodeCursor = (cursor) => {
525
+ const [token, insertionId] = cursor.split("|");
526
+ return {
527
+ token,
528
+ insertionId: Number(insertionId)
529
+ };
530
+ };
531
+
532
+ // src/sync-server.ts
533
+ import * as Effect2 from "effect/Effect";
534
+ var SyncServer = class {
535
+ #peerId;
536
+ #feedStore;
537
+ #sendMessage;
538
+ constructor(options) {
539
+ this.#peerId = options.peerId;
540
+ this.#feedStore = options.feedStore;
541
+ this.#sendMessage = options.sendMessage;
542
+ }
543
+ /**
544
+ * Receive a message from a client. Handles QueryRequest and AppendRequest; sends response via sendMessage with correct peer ids.
545
+ */
546
+ handleMessage(message) {
547
+ const self = this;
548
+ const recipientPeerId = message.senderPeerId;
549
+ const withPeerIds = (payload) => ({
550
+ ...payload,
551
+ senderPeerId: self.#peerId,
552
+ recipientPeerId
553
+ });
554
+ switch (message._tag) {
555
+ case "QueryRequest": {
556
+ const req = message;
557
+ return Effect2.gen(function* () {
558
+ const response = yield* self.#feedStore.query(req);
559
+ yield* self.#sendMessage(withPeerIds({
560
+ _tag: "QueryResponse",
561
+ ...response
562
+ }));
563
+ }).pipe(Effect2.catchAll((err) => self.#sendMessage(withPeerIds({
564
+ _tag: "Error",
565
+ message: err instanceof Error ? err.message : String(err)
566
+ }))));
567
+ }
568
+ case "AppendRequest": {
569
+ const req = message;
570
+ return Effect2.gen(function* () {
571
+ const response = yield* self.#feedStore.append(req);
572
+ yield* self.#sendMessage(withPeerIds({
573
+ _tag: "AppendResponse",
574
+ ...response
575
+ }));
576
+ }).pipe(Effect2.catchAll((err) => self.#sendMessage(withPeerIds({
577
+ _tag: "Error",
578
+ message: err instanceof Error ? err.message : String(err)
579
+ }))));
580
+ }
581
+ default:
582
+ return Effect2.void;
583
+ }
584
+ }
585
+ };
586
+
587
+ // src/sync-client.ts
588
+ import * as Array from "effect/Array";
589
+ import * as Deferred from "effect/Deferred";
590
+ import * as Effect3 from "effect/Effect";
591
+ var SyncClient = class {
592
+ #peerId;
593
+ #serverPeerId;
594
+ #feedStore;
595
+ #sendMessage;
596
+ #handlers = /* @__PURE__ */ new Map();
597
+ constructor(options) {
598
+ this.#peerId = options.peerId;
599
+ this.#serverPeerId = options.serverPeerId;
600
+ this.#feedStore = options.feedStore;
601
+ this.#sendMessage = options.sendMessage;
602
+ }
603
+ #withPeerIds(payload) {
604
+ if (payload._tag === "QueryRequest") {
605
+ return {
606
+ ...payload,
607
+ senderPeerId: this.#peerId,
608
+ recipientPeerId: this.#serverPeerId
609
+ };
610
+ }
611
+ return {
612
+ ...payload,
613
+ senderPeerId: this.#peerId,
614
+ recipientPeerId: this.#serverPeerId
615
+ };
616
+ }
617
+ /**
618
+ * Receive a message from the server. If a handler is registered for the message's requestId, complete it and remove; else noop.
619
+ */
620
+ handleMessage(message) {
621
+ const requestId = "requestId" in message && message.requestId != null ? String(message.requestId) : void 0;
622
+ if (requestId == null) return Effect3.void;
623
+ const deferred = this.#handlers.get(requestId);
624
+ if (deferred == null) return Effect3.void;
625
+ this.#handlers.delete(requestId);
626
+ if (message._tag === "Error") {
627
+ return Effect3.andThen(Deferred.fail(deferred, new Error(message.message)), () => Effect3.void);
628
+ }
629
+ return Effect3.andThen(Deferred.succeed(deferred, message), () => Effect3.void);
630
+ }
631
+ pull(opts) {
632
+ const self = this;
633
+ return Effect3.gen(function* () {
634
+ const lastPulledPosition = yield* self.#feedStore.getSyncState({
635
+ spaceId: opts.spaceId,
636
+ feedNamespace: opts.feedNamespace
637
+ });
638
+ const requestId = crypto.randomUUID();
639
+ const deferred = yield* Deferred.make();
640
+ self.#handlers.set(requestId, deferred);
641
+ const request = {
642
+ _tag: "QueryRequest",
643
+ requestId,
644
+ spaceId: opts.spaceId,
645
+ feedNamespace: opts.feedNamespace,
646
+ position: lastPulledPosition,
647
+ limit: opts.limit
648
+ };
649
+ yield* self.#sendMessage(self.#withPeerIds(request));
650
+ const message = yield* Deferred.await(deferred);
651
+ const response = yield* self.#expectResponse(requestId, message, "QueryResponse");
652
+ if (response.blocks.length === 0) {
653
+ return {
654
+ done: true
655
+ };
656
+ }
657
+ yield* self.#feedStore.append({
658
+ spaceId: opts.spaceId,
659
+ feedNamespace: opts.feedNamespace,
660
+ blocks: response.blocks
661
+ });
662
+ const maxPulledPosition = response.blocks.reduce((max, block) => block.position != null && block.position > max ? block.position : max, lastPulledPosition);
663
+ yield* self.#feedStore.setSyncState({
664
+ spaceId: opts.spaceId,
665
+ feedNamespace: opts.feedNamespace,
666
+ lastPulledPosition: maxPulledPosition
667
+ });
668
+ return {
669
+ done: false
670
+ };
671
+ });
672
+ }
673
+ push(opts) {
674
+ const self = this;
675
+ return Effect3.gen(function* () {
676
+ const unpositioned = yield* self.#feedStore.query({
677
+ spaceId: opts.spaceId,
678
+ feedNamespace: opts.feedNamespace,
679
+ unpositionedOnly: true,
680
+ limit: opts.limit
681
+ });
682
+ if (unpositioned.blocks.length === 0) {
683
+ return {
684
+ done: true
685
+ };
686
+ }
687
+ const requestId = crypto.randomUUID();
688
+ const deferred = yield* Deferred.make();
689
+ self.#handlers.set(requestId, deferred);
690
+ const request = {
691
+ _tag: "AppendRequest",
692
+ requestId,
693
+ spaceId: opts.spaceId,
694
+ feedNamespace: opts.feedNamespace,
695
+ blocks: unpositioned.blocks
696
+ };
697
+ yield* self.#sendMessage(self.#withPeerIds(request));
698
+ const message = yield* Deferred.await(deferred);
699
+ const response = yield* self.#expectResponse(requestId, message, "AppendResponse");
700
+ yield* self.#feedStore.setPosition({
701
+ spaceId: opts.spaceId,
702
+ blocks: Array.zipWith(response.positions, unpositioned.blocks, (position, block) => ({
703
+ feedId: block.feedId,
704
+ feedNamespace: opts.feedNamespace,
705
+ actorId: block.actorId,
706
+ sequence: block.sequence,
707
+ position
708
+ }))
709
+ });
710
+ return {
711
+ done: false
712
+ };
713
+ });
714
+ }
715
+ #expectResponse(requestId, message, expectedTag) {
716
+ if (message._tag === "Error") {
717
+ return Effect3.fail(new Error(message.message));
718
+ }
719
+ const requestIdMsg = "requestId" in message ? String(message.requestId) : void 0;
720
+ if (message._tag !== expectedTag || requestIdMsg !== requestId) {
721
+ return Effect3.fail(new Error(`Unexpected message: expected ${expectedTag} with requestId ${requestId}`));
722
+ }
723
+ return Effect3.succeed(message);
724
+ }
725
+ };
726
+
727
+ export {
728
+ DuplicateBlockPositionError,
729
+ DuplicateBlockLamportTimestampError,
730
+ PositionConflictError,
731
+ FeedStore,
732
+ SyncServer,
733
+ SyncClient
734
+ };
735
+ //# sourceMappingURL=chunk-Q5PE2Q5P.mjs.map