foldkit-remote-server 0.23.0 → 0.24.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 +210 -29
- package/dist/fetch.d.mts +1 -1
- package/dist/fetch.d.mts.map +1 -1
- package/dist/fetch.mjs +12 -6
- package/dist/fetch.mjs.map +1 -1
- package/dist/{index-lJvjBBDL.d.mts → index-Dq3fHdhH.d.mts} +125 -19
- package/dist/index-Dq3fHdhH.d.mts.map +1 -0
- package/dist/index.d.mts +2 -2
- package/dist/index.mjs +1 -1
- package/dist/{src-B1JAs_gH.mjs → src-6l1A9ww5.mjs} +444 -53
- package/dist/src-6l1A9ww5.mjs.map +1 -0
- package/package.json +6 -6
- package/dist/index-lJvjBBDL.d.mts.map +0 -1
- package/dist/src-B1JAs_gH.mjs.map +0 -1
|
@@ -1,25 +1,19 @@
|
|
|
1
1
|
import { Cause, Context, Data, Duration, Effect, Layer, Option, Schema, Stream } from "effect";
|
|
2
|
-
import { AnyQuery, AnyWrite, Computation, EntityRef, ExprContext, MemoryOperators, QueryEvaluateError, Row, WriteAssignment, assertSupported as assertSupported$1, evaluate as evaluate$1, supported } from "foldkit-entity";
|
|
2
|
+
import { AnyEntity, AnyQuery, AnyWrite, Computation, EntityRef, ExprContext, Invariant, MemoryOperators, QueryEvaluateError, Row, WriteAssignment, assertSupported as assertSupported$1, evaluate as evaluate$1, supported as supported$1 } from "foldkit-entity";
|
|
3
3
|
import { Boundary, CachePolicy, ConnectionChangeSchema, ConnectionIdentity, ConnectionSpec, Diagnostic, LiveChange, MutationDescriptor, NormalizedPatch, QueryDescriptor, QueryWindow, RelationRequirement, RemoteClient, RemoteDescriptor, RemoteForbidden, RemoteJsonAnswer, RemoteReadError, RemoteRpcClient, RemoteUnauthenticated, Requirement } from "foldkit-remote";
|
|
4
4
|
import { HttpServerRequest, HttpServerResponse } from "effect/http";
|
|
5
5
|
/**
|
|
6
|
-
*
|
|
7
|
-
*
|
|
8
|
-
*
|
|
9
|
-
* `RpcServer`, where Effect's own `MaxBodySize` fails the body read as a
|
|
10
|
-
* defect, a 500:
|
|
11
|
-
*
|
|
12
|
-
* ```ts
|
|
13
|
-
* HttpRouter.add('POST', '/rpc', bodyLimit(64 * 1024)(rpcHttpEffect))
|
|
14
|
-
* ```
|
|
15
|
-
*
|
|
16
|
-
* A body within the limit reaches the endpoint whole, read once.
|
|
6
|
+
* A failure on this side, answered "Internal error": a defect, or a Source's
|
|
7
|
+
* failure it did not write for its caller (`RemoteServer.tell`). The caller is
|
|
8
|
+
* told `incident` and nothing of the cause.
|
|
17
9
|
*/
|
|
18
|
-
declare const bodyLimit: (maxBytes?: number) => <E, R>(endpoint: Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R | HttpServerRequest.HttpServerRequest>;
|
|
19
|
-
/** A failure on this side, answered "Internal error"; the caller is told nothing of it. */
|
|
20
10
|
interface ServerDefect extends Diagnostic {
|
|
21
11
|
readonly _tag: 'ServerDefect';
|
|
22
12
|
readonly cause: Cause.Cause<unknown>;
|
|
13
|
+
/** The id the caller was answered with, to find this report by. */
|
|
14
|
+
readonly incident: string;
|
|
15
|
+
/** What was being answered: `read Note`, `query Notes`, `mutate SaveNote`, `live Note`; `request` where no handler was reached. */
|
|
16
|
+
readonly during: string;
|
|
23
17
|
}
|
|
24
18
|
/**
|
|
25
19
|
* A mutation that committed, answered without the read of the rows it names or
|
|
@@ -65,10 +59,74 @@ interface CachedReadDiffers extends Diagnostic {
|
|
|
65
59
|
}
|
|
66
60
|
/** Every diagnostic a Remote server reports. */
|
|
67
61
|
type RemoteServerDiagnostic = ServerDefect | AnswerUnread | PublishFailed | ClockSkewed | CachedReadDiffers;
|
|
62
|
+
/** What a caller is told of a failure on this side: that there was one, and the id it was reported under. */
|
|
63
|
+
interface InternalFailure {
|
|
64
|
+
readonly message: string;
|
|
65
|
+
readonly incident: string;
|
|
66
|
+
}
|
|
67
|
+
/** What `RemoteServer.memoryWriter` is made with. */
|
|
68
|
+
interface MemoryWriterOptions {
|
|
69
|
+
/**
|
|
70
|
+
* How the write's `when`, its computed fields and the Entity's invariants
|
|
71
|
+
* run their primitive operators: the memory backend's own table, as a
|
|
72
|
+
* Drizzle writer names its binding's. `Operators.kernel` when not given.
|
|
73
|
+
*/
|
|
74
|
+
readonly operators?: MemoryOperators | undefined;
|
|
75
|
+
}
|
|
76
|
+
/**
|
|
77
|
+
* A writer of `entity`'s rows in `store` (a memory backend's), for
|
|
78
|
+
* `RemoteServer.write`: an update lands while the row is at the revision it
|
|
79
|
+
* `expect`s, holds its `when`, and the row it would leave keeps every
|
|
80
|
+
* invariant, and moves the revision on by one; an insert lands while its id is
|
|
81
|
+
* free and its row keeps the state invariants; a delete while the row is at
|
|
82
|
+
* its revision and holds its `when`. Each refusal is the writer's own error,
|
|
83
|
+
* which `RemoteServer.write` answers as the mutation's `Conflict`, `Unmet`,
|
|
84
|
+
* `Invalid` or `Taken`. It holds no ledger, judges no rule that reads another
|
|
85
|
+
* row, and removes, restricts or clears nothing a delete would take with it,
|
|
86
|
+
* so `RemoteServer.write` and `GuardServer.writer` refuse, by name, a write or
|
|
87
|
+
* a rule that needs one of those. A write's postcondition (`ensures`) is
|
|
88
|
+
* judged beside the invariants, and refused the same way.
|
|
89
|
+
*
|
|
90
|
+
* ```ts
|
|
91
|
+
* RemoteServer.memory({
|
|
92
|
+
* domain,
|
|
93
|
+
* rows,
|
|
94
|
+
* mutations: store => [RemoteServer.write(ReserveStock, RemoteServer.memoryWriter(store, Product))],
|
|
95
|
+
* })
|
|
96
|
+
* ```
|
|
97
|
+
*/
|
|
98
|
+
declare const memoryWriter: <P>(store: MemoryStore, entity: AnyEntity, options?: MemoryWriterOptions) => EntityWriter<P>;
|
|
99
|
+
/**
|
|
100
|
+
* Effect HTTP middleware refusing a request body over `maxBytes` (default
|
|
101
|
+
* 1 MiB, `serveFetch`'s) with a 413 and Remote's `tooLarge` answer, before
|
|
102
|
+
* the endpoint reads it. For an endpoint that serves `RemoteRpc` through
|
|
103
|
+
* `RpcServer`, where Effect's own `MaxBodySize` fails the body read as a
|
|
104
|
+
* defect, a 500:
|
|
105
|
+
*
|
|
106
|
+
* ```ts
|
|
107
|
+
* HttpRouter.add('POST', '/rpc', bodyLimit(64 * 1024)(rpcHttpEffect))
|
|
108
|
+
* ```
|
|
109
|
+
*
|
|
110
|
+
* A body within the limit reaches the endpoint whole, read once.
|
|
111
|
+
*/
|
|
112
|
+
declare const bodyLimit: (maxBytes?: number) => <E, R>(endpoint: Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, R | HttpServerRequest.HttpServerRequest>;
|
|
68
113
|
declare const RemoteServerError_base: Schema.Class<RemoteServerError, Schema.TaggedStruct<"RemoteServerError", {
|
|
69
114
|
readonly message: Schema.String;
|
|
115
|
+
/** What was caught, for the report; never sent. */
|
|
116
|
+
readonly cause: Schema.optional<Schema.Unknown>;
|
|
117
|
+
/** Set by `RemoteServer.tell` alone: `message` was written for the caller, who reads it as it is. */
|
|
118
|
+
readonly told: Schema.optional<Schema.Literal<true>>;
|
|
70
119
|
}>, Cause.YieldableError>;
|
|
120
|
+
/**
|
|
121
|
+
* A Source's failure. Its `message` and `cause` stay on this side: the server
|
|
122
|
+
* reports them as a `ServerDefect` and answers "Internal error" with the id it
|
|
123
|
+
* reported them under, so a driver's words, a thrown error's or a rule's
|
|
124
|
+
* internals reach no caller. Only `RemoteServer.tell` makes one whose message
|
|
125
|
+
* the caller reads.
|
|
126
|
+
*/
|
|
71
127
|
declare class RemoteServerError extends RemoteServerError_base {}
|
|
128
|
+
/** See `RemoteServer.tell`. */
|
|
129
|
+
declare const tell: (message: string) => RemoteServerError;
|
|
72
130
|
declare const RemoteUnmet_base: Schema.Class<RemoteUnmet, Schema.TaggedStruct<"RemoteUnmet", {
|
|
73
131
|
readonly message: Schema.String;
|
|
74
132
|
}>, Cause.YieldableError>;
|
|
@@ -121,6 +179,11 @@ declare class MutationRefused extends MutationRefused_base {}
|
|
|
121
179
|
interface EntityRecord {
|
|
122
180
|
readonly id: string;
|
|
123
181
|
readonly values: Readonly<Record<string, unknown>>;
|
|
182
|
+
/**
|
|
183
|
+
* The row's revision, when the source keeps one: sent with the row, and a
|
|
184
|
+
* client never lets a lower revision over a higher one it holds.
|
|
185
|
+
*/
|
|
186
|
+
readonly revision?: number | undefined;
|
|
124
187
|
}
|
|
125
188
|
interface EntitySourceContext<P> {
|
|
126
189
|
readonly ids: readonly string[];
|
|
@@ -350,6 +413,14 @@ interface EntityWriter<P, R = never> {
|
|
|
350
413
|
* a writer without it.
|
|
351
414
|
*/
|
|
352
415
|
readonly invariants?: true;
|
|
416
|
+
/**
|
|
417
|
+
* Whether `update` and `insert` refuse a row they would leave that breaks
|
|
418
|
+
* the write's own postcondition (`ensures`, a `becomes` enumeration could
|
|
419
|
+
* not decide), with `RemoteInvalid`, judged as they judge the Entity's
|
|
420
|
+
* invariants. `RemoteServer.write` refuses a write with one through a
|
|
421
|
+
* writer without it, which would land a row outside the state.
|
|
422
|
+
*/
|
|
423
|
+
readonly postconditions?: true;
|
|
353
424
|
/**
|
|
354
425
|
* Whether `delete` removes, in the transaction that deletes the row, every
|
|
355
426
|
* row declared to go with it (`Entity.cascading`), and answers them as
|
|
@@ -430,6 +501,11 @@ interface EntityWriter<P, R = never> {
|
|
|
430
501
|
readonly when: Option.Option<WriteWhen>;
|
|
431
502
|
/** What the row must hold, judged where it is written; only a writer with `requires` is given one. */
|
|
432
503
|
readonly requires?: WriteRequirement | undefined;
|
|
504
|
+
/**
|
|
505
|
+
* The write's postcondition, judged over the row it leaves as an
|
|
506
|
+
* invariant is; only a writer with `postconditions` is given one.
|
|
507
|
+
*/
|
|
508
|
+
readonly ensures?: Invariant | undefined;
|
|
433
509
|
readonly principal: P;
|
|
434
510
|
}) => Effect.Effect<Option.Option<Readonly<Record<string, unknown>>>, RemoteServerError | RemoteForbidden | RemoteUnauthenticated | RemoteUnmet | RemoteInvalid, R>;
|
|
435
511
|
/**
|
|
@@ -451,6 +527,11 @@ interface EntityWriter<P, R = never> {
|
|
|
451
527
|
readonly request: string;
|
|
452
528
|
readonly values: Readonly<Record<string, unknown>>;
|
|
453
529
|
readonly links: Readonly<Record<string, Option.Option<EntityRef>>>;
|
|
530
|
+
/**
|
|
531
|
+
* The write's postcondition, judged over the row it would make as a
|
|
532
|
+
* state invariant is; only a writer with `postconditions` is given one.
|
|
533
|
+
*/
|
|
534
|
+
readonly ensures?: Invariant | undefined;
|
|
454
535
|
readonly principal: P;
|
|
455
536
|
}) => Effect.Effect<Readonly<Record<string, unknown>>, RemoteServerError | RemoteForbidden | RemoteUnauthenticated | RemoteInvalid | RemoteTaken, R>;
|
|
456
537
|
/**
|
|
@@ -859,6 +940,11 @@ declare function memory<P = undefined>(config: MemoryConfig<P>): MemoryServed<P>
|
|
|
859
940
|
declare const RemoteServer: {
|
|
860
941
|
/** A backend held in memory, for a first run, a test or a demo. See `memory`. */
|
|
861
942
|
memory: typeof memory;
|
|
943
|
+
/**
|
|
944
|
+
* A declared write landed over a memory backend's rows (`MemoryStore`), as
|
|
945
|
+
* `foldkit-remote-drizzle`'s writer lands it over a table. See `memoryWriter`.
|
|
946
|
+
*/
|
|
947
|
+
memoryWriter: typeof memoryWriter;
|
|
862
948
|
/** A mutation outcome's report that `ref` now heads the connection. */
|
|
863
949
|
prepend: (connection: ConnectionIdentity, ref: {
|
|
864
950
|
readonly entity: string;
|
|
@@ -904,6 +990,22 @@ declare const RemoteServer: {
|
|
|
904
990
|
* person reads, beside it.
|
|
905
991
|
*/
|
|
906
992
|
refuse: <Refused>(mutation: MutationDescriptor<string, any, any, Refused>, refusal: NoInfer<Refused>, message?: string) => MutationRefused;
|
|
993
|
+
/**
|
|
994
|
+
* A failure whose `message` the caller reads as it is: fail a Source with it
|
|
995
|
+
* (`yield* RemoteServer.tell('That report is still being built')`) for words
|
|
996
|
+
* written for whoever asked. Every other `RemoteServerError` is this side's:
|
|
997
|
+
* reported, and answered "Internal error". It takes text, not what was
|
|
998
|
+
* caught: an error's own message may say anything.
|
|
999
|
+
*/
|
|
1000
|
+
tell: typeof tell;
|
|
1001
|
+
/**
|
|
1002
|
+
* Reports a failure on this side that no handler answers, as the server
|
|
1003
|
+
* reports its own: a scheduled job's, or an adapter's on a transport of its
|
|
1004
|
+
* own. `cause` goes to a `ServerDefect` under a new incident, with `during`
|
|
1005
|
+
* (what was being done: `publish due e3`). It answers what a caller may be
|
|
1006
|
+
* told of it, the fixed words and that id, and nothing of `cause`.
|
|
1007
|
+
*/
|
|
1008
|
+
report: (during: string, cause: unknown) => Effect.Effect<InternalFailure>;
|
|
907
1009
|
/**
|
|
908
1010
|
* A writer's refusal of a row that does not hold the write's `when`: fail
|
|
909
1011
|
* `update` or `delete` with it (`yield* RemoteServer.unmet()`), and
|
|
@@ -951,7 +1053,10 @@ declare const RemoteServer: {
|
|
|
951
1053
|
* a row already gone succeeds. A row that moved past the revision the write
|
|
952
1054
|
* `expect`s is refused as a conflict, and one that does not hold its `when`
|
|
953
1055
|
* as unmet; a write with a `when` needs a writer that checks it
|
|
954
|
-
* (`preconditions`), and is refused here without one.
|
|
1056
|
+
* (`preconditions`), and is refused here without one. A row the write
|
|
1057
|
+
* would leave outside its postcondition (`ensures`) is refused as
|
|
1058
|
+
* invalid, as one breaking an invariant is; a write with one needs a
|
|
1059
|
+
* writer that judges it (`postconditions`).
|
|
955
1060
|
*/
|
|
956
1061
|
write: <P = unknown, R = never, Name extends string = string, Input = unknown>(mutation: MutationDescriptor<Name, Input, {}, any> & {
|
|
957
1062
|
readonly write: AnyWrite;
|
|
@@ -1049,8 +1154,9 @@ declare const RemoteServer: {
|
|
|
1049
1154
|
* could not be told a 401; a refusal of who is asking a 403; a write made
|
|
1050
1155
|
* for someone else (`RemotePrincipalChanged`) a 409; a mutation's
|
|
1051
1156
|
* declared refusal a 422, or a 409 when it is `Refusal.taken`; a handler's
|
|
1052
|
-
* failure a 500 with its message
|
|
1053
|
-
*
|
|
1157
|
+
* failure a 500 with its message, and the `incident` it carries; a defect
|
|
1158
|
+
* a 500 that says nothing of it but the `incident` its cause was reported
|
|
1159
|
+
* under, as a `ServerDefect` (`Diagnostics`, by default the log).
|
|
1054
1160
|
* `Remote.json` and `Remote.http` are the other end.
|
|
1055
1161
|
*/
|
|
1056
1162
|
answer: <R>(handlers: RemoteRpcClient<R>, body: unknown) => Effect.Effect<{
|
|
@@ -1066,5 +1172,5 @@ declare const RemoteServer: {
|
|
|
1066
1172
|
*/
|
|
1067
1173
|
handlers: <P, R, I = never>(server: ServerDefinition<P, R>, principal: P | Context.Key<I, P>, options?: HandlerOptions<P, R>) => RemoteRpcClient<R | I>;
|
|
1068
1174
|
};
|
|
1069
|
-
export { RemoteUnmet as A,
|
|
1070
|
-
//# sourceMappingURL=index-
|
|
1175
|
+
export { RemoteUnmet as A, evaluate$1 as B, QueryPage as C, RemoteServer as D, RemoteInvalid as E, exprContext as F, ClockSkewed as G, MemoryWriterOptions as H, bodyLimit as I, RemoteServerDiagnostic as J, InternalFailure as K, QueryEvaluateError as L, ServerDefinition as M, WriteRequirement as N, RemoteServerError as O, WriteWhen as P, Row as R, MutationSource as S, ReadPlan as T, AnswerUnread as U, supported$1 as V, CachedReadDiffers as W, ServerDefect as Y, MemoryRows as _, EntityRecord as a, MutationOutcome as b, EntityWriter as c, LiveQuery as d, LiveSource as f, MemoryReadable as g, MemoryConfig as h, DeleteOutcome as i, RowRequirement as j, RemoteTaken as k, HandlerOptions as l, MemoryBackend as m, CascadedRow as n, EntitySource as o, MemoryAnswering as p, PublishFailed as q, ConnectionChange as r, EntitySourceContext as s, CascadeRequirement as t, LiveHub as u, MemoryServed as v, QuerySource as w, MutationRefused as x, MemoryStore as y, assertSupported$1 as z };
|
|
1176
|
+
//# sourceMappingURL=index-Dq3fHdhH.d.mts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"index-Dq3fHdhH.d.mts","names":[],"sources":["../src/diagnostics.ts","../src/memoryWriter.ts","../src/body.ts","../src/index.ts"],"mappings":"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"}
|
package/dist/index.d.mts
CHANGED
|
@@ -1,2 +1,2 @@
|
|
|
1
|
-
import { A as RemoteUnmet, B as
|
|
2
|
-
export { type AnswerUnread, type CachedReadDiffers, CascadeRequirement, CascadedRow, type ClockSkewed, ConnectionChange, DeleteOutcome, EntityRecord, EntitySource, EntitySourceContext, EntityWriter, HandlerOptions, LiveHub, LiveQuery, LiveSource, MemoryAnswering, MemoryBackend, MemoryConfig, MemoryReadable, MemoryRows, MemoryServed, MemoryStore, MutationOutcome, MutationRefused, MutationSource, type PublishFailed, QueryEvaluateError, QueryPage, QuerySource, ReadPlan, RemoteInvalid, RemoteServer, type RemoteServerDiagnostic, RemoteServerError, RemoteTaken, RemoteUnmet, type Row, RowRequirement, type ServerDefect, ServerDefinition, WriteRequirement, WriteWhen, assertSupported, bodyLimit, evaluate, exprContext, supported };
|
|
1
|
+
import { A as RemoteUnmet, B as evaluate, C as QueryPage, D as RemoteServer, E as RemoteInvalid, F as exprContext, G as ClockSkewed, H as MemoryWriterOptions, I as bodyLimit, J as RemoteServerDiagnostic, K as InternalFailure, L as QueryEvaluateError, M as ServerDefinition, N as WriteRequirement, O as RemoteServerError, P as WriteWhen, R as Row, S as MutationSource, T as ReadPlan, U as AnswerUnread, V as supported, W as CachedReadDiffers, Y as ServerDefect, _ as MemoryRows, a as EntityRecord, b as MutationOutcome, c as EntityWriter, d as LiveQuery, f as LiveSource, g as MemoryReadable, h as MemoryConfig, i as DeleteOutcome, j as RowRequirement, k as RemoteTaken, l as HandlerOptions, m as MemoryBackend, n as CascadedRow, o as EntitySource, p as MemoryAnswering, q as PublishFailed, r as ConnectionChange, s as EntitySourceContext, t as CascadeRequirement, u as LiveHub, v as MemoryServed, w as QuerySource, x as MutationRefused, y as MemoryStore, z as assertSupported } from "./index-Dq3fHdhH.mjs";
|
|
2
|
+
export { type AnswerUnread, type CachedReadDiffers, CascadeRequirement, CascadedRow, type ClockSkewed, ConnectionChange, DeleteOutcome, EntityRecord, EntitySource, EntitySourceContext, EntityWriter, HandlerOptions, type InternalFailure, LiveHub, LiveQuery, LiveSource, MemoryAnswering, MemoryBackend, MemoryConfig, MemoryReadable, MemoryRows, MemoryServed, MemoryStore, type MemoryWriterOptions, MutationOutcome, MutationRefused, MutationSource, type PublishFailed, QueryEvaluateError, QueryPage, QuerySource, ReadPlan, RemoteInvalid, RemoteServer, type RemoteServerDiagnostic, RemoteServerError, RemoteTaken, RemoteUnmet, type Row, RowRequirement, type ServerDefect, ServerDefinition, WriteRequirement, WriteWhen, assertSupported, bodyLimit, evaluate, exprContext, supported };
|
package/dist/index.mjs
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
export { t as DeleteOutcome, n as MutationRefused, h as QueryEvaluateError, r as RemoteInvalid, i as RemoteServer, a as RemoteServerError, o as RemoteTaken, s as RemoteUnmet, c as RowRequirement, g as assertSupported, u as bodyLimit, _ as evaluate, l as exprContext, v as supported } from "./src-
|
|
1
|
+
export { t as DeleteOutcome, n as MutationRefused, h as QueryEvaluateError, r as RemoteInvalid, i as RemoteServer, a as RemoteServerError, o as RemoteTaken, s as RemoteUnmet, c as RowRequirement, g as assertSupported, u as bodyLimit, _ as evaluate, l as exprContext, v as supported } from "./src-6l1A9ww5.mjs";
|