@rojaebl/supa-store 0.0.0-stage → 0.7.2
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/LICENSE +21 -0
- package/README.md +707 -3
- package/dist/derived.d.ts +9 -0
- package/dist/derived.js +103 -0
- package/dist/index.d.ts +123 -0
- package/dist/index.js +271 -0
- package/dist/label.d.ts +5 -0
- package/dist/label.js +38 -0
- package/dist/mutation.d.ts +46 -0
- package/dist/mutation.js +131 -0
- package/dist/query.d.ts +184 -0
- package/dist/query.js +301 -0
- package/dist/react.d.ts +29 -0
- package/dist/react.js +36 -0
- package/dist/refetch.d.ts +25 -0
- package/dist/refetch.js +117 -0
- package/dist/resourceHook.d.ts +57 -0
- package/dist/resourceHook.js +292 -0
- package/dist/rpc/client.d.ts +65 -0
- package/dist/rpc/client.js +226 -0
- package/dist/rpc/error.d.ts +7 -0
- package/dist/rpc/error.js +13 -0
- package/dist/rpc/framing.d.ts +4 -0
- package/dist/rpc/framing.js +64 -0
- package/dist/rpc/index.d.ts +4 -0
- package/dist/rpc/index.js +4 -0
- package/dist/rpc/session.d.ts +18 -0
- package/dist/rpc/session.js +120 -0
- package/dist/rpc/transport.d.ts +26 -0
- package/dist/rpc/transport.js +122 -0
- package/dist/server/core.d.ts +72 -0
- package/dist/server/core.js +367 -0
- package/dist/server/index.d.ts +2 -0
- package/dist/server/index.js +2 -0
- package/dist/server/node.d.ts +12 -0
- package/dist/server/node.js +240 -0
- package/dist/server/sse.d.ts +10 -0
- package/dist/server/sse.js +25 -0
- package/dist/server/web.d.ts +8 -0
- package/dist/server/web.js +147 -0
- package/dist/stream/client.d.ts +43 -0
- package/dist/stream/client.js +397 -0
- package/dist/stream/hook.d.ts +9 -0
- package/dist/stream/hook.js +70 -0
- package/dist/stream/index.d.ts +53 -0
- package/dist/stream/index.js +43 -0
- package/dist/stream/protocol.d.ts +105 -0
- package/dist/stream/protocol.js +32 -0
- package/dist/track.d.ts +19 -0
- package/dist/track.js +25 -0
- package/package.json +104 -3
- package/tools/decline-loader.cjs +8 -0
- package/tools/definition.cjs +14 -0
- package/tools/next.d.mts +2 -0
- package/tools/next.mjs +30 -0
- package/tools/vite.d.mts +3 -0
- package/tools/vite.mjs +43 -0
|
@@ -0,0 +1,72 @@
|
|
|
1
|
+
import { type ClientMessage, type ServerMessage } from "../stream/protocol.js";
|
|
2
|
+
/** 홉이 연결에 대해 아는 것 전부 — 전송의 겉이 이 꼴로 맞춘다
|
|
3
|
+
* - headers: 연결을 연 요청의 헤더, 이름은 소문자. SSE 는 이것이 곧 hello 다(Authorization · X-Supa-Channel · X-Supa-Epoch ·
|
|
4
|
+
* Last-Event-ID) — 그래서 SSE 는 onMessage 를 부르지 않아도 되고, 홉은 attach 하자마자 인증한다
|
|
5
|
+
* - close: 웹소켓은 닫기 코드로, SSE 는 close 메시지를 쓰고 응답을 끝낸다. SSE 에서 첫 send 전에 close 가 오면
|
|
6
|
+
* 아직 응답 머리를 쓰지 않았으므로 HTTP 상태로 답한다 — 4001 → 401, 그 밖의 코드 → 503. 홉은 무엇을 보냈는지 모르므로
|
|
7
|
+
* 이 판정은 전송의 겉(node · web)이 한다
|
|
8
|
+
* - onClose: 상대가 끊었을 때, 그리고 close 를 부른 뒤에 — 여러 번 불려도 된다
|
|
9
|
+
* - buffered: 아직 나가지 못한 바이트 수 — 홉이 보내기 직전에 maxBuffered 와 견준다.
|
|
10
|
+
* 모르면 비워 둔다 — 그러면 한도를 재지 않는다 */
|
|
11
|
+
export interface Conn {
|
|
12
|
+
send(m: ServerMessage): void;
|
|
13
|
+
close(code: number, reason: string): void;
|
|
14
|
+
onMessage(fn: (m: ClientMessage) => void): void;
|
|
15
|
+
onClose(fn: () => void): void;
|
|
16
|
+
buffered?(): number;
|
|
17
|
+
kind: "ws" | "sse";
|
|
18
|
+
headers: Record<string, string | undefined>;
|
|
19
|
+
}
|
|
20
|
+
export interface AuthCtx {
|
|
21
|
+
/** 웹소켓은 hello.auth, SSE · POST 는 Authorization 헤더(Bearer 를 뗀 것) */
|
|
22
|
+
token: string | undefined;
|
|
23
|
+
/** 클라이언트가 청한 채널 — 웹소켓은 hello.channel, SSE · POST 는 X-Supa-Channel */
|
|
24
|
+
channel: string | undefined;
|
|
25
|
+
headers: Record<string, string | undefined>;
|
|
26
|
+
/** 거절한다 — 연결은 4001 로, POST 는 401 로 닫힌다 */
|
|
27
|
+
reject(reason: string): never;
|
|
28
|
+
}
|
|
29
|
+
export interface ConnCtx<Id> {
|
|
30
|
+
identity: Id;
|
|
31
|
+
channel: string;
|
|
32
|
+
token: string | undefined;
|
|
33
|
+
/** welcome.connection */
|
|
34
|
+
connection: string;
|
|
35
|
+
/** 클라이언트의 handlers 에 묻는다(§7.6) — 30초 안에 답이 없으면 응답 지연, 끊기면 명령 실패로 거절한다 */
|
|
36
|
+
request(method: string, params?: unknown[]): Promise<unknown>;
|
|
37
|
+
}
|
|
38
|
+
export interface StreamServerOptions<V, C, Id> {
|
|
39
|
+
authorize?: (ctx: AuthCtx) => Id | Promise<Id>;
|
|
40
|
+
/** 기본은 클라이언트가 청한 채널, 없으면 "default" */
|
|
41
|
+
channel?: (ctx: AuthCtx & {
|
|
42
|
+
identity: Id;
|
|
43
|
+
}) => string;
|
|
44
|
+
/** 동기 — 부르는 순간의 채널 버전이 그 값의 버전이다 */
|
|
45
|
+
snapshot: (ctx: ConnCtx<Id>) => V;
|
|
46
|
+
commands?: Record<string, (ctx: ConnCtx<Id>, ...args: any[]) => unknown>;
|
|
47
|
+
history?: {
|
|
48
|
+
count?: number;
|
|
49
|
+
ms?: number;
|
|
50
|
+
};
|
|
51
|
+
/** 연결 하나에 쌓인 바이트가 이것을 넘으면 다음 보낼 때 4000 으로 닫는다. 기본 4 MiB, Infinity 면 재지 않는다 */
|
|
52
|
+
maxBuffered?: number;
|
|
53
|
+
}
|
|
54
|
+
/** SSE 의 POST — body 는 받은 글자 그대로(JSON 읽기도 홉이 한다) */
|
|
55
|
+
export interface PostReq {
|
|
56
|
+
headers: Record<string, string | undefined>;
|
|
57
|
+
body: string;
|
|
58
|
+
}
|
|
59
|
+
/** command 면 reply, ask 면 fate 의 배열, answer 면 204 */
|
|
60
|
+
export interface PostRes {
|
|
61
|
+
status: number;
|
|
62
|
+
body: unknown;
|
|
63
|
+
}
|
|
64
|
+
export interface StreamServer<V, C = V, Id = unknown> {
|
|
65
|
+
publish(channel: string, change: C): void;
|
|
66
|
+
attach(conn: Conn): void;
|
|
67
|
+
handlePost(req: PostReq): Promise<PostRes>;
|
|
68
|
+
close(): void;
|
|
69
|
+
}
|
|
70
|
+
/** 시험 전용 — 홉이 쥔 채널 이름을 꺼낸다. 하위 경로로 내보내지 않는다 */
|
|
71
|
+
export declare const INSPECT: unique symbol;
|
|
72
|
+
export declare function createStreamServer<V, C = V, Id = unknown>(o: StreamServerOptions<V, C, Id>): StreamServer<V, C, Id>;
|
|
@@ -0,0 +1,367 @@
|
|
|
1
|
+
// 서버의 홉 — 채널 · epoch · 버전 · 기록 · 답 기록 · ask · heartbeat · authorize · snapshot · 서버의 request(스펙 §7 · §9)
|
|
2
|
+
// 전송을 모른다. 웹소켓 · SSE 의 겉이 연결 하나를 Conn 으로 맞춰 attach 로 넘기고, SSE 의 POST 는 handlePost 로 넘긴다
|
|
3
|
+
import { CLOSE, DEFAULTS, HEADER, TEXT } from "../stream/protocol.js";
|
|
4
|
+
import { helloFromHeaders, tokenOf } from "./sse.js";
|
|
5
|
+
class Rejection extends Error {
|
|
6
|
+
}
|
|
7
|
+
/** 시험 전용 — 홉이 쥔 채널 이름을 꺼낸다. 하위 경로로 내보내지 않는다 */
|
|
8
|
+
export const INSPECT = Symbol("supa-store.inspect");
|
|
9
|
+
const messageOf = (e) => (e instanceof Error ? e.message : String(e));
|
|
10
|
+
// ponytail: 신원은 JSON 글자로 가른다 — 키 순서가 다른 객체는 다른 신원, JSON 으로 쓸 수 없는 신원(순환)은 던진다
|
|
11
|
+
const identityKey = (v) => JSON.stringify(v) ?? "undefined";
|
|
12
|
+
const keyOf = (who, id) => `${who}\n${id}`;
|
|
13
|
+
const isStr = (v) => v === undefined || typeof v === "string";
|
|
14
|
+
/** 보내기 전에 JSON 으로 써 본다 — BigInt · 순환 같은 값 하나가 전송의 겉에서 던져 프로세스를 죽이지 않게. 쓸 수 있으면 undefined
|
|
15
|
+
* ponytail: 보낼 때 한 번 더 쓰므로 두 번 직렬화한다. 큰 값이 잦아지면 쓴 글자를 Conn 으로 넘긴다 */
|
|
16
|
+
const unwritable = (what, v) => {
|
|
17
|
+
try {
|
|
18
|
+
JSON.stringify(v);
|
|
19
|
+
return undefined;
|
|
20
|
+
}
|
|
21
|
+
catch (e) {
|
|
22
|
+
return `${what} JSON 으로 쓸 수 없다: ${messageOf(e)}`;
|
|
23
|
+
}
|
|
24
|
+
};
|
|
25
|
+
/** 밖에서 온 메시지의 꼴을 본다 — 홉이 그 칸을 믿고 쓰기 전에 */
|
|
26
|
+
function valid(m) {
|
|
27
|
+
if (typeof m !== "object" || m === null)
|
|
28
|
+
return false;
|
|
29
|
+
const x = m;
|
|
30
|
+
switch (x.t) {
|
|
31
|
+
case "command":
|
|
32
|
+
return typeof x.id === "string" && typeof x.name === "string" && Array.isArray(x.args);
|
|
33
|
+
case "ask":
|
|
34
|
+
return Array.isArray(x.ids) && x.ids.every((id) => typeof id === "string");
|
|
35
|
+
case "answer":
|
|
36
|
+
return typeof x.id === "string" && typeof x.ok === "boolean" && (x.ok || typeof x.error === "string");
|
|
37
|
+
case "hello":
|
|
38
|
+
return (isStr(x.channel) &&
|
|
39
|
+
isStr(x.epoch) &&
|
|
40
|
+
isStr(x.auth) &&
|
|
41
|
+
(x.version === undefined || (Number.isInteger(x.version) && x.version >= 0)));
|
|
42
|
+
case "pong":
|
|
43
|
+
return true;
|
|
44
|
+
default:
|
|
45
|
+
return false;
|
|
46
|
+
}
|
|
47
|
+
}
|
|
48
|
+
export function createStreamServer(o) {
|
|
49
|
+
/** 홉이 뜰 때마다 새로 — 다시 뜬 홉의 버전을 앞 홉의 것과 섞지 않는다 */
|
|
50
|
+
const epoch = crypto.randomUUID();
|
|
51
|
+
const count = o.history?.count ?? DEFAULTS.historyCount;
|
|
52
|
+
const ms = o.history?.ms ?? DEFAULTS.historyMs;
|
|
53
|
+
const maxBuffered = o.maxBuffered ?? 4 * 1024 * 1024;
|
|
54
|
+
const channels = new Map();
|
|
55
|
+
/** connection id → 붙은 연결(hello 전 것까지) */
|
|
56
|
+
const sessions = new Map();
|
|
57
|
+
/** close() 뒤 — 새 연결은 4000 으로 닫고 publish 는 하지 않는다 */
|
|
58
|
+
let down = false;
|
|
59
|
+
const chan = (name) => {
|
|
60
|
+
let ch = channels.get(name);
|
|
61
|
+
if (ch)
|
|
62
|
+
return ch;
|
|
63
|
+
// 새 채널을 지을 때마다 연결 없는 버전 0 채널을 훑는다 — 답 기록이 다 지나간 것은 지운다
|
|
64
|
+
// ponytail: 짓기마다 O(채널 수). 채널이 아주 많아지면 타이머로 한 번씩 훑는다
|
|
65
|
+
for (const c of channels.values())
|
|
66
|
+
if (c.version === 0 && c.sessions.size === 0) {
|
|
67
|
+
trim(c);
|
|
68
|
+
forget(c);
|
|
69
|
+
}
|
|
70
|
+
channels.set(name, (ch = { name, version: 0, history: [], replies: new Map(), sessions: new Set() }));
|
|
71
|
+
return ch;
|
|
72
|
+
};
|
|
73
|
+
/** 클라이언트가 지은 이름의 빈 채널이 쌓이지 않게 — 버전이 오른 채널은 기록이 버전을 지키므로 남긴다 */
|
|
74
|
+
const forget = (ch) => {
|
|
75
|
+
if (ch.version === 0 && ch.sessions.size === 0 && ch.replies.size === 0)
|
|
76
|
+
channels.delete(ch.name);
|
|
77
|
+
};
|
|
78
|
+
/** 기록 · 답 기록을 count 개 또는 ms 가운데 짧은 쪽까지 앞에서 자른다. 도는 중인 명령은 남긴다 */
|
|
79
|
+
const trim = (ch) => {
|
|
80
|
+
const old = Date.now() - ms;
|
|
81
|
+
const h = ch.history;
|
|
82
|
+
while (h.length > count || (h[0] && h[0].at < old))
|
|
83
|
+
h.shift();
|
|
84
|
+
for (const [id, r] of ch.replies) {
|
|
85
|
+
if (ch.replies.size <= count && r.at >= old)
|
|
86
|
+
break;
|
|
87
|
+
if (r.reply)
|
|
88
|
+
ch.replies.delete(id);
|
|
89
|
+
}
|
|
90
|
+
};
|
|
91
|
+
const drop = (s) => {
|
|
92
|
+
if (s.closed)
|
|
93
|
+
return;
|
|
94
|
+
s.closed = true;
|
|
95
|
+
clearTimeout(s.helloTimer);
|
|
96
|
+
clearInterval(s.ping);
|
|
97
|
+
sessions.delete(s.id);
|
|
98
|
+
const ch = s.live?.channel;
|
|
99
|
+
if (ch) {
|
|
100
|
+
ch.sessions.delete(s);
|
|
101
|
+
forget(ch);
|
|
102
|
+
}
|
|
103
|
+
for (const r of s.requests.values()) {
|
|
104
|
+
clearTimeout(r.timer);
|
|
105
|
+
r.reject(new Error(TEXT.commandFailed));
|
|
106
|
+
}
|
|
107
|
+
s.requests.clear();
|
|
108
|
+
};
|
|
109
|
+
const shut = (s, code, reason) => {
|
|
110
|
+
if (s.closed)
|
|
111
|
+
return;
|
|
112
|
+
s.conn.close(code, reason);
|
|
113
|
+
drop(s);
|
|
114
|
+
};
|
|
115
|
+
/** 연결에 보내는 자리는 여기 하나 — 이미 쌓인 양이 한도를 넘었으면 보내지 않고 닫는다. 보냈으면 true */
|
|
116
|
+
const send = (s, m) => {
|
|
117
|
+
if (s.closed)
|
|
118
|
+
return false;
|
|
119
|
+
if ((s.conn.buffered?.() ?? 0) > maxBuffered) {
|
|
120
|
+
shut(s, CLOSE.COME_BACK, "버퍼가 넘쳤다");
|
|
121
|
+
return false;
|
|
122
|
+
}
|
|
123
|
+
s.conn.send(m);
|
|
124
|
+
return true;
|
|
125
|
+
};
|
|
126
|
+
const authCtx = (token, channel, headers) => ({
|
|
127
|
+
token,
|
|
128
|
+
channel,
|
|
129
|
+
headers,
|
|
130
|
+
reject: (reason) => {
|
|
131
|
+
throw new Rejection(reason);
|
|
132
|
+
},
|
|
133
|
+
});
|
|
134
|
+
/** 신원과 채널을 정한다 — 거절이면 Rejection 을 던진다 */
|
|
135
|
+
const identify = async (a) => {
|
|
136
|
+
const identity = (await o.authorize?.(a));
|
|
137
|
+
const channel = o.channel ? o.channel({ ...a, identity }) : (a.channel ?? "default");
|
|
138
|
+
return { identity, channel, key: identityKey(identity) };
|
|
139
|
+
};
|
|
140
|
+
const request = (s, method, params = []) => {
|
|
141
|
+
if (s.closed)
|
|
142
|
+
return Promise.reject(new Error(TEXT.commandFailed));
|
|
143
|
+
const id = crypto.randomUUID();
|
|
144
|
+
return new Promise((resolve, reject) => {
|
|
145
|
+
const timer = setTimeout(() => {
|
|
146
|
+
s.requests.delete(id);
|
|
147
|
+
reject(new Error(TEXT.timeout));
|
|
148
|
+
}, DEFAULTS.timeoutMs);
|
|
149
|
+
s.requests.set(id, { resolve, reject, timer });
|
|
150
|
+
send(s, { t: "request", id, method, params });
|
|
151
|
+
});
|
|
152
|
+
};
|
|
153
|
+
/** hello(SSE 는 헤더)를 받아 인증하고 welcome 뒤 따라잡기 — 따라잡을 기록이 없으면 snapshot */
|
|
154
|
+
const welcome = async (s, hello) => {
|
|
155
|
+
let who;
|
|
156
|
+
try {
|
|
157
|
+
who = await identify(authCtx(hello.auth, hello.channel, s.conn.headers));
|
|
158
|
+
}
|
|
159
|
+
catch (e) {
|
|
160
|
+
return shut(s, e instanceof Rejection ? CLOSE.GO_AWAY : CLOSE.COME_BACK, messageOf(e));
|
|
161
|
+
}
|
|
162
|
+
if (s.closed)
|
|
163
|
+
return;
|
|
164
|
+
const ch = chan(who.channel);
|
|
165
|
+
const ctx = {
|
|
166
|
+
identity: who.identity,
|
|
167
|
+
channel: who.channel,
|
|
168
|
+
token: hello.auth,
|
|
169
|
+
connection: s.id,
|
|
170
|
+
request: (method, params) => request(s, method, params),
|
|
171
|
+
};
|
|
172
|
+
s.live = { channel: ch, who: who.key, ctx };
|
|
173
|
+
ch.sessions.add(s);
|
|
174
|
+
trim(ch);
|
|
175
|
+
if (!send(s, { t: "welcome", epoch, version: ch.version, connection: s.id }))
|
|
176
|
+
return;
|
|
177
|
+
// 같은 epoch 이고 그 뒤 첫 바뀜이 기록에 남아 있으면 빠진 것만
|
|
178
|
+
const from = hello.epoch === epoch ? hello.version : undefined;
|
|
179
|
+
const first = ch.history[0]?.version ?? ch.version + 1;
|
|
180
|
+
if (from !== undefined && from <= ch.version && from + 1 >= first) {
|
|
181
|
+
for (const h of ch.history)
|
|
182
|
+
if (h.version > from && !send(s, { t: "change", version: h.version, change: h.change }))
|
|
183
|
+
return;
|
|
184
|
+
}
|
|
185
|
+
else {
|
|
186
|
+
let value;
|
|
187
|
+
try {
|
|
188
|
+
value = o.snapshot(ctx);
|
|
189
|
+
const bad = unwritable("snapshot 을", value);
|
|
190
|
+
if (bad)
|
|
191
|
+
throw new Error(bad);
|
|
192
|
+
}
|
|
193
|
+
catch (e) {
|
|
194
|
+
// 그 연결만 닫는다 — 홉과 다른 연결은 산다
|
|
195
|
+
return shut(s, CLOSE.COME_BACK, `snapshot 실패: ${messageOf(e)}`);
|
|
196
|
+
}
|
|
197
|
+
if (!send(s, { t: "snapshot", version: ch.version, value }))
|
|
198
|
+
return;
|
|
199
|
+
}
|
|
200
|
+
s.ping = setInterval(() => {
|
|
201
|
+
// 웹소켓만 — SSE 는 받는 줄이 없어 pong 이 없다
|
|
202
|
+
if (s.conn.kind === "ws" && Date.now() - s.heard > DEFAULTS.idleMs)
|
|
203
|
+
return shut(s, CLOSE.COME_BACK, "응답이 없다");
|
|
204
|
+
send(s, { t: "ping" });
|
|
205
|
+
}, DEFAULTS.pingMs);
|
|
206
|
+
};
|
|
207
|
+
/** 명령을 돌린다 — 같은 id 가 답 기록에 있으면 돌리지 않고 그 답(또는 도는 중인 그 약속)을 준다 */
|
|
208
|
+
const run = (s, m) => {
|
|
209
|
+
const live = s.live;
|
|
210
|
+
const ch = live.channel;
|
|
211
|
+
trim(ch);
|
|
212
|
+
// 다른 신원의 같은 id 는 다른 기록이다 — 남의 답을 받지도, 남의 명령을 막지도 않는다
|
|
213
|
+
const key = keyOf(live.who, m.id);
|
|
214
|
+
const had = ch.replies.get(key);
|
|
215
|
+
if (had)
|
|
216
|
+
return had.promise;
|
|
217
|
+
// 원형의 이름(toString 등)은 명령이 아니다. 없는 명령은 답 기록에 남기지 않는다 — 아무 이름으로 기록을 쌓지 못하게
|
|
218
|
+
if (!o.commands || !Object.hasOwn(o.commands, m.name))
|
|
219
|
+
return Promise.resolve({ t: "reply", id: m.id, ok: false, error: `알 수 없는 명령: ${m.name}`, version: ch.version });
|
|
220
|
+
const ran = { at: Date.now() };
|
|
221
|
+
ran.promise = (async () => {
|
|
222
|
+
let out;
|
|
223
|
+
try {
|
|
224
|
+
const result = await o.commands[m.name](live.ctx, ...m.args);
|
|
225
|
+
const bad = unwritable("명령의 결과를", result);
|
|
226
|
+
out = bad ? { ok: false, error: bad } : { ok: true, result };
|
|
227
|
+
}
|
|
228
|
+
catch (e) {
|
|
229
|
+
out = { ok: false, error: messageOf(e) };
|
|
230
|
+
}
|
|
231
|
+
// 쥐는 기간은 답을 낸 때부터 — 오래 돈 명령이 끝나자마자 잘려 다시 돌지 않게
|
|
232
|
+
// 뒤로 옮겨 trim 이 앞에서부터 at 차례로 자르게 한다
|
|
233
|
+
ran.at = Date.now();
|
|
234
|
+
ch.replies.delete(key);
|
|
235
|
+
ch.replies.set(key, ran);
|
|
236
|
+
// 답할 때의 버전 — 명령이 낸 바뀜이 이미 들어 있다
|
|
237
|
+
return (ran.reply = { t: "reply", id: m.id, ...out, version: ch.version });
|
|
238
|
+
})();
|
|
239
|
+
ch.replies.set(key, ran);
|
|
240
|
+
return ran.promise;
|
|
241
|
+
};
|
|
242
|
+
const fate = (ch, who, id) => {
|
|
243
|
+
const r = ch.replies.get(keyOf(who, id));
|
|
244
|
+
if (!r)
|
|
245
|
+
return { t: "fate", id, state: "unknown-id" };
|
|
246
|
+
if (!r.reply)
|
|
247
|
+
return { t: "fate", id, state: "running" };
|
|
248
|
+
const { t: _, ...rest } = r.reply;
|
|
249
|
+
return { t: "fate", state: "done", ...rest };
|
|
250
|
+
};
|
|
251
|
+
const answer = (s, m) => {
|
|
252
|
+
const r = s.requests.get(m.id);
|
|
253
|
+
if (!r)
|
|
254
|
+
return; // 늦게 온 답은 버린다
|
|
255
|
+
s.requests.delete(m.id);
|
|
256
|
+
clearTimeout(r.timer);
|
|
257
|
+
if (m.ok)
|
|
258
|
+
r.resolve(m.result);
|
|
259
|
+
else
|
|
260
|
+
r.reject(new Error(m.error));
|
|
261
|
+
};
|
|
262
|
+
/** command · ask · answer — 웹소켓의 메시지와 SSE 의 POST 가 함께 쓴다 */
|
|
263
|
+
const dispatch = async (s, m) => {
|
|
264
|
+
if (m.t === "command")
|
|
265
|
+
return run(s, m);
|
|
266
|
+
if (m.t === "ask") {
|
|
267
|
+
const { channel, who } = s.live;
|
|
268
|
+
trim(channel);
|
|
269
|
+
return m.ids.map((id) => fate(channel, who, id));
|
|
270
|
+
}
|
|
271
|
+
answer(s, m);
|
|
272
|
+
return null;
|
|
273
|
+
};
|
|
274
|
+
const hop = {
|
|
275
|
+
publish(name, change) {
|
|
276
|
+
if (down)
|
|
277
|
+
return;
|
|
278
|
+
// 버전을 올리기 전에 본다 — 쓸 수 없는 바뀜이 기록에 남아 따라잡기마다 다시 터지지 않게 부른 쪽에 던진다
|
|
279
|
+
const bad = unwritable("바뀜을", change);
|
|
280
|
+
if (bad)
|
|
281
|
+
throw new TypeError(bad);
|
|
282
|
+
const ch = chan(name);
|
|
283
|
+
const version = ++ch.version;
|
|
284
|
+
ch.history.push({ version, change, at: Date.now() });
|
|
285
|
+
trim(ch);
|
|
286
|
+
for (const s of ch.sessions)
|
|
287
|
+
send(s, { t: "change", version, change });
|
|
288
|
+
},
|
|
289
|
+
attach(conn) {
|
|
290
|
+
if (down)
|
|
291
|
+
return conn.close(CLOSE.COME_BACK, "서버가 내려갔다");
|
|
292
|
+
const s = { id: crypto.randomUUID(), conn, closed: false, heard: Date.now(), requests: new Map() };
|
|
293
|
+
sessions.set(s.id, s);
|
|
294
|
+
conn.onClose(() => drop(s));
|
|
295
|
+
// SSE 는 GET 요청이 곧 hello 다
|
|
296
|
+
if (conn.kind === "sse")
|
|
297
|
+
return void welcome(s, helloFromHeaders(conn.headers));
|
|
298
|
+
s.helloTimer = setTimeout(() => shut(s, CLOSE.COME_BACK, "hello 가 오지 않았다"), DEFAULTS.helloMs);
|
|
299
|
+
let greeted = false;
|
|
300
|
+
conn.onMessage((m) => {
|
|
301
|
+
s.heard = Date.now();
|
|
302
|
+
if (s.closed || !valid(m))
|
|
303
|
+
return;
|
|
304
|
+
if (!greeted && m.t === "hello") {
|
|
305
|
+
greeted = true;
|
|
306
|
+
clearTimeout(s.helloTimer);
|
|
307
|
+
return void welcome(s, m);
|
|
308
|
+
}
|
|
309
|
+
if (m.t === "hello" || m.t === "pong")
|
|
310
|
+
return;
|
|
311
|
+
// welcome 전의 command · ask 는 처리하지 않고 실패로 답한다 — 클라이언트가 영영 기다리지 않게
|
|
312
|
+
if (!s.live) {
|
|
313
|
+
if (m.t === "answer")
|
|
314
|
+
return;
|
|
315
|
+
for (const id of m.t === "command" ? [m.id] : m.ids)
|
|
316
|
+
send(s, { t: "reply", id, ok: false, error: TEXT.commandFailed, version: 0 });
|
|
317
|
+
return;
|
|
318
|
+
}
|
|
319
|
+
void dispatch(s, m).then((out) => {
|
|
320
|
+
if (s.closed || !out)
|
|
321
|
+
return;
|
|
322
|
+
for (const x of Array.isArray(out) ? out : [out])
|
|
323
|
+
if (!send(s, x))
|
|
324
|
+
return;
|
|
325
|
+
});
|
|
326
|
+
});
|
|
327
|
+
},
|
|
328
|
+
async handlePost(req) {
|
|
329
|
+
let m;
|
|
330
|
+
try {
|
|
331
|
+
m = JSON.parse(req.body);
|
|
332
|
+
}
|
|
333
|
+
catch {
|
|
334
|
+
return { status: 400, body: "JSON 이 아니다" };
|
|
335
|
+
}
|
|
336
|
+
if (!valid(m) || m.t === "hello" || m.t === "pong")
|
|
337
|
+
return { status: 400, body: "command · ask · answer 가 아니다" };
|
|
338
|
+
const s = sessions.get(req.headers[HEADER.connection] ?? "");
|
|
339
|
+
if (!s?.live)
|
|
340
|
+
return { status: 404, body: "그 연결이 없다" };
|
|
341
|
+
// POST 마다 다시 인증하고, 신원과 채널이 그 연결의 것과 같은지 본다
|
|
342
|
+
let who;
|
|
343
|
+
try {
|
|
344
|
+
// 신원을 JSON 으로 쓸 수 없으면 identify 가 던진다 → 500
|
|
345
|
+
who = await identify(authCtx(tokenOf(req.headers), req.headers[HEADER.channel] || undefined, req.headers));
|
|
346
|
+
}
|
|
347
|
+
catch (e) {
|
|
348
|
+
return e instanceof Rejection ? { status: 401, body: e.message } : { status: 500, body: messageOf(e) };
|
|
349
|
+
}
|
|
350
|
+
if (s.closed)
|
|
351
|
+
return { status: 404, body: "그 연결이 없다" };
|
|
352
|
+
const live = s.live;
|
|
353
|
+
if (who.key !== live.who || who.channel !== live.ctx.channel)
|
|
354
|
+
return { status: 403, body: "그 연결의 신원 · 채널이 아니다" };
|
|
355
|
+
const out = await dispatch(s, m);
|
|
356
|
+
return out === null ? { status: 204, body: null } : { status: 200, body: out };
|
|
357
|
+
},
|
|
358
|
+
close() {
|
|
359
|
+
down = true;
|
|
360
|
+
for (const s of [...sessions.values()])
|
|
361
|
+
shut(s, CLOSE.COME_BACK, "서버가 내려간다");
|
|
362
|
+
channels.clear();
|
|
363
|
+
},
|
|
364
|
+
};
|
|
365
|
+
// 시험만 본다 — 지금 쥔 채널의 이름
|
|
366
|
+
return Object.assign(hop, { [INSPECT]: () => [...channels.keys()] });
|
|
367
|
+
}
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
import type { Server } from "node:http";
|
|
2
|
+
import type { StreamServer } from "./core.js";
|
|
3
|
+
/** 한 Node http 서버의 한 path 에 웹소켓 · SSE · POST 를 붙인다. 돌려준 함수가 떼어 낸다
|
|
4
|
+
* - 서버 하나에 한 번만 붙는다 — 두 번째 attachStream 은 던진다. 여러 줄기가 필요하면 서버를 나누거나 한 홉에 채널로 가른다
|
|
5
|
+
* - 붙기 전의 request 리스너(Express 등)는 우리 처리기 뒤로 옮겨 그 path 밖의 요청을 받게 하고, 떼어 내면 되돌린다
|
|
6
|
+
* - origins 를 주면 Origin 헤더가 있고 목록에 없는 요청은 403 — 웹소켓은 CORS 를 따르지 않으므로 쿠키 인증이면 둔다
|
|
7
|
+
* ponytail: 한 서버 한 번. 한 서버에 path 여럿이 필요해지면 서버마다 path 표 하나를 쥐는 꼴로 넓힌다 */
|
|
8
|
+
export declare function attachStream(server: Server, o: {
|
|
9
|
+
path: string;
|
|
10
|
+
stream: StreamServer<any, any, any>;
|
|
11
|
+
origins?: string[];
|
|
12
|
+
}): () => void;
|