foldkit-remote-server 0.17.0 → 0.19.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 +442 -149
- package/dist/fetch.d.mts +30 -3
- package/dist/fetch.d.mts.map +1 -1
- package/dist/fetch.mjs +52 -16
- package/dist/fetch.mjs.map +1 -1
- package/dist/index-BnaRbvjr.d.mts +937 -0
- package/dist/index-BnaRbvjr.d.mts.map +1 -0
- package/dist/index.d.mts +2 -638
- package/dist/index.mjs +1 -1
- package/dist/{src-ErnDxcWe.mjs → src-ZV9pARkU.mjs} +478 -59
- package/dist/src-ZV9pARkU.mjs.map +1 -0
- package/package.json +8 -8
- package/dist/index.d.mts.map +0 -1
- package/dist/src-ErnDxcWe.mjs.map +0 -1
|
@@ -1,6 +1,45 @@
|
|
|
1
|
-
import { Context, Effect, Match, Option, Queue, Schema, Stream } from "effect";
|
|
2
|
-
import { Entity, Operators, QueryEvaluateError, Write, assertSupported, assertSupported as assertSupported$1, evaluate, evaluate as evaluate$1, supported } from "foldkit-entity";
|
|
3
|
-
import { MutationRequest, QueryRequest, RELATION_ALIAS, REMOTE_PROTOCOL_VERSION, ReadBatch, Remote, RemoteForbidden, RemoteJsonRequest, RemoteLiveError, RemoteMutationError, RemoteProtocolError, RemoteQueryError, RemoteReadError, RemoteUnauthenticated, Requirement, aliasedField, connectionIdentity, entityKey, refParts, refsIn, relationShape, stableStringify } from "foldkit-remote";
|
|
1
|
+
import { Cause, Clock, Context, Data, Duration, Effect, Match, Option, Queue, Schema, Stream } from "effect";
|
|
2
|
+
import { Derivation, Entity, Held, Operators, Query, QueryEvaluateError, SchemaShape, Write, assertSupported, assertSupported as assertSupported$1, evaluate, evaluate as evaluate$1, supported } from "foldkit-entity";
|
|
3
|
+
import { Diagnostics, MutationRequest, QueryRequest, RELATION_ALIAS, REMOTE_PROTOCOL_VERSION, ReadBatch, Refusal, Remote, RemoteForbidden, RemoteJsonRequest, RemoteLiveError, RemoteLiveRefused, RemoteMutationError, RemoteProtocolError, RemoteQueryError, RemoteReadError, RemoteUnauthenticated, Requirement, aliasedField, connectionIdentity, entityKey, queryIdentity, refParts, refsIn, relationShape, stableStringify } from "foldkit-remote";
|
|
4
|
+
// src/diagnostics.ts
|
|
5
|
+
/**
|
|
6
|
+
* What a Remote server answers past without telling the caller why: a defect
|
|
7
|
+
* it answered "Internal error", a committed mutation whose answer's read or
|
|
8
|
+
* live publish failed, and a client's time it would not take. Each is
|
|
9
|
+
* reported through `Diagnostics.report`, so a host's log (a Worker's
|
|
10
|
+
* `wrangler tail`) shows it by default.
|
|
11
|
+
*/
|
|
12
|
+
const source = "foldkit-remote-server";
|
|
13
|
+
const serverDefect = (cause) => ({
|
|
14
|
+
_tag: "ServerDefect",
|
|
15
|
+
source,
|
|
16
|
+
level: "error",
|
|
17
|
+
message: `a request failed on this side, and its caller was answered "Internal error"\n${Cause.pretty(cause)}`,
|
|
18
|
+
cause
|
|
19
|
+
});
|
|
20
|
+
const answerUnread = (mutation, reason) => ({
|
|
21
|
+
_tag: "AnswerUnread",
|
|
22
|
+
source,
|
|
23
|
+
level: "warning",
|
|
24
|
+
message: `${mutation} committed, but reading its answer failed (${reason}): the client reads the rows it names again.`,
|
|
25
|
+
mutation,
|
|
26
|
+
reason
|
|
27
|
+
});
|
|
28
|
+
const publishFailed = (mutation, cause) => ({
|
|
29
|
+
_tag: "PublishFailed",
|
|
30
|
+
source,
|
|
31
|
+
level: "error",
|
|
32
|
+
message: `${mutation} committed, but its live publish failed, so live subscribers do not hear it\n${Cause.pretty(cause)}`,
|
|
33
|
+
mutation,
|
|
34
|
+
cause
|
|
35
|
+
});
|
|
36
|
+
const clockSkewed = (facts) => ({
|
|
37
|
+
_tag: "ClockSkewed",
|
|
38
|
+
source,
|
|
39
|
+
level: "warning",
|
|
40
|
+
message: `${facts.mutation} was sent at ${facts.sent}, ${Math.abs(facts.sent - facts.own)} ms from this server's clock (${facts.own}), past its clockSkew of ${facts.bound} ms: it was written at the server's time, so the client's prediction of it moves when the answer lands. The client's clock is off, or the request waited that long.`,
|
|
41
|
+
...facts
|
|
42
|
+
});
|
|
4
43
|
// src/refusal.ts
|
|
5
44
|
/** A caller who could not be told, as a 401 body: the twin of `answer`'s 403. */
|
|
6
45
|
const unauthenticatedAnswer = (refusal) => ({
|
|
@@ -26,6 +65,13 @@ var RemoteServerError = class extends Schema.TaggedError()("RemoteServerError",
|
|
|
26
65
|
*/
|
|
27
66
|
var RemoteUnmet = class extends Schema.TaggedError()("RemoteUnmet", { message: Schema.String }) {};
|
|
28
67
|
/**
|
|
68
|
+
* A writer's word that a row already holds the id an insert names, and its
|
|
69
|
+
* ledger records no insert of this operation that made it: `RemoteServer.write`
|
|
70
|
+
* answers it as the mutation's `Taken` refusal. It says nothing of the row,
|
|
71
|
+
* which may be hidden from whoever asked.
|
|
72
|
+
*/
|
|
73
|
+
var RemoteTaken = class extends Schema.TaggedError()("RemoteTaken", { message: Schema.String }) {};
|
|
74
|
+
/**
|
|
29
75
|
* A writer's word that the row a write would leave breaks one of its Entity's
|
|
30
76
|
* invariants: `RemoteServer.write` answers it as the mutation's `Invalid`
|
|
31
77
|
* refusal. `rule` and `path` are none and empty when saying them would tell
|
|
@@ -50,6 +96,32 @@ var MutationRefused = class extends Schema.TaggedError()("MutationRefused", {
|
|
|
50
96
|
}) {};
|
|
51
97
|
/** `source.read` of `fields`, through the source's `filter` when it has one. */
|
|
52
98
|
const readFiltered = (source, principal, fields, read) => source.filter === void 0 ? read(fields) : Effect.flatMap(source.filter(principal, fields), (plan) => Effect.map(read(plan.fields), (records) => records.map(plan.apply)));
|
|
99
|
+
/**
|
|
100
|
+
* A read as the handlers make it for `context.principal`: the asked fields the
|
|
101
|
+
* source declares and `authorize` allows, through `filter`, each record holding
|
|
102
|
+
* no other field. None when the principal may read none of the fields asked,
|
|
103
|
+
* so a caller can tell nothing to read from a row that is gone.
|
|
104
|
+
*/
|
|
105
|
+
const readAs = (source, context) => {
|
|
106
|
+
const { ids, principal, viewer } = context;
|
|
107
|
+
const allowed = allowedFields(source, principal, context.fields);
|
|
108
|
+
if (allowed.length === 0) return Effect.succeed(Option.none());
|
|
109
|
+
return readFiltered(source, principal, allowed, (fields) => source.read({
|
|
110
|
+
ids,
|
|
111
|
+
fields,
|
|
112
|
+
principal,
|
|
113
|
+
viewer,
|
|
114
|
+
...windowsOf(context.windows, allowed)
|
|
115
|
+
})).pipe(Effect.map((records) => Option.some(records.map((record) => {
|
|
116
|
+
const values = Object.create(null);
|
|
117
|
+
for (const field of allowed) if (Object.hasOwn(record.values, field)) values[field] = record.values[field];
|
|
118
|
+
return {
|
|
119
|
+
id: record.id,
|
|
120
|
+
values
|
|
121
|
+
};
|
|
122
|
+
}))));
|
|
123
|
+
};
|
|
124
|
+
const RowRequirement = Data.taggedEnum();
|
|
53
125
|
const connectionChange = (connection, ref, position) => {
|
|
54
126
|
const edge = {
|
|
55
127
|
entity: ref.entity,
|
|
@@ -84,11 +156,63 @@ const windowsOf = (windows, fields) => {
|
|
|
84
156
|
const kept = Object.fromEntries(fields.flatMap((field) => Object.hasOwn(windows, field) ? [[field, windows[field]]] : []));
|
|
85
157
|
return Object.keys(kept).length === 0 ? {} : { windows: kept };
|
|
86
158
|
};
|
|
159
|
+
/** How far from the server's clock a client's time is taken as a write's, unless `make` says. */
|
|
160
|
+
const DEFAULT_CLOCK_SKEW = Duration.seconds(60);
|
|
161
|
+
/**
|
|
162
|
+
* A write's time: the client's, when it sent one within `clockSkew` of this
|
|
163
|
+
* server's clock, or this server's. A time refused past a bound above zero is
|
|
164
|
+
* reported; at zero every client time is refused by design, so none is.
|
|
165
|
+
*/
|
|
166
|
+
const writeTime = (server, mutation, sent) => Effect.flatMap(Clock.currentTimeMillis, (own) => Option.match(sent, {
|
|
167
|
+
onNone: () => Effect.succeed(own),
|
|
168
|
+
onSome: (time) => {
|
|
169
|
+
const bound = Duration.toMillis(server.clockSkew ?? DEFAULT_CLOCK_SKEW);
|
|
170
|
+
if (bound === 0) return Effect.succeed(own);
|
|
171
|
+
return Math.abs(time - own) <= bound ? Effect.succeed(time) : Effect.as(Diagnostics.report(clockSkewed({
|
|
172
|
+
mutation,
|
|
173
|
+
sent: time,
|
|
174
|
+
own,
|
|
175
|
+
bound
|
|
176
|
+
})), own);
|
|
177
|
+
}
|
|
178
|
+
}));
|
|
179
|
+
/**
|
|
180
|
+
* What a body's `Expr.viewer` and `Expr.now` read on this server: the viewer
|
|
181
|
+
* the request was given, and the server's clock. A body that reads the viewer
|
|
182
|
+
* in a run given none (not through a server) is refused, never read as a
|
|
183
|
+
* visitor's.
|
|
184
|
+
*/
|
|
185
|
+
const exprContext = (body, viewer, now) => {
|
|
186
|
+
if (viewer === void 0 && Query.dependencies(body).operations.includes("viewer")) throw new Error(`[foldkit-remote-server] a query of ${body.entity.name} reads Expr.viewer, but was run outside a server, which gives the viewer`);
|
|
187
|
+
return {
|
|
188
|
+
viewer: viewer ?? Option.none(),
|
|
189
|
+
now: Option.some(now)
|
|
190
|
+
};
|
|
191
|
+
};
|
|
192
|
+
/** Who asks, as the server's `viewer` says: none for a visitor, or on a server with no viewer. */
|
|
193
|
+
const viewerOf = (server, principal) => server.viewer === void 0 ? Option.none() : server.viewer(principal);
|
|
194
|
+
/**
|
|
195
|
+
* One row as `principal` may see it, through the server's own source for its
|
|
196
|
+
* Entity: the fields its `authorize` allows, filtered as the source filters.
|
|
197
|
+
* None for a row hidden or not there.
|
|
198
|
+
*/
|
|
199
|
+
const rowAs = (server, principal) => (ref, fields) => {
|
|
200
|
+
const source = server.entities.get(ref.entity);
|
|
201
|
+
if (source === void 0) return Effect.fail(new RemoteServerError({ message: `No source serves ${ref.entity}` }));
|
|
202
|
+
const allowed = source.authorize?.(principal, fields) ?? fields;
|
|
203
|
+
return Effect.map(readFiltered(source, principal, allowed, (read) => source.read({
|
|
204
|
+
ids: [ref.id],
|
|
205
|
+
fields: read,
|
|
206
|
+
principal,
|
|
207
|
+
viewer: viewerOf(server, principal)
|
|
208
|
+
})), (records) => Option.map(Option.fromUndefinedOr(records[0]), (record) => record.values));
|
|
209
|
+
};
|
|
210
|
+
/** `read` with the services the request already runs with, so its caller needs none. */
|
|
211
|
+
const withServices = (read, services) => (...args) => Effect.provideContext(read(...args), services);
|
|
87
212
|
/** A read batch may not carry more than this many distinct ids per entity. */
|
|
88
213
|
const DEFAULT_MAX_IDS_PER_ENTITY = 1e3;
|
|
89
214
|
/** A nested selection may not reach further than this many relation levels. */
|
|
90
215
|
const DEFAULT_MAX_DEPTH = 8;
|
|
91
|
-
/** Fails when the requirements name more distinct ids of one entity than `maxIds`. */
|
|
92
216
|
/**
|
|
93
217
|
* Each page of a relation read beside another is a source read of its own, and
|
|
94
218
|
* the names come from the client, so how many one relation may have is bounded.
|
|
@@ -110,6 +234,7 @@ const checkPagesPerRelation = (requirements) => {
|
|
|
110
234
|
if (nested !== void 0) return nested;
|
|
111
235
|
}
|
|
112
236
|
};
|
|
237
|
+
/** The entity the requirements name more distinct ids of than `maxIds`; `undefined` when none. */
|
|
113
238
|
const checkIdsPerEntity = (requirements, maxIds) => {
|
|
114
239
|
const ids = /* @__PURE__ */ new Map();
|
|
115
240
|
for (const requirement of requirements) {
|
|
@@ -119,6 +244,58 @@ const checkIdsPerEntity = (requirements, maxIds) => {
|
|
|
119
244
|
if (seen.size > maxIds) return requirement.entity;
|
|
120
245
|
}
|
|
121
246
|
};
|
|
247
|
+
/** Why a live subscription asks more than a read may; `undefined` when it does not. */
|
|
248
|
+
const liveRefusal = (requirements, maxIds) => {
|
|
249
|
+
const over = checkIdsPerEntity(requirements, maxIds);
|
|
250
|
+
if (over !== void 0) return new RemoteLiveRefused({ message: `Too many "${over}" ids in one live subscription (at most ${maxIds})` });
|
|
251
|
+
const paged = checkPagesPerRelation(requirements);
|
|
252
|
+
if (paged !== void 0) return new RemoteLiveRefused({ message: `Too many pages of "${paged}" in one live subscription` });
|
|
253
|
+
};
|
|
254
|
+
/**
|
|
255
|
+
* Admits each live list as a read of it is admitted, and refuses what a list
|
|
256
|
+
* read again every tick may not be: a query the server does not register, an
|
|
257
|
+
* input it does not decode, no `select` (a row is diffed by what it is drawn
|
|
258
|
+
* with) or one of another entity than the query lists, no `first`, or a
|
|
259
|
+
* `first` that, with the ids of its entity the subscription names, passes
|
|
260
|
+
* `maxIds`.
|
|
261
|
+
*/
|
|
262
|
+
const admitQueries = (server, queries, requirements, maxIds) => Effect.gen(function* () {
|
|
263
|
+
const refused = (message) => new RemoteLiveRefused({ message });
|
|
264
|
+
const admitted = [];
|
|
265
|
+
const rows = /* @__PURE__ */ new Map();
|
|
266
|
+
for (const request of queries) {
|
|
267
|
+
const source = server.queries.get(request.query);
|
|
268
|
+
if (source === void 0) return yield* refused(`Unknown query "${request.query}" read live`);
|
|
269
|
+
const { select } = request;
|
|
270
|
+
if (select === void 0) return yield* refused(`Query "${request.query}" is read live with no select`);
|
|
271
|
+
if (select.entity !== source.entity) return yield* refused(`Query "${request.query}" lists "${source.entity}", but is read live selecting "${select.entity}"`);
|
|
272
|
+
const { first } = request.window;
|
|
273
|
+
if (first === void 0) return yield* refused(`Query "${request.query}" is read live with no first`);
|
|
274
|
+
const paged = checkPagesPerRelation([select]);
|
|
275
|
+
if (paged !== void 0) return yield* refused(`Too many pages of "${paged}" in one live subscription`);
|
|
276
|
+
const input = yield* Schema.decodeUnknownEffect(source.Input)(request.input).pipe(Effect.mapError(() => refused(`Invalid input of query "${request.query}" read live`)));
|
|
277
|
+
rows.set(select.entity, (rows.get(select.entity) ?? 0) + first);
|
|
278
|
+
admitted.push({
|
|
279
|
+
request,
|
|
280
|
+
select,
|
|
281
|
+
source,
|
|
282
|
+
input
|
|
283
|
+
});
|
|
284
|
+
}
|
|
285
|
+
const ids = /* @__PURE__ */ new Map();
|
|
286
|
+
for (const requirement of requirements) {
|
|
287
|
+
const seen = ids.get(requirement.entity) ?? /* @__PURE__ */ new Set();
|
|
288
|
+
seen.add(requirement.id);
|
|
289
|
+
ids.set(requirement.entity, seen);
|
|
290
|
+
}
|
|
291
|
+
for (const [entity, listed] of rows) if ((ids.get(entity)?.size ?? 0) + listed > maxIds) return yield* refused(`Too many "${entity}" ids in one live subscription (at most ${maxIds}, the rows of its live lists counted)`);
|
|
292
|
+
return admitted;
|
|
293
|
+
});
|
|
294
|
+
/** A subscriber's viewer as a group key: who, none for a visitor, or no server viewer. */
|
|
295
|
+
const viewerKeyOf = (viewer) => viewer === void 0 ? "unset" : Option.match(viewer, {
|
|
296
|
+
onNone: () => "visitor",
|
|
297
|
+
onSome: (ref) => `as ${ref.entity}:${ref.id}`
|
|
298
|
+
});
|
|
122
299
|
const liveHub = (entities, options = {}) => Effect.sync(() => {
|
|
123
300
|
const keyOf = options.key ?? ((principal) => principal);
|
|
124
301
|
const sources = new Map(entities.map((source) => [source.entity, source]));
|
|
@@ -149,12 +326,14 @@ const liveHub = (entities, options = {}) => Effect.sync(() => {
|
|
|
149
326
|
return;
|
|
150
327
|
}
|
|
151
328
|
const given = (field) => values !== void 0 && source.shared !== void 0 && source.shared.has(field) && Object.hasOwn(values, field);
|
|
329
|
+
const perViewer = (source.perViewer ?? []).length > 0;
|
|
152
330
|
const groups = /* @__PURE__ */ new Map();
|
|
153
331
|
for (const subscriber of subscribers) {
|
|
154
332
|
const selected = subscriber.selected.get(key);
|
|
155
333
|
if (selected === void 0) continue;
|
|
156
334
|
const fields = Option.getOrElse(which, () => [...new Set([...selected.fields].map(aliasedField))]);
|
|
157
335
|
const principalKey = keyOf(subscriber.principal);
|
|
336
|
+
const viewerKey = perViewer ? viewerKeyOf(subscriber.viewer) : "";
|
|
158
337
|
const sharing = groups.get(principalKey) ?? {
|
|
159
338
|
principal: subscriber.principal,
|
|
160
339
|
byWindows: /* @__PURE__ */ new Map()
|
|
@@ -162,7 +341,7 @@ const liveHub = (entities, options = {}) => Effect.sync(() => {
|
|
|
162
341
|
groups.set(principalKey, sharing);
|
|
163
342
|
const { byWindows } = sharing;
|
|
164
343
|
const join = (windows, renames, wanted) => {
|
|
165
|
-
const groupKey = `${stableStringify(windows)}\u0000${stableStringify(renames)}`;
|
|
344
|
+
const groupKey = `${stableStringify(windows)}\u0000${stableStringify(renames)}\u0000${viewerKey}`;
|
|
166
345
|
const group = byWindows.get(groupKey) ?? {
|
|
167
346
|
windows,
|
|
168
347
|
renames,
|
|
@@ -203,15 +382,16 @@ const liveHub = (entities, options = {}) => Effect.sync(() => {
|
|
|
203
382
|
const gone = /* @__PURE__ */ new Set();
|
|
204
383
|
const read = (principal, { windows, renames, entries: group }) => Effect.gen(function* () {
|
|
205
384
|
const requested = [...new Set(group.flatMap((entry) => entry.fields))];
|
|
206
|
-
const
|
|
207
|
-
|
|
208
|
-
const allowedSet = new Set(allowed);
|
|
209
|
-
const record = (yield* readFiltered(source, principal, allowed, (fields) => source.read({
|
|
385
|
+
const viewer = group[0]?.subscriber.viewer;
|
|
386
|
+
const records = yield* readAs(source, {
|
|
210
387
|
ids: [ref.id],
|
|
211
|
-
fields,
|
|
388
|
+
fields: requested,
|
|
212
389
|
principal,
|
|
213
|
-
|
|
214
|
-
|
|
390
|
+
viewer,
|
|
391
|
+
windows
|
|
392
|
+
});
|
|
393
|
+
if (Option.isNone(records)) return;
|
|
394
|
+
const record = records.value.find((candidate) => candidate.id === ref.id);
|
|
215
395
|
for (const { subscriber, fields: wanted } of group) {
|
|
216
396
|
if (gone.has(subscriber)) continue;
|
|
217
397
|
if (record === void 0) {
|
|
@@ -224,7 +404,7 @@ const liveHub = (entities, options = {}) => Effect.sync(() => {
|
|
|
224
404
|
continue;
|
|
225
405
|
}
|
|
226
406
|
const values = Object.create(null);
|
|
227
|
-
for (const field of wanted) if (
|
|
407
|
+
for (const field of wanted) if (Object.hasOwn(record.values, field)) values[renamed(renames, field)] = record.values[field];
|
|
228
408
|
const changed = Object.keys(values);
|
|
229
409
|
if (changed.length === 0) continue;
|
|
230
410
|
yield* emit(subscriber, {
|
|
@@ -241,11 +421,7 @@ const liveHub = (entities, options = {}) => Effect.sync(() => {
|
|
|
241
421
|
if (failures.length > 0) return yield* Effect.fail(failures[0]);
|
|
242
422
|
});
|
|
243
423
|
return {
|
|
244
|
-
subscribe: ({ requirements, after, principal,
|
|
245
|
-
const over = checkIdsPerEntity(requirements, Math.max(1, maxIdsPerEntity ?? DEFAULT_MAX_IDS_PER_ENTITY));
|
|
246
|
-
if (over !== void 0) return yield* new RemoteServerError({ message: `Too many "${over}" ids in one live subscription` });
|
|
247
|
-
const paged = checkPagesPerRelation(requirements);
|
|
248
|
-
if (paged !== void 0) return yield* new RemoteServerError({ message: `Too many pages of "${paged}" in one live subscription` });
|
|
424
|
+
subscribe: ({ requirements, after, principal, viewer }) => Stream.unwrap(Effect.gen(function* () {
|
|
249
425
|
const selected = /* @__PURE__ */ new Map();
|
|
250
426
|
for (const requirement of requirements) {
|
|
251
427
|
const key = `${requirement.entity}:${requirement.id}`;
|
|
@@ -260,6 +436,7 @@ const liveHub = (entities, options = {}) => Effect.sync(() => {
|
|
|
260
436
|
const subscriber = {
|
|
261
437
|
selected,
|
|
262
438
|
principal,
|
|
439
|
+
viewer,
|
|
263
440
|
queue: yield* Queue.unbounded(),
|
|
264
441
|
cursor: after
|
|
265
442
|
};
|
|
@@ -511,7 +688,7 @@ function memory(config) {
|
|
|
511
688
|
if (row === void 0 || !readable(name, row)) return [];
|
|
512
689
|
return [{
|
|
513
690
|
id,
|
|
514
|
-
values: Object.fromEntries(fields.flatMap((field) => Object.hasOwn(row, field) ? [[field, valueFor(refsShown(readable, name, field, row[field]), windows
|
|
691
|
+
values: Object.fromEntries(fields.flatMap((field) => Object.hasOwn(row, field) ? [[field, valueFor(refsShown(readable, name, field, row[field]), windows !== void 0 && Object.hasOwn(windows, field) ? windows[field] : void 0)]] : []))
|
|
515
692
|
}];
|
|
516
693
|
}),
|
|
517
694
|
catch: (error) => new RemoteServerError({ message: error instanceof Error ? error.message : String(error) })
|
|
@@ -523,13 +700,17 @@ function memory(config) {
|
|
|
523
700
|
if (bodiless.length > 0) throw new Error(`RemoteServer.memory: ${bodiless.map((query) => `"${query.name}"`).join(", ")} ${bodiless.length === 1 ? "has" : "have"} no body to run. Declare ${bodiless.length === 1 ? "it" : "them"} with Query.define, or give a source in \`queries\`.`);
|
|
524
701
|
const queries = [...config.queries ?? [], ...[...config.domain.registry.queries.values()].filter((query) => !given.has(query.name)).map((query) => ({
|
|
525
702
|
...visible,
|
|
526
|
-
...RemoteServer.query(query, ({ input, window, principal }) => Effect.flatMap(readableFor(principal), (readable) => Effect.try({
|
|
703
|
+
...RemoteServer.query(query, ({ input, window, principal, viewer }) => Effect.flatMap(Effect.all([readableFor(principal), Clock.currentTimeMillis]), ([readable, now]) => Effect.try({
|
|
527
704
|
try: () => {
|
|
528
705
|
const body = query.body;
|
|
706
|
+
const context = exprContext(body, viewer, now);
|
|
529
707
|
const encoded = Schema.encodeSync(query.Input)(input);
|
|
530
708
|
const entity = body.entity.name;
|
|
531
|
-
const rows = store.rows(entity).filter((row) => readable(entity, row));
|
|
532
|
-
const matched = evaluate(body, encoded, rows, {
|
|
709
|
+
const rows = store.rows(entity).filter((row) => readable(entity, row)).map((row) => Held.fromRefs(body, row));
|
|
710
|
+
const matched = evaluate(body, encoded, rows, {
|
|
711
|
+
operators,
|
|
712
|
+
context
|
|
713
|
+
});
|
|
533
714
|
const locate = (cursor) => {
|
|
534
715
|
const row = rows.find((candidate) => String(candidate.id) === cursor);
|
|
535
716
|
if (row === void 0) throw new Error(`Cursor "${cursor}" names a row that no longer exists`);
|
|
@@ -537,7 +718,10 @@ function memory(config) {
|
|
|
537
718
|
index: evaluate({
|
|
538
719
|
...body,
|
|
539
720
|
where: []
|
|
540
|
-
}, encoded, [...matched, row], {
|
|
721
|
+
}, encoded, [...matched, row], {
|
|
722
|
+
operators,
|
|
723
|
+
context
|
|
724
|
+
}).indexOf(row),
|
|
541
725
|
exact: false
|
|
542
726
|
};
|
|
543
727
|
};
|
|
@@ -561,7 +745,8 @@ function memory(config) {
|
|
|
561
745
|
const server = RemoteServer.make({
|
|
562
746
|
entities: [...entities, ...config.entities ?? []],
|
|
563
747
|
queries,
|
|
564
|
-
mutations: config.mutations?.(store) ?? []
|
|
748
|
+
mutations: config.mutations?.(store) ?? [],
|
|
749
|
+
viewer: config.viewer
|
|
565
750
|
});
|
|
566
751
|
return {
|
|
567
752
|
...store,
|
|
@@ -569,6 +754,65 @@ function memory(config) {
|
|
|
569
754
|
layer: Remote.clientLayer(RemoteServer.handlers(server, config.principal))
|
|
570
755
|
};
|
|
571
756
|
}
|
|
757
|
+
/** The entries of `record` whose key is in `keys`. */
|
|
758
|
+
const pickKeys = (record, keys) => Object.fromEntries(Object.entries(record).filter(([key]) => keys.has(key)));
|
|
759
|
+
/**
|
|
760
|
+
* A fresh read, after a mutation, of what the client shows of each row its
|
|
761
|
+
* outcome names: of each, the shown fields the answer left out, and every
|
|
762
|
+
* shown relation, since the answer's ref alone does not reach what the client
|
|
763
|
+
* reads of its target. Read as any read is, so `authorize` and `filter` hold.
|
|
764
|
+
* Only rows the read returned are answered: a row hidden from the asker keeps
|
|
765
|
+
* what the answer gave it rather than reading as gone.
|
|
766
|
+
*/
|
|
767
|
+
const answerRead = (server, principal, options, shown, outcome) => Effect.gen(function* () {
|
|
768
|
+
const slices = /* @__PURE__ */ new Map();
|
|
769
|
+
for (const slice of shown) {
|
|
770
|
+
const current = slices.get(slice.entity);
|
|
771
|
+
slices.set(slice.entity, current === void 0 ? slice : Requirement.mergeRelation(current, slice));
|
|
772
|
+
}
|
|
773
|
+
const named = /* @__PURE__ */ new Map();
|
|
774
|
+
const name = (entity, id, answered) => {
|
|
775
|
+
const key = `${entity}:${id}`;
|
|
776
|
+
const row = named.get(key) ?? {
|
|
777
|
+
entity,
|
|
778
|
+
id,
|
|
779
|
+
answered: /* @__PURE__ */ new Set()
|
|
780
|
+
};
|
|
781
|
+
for (const field of answered) row.answered.add(field);
|
|
782
|
+
named.set(key, row);
|
|
783
|
+
};
|
|
784
|
+
for (const patch of outcome.entities) name(patch.entity, patch.id, Object.keys(patch.values));
|
|
785
|
+
for (const change of outcome.connections) if (change._tag === "Insert") name(change.edge.entity, change.edge.id, []);
|
|
786
|
+
for (const row of outcome.pointed ?? []) name(row.entity, row.id, []);
|
|
787
|
+
for (const gone of outcome.deleted) named.delete(`${gone.entity}:${gone.id}`);
|
|
788
|
+
const requests = [];
|
|
789
|
+
for (const row of named.values()) {
|
|
790
|
+
const slice = slices.get(row.entity);
|
|
791
|
+
if (slice === void 0) continue;
|
|
792
|
+
const relations = slice.relations ?? {};
|
|
793
|
+
const fields = slice.fields.filter((field) => !row.answered.has(field) || Object.hasOwn(relations, field));
|
|
794
|
+
const kept = new Set(fields);
|
|
795
|
+
requests.push({
|
|
796
|
+
entity: row.entity,
|
|
797
|
+
id: row.id,
|
|
798
|
+
fields,
|
|
799
|
+
...slice.windows === void 0 ? {} : { windows: pickKeys(slice.windows, kept) },
|
|
800
|
+
...slice.relations === void 0 ? {} : { relations: pickKeys(slice.relations, kept) }
|
|
801
|
+
});
|
|
802
|
+
}
|
|
803
|
+
const read = yield* RemoteServer.readHelper(server, principal, options, requests);
|
|
804
|
+
const reached = new Set(read.entities.map((row) => `${row.entity}:${row.id}`));
|
|
805
|
+
const found = requests.filter((request) => reached.has(`${request.entity}:${request.id}`));
|
|
806
|
+
const unreached = new Set(requests.map((request) => `${request.entity}:${request.id}`).filter((key) => !reached.has(key)));
|
|
807
|
+
const result = {
|
|
808
|
+
entities: read.entities,
|
|
809
|
+
settled: read.settled.filter((row) => !unreached.has(`${row.entity}:${row.id}`))
|
|
810
|
+
};
|
|
811
|
+
return found.length === 0 ? Option.none() : Option.some({
|
|
812
|
+
requests: found,
|
|
813
|
+
result
|
|
814
|
+
});
|
|
815
|
+
});
|
|
572
816
|
/**
|
|
573
817
|
* A Source's refusal as the client receives it: encoded by the mutation's own
|
|
574
818
|
* `Refusal`. A refusal made for another mutation, or one the mutation does not
|
|
@@ -621,7 +865,8 @@ const RemoteServer = {
|
|
|
621
865
|
input: context.input,
|
|
622
866
|
principal: context.principal,
|
|
623
867
|
requestId: context.requestId,
|
|
624
|
-
operation: context.operation
|
|
868
|
+
operation: context.operation,
|
|
869
|
+
now: context.now
|
|
625
870
|
}).pipe(Effect.map((outcome) => ({
|
|
626
871
|
output: outcome.output,
|
|
627
872
|
entities: outcome.entities ?? [],
|
|
@@ -647,6 +892,12 @@ const RemoteServer = {
|
|
|
647
892
|
*/
|
|
648
893
|
unmet: (message = "The row does not hold what the write asks of it") => new RemoteUnmet({ message }),
|
|
649
894
|
/**
|
|
895
|
+
* A writer's refusal of an insert whose id a row already holds: fail
|
|
896
|
+
* `insert` with it (`yield* RemoteServer.taken()`), and `RemoteServer.write`
|
|
897
|
+
* answers the mutation's `Taken` refusal, naming the Entity and the id.
|
|
898
|
+
*/
|
|
899
|
+
taken: (message = "The id is already taken") => new RemoteTaken({ message }),
|
|
900
|
+
/**
|
|
650
901
|
* A writer's refusal of a row that would break an invariant: fail `update`
|
|
651
902
|
* or `insert` with it, naming the invariant's id and path when the caller
|
|
652
903
|
* may be told them, and `RemoteServer.write` answers the mutation's
|
|
@@ -683,8 +934,9 @@ const RemoteServer = {
|
|
|
683
934
|
* input bound to the write lands through `writer`, and the row as written
|
|
684
935
|
* answers as a patch (a deletion as `deleted`). An update writes only the
|
|
685
936
|
* keys the client named, when it named some, and fails for a row that is not
|
|
686
|
-
* there; an insert of an id already
|
|
687
|
-
*
|
|
937
|
+
* there; an insert of an id already taken is refused as taken, alike
|
|
938
|
+
* whatever the row holds, unless the writer's ledger records this operation
|
|
939
|
+
* as the insert that made it (a retry), answered with that row; a delete of
|
|
688
940
|
* a row already gone succeeds. A row that moved past the revision the write
|
|
689
941
|
* `expect`s is refused as a conflict, and one that does not hold its `when`
|
|
690
942
|
* as unmet; a write with a `when` needs a writer that checks it
|
|
@@ -695,17 +947,59 @@ const RemoteServer = {
|
|
|
695
947
|
if (write.input.entity.name !== writer.entity) throw new Error(`[foldkit-remote-server] write "${mutation.name}" writes ${write.input.entity.name}, but its writer is for ${writer.entity}`);
|
|
696
948
|
if (write.increments.length > 0 && write.expect === void 0 && writer.ledger !== true) throw new Error(`[foldkit-remote-server] write "${mutation.name}" increments a field and expects no revision, so a retry could add twice; give it \`expect\`, or a writer with a ledger`);
|
|
697
949
|
if (write.increments.length > 0 && writer.increments !== true) throw new Error(`[foldkit-remote-server] write "${mutation.name}" increments a field, but its writer for ${writer.entity} does not add one (increments)`);
|
|
950
|
+
const real = write.increments.find((increment) => !SchemaShape.holdsIntegers(Schema.toEncoded(increment.field.schema).ast));
|
|
951
|
+
if (real !== void 0 && write.expect === void 0 && writer.pins !== true) throw new Error(`[foldkit-remote-server] write "${mutation.name}" increments "${real.field.key}", a real number, and expects no revision; adding reals does not associate, so concurrent increments could land as two different sums. Give it \`expect\``);
|
|
952
|
+
if (write.assignments.length > 0 && writer.assignments !== true) throw new Error(`[foldkit-remote-server] write "${mutation.name}" computes a field, but its writer for ${writer.entity} does not compute one (assignments)`);
|
|
953
|
+
if (write.assignments.length > 0 && write.expect === void 0) {
|
|
954
|
+
if (writer.ledger !== true) throw new Error(`[foldkit-remote-server] write "${mutation.name}" computes a field and expects no revision, so a retry could compute twice; give it \`expect\`, or a writer with a ledger`);
|
|
955
|
+
const order = write.assignments.find((assignment) => writer.pins !== true && writer.commutes?.(assignment) !== true);
|
|
956
|
+
if (order !== void 0) throw new Error(`[foldkit-remote-server] write "${mutation.name}" computes "${order.field.key}" and expects no revision, but its writer does not show concurrent writes of it land as one result (its operator commuting and associating, tested); give it \`expect\``);
|
|
957
|
+
}
|
|
698
958
|
const refused = writer.refuses?.(write) ?? [];
|
|
699
959
|
if (refused.length > 0) throw new Error(`[foldkit-remote-server] write "${mutation.name}" cannot land through its writer for ${writer.entity}: ${refused.join("; ")}`);
|
|
700
960
|
const judged = Entity.invariants(write.input.entity).filter((held) => write._tag === "Update" || !Entity.readsBefore(held));
|
|
701
961
|
if (judged.length > 0 && writer.invariants !== true) throw new Error(`[foldkit-remote-server] write "${mutation.name}" writes ${writer.entity}, which has invariants, but its writer does not judge them (invariants)`);
|
|
962
|
+
const contextual = write.context.flatMap(({ member }) => member._tag === "Field" ? [member.key] : []);
|
|
702
963
|
if (write._tag === "Insert") {
|
|
703
|
-
const sets = /* @__PURE__ */ new Set([
|
|
964
|
+
const sets = /* @__PURE__ */ new Set([
|
|
965
|
+
"id",
|
|
966
|
+
...write.sets.map((set) => set.field.key),
|
|
967
|
+
...contextual
|
|
968
|
+
]);
|
|
704
969
|
const unset = judged.flatMap((held) => held.after.filter((key) => !sets.has(key)).map((key) => `${held.id} reads ${key}`));
|
|
705
970
|
if (unset.length > 0) throw new Error(`[foldkit-remote-server] insert "${mutation.name}" leaves unset a field an invariant reads (${unset.join("; ")})`);
|
|
706
971
|
}
|
|
707
972
|
if (Option.isSome(write.when) && writer.preconditions !== true) throw new Error(`[foldkit-remote-server] write "${mutation.name}" has a precondition, but its writer for ${writer.entity} does not check one (preconditions)`);
|
|
708
973
|
const encodeInput = Schema.encodeUnknownEffect(write.input.schema);
|
|
974
|
+
const relations = write.input.entity.relations;
|
|
975
|
+
const pointers = Object.values(relations).flatMap((relation) => {
|
|
976
|
+
if (relation._tag !== "Relation" || relation.cardinality !== "one") return [];
|
|
977
|
+
const isThis = (read) => read.owner.token === relation.owner.token && read.key === relation.key;
|
|
978
|
+
return Object.values(relation.target().derived).some((member) => member._tag === "Derived" && Derivation.$match(member.derives, {
|
|
979
|
+
Supplied: () => true,
|
|
980
|
+
Count: ({ relation: read }) => isThis(read),
|
|
981
|
+
Exists: ({ relation: read }) => isThis(read)
|
|
982
|
+
})) ? [relation.key] : [];
|
|
983
|
+
});
|
|
984
|
+
const seenLinks = (id, principal) => writer.read !== void 0 ? writer.read({
|
|
985
|
+
id,
|
|
986
|
+
fields: pointers,
|
|
987
|
+
principal
|
|
988
|
+
}) : writer.linked !== void 0 ? writer.linked({
|
|
989
|
+
id,
|
|
990
|
+
relations: pointers
|
|
991
|
+
}) : Effect.succeed(Option.none());
|
|
992
|
+
const pointedAt = (id, principal) => pointers.length === 0 ? Effect.succeed([]) : Effect.map(seenLinks(id, principal), (held) => Option.match(held, {
|
|
993
|
+
onNone: () => [],
|
|
994
|
+
onSome: (links) => pointers.flatMap((key) => {
|
|
995
|
+
const ref = Object.hasOwn(links, key) ? links[key] : void 0;
|
|
996
|
+
return typeof ref === "string" ? [refParts(ref)] : [];
|
|
997
|
+
})
|
|
998
|
+
}));
|
|
999
|
+
const naming = (outcome, pointed) => pointed.length === 0 ? outcome : {
|
|
1000
|
+
...outcome,
|
|
1001
|
+
pointed
|
|
1002
|
+
};
|
|
709
1003
|
return {
|
|
710
1004
|
mutation: mutation.name,
|
|
711
1005
|
writes: {
|
|
@@ -716,7 +1010,15 @@ const RemoteServer = {
|
|
|
716
1010
|
Input: mutation.Input,
|
|
717
1011
|
Output: mutation.Output,
|
|
718
1012
|
Refusal: mutation.Refusal,
|
|
719
|
-
run: ({ input, principal, keys, operation }) => {
|
|
1013
|
+
run: ({ input, principal, viewer, keys, operation, now, read }) => {
|
|
1014
|
+
/** A path from the viewer, read through the server's sources: a row hidden or gone is null. */
|
|
1015
|
+
const context = Write.contextValues(write, {
|
|
1016
|
+
viewer,
|
|
1017
|
+
now: Option.some(now)
|
|
1018
|
+
}, (row, key) => Effect.map(read(row, [key]), (found) => Held.of(Option.match(found, {
|
|
1019
|
+
onNone: () => null,
|
|
1020
|
+
onSome: (values) => Object.hasOwn(values, key) ? values[key] : void 0
|
|
1021
|
+
}))));
|
|
720
1022
|
const given = input;
|
|
721
1023
|
const expect = Write.expected(write, given);
|
|
722
1024
|
const conflict = (bound) => RemoteServer.refuse(mutation, { _tag: "Conflict" }, `${bound.entity} ${bound.id} changed since it was read`);
|
|
@@ -730,6 +1032,7 @@ const RemoteServer = {
|
|
|
730
1032
|
const unmet = (bound, writing) => Effect.catchTag(writing, "RemoteUnmet", () => Option.isNone(write.when) ? Effect.fail(new RemoteServerError({ message: `${writer.entity}'s writer refused ${mutation.name}, which has no precondition, as unmet` })) : Effect.fail(RemoteServer.refuse(mutation, { _tag: "Unmet" }, `${bound.entity} ${bound.id} does not hold what ${mutation.name} asks of it`)));
|
|
731
1033
|
const invalid = (writing) => Effect.catchTag(writing, "RemoteInvalid", (refused) => Effect.fail(RemoteServer.refuse(mutation, {
|
|
732
1034
|
_tag: "Invalid",
|
|
1035
|
+
entity: Option.some(write.input.entity.name),
|
|
733
1036
|
rule: refused.rule,
|
|
734
1037
|
message: refused.message,
|
|
735
1038
|
path: refused.path
|
|
@@ -763,42 +1066,79 @@ const RemoteServer = {
|
|
|
763
1066
|
})
|
|
764
1067
|
}));
|
|
765
1068
|
};
|
|
1069
|
+
const request = encodeInput(given).pipe(Effect.map((encoded) => JSON.stringify([
|
|
1070
|
+
mutation.name,
|
|
1071
|
+
keys ?? null,
|
|
1072
|
+
encoded
|
|
1073
|
+
])), Effect.mapError(() => new RemoteServerError({ message: `${mutation.name}'s input did not encode` })));
|
|
766
1074
|
return Match.value(write).pipe(Match.tagsExhaustive({
|
|
767
1075
|
Update: () => Effect.gen(function* () {
|
|
768
|
-
const
|
|
769
|
-
|
|
1076
|
+
const named = Write.bind(write, given, keys);
|
|
1077
|
+
const set = yield* context;
|
|
1078
|
+
if (set.unfilled.length > 0) return yield* Effect.fail(RemoteServer.forbid());
|
|
1079
|
+
const bound = {
|
|
1080
|
+
...named,
|
|
1081
|
+
values: {
|
|
1082
|
+
...named.values,
|
|
1083
|
+
...set.values
|
|
1084
|
+
},
|
|
1085
|
+
links: {
|
|
1086
|
+
...named.links,
|
|
1087
|
+
...set.links
|
|
1088
|
+
}
|
|
1089
|
+
};
|
|
1090
|
+
const before = yield* pointedAt(bound.id, principal);
|
|
1091
|
+
if (write.increments.length + write.assignments.length > 0 && write.expect === void 0 && Option.isNone(operation)) return yield* new RemoteServerError({ message: `${mutation.name} moves a field with no revision, so it needs an operation id` });
|
|
770
1092
|
const written = yield* invalid(unmet(bound, writer.update({
|
|
771
1093
|
id: bound.id,
|
|
772
1094
|
operation,
|
|
1095
|
+
request: yield* request,
|
|
773
1096
|
values: bound.values,
|
|
774
1097
|
increments: bound.increments,
|
|
1098
|
+
assignments: bound.assignments,
|
|
775
1099
|
links: bound.links,
|
|
776
1100
|
expect,
|
|
777
1101
|
when: yield* when,
|
|
778
1102
|
principal
|
|
779
1103
|
})));
|
|
780
|
-
if (Option.isSome(written)) return yield* answered(bound, written.value);
|
|
1104
|
+
if (Option.isSome(written)) return naming(yield* answered(bound, written.value), [...before, ...yield* pointedAt(bound.id, principal)]);
|
|
781
1105
|
return yield* Option.isSome(expect) ? Effect.fail(conflict(bound)) : Effect.fail(new RemoteServerError({ message: `No ${bound.entity} ${bound.id} to update` }));
|
|
782
1106
|
}),
|
|
783
1107
|
Insert: () => Effect.gen(function* () {
|
|
784
1108
|
const bound = Write.bind(write, given);
|
|
1109
|
+
const set = yield* context;
|
|
1110
|
+
if (set.unfilled.length > 0) return yield* Effect.fail(RemoteServer.forbid());
|
|
785
1111
|
const row = yield* invalid(writer.insert({
|
|
786
1112
|
id: bound.id,
|
|
787
|
-
values:
|
|
788
|
-
|
|
1113
|
+
values: {
|
|
1114
|
+
...bound.values,
|
|
1115
|
+
...set.values
|
|
1116
|
+
},
|
|
1117
|
+
links: {
|
|
1118
|
+
...bound.links,
|
|
1119
|
+
...set.links
|
|
1120
|
+
},
|
|
1121
|
+
operation,
|
|
1122
|
+
request: yield* request,
|
|
789
1123
|
principal
|
|
790
|
-
}))
|
|
791
|
-
|
|
1124
|
+
}).pipe(Effect.catchTag("RemoteTaken", () => Effect.fail(RemoteServer.refuse(mutation, {
|
|
1125
|
+
_tag: "Taken",
|
|
1126
|
+
entity: bound.entity,
|
|
1127
|
+
id: bound.id
|
|
1128
|
+
}, `${bound.entity} ${bound.id} is already taken`)))));
|
|
1129
|
+
return naming(yield* answered(bound, row), yield* pointedAt(bound.id, principal));
|
|
792
1130
|
}),
|
|
793
1131
|
Delete: () => Effect.gen(function* () {
|
|
794
1132
|
const bound = Write.bind(write, given);
|
|
795
|
-
|
|
1133
|
+
const before = yield* pointedAt(bound.id, principal);
|
|
1134
|
+
const outcome = yield* invalid(unmet(bound, writer.delete({
|
|
796
1135
|
id: bound.id,
|
|
797
1136
|
expect,
|
|
798
1137
|
when: yield* when,
|
|
799
1138
|
principal
|
|
800
|
-
})))
|
|
801
|
-
return
|
|
1139
|
+
})));
|
|
1140
|
+
if (outcome === "moved") return yield* Effect.fail(conflict(bound));
|
|
1141
|
+
const gone = {
|
|
802
1142
|
output: {},
|
|
803
1143
|
entities: [],
|
|
804
1144
|
connections: [],
|
|
@@ -807,6 +1147,7 @@ const RemoteServer = {
|
|
|
807
1147
|
id: bound.id
|
|
808
1148
|
}]
|
|
809
1149
|
};
|
|
1150
|
+
return outcome === "deleted" ? naming(gone, before) : gone;
|
|
810
1151
|
})
|
|
811
1152
|
}));
|
|
812
1153
|
}
|
|
@@ -814,14 +1155,30 @@ const RemoteServer = {
|
|
|
814
1155
|
},
|
|
815
1156
|
query: (query, run) => ({
|
|
816
1157
|
query: query.name,
|
|
1158
|
+
entity: query.Result.entity,
|
|
817
1159
|
Input: query.Input,
|
|
818
1160
|
run: (context) => run({
|
|
819
1161
|
input: context.input,
|
|
820
1162
|
window: context.window,
|
|
821
1163
|
principal: context.principal,
|
|
1164
|
+
viewer: context.viewer,
|
|
822
1165
|
...context.select === void 0 ? {} : { select: context.select }
|
|
823
1166
|
})
|
|
824
1167
|
}),
|
|
1168
|
+
/**
|
|
1169
|
+
* Reads through `source` as the read handlers and the live hub do: only the
|
|
1170
|
+
* asked fields the source declares and its `authorize` allows, each record
|
|
1171
|
+
* through its `filter` and holding no other field. None when the principal
|
|
1172
|
+
* may read none of the fields asked. What a live source of its own reads
|
|
1173
|
+
* with, so it sends no more than a read would.
|
|
1174
|
+
*/
|
|
1175
|
+
readAs,
|
|
1176
|
+
/**
|
|
1177
|
+
* The fields of `fields` that `readAs` reads for `principal`: those the
|
|
1178
|
+
* source declares and its `authorize` allows, in the order asked. Asks
|
|
1179
|
+
* nothing of the store.
|
|
1180
|
+
*/
|
|
1181
|
+
allowedFields,
|
|
825
1182
|
/** Streams live entity patches for a client's live requirements. */
|
|
826
1183
|
live: (entity, options) => ({
|
|
827
1184
|
entity: entity.name,
|
|
@@ -836,12 +1193,39 @@ const RemoteServer = {
|
|
|
836
1193
|
* own principal.
|
|
837
1194
|
*/
|
|
838
1195
|
liveHub,
|
|
839
|
-
|
|
840
|
-
|
|
841
|
-
|
|
842
|
-
|
|
843
|
-
|
|
844
|
-
|
|
1196
|
+
/**
|
|
1197
|
+
* The server: its sources by name. `viewer` says who asks, as a row
|
|
1198
|
+
* (`principal => Option.some(Remote.ref(User, principal.id))`), or none for
|
|
1199
|
+
* a visitor: what a declared write's `Expr.viewer` sets. A server
|
|
1200
|
+
* registering such an insert without one is refused here.
|
|
1201
|
+
*
|
|
1202
|
+
* `clockSkew` is how far from this server's clock a client's time (the
|
|
1203
|
+
* `now` a write is sent with, when the reader acted) may be and still be
|
|
1204
|
+
* the write's time: 60 seconds unless given, and `0` to never take it. A
|
|
1205
|
+
* time beyond it is replaced by the server's own, and reported as
|
|
1206
|
+
* `ClockSkewed`. It bounds how far a client can backdate or postdate a row.
|
|
1207
|
+
*/
|
|
1208
|
+
make: (config) => {
|
|
1209
|
+
const served = new Set(config.entities.map((source) => source.entity));
|
|
1210
|
+
for (const source of config.mutations ?? []) {
|
|
1211
|
+
const unserved = (source.writes === void 0 ? [] : Write.contextReads(source.writes.write)).filter((entity) => !served.has(entity));
|
|
1212
|
+
if (unserved.length > 0) throw new Error(`[foldkit-remote-server] write "${source.mutation}" sets a member from a path through ${unserved.join(", ")}, which no source of this server serves; mount one in entities`);
|
|
1213
|
+
}
|
|
1214
|
+
if (config.viewer === void 0) {
|
|
1215
|
+
const viewing = (config.mutations ?? []).find((source) => (source.writes?.write.context ?? []).some(({ value }) => value._tag === "Viewer"));
|
|
1216
|
+
if (viewing !== void 0) throw new Error(`[foldkit-remote-server] write "${viewing.mutation}" sets a member to whoever asks (Expr.viewer), but the server has no viewer; give RemoteServer.make a viewer`);
|
|
1217
|
+
const reading = config.entities.find((source) => (source.perViewer ?? []).length > 0);
|
|
1218
|
+
if (reading !== void 0) throw new Error(`[foldkit-remote-server] ${reading.entity}'s ${reading.perViewer.join(", ")} depend on who reads them (Derived.exists), but the server has no viewer; give RemoteServer.make a viewer`);
|
|
1219
|
+
}
|
|
1220
|
+
return {
|
|
1221
|
+
entities: new Map(config.entities.map((source) => [source.entity, source])),
|
|
1222
|
+
mutations: new Map((config.mutations ?? []).map((source) => [source.mutation, source])),
|
|
1223
|
+
queries: new Map((config.queries ?? []).map((source) => [source.query, source])),
|
|
1224
|
+
live: new Map((config.live ?? []).map((source) => [source.entity, source])),
|
|
1225
|
+
viewer: config.viewer,
|
|
1226
|
+
...config.clockSkew === void 0 ? {} : { clockSkew: Duration.fromInputUnsafe(config.clockSkew) }
|
|
1227
|
+
};
|
|
1228
|
+
},
|
|
845
1229
|
/**
|
|
846
1230
|
* Checks every source name against the declared domain, so an undeclared
|
|
847
1231
|
* entity/query/mutation fails at startup rather than returning nothing at
|
|
@@ -877,6 +1261,7 @@ const RemoteServer = {
|
|
|
877
1261
|
};
|
|
878
1262
|
const fetched = /* @__PURE__ */ new Map();
|
|
879
1263
|
const fetchedValues = /* @__PURE__ */ new Map();
|
|
1264
|
+
const viewer = viewerOf(server, principal);
|
|
880
1265
|
const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
|
|
881
1266
|
const maxIds = Math.max(1, options.maxIdsPerEntity ?? DEFAULT_MAX_IDS_PER_ENTITY);
|
|
882
1267
|
const over = checkIdsPerEntity(requests, maxIds);
|
|
@@ -920,6 +1305,7 @@ const RemoteServer = {
|
|
|
920
1305
|
ids: chunk,
|
|
921
1306
|
fields,
|
|
922
1307
|
principal,
|
|
1308
|
+
viewer,
|
|
923
1309
|
...windows
|
|
924
1310
|
})), (chunks) => chunks.flat())).pipe(Effect.catchTag("RemoteServerError", (error) => Effect.fail(new RemoteReadError({ message: error.message }))));
|
|
925
1311
|
for (const record of records) {
|
|
@@ -968,8 +1354,10 @@ const RemoteServer = {
|
|
|
968
1354
|
* The request and its payload are decoded by the protocol's own schemas
|
|
969
1355
|
* before a handler sees them, so an operation name is one of Remote's three
|
|
970
1356
|
* and nothing else. A body that is not a request is a 400; a caller who
|
|
971
|
-
* could not be told a 401; a refusal of who is asking a 403; a
|
|
972
|
-
*
|
|
1357
|
+
* could not be told a 401; a refusal of who is asking a 403; a mutation's
|
|
1358
|
+
* declared refusal a 422, or a 409 when it is `Refusal.taken`; a handler's
|
|
1359
|
+
* failure a 500 with its message; a defect a 500 that says nothing of it,
|
|
1360
|
+
* its cause reported as a `ServerDefect` (`Diagnostics`, by default the log).
|
|
973
1361
|
* `Remote.json` and `Remote.http` are the other end.
|
|
974
1362
|
*/
|
|
975
1363
|
answer: (handlers, body) => {
|
|
@@ -994,7 +1382,7 @@ const RemoteServer = {
|
|
|
994
1382
|
status: 500,
|
|
995
1383
|
body: { error: error.message }
|
|
996
1384
|
} : {
|
|
997
|
-
status: 422,
|
|
1385
|
+
status: Refusal.isTaken(error.refusal) ? 409 : 422,
|
|
998
1386
|
body: {
|
|
999
1387
|
error: error.message,
|
|
1000
1388
|
refusal: error.refusal
|
|
@@ -1002,10 +1390,10 @@ const RemoteServer = {
|
|
|
1002
1390
|
})), Effect.catch((error) => Effect.succeed({
|
|
1003
1391
|
status: 500,
|
|
1004
1392
|
body: { error: error.message }
|
|
1005
|
-
})), Effect.catchCause(() => Effect.
|
|
1393
|
+
})), Effect.catchCause((cause) => Diagnostics.report(serverDefect(cause)).pipe(Effect.as({
|
|
1006
1394
|
status: 500,
|
|
1007
1395
|
body: { error: "Internal error" }
|
|
1008
|
-
})));
|
|
1396
|
+
}))));
|
|
1009
1397
|
},
|
|
1010
1398
|
/**
|
|
1011
1399
|
* Compiles the server into Remote's RPC handlers, answering as `principal`:
|
|
@@ -1031,18 +1419,22 @@ const RemoteServer = {
|
|
|
1031
1419
|
const outcome = yield* source.run({
|
|
1032
1420
|
input,
|
|
1033
1421
|
principal: caller,
|
|
1422
|
+
viewer: server.viewer === void 0 ? Option.none() : server.viewer(caller),
|
|
1034
1423
|
requestId: payload.requestId,
|
|
1035
1424
|
operation: Option.fromUndefinedOr(payload.operation),
|
|
1425
|
+
now: yield* writeTime(server, payload.mutation, Option.fromUndefinedOr(payload.now)),
|
|
1426
|
+
read: withServices(rowAs(server, caller), yield* Effect.context()),
|
|
1036
1427
|
keys: payload.keys
|
|
1037
1428
|
}).pipe(Effect.catchTag("RemoteServerError", (error) => Effect.fail(new RemoteMutationError({ message: error.message }))), Effect.catchTag("MutationRefused", (refused) => refusalError(source.Refusal, payload.mutation, refused)));
|
|
1038
1429
|
const output = yield* Schema.encodeUnknownEffect(source.Output)(outcome.output).pipe(Effect.catchTag("SchemaError", () => Effect.fail(new RemoteMutationError({ message: "Invalid mutation output" }))));
|
|
1430
|
+
const read = yield* answerRead(server, caller, options, payload.shown ?? [], outcome).pipe(Effect.catchTag("RemoteReadError", (error) => Diagnostics.report(answerUnread(payload.mutation, error.message)).pipe(Effect.as(Option.none()))));
|
|
1039
1431
|
const hub = options.live;
|
|
1040
1432
|
if (hub !== void 0) {
|
|
1041
1433
|
const stored = source.writes !== void 0;
|
|
1042
1434
|
yield* Effect.forEach(outcome.entities, (patch) => hub.changed({
|
|
1043
1435
|
entity: patch.entity,
|
|
1044
1436
|
id: patch.id
|
|
1045
|
-
}, Object.keys(patch.values), stored ? patch.values : void 0)).pipe(Effect.andThen(Effect.forEach(outcome.deleted, (gone) => hub.deleted(gone))), Effect.catchCause((cause) =>
|
|
1437
|
+
}, Object.keys(patch.values), stored ? patch.values : void 0)).pipe(Effect.andThen(Effect.forEach(outcome.deleted, (gone) => hub.deleted(gone))), Effect.catchCause((cause) => Diagnostics.report(publishFailed(payload.mutation, cause))));
|
|
1046
1438
|
}
|
|
1047
1439
|
return {
|
|
1048
1440
|
output,
|
|
@@ -1055,7 +1447,11 @@ const RemoteServer = {
|
|
|
1055
1447
|
deleted: outcome.deleted.map((gone) => ({
|
|
1056
1448
|
entity: gone.entity,
|
|
1057
1449
|
id: gone.id
|
|
1058
|
-
}))
|
|
1450
|
+
})),
|
|
1451
|
+
...Option.match(read, {
|
|
1452
|
+
onNone: () => ({}),
|
|
1453
|
+
onSome: (value) => ({ read: value })
|
|
1454
|
+
})
|
|
1059
1455
|
};
|
|
1060
1456
|
}),
|
|
1061
1457
|
FoldkitRemoteQuery: Effect.fn("RemoteServer.FoldkitRemoteQuery")(function* (payload) {
|
|
@@ -1072,6 +1468,7 @@ const RemoteServer = {
|
|
|
1072
1468
|
input,
|
|
1073
1469
|
window: payload.window,
|
|
1074
1470
|
principal: caller,
|
|
1471
|
+
viewer: viewerOf(server, caller),
|
|
1075
1472
|
...select === void 0 ? {} : { select }
|
|
1076
1473
|
}).pipe(Effect.catchTag("RemoteServerError", (error) => Effect.fail(new RemoteQueryError({ message: error.message }))));
|
|
1077
1474
|
if (select === void 0) return {
|
|
@@ -1104,28 +1501,50 @@ const RemoteServer = {
|
|
|
1104
1501
|
FoldkitRemoteLive: (payload) => {
|
|
1105
1502
|
const mismatch = protocolMismatch(payload.version);
|
|
1106
1503
|
if (mismatch !== void 0) return Stream.fail(mismatch);
|
|
1107
|
-
|
|
1108
|
-
|
|
1504
|
+
const maxIds = Math.max(1, options.maxIdsPerEntity ?? DEFAULT_MAX_IDS_PER_ENTITY);
|
|
1505
|
+
const refusal = liveRefusal(payload.requirements, maxIds);
|
|
1506
|
+
if (refusal !== void 0) return Stream.fail(refusal);
|
|
1507
|
+
return Stream.unwrap(Effect.gen(function* () {
|
|
1508
|
+
const admitted = yield* admitQueries(server, payload.queries ?? [], payload.requirements, maxIds);
|
|
1509
|
+
const caller = yield* asking;
|
|
1510
|
+
const viewer = viewerOf(server, caller);
|
|
1511
|
+
const queries = admitted.map(({ request, select, source, input }) => ({
|
|
1512
|
+
identity: queryIdentity(request.query, request.input),
|
|
1513
|
+
select,
|
|
1514
|
+
edges: Effect.map(source.run({
|
|
1515
|
+
input,
|
|
1516
|
+
window: request.window,
|
|
1517
|
+
principal: caller,
|
|
1518
|
+
viewer,
|
|
1519
|
+
select
|
|
1520
|
+
}), (page) => page.edges)
|
|
1521
|
+
}));
|
|
1522
|
+
const streams = [.../* @__PURE__ */ new Set([...payload.requirements.map((request) => request.entity), ...queries.map((query) => query.select.entity)])].flatMap((entity) => {
|
|
1109
1523
|
const source = server.live.get(entity);
|
|
1110
1524
|
if (source === void 0) return [];
|
|
1111
1525
|
return [source.subscribe({
|
|
1112
1526
|
requirements: payload.requirements.filter((request) => request.entity === entity),
|
|
1527
|
+
queries: queries.filter((query) => query.select.entity === entity),
|
|
1113
1528
|
after: payload.after,
|
|
1114
|
-
principal: caller
|
|
1529
|
+
principal: caller,
|
|
1530
|
+
viewer
|
|
1115
1531
|
})];
|
|
1116
1532
|
});
|
|
1117
1533
|
if (options.live !== void 0) streams.push(options.live.subscribe({
|
|
1118
1534
|
requirements: payload.requirements,
|
|
1119
1535
|
after: payload.after,
|
|
1120
1536
|
principal: caller,
|
|
1121
|
-
|
|
1537
|
+
viewer
|
|
1122
1538
|
}));
|
|
1123
|
-
return Stream.mergeAll(streams, { concurrency: "unbounded" }).pipe(Stream.
|
|
1539
|
+
return Stream.mergeAll(streams, { concurrency: "unbounded" }).pipe(Stream.mapAccum(() => payload.after, (cursor, change) => [cursor + 1, [{
|
|
1540
|
+
...change,
|
|
1541
|
+
cursor: cursor + 1
|
|
1542
|
+
}]]), Stream.mapError((error) => new RemoteLiveError({ message: error.message })));
|
|
1124
1543
|
}));
|
|
1125
1544
|
}
|
|
1126
1545
|
};
|
|
1127
1546
|
}
|
|
1128
1547
|
};
|
|
1129
|
-
export {
|
|
1548
|
+
export { RemoteTaken as a, exprContext as c, evaluate$1 as d, supported as f, RemoteServerError as i, QueryEvaluateError as l, serverDefect as m, RemoteInvalid as n, RemoteUnmet as o, unauthenticatedAnswer as p, RemoteServer as r, RowRequirement as s, MutationRefused as t, assertSupported$1 as u };
|
|
1130
1549
|
|
|
1131
|
-
//# sourceMappingURL=src-
|
|
1550
|
+
//# sourceMappingURL=src-ZV9pARkU.mjs.map
|