@agentshouse/mdruntime 0.1.0-c1c2b722d3dcd → 0.1.0-c1c9f29ad800c
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/AGENTS.md +96 -78
- package/README.md +9 -8
- package/dist/adapter.d.ts +53 -32
- package/dist/adapter.d.ts.map +1 -1
- package/dist/attached-model.d.ts +4 -1
- package/dist/attached-model.d.ts.map +1 -1
- package/dist/attached-model.js +13 -3
- package/dist/binary.d.ts +0 -5
- package/dist/binary.d.ts.map +1 -1
- package/dist/binary.js +1 -1
- package/dist/bootstrap.d.ts +24 -6
- package/dist/bootstrap.d.ts.map +1 -1
- package/dist/bootstrap.js +148 -82
- package/dist/chain.d.ts +11 -0
- package/dist/chain.d.ts.map +1 -0
- package/dist/chain.js +64 -0
- package/dist/change-set.d.ts +9 -16
- package/dist/change-set.d.ts.map +1 -1
- package/dist/change-set.js +11 -89
- package/dist/change.d.ts +31 -1
- package/dist/change.d.ts.map +1 -1
- package/dist/change.js +10 -1
- package/dist/chat/house.d.ts +25 -0
- package/dist/chat/house.d.ts.map +1 -0
- package/dist/chat/house.js +38 -0
- package/dist/chat/input.d.ts +3 -1
- package/dist/chat/input.d.ts.map +1 -1
- package/dist/chat/input.js +11 -18
- package/dist/chat/list.d.ts +2 -1
- package/dist/chat/list.d.ts.map +1 -1
- package/dist/chat/list.js +7 -3
- package/dist/chat/markdown.d.ts +1 -2
- package/dist/chat/markdown.d.ts.map +1 -1
- package/dist/chat/markdown.js +2 -19
- package/dist/chat/message.d.ts +1 -0
- package/dist/chat/message.d.ts.map +1 -1
- package/dist/chat/message.js +73 -11
- package/dist/chat/messages.d.ts +14 -1
- package/dist/chat/messages.d.ts.map +1 -1
- package/dist/chat/messages.js +79 -24
- package/dist/chat/name.d.ts +1 -0
- package/dist/chat/name.d.ts.map +1 -1
- package/dist/chat/name.js +1 -1
- package/dist/chat/opened.d.ts +1 -0
- package/dist/chat/opened.d.ts.map +1 -1
- package/dist/chat/opened.js +2 -0
- package/dist/chat/overlay.d.ts +1 -0
- package/dist/chat/overlay.d.ts.map +1 -1
- package/dist/chat/overlay.js +11 -5
- package/dist/chat/parts.d.ts +1 -0
- package/dist/chat/parts.d.ts.map +1 -1
- package/dist/chat/parts.js +3 -2
- package/dist/chat/provider.d.ts +8 -1
- package/dist/chat/provider.d.ts.map +1 -1
- package/dist/chat/provider.js +88 -81
- package/dist/chat/ready.d.ts +5 -2
- package/dist/chat/ready.d.ts.map +1 -1
- package/dist/chat/ready.js +7 -5
- package/dist/chat/room-file.d.ts +8 -0
- package/dist/chat/room-file.d.ts.map +1 -0
- package/dist/chat/room-file.js +72 -0
- package/dist/chat/steady.d.ts +3 -0
- package/dist/chat/steady.d.ts.map +1 -0
- package/dist/chat/steady.js +26 -0
- package/dist/chat/style.d.ts.map +1 -1
- package/dist/chat/style.js +5 -0
- package/dist/chat.d.ts +2 -1
- package/dist/chat.d.ts.map +1 -1
- package/dist/chat.js +1 -1
- package/dist/client.d.ts +6 -3
- package/dist/client.d.ts.map +1 -1
- package/dist/client.js +28 -2
- package/dist/collection.d.ts +6 -20
- package/dist/collection.d.ts.map +1 -1
- package/dist/collection.js +30 -352
- package/dist/compile.d.ts +16 -0
- package/dist/compile.d.ts.map +1 -0
- package/dist/compile.js +721 -0
- package/dist/connection.d.ts +13 -8
- package/dist/connection.d.ts.map +1 -1
- package/dist/connection.js +2187 -810
- package/dist/conversation.d.ts +11 -3
- package/dist/conversation.d.ts.map +1 -1
- package/dist/conversation.js +120 -66
- package/dist/digest.d.ts +7 -0
- package/dist/digest.d.ts.map +1 -0
- package/dist/digest.js +113 -0
- package/dist/durability.d.ts +3 -5
- package/dist/durability.d.ts.map +1 -1
- package/dist/durability.js +5 -0
- package/dist/entry.d.ts +3 -1
- package/dist/entry.d.ts.map +1 -1
- package/dist/entry.js +18 -24
- package/dist/file.d.ts +2 -10
- package/dist/file.d.ts.map +1 -1
- package/dist/file.js +3 -120
- package/dist/fulltext.d.ts +27 -0
- package/dist/fulltext.d.ts.map +1 -0
- package/dist/fulltext.js +368 -0
- package/dist/host.d.ts +4 -4
- package/dist/host.d.ts.map +1 -1
- package/dist/host.js +16 -8
- package/dist/identity.d.ts +0 -1
- package/dist/identity.d.ts.map +1 -1
- package/dist/identity.js +0 -3
- package/dist/index.d.ts +12 -9
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +4 -1
- package/dist/live.d.ts +22 -0
- package/dist/live.d.ts.map +1 -0
- package/dist/live.js +123 -0
- package/dist/memory.d.ts +1 -0
- package/dist/memory.d.ts.map +1 -1
- package/dist/memory.js +20 -15
- package/dist/messages.d.ts +28 -0
- package/dist/messages.d.ts.map +1 -0
- package/dist/messages.js +90 -0
- package/dist/name.d.ts +4 -0
- package/dist/name.d.ts.map +1 -0
- package/dist/name.js +122 -0
- package/dist/observation.d.ts +12 -0
- package/dist/observation.d.ts.map +1 -1
- package/dist/observation.js +84 -0
- package/dist/opened.d.ts +22 -0
- package/dist/opened.d.ts.map +1 -0
- package/dist/opened.js +107 -0
- package/dist/outcome.d.ts +28 -4
- package/dist/outcome.d.ts.map +1 -1
- package/dist/outcome.js +22 -0
- package/dist/overlay.d.ts +2 -6
- package/dist/overlay.d.ts.map +1 -1
- package/dist/overlay.js +35 -136
- package/dist/query.d.ts +5 -1
- package/dist/query.d.ts.map +1 -1
- package/dist/query.js +13 -1
- package/dist/reach.d.ts +5 -3
- package/dist/reach.d.ts.map +1 -1
- package/dist/reach.js +149 -61
- package/dist/readiness.d.ts +19 -9
- package/dist/readiness.d.ts.map +1 -1
- package/dist/readiness.js +2 -2
- package/dist/reads.d.ts.map +1 -1
- package/dist/reads.js +4 -2
- package/dist/recovery.d.ts +2 -2
- package/dist/recovery.d.ts.map +1 -1
- package/dist/recovery.js +8 -7
- package/dist/refresh.d.ts +15 -14
- package/dist/refresh.d.ts.map +1 -1
- package/dist/refresh.js +112 -51
- package/dist/replica.d.ts +57 -38
- package/dist/replica.d.ts.map +1 -1
- package/dist/replica.js +276 -193
- package/dist/room-draft.d.ts +3 -1
- package/dist/room-draft.d.ts.map +1 -1
- package/dist/room-draft.js +21 -13
- package/dist/rows.d.ts +29 -31
- package/dist/rows.d.ts.map +1 -1
- package/dist/rows.js +113 -69
- package/dist/save.d.ts +50 -15
- package/dist/save.d.ts.map +1 -1
- package/dist/save.js +374 -107
- package/dist/search.d.ts +11 -43
- package/dist/search.d.ts.map +1 -1
- package/dist/search.js +0 -213
- package/dist/shared.d.ts +5 -3
- package/dist/shared.d.ts.map +1 -1
- package/dist/shared.js +72 -35
- package/dist/store.d.ts +87 -92
- package/dist/store.d.ts.map +1 -1
- package/dist/store.js +329 -687
- package/dist/stored.d.ts +145 -0
- package/dist/stored.d.ts.map +1 -0
- package/dist/stored.js +567 -0
- package/dist/tables.d.ts +344 -0
- package/dist/tables.d.ts.map +1 -0
- package/dist/tables.js +580 -0
- package/dist/turn.d.ts +2 -2
- package/dist/turn.d.ts.map +1 -1
- package/dist/turn.js +34 -23
- package/dist/validation.d.ts +30 -0
- package/dist/validation.d.ts.map +1 -0
- package/dist/validation.js +162 -0
- package/dist/windows.d.ts +2 -6
- package/dist/windows.d.ts.map +1 -1
- package/dist/windows.js +30 -34
- package/dist/wire.d.ts +13 -1
- package/dist/wire.d.ts.map +1 -1
- package/dist/wire.js +4 -1
- package/dist/words.d.ts +19 -0
- package/dist/words.d.ts.map +1 -0
- package/dist/words.js +150 -0
- package/package.json +10 -4
- package/dist/read-side.d.ts +0 -27
- package/dist/read-side.d.ts.map +0 -1
- package/dist/read-side.js +0 -824
package/dist/store.js
CHANGED
|
@@ -1,768 +1,410 @@
|
|
|
1
|
-
import {
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
const AUTHORED = 'mdruntime-authored';
|
|
6
|
-
const FENCES = 'fences';
|
|
7
|
-
const ROOMS = 'rooms';
|
|
8
|
-
const DOCUMENTS = 'documents';
|
|
9
|
-
const BINARY_FILES = 'binaryFiles';
|
|
10
|
-
const TRANSFERS = 'transfers';
|
|
11
|
-
const RECEIVED = 'received';
|
|
12
|
-
const RECEIVED_PARTS = 'receivedParts';
|
|
13
|
-
const PENDING_CHANGES = 'pendingChanges';
|
|
14
|
-
const DECLARATIONS = 'declarations';
|
|
15
|
-
const ROOM_DRAFTS = 'roomDrafts';
|
|
16
|
-
const PRESENTATION = 'presentation';
|
|
17
|
-
const CONVERSATIONS = 'conversations';
|
|
18
|
-
const MESSAGES = 'messages';
|
|
19
|
-
const CHAT_DRAFTS = 'chatDrafts';
|
|
20
|
-
const CALLS = 'calls';
|
|
21
|
-
const QUEUES = 'queues';
|
|
22
|
-
const FACTS = 'facts';
|
|
23
|
-
const CURRENT = 'current';
|
|
24
|
-
const MEMBER = 'member';
|
|
25
|
-
const TARGETS = 'targets';
|
|
26
|
-
const GENERATION = 'generation';
|
|
27
|
-
const HOLDER = 'holder';
|
|
28
|
-
const BINDING = 'binding';
|
|
29
|
-
export const STORE_SCHEMA = 25;
|
|
30
|
-
const REPLICA_SHAPE = 23;
|
|
31
|
-
export const AUTHORED_SCHEMA = 3;
|
|
32
|
-
const AUTHORED_STORES = [
|
|
33
|
-
[QUEUES, { keyPath: 'locator' }],
|
|
34
|
-
[PENDING_CHANGES, { keyPath: ['locator', 'id'] }],
|
|
35
|
-
[ROOM_DRAFTS, { keyPath: ['locator', 'path'] }],
|
|
36
|
-
[CHAT_DRAFTS, { keyPath: 'conversation' }],
|
|
37
|
-
[CALLS, { keyPath: 'operation' }],
|
|
38
|
-
[FACTS, undefined],
|
|
39
|
-
[FENCES, { keyPath: 'locator' }],
|
|
40
|
-
];
|
|
41
|
-
const REPLICA_STORES = [
|
|
42
|
-
[ROOMS, { keyPath: 'locator' }],
|
|
43
|
-
[DOCUMENTS, { keyPath: ['locator', 'transfer', 'path'] }],
|
|
44
|
-
[BINARY_FILES, { keyPath: ['locator', 'transfer', 'path'] }],
|
|
45
|
-
[TRANSFERS, { keyPath: 'locator' }],
|
|
46
|
-
[RECEIVED, { keyPath: 'key' }],
|
|
47
|
-
[RECEIVED_PARTS, { keyPath: ['key', 'index'] }],
|
|
48
|
-
[DECLARATIONS, undefined],
|
|
49
|
-
[PRESENTATION, { keyPath: 'app' }],
|
|
50
|
-
[CONVERSATIONS, { keyPath: 'conversation' }],
|
|
51
|
-
[MESSAGES, { keyPath: ['conversation', 'identity'] }],
|
|
52
|
-
];
|
|
53
|
-
const READ_BATCH = 256;
|
|
54
|
-
const MESSAGE_INDEXES = [
|
|
55
|
-
['conversation', 'conversation'],
|
|
56
|
-
['position', ['conversation', 'position']],
|
|
57
|
-
['turn', ['conversation', 'turn']],
|
|
58
|
-
];
|
|
59
|
-
function settled(request) {
|
|
60
|
-
return new Promise((resolve, reject) => {
|
|
61
|
-
request.onsuccess = () => resolve(request.result);
|
|
62
|
-
request.onerror = () => reject(request.error);
|
|
63
|
-
});
|
|
64
|
-
}
|
|
65
|
-
function completed(transaction) {
|
|
66
|
-
return new Promise((resolve, reject) => {
|
|
67
|
-
transaction.oncomplete = () => resolve();
|
|
68
|
-
transaction.onerror = () => reject(transaction.error);
|
|
69
|
-
transaction.onabort = () => reject(transaction.error);
|
|
70
|
-
});
|
|
71
|
-
}
|
|
72
|
-
const EMPTY_DECLARATIONS = {
|
|
73
|
-
lastCompleted: null,
|
|
74
|
-
providerLimits: [],
|
|
75
|
-
capabilities: [],
|
|
76
|
-
};
|
|
77
|
-
function declaration(database) {
|
|
78
|
-
const transaction = database.transaction(DECLARATIONS, 'readonly');
|
|
79
|
-
return settled(transaction.objectStore(DECLARATIONS).get(CURRENT)).then((record) => record ?? EMPTY_DECLARATIONS);
|
|
80
|
-
}
|
|
81
|
-
function updateDeclaration(database, update) {
|
|
82
|
-
const transaction = database.transaction(DECLARATIONS, 'readwrite');
|
|
83
|
-
const store = transaction.objectStore(DECLARATIONS);
|
|
84
|
-
const prior = store.get(CURRENT);
|
|
85
|
-
prior.onsuccess = () => {
|
|
86
|
-
store.put(update(prior.result ?? EMPTY_DECLARATIONS), CURRENT);
|
|
87
|
-
};
|
|
88
|
-
return completed(transaction);
|
|
89
|
-
}
|
|
90
|
-
function amendPending(database, locator, id, amendment) {
|
|
91
|
-
const transaction = database.transaction(PENDING_CHANGES, 'readwrite');
|
|
92
|
-
const pending = transaction.objectStore(PENDING_CHANGES);
|
|
93
|
-
const request = pending.get([locator, id]);
|
|
94
|
-
request.onsuccess = () => {
|
|
95
|
-
const record = request.result;
|
|
96
|
-
if (record !== undefined)
|
|
97
|
-
pending.put({ ...record, ...amendment });
|
|
98
|
-
};
|
|
99
|
-
return completed(transaction);
|
|
100
|
-
}
|
|
101
|
-
function accepted({ conversation: _held, ...message }) {
|
|
102
|
-
return message;
|
|
103
|
-
}
|
|
104
|
-
function roomRecord(record) {
|
|
105
|
-
const { documents, binaries, revisions, fileIds, changes, written, ...room } = record;
|
|
106
|
-
return room;
|
|
107
|
-
}
|
|
108
|
-
function chatDraftRecord(record) {
|
|
109
|
-
return { ...record, revision: record.revision ?? '' };
|
|
110
|
-
}
|
|
111
|
-
function underTransfer(locator, transfer, after) {
|
|
112
|
-
return after === undefined
|
|
113
|
-
? IDBKeyRange.bound([locator, transfer], [locator, transfer, []])
|
|
114
|
-
: IDBKeyRange.bound([locator, transfer, after], [locator, transfer, []], true);
|
|
115
|
-
}
|
|
116
|
-
function underRoom(locator) {
|
|
117
|
-
return IDBKeyRange.bound([locator], [locator, []]);
|
|
118
|
-
}
|
|
119
|
-
async function readTransfer(store, locator, transfer, receive) {
|
|
120
|
-
let range = underTransfer(locator, transfer);
|
|
121
|
-
for (;;) {
|
|
122
|
-
const batch = await settled(store.getAll(range, READ_BATCH));
|
|
123
|
-
for (const record of batch)
|
|
124
|
-
receive(record);
|
|
125
|
-
if (batch.length < READ_BATCH)
|
|
126
|
-
return;
|
|
127
|
-
range = underTransfer(locator, transfer, batch[batch.length - 1].path);
|
|
128
|
-
}
|
|
1
|
+
import { binaryLocalId } from './identity.js';
|
|
2
|
+
const FILE = '\u0000file';
|
|
3
|
+
function batchFiles(batch) {
|
|
4
|
+
return batch.changes.flatMap((change) => (change.kind === 'binary' ? [change.localId] : []));
|
|
129
5
|
}
|
|
130
|
-
function
|
|
131
|
-
return {
|
|
6
|
+
function draftFiles(drafts) {
|
|
7
|
+
return drafts.flatMap(({ parts }) => (parts.file === undefined ? [] : [parts.file.localId]));
|
|
132
8
|
}
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
const head = (held) => {
|
|
136
|
-
if (held.revision !== null)
|
|
137
|
-
layer.revisions[held.path] = held.revision;
|
|
138
|
-
if (held.fileId !== null)
|
|
139
|
-
layer.fileIds[held.path] = held.fileId;
|
|
140
|
-
if (held.change !== null)
|
|
141
|
-
layer.changes[held.path] = held.change;
|
|
142
|
-
};
|
|
143
|
-
await readTransfer(transaction.objectStore(DOCUMENTS), locator, transfer, (document) => {
|
|
144
|
-
layer.documents[document.path] = document.content;
|
|
145
|
-
if (document.written !== null)
|
|
146
|
-
layer.written[document.path] = document.written;
|
|
147
|
-
head(document);
|
|
148
|
-
});
|
|
149
|
-
await readTransfer(transaction.objectStore(BINARY_FILES), locator, transfer, (file) => {
|
|
150
|
-
layer.binaries[file.path] = file.binary;
|
|
151
|
-
head(file);
|
|
152
|
-
});
|
|
153
|
-
return layer;
|
|
9
|
+
function roomDraftRow(record) {
|
|
10
|
+
return { path: record.path, record: JSON.stringify(record), files: draftFiles([record]) };
|
|
154
11
|
}
|
|
155
|
-
function
|
|
12
|
+
function authoredRows({ locator, queue, founded, saved, roomDrafts, consumedRoomDrafts, accepted }, held) {
|
|
156
13
|
return {
|
|
157
14
|
locator,
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
|
|
164
|
-
|
|
15
|
+
...(queue === undefined
|
|
16
|
+
? {}
|
|
17
|
+
: {
|
|
18
|
+
order: queue.map(({ id }) => id),
|
|
19
|
+
added: queue
|
|
20
|
+
.filter(({ id }) => held?.has(id) !== true)
|
|
21
|
+
.map((batch) => {
|
|
22
|
+
const drafts = saved?.get(batch.id) ?? [];
|
|
23
|
+
return {
|
|
24
|
+
id: batch.id,
|
|
25
|
+
batch: JSON.stringify(batch),
|
|
26
|
+
state: JSON.stringify({
|
|
27
|
+
drafts,
|
|
28
|
+
submission: { state: 'waiting' },
|
|
29
|
+
lost: false,
|
|
30
|
+
}),
|
|
31
|
+
files: [...batchFiles(batch), ...draftFiles(drafts)],
|
|
32
|
+
};
|
|
33
|
+
}),
|
|
34
|
+
}),
|
|
35
|
+
...(founded === undefined
|
|
36
|
+
? {}
|
|
37
|
+
: {
|
|
38
|
+
founded: founded.map((batch) => ({
|
|
39
|
+
id: batch.id,
|
|
40
|
+
batch: JSON.stringify(batch),
|
|
41
|
+
files: batchFiles(batch),
|
|
42
|
+
})),
|
|
43
|
+
}),
|
|
44
|
+
...(roomDrafts === undefined ? {} : { roomDrafts: roomDrafts.map(roomDraftRow) }),
|
|
45
|
+
...(consumedRoomDrafts === undefined ? {} : { consumedRoomDrafts }),
|
|
46
|
+
...(accepted === undefined
|
|
47
|
+
? {}
|
|
48
|
+
: {
|
|
49
|
+
amendments: accepted.map(({ id, roomVersion }) => ({
|
|
50
|
+
id,
|
|
51
|
+
amendment: JSON.stringify({ accepted: roomVersion }),
|
|
52
|
+
})),
|
|
53
|
+
}),
|
|
165
54
|
};
|
|
166
55
|
}
|
|
167
|
-
function
|
|
168
|
-
return
|
|
169
|
-
locator,
|
|
170
|
-
transfer,
|
|
171
|
-
path,
|
|
172
|
-
revision: layer.revisions[path] ?? null,
|
|
173
|
-
fileId: layer.fileIds[path] ?? null,
|
|
174
|
-
change: layer.changes[path] ?? null,
|
|
175
|
-
binary: layer.binaries[path],
|
|
176
|
-
};
|
|
56
|
+
function marked(value) {
|
|
57
|
+
return typeof value === 'object' && value !== null && FILE in value;
|
|
177
58
|
}
|
|
178
|
-
function
|
|
179
|
-
const
|
|
180
|
-
const files =
|
|
181
|
-
const
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
...differing(base.changes, next.changes, sameChange),
|
|
189
|
-
...differing(base.binaries, next.binaries, sameBinary),
|
|
190
|
-
]);
|
|
191
|
-
for (const path of paths) {
|
|
192
|
-
if (next.documents[path] !== undefined) {
|
|
193
|
-
documents.put(documentRecord(locator, transfer, next, path));
|
|
194
|
-
}
|
|
195
|
-
else if (base?.documents[path] !== undefined) {
|
|
196
|
-
documents.delete([locator, transfer, path]);
|
|
197
|
-
}
|
|
198
|
-
if (next.binaries[path] !== undefined) {
|
|
199
|
-
files.put(binaryFileRecord(locator, transfer, next, path));
|
|
200
|
-
}
|
|
201
|
-
else if (base?.binaries[path] !== undefined) {
|
|
202
|
-
files.delete([locator, transfer, path]);
|
|
59
|
+
function keyed(keys, value) {
|
|
60
|
+
const stored = [];
|
|
61
|
+
const files = [];
|
|
62
|
+
const record = JSON.stringify(value, (_name, held) => {
|
|
63
|
+
if (!(held instanceof Blob))
|
|
64
|
+
return held;
|
|
65
|
+
let key = keys.get(held);
|
|
66
|
+
if (key === undefined) {
|
|
67
|
+
key = binaryLocalId();
|
|
68
|
+
keys.set(held, key);
|
|
203
69
|
}
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
const keys = store.getAllKeys();
|
|
208
|
-
keys.onsuccess = () => {
|
|
209
|
-
for (const key of keys.result) {
|
|
210
|
-
if (Array.isArray(key) && key[0] === locator)
|
|
211
|
-
store.delete(key);
|
|
212
|
-
}
|
|
213
|
-
};
|
|
214
|
-
}
|
|
215
|
-
function removeDatabase(name) {
|
|
216
|
-
return new Promise((resolve, reject) => {
|
|
217
|
-
const removal = indexedDB.deleteDatabase(name);
|
|
218
|
-
removal.onsuccess = () => resolve();
|
|
219
|
-
removal.onerror = () => reject(removal.error);
|
|
70
|
+
stored.push({ key, blob: held });
|
|
71
|
+
files.push(key);
|
|
72
|
+
return { [FILE]: key, type: held.type };
|
|
220
73
|
});
|
|
74
|
+
return { record, files, stored };
|
|
221
75
|
}
|
|
222
|
-
|
|
223
|
-
|
|
224
|
-
|
|
225
|
-
|
|
226
|
-
|
|
227
|
-
|
|
228
|
-
return
|
|
229
|
-
}
|
|
230
|
-
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
}
|
|
234
|
-
export async function authoredBy(holder) {
|
|
235
|
-
const authored = await openAuthored();
|
|
236
|
-
try {
|
|
237
|
-
const transaction = authored.transaction(FACTS, 'readwrite');
|
|
238
|
-
const facts = transaction.objectStore(FACTS);
|
|
239
|
-
const held = facts.get(HOLDER);
|
|
240
|
-
let owned = true;
|
|
241
|
-
held.onsuccess = () => {
|
|
242
|
-
if (held.result === undefined)
|
|
243
|
-
facts.put(holder, HOLDER);
|
|
244
|
-
else
|
|
245
|
-
owned = held.result === holder;
|
|
246
|
-
};
|
|
247
|
-
await completed(transaction);
|
|
248
|
-
return owned;
|
|
249
|
-
}
|
|
250
|
-
finally {
|
|
251
|
-
authored.close();
|
|
252
|
-
}
|
|
253
|
-
}
|
|
254
|
-
export async function authoredBinding() {
|
|
255
|
-
const authored = await openAuthored();
|
|
256
|
-
try {
|
|
257
|
-
const transaction = authored.transaction(FACTS, 'readonly');
|
|
258
|
-
const held = transaction.objectStore(FACTS).get(BINDING);
|
|
259
|
-
await completed(transaction);
|
|
260
|
-
return typeof held.result === 'string' ? held.result : null;
|
|
261
|
-
}
|
|
262
|
-
finally {
|
|
263
|
-
authored.close();
|
|
264
|
-
}
|
|
265
|
-
}
|
|
266
|
-
export async function bindAuthored(binding) {
|
|
267
|
-
const authored = await openAuthored();
|
|
268
|
-
try {
|
|
269
|
-
const transaction = authored.transaction(FACTS, 'readwrite');
|
|
270
|
-
transaction.objectStore(FACTS).put(binding, BINDING);
|
|
271
|
-
await completed(transaction);
|
|
272
|
-
}
|
|
273
|
-
finally {
|
|
274
|
-
authored.close();
|
|
275
|
-
}
|
|
76
|
+
async function filed(value, read) {
|
|
77
|
+
if (Array.isArray(value))
|
|
78
|
+
return Promise.all(value.map((item) => filed(item, read)));
|
|
79
|
+
if (marked(value))
|
|
80
|
+
return read(value[FILE], value.type);
|
|
81
|
+
if (typeof value !== 'object' || value === null)
|
|
82
|
+
return value;
|
|
83
|
+
const restored = {};
|
|
84
|
+
for (const [name, item] of Object.entries(value))
|
|
85
|
+
restored[name] = await filed(item, read);
|
|
86
|
+
return restored;
|
|
276
87
|
}
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
if (holder !== undefined && (await authoredBy(holder)))
|
|
280
|
-
return true;
|
|
281
|
-
await removeDatabase(AUTHORED);
|
|
282
|
-
return false;
|
|
88
|
+
function json(value, fallback) {
|
|
89
|
+
return value === undefined ? fallback : JSON.parse(value);
|
|
283
90
|
}
|
|
284
|
-
export function
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
}
|
|
312
|
-
const messages = opening.transaction.objectStore(MESSAGES);
|
|
313
|
-
for (const [name, keyPath] of MESSAGE_INDEXES) {
|
|
314
|
-
if (!messages.indexNames.contains(name))
|
|
315
|
-
messages.createIndex(name, keyPath);
|
|
316
|
-
}
|
|
317
|
-
});
|
|
318
|
-
}
|
|
319
|
-
function openAuthored() {
|
|
320
|
-
return openDatabase(AUTHORED, AUTHORED_SCHEMA, (opening) => {
|
|
321
|
-
const database = opening.result;
|
|
322
|
-
for (const [name, parameters] of AUTHORED_STORES) {
|
|
323
|
-
if (!database.objectStoreNames.contains(name))
|
|
324
|
-
database.createObjectStore(name, parameters);
|
|
91
|
+
export function openRuntimeStore(fenced, authored) {
|
|
92
|
+
const keys = new WeakMap();
|
|
93
|
+
const read = async (key, type) => {
|
|
94
|
+
const blob = await authored.ask({ kind: 'authored.file', key, type });
|
|
95
|
+
keys.set(blob, key);
|
|
96
|
+
return blob;
|
|
97
|
+
};
|
|
98
|
+
const restored = async (records) => Promise.all(records.map(async (record) => (await filed(JSON.parse(record), read))));
|
|
99
|
+
const amend = async (locator, id, amendment) => {
|
|
100
|
+
if (fenced(locator))
|
|
101
|
+
return;
|
|
102
|
+
await authored.ask({
|
|
103
|
+
kind: 'authored.amend',
|
|
104
|
+
locator,
|
|
105
|
+
id,
|
|
106
|
+
amendment: JSON.stringify(amendment),
|
|
107
|
+
});
|
|
108
|
+
};
|
|
109
|
+
const fact = (name) => authored.ask({ kind: 'authored.fact', name });
|
|
110
|
+
const queued = new Map();
|
|
111
|
+
const changed = new Map();
|
|
112
|
+
const change = (key) => changed.set(key, (changed.get(key) ?? 0) + 1);
|
|
113
|
+
const rows = (writes) => writes.map((write) => authoredRows(write, queued.get(write.locator)));
|
|
114
|
+
const noted = (writes) => {
|
|
115
|
+
for (const { locator, queue } of writes) {
|
|
116
|
+
if (queue !== undefined)
|
|
117
|
+
queued.set(locator, new Set(queue.map(({ id }) => id)));
|
|
325
118
|
}
|
|
326
|
-
}
|
|
327
|
-
}
|
|
328
|
-
export async function openRuntimeStore(fenced) {
|
|
329
|
-
const authored = await openAuthored();
|
|
330
|
-
const database = await openReplica().catch((error) => {
|
|
331
|
-
authored.close();
|
|
332
|
-
throw error;
|
|
333
|
-
});
|
|
119
|
+
};
|
|
334
120
|
return {
|
|
335
|
-
async
|
|
336
|
-
const
|
|
337
|
-
const
|
|
338
|
-
const
|
|
339
|
-
for (const
|
|
340
|
-
|
|
121
|
+
async opened() {
|
|
122
|
+
const held = await authored.ask({ kind: 'replica.open' });
|
|
123
|
+
const unindexed = new Set(held.keys.flatMap(({ key, rederiving }) => (rederiving === null ? [] : [key])));
|
|
124
|
+
const overlaid = new Map();
|
|
125
|
+
for (const { key, path } of held.overlaid) {
|
|
126
|
+
const paths = overlaid.get(key) ?? new Set();
|
|
127
|
+
paths.add(path);
|
|
128
|
+
overlaid.set(key, paths);
|
|
341
129
|
}
|
|
342
|
-
return
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
drafts: saved?.get(batch.id) ?? [],
|
|
369
|
-
submission: { state: 'waiting' },
|
|
370
|
-
lost: false,
|
|
371
|
-
});
|
|
372
|
-
}
|
|
373
|
-
}
|
|
374
|
-
for (const batch of founded ?? []) {
|
|
375
|
-
if (!before.has(batch.id))
|
|
376
|
-
continue;
|
|
377
|
-
const stored = pending.get([locator, batch.id]);
|
|
378
|
-
stored.onsuccess = () => {
|
|
379
|
-
const record = stored.result;
|
|
380
|
-
if (record !== undefined)
|
|
381
|
-
pending.put({ ...record, batch });
|
|
382
|
-
};
|
|
383
|
-
}
|
|
130
|
+
return {
|
|
131
|
+
rooms: new Map(held.rooms
|
|
132
|
+
.filter(({ locator }) => !fenced(locator))
|
|
133
|
+
.map(({ locator, key, record }) => [
|
|
134
|
+
locator,
|
|
135
|
+
{ ...JSON.parse(record), key },
|
|
136
|
+
])),
|
|
137
|
+
transfers: new Map(held.transfers
|
|
138
|
+
.filter(({ locator }) => !fenced(locator))
|
|
139
|
+
.map(({ locator, key, record }) => [
|
|
140
|
+
locator,
|
|
141
|
+
{ ...JSON.parse(record), key },
|
|
142
|
+
])),
|
|
143
|
+
unindexed,
|
|
144
|
+
overlaid,
|
|
145
|
+
erasing: held.erasing.length > 0,
|
|
146
|
+
orphans: held.orphans,
|
|
147
|
+
lastCompleted: json(held.facts.lastCompleted, null),
|
|
148
|
+
providerLimits: json(held.facts.providerLimits, []),
|
|
149
|
+
capabilities: json(held.facts.capabilities, []),
|
|
150
|
+
member: json(held.facts.member, null),
|
|
151
|
+
targets: json(held.facts.targets, {}),
|
|
152
|
+
presentation: held.presentation.map(({ app, value }) => ({
|
|
153
|
+
app,
|
|
154
|
+
value: JSON.parse(value),
|
|
155
|
+
})),
|
|
384
156
|
};
|
|
385
|
-
const draftStore = transaction.objectStore(ROOM_DRAFTS);
|
|
386
|
-
for (const path of consumedRoomDrafts ?? [])
|
|
387
|
-
draftStore.delete([locator, path]);
|
|
388
|
-
for (const record of roomDrafts ?? [])
|
|
389
|
-
draftStore.put(record);
|
|
390
|
-
await completed(transaction);
|
|
391
|
-
},
|
|
392
|
-
async write({ next, previous, stored }) {
|
|
393
|
-
if (next === previous || fenced(next.locator))
|
|
394
|
-
return;
|
|
395
|
-
const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_FILES, TRANSFERS], 'readwrite');
|
|
396
|
-
transaction.objectStore(ROOMS).put(roomRecord(next));
|
|
397
|
-
const moved = previous?.transfer !== next.transfer;
|
|
398
|
-
if (moved && previous !== null) {
|
|
399
|
-
const range = underTransfer(previous.locator, previous.transfer);
|
|
400
|
-
transaction.objectStore(DOCUMENTS).delete(range);
|
|
401
|
-
transaction.objectStore(BINARY_FILES).delete(range);
|
|
402
|
-
}
|
|
403
|
-
if (moved)
|
|
404
|
-
transaction.objectStore(TRANSFERS).delete(next.locator);
|
|
405
|
-
writeLayer(transaction, next.locator, next.transfer, next, moved ? (stored ?? null) : previous);
|
|
406
|
-
await completed(transaction);
|
|
407
|
-
},
|
|
408
|
-
async revokeModels(records) {
|
|
409
|
-
const transaction = database.transaction(ROOMS, 'readwrite');
|
|
410
|
-
const rooms = transaction.objectStore(ROOMS);
|
|
411
|
-
const revoked = { status: 'unavailable', reason: 'revoked' };
|
|
412
|
-
for (const record of records) {
|
|
413
|
-
if (fenced(record.locator))
|
|
414
|
-
continue;
|
|
415
|
-
rooms.put(roomRecord({ ...record, model: revoked, selectionModel: revoked }));
|
|
416
|
-
}
|
|
417
|
-
await completed(transaction);
|
|
418
157
|
},
|
|
419
|
-
|
|
420
|
-
return (
|
|
158
|
+
counts(rooms) {
|
|
159
|
+
return authored.ask({ kind: 'replica.counts', rooms });
|
|
421
160
|
},
|
|
422
|
-
|
|
423
|
-
return
|
|
161
|
+
query(plan, rooms, budget) {
|
|
162
|
+
return authored.ask({ kind: 'replica.query', plan, rooms, budget });
|
|
424
163
|
},
|
|
425
|
-
|
|
426
|
-
return (
|
|
164
|
+
changes(keys) {
|
|
165
|
+
return keys.reduce((total, key) => total + (changed.get(key) ?? 0), 0);
|
|
427
166
|
},
|
|
428
|
-
|
|
429
|
-
return (
|
|
167
|
+
entries(key, view, paths) {
|
|
168
|
+
return authored.ask({ kind: 'replica.entries', key, view, paths });
|
|
430
169
|
},
|
|
431
|
-
|
|
432
|
-
return
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
170
|
+
typed(key, view, paths) {
|
|
171
|
+
return authored.ask({ kind: 'replica.typed', key, view, paths });
|
|
172
|
+
},
|
|
173
|
+
referrers(key, view, targets, kinds) {
|
|
174
|
+
return authored.ask({ kind: 'replica.referrers', key, view, targets, kinds });
|
|
175
|
+
},
|
|
176
|
+
walk(key, view, after, bytes) {
|
|
177
|
+
return authored.ask({ kind: 'replica.walk', key, view, after, bytes });
|
|
178
|
+
},
|
|
179
|
+
files(key, view, after, limit) {
|
|
180
|
+
return authored.ask({ kind: 'replica.files', key, view, after, limit });
|
|
181
|
+
},
|
|
182
|
+
typedWithin(key, view, roots, within) {
|
|
183
|
+
return authored.ask({ kind: 'replica.typedWithin', key, view, roots, within });
|
|
184
|
+
},
|
|
185
|
+
search(ask) {
|
|
186
|
+
return authored.ask({ kind: 'replica.search', ...ask });
|
|
187
|
+
},
|
|
188
|
+
async stage(record, composition, page, written) {
|
|
189
|
+
if (fenced(record.locator))
|
|
190
|
+
return null;
|
|
191
|
+
const { key, ...kept } = record;
|
|
192
|
+
return authored.ask({
|
|
193
|
+
kind: 'replica.stage',
|
|
194
|
+
locator: record.locator,
|
|
195
|
+
transfer: record.transfer,
|
|
196
|
+
record: JSON.stringify(kept),
|
|
197
|
+
key,
|
|
198
|
+
composition,
|
|
199
|
+
entries: page.entries,
|
|
200
|
+
folders: page.folders,
|
|
201
|
+
...(written === undefined ? {} : { written }),
|
|
202
|
+
});
|
|
437
203
|
},
|
|
438
|
-
async
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
return
|
|
204
|
+
async transferPart(locator, token) {
|
|
205
|
+
if (fenced(locator))
|
|
206
|
+
return null;
|
|
207
|
+
return authored.ask({ kind: 'replica.transferPart', locator, token });
|
|
208
|
+
},
|
|
209
|
+
async keepPart(locator, token, part) {
|
|
210
|
+
if (fenced(locator))
|
|
211
|
+
return;
|
|
212
|
+
await authored.ask({ kind: 'replica.keepPart', locator, token, part });
|
|
213
|
+
},
|
|
214
|
+
async refresh(key, page) {
|
|
215
|
+
await authored.ask({
|
|
216
|
+
kind: 'replica.refresh',
|
|
217
|
+
key,
|
|
218
|
+
entries: page.entries,
|
|
219
|
+
removals: page.removals,
|
|
220
|
+
folders: page.folders,
|
|
221
|
+
folderRemovals: page.folderRemovals,
|
|
222
|
+
});
|
|
223
|
+
},
|
|
224
|
+
async unrefresh(key) {
|
|
225
|
+
await authored.ask({ kind: 'replica.unrefresh', key });
|
|
226
|
+
},
|
|
227
|
+
async commit({ rooms, writes = [], files = [], whole = false, discards = [] }) {
|
|
228
|
+
const kept = whole ? writes : writes.filter(({ locator }) => !fenced(locator));
|
|
229
|
+
const refused = whole ? kept.find(({ locator }) => fenced(locator)) : undefined;
|
|
230
|
+
if (refused !== undefined) {
|
|
231
|
+
return { fenced: refused.locator, counts: {}, changed: {}, indexed: {} };
|
|
232
|
+
}
|
|
233
|
+
for (const room of rooms)
|
|
234
|
+
change(room.key);
|
|
235
|
+
const committed = await authored.ask({
|
|
236
|
+
kind: 'replica.commit',
|
|
237
|
+
...(kept.length === 0 && files.length === 0 && discards.length === 0
|
|
238
|
+
? {}
|
|
239
|
+
: { authored: { writes: rows(kept), files, whole, discards } }),
|
|
240
|
+
rooms: rooms.filter(({ locator }) => !fenced(locator)),
|
|
241
|
+
});
|
|
242
|
+
if (committed.fenced === null || !whole)
|
|
243
|
+
noted(kept);
|
|
244
|
+
for (const locator of discards)
|
|
245
|
+
queued.delete(locator);
|
|
246
|
+
return committed;
|
|
247
|
+
},
|
|
248
|
+
async fence(locators) {
|
|
249
|
+
await authored.ask({ kind: 'replica.fence', locators });
|
|
250
|
+
for (const locator of locators)
|
|
251
|
+
queued.delete(locator);
|
|
442
252
|
},
|
|
443
|
-
async
|
|
444
|
-
|
|
445
|
-
transaction.objectStore(DECLARATIONS).put(member, MEMBER);
|
|
446
|
-
await completed(transaction);
|
|
253
|
+
async erase(locator, limit) {
|
|
254
|
+
return (await authored.ask({ kind: 'replica.erase', locator, limit })).remaining;
|
|
447
255
|
},
|
|
448
|
-
async
|
|
449
|
-
|
|
450
|
-
|
|
451
|
-
return
|
|
256
|
+
async abandon(locator, kept = false) {
|
|
257
|
+
if (fenced(locator))
|
|
258
|
+
return null;
|
|
259
|
+
return authored.ask({ kind: 'replica.abandon', locator, kept });
|
|
452
260
|
},
|
|
453
|
-
async
|
|
454
|
-
|
|
455
|
-
|
|
456
|
-
|
|
261
|
+
async release(key) {
|
|
262
|
+
await authored.ask({ kind: 'replica.release', key });
|
|
263
|
+
},
|
|
264
|
+
async rederive(key, limit) {
|
|
265
|
+
change(key);
|
|
266
|
+
return (await authored.ask({ kind: 'replica.rederive', key, limit })).done;
|
|
267
|
+
},
|
|
268
|
+
async fact(name, value) {
|
|
269
|
+
await authored.ask({ kind: 'replica.fact', name, value: JSON.stringify(value) });
|
|
457
270
|
},
|
|
458
271
|
async queues() {
|
|
459
|
-
const
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
]);
|
|
272
|
+
const { queues, pending } = await authored.ask({ kind: 'authored.queues' });
|
|
273
|
+
queued.clear();
|
|
274
|
+
for (const queue of queues)
|
|
275
|
+
queued.set(queue.locator, new Set(queue.ids));
|
|
464
276
|
const byId = new Map(pending.map((record) => [`${record.locator}\0${record.id}`, record]));
|
|
465
277
|
return queues
|
|
466
278
|
.filter((queue) => !fenced(queue.locator))
|
|
467
279
|
.map((queue) => ({
|
|
468
280
|
locator: queue.locator,
|
|
469
|
-
pending: queue.
|
|
281
|
+
pending: queue.ids.map((id) => {
|
|
470
282
|
const record = byId.get(`${queue.locator}\0${id}`);
|
|
471
283
|
if (record === undefined)
|
|
472
284
|
throw new Error(`Missing Pending Change ${queue.locator}/${id}`);
|
|
473
|
-
|
|
474
|
-
|
|
285
|
+
return {
|
|
286
|
+
batch: JSON.parse(record.batch),
|
|
287
|
+
state: JSON.parse(record.state),
|
|
288
|
+
};
|
|
475
289
|
}),
|
|
476
290
|
}));
|
|
477
291
|
},
|
|
478
|
-
|
|
479
|
-
|
|
480
|
-
await amendPending(authored, locator, id, { submission, lost });
|
|
292
|
+
submit(locator, id, submission, lost) {
|
|
293
|
+
return amend(locator, id, { submission, lost });
|
|
481
294
|
},
|
|
482
|
-
|
|
483
|
-
|
|
484
|
-
await amendPending(authored, locator, id, { accepted: roomVersion });
|
|
485
|
-
},
|
|
486
|
-
async keepUpload(locator, id, upload) {
|
|
487
|
-
if (!fenced(locator))
|
|
488
|
-
await amendPending(authored, locator, id, { upload });
|
|
295
|
+
keepUpload(locator, id, upload) {
|
|
296
|
+
return amend(locator, id, { upload });
|
|
489
297
|
},
|
|
490
298
|
async roomDrafts() {
|
|
491
|
-
const
|
|
492
|
-
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
async presentation() {
|
|
496
|
-
const transaction = database.transaction(PRESENTATION, 'readonly');
|
|
497
|
-
return settled(transaction.objectStore(PRESENTATION).getAll());
|
|
299
|
+
const held = await authored.ask({ kind: 'authored.roomDrafts' });
|
|
300
|
+
return held
|
|
301
|
+
.map((record) => JSON.parse(record))
|
|
302
|
+
.filter((record) => !fenced(record.locator));
|
|
498
303
|
},
|
|
499
304
|
async present(record) {
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
async conversations() {
|
|
505
|
-
const transaction = database.transaction([CONVERSATIONS, MESSAGES], 'readonly');
|
|
506
|
-
const records = await settled(transaction.objectStore(CONVERSATIONS).getAll());
|
|
507
|
-
const held = new Map(records.map(({ conversation, read, partial }) => [
|
|
508
|
-
conversation,
|
|
509
|
-
{ conversation, read, partial: partial === true },
|
|
510
|
-
]));
|
|
511
|
-
const keys = transaction.objectStore(MESSAGES).index('conversation');
|
|
512
|
-
await new Promise((resolve, reject) => {
|
|
513
|
-
const cursor = keys.openKeyCursor(null, 'nextunique');
|
|
514
|
-
cursor.onerror = () => reject(cursor.error);
|
|
515
|
-
cursor.onsuccess = () => {
|
|
516
|
-
const at = cursor.result;
|
|
517
|
-
if (at === null) {
|
|
518
|
-
resolve();
|
|
519
|
-
return;
|
|
520
|
-
}
|
|
521
|
-
const conversation = at.key;
|
|
522
|
-
if (!held.has(conversation)) {
|
|
523
|
-
held.set(conversation, { conversation, read: undefined, partial: true });
|
|
524
|
-
}
|
|
525
|
-
at.continue();
|
|
526
|
-
};
|
|
305
|
+
await authored.ask({
|
|
306
|
+
kind: 'replica.present',
|
|
307
|
+
app: record.app,
|
|
308
|
+
value: JSON.stringify(record.value ?? null),
|
|
527
309
|
});
|
|
528
|
-
return [...held.values()];
|
|
529
310
|
},
|
|
530
|
-
|
|
531
|
-
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
|
|
537
|
-
|
|
538
|
-
|
|
539
|
-
|
|
540
|
-
|
|
541
|
-
|
|
542
|
-
|
|
543
|
-
|
|
544
|
-
},
|
|
545
|
-
async messageWindow(conversation, limit, before) {
|
|
546
|
-
const transaction = database.transaction(MESSAGES, 'readonly');
|
|
547
|
-
const index = transaction.objectStore(MESSAGES).index('position');
|
|
548
|
-
const range = IDBKeyRange.bound([conversation], [conversation, before?.[0] ?? []]);
|
|
549
|
-
const latest = [];
|
|
550
|
-
let more = false;
|
|
551
|
-
await new Promise((resolve, reject) => {
|
|
552
|
-
const cursor = index.openCursor(range, 'prev');
|
|
553
|
-
cursor.onerror = () => reject(cursor.error);
|
|
554
|
-
cursor.onsuccess = () => {
|
|
555
|
-
const at = cursor.result;
|
|
556
|
-
if (at === null) {
|
|
557
|
-
resolve();
|
|
558
|
-
return;
|
|
559
|
-
}
|
|
560
|
-
const record = at.value;
|
|
561
|
-
if (!precedes(record, before)) {
|
|
562
|
-
at.continue();
|
|
563
|
-
return;
|
|
564
|
-
}
|
|
565
|
-
if (latest.length === limit) {
|
|
566
|
-
more = true;
|
|
567
|
-
resolve();
|
|
568
|
-
return;
|
|
569
|
-
}
|
|
570
|
-
latest.push(accepted(record));
|
|
571
|
-
at.continue();
|
|
572
|
-
};
|
|
573
|
-
});
|
|
574
|
-
return { messages: latest.reverse(), more };
|
|
575
|
-
},
|
|
576
|
-
async messageCount(conversation) {
|
|
577
|
-
const transaction = database.transaction(MESSAGES, 'readonly');
|
|
578
|
-
return settled(transaction.objectStore(MESSAGES).index('conversation').count(conversation));
|
|
579
|
-
},
|
|
580
|
-
async messagesAfter(conversation, identity) {
|
|
581
|
-
const transaction = database.transaction(MESSAGES, 'readonly');
|
|
582
|
-
const range = identity === null
|
|
583
|
-
? IDBKeyRange.bound([conversation], [conversation, []])
|
|
584
|
-
: IDBKeyRange.bound([conversation, identity], [conversation, []], true);
|
|
585
|
-
const held = await settled(transaction.objectStore(MESSAGES).getAll(range, READ_BATCH));
|
|
586
|
-
return held.map(accepted);
|
|
587
|
-
},
|
|
588
|
-
async messageIdentities(conversation) {
|
|
589
|
-
const transaction = database.transaction(MESSAGES, 'readonly');
|
|
590
|
-
const keys = await settled(transaction.objectStore(MESSAGES).index('conversation').getAllKeys(conversation));
|
|
591
|
-
return keys.map((key) => key[1]);
|
|
592
|
-
},
|
|
593
|
-
async turnArrived(conversation, turn) {
|
|
594
|
-
const transaction = database.transaction(MESSAGES, 'readonly');
|
|
595
|
-
const held = await settled(transaction.objectStore(MESSAGES).index('turn').count([conversation, turn]));
|
|
596
|
-
return held > 0;
|
|
311
|
+
conversations() {
|
|
312
|
+
return authored.ask({ kind: 'conversation.held' });
|
|
313
|
+
},
|
|
314
|
+
async keepMessages(write) {
|
|
315
|
+
await authored.ask({ kind: 'conversation.keep', ...write });
|
|
316
|
+
},
|
|
317
|
+
messageWindow(conversation, limit, before) {
|
|
318
|
+
return authored.ask({ kind: 'conversation.window', conversation, limit, before });
|
|
319
|
+
},
|
|
320
|
+
messageCount(conversation) {
|
|
321
|
+
return authored.ask({ kind: 'conversation.count', conversation });
|
|
322
|
+
},
|
|
323
|
+
turnArrived(conversation, turn) {
|
|
324
|
+
return authored.ask({ kind: 'conversation.turn', conversation, turn });
|
|
597
325
|
},
|
|
598
326
|
async dropConversations(conversations) {
|
|
599
|
-
|
|
600
|
-
for (const conversation of conversations)
|
|
601
|
-
drafts.objectStore(CHAT_DRAFTS).delete(conversation);
|
|
602
|
-
await completed(drafts);
|
|
603
|
-
const transaction = database.transaction([CONVERSATIONS, MESSAGES], 'readwrite');
|
|
604
|
-
const messages = transaction.objectStore(MESSAGES);
|
|
605
|
-
for (const conversation of conversations) {
|
|
606
|
-
transaction.objectStore(CONVERSATIONS).delete(conversation);
|
|
607
|
-
const keys = messages.index('conversation').getAllKeys(conversation);
|
|
608
|
-
keys.onsuccess = () => {
|
|
609
|
-
for (const key of keys.result)
|
|
610
|
-
messages.delete(key);
|
|
611
|
-
};
|
|
612
|
-
}
|
|
613
|
-
await completed(transaction);
|
|
327
|
+
await authored.ask({ kind: 'conversation.drop', conversations });
|
|
614
328
|
},
|
|
615
329
|
async chatDrafts() {
|
|
616
|
-
const
|
|
617
|
-
|
|
618
|
-
return held.map(chatDraftRecord);
|
|
330
|
+
const records = await authored.ask({ kind: 'authored.chatDrafts' });
|
|
331
|
+
return records.map((record) => JSON.parse(record));
|
|
619
332
|
},
|
|
620
333
|
async keepChatDrafts(records) {
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
|
|
334
|
+
await authored.ask({
|
|
335
|
+
kind: 'authored.chatDraft',
|
|
336
|
+
kept: records.map((record) => ({
|
|
337
|
+
conversation: record.conversation,
|
|
338
|
+
record: JSON.stringify(record),
|
|
339
|
+
})),
|
|
340
|
+
dropped: [],
|
|
341
|
+
});
|
|
625
342
|
},
|
|
626
343
|
async dropChatDraft(conversation) {
|
|
627
|
-
|
|
628
|
-
transaction.objectStore(CHAT_DRAFTS).delete(conversation);
|
|
629
|
-
await completed(transaction);
|
|
344
|
+
await authored.ask({ kind: 'authored.chatDraft', kept: [], dropped: [conversation] });
|
|
630
345
|
},
|
|
631
346
|
async calls() {
|
|
632
|
-
|
|
633
|
-
return settled(transaction.objectStore(CALLS).getAll());
|
|
347
|
+
return restored(await authored.ask({ kind: 'authored.calls' }));
|
|
634
348
|
},
|
|
635
349
|
async keepCall(record) {
|
|
636
|
-
const
|
|
637
|
-
|
|
638
|
-
|
|
350
|
+
const { stored, ...kept } = keyed(keys, record);
|
|
351
|
+
await authored.ask({
|
|
352
|
+
kind: 'authored.call',
|
|
353
|
+
operation: record.operation,
|
|
354
|
+
kept,
|
|
355
|
+
files: stored,
|
|
356
|
+
});
|
|
639
357
|
},
|
|
640
358
|
async dropCall(operation) {
|
|
641
|
-
|
|
642
|
-
transaction.objectStore(CALLS).delete(operation);
|
|
643
|
-
await completed(transaction);
|
|
359
|
+
await authored.ask({ kind: 'authored.call', operation, kept: null, files: [] });
|
|
644
360
|
},
|
|
645
|
-
async keepRoomDraft(record) {
|
|
361
|
+
async keepRoomDraft(record, files) {
|
|
646
362
|
if (fenced(record.locator))
|
|
647
363
|
return;
|
|
648
|
-
const
|
|
649
|
-
|
|
650
|
-
|
|
364
|
+
const { path, ...kept } = roomDraftRow(record);
|
|
365
|
+
await authored.ask({
|
|
366
|
+
kind: 'authored.roomDraft',
|
|
367
|
+
locator: record.locator,
|
|
368
|
+
path,
|
|
369
|
+
kept,
|
|
370
|
+
files,
|
|
371
|
+
});
|
|
651
372
|
},
|
|
652
373
|
async discardRoomDraft(locator, path) {
|
|
653
374
|
if (fenced(locator))
|
|
654
375
|
return;
|
|
655
|
-
|
|
656
|
-
transaction.objectStore(ROOM_DRAFTS).delete([locator, path]);
|
|
657
|
-
await completed(transaction);
|
|
658
|
-
},
|
|
659
|
-
async fences() {
|
|
660
|
-
const transaction = authored.transaction(FENCES, 'readonly');
|
|
661
|
-
const held = await settled(transaction.objectStore(FENCES).getAll());
|
|
662
|
-
return held.map((fence) => fence.locator);
|
|
663
|
-
},
|
|
664
|
-
async erase(locators) {
|
|
665
|
-
const work = authored.transaction([FENCES, QUEUES, PENDING_CHANGES, ROOM_DRAFTS], 'readwrite');
|
|
666
|
-
for (const locator of locators) {
|
|
667
|
-
work.objectStore(FENCES).put({ locator });
|
|
668
|
-
work.objectStore(QUEUES).delete(locator);
|
|
669
|
-
for (const name of [PENDING_CHANGES, ROOM_DRAFTS]) {
|
|
670
|
-
removeRoomEntries(work.objectStore(name), locator);
|
|
671
|
-
}
|
|
672
|
-
}
|
|
673
|
-
await completed(work);
|
|
674
|
-
const transaction = database.transaction([ROOMS, DOCUMENTS, BINARY_FILES, TRANSFERS], 'readwrite');
|
|
675
|
-
for (const locator of locators) {
|
|
676
|
-
transaction.objectStore(ROOMS).delete(locator);
|
|
677
|
-
transaction.objectStore(TRANSFERS).delete(locator);
|
|
678
|
-
transaction.objectStore(DOCUMENTS).delete(underRoom(locator));
|
|
679
|
-
transaction.objectStore(BINARY_FILES).delete(underRoom(locator));
|
|
680
|
-
}
|
|
681
|
-
await completed(transaction);
|
|
682
|
-
const fences = authored.transaction(FENCES, 'readwrite');
|
|
683
|
-
for (const locator of locators)
|
|
684
|
-
fences.objectStore(FENCES).delete(locator);
|
|
685
|
-
await completed(fences);
|
|
376
|
+
await authored.ask({ kind: 'authored.roomDraft', locator, path, kept: null, files: [] });
|
|
686
377
|
},
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
transaction.objectStore(QUEUES).delete(locator);
|
|
690
|
-
removeRoomEntries(transaction.objectStore(PENDING_CHANGES), locator);
|
|
691
|
-
await completed(transaction);
|
|
378
|
+
fences() {
|
|
379
|
+
return authored.ask({ kind: 'authored.fences' });
|
|
692
380
|
},
|
|
693
|
-
|
|
694
|
-
|
|
695
|
-
const held = await settled(transaction.objectStore(TRANSFERS).getAll());
|
|
696
|
-
return held.filter((record) => !fenced(record.locator));
|
|
381
|
+
receivedHeads() {
|
|
382
|
+
return authored.ask({ kind: 'replica.received' });
|
|
697
383
|
},
|
|
698
|
-
|
|
699
|
-
|
|
700
|
-
return readLayer(transaction, record.locator, record.transfer);
|
|
701
|
-
},
|
|
702
|
-
async stage(record, page) {
|
|
703
|
-
if (fenced(record.locator))
|
|
704
|
-
return;
|
|
705
|
-
const transaction = database.transaction([TRANSFERS, DOCUMENTS, BINARY_FILES], 'readwrite');
|
|
706
|
-
writeLayer(transaction, record.locator, record.transfer, page, null);
|
|
707
|
-
transaction.objectStore(TRANSFERS).put(record);
|
|
708
|
-
await completed(transaction);
|
|
709
|
-
},
|
|
710
|
-
async abandon(locator) {
|
|
711
|
-
if (fenced(locator))
|
|
712
|
-
return;
|
|
713
|
-
const transaction = database.transaction([TRANSFERS, DOCUMENTS, BINARY_FILES], 'readwrite');
|
|
714
|
-
const transfers = transaction.objectStore(TRANSFERS);
|
|
715
|
-
const held = transfers.get(locator);
|
|
716
|
-
held.onsuccess = () => {
|
|
717
|
-
const record = held.result;
|
|
718
|
-
if (record === undefined)
|
|
719
|
-
return;
|
|
720
|
-
transfers.delete(locator);
|
|
721
|
-
const range = underTransfer(locator, record.transfer);
|
|
722
|
-
transaction.objectStore(DOCUMENTS).delete(range);
|
|
723
|
-
transaction.objectStore(BINARY_FILES).delete(range);
|
|
724
|
-
};
|
|
725
|
-
await completed(transaction);
|
|
726
|
-
},
|
|
727
|
-
async receivedHeads() {
|
|
728
|
-
const transaction = database.transaction(RECEIVED, 'readonly');
|
|
729
|
-
return settled(transaction.objectStore(RECEIVED).getAll());
|
|
730
|
-
},
|
|
731
|
-
async receivedParts(key, count) {
|
|
732
|
-
const transaction = database.transaction(RECEIVED_PARTS, 'readonly');
|
|
733
|
-
const kept = await settled(transaction
|
|
734
|
-
.objectStore(RECEIVED_PARTS)
|
|
735
|
-
.getAll(IDBKeyRange.bound([key, 0], [key, count], false, true)));
|
|
736
|
-
return kept.map((part) => part.value);
|
|
384
|
+
receivedParts(key, count) {
|
|
385
|
+
return authored.ask({ kind: 'replica.receivedParts', key, count });
|
|
737
386
|
},
|
|
738
387
|
async keepReceived(key, head, part) {
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
|
|
743
|
-
|
|
388
|
+
await authored.ask({
|
|
389
|
+
kind: 'replica.receive',
|
|
390
|
+
key,
|
|
391
|
+
head: JSON.stringify(head),
|
|
392
|
+
...(part === undefined
|
|
393
|
+
? {}
|
|
394
|
+
: { part: { index: part.index, value: JSON.stringify(part.value) } }),
|
|
395
|
+
});
|
|
744
396
|
},
|
|
745
397
|
async dropReceived(keys) {
|
|
746
|
-
|
|
747
|
-
for (const key of keys) {
|
|
748
|
-
transaction.objectStore(RECEIVED).delete(key);
|
|
749
|
-
transaction.objectStore(RECEIVED_PARTS).delete(IDBKeyRange.bound([key], [key, []]));
|
|
750
|
-
}
|
|
751
|
-
await completed(transaction);
|
|
398
|
+
await authored.ask({ kind: 'replica.unreceive', keys });
|
|
752
399
|
},
|
|
753
|
-
|
|
754
|
-
|
|
755
|
-
const held = await settled(transaction.objectStore(FACTS).get(GENERATION));
|
|
756
|
-
return held ?? null;
|
|
400
|
+
generation() {
|
|
401
|
+
return fact('generation');
|
|
757
402
|
},
|
|
758
403
|
async rememberGeneration(value) {
|
|
759
|
-
|
|
760
|
-
transaction.objectStore(FACTS).put(value, GENERATION);
|
|
761
|
-
await completed(transaction);
|
|
404
|
+
await authored.ask({ kind: 'authored.remember', name: 'generation', value });
|
|
762
405
|
},
|
|
763
|
-
|
|
764
|
-
authored.
|
|
765
|
-
database.close();
|
|
406
|
+
file(key, type) {
|
|
407
|
+
return authored.ask({ kind: 'authored.file', key, type });
|
|
766
408
|
},
|
|
767
409
|
};
|
|
768
410
|
}
|