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.
- package/README.md +567 -41
- package/dist/diagnostics.d.ts +74 -3
- package/dist/diagnostics.d.ts.map +1 -1
- package/dist/diagnostics.js +60 -4
- package/dist/diagnostics.js.map +1 -1
- package/dist/do.d.ts +49 -7
- package/dist/do.d.ts.map +1 -1
- package/dist/do.js +91 -8
- package/dist/do.js.map +1 -1
- package/dist/errors.d.ts +92 -1
- package/dist/errors.d.ts.map +1 -1
- package/dist/errors.js +87 -1
- package/dist/errors.js.map +1 -1
- package/dist/index.d.ts +9 -5
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +6 -2
- package/dist/index.js.map +1 -1
- package/dist/journal.d.ts +52 -27
- package/dist/journal.d.ts.map +1 -1
- package/dist/journal.js +176 -64
- package/dist/journal.js.map +1 -1
- package/dist/make.d.ts +48 -17
- package/dist/make.d.ts.map +1 -1
- package/dist/make.js +11 -4
- package/dist/make.js.map +1 -1
- package/dist/migrations.d.ts +37 -0
- package/dist/migrations.d.ts.map +1 -0
- package/dist/migrations.js +56 -0
- package/dist/migrations.js.map +1 -0
- package/dist/mount.d.ts +1 -1
- package/dist/mount.d.ts.map +1 -1
- package/dist/mount.js +12 -6
- package/dist/mount.js.map +1 -1
- package/dist/refusal.d.ts +33 -0
- package/dist/refusal.d.ts.map +1 -0
- package/dist/refusal.js +47 -0
- package/dist/refusal.js.map +1 -0
- package/dist/serverJournal.d.ts +143 -0
- package/dist/serverJournal.d.ts.map +1 -0
- package/dist/serverJournal.js +503 -0
- package/dist/serverJournal.js.map +1 -0
- package/dist/sync.d.ts +150 -14
- package/dist/sync.d.ts.map +1 -1
- package/dist/sync.js +273 -64
- package/dist/sync.js.map +1 -1
- package/dist/transport.d.ts +10 -6
- package/dist/transport.d.ts.map +1 -1
- package/dist/transport.js.map +1 -1
- 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
|
-
/**
|
|
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,
|
|
53
|
-
*
|
|
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
|
-
|
|
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
|
-
/**
|
|
92
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
177
|
-
|
|
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
|
-
|
|
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
|
-
/**
|
|
252
|
-
readonly encode: (operation: Operation
|
|
253
|
-
|
|
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;
|
package/dist/sync.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"sync.d.ts","names":[],"sources":["../src/sync.ts"],"mappings":"
|
|
1
|
+
{"version":3,"file":"sync.d.ts","names":[],"sources":["../src/sync.ts"],"mappings":"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"}
|