foldkit-sync 0.15.0 → 0.17.0

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 (49) hide show
  1. package/README.md +567 -41
  2. package/dist/diagnostics.d.ts +74 -3
  3. package/dist/diagnostics.d.ts.map +1 -1
  4. package/dist/diagnostics.js +60 -4
  5. package/dist/diagnostics.js.map +1 -1
  6. package/dist/do.d.ts +49 -7
  7. package/dist/do.d.ts.map +1 -1
  8. package/dist/do.js +91 -8
  9. package/dist/do.js.map +1 -1
  10. package/dist/errors.d.ts +92 -1
  11. package/dist/errors.d.ts.map +1 -1
  12. package/dist/errors.js +87 -1
  13. package/dist/errors.js.map +1 -1
  14. package/dist/index.d.ts +9 -5
  15. package/dist/index.d.ts.map +1 -1
  16. package/dist/index.js +6 -2
  17. package/dist/index.js.map +1 -1
  18. package/dist/journal.d.ts +52 -27
  19. package/dist/journal.d.ts.map +1 -1
  20. package/dist/journal.js +176 -64
  21. package/dist/journal.js.map +1 -1
  22. package/dist/make.d.ts +48 -17
  23. package/dist/make.d.ts.map +1 -1
  24. package/dist/make.js +11 -4
  25. package/dist/make.js.map +1 -1
  26. package/dist/migrations.d.ts +37 -0
  27. package/dist/migrations.d.ts.map +1 -0
  28. package/dist/migrations.js +56 -0
  29. package/dist/migrations.js.map +1 -0
  30. package/dist/mount.d.ts +1 -1
  31. package/dist/mount.d.ts.map +1 -1
  32. package/dist/mount.js +12 -6
  33. package/dist/mount.js.map +1 -1
  34. package/dist/refusal.d.ts +33 -0
  35. package/dist/refusal.d.ts.map +1 -0
  36. package/dist/refusal.js +47 -0
  37. package/dist/refusal.js.map +1 -0
  38. package/dist/serverJournal.d.ts +143 -0
  39. package/dist/serverJournal.d.ts.map +1 -0
  40. package/dist/serverJournal.js +503 -0
  41. package/dist/serverJournal.js.map +1 -0
  42. package/dist/sync.d.ts +150 -14
  43. package/dist/sync.d.ts.map +1 -1
  44. package/dist/sync.js +273 -64
  45. package/dist/sync.js.map +1 -1
  46. package/dist/transport.d.ts +10 -6
  47. package/dist/transport.d.ts.map +1 -1
  48. package/dist/transport.js.map +1 -1
  49. package/package.json +11 -8
package/dist/sync.d.ts CHANGED
@@ -1,12 +1,23 @@
1
1
  import { Effect, Metric, Option, Schema, Stream } from "effect";
2
2
  import { Transport, TransportError } from "./transport.js";
3
3
  import { Storage } from "./indexedDb.js";
4
+ import { Migrations } from "./migrations.js";
5
+ import { SyncRefusal } from "./refusal.js";
4
6
  import { DocumentId, LocalSequence, OpId, ReplicaId, Sequence } from "./ids.js";
5
7
  import { ReplicaError } from "./errors.js";
6
8
  /** Wire and persisted-format versions. A bump must handle the older value explicitly. */
7
9
  declare const PROTOCOL_VERSION = 1;
8
10
  declare const SCHEMA_VERSION = 1;
9
- /** A client-authored operation envelope. `message` is the application's encoded Message. */
11
+ /**
12
+ * Replica ids the server's own operations use (`foldkit-sync/journal`'s
13
+ * `serverJournal`): a sent entry may not claim one, or it could bind the id to
14
+ * its actor first and have the server's append refused.
15
+ */
16
+ export declare const SERVER_REPLICA_PREFIX = "server/";
17
+ /**
18
+ * A client-authored operation envelope. `message` is the application's
19
+ * Message, encoded at the current version of the document's history.
20
+ */
10
21
  declare const OperationSchema: Schema.Struct<{
11
22
  readonly protocolVersion: Schema.Literal<1>;
12
23
  readonly schemaVersion: Schema.Literal<1>;
@@ -18,6 +29,24 @@ declare const OperationSchema: Schema.Struct<{
18
29
  readonly message: Schema.Unknown;
19
30
  }>;
20
31
  export type Operation = typeof OperationSchema.Type;
32
+ /**
33
+ * Branded, so only Sync makes one: decoding an entry, or writing an
34
+ * `Operation` at the current version (`journalContract().operation.encode`).
35
+ * A decoded `Operation` is not one, since its missing `messageVersion` would
36
+ * read as version 1 and be upcast again.
37
+ */
38
+ declare const WrittenOperationSchema: Schema.brand<Schema.Struct<{
39
+ readonly protocolVersion: Schema.Literal<1>;
40
+ readonly schemaVersion: Schema.Literal<1>;
41
+ readonly documentId: Schema.brand<Schema.NonEmptyString, "@foldkit-sync/DocumentId">;
42
+ readonly replicaId: Schema.brand<Schema.NonEmptyString, "@foldkit-sync/ReplicaId">;
43
+ readonly localSequence: Schema.brand<Schema.Number, "@foldkit-sync/LocalSequence">;
44
+ readonly opId: Schema.brand<Schema.NonEmptyString, "@foldkit-sync/OpId">;
45
+ readonly baseCursor: Schema.brand<Schema.Number, "@foldkit-sync/Sequence">;
46
+ readonly message: Schema.Unknown;
47
+ readonly messageVersion: Schema.optionalKey<Schema.Int>;
48
+ }>, "foldkit-sync/WrittenOperation">;
49
+ export type WrittenOperation = typeof WrittenOperationSchema.Type;
21
50
  /** An operation the server committed, with its authoritative order and actor. */
22
51
  declare const CommittedSchema: Schema.Struct<{
23
52
  readonly protocolVersion: Schema.Literal<1>;
@@ -33,6 +62,20 @@ declare const CommittedSchema: Schema.Struct<{
33
62
  }>;
34
63
  /** Named to avoid colliding with `foldkit-durable`'s `Committed`. */
35
64
  export type CommittedOperation = typeof CommittedSchema.Type;
65
+ /**
66
+ * A type-only mark on what `codec.committedFrom` returns. It reads its input as
67
+ * history, so it skips the checks of a sent entry, and
68
+ * `journalContract().operation.encode` refuses it, stripped of its commit or not.
69
+ */
70
+ export interface ReadAsHistory {
71
+ readonly '~foldkit-sync/history': true;
72
+ }
73
+ /**
74
+ * An envelope as written, checked for its shape and nothing else: for the
75
+ * server's own operations (`serverJournal`), whose bytes it wrote or recorded.
76
+ * Never for an entry someone sent.
77
+ */
78
+ export declare const writtenEnvelope: (input: unknown) => WrittenOperation;
36
79
  /** Counters and a histogram an application can scrape. */
37
80
  export declare const syncMetrics: {
38
81
  exchanges: Metric.Counter<number>;
@@ -49,8 +92,16 @@ export interface Exchange<Shared> {
49
92
  readonly operations: ReadonlyArray<unknown>;
50
93
  readonly rejected: ReadonlyArray<OpId>;
51
94
  /**
52
- * Why some of `rejected` were refused, in words the server chose for a person:
53
- * a policy's reason, never an internal error. One without a reason is still rejected.
95
+ * Why some of `rejected` were refused, each an encoded `SyncRefusal`. One
96
+ * without a refusal is still rejected.
97
+ */
98
+ readonly refusals?: ReadonlyArray<{
99
+ readonly opId: OpId;
100
+ readonly refusal: typeof SyncRefusal.Encoded;
101
+ }> | undefined;
102
+ /**
103
+ * @deprecated Send `refusals`; removed in the next release. Words the server
104
+ * chose for a person, for some of `rejected`.
54
105
  */
55
106
  readonly reasons?: ReadonlyArray<{
56
107
  readonly opId: OpId;
@@ -79,7 +130,10 @@ export interface ReplicaState<Shared> {
79
130
  readonly cursor: Sequence;
80
131
  readonly committed: Shared;
81
132
  readonly committedIds: ReadonlyArray<string>;
82
- readonly pending: ReadonlyArray<Operation>;
133
+ /** Operations not yet committed, as written. */
134
+ readonly pending: ReadonlyArray<WrittenOperation>;
135
+ /** Operations this build cannot read, kept as written until dismissed; absent when none. */
136
+ readonly refused?: ReadonlyArray<WrittenOperation>;
83
137
  /** The server history `cursor` points into, once an exchange has named one. */
84
138
  readonly epoch?: string;
85
139
  }
@@ -88,8 +142,12 @@ export interface ReplicaState<Shared> {
88
142
  * is the primary seam.
89
143
  */
90
144
  export interface TransportClient {
91
- /** `epoch` is the server history the replica's cursor points into, when it knows one. */
92
- exchange(cursor: Sequence, pending: ReadonlyArray<Operation>, epoch?: string | undefined): Promise<unknown>;
145
+ /**
146
+ * `epoch` is the server history the replica's cursor points into, when it
147
+ * knows one. `pending` is unread, as on every transport seam: a server reads
148
+ * each entry with `codec.writtenFrom`, which refuses what only it may append.
149
+ */
150
+ exchange(cursor: Sequence, pending: ReadonlyArray<unknown>, epoch?: string | undefined): Promise<unknown>;
93
151
  }
94
152
  /** A redacted view of a replica's state, for a UI to explain and recover. */
95
153
  export interface ReplicaStatus {
@@ -99,6 +157,13 @@ export interface ReplicaStatus {
99
157
  readonly lastError: string | undefined;
100
158
  /** Operations the server refused, most recent first, with its reason when it gave one. */
101
159
  readonly rejected: ReadonlyArray<Rejection>;
160
+ /**
161
+ * Operations this build cannot read, as written: an older version of the
162
+ * document's Message that no step of its history reads, found in the outbox
163
+ * or refused by the server as `Unreadable`. Never sent; kept, with their
164
+ * payload, until `Replica.dismiss`.
165
+ */
166
+ readonly refused: ReadonlyArray<WrittenOperation>;
102
167
  /**
103
168
  * The server history the cursor points into, once a server named one. A new
104
169
  * one means the server was reset: what the replica had committed is gone.
@@ -112,8 +177,20 @@ export interface ReplicaStatus {
112
177
  */
113
178
  export interface Rejection {
114
179
  readonly opId: OpId;
180
+ /**
181
+ * Why, typed. None when the server named no refusal (an older or a custom
182
+ * server), or one this build cannot read (reported as `UnknownRefusal`).
183
+ */
184
+ readonly refusal: Option.Option<SyncRefusal>;
185
+ /**
186
+ * @deprecated Read `refusal`, through `SyncRefusal.match`; removed in the
187
+ * next release. The server's words from its `reasons`.
188
+ */
115
189
  readonly reason: Option.Option<string>;
116
- readonly operation: Operation;
190
+ /** The operation as it was sent: its Message at the version it was written at. */
191
+ readonly operation: WrittenOperation;
192
+ /** The operation's Message, encoded at the current version: what to read it by. */
193
+ readonly message: unknown;
117
194
  }
118
195
  /**
119
196
  * A consistent status and optimistic-shared pair, read from one replica state.
@@ -142,7 +219,8 @@ export interface Replica<Message, Shared> {
142
219
  * rejected one never does.
143
220
  */
144
221
  readonly committed: Effect.Effect<Shared>;
145
- readonly pending: Effect.Effect<ReadonlyArray<Operation>>;
222
+ /** The outbox, as written. */
223
+ readonly pending: Effect.Effect<ReadonlyArray<WrittenOperation>>;
146
224
  readonly cursor: Effect.Effect<Sequence>;
147
225
  /**
148
226
  * Waiting/recovery information without exposing Messages or the Model. It is a
@@ -171,14 +249,34 @@ export interface Replica<Message, Shared> {
171
249
  * with `Effect.forkScoped` and provide `Transport`.
172
250
  */
173
251
  readonly start: Effect.Effect<void, never, Transport>;
252
+ /** Forgets a `status.refused` operation, its payload with it. One that is not there changes nothing. */
253
+ dismiss(opId: OpId): Effect.Effect<void, ReplicaError>;
174
254
  readonly close: Effect.Effect<void>;
175
255
  }
176
- export interface SyncDefinition<Message, Shared, MessageEncoded, SharedEncoded> {
177
- readonly documentId: DocumentId;
256
+ /**
257
+ * The document's Message: one Schema, at version 1, or its history
258
+ * (`Sync.migrations`), whose current Schema is the Message.
259
+ */
260
+ export type MessageHistory<Message, MessageEncoded> = {
178
261
  readonly message: Schema.Codec<Message, MessageEncoded, never, never>;
262
+ readonly migrations?: undefined;
263
+ } | {
264
+ /** The Schemas operations may be stored in, and how each becomes the next. */
265
+ readonly migrations: Migrations<Message, MessageEncoded>;
266
+ readonly message?: undefined;
267
+ };
268
+ export type SyncDefinition<Message, Shared, MessageEncoded, SharedEncoded> = SyncDefinitionOptions<Message, Shared, SharedEncoded> & MessageHistory<Message, MessageEncoded>;
269
+ export interface SyncDefinitionOptions<Message, Shared, SharedEncoded> {
270
+ readonly documentId: DocumentId;
179
271
  readonly shared: Schema.Codec<Shared, SharedEncoded, never, never>;
180
272
  readonly empty: Shared;
181
273
  readonly durable: (message: Message) => boolean;
274
+ /**
275
+ * Optional. The Messages only the server appends: stored and replayed like
276
+ * durable ones, never accepted from a replica. A Message both predicates
277
+ * accept is refused wherever it is read.
278
+ */
279
+ readonly serverOnly?: ((message: Message) => boolean) | undefined;
182
280
  readonly replay: (shared: Shared, message: Message) => Shared;
183
281
  /**
184
282
  * Optional. Merges a durable Message into the one submitted before it, while that one
@@ -212,15 +310,39 @@ export interface Sync<Message, Shared, Durable = Message> {
212
310
  readonly documentId: DocumentId;
213
311
  /** Whether a Message is one the replica records and replays. */
214
312
  readonly durable: (message: Message) => boolean;
313
+ /** Whether a Message is one only the server appends: replicas replay it and never submit it. */
314
+ readonly serverOnly: (message: Message) => boolean;
215
315
  /**
216
316
  * Low-level wire codecs for adapters and the transport. Most applications use
217
317
  * `journalContract` and `openReplica`; these are exposed for a custom
218
318
  * transport or a server that must speak the operation envelope directly.
219
319
  */
220
320
  readonly codec: {
321
+ /** The current version of the document's Message history: 1 with no migrations. */
322
+ readonly messageVersion: number;
323
+ /** The document's Message at its current version: what every hook decodes. */
324
+ readonly message: Schema.Codec<Message, unknown, never, never>;
325
+ /**
326
+ * An entry someone sent, read: its Message upcast to the current version.
327
+ * Throws `UnsupportedMessageVersionError` for a newer version,
328
+ * `UnreadableMessageError` for an older one no step reads, and
329
+ * `ServerOnlyMessageError` for a Message only the server appends; it
330
+ * refuses a replica id under `server/` or past 128 characters. Read
331
+ * stored history with `journalContract().operation.decode`, which takes
332
+ * the server's Messages too.
333
+ */
221
334
  readonly normalizeOperation: (input: unknown) => Operation;
335
+ /** `normalizeOperation`, of this document only. */
222
336
  readonly operationFrom: (input: unknown, documentId: DocumentId) => Operation;
223
- readonly committedFrom: (input: unknown, documentId: DocumentId) => CommittedOperation;
337
+ /**
338
+ * An entry as received, checked as an envelope of this document and read
339
+ * as `normalizeOperation` reads it, and returned as written: what a server
340
+ * appends. A custom server reads every entry with it before appending.
341
+ * Never pass it an `Operation`: that Message is already current and would
342
+ * be read as version 1. Write one with `journalContract().operation.encode`.
343
+ */
344
+ readonly writtenFrom: (input: unknown, documentId: DocumentId) => WrittenOperation;
345
+ readonly committedFrom: (input: unknown, documentId: DocumentId) => CommittedOperation & ReadAsHistory;
224
346
  readonly decodeExchange: (input: unknown) => Exchange<Shared>;
225
347
  };
226
348
  /** The codecs and pure reducer `foldkit-durable`'s `makeJournal` consumes. */
@@ -248,9 +370,23 @@ export interface JournalContract<Operation, Shared> {
248
370
  /** Sync's operation id includes the replica, even after Durable compacts its payload. */
249
371
  readonly legacyReplicaId: (opId: string) => string;
250
372
  readonly operation: {
251
- /** Operations are stored in their encoded form, so this is the identity. */
252
- readonly encode: (operation: Operation) => Operation;
253
- readonly decode: (input: unknown) => Operation;
373
+ /** Written at the current version: what the journal stores. */
374
+ readonly encode: (operation: Operation & {
375
+ readonly '~foldkit-sync/history'?: never;
376
+ }) => WrittenOperation;
377
+ /**
378
+ * Read from any version the history has, upcast to the current one: stored
379
+ * history, so the server's own Messages read too. Never the reader of an
380
+ * entry someone sent (`codec.writtenFrom`).
381
+ */
382
+ readonly decode: (input: WrittenOperation) => Operation;
383
+ /**
384
+ * What a retransmission is compared by: the operation normalized at the
385
+ * version it was written at, as the build that wrote it normalized it, so
386
+ * an edit committed before a deploy is still recognized after it. Only
387
+ * hashed: never an entry to append.
388
+ */
389
+ readonly compared: (input: unknown) => unknown;
254
390
  };
255
391
  readonly snapshot: {
256
392
  readonly encode: (snapshot: Shared) => unknown;
@@ -1 +1 @@
1
- {"version":3,"file":"sync.d.ts","names":[],"sources":["../src/sync.ts"],"mappings":";;;;;;cAyCM;cACA;;cAGA,iBAAe,OAAA;;;;;;;;;;YAUT,mBAAmB,gBAAgB;;cAGzC,iBAAe,OAAA;;;;;;;;;;;;;YAMT,4BAA4B,gBAAgB;;qBAiB3C;EACX,WAAS,OAAA;EACT,SAAO,OAAA;EACP,aAAW,OAAA;EACX,iBAAe,OAAA;;iBAKA,WAAW;WACjB,QAAQ;WACR,OAAO;;iBAGD,SAAS;;WAEf,YAAY;WACZ,UAAU,cAAc;;;;;WAKxB,UAAU;aAAyB,MAAM;aAAe;;;WAExD,eAAe,cAAc;;WAE7B,aAAa,WAAW;;WAExB;;;;;;WAMA;;iBAGM,aAAa;WACnB,wBAAwB;WACxB,sBAAsB;WACtB,YAAY;WACZ,WAAW;WACX;WACA,mBAAmB;WACnB,QAAQ;WACR,WAAW;WACX,cAAc;WACd,SAAS,cAAc;;WAEvB;;;;;;iBAOM;;EAEf,SACE,QAAQ,UACR,SAAS,cAAc,YACvB,6BACC;;;iBAIY;WACN;WACA,QAAQ;;WAER;;WAEA,UAAU,cAAc;;;;;WAKxB,OAAO,OAAO;;;;;;;iBAQR;WACN,MAAM;WACN,QAAQ,OAAO;WACf,WAAW;;;;;;iBAOL,gBAAgB;WACtB,QAAQ;WACR,QAAQ;;WAER,WAAW;;;;;;WAMX,mBAAmB;;iBAGb,QAAQ,SAAS;;WAEvB,WAAW;;WAEX,QAAQ,OAAO,OAAO;;;;;;WAMtB,WAAW,OAAO,OAAO;WACzB,SAAS,OAAO,OAAO,cAAc;WACrC,QAAQ,OAAO,OAAO;;;;;WAKtB,QAAQ,OAAO,OAAO;;WAEtB,eAAe,OAAO,OAAO;;;;;WAK7B,SAAS,OAAO,OAAO,gBAAgB;;WAEvC,UAAU,OAAO,OAAO,gBAAgB;;EAIjD,OAAO,SAAS,UAAU,OAAO,aAAa;;WAErC,aAAa,OAAO,aAAa,eAAe,gBAAgB;;;;;;;;;WAShE,OAAO,OAAO,oBAAoB;WAClC,OAAO,OAAO;;iBAGR,eAAe,SAAS,QAAQ,gBAAgB;WACtD,YAAY;WACZ,SAAS,OAAO,MAAM,SAAS;WAC/B,QAAQ,OAAO,MAAM,QAAQ;WAC7B,OAAO;WACP,UAAU,SAAS;WACnB,SAAS,QAAQ,QAAQ,SAAS,YAAY;;;;;;WAM9C,aAAa,MAAM,SAAS,MAAM,YAAY;;;;;;WAM9C,UAAU,SAAS,SAAS,QAAQ,gBAAgB;;;;;;;iBAQ9C;WACN;WACA;WACA;;;;;;;iBAQM,KAAK,SAAS,QAAQ,UAAU;WACtC,YAAY;;WAEZ,UAAU,SAAS;;;;;;WAMnB;aACE,qBAAqB,mBAAmB;aACxC,gBAAgB,gBAAgB,YAAY,eAAe;aAC3D,gBAAgB,gBAAgB,YAAY,eAAe;aAC3D,iBAAiB,mBAAmB,SAAS;;;WAG/C,uBAAuB,gBAAgB,WAAW;;;;;;WAMlD,cACP,SAAS,SACT,UAAU,uBACP,OAAO,OAAO,QAAQ,SAAS,SAAS;;iBAG9B;;;;;;;WAON,YAAY;;;iBAIN,gBAAgB,WAAW;;WAEjC,YAAY,WAAW;;WAEvB,kBAAkB;WAClB;;aAEE,SAAS,WAAW,cAAc;aAClC,SAAS,mBAAmB;;WAE9B;aACE,SAAS,UAAU;aACnB,SAAS,mBAAmB;;WAE9B,aAAa;WACb,SAAS,UAAU,QAAQ,WAAW,cAAc;;WAEpD,SACP,WAAW,WACX;aAAmB;aAA2B;QAC3C;;;;;;;;;qBAUM,aAAc,SAAS,QAAQ,gBAAgB,eAAa,YAC3D,eAAe,SAAS,QAAQ,gBAAgB,mBAC3D,KAAK,SAAS"}
1
+ {"version":3,"file":"sync.d.ts","names":[],"sources":["../src/sync.ts"],"mappings":"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"}