@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,240 @@
|
|
|
1
|
+
import { CLOSE } from "../stream/protocol.js";
|
|
2
|
+
import { sseFrame } from "./sse.js";
|
|
3
|
+
/** POST 본문의 위 끝 — 명령 하나가 이보다 크면 413
|
|
4
|
+
* ponytail: 고정 1 MiB. 큰 인자를 보내는 앱이 생기면 옵션으로 연다 */
|
|
5
|
+
const BODY_MAX = 1 << 20;
|
|
6
|
+
/** 요청의 헤더를 홉의 꼴로 — 이름은 소문자(연결의 약속 4), 여러 값은 쉼표로 잇는다 */
|
|
7
|
+
const headersOf = (req) => {
|
|
8
|
+
const out = {};
|
|
9
|
+
for (const [k, v] of Object.entries(req.headers))
|
|
10
|
+
out[k.toLowerCase()] = Array.isArray(v) ? v.join(", ") : v;
|
|
11
|
+
return out;
|
|
12
|
+
};
|
|
13
|
+
/** 웹소켓의 닫기 이유는 123 바이트까지 — 넘으면 ws 가 던지므로 글자 단위로 자른다 */
|
|
14
|
+
const fit = (reason) => {
|
|
15
|
+
const enc = new TextEncoder();
|
|
16
|
+
let r = reason;
|
|
17
|
+
while (enc.encode(r).length > 123)
|
|
18
|
+
r = r.slice(0, -1);
|
|
19
|
+
return r;
|
|
20
|
+
};
|
|
21
|
+
const DETACHED = "서버가 떼어 낸다";
|
|
22
|
+
const UNWRITABLE = "JSON 으로 쓸 수 없는 메시지";
|
|
23
|
+
/** 이미 붙은 서버 — 한 서버에 둘을 붙이면 앞 처리기를 걷고 되돌리는 일이 서로 겹치므로 막는다 */
|
|
24
|
+
const attached = new WeakSet();
|
|
25
|
+
/** 한 Node http 서버의 한 path 에 웹소켓 · SSE · POST 를 붙인다. 돌려준 함수가 떼어 낸다
|
|
26
|
+
* - 서버 하나에 한 번만 붙는다 — 두 번째 attachStream 은 던진다. 여러 줄기가 필요하면 서버를 나누거나 한 홉에 채널로 가른다
|
|
27
|
+
* - 붙기 전의 request 리스너(Express 등)는 우리 처리기 뒤로 옮겨 그 path 밖의 요청을 받게 하고, 떼어 내면 되돌린다
|
|
28
|
+
* - origins 를 주면 Origin 헤더가 있고 목록에 없는 요청은 403 — 웹소켓은 CORS 를 따르지 않으므로 쿠키 인증이면 둔다
|
|
29
|
+
* ponytail: 한 서버 한 번. 한 서버에 path 여럿이 필요해지면 서버마다 path 표 하나를 쥐는 꼴로 넓힌다 */
|
|
30
|
+
export function attachStream(server, o) {
|
|
31
|
+
if (attached.has(server))
|
|
32
|
+
throw new Error("이 서버에는 이미 attachStream 이 붙어 있다 — 서버 하나에 한 번만 붙인다");
|
|
33
|
+
attached.add(server);
|
|
34
|
+
const { path, stream, origins } = o;
|
|
35
|
+
/** Origin 이 없으면(브라우저 밖) 받는다 — 남의 사이트가 연 요청만 막는다 */
|
|
36
|
+
const foreign = (req) => !!origins && req.headers.origin !== undefined && !origins.includes(req.headers.origin);
|
|
37
|
+
/** 지금 열린 연결의 닫기 — 떼어 낼 때 모두 부른다 */
|
|
38
|
+
const open = new Set();
|
|
39
|
+
const track = (shut, onGone) => {
|
|
40
|
+
open.add(shut);
|
|
41
|
+
onGone(() => open.delete(shut));
|
|
42
|
+
};
|
|
43
|
+
let wss;
|
|
44
|
+
let detached = false;
|
|
45
|
+
const ours = (req) => new URL(req.url ?? "/", "http://x").pathname === path;
|
|
46
|
+
// 붙기 전의 요청 처리기(Express 등)를 걷어 우리 처리기 뒤로 둔다 — 그 path 밖의 요청은 그쪽이 받는다
|
|
47
|
+
// ponytail: 붙인 뒤에 더한 request 리스너는 그 path 의 요청도 함께 받는다. 그런 틀이 생기면 그때 가린다
|
|
48
|
+
const prior = server.listeners("request");
|
|
49
|
+
const fallthrough = (req, res) => {
|
|
50
|
+
if (prior.length === 0)
|
|
51
|
+
return void res.writeHead(404).end();
|
|
52
|
+
for (const fn of prior)
|
|
53
|
+
fn.call(server, req, res);
|
|
54
|
+
};
|
|
55
|
+
/** GET(Accept text/event-stream) — 요청이 곧 hello. 첫 send 에 응답 머리를 쓴다 */
|
|
56
|
+
const sse = (req, res) => {
|
|
57
|
+
let started = false;
|
|
58
|
+
const close = (code, reason) => {
|
|
59
|
+
if (res.writableEnded)
|
|
60
|
+
return;
|
|
61
|
+
// 아직 아무것도 보내지 않았으면 HTTP 상태로 — 4001 은 401, 그 밖은 503(연결의 약속 9)
|
|
62
|
+
if (!started)
|
|
63
|
+
return void res
|
|
64
|
+
.writeHead(code === CLOSE.GO_AWAY ? 401 : 503, { "content-type": "text/plain; charset=utf-8" })
|
|
65
|
+
.end(reason);
|
|
66
|
+
res.end(sseFrame({ t: "close", code, reason }));
|
|
67
|
+
};
|
|
68
|
+
const conn = {
|
|
69
|
+
kind: "sse",
|
|
70
|
+
// 응답과 그 소켓에 쌓인 바이트 — 끝난 뒤에도 던지지 않는다
|
|
71
|
+
buffered: () => res.writableLength,
|
|
72
|
+
headers: headersOf(req),
|
|
73
|
+
send(m) {
|
|
74
|
+
if (res.writableEnded)
|
|
75
|
+
return;
|
|
76
|
+
if (!started) {
|
|
77
|
+
started = true;
|
|
78
|
+
res.writeHead(200, {
|
|
79
|
+
"content-type": "text/event-stream; charset=utf-8",
|
|
80
|
+
// 프록시(nginx 등)가 쌓아 두거나 고치지 않고 곧바로 흘리게
|
|
81
|
+
"cache-control": "no-cache, no-transform",
|
|
82
|
+
"x-accel-buffering": "no",
|
|
83
|
+
connection: "keep-alive",
|
|
84
|
+
});
|
|
85
|
+
}
|
|
86
|
+
let frame;
|
|
87
|
+
try {
|
|
88
|
+
frame = sseFrame(m);
|
|
89
|
+
}
|
|
90
|
+
catch {
|
|
91
|
+
// JSON 으로 쓸 수 없는 메시지 — 던지지 않고 그 연결만 닫는다
|
|
92
|
+
return close(CLOSE.COME_BACK, UNWRITABLE);
|
|
93
|
+
}
|
|
94
|
+
res.write(frame);
|
|
95
|
+
},
|
|
96
|
+
close,
|
|
97
|
+
onMessage() { }, // SSE 는 받는 줄이 없다 — command · ask · answer 는 POST 로 온다
|
|
98
|
+
onClose: (fn) => void res.on("close", fn),
|
|
99
|
+
};
|
|
100
|
+
track(() => close(CLOSE.COME_BACK, DETACHED), conn.onClose);
|
|
101
|
+
stream.attach(conn);
|
|
102
|
+
};
|
|
103
|
+
const post = (req, res) => {
|
|
104
|
+
const chunks = [];
|
|
105
|
+
let size = 0;
|
|
106
|
+
req.on("data", (c) => {
|
|
107
|
+
size += c.length;
|
|
108
|
+
if (size > BODY_MAX) {
|
|
109
|
+
if (res.headersSent)
|
|
110
|
+
return;
|
|
111
|
+
// 답을 다 보낸 뒤에 끊는다 — 먼저 끊으면 413 이 닿지 않는다
|
|
112
|
+
res.on("finish", () => req.destroy());
|
|
113
|
+
res.writeHead(413, { connection: "close" }).end();
|
|
114
|
+
}
|
|
115
|
+
else
|
|
116
|
+
chunks.push(c);
|
|
117
|
+
});
|
|
118
|
+
req.on("end", async () => {
|
|
119
|
+
if (res.writableEnded)
|
|
120
|
+
return;
|
|
121
|
+
let out;
|
|
122
|
+
try {
|
|
123
|
+
out = await stream.handlePost({ headers: headersOf(req), body: Buffer.concat(chunks).toString("utf8") });
|
|
124
|
+
}
|
|
125
|
+
catch (e) {
|
|
126
|
+
out = { status: 500, body: e instanceof Error ? e.message : String(e) };
|
|
127
|
+
}
|
|
128
|
+
// command 는 reply, ask 는 fate 의 배열(JSON), answer 는 204, 실패는 글자(연결의 약속 5)
|
|
129
|
+
if (out.status === 204)
|
|
130
|
+
return void res.writeHead(204).end();
|
|
131
|
+
if (out.status === 200) {
|
|
132
|
+
// 이 리스너에서 던지면 프로세스가 죽는다 — 쓸 수 없는 본문은 500
|
|
133
|
+
let json;
|
|
134
|
+
try {
|
|
135
|
+
json = JSON.stringify(out.body);
|
|
136
|
+
}
|
|
137
|
+
catch { }
|
|
138
|
+
if (json !== undefined)
|
|
139
|
+
return void res.writeHead(200, { "content-type": "application/json" }).end(json);
|
|
140
|
+
out = { status: 500, body: UNWRITABLE };
|
|
141
|
+
}
|
|
142
|
+
res.writeHead(out.status, { "content-type": "text/plain; charset=utf-8" }).end(String(out.body));
|
|
143
|
+
});
|
|
144
|
+
};
|
|
145
|
+
const onRequest = (req, res) => {
|
|
146
|
+
if (!ours(req))
|
|
147
|
+
return fallthrough(req, res);
|
|
148
|
+
if (foreign(req))
|
|
149
|
+
return void res.writeHead(403).end();
|
|
150
|
+
if (req.method === "GET" && req.headers.accept?.includes("text/event-stream"))
|
|
151
|
+
return sse(req, res);
|
|
152
|
+
if (req.method === "POST")
|
|
153
|
+
return post(req, res);
|
|
154
|
+
fallthrough(req, res);
|
|
155
|
+
};
|
|
156
|
+
/** 웹소켓 하나를 Conn 으로 — 메시지는 JSON 글자 하나, 꼴은 홉이 본다 */
|
|
157
|
+
const wsConn = (ws, req) => {
|
|
158
|
+
const close = (code, reason) => ws.close(code, fit(reason));
|
|
159
|
+
// 망가진 프레임(가리지 않은 프레임 · 너무 큼 · 틀린 UTF-8)이면 ws 가 error 를 낸다 — 듣지 않으면 프로세스가 죽는다
|
|
160
|
+
// ws 는 그 뒤 close 를 내므로 정리는 onClose 가 한다
|
|
161
|
+
ws.on("error", () => { });
|
|
162
|
+
const conn = {
|
|
163
|
+
kind: "ws",
|
|
164
|
+
// ws 가 아직 소켓에 넘기지 못한 바이트 — 닫힌 뒤에도 읽힌다
|
|
165
|
+
buffered: () => ws.bufferedAmount,
|
|
166
|
+
headers: headersOf(req),
|
|
167
|
+
send(m) {
|
|
168
|
+
if (ws.readyState !== ws.OPEN)
|
|
169
|
+
return;
|
|
170
|
+
let text;
|
|
171
|
+
try {
|
|
172
|
+
text = JSON.stringify(m);
|
|
173
|
+
}
|
|
174
|
+
catch {
|
|
175
|
+
// JSON 으로 쓸 수 없는 메시지 — 던지지 않고 그 연결만 닫는다
|
|
176
|
+
return close(CLOSE.COME_BACK, UNWRITABLE);
|
|
177
|
+
}
|
|
178
|
+
ws.send(text);
|
|
179
|
+
},
|
|
180
|
+
close,
|
|
181
|
+
onMessage: (fn) => void ws.on("message", (data) => {
|
|
182
|
+
let m;
|
|
183
|
+
try {
|
|
184
|
+
m = JSON.parse(String(data));
|
|
185
|
+
}
|
|
186
|
+
catch {
|
|
187
|
+
// JSON 이 아니면 버린다 — 꼴이 틀린 메시지를 홉이 버리는 것과 같다(연결은 살린다)
|
|
188
|
+
return;
|
|
189
|
+
}
|
|
190
|
+
fn(m);
|
|
191
|
+
}),
|
|
192
|
+
onClose: (fn) => void ws.on("close", fn),
|
|
193
|
+
};
|
|
194
|
+
track(() => close(CLOSE.COME_BACK, DETACHED), conn.onClose);
|
|
195
|
+
stream.attach(conn);
|
|
196
|
+
};
|
|
197
|
+
const onUpgrade = async (req, socket, head) => {
|
|
198
|
+
if (!ours(req)) {
|
|
199
|
+
// 다른 upgrade 리스너가 없으면 아무도 받지 않으므로 끊는다
|
|
200
|
+
if (server.listenerCount("upgrade") === 1)
|
|
201
|
+
socket.destroy();
|
|
202
|
+
return;
|
|
203
|
+
}
|
|
204
|
+
// ws 를 들이는 동안이나 받기 전에 소켓이 깨져도 프로세스가 죽지 않게 — 남의 path 의 소켓은 그 주인이 듣는다
|
|
205
|
+
socket.on("error", () => socket.destroy());
|
|
206
|
+
if (foreign(req))
|
|
207
|
+
return void socket.end("HTTP/1.1 403 Forbidden\r\ncontent-length: 0\r\n\r\n");
|
|
208
|
+
let ws;
|
|
209
|
+
try {
|
|
210
|
+
// 메시지 하나의 위 끝도 POST 본문과 같다 — 넘으면 ws 가 1009 로 닫는다
|
|
211
|
+
ws = await (wss ??= import("ws").then((m) => new m.WebSocketServer({ noServer: true, maxPayload: BODY_MAX })));
|
|
212
|
+
}
|
|
213
|
+
catch {
|
|
214
|
+
wss = undefined;
|
|
215
|
+
const text = "웹소켓을 받으려면 ws 를 설치한다(pnpm add ws)";
|
|
216
|
+
socket.end(`HTTP/1.1 501 Not Implemented\r\ncontent-type: text/plain; charset=utf-8\r\n\r\n${text}`);
|
|
217
|
+
return;
|
|
218
|
+
}
|
|
219
|
+
if (detached)
|
|
220
|
+
return void socket.destroy();
|
|
221
|
+
ws.handleUpgrade(req, socket, head, (w) => wsConn(w, req));
|
|
222
|
+
};
|
|
223
|
+
server.removeAllListeners("request");
|
|
224
|
+
server.on("request", onRequest);
|
|
225
|
+
server.on("upgrade", onUpgrade);
|
|
226
|
+
return () => {
|
|
227
|
+
if (detached)
|
|
228
|
+
return;
|
|
229
|
+
detached = true;
|
|
230
|
+
server.off("request", onRequest);
|
|
231
|
+
server.off("upgrade", onUpgrade);
|
|
232
|
+
for (const fn of prior)
|
|
233
|
+
server.on("request", fn);
|
|
234
|
+
for (const shut of [...open])
|
|
235
|
+
shut();
|
|
236
|
+
open.clear();
|
|
237
|
+
void wss?.then((w) => w.close(), () => { });
|
|
238
|
+
attached.delete(server);
|
|
239
|
+
};
|
|
240
|
+
}
|
|
@@ -0,0 +1,10 @@
|
|
|
1
|
+
import { type ClientMessage, type ServerMessage } from "../stream/protocol.js";
|
|
2
|
+
/** 메시지 하나를 이벤트 하나로 — data: 한 줄 JSON. snapshot · change 에는 id: 버전을 붙여 Last-Event-ID 로 돌아오게 한다
|
|
3
|
+
* 갈래는 JSON 의 t 가 가르므로 event: 줄은 쓰지 않는다. JSON.stringify 는 줄바꿈을 \n 으로 바꾸므로 data: 는 늘 한 줄이다 */
|
|
4
|
+
export declare function sseFrame(m: ServerMessage): string;
|
|
5
|
+
/** Authorization 의 토큰 — Bearer 머리는 떼고 읽는다 */
|
|
6
|
+
export declare function tokenOf(headers: Record<string, string | undefined>): string | undefined;
|
|
7
|
+
/** SSE 는 GET 요청이 hello 다 — 채널 · epoch · 버전(Last-Event-ID) · 토큰을 헤더에서 읽는다 */
|
|
8
|
+
export declare function helloFromHeaders(headers: Record<string, string | undefined>): Extract<ClientMessage, {
|
|
9
|
+
t: "hello";
|
|
10
|
+
}>;
|
|
@@ -0,0 +1,25 @@
|
|
|
1
|
+
// SSE 의 글자 — 두 진입점(node · web)이 함께 쓰는 한 벌. 프레임 쓰기와, GET 요청의 헤더를 hello 로 읽기
|
|
2
|
+
import { HEADER } from "../stream/protocol.js";
|
|
3
|
+
/** 메시지 하나를 이벤트 하나로 — data: 한 줄 JSON. snapshot · change 에는 id: 버전을 붙여 Last-Event-ID 로 돌아오게 한다
|
|
4
|
+
* 갈래는 JSON 의 t 가 가르므로 event: 줄은 쓰지 않는다. JSON.stringify 는 줄바꿈을 \n 으로 바꾸므로 data: 는 늘 한 줄이다 */
|
|
5
|
+
export function sseFrame(m) {
|
|
6
|
+
const id = m.t === "snapshot" || m.t === "change" ? `id: ${m.version}\n` : "";
|
|
7
|
+
return `${id}data: ${JSON.stringify(m)}\n\n`;
|
|
8
|
+
}
|
|
9
|
+
/** Authorization 의 토큰 — Bearer 머리는 떼고 읽는다 */
|
|
10
|
+
export function tokenOf(headers) {
|
|
11
|
+
const v = headers[HEADER.authorization];
|
|
12
|
+
return v?.replace(/^Bearer\s+/i, "") || undefined;
|
|
13
|
+
}
|
|
14
|
+
/** SSE 는 GET 요청이 hello 다 — 채널 · epoch · 버전(Last-Event-ID) · 토큰을 헤더에서 읽는다 */
|
|
15
|
+
export function helloFromHeaders(headers) {
|
|
16
|
+
const last = headers[HEADER.lastEventId];
|
|
17
|
+
const version = last === undefined || last === "" ? undefined : Number(last);
|
|
18
|
+
return {
|
|
19
|
+
t: "hello",
|
|
20
|
+
channel: headers[HEADER.channel] || undefined,
|
|
21
|
+
epoch: headers[HEADER.epoch] || undefined,
|
|
22
|
+
version: Number.isInteger(version) && version >= 0 ? version : undefined,
|
|
23
|
+
auth: tokenOf(headers),
|
|
24
|
+
};
|
|
25
|
+
}
|
|
@@ -0,0 +1,8 @@
|
|
|
1
|
+
import type { StreamServer } from "./core.js";
|
|
2
|
+
/** 홉 하나를 Web 표준 처리기로 — GET(Accept text/event-stream)은 SSE, POST 는 command · ask · answer
|
|
3
|
+
* - SSE 의 첫 send 나 close 가 올 때까지 응답을 돌려주지 않는다 — Response 의 상태는 돌려줄 때 정해지므로,
|
|
4
|
+
* 첫 send 전의 close 는 401(4001) 또는 503(그 밖)로 답한다. 기다림은 홉의 hello · 인증 흐름이 끊는다
|
|
5
|
+
* - origins 를 주면 Origin 헤더가 있고 목록에 없는 요청은 403 — 쿠키 인증이면 둔다(node.ts 와 같다) */
|
|
6
|
+
export declare function streamHandler(stream: StreamServer<any, any, any>, o?: {
|
|
7
|
+
origins?: string[];
|
|
8
|
+
}): (req: Request) => Promise<Response>;
|
|
@@ -0,0 +1,147 @@
|
|
|
1
|
+
// Web 표준 진입점(스펙 §9.3) — (Request) => Promise<Response>. Next · Hono · Workers 같은 곳에 SSE(GET)와 POST 만 붙인다
|
|
2
|
+
// 웹소켓은 Web 표준에 없으므로 받지 않는다. 겉의 약속은 node.ts 와 같다
|
|
3
|
+
import { CLOSE } from "../stream/protocol.js";
|
|
4
|
+
import { sseFrame } from "./sse.js";
|
|
5
|
+
/** POST 본문의 위 끝 — node.ts 와 같은 1 MiB, 넘으면 413 */
|
|
6
|
+
const BODY_MAX = 1 << 20;
|
|
7
|
+
/** 요청 헤더를 홉의 꼴로 — Headers 는 이미 소문자 이름이고 여러 값은 쉼표로 이어 준다 */
|
|
8
|
+
const headersOf = (req) => {
|
|
9
|
+
const out = {};
|
|
10
|
+
req.headers.forEach((v, k) => (out[k] = v));
|
|
11
|
+
return out;
|
|
12
|
+
};
|
|
13
|
+
const text = (status, body) => new Response(body, { status, headers: { "content-type": "text/plain; charset=utf-8" } });
|
|
14
|
+
/** 본문을 글자로 — 위 끝을 넘으면 읽기를 그만두고 undefined */
|
|
15
|
+
async function readBody(req) {
|
|
16
|
+
if (Number(req.headers.get("content-length")) > BODY_MAX)
|
|
17
|
+
return undefined;
|
|
18
|
+
const dec = new TextDecoder();
|
|
19
|
+
let out = "";
|
|
20
|
+
let size = 0;
|
|
21
|
+
if (req.body) {
|
|
22
|
+
const reader = req.body.getReader();
|
|
23
|
+
for (;;) {
|
|
24
|
+
const { value, done } = await reader.read();
|
|
25
|
+
if (done)
|
|
26
|
+
break;
|
|
27
|
+
size += value.length;
|
|
28
|
+
if (size > BODY_MAX)
|
|
29
|
+
return void (await reader.cancel());
|
|
30
|
+
out += dec.decode(value, { stream: true });
|
|
31
|
+
}
|
|
32
|
+
}
|
|
33
|
+
return out + dec.decode();
|
|
34
|
+
}
|
|
35
|
+
/** 홉 하나를 Web 표준 처리기로 — GET(Accept text/event-stream)은 SSE, POST 는 command · ask · answer
|
|
36
|
+
* - SSE 의 첫 send 나 close 가 올 때까지 응답을 돌려주지 않는다 — Response 의 상태는 돌려줄 때 정해지므로,
|
|
37
|
+
* 첫 send 전의 close 는 401(4001) 또는 503(그 밖)로 답한다. 기다림은 홉의 hello · 인증 흐름이 끊는다
|
|
38
|
+
* - origins 를 주면 Origin 헤더가 있고 목록에 없는 요청은 403 — 쿠키 인증이면 둔다(node.ts 와 같다) */
|
|
39
|
+
export function streamHandler(stream, o = {}) {
|
|
40
|
+
const sse = (req) => new Promise((respond) => {
|
|
41
|
+
const enc = new TextEncoder();
|
|
42
|
+
const listeners = [];
|
|
43
|
+
let ctl;
|
|
44
|
+
let started = false;
|
|
45
|
+
let ended = false;
|
|
46
|
+
const end = () => {
|
|
47
|
+
ended = true;
|
|
48
|
+
for (const fn of listeners)
|
|
49
|
+
fn();
|
|
50
|
+
};
|
|
51
|
+
// 상대가 끊었다 — 본문 읽기를 그만두거나 요청이 abort 된다
|
|
52
|
+
const gone = () => {
|
|
53
|
+
if (ended)
|
|
54
|
+
return;
|
|
55
|
+
end();
|
|
56
|
+
// 응답을 아직 돌려주지 않았으면 매달린 약속을 풀어 준다
|
|
57
|
+
if (!started)
|
|
58
|
+
respond(text(499));
|
|
59
|
+
};
|
|
60
|
+
// 바이트로 세고 highWaterMark 0 — desiredSize 가 곧 −(아직 읽히지 않은 바이트)
|
|
61
|
+
const body = new ReadableStream({ start: (c) => void (ctl = c), cancel: gone }, new ByteLengthQueuingStrategy({ highWaterMark: 0 }));
|
|
62
|
+
const conn = {
|
|
63
|
+
kind: "sse",
|
|
64
|
+
// 닫히면 0, 망가지면 null — 어느 쪽도 던지지 않는다
|
|
65
|
+
buffered: () => 0 - (ctl.desiredSize ?? 0),
|
|
66
|
+
headers: headersOf(req),
|
|
67
|
+
send(m) {
|
|
68
|
+
if (ended)
|
|
69
|
+
return;
|
|
70
|
+
let frame;
|
|
71
|
+
try {
|
|
72
|
+
frame = sseFrame(m);
|
|
73
|
+
}
|
|
74
|
+
catch {
|
|
75
|
+
// JSON 으로 쓸 수 없는 메시지 — 던지지 않고 그 연결만 닫는다
|
|
76
|
+
return conn.close(CLOSE.COME_BACK, "JSON 으로 쓸 수 없는 메시지");
|
|
77
|
+
}
|
|
78
|
+
if (!started) {
|
|
79
|
+
started = true;
|
|
80
|
+
respond(new Response(body, {
|
|
81
|
+
headers: {
|
|
82
|
+
"content-type": "text/event-stream; charset=utf-8",
|
|
83
|
+
// 프록시(nginx 등)가 쌓아 두거나 고치지 않고 곧바로 흘리게
|
|
84
|
+
// ponytail: connection: keep-alive 는 HTTP/2 · Workers 에서 금지라 쓰지 않는다
|
|
85
|
+
"cache-control": "no-cache, no-transform",
|
|
86
|
+
"x-accel-buffering": "no",
|
|
87
|
+
},
|
|
88
|
+
}));
|
|
89
|
+
}
|
|
90
|
+
ctl.enqueue(enc.encode(frame));
|
|
91
|
+
},
|
|
92
|
+
close(code, reason) {
|
|
93
|
+
if (ended)
|
|
94
|
+
return;
|
|
95
|
+
if (!started)
|
|
96
|
+
respond(text(code === CLOSE.GO_AWAY ? 401 : 503, reason));
|
|
97
|
+
else {
|
|
98
|
+
ctl.enqueue(enc.encode(sseFrame({ t: "close", code, reason })));
|
|
99
|
+
ctl.close();
|
|
100
|
+
}
|
|
101
|
+
end();
|
|
102
|
+
},
|
|
103
|
+
onMessage() { }, // SSE 는 받는 줄이 없다 — command · ask · answer 는 POST 로 온다
|
|
104
|
+
onClose: (fn) => void listeners.push(fn),
|
|
105
|
+
};
|
|
106
|
+
if (req.signal.aborted)
|
|
107
|
+
return gone();
|
|
108
|
+
req.signal.addEventListener("abort", gone, { once: true });
|
|
109
|
+
stream.attach(conn);
|
|
110
|
+
});
|
|
111
|
+
const post = async (req) => {
|
|
112
|
+
const raw = await readBody(req);
|
|
113
|
+
if (raw === undefined)
|
|
114
|
+
return text(413);
|
|
115
|
+
let out;
|
|
116
|
+
try {
|
|
117
|
+
out = await stream.handlePost({ headers: headersOf(req), body: raw });
|
|
118
|
+
}
|
|
119
|
+
catch (e) {
|
|
120
|
+
out = { status: 500, body: e instanceof Error ? e.message : String(e) };
|
|
121
|
+
}
|
|
122
|
+
// command 는 reply, ask 는 fate 의 배열(JSON), answer 는 204, 실패는 글자(연결의 약속 5)
|
|
123
|
+
if (out.status === 204)
|
|
124
|
+
return new Response(null, { status: 204 });
|
|
125
|
+
if (out.status === 200)
|
|
126
|
+
try {
|
|
127
|
+
return Response.json(out.body);
|
|
128
|
+
}
|
|
129
|
+
catch {
|
|
130
|
+
return text(500, "JSON 으로 쓸 수 없는 메시지");
|
|
131
|
+
}
|
|
132
|
+
return text(out.status, String(out.body));
|
|
133
|
+
};
|
|
134
|
+
return async (req) => {
|
|
135
|
+
const origin = req.headers.get("origin");
|
|
136
|
+
// Origin 이 없으면(브라우저 밖) 받는다 — 남의 사이트가 연 요청만 막는다
|
|
137
|
+
if (o.origins && origin !== null && !o.origins.includes(origin))
|
|
138
|
+
return text(403);
|
|
139
|
+
if (req.headers.get("upgrade")?.toLowerCase() === "websocket")
|
|
140
|
+
return text(426, 'Web 표준 처리기는 SSE 만 받는다 — transport: "sse" 를 쓴다');
|
|
141
|
+
if (req.method === "GET" && req.headers.get("accept")?.includes("text/event-stream"))
|
|
142
|
+
return sse(req);
|
|
143
|
+
if (req.method === "POST")
|
|
144
|
+
return post(req);
|
|
145
|
+
return text(404);
|
|
146
|
+
};
|
|
147
|
+
}
|
|
@@ -0,0 +1,43 @@
|
|
|
1
|
+
export interface ClientOptions<V, C> {
|
|
2
|
+
/** 웹소켓은 ws(s)://, SSE 는 http(s):// — 한 path 가 GET · POST 를 함께 받는다 */
|
|
3
|
+
url: string;
|
|
4
|
+
transport?: "ws" | "sse";
|
|
5
|
+
/** 생략하면 "default" */
|
|
6
|
+
channel?: string;
|
|
7
|
+
/** 다시 이을 때마다 부른다. 웹소켓은 hello.auth, SSE · POST 는 Authorization 헤더 — 주소에는 싣지 않는다 */
|
|
8
|
+
auth?: () => string | Promise<string>;
|
|
9
|
+
/** 생략하면 change 를 새 값 전체로 본다 */
|
|
10
|
+
reduce?: (value: V, change: C) => V;
|
|
11
|
+
/** 명령의 답을 기다리는 시간 — 기본 30초 */
|
|
12
|
+
timeout?: number;
|
|
13
|
+
commands?: Record<string, {
|
|
14
|
+
timeout?: number;
|
|
15
|
+
}>;
|
|
16
|
+
/** 서버의 request 에 답한다(§7.6) */
|
|
17
|
+
handlers?: Record<string, (...params: any[]) => unknown>;
|
|
18
|
+
}
|
|
19
|
+
/** §8.3 의 표 그대로 — 연결 상태를 따로 담는 칸은 두지 않는다 */
|
|
20
|
+
export interface ClientView<V> {
|
|
21
|
+
data: V | undefined;
|
|
22
|
+
status: "loading" | "ready" | "error";
|
|
23
|
+
isFetching: boolean;
|
|
24
|
+
error: string | null;
|
|
25
|
+
}
|
|
26
|
+
export interface StreamClient<V> {
|
|
27
|
+
/** 바뀌지 않았으면 같은 객체 */
|
|
28
|
+
view(): ClientView<V>;
|
|
29
|
+
subscribe(fn: () => void): () => void;
|
|
30
|
+
/** id 를 주면 그 id 로 보낸다(retry) — 홉이 이미 처리한 id 면 다시 돌리지 않고 쥔 답을 준다 */
|
|
31
|
+
command(name: string, args: unknown[], id?: string): Promise<unknown>;
|
|
32
|
+
close(): void;
|
|
33
|
+
}
|
|
34
|
+
/** 명령의 실패 — message 는 TEXT 의 문구 또는 서버 앱의 문구, requestId 는 같은 id 로 다시 보낼 때 */
|
|
35
|
+
export type CommandError = Error & {
|
|
36
|
+
requestId: string;
|
|
37
|
+
};
|
|
38
|
+
/** 시험 전용 — 다시 잇기의 첫 간격(ms)을 줄인다. 하위 경로로 내보내지 않는다 */
|
|
39
|
+
export declare const TIMING: unique symbol;
|
|
40
|
+
/** SSE 본문 읽기 — 조각을 받아 이벤트마다 data 줄을 \n 으로 이어 넘긴다
|
|
41
|
+
* 줄 끝은 \r\n · \r · \n 모두, : 로 시작하는 줄은 주석, data 밖의 칸(id · event · retry)은 버린다 */
|
|
42
|
+
export declare function sseParser(onData: (data: string) => void): (chunk: string) => void;
|
|
43
|
+
export declare function connect<V, C>(o: ClientOptions<V, C>): StreamClient<V>;
|