Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 chiyi
|
9019798382 | ||
|
chiyi
|
095cb859a5 | ||
|
chiyi
|
eb290cc88c |
@@ -75,6 +75,7 @@ func TestBugNullableEnum(t *testing.T) {
|
||||
|
||||
// bug3: 含 () error 方法的代码生成不应 panic，且类型应生成为 Void/void
|
||||
func TestBugGenErrorOnly(t *testing.T) {
|
||||
isolateGeneratorGlobals(t)
|
||||
GetFun().BindService(&BugSvc{})
|
||||
SetOutput(t.TempDir())
|
||||
GenCode(GenGo{}, GenTs{})
|
||||
|
||||
@@ -0,0 +1,589 @@
|
||||
package fun
|
||||
|
||||
import (
|
||||
"os"
|
||||
"os/exec"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestTypeScriptClientBehavior(t *testing.T) {
|
||||
node, err := exec.LookPath("node")
|
||||
if err != nil {
|
||||
t.Skip("node is not installed")
|
||||
}
|
||||
probe := exec.Command(node, "--experimental-strip-types", "--input-type=module", "-e",
|
||||
`if (typeof fetch !== "function" || typeof ReadableStream !== "function") process.exit(1)`)
|
||||
if err := probe.Run(); err != nil {
|
||||
t.Skip("node does not support TypeScript stripping and web streams")
|
||||
}
|
||||
|
||||
dir := t.TempDir()
|
||||
if err := os.WriteFile(filepath.Join(dir, "client.ts"), []byte(templateTs{}.genClientTemplate()), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
const script = `
|
||||
import assert from "node:assert/strict";
|
||||
import { Client } from "./client.ts";
|
||||
|
||||
const json = (value, status = 200) => new Response(JSON.stringify(value), {
|
||||
status,
|
||||
headers: { "Content-Type": "application/json" },
|
||||
});
|
||||
const ndjson = body => new Response(body, {
|
||||
headers: { "Content-Type": "application/x-ndjson; charset=utf-8" },
|
||||
});
|
||||
const client = new Client("http://example.test///");
|
||||
const seen = [];
|
||||
let cleanupCheck;
|
||||
client.addResponseInterceptor((_service, _method, result) => {
|
||||
if (cleanupCheck) {
|
||||
assert.equal(cleanupCheck(), true);
|
||||
cleanupCheck = undefined;
|
||||
}
|
||||
seen.push(result.status);
|
||||
});
|
||||
const expectSeen = status => assert.deepEqual(seen.splice(0), [status]);
|
||||
|
||||
let fetchInit;
|
||||
globalThis.fetch = async (url, init) => {
|
||||
fetchInit = { url, init };
|
||||
return json({ status: 0, data: "ok" });
|
||||
};
|
||||
let result = await client.request("Svc", "fetchShape", undefined, { signal: new AbortController().signal });
|
||||
assert.equal(result.status, 0);
|
||||
assert.equal(fetchInit.url, "http://example.test/cell");
|
||||
assert.equal(fetchInit.init.method, "POST");
|
||||
assert.equal(fetchInit.init.headers["Content-Type"], "application/json");
|
||||
assert.ok(fetchInit.init.signal);
|
||||
assert.deepEqual(JSON.parse(fetchInit.init.body), { serviceName: "Svc", methodName: "fetchShape" });
|
||||
expectSeen(0);
|
||||
|
||||
globalThis.fetch = async () => json({ status: 2, code: 4001, msg: "business" }, 503);
|
||||
result = await client.request("Svc", "business");
|
||||
assert.deepEqual(result, { status: 2, code: 4001, msg: "business" });
|
||||
expectSeen(2);
|
||||
|
||||
globalThis.fetch = async () => json({ status: 1, msg: "framework" }, 500);
|
||||
result = await client.request("Svc", "framework");
|
||||
assert.deepEqual(result, { status: 1, msg: "framework" });
|
||||
expectSeen(1);
|
||||
|
||||
globalThis.fetch = async () => new Response("<html>gateway timeout</html>", { status: 504 });
|
||||
result = await client.request("Svc", "gatewayTimeout");
|
||||
assert.equal(result.status, 5);
|
||||
assert.match(result.msg, /504/);
|
||||
expectSeen(5);
|
||||
|
||||
globalThis.fetch = async () => new Response("request timeout", { status: 408 });
|
||||
result = await client.request("Svc", "gateway408");
|
||||
assert.equal(result.status, 5);
|
||||
expectSeen(5);
|
||||
|
||||
globalThis.fetch = async () => json({ status: 5, msg: "server timeout" });
|
||||
result = await client.request("Svc", "serverTimeout");
|
||||
assert.equal(result.status, 5);
|
||||
assert.equal(result.msg, "server timeout");
|
||||
expectSeen(5);
|
||||
|
||||
globalThis.fetch = async () => new Response("bad gateway", { status: 502 });
|
||||
result = await client.request("Svc", "gateway");
|
||||
assert.equal(result.status, 4);
|
||||
expectSeen(4);
|
||||
|
||||
globalThis.fetch = async () => new Response("", { status: 200 });
|
||||
result = await client.request("Svc", "empty");
|
||||
assert.equal(result.status, 1);
|
||||
assert.match(result.msg, /Empty/);
|
||||
expectSeen(1);
|
||||
|
||||
globalThis.fetch = async () => new Response("not-json", { status: 200 });
|
||||
result = await client.request("Svc", "invalidJson");
|
||||
assert.equal(result.status, 1);
|
||||
assert.match(result.msg, /Invalid JSON/);
|
||||
expectSeen(1);
|
||||
|
||||
globalThis.fetch = async () => new Response("<html>login</html>", {
|
||||
status: 200,
|
||||
headers: { "Content-Type": "text/html" },
|
||||
});
|
||||
result = await client.request("Svc", "html");
|
||||
assert.equal(result.status, 1);
|
||||
assert.match(result.msg, /HTML/);
|
||||
expectSeen(1);
|
||||
|
||||
globalThis.fetch = async () => json({ data: 1 });
|
||||
result = await client.request("Svc", "invalidResult");
|
||||
assert.equal(result.status, 1);
|
||||
expectSeen(1);
|
||||
|
||||
globalThis.fetch = async () => { throw new TypeError("DNS failed"); };
|
||||
result = await client.request("Svc", "network");
|
||||
assert.equal(result.status, 4);
|
||||
assert.match(result.msg, /DNS failed/);
|
||||
expectSeen(4);
|
||||
|
||||
globalThis.fetch = async () => new Response(new ReadableStream({
|
||||
pull(controller) { controller.error(new Error("body read failed")); },
|
||||
}));
|
||||
result = await client.request("Svc", "bodyRead");
|
||||
assert.equal(result.status, 4);
|
||||
assert.match(result.msg, /body read failed/);
|
||||
expectSeen(4);
|
||||
|
||||
const manualAbort = new AbortController();
|
||||
manualAbort.abort();
|
||||
globalThis.fetch = async () => { throw new DOMException("aborted", "AbortError"); };
|
||||
result = await client.request("Svc", "abort", undefined, { signal: manualAbort.signal });
|
||||
assert.equal(result.status, 4);
|
||||
assert.match(result.msg, /aborted/i);
|
||||
expectSeen(4);
|
||||
|
||||
const timeoutAbort = new AbortController();
|
||||
timeoutAbort.abort(new DOMException("timed out", "TimeoutError"));
|
||||
result = await client.request("Svc", "timeoutSignal", undefined, { signal: timeoutAbort.signal });
|
||||
assert.equal(result.status, 5);
|
||||
expectSeen(5);
|
||||
|
||||
globalThis.fetch = async () => { throw new DOMException("timed out", "TimeoutError"); };
|
||||
result = await client.request("Svc", "timeoutError");
|
||||
assert.equal(result.status, 5);
|
||||
expectSeen(5);
|
||||
|
||||
const requestInterceptorClient = new Client("http://example.test");
|
||||
let requestInterceptorSeen;
|
||||
requestInterceptorClient.addRequestInterceptor((_service, _method, state, dto) => {
|
||||
state.token = "abc";
|
||||
requestInterceptorSeen = dto;
|
||||
});
|
||||
requestInterceptorClient.addResponseInterceptor((_service, _method, value) => ({ ...value, msg: "intercepted" }));
|
||||
globalThis.fetch = async (_url, init) => {
|
||||
const payload = JSON.parse(init.body);
|
||||
assert.deepEqual(payload.state, { token: "abc" });
|
||||
return json({ status: 0 });
|
||||
};
|
||||
result = await requestInterceptorClient.request("Svc", "interceptors", { value: 1 });
|
||||
assert.deepEqual(requestInterceptorSeen, { value: 1 });
|
||||
assert.equal(result.msg, "intercepted");
|
||||
|
||||
const stateClient = new Client("http://example.test");
|
||||
stateClient.setState({ shared: "global", globalOnly: "yes" });
|
||||
const stateContexts = new Map();
|
||||
const nativeResponses = new Map();
|
||||
const payloads = new Map();
|
||||
let releaseFirst;
|
||||
const firstMayContinue = new Promise(resolve => { releaseFirst = resolve; });
|
||||
let firstInterceptorEntered;
|
||||
const firstDidEnter = new Promise(resolve => { firstInterceptorEntered = resolve; });
|
||||
let firstStateReference;
|
||||
stateClient.addRequestInterceptor(async (_service, method, state, dto) => {
|
||||
state.interceptor = dto.id;
|
||||
if (method === "first") {
|
||||
firstStateReference = state;
|
||||
firstInterceptorEntered();
|
||||
await firstMayContinue;
|
||||
}
|
||||
state.completed = dto.id;
|
||||
});
|
||||
stateClient.addResponseInterceptor((_service, method, _value, context) => {
|
||||
stateContexts.set(method, context);
|
||||
});
|
||||
globalThis.fetch = async (_url, init) => {
|
||||
const payload = JSON.parse(init.body);
|
||||
payloads.set(payload.methodName, payload);
|
||||
const response = json({ status: 0, data: payload.methodName });
|
||||
nativeResponses.set(payload.methodName, response);
|
||||
return response;
|
||||
};
|
||||
const firstOverride = { shared: "first", requestOnly: "one" };
|
||||
const firstRequest = stateClient.request("Svc", "first", { id: "one" }, { state: firstOverride });
|
||||
await firstDidEnter;
|
||||
firstOverride.shared = "mutated outside";
|
||||
const secondRequest = stateClient.request("Svc", "second", { id: "two" }, {
|
||||
state: { shared: "second", requestOnly: "two" },
|
||||
});
|
||||
assert.equal((await secondRequest).status, 0);
|
||||
releaseFirst();
|
||||
assert.equal((await firstRequest).status, 0);
|
||||
assert.deepEqual(payloads.get("first").state, {
|
||||
shared: "first",
|
||||
globalOnly: "yes",
|
||||
requestOnly: "one",
|
||||
interceptor: "one",
|
||||
completed: "one",
|
||||
});
|
||||
assert.deepEqual(payloads.get("second").state, {
|
||||
shared: "second",
|
||||
globalOnly: "yes",
|
||||
requestOnly: "two",
|
||||
interceptor: "two",
|
||||
completed: "two",
|
||||
});
|
||||
firstStateReference.shared = "mutated after snapshot";
|
||||
for (const method of ["first", "second"]) {
|
||||
const context = stateContexts.get(method);
|
||||
assert.deepEqual(context.requestState, payloads.get(method).state);
|
||||
assert.equal(Object.isFrozen(context.requestState), true);
|
||||
assert.equal(Object.isFrozen(context), true);
|
||||
assert.equal(context.response, nativeResponses.get(method));
|
||||
assert.ok(context.response instanceof Response);
|
||||
}
|
||||
assert.equal(stateContexts.get("first").requestState.shared, "first");
|
||||
|
||||
const throwingState = Object.defineProperty({}, "token", {
|
||||
enumerable: true,
|
||||
get() { throw new Error("state read failed"); },
|
||||
});
|
||||
const stateFailureClient = new Client("http://example.test");
|
||||
let stateFailureSeen = [];
|
||||
stateFailureClient.addResponseInterceptor((_service, _method, value, context) => {
|
||||
stateFailureSeen.push([value.status, context.requestState]);
|
||||
});
|
||||
globalThis.fetch = async () => assert.fail("fetch must not run for state failure");
|
||||
result = await stateFailureClient.request("Svc", "requestStateFailure", undefined, { state: throwingState });
|
||||
assert.equal(result.status, 1);
|
||||
assert.match(result.msg, /prepare request state/i);
|
||||
result = await stateFailureClient.stream("Svc", "streamStateFailure", undefined, () => {}, { state: throwingState });
|
||||
assert.equal(result.status, 1);
|
||||
assert.match(result.msg, /prepare request state/i);
|
||||
assert.deepEqual(stateFailureSeen, [[1, {}], [1, {}]]);
|
||||
|
||||
const snapshotFailureClient = new Client("http://example.test");
|
||||
snapshotFailureClient.addRequestInterceptor((_service, _method, state) => {
|
||||
Object.defineProperty(state, "broken", {
|
||||
enumerable: true,
|
||||
get() { throw new Error("snapshot read failed"); },
|
||||
});
|
||||
});
|
||||
globalThis.fetch = async () => assert.fail("fetch must not run for snapshot failure");
|
||||
result = await snapshotFailureClient.request("Svc", "requestSnapshotFailure");
|
||||
assert.equal(result.status, 1);
|
||||
assert.match(result.msg, /snapshot request state/i);
|
||||
result = await snapshotFailureClient.stream("Svc", "streamSnapshotFailure", undefined, () => {});
|
||||
assert.equal(result.status, 1);
|
||||
assert.match(result.msg, /snapshot request state/i);
|
||||
|
||||
const contextClient = new Client("http://example.test");
|
||||
contextClient.setState({ base: "global" });
|
||||
const outcomeContexts = new Map();
|
||||
contextClient.addResponseInterceptor((_service, method, _value, context) => {
|
||||
outcomeContexts.set(method, context);
|
||||
});
|
||||
contextClient.addRequestInterceptor((_service, method, state) => {
|
||||
state.method = method;
|
||||
if (method === "requestHookFailure") throw new Error("request context hook");
|
||||
});
|
||||
globalThis.fetch = async () => assert.fail("fetch must not run before serialization");
|
||||
const contextCyclic = {};
|
||||
contextCyclic.self = contextCyclic;
|
||||
result = await contextClient.request("Svc", "serializeContext", contextCyclic, { state: { base: "request" } });
|
||||
assert.equal(result.status, 1);
|
||||
assert.deepEqual(outcomeContexts.get("serializeContext").requestState, {
|
||||
base: "request",
|
||||
method: "serializeContext",
|
||||
});
|
||||
assert.equal(outcomeContexts.get("serializeContext").response, undefined);
|
||||
result = await contextClient.request("Svc", "requestHookFailure", undefined, { state: { request: "hook" } });
|
||||
assert.equal(result.status, 1);
|
||||
assert.deepEqual(outcomeContexts.get("requestHookFailure").requestState, {
|
||||
base: "global",
|
||||
request: "hook",
|
||||
method: "requestHookFailure",
|
||||
});
|
||||
assert.equal(outcomeContexts.get("requestHookFailure").response, undefined);
|
||||
globalThis.fetch = async () => { throw new TypeError("offline"); };
|
||||
result = await contextClient.request("Svc", "networkContext", undefined, { state: { request: "network" } });
|
||||
assert.equal(result.status, 4);
|
||||
assert.deepEqual(outcomeContexts.get("networkContext").requestState, {
|
||||
base: "global",
|
||||
request: "network",
|
||||
method: "networkContext",
|
||||
});
|
||||
assert.equal(outcomeContexts.get("networkContext").response, undefined);
|
||||
const bodyReadResponse = new Response(new ReadableStream({
|
||||
pull(controller) { controller.error(new Error("context body read failed")); },
|
||||
}));
|
||||
globalThis.fetch = async () => bodyReadResponse;
|
||||
result = await contextClient.request("Svc", "bodyReadContext", undefined, { state: { request: "body" } });
|
||||
assert.equal(result.status, 4);
|
||||
assert.deepEqual(outcomeContexts.get("bodyReadContext").requestState, {
|
||||
base: "global",
|
||||
request: "body",
|
||||
method: "bodyReadContext",
|
||||
});
|
||||
assert.equal(outcomeContexts.get("bodyReadContext").response, bodyReadResponse);
|
||||
|
||||
const failingRequestInterceptor = new Client("http://example.test");
|
||||
let normalized = [];
|
||||
failingRequestInterceptor.addRequestInterceptor(() => { throw new Error("request hook"); });
|
||||
failingRequestInterceptor.addResponseInterceptor((_s, _m, value) => { normalized.push(value.status); });
|
||||
result = await failingRequestInterceptor.request("Svc", "hook");
|
||||
assert.equal(result.status, 1);
|
||||
assert.match(result.msg, /request hook/);
|
||||
assert.deepEqual(normalized, [1]);
|
||||
|
||||
const failingResponseInterceptor = new Client("http://example.test");
|
||||
normalized = [];
|
||||
failingResponseInterceptor.addResponseInterceptor(() => { throw new Error("response hook"); });
|
||||
failingResponseInterceptor.addResponseInterceptor((_s, _m, value) => { normalized.push(value.status); });
|
||||
globalThis.fetch = async () => json({ status: 2, code: 4003, msg: "original" });
|
||||
result = await failingResponseInterceptor.request("Svc", "responseHook");
|
||||
assert.equal(result.status, 1);
|
||||
assert.match(result.msg, /response hook/);
|
||||
assert.deepEqual(normalized, [1]);
|
||||
|
||||
const cyclic = {};
|
||||
cyclic.self = cyclic;
|
||||
globalThis.fetch = async () => assert.fail("fetch must not run for serialization failure");
|
||||
result = await client.request("Svc", "serialize", cyclic);
|
||||
assert.equal(result.status, 1);
|
||||
assert.match(result.msg, /serialize/i);
|
||||
expectSeen(1);
|
||||
|
||||
globalThis.fetch = async () => json({ status: 2, code: 4002, msg: "stream business" }, 422);
|
||||
result = await client.stream("Svc", "streamBusiness", undefined, () => {});
|
||||
assert.deepEqual(result, { status: 2, code: 4002, msg: "stream business" });
|
||||
expectSeen(2);
|
||||
|
||||
globalThis.fetch = async () => json({ status: 0 });
|
||||
result = await client.stream("Svc", "wrongMedia", undefined, () => {});
|
||||
assert.equal(result.status, 1);
|
||||
assert.match(result.msg, /x-ndjson/);
|
||||
expectSeen(1);
|
||||
|
||||
const bytes = new TextEncoder().encode('{"text":"你好"}\r\n\n{"n":2}');
|
||||
const split = bytes.indexOf(0xe5) + 1;
|
||||
globalThis.fetch = async () => new Response(new ReadableStream({
|
||||
start(controller) {
|
||||
controller.enqueue(bytes.slice(0, split));
|
||||
controller.enqueue(bytes.slice(split));
|
||||
controller.close();
|
||||
},
|
||||
}), { headers: { "Content-Type": "application/x-ndjson; charset=utf-8" } });
|
||||
const messages = [];
|
||||
result = await client.stream("Svc", "valid", undefined, value => messages.push(value));
|
||||
assert.equal(result.status, 0);
|
||||
assert.deepEqual(messages, [{ text: "你好" }, { n: 2 }]);
|
||||
expectSeen(0);
|
||||
|
||||
let malformedCancelled = false;
|
||||
globalThis.fetch = async () => new Response(new ReadableStream({
|
||||
start(controller) { controller.enqueue(new TextEncoder().encode("bad\n")); },
|
||||
cancel() { malformedCancelled = true; },
|
||||
}), { headers: { "Content-Type": "application/x-ndjson" } });
|
||||
cleanupCheck = () => malformedCancelled;
|
||||
result = await client.stream("Svc", "malformed", undefined, () => {});
|
||||
assert.equal(result.status, 1);
|
||||
assert.match(result.msg, /line 1/);
|
||||
assert.equal(malformedCancelled, true);
|
||||
expectSeen(1);
|
||||
|
||||
globalThis.fetch = async () => ndjson('{"n":1}\n');
|
||||
result = await client.stream("Svc", "callback", undefined, () => { throw new Error("callback boom"); });
|
||||
assert.equal(result.status, 1);
|
||||
assert.match(result.msg, /callback boom/);
|
||||
expectSeen(1);
|
||||
|
||||
globalThis.fetch = async () => new Response(new ReadableStream({
|
||||
pull(controller) { controller.error(new Error("read boom")); },
|
||||
}), { headers: { "Content-Type": "application/x-ndjson" } });
|
||||
result = await client.stream("Svc", "read", undefined, () => {});
|
||||
assert.equal(result.status, 4);
|
||||
assert.match(result.msg, /read boom/);
|
||||
expectSeen(4);
|
||||
|
||||
globalThis.fetch = async () => ndjson(new Uint8Array([0xff, 0x0a]));
|
||||
result = await client.stream("Svc", "utf8", undefined, () => {});
|
||||
assert.equal(result.status, 1);
|
||||
assert.match(result.msg, /UTF-8/);
|
||||
expectSeen(1);
|
||||
|
||||
globalThis.fetch = async () => ndjson("");
|
||||
result = await client.stream("Svc", "emptyStream", undefined, () => assert.fail("empty stream callback"));
|
||||
assert.deepEqual(result, { status: 0 });
|
||||
expectSeen(0);
|
||||
|
||||
globalThis.fetch = async () => new Response(null, {
|
||||
headers: { "Content-Type": "application/x-ndjson" },
|
||||
});
|
||||
result = await client.stream("Svc", "nullBody", undefined, () => assert.fail("null stream callback"));
|
||||
assert.deepEqual(result, { status: 0 });
|
||||
expectSeen(0);
|
||||
|
||||
const streamAbort = new AbortController();
|
||||
streamAbort.abort();
|
||||
globalThis.fetch = async () => { throw new DOMException("aborted", "AbortError"); };
|
||||
result = await client.stream("Svc", "abortStream", undefined, () => {}, { signal: streamAbort.signal });
|
||||
assert.equal(result.status, 4);
|
||||
expectSeen(4);
|
||||
|
||||
const readAbort = new AbortController();
|
||||
globalThis.fetch = async () => new Response(new ReadableStream({
|
||||
start(controller) {
|
||||
readAbort.signal.addEventListener("abort", () => controller.error(new DOMException("aborted", "AbortError")), { once: true });
|
||||
readAbort.abort();
|
||||
},
|
||||
}), { headers: { "Content-Type": "application/x-ndjson" } });
|
||||
result = await client.stream("Svc", "readAbort", undefined, () => {}, { signal: readAbort.signal });
|
||||
assert.equal(result.status, 4);
|
||||
assert.match(result.msg, /aborted/i);
|
||||
expectSeen(4);
|
||||
|
||||
const readTimeout = new AbortController();
|
||||
readTimeout.abort(new DOMException("timed out", "TimeoutError"));
|
||||
globalThis.fetch = async () => new Response(new ReadableStream({
|
||||
pull(controller) { controller.error(new DOMException("aborted", "AbortError")); },
|
||||
}), { headers: { "Content-Type": "application/x-ndjson" } });
|
||||
result = await client.stream("Svc", "timeoutStream", undefined, () => {}, { signal: readTimeout.signal });
|
||||
assert.equal(result.status, 5);
|
||||
expectSeen(5);
|
||||
|
||||
const streamHookClient = new Client("http://example.test");
|
||||
normalized = [];
|
||||
streamHookClient.addRequestInterceptor(() => { throw new Error("stream hook"); });
|
||||
streamHookClient.addResponseInterceptor((_s, _m, value) => { normalized.push(value.status); });
|
||||
result = await streamHookClient.stream("Svc", "hook", undefined, () => {});
|
||||
assert.equal(result.status, 1);
|
||||
assert.deepEqual(normalized, [1]);
|
||||
|
||||
const streamStateClient = new Client("http://example.test");
|
||||
streamStateClient.setState({ shared: "global", globalOnly: "stream" });
|
||||
const streamContexts = new Map();
|
||||
const streamResponses = new Map();
|
||||
const streamPayloads = new Map();
|
||||
streamStateClient.addRequestInterceptor((_service, method, state) => {
|
||||
state.interceptor = method;
|
||||
if (method === "streamHookFailure") throw new Error("stream context hook");
|
||||
});
|
||||
streamStateClient.addResponseInterceptor((_service, method, _value, context) => {
|
||||
streamContexts.set(method, context);
|
||||
});
|
||||
globalThis.fetch = async (_url, init) => {
|
||||
const payload = JSON.parse(init.body);
|
||||
streamPayloads.set(payload.methodName, payload);
|
||||
if (payload.methodName === "streamNetwork") throw new TypeError("stream offline");
|
||||
const response = payload.methodName === "streamWrongMedia"
|
||||
? json({ status: 0 })
|
||||
: payload.methodName === "streamReadFailure"
|
||||
? new Response(new ReadableStream({
|
||||
pull(controller) { controller.error(new Error("stream context read failed")); },
|
||||
}), { headers: { "Content-Type": "application/x-ndjson" } })
|
||||
: ndjson('{"n":1}\n');
|
||||
streamResponses.set(payload.methodName, response);
|
||||
return response;
|
||||
};
|
||||
result = await streamStateClient.stream("Svc", "streamSuccess", undefined, () => {}, {
|
||||
state: { shared: "request", requestOnly: "success" },
|
||||
});
|
||||
assert.equal(result.status, 0);
|
||||
result = await streamStateClient.stream("Svc", "streamWrongMedia", undefined, () => {}, {
|
||||
state: { shared: "wrong-media" },
|
||||
});
|
||||
assert.equal(result.status, 1);
|
||||
result = await streamStateClient.stream("Svc", "streamNetwork", undefined, () => {}, {
|
||||
state: { shared: "network" },
|
||||
});
|
||||
assert.equal(result.status, 4);
|
||||
result = await streamStateClient.stream("Svc", "streamReadFailure", undefined, () => {}, {
|
||||
state: { shared: "read" },
|
||||
});
|
||||
assert.equal(result.status, 4);
|
||||
const streamCyclic = {};
|
||||
streamCyclic.self = streamCyclic;
|
||||
result = await streamStateClient.stream("Svc", "streamSerialize", streamCyclic, () => {}, {
|
||||
state: { shared: "serialize" },
|
||||
});
|
||||
assert.equal(result.status, 1);
|
||||
result = await streamStateClient.stream("Svc", "streamHookFailure", undefined, () => {}, {
|
||||
state: { shared: "hook" },
|
||||
});
|
||||
assert.equal(result.status, 1);
|
||||
for (const method of ["streamSuccess", "streamWrongMedia", "streamNetwork", "streamReadFailure"]) {
|
||||
const context = streamContexts.get(method);
|
||||
assert.deepEqual(context.requestState, streamPayloads.get(method).state);
|
||||
assert.equal(Object.isFrozen(context.requestState), true);
|
||||
assert.equal(Object.isFrozen(context), true);
|
||||
}
|
||||
assert.equal(streamContexts.get("streamSuccess").response, streamResponses.get("streamSuccess"));
|
||||
assert.equal(streamContexts.get("streamWrongMedia").response, streamResponses.get("streamWrongMedia"));
|
||||
assert.equal(streamContexts.get("streamReadFailure").response, streamResponses.get("streamReadFailure"));
|
||||
assert.equal(streamContexts.get("streamNetwork").response, undefined);
|
||||
assert.deepEqual(streamContexts.get("streamSerialize").requestState, {
|
||||
shared: "serialize",
|
||||
globalOnly: "stream",
|
||||
interceptor: "streamSerialize",
|
||||
});
|
||||
assert.equal(streamContexts.get("streamSerialize").response, undefined);
|
||||
assert.deepEqual(streamContexts.get("streamHookFailure").requestState, {
|
||||
shared: "hook",
|
||||
globalOnly: "stream",
|
||||
interceptor: "streamHookFailure",
|
||||
});
|
||||
assert.equal(streamContexts.get("streamHookFailure").response, undefined);
|
||||
`
|
||||
scriptPath := filepath.Join(dir, "behavior.mjs")
|
||||
if err := os.WriteFile(scriptPath, []byte(script), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
command := exec.Command(node, "--experimental-strip-types", scriptPath)
|
||||
if output, err := command.CombinedOutput(); err != nil {
|
||||
t.Fatalf("TypeScript client behavior failed: %v\n%s", err, output)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTypeScriptClientStrictTypecheck(t *testing.T) {
|
||||
tsc, err := exec.LookPath("tsc")
|
||||
if err != nil {
|
||||
t.Skip("tsc is not installed")
|
||||
}
|
||||
dir := t.TempDir()
|
||||
path := filepath.Join(dir, "client.ts")
|
||||
if err := os.WriteFile(path, []byte(templateTs{}.genClientTemplate()), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
usagePath := filepath.Join(dir, "usage.ts")
|
||||
const usage = `import { Client, type ContextResponseInterceptor, type RequestOptions, type ResponseContext, type ResponseInterceptor, type StreamOptions } from "./client";
|
||||
|
||||
const requestOptions: RequestOptions = { state: { token: "request" } };
|
||||
const streamOptions: StreamOptions = { state: { token: "stream" } };
|
||||
const legacy: ResponseInterceptor = (_service, _method, result) => result;
|
||||
const legacyConsumer: (service: string, method: string, result: import("./client").result<any>) => unknown = legacy;
|
||||
const current: ContextResponseInterceptor = (_service, _method, result, context) => {
|
||||
const token: string | undefined = context.requestState.token;
|
||||
const response: Response | undefined = context.response;
|
||||
void token;
|
||||
void response;
|
||||
return result;
|
||||
};
|
||||
void legacyConsumer;
|
||||
const context = {} as ResponseContext;
|
||||
// @ts-expect-error requestState is readonly
|
||||
context.requestState.token = "changed";
|
||||
const client = new Client("/");
|
||||
client.addResponseInterceptor(legacy);
|
||||
client.addResponseInterceptor(current);
|
||||
void client.request("Svc", "method", undefined, requestOptions);
|
||||
void client.stream("Svc", "method", undefined, () => {}, streamOptions);
|
||||
`
|
||||
if err := os.WriteFile(usagePath, []byte(usage), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
command := exec.Command(tsc,
|
||||
"--strict", "--noEmit", "--target", "ES2022", "--module", "ESNext", "--lib", "ES2022,DOM", path, usagePath)
|
||||
if output, err := command.CombinedOutput(); err != nil {
|
||||
t.Fatalf("strict TypeScript check failed: %v\n%s", err, output)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTypeScriptClientSimplicityGate(t *testing.T) {
|
||||
source := templateTs{}.genClientTemplate() + templateTs{}.genServiceTemplate()
|
||||
for _, forbidden := range []string{"RpcError", "httpStatus", "result.aborted", "ClientErrorCode", "setTimeout"} {
|
||||
if strings.Contains(source, forbidden) {
|
||||
t.Errorf("generated TypeScript templates contain forbidden %q", forbidden)
|
||||
}
|
||||
}
|
||||
if !strings.Contains(source, "Promise<result<void>>") {
|
||||
t.Fatal("stream methods must resolve result<void>")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,154 @@
|
||||
# fun 框架（github.com/cyi-cc/fun）使用文档
|
||||
|
||||
> 适用版本：**v1.3.2**（当前最新发布）。基于 fasthttp 的单端点 RPC 框架，
|
||||
> 自带依赖注入、Guard 鉴权、NDJSON 流式响应、自定义路由与 TypeScript 客户端生成。
|
||||
|
||||
## 版本沿革
|
||||
|
||||
| 版本 | 要点 |
|
||||
|---|---|
|
||||
| v1.1.0 | BindRoute 自定义 GET/POST 路由（回调、健康检查） |
|
||||
| v1.3.0 | BindRoute 通配符路由 `/prefix/*`，`RouteCtx.Wildcard` 取剩余路径 |
|
||||
| v1.3.1 | TS 客户端可靠性：所有失败统一归一为 Result 并经过响应拦截器 |
|
||||
| v1.3.2 | 每请求上下文（request/stream options + `state`）与免基础设施的生成期注册 `BindServiceForGen` |
|
||||
|
||||
## 1. 启动与服务注册
|
||||
|
||||
```go
|
||||
func main() {
|
||||
f := fun.GetFun()
|
||||
f.BindService(&UserSvc{}, &AuthGuard{}) // 服务级 Guard 可选
|
||||
f.BindGuard(&LogGuard{}) // 全局 Guard
|
||||
|
||||
cfg := fun.Wired[config.Config]() // 创建/获取单例（触发 DI）
|
||||
go f.Start(cfg.ListenPort()) // fasthttp 监听，RPC 只响应 POST /cell
|
||||
}
|
||||
```
|
||||
|
||||
- 服务结构体嵌入 `fun.Ctx` + 依赖字段（指针结构体字段自动装配）。
|
||||
- **每请求新建服务实例**并注入依赖，服务内不放共享状态。
|
||||
- 方法签名四种：`() error`、`(dto) (T, error)`、`(dto) (*fun.Stream, error)`、
|
||||
`(dto) (T, *fun.Stream, error)`（首条消息 T + 后续流）。
|
||||
- 只有导出方法成为端点，注册名 `服务名.方法名`。
|
||||
|
||||
## 2. DTO 规则（违反即注册期 panic）
|
||||
|
||||
- 允许：定宽整型（int8…int64、uint8…uint64）、string、bool、具名 struct、slice、指针。
|
||||
- **不支持**：普通 `int`/`uint`、float、map、any/interface、匿名结构体、私有字段。
|
||||
- 非指针且非 slice 字段必传且非 null；可空字段一律 `*T`；小数用字符串传。
|
||||
- 枚举：`uint8` 底线 + `Names() []string`（可选 `DisplayNames()`）。
|
||||
- 响应所有键递归转首字母小写，前端直接 camelCase 取值。
|
||||
|
||||
## 3. 线协议与 Result
|
||||
|
||||
请求：`POST /cell`，body `{"serviceName","methodName","data","state"}`。
|
||||
|
||||
```ts
|
||||
export type result<T> = {
|
||||
id?: string; code?: number; data?: T; msg?: string; status: number
|
||||
}
|
||||
```
|
||||
|
||||
- `status`：`0` 成功；`1` 框架/协议/基础设施失败；`2` 业务失败（`fun.Error(code,msg)`）；
|
||||
`4` 外部请求失败或调用方取消；`5` 明确的外部超时失败。
|
||||
- 业务错误：`return nil, fun.Error(4001, "登录失败")` —— code/msg 原样透传。
|
||||
- 成功空 slice 序列化为 `[]`；`data` 为 nil 时整个字段省略。
|
||||
- `Ctx.State`（map[string]string）请求往返透传；`Ctx.Ip` 已解析客户端 IP。
|
||||
|
||||
## 4. Guard（v1.3.2 无变化，推荐用法见 vividai）
|
||||
|
||||
```go
|
||||
func (g *AuthGuard) Guard(ctx fun.Ctx) { /* 校验失败 panic(fun.Error(...)) */ }
|
||||
f.BindService(&AdminSvc{}, &AuthGuard{})
|
||||
```
|
||||
|
||||
Guard 也是 Box，字段自动注入；panic 被框架兜底转错误响应。
|
||||
vividai 的用法：**显式端点策略表**（缺省拒绝）+ Guard 从 HttpOnly Cookie 读会话，
|
||||
并把校验结果经 `RequestCtx.SetUserValue` 传给服务层做对象级授权。
|
||||
|
||||
## 5. 自定义路由（v1.3.0+）
|
||||
|
||||
```go
|
||||
f.BindRoute("GET", "/image/*", func(c *fun.RouteCtx) error {
|
||||
key := c.Wildcard // /image/ 之后的剩余路径
|
||||
c.RequestCtx.WriteString("…") // 纯文本直写；返回 nil 框架不再写
|
||||
return fun.Error(4001, "…") // 或统一 Result 错误
|
||||
})
|
||||
```
|
||||
|
||||
- 精确路由优先于通配符；`/cell` 保留；方法大小写不敏感。
|
||||
- 查询参数与 form 表单合并进 `c.Param(name)`；multipart 不支持（转 base64 走 /cell）。
|
||||
|
||||
## 6. 流式响应（NDJSON）
|
||||
|
||||
```go
|
||||
st := &fun.Stream{}
|
||||
go func() {
|
||||
for _, chunk := range chunks {
|
||||
if st.Send(chunk) != nil { return } // 连接断开
|
||||
}
|
||||
st.Close() // 必须关闭
|
||||
}()
|
||||
return st, nil
|
||||
```
|
||||
|
||||
`Content-Type: application/x-ndjson`，每行一个 JSON；合法零消息流正常结束；
|
||||
业务出错在建流前返回普通 Result；`OnClose` 注册清理回调。
|
||||
|
||||
## 7. TS 客户端生成与请求上下文（v1.3.2 核心）
|
||||
|
||||
```go
|
||||
f := fun.GetFun()
|
||||
f.BindServiceForGen(&UserSvc{}) // 生成期专用：只反射注册方法，不装配任何基础设施
|
||||
fun.SetOutput("./frontend/src/api")
|
||||
fun.GenCode(fun.GenTs{})
|
||||
```
|
||||
|
||||
- `BindServiceForGen` 不触发 Box 装配，生成命令**不需要数据库/Redis 在运行**。
|
||||
- 生成确定性：service/method/imports 全部源端排序，重复生成字节一致。
|
||||
- 产物：`client.ts`（Client + `result<T>`）、每服务一个 `<service>.ts`、DTO/View 类型、
|
||||
`fun.ts`（`api.create(url)` 聚合入口，服务属性首字母小写）。
|
||||
|
||||
### 每调用选项（v1.3.2）
|
||||
|
||||
```ts
|
||||
export type RequestOptions = { signal?: AbortSignal; state?: Record<string, string> }
|
||||
export type StreamOptions = { signal?: AbortSignal; state?: Record<string, string> }
|
||||
|
||||
const r = await c.userSvc.profile({ signal: ctrl.signal })
|
||||
c.chatSvc.chat(dto, msg => {...}, { signal: ctrl.signal })
|
||||
```
|
||||
|
||||
- 调用方可传 `AbortSignal`；**框架自身不设任何请求/连接/空闲超时定时器**，
|
||||
超时由调用方或网关（nginx）决定，框架只负责把失败归一为 Result。
|
||||
- `state` 为每请求字符串字典：请求拦截器可写入（如会话纪元、请求标识），
|
||||
响应拦截器经 `context.requestState` 只读快照取回。
|
||||
|
||||
### 拦截器（v1.3.2 四参上下文形态）
|
||||
|
||||
```ts
|
||||
c.addRequestInterceptor((svc, m, state) => { state.epoch = myEpoch() })
|
||||
|
||||
c.addResponseInterceptor((svc, m, result, context) => {
|
||||
// context.requestState: Readonly<Record<string,string>>
|
||||
// context.response?: Response —— 原生 Response（头、状态码可读）
|
||||
})
|
||||
```
|
||||
|
||||
旧三参签名仍兼容。所有失败（网络、HTTP、HTML、非法 JSON、取消、拦截器异常）
|
||||
统一归一为 Result 并**必经响应拦截器**，不存在绕过拦截器的错误路径。
|
||||
|
||||
## 8. 依赖注入（box.go）
|
||||
|
||||
- `fun.Wired[T]()`：按 `*T` 建单例；先注入 `fun:"auto"` 字段（缺则递归创建），
|
||||
再调 `New()`（无参；连接类资源在此初始化，失败可 log.Fatalf）。
|
||||
- 启动顺序：先 `Wired` 基础配置/平台单例，再 `BindService`。
|
||||
|
||||
## 9. 常见坑
|
||||
|
||||
- DTO 用普通 `int`/float/map → 注册期 panic；用 int64/字符串/指针。
|
||||
- 非指针字段漏传 → 运行期 "must be a pointer or have a corresponding field"。
|
||||
- 流式忘记 `Close()` → 客户端挂起；连接断开后 `Send` 返回 error，循环须检查。
|
||||
- 方法首字母小写 = 不注册；客户端报 method not found。
|
||||
- vite 代理需重写前缀：`/api/cell → /cell`。
|
||||
- 生成用 `BindService`（而非 `BindServiceForGen`）会把基础设施拉起来 —— 生成命令请用后者。
|
||||
@@ -15,6 +15,16 @@ type Fun struct {
|
||||
boxes *sync.Map // 依赖容器：reflect.Type → reflect.Value
|
||||
guards []*any // 全局 Guard
|
||||
serviceGuards map[string][]*any // 服务级 Guard，按服务名
|
||||
bodyLimit int // 请求体上限（字节）；0 = fasthttp 默认 4MB
|
||||
}
|
||||
|
||||
// SetBodyLimit 设置请求体上限（字节），须在 Start 前调用。
|
||||
// multipart 上传等大请求体的自定义路由需要时设置；0 或负数恢复默认。
|
||||
func (f *Fun) SetBodyLimit(n int) {
|
||||
if n < 0 {
|
||||
n = 0
|
||||
}
|
||||
f.bodyLimit = n
|
||||
}
|
||||
|
||||
// wildcardRoute 通配符路由（BindRoute path 以 "/*" 结尾注册）：
|
||||
@@ -68,16 +78,7 @@ func GetFun() *Fun {
|
||||
//
|
||||
// guardList 为该服务绑定的 Guard，方法调用前按注册顺序执行
|
||||
func (f *Fun) BindService(service any, guardList ...Guard) {
|
||||
t := reflect.TypeOf(service)
|
||||
// 必须是指针指向的结构体，匿名类型无法注册
|
||||
if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct {
|
||||
panic("fun: BindService requires a pointer to a struct")
|
||||
}
|
||||
name := t.Elem().Name()
|
||||
if name == "" {
|
||||
panic("fun: BindService requires a named type")
|
||||
}
|
||||
|
||||
t, name := serviceType(service)
|
||||
boxWired(service, f)
|
||||
|
||||
serviceGuards := make([]*any, 0, len(guardList))
|
||||
@@ -86,7 +87,29 @@ func (f *Fun) BindService(service any, guardList ...Guard) {
|
||||
serviceGuards = append(serviceGuards, serviceGuardWired(guard, f))
|
||||
}
|
||||
f.serviceGuards[name] = serviceGuards
|
||||
f.bindServiceMethods(t, name)
|
||||
}
|
||||
|
||||
// BindServiceForGen registers service metadata for code generation without
|
||||
// constructing runtime dependencies or guards.
|
||||
func (f *Fun) BindServiceForGen(service any) {
|
||||
t, name := serviceType(service)
|
||||
f.bindServiceMethods(t, name)
|
||||
}
|
||||
|
||||
func serviceType(service any) (reflect.Type, string) {
|
||||
t := reflect.TypeOf(service)
|
||||
if t == nil || t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct {
|
||||
panic("fun: BindService requires a pointer to a struct")
|
||||
}
|
||||
name := t.Elem().Name()
|
||||
if name == "" {
|
||||
panic("fun: BindService requires a named type")
|
||||
}
|
||||
return t, name
|
||||
}
|
||||
|
||||
func (f *Fun) bindServiceMethods(t reflect.Type, name string) {
|
||||
for m := range t.Methods() {
|
||||
m := m
|
||||
// Ctx 命名持有 *fasthttp.RequestCtx（非嵌入），服务方法集只含业务方法，无需过滤提升方法
|
||||
@@ -159,9 +182,11 @@ func (f *Fun) callGuard(c *Ctx, serviceName string) {
|
||||
}
|
||||
|
||||
func (f *Fun) Start(port uint16) {
|
||||
addr := fmt.Sprintf(":%d", port)
|
||||
err := fasthttp.ListenAndServe(addr, f.handle)
|
||||
if err != nil {
|
||||
server := &fasthttp.Server{Handler: f.handle}
|
||||
if f.bodyLimit > 0 {
|
||||
server.MaxRequestBodySize = f.bodyLimit
|
||||
}
|
||||
if err := server.ListenAndServe(fmt.Sprintf(":%d", port)); err != nil {
|
||||
panic(err.Error())
|
||||
}
|
||||
}
|
||||
|
||||
@@ -93,6 +93,7 @@ func TestCheckDtoRequired(t *testing.T) {
|
||||
}
|
||||
|
||||
func TestGenCode(t *testing.T) {
|
||||
isolateGeneratorGlobals(t)
|
||||
GetFun().BindService(&TestSvc{})
|
||||
SetOutput(t.TempDir())
|
||||
GenCode(GenGo{}, GenTs{})
|
||||
|
||||
@@ -6,6 +6,7 @@ import (
|
||||
"path/filepath"
|
||||
"reflect"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strings"
|
||||
"text/template"
|
||||
)
|
||||
@@ -33,8 +34,8 @@ type genMethod struct {
|
||||
isStream bool
|
||||
}
|
||||
|
||||
// serviceGroups 按服务名分组已注册方法
|
||||
func (f *Fun) serviceGroups() map[string][]*genMethod {
|
||||
// serviceGroups 按服务名和方法名稳定分组已注册方法
|
||||
func (f *Fun) serviceGroups() []*genSvc {
|
||||
groups := map[string][]*genMethod{}
|
||||
for key, m := range f.methods {
|
||||
parts := strings.SplitN(key, ".", 2)
|
||||
@@ -47,7 +48,14 @@ func (f *Fun) serviceGroups() map[string][]*genMethod {
|
||||
isStream: m.isStream,
|
||||
})
|
||||
}
|
||||
return groups
|
||||
|
||||
services := make([]*genSvc, 0, len(groups))
|
||||
for name, methods := range groups {
|
||||
sort.Slice(methods, func(i, j int) bool { return methods[i].name < methods[j].name })
|
||||
services = append(services, &genSvc{name: name, methods: methods})
|
||||
}
|
||||
sort.Slice(services, func(i, j int) bool { return services[i].name < services[j].name })
|
||||
return services
|
||||
}
|
||||
|
||||
type genType struct {
|
||||
@@ -79,6 +87,7 @@ type genServiceType struct {
|
||||
GenMethodTypeList []*genMethodType
|
||||
GenImport []*genImportType
|
||||
IsIncludeProxy bool
|
||||
IsIncludeRequest bool
|
||||
IsIncludeStream bool
|
||||
}
|
||||
|
||||
@@ -103,6 +112,7 @@ func deduplicateServiceImports(imports []*genImportType) []*genImportType {
|
||||
result = append(result, imp)
|
||||
}
|
||||
}
|
||||
sort.Slice(result, func(i, j int) bool { return result[i].Name < result[j].Name })
|
||||
return result
|
||||
}
|
||||
|
||||
|
||||
@@ -132,13 +132,13 @@ func (ctx GenGo) genDefaultService() {
|
||||
f := GetFun()
|
||||
genContext := genType{GenServiceList: []*genServiceType{}}
|
||||
|
||||
for svcName, methods := range f.serviceGroups() {
|
||||
for _, svc := range f.serviceGroups() {
|
||||
serviceContext := &genServiceType{
|
||||
ServiceName: svcName,
|
||||
ServiceName: svc.name,
|
||||
GenMethodTypeList: []*genMethodType{},
|
||||
}
|
||||
genContext.GenServiceList = append(genContext.GenServiceList, serviceContext)
|
||||
ctx.genService(&genSvc{name: svcName, methods: methods}, serviceContext)
|
||||
ctx.genService(svc, serviceContext)
|
||||
}
|
||||
genCode(ctx.template.genDefaultServiceTemplate(), "fun", genContext, ctx.getName())
|
||||
}
|
||||
|
||||
@@ -0,0 +1,216 @@
|
||||
package fun
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"reflect"
|
||||
"sort"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
type AlphaGenDto struct {
|
||||
Value string
|
||||
}
|
||||
|
||||
type ZebraGenDto struct {
|
||||
Value string
|
||||
}
|
||||
|
||||
type AlphaGenSvc struct{}
|
||||
|
||||
func (*AlphaGenSvc) Zebra(dto ZebraGenDto) (AlphaGenDto, error) { return AlphaGenDto{}, nil }
|
||||
func (*AlphaGenSvc) Alpha(dto AlphaGenDto) (ZebraGenDto, error) { return ZebraGenDto{}, nil }
|
||||
func (*AlphaGenSvc) Ping() error { return nil }
|
||||
|
||||
type MixedGenSvc struct{}
|
||||
|
||||
func (*MixedGenSvc) Request() (string, error) { return "", nil }
|
||||
func (*MixedGenSvc) Stream() (*Stream, error) { return &Stream{}, nil }
|
||||
|
||||
type ZebraGenSvc struct{}
|
||||
|
||||
func (*ZebraGenSvc) Watch() (*Stream, error) { return &Stream{}, nil }
|
||||
|
||||
type GenOnlyDependency struct{}
|
||||
|
||||
func (*GenOnlyDependency) New() { panic("generation initialized a runtime dependency") }
|
||||
|
||||
type DependencyGenSvc struct {
|
||||
Dependency *GenOnlyDependency
|
||||
}
|
||||
|
||||
func (*DependencyGenSvc) Ping() error { return nil }
|
||||
|
||||
func isolateGeneratorGlobals(t *testing.T) {
|
||||
t.Helper()
|
||||
oldFun, oldDirectory := fun, directory
|
||||
fun = nil
|
||||
directory = "./gen"
|
||||
t.Cleanup(func() {
|
||||
fun = oldFun
|
||||
directory = oldDirectory
|
||||
})
|
||||
}
|
||||
|
||||
func generatedFiles(t *testing.T, root string) map[string]string {
|
||||
t.Helper()
|
||||
files := map[string]string{}
|
||||
err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if info.IsDir() {
|
||||
return nil
|
||||
}
|
||||
body, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
rel, err := filepath.Rel(root, path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
files[rel] = string(body)
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return files
|
||||
}
|
||||
|
||||
func TestBindServiceForGenDoesNotInitializeDependencies(t *testing.T) {
|
||||
isolateGeneratorGlobals(t)
|
||||
f := GetFun()
|
||||
f.BindServiceForGen(&DependencyGenSvc{})
|
||||
if _, ok := f.methods["DependencyGenSvc.Ping"]; !ok {
|
||||
t.Fatal("generation-only service method was not registered")
|
||||
}
|
||||
if _, ok := f.boxes.Load(reflect.TypeFor[*GenOnlyDependency]()); ok {
|
||||
t.Fatal("generation-only registration stored a runtime dependency")
|
||||
}
|
||||
}
|
||||
|
||||
func TestGeneratedTypeScriptSignaturesAndImports(t *testing.T) {
|
||||
isolateGeneratorGlobals(t)
|
||||
f := GetFun()
|
||||
f.BindService(&ZebraGenSvc{})
|
||||
f.BindService(&MixedGenSvc{})
|
||||
f.BindService(&AlphaGenSvc{})
|
||||
SetOutput(t.TempDir())
|
||||
GenCode(GenTs{})
|
||||
|
||||
read := func(name string) string {
|
||||
t.Helper()
|
||||
body, err := os.ReadFile(filepath.Join(getDirectory(), "ts", name))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return string(body)
|
||||
}
|
||||
|
||||
client := read("client.ts")
|
||||
for _, want := range []string{
|
||||
`state?: Record<string, string>;`,
|
||||
`export type ResponseContext = {`,
|
||||
`readonly requestState: Readonly<Record<string, string>>;`,
|
||||
`readonly response?: Response;`,
|
||||
`state = { ...this.state, ...options?.state };`,
|
||||
`interceptor(serviceName, methodName, current, context)`,
|
||||
} {
|
||||
if !strings.Contains(client, want) {
|
||||
t.Errorf("client.ts missing %q:\n%s", want, client)
|
||||
}
|
||||
}
|
||||
|
||||
alpha := read("alphaGenSvc.ts")
|
||||
if first := strings.SplitN(alpha, "\n", 2)[0]; first != `import { Client, type result, type RequestOptions } from "./client";` {
|
||||
t.Fatalf("unexpected request-only imports: %s", first)
|
||||
}
|
||||
for _, want := range []string{
|
||||
`async ping(options?: RequestOptions): Promise<result<void>>`,
|
||||
`this.client.request<void>("alphaGenSvc", "ping", undefined, options)`,
|
||||
`async alpha(dto:alphaGenDto, options?: RequestOptions): Promise<result<zebraGenDto>>`,
|
||||
`this.client.request<zebraGenDto>("alphaGenSvc", "alpha", dto, options)`,
|
||||
} {
|
||||
if !strings.Contains(alpha, want) {
|
||||
t.Errorf("alphaGenSvc.ts missing %q:\n%s", want, alpha)
|
||||
}
|
||||
}
|
||||
if strings.Index(alpha, `import type alphaGenDto`) > strings.Index(alpha, `import type zebraGenDto`) {
|
||||
t.Fatalf("DTO imports are not sorted:\n%s", alpha)
|
||||
}
|
||||
if strings.Index(alpha, `async alpha`) > strings.Index(alpha, `async ping`) ||
|
||||
strings.Index(alpha, `async ping`) > strings.Index(alpha, `async zebra`) {
|
||||
t.Fatalf("methods are not sorted:\n%s", alpha)
|
||||
}
|
||||
|
||||
stream := read("zebraGenSvc.ts")
|
||||
if first := strings.SplitN(stream, "\n", 2)[0]; first != `import { Client, type result, type StreamOptions } from "./client";` {
|
||||
t.Fatalf("unexpected stream-only imports: %s", first)
|
||||
}
|
||||
for _, want := range []string{
|
||||
`async watch(onMessage: (data: any) => unknown, options?: StreamOptions): Promise<result<void>>`,
|
||||
`this.client.stream<any>("zebraGenSvc", "watch", undefined, onMessage, options)`,
|
||||
} {
|
||||
if !strings.Contains(stream, want) {
|
||||
t.Errorf("zebraGenSvc.ts missing %q:\n%s", want, stream)
|
||||
}
|
||||
}
|
||||
|
||||
mixed := read("mixedGenSvc.ts")
|
||||
if first := strings.SplitN(mixed, "\n", 2)[0]; first != `import { Client, type result, type RequestOptions, type StreamOptions } from "./client";` {
|
||||
t.Fatalf("unexpected mixed imports: %s", first)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGeneratedSourcesAreDeterministic(t *testing.T) {
|
||||
isolateGeneratorGlobals(t)
|
||||
f := GetFun()
|
||||
f.BindService(&ZebraGenSvc{})
|
||||
f.BindService(&AlphaGenSvc{})
|
||||
f.BindService(&MixedGenSvc{})
|
||||
root := t.TempDir()
|
||||
SetOutput(root)
|
||||
GenCode(GenGo{}, GenTs{})
|
||||
first := generatedFiles(t, root)
|
||||
GenCode(GenGo{}, GenTs{})
|
||||
second := generatedFiles(t, root)
|
||||
if len(first) != len(second) {
|
||||
t.Fatalf("generated file count changed: %d != %d", len(first), len(second))
|
||||
}
|
||||
for name, body := range first {
|
||||
if second[name] != body {
|
||||
t.Errorf("generated file changed between runs: %s", name)
|
||||
}
|
||||
}
|
||||
|
||||
tsFun := first[filepath.Join("ts", "fun.ts")]
|
||||
positions := []int{
|
||||
strings.Index(tsFun, `import alphaGenSvc`),
|
||||
strings.Index(tsFun, `import mixedGenSvc`),
|
||||
strings.Index(tsFun, `import zebraGenSvc`),
|
||||
}
|
||||
if !sort.IntsAreSorted(positions) || positions[0] < 0 {
|
||||
t.Fatalf("TypeScript services are not sorted:\n%s", tsFun)
|
||||
}
|
||||
goFun := first[filepath.Join("go", "fun.go")]
|
||||
positions = []int{
|
||||
strings.Index(goFun, "AlphaGenSvc *AlphaGenSvc"),
|
||||
strings.Index(goFun, "MixedGenSvc *MixedGenSvc"),
|
||||
strings.Index(goFun, "ZebraGenSvc *ZebraGenSvc"),
|
||||
}
|
||||
if !sort.IntsAreSorted(positions) || positions[0] < 0 {
|
||||
t.Fatalf("Go services are not sorted:\n%s", goFun)
|
||||
}
|
||||
goService := first[filepath.Join("go", "alpha_gen_svc.go")]
|
||||
positions = []int{
|
||||
strings.Index(goService, "func (ctx *AlphaGenSvc) Alpha("),
|
||||
strings.Index(goService, "func (ctx *AlphaGenSvc) Ping("),
|
||||
strings.Index(goService, "func (ctx *AlphaGenSvc) Zebra("),
|
||||
}
|
||||
if !sort.IntsAreSorted(positions) || positions[0] < 0 {
|
||||
t.Fatalf("Go methods are not sorted:\n%s", goService)
|
||||
}
|
||||
}
|
||||
@@ -56,6 +56,7 @@ func (ctx GenTs) genService(svc *genSvc, serviceContext *genServiceType) {
|
||||
argsText += ",dto"
|
||||
nestedImports = append(nestedImports, ctx.genStruct(gm.dtoType))
|
||||
}
|
||||
serviceContext.IsIncludeRequest = true
|
||||
serviceContext.GenMethodTypeList = append(serviceContext.GenMethodTypeList, &genMethodType{
|
||||
MethodName: firstLetterToLower(gm.name),
|
||||
ReturnValueText: returnValueText,
|
||||
@@ -83,6 +84,7 @@ func (ctx GenTs) genService(svc *genSvc, serviceContext *genServiceType) {
|
||||
nestedImports = ctx.genReturnTypes(returnType, nestedImports)
|
||||
}
|
||||
} else {
|
||||
serviceContext.IsIncludeRequest = true
|
||||
t := firstLetterToLower(ctx.typeToTemplateType(returnType))
|
||||
if !strings.Contains(t, "[]") && strings.Contains(t, "[") {
|
||||
returnValueText = getGenericTypeName(t) + parseGenericTypeParams(t)
|
||||
@@ -151,13 +153,13 @@ func (ctx GenTs) genDefaultService() {
|
||||
f := GetFun()
|
||||
genContext := genType{GenServiceList: []*genServiceType{}}
|
||||
|
||||
for svcName, methods := range f.serviceGroups() {
|
||||
for _, svc := range f.serviceGroups() {
|
||||
serviceContext := &genServiceType{
|
||||
ServiceName: firstLetterToLower(svcName),
|
||||
ServiceName: firstLetterToLower(svc.name),
|
||||
GenMethodTypeList: []*genMethodType{},
|
||||
}
|
||||
genContext.GenServiceList = append(genContext.GenServiceList, serviceContext)
|
||||
ctx.genService(&genSvc{name: svcName, methods: methods}, serviceContext)
|
||||
ctx.genService(svc, serviceContext)
|
||||
}
|
||||
genCode(ctx.template.genClientTemplate(), "client", nil, ctx.getName())
|
||||
genCode(ctx.template.genDefaultServiceTemplate(), "fun", genContext, ctx.getName())
|
||||
|
||||
@@ -0,0 +1,109 @@
|
||||
package fun
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"net"
|
||||
"net/http"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/valyala/fasthttp"
|
||||
)
|
||||
|
||||
type ProtocolStreamSvc struct{}
|
||||
|
||||
func (*ProtocolStreamSvc) Empty() (*Stream, error) {
|
||||
stream := &Stream{}
|
||||
go stream.Close()
|
||||
return stream, nil
|
||||
}
|
||||
|
||||
func (*ProtocolStreamSvc) Before() (*Stream, error) {
|
||||
return nil, errors.New("before stream")
|
||||
}
|
||||
|
||||
func (*ProtocolStreamSvc) Business() (*Stream, error) {
|
||||
return nil, Error(4201, "business before stream")
|
||||
}
|
||||
|
||||
func serveFun(t *testing.T, f *Fun) string {
|
||||
t.Helper()
|
||||
listener, err := net.Listen("tcp", "127.0.0.1:0")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
done := make(chan error, 1)
|
||||
go func() { done <- fasthttp.Serve(listener, f.handle) }()
|
||||
t.Cleanup(func() {
|
||||
_ = listener.Close()
|
||||
<-done
|
||||
})
|
||||
return "http://" + listener.Addr().String()
|
||||
}
|
||||
|
||||
func streamPost(t *testing.T, url, method string) (*http.Response, []byte) {
|
||||
t.Helper()
|
||||
body := strings.NewReader(`{"serviceName":"ProtocolStreamSvc","methodName":"` + method + `"}`)
|
||||
request, err := http.NewRequest(http.MethodPost, url+"/cell", body)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
request.Header.Set("Content-Type", "application/json")
|
||||
request.Close = true
|
||||
response, err := http.DefaultClient.Do(request)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer response.Body.Close()
|
||||
data, err := io.ReadAll(response.Body)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return response, data
|
||||
}
|
||||
|
||||
func TestServerStreamContentTypeAndEmptyStream(t *testing.T) {
|
||||
f := New()
|
||||
f.BindService(&ProtocolStreamSvc{})
|
||||
response, body := streamPost(t, serveFun(t, f), "Empty")
|
||||
if got := response.Header.Get("Content-Type"); got != "application/x-ndjson" {
|
||||
t.Fatalf("Content-Type = %q", got)
|
||||
}
|
||||
if len(body) != 0 {
|
||||
t.Fatalf("empty stream returned %q", body)
|
||||
}
|
||||
}
|
||||
|
||||
func TestServerStreamSetupErrorsUseResultProtocol(t *testing.T) {
|
||||
f := New()
|
||||
f.BindService(&ProtocolStreamSvc{})
|
||||
url := serveFun(t, f)
|
||||
for _, test := range []struct {
|
||||
method string
|
||||
status uint8
|
||||
code uint16
|
||||
msg string
|
||||
}{
|
||||
{method: "Before", status: 1, msg: "before stream"},
|
||||
{method: "Business", status: 2, code: 4201, msg: "business before stream"},
|
||||
} {
|
||||
t.Run(test.method, func(t *testing.T) {
|
||||
response, body := streamPost(t, url, test.method)
|
||||
if strings.HasPrefix(response.Header.Get("Content-Type"), "application/x-ndjson") {
|
||||
t.Fatalf("setup error used stream Content-Type: %q", response.Header.Get("Content-Type"))
|
||||
}
|
||||
var result Result[any]
|
||||
if err := json.Unmarshal(body, &result); err != nil {
|
||||
t.Fatalf("invalid Result body %q: %v", body, err)
|
||||
}
|
||||
if result.Status != test.status || result.Msg == nil || *result.Msg != test.msg {
|
||||
t.Fatalf("unexpected Result: %+v", result)
|
||||
}
|
||||
if test.code != 0 && (result.Code == nil || *result.Code != test.code) {
|
||||
t.Fatalf("code = %v, want %d", result.Code, test.code)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
+490
-53
@@ -12,7 +12,17 @@ func (ctx templateTs) genClientTemplate() string {
|
||||
};
|
||||
|
||||
export type resultStatus = 0 | 1 | 2 | 4 | 5;
|
||||
// 0 成功；1 框架错误；2 业务错误；4 网络错误；5 超时
|
||||
// 0 success; 1 framework/client protocol error; 2 business error; 4 external request error; 5 external timeout
|
||||
|
||||
export type RequestOptions = {
|
||||
signal?: AbortSignal;
|
||||
state?: Record<string, string>;
|
||||
};
|
||||
|
||||
export type StreamOptions = {
|
||||
signal?: AbortSignal;
|
||||
state?: Record<string, string>;
|
||||
};
|
||||
|
||||
export type RequestInterceptor = (
|
||||
serviceName: string,
|
||||
@@ -21,18 +31,127 @@ export type RequestInterceptor = (
|
||||
dto?: any
|
||||
) => Promise<void> | void;
|
||||
|
||||
// 返回新 result 将替换原结果继续向下传递（可用于集中换 token / 错误处理）
|
||||
export type ResponseContext = {
|
||||
readonly requestState: Readonly<Record<string, string>>;
|
||||
readonly response?: Response;
|
||||
};
|
||||
|
||||
export type ResponseInterceptor = (
|
||||
serviceName: string,
|
||||
methodName: string,
|
||||
result: result<any>
|
||||
) => Promise<result<any> | void> | result<any> | void;
|
||||
|
||||
export type ContextResponseInterceptor = (
|
||||
serviceName: string,
|
||||
methodName: string,
|
||||
result: result<any>,
|
||||
context: ResponseContext
|
||||
) => Promise<result<any> | void> | result<any> | void;
|
||||
|
||||
function messageOf(error: unknown): string {
|
||||
if (error instanceof Error && error.message) return error.message;
|
||||
if (typeof error === "string" && error) return error;
|
||||
return "unknown error";
|
||||
}
|
||||
|
||||
function failure(status: resultStatus, msg: string): result<any> {
|
||||
return { status, msg };
|
||||
}
|
||||
|
||||
function isTimeout(error: unknown, signal?: AbortSignal): boolean {
|
||||
const errorName = error !== null && typeof error === "object"
|
||||
? (error as { name?: unknown }).name
|
||||
: undefined;
|
||||
const reason = signal?.reason;
|
||||
const reasonName = reason !== null && typeof reason === "object"
|
||||
? (reason as { name?: unknown }).name
|
||||
: undefined;
|
||||
return errorName === "TimeoutError" || reasonName === "TimeoutError";
|
||||
}
|
||||
|
||||
function requestFailure(error: unknown, signal: AbortSignal | undefined, stream: boolean): result<any> {
|
||||
if (isTimeout(error, signal)) {
|
||||
return failure(5, stream ? "Stream timed out" : "Request timed out");
|
||||
}
|
||||
if (signal?.aborted === true) {
|
||||
return failure(4, stream ? "Stream aborted" : "Request aborted");
|
||||
}
|
||||
const kind = stream ? "External stream request" : "External request";
|
||||
return failure(4, ` + "`${kind} failed: ${messageOf(error)}`" + `);
|
||||
}
|
||||
|
||||
function isResult(value: unknown): value is result<any> {
|
||||
return value !== null && typeof value === "object" &&
|
||||
typeof (value as { status?: unknown }).status === "number";
|
||||
}
|
||||
|
||||
function mediaType(response: Response): string {
|
||||
return (response.headers.get("content-type") || "").split(";", 1)[0].trim().toLowerCase();
|
||||
}
|
||||
|
||||
function excerpt(text: string, limit = 180): string {
|
||||
const value = text.replace(/\s+/g, " ").trim();
|
||||
return value.length <= limit ? value : ` + "`${value.slice(0, limit)}...`" + `;
|
||||
}
|
||||
|
||||
function externalFailure(response: Response, detail?: string): result<any> {
|
||||
const timeout = response.status === 408 || response.status === 504;
|
||||
const statusText = response.statusText || (timeout ? "timeout" : "request failed");
|
||||
const suffix = detail ? ` + "`: ${detail}`" + ` : "";
|
||||
return failure(timeout ? 5 : 4, ` + "`HTTP ${response.status} ${statusText}${suffix}`" + `);
|
||||
}
|
||||
|
||||
function responseReadFailure(
|
||||
error: unknown,
|
||||
response: Response,
|
||||
signal: AbortSignal | undefined,
|
||||
stream: boolean
|
||||
): result<any> {
|
||||
if (isTimeout(error, signal)) {
|
||||
return failure(5, stream ? "Stream timed out" : "Request timed out");
|
||||
}
|
||||
if (signal?.aborted === true) {
|
||||
return failure(4, stream ? "Stream aborted" : "Request aborted");
|
||||
}
|
||||
const kind = stream ? "Stream" : "Response body";
|
||||
return response.ok
|
||||
? failure(4, ` + "`${kind} failed: ${messageOf(error)}`" + `)
|
||||
: externalFailure(response, ` + "`response body failed: ${messageOf(error)}`" + `);
|
||||
}
|
||||
|
||||
function parseResult(response: Response, text: string): result<any> {
|
||||
const body = text.trim();
|
||||
if (!body) {
|
||||
return response.ok
|
||||
? failure(1, "Empty response body")
|
||||
: externalFailure(response);
|
||||
}
|
||||
|
||||
let value: unknown;
|
||||
try {
|
||||
value = JSON.parse(body);
|
||||
} catch {
|
||||
if (!response.ok) return externalFailure(response, excerpt(body));
|
||||
const type = mediaType(response);
|
||||
if (type === "text/html" || /^\s*(?:<!doctype\s+html|<html\b)/i.test(body)) {
|
||||
return failure(1, ` + "`Unexpected HTML response: ${excerpt(body)}`" + `);
|
||||
}
|
||||
return failure(1, ` + "`Invalid JSON response: ${excerpt(body)}`" + `);
|
||||
}
|
||||
if (!isResult(value)) {
|
||||
return response.ok
|
||||
? failure(1, "Invalid fun response")
|
||||
: externalFailure(response, "invalid fun response");
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
export class Client {
|
||||
private url: string;
|
||||
private state: Record<string, string> = {};
|
||||
private requestInterceptors: RequestInterceptor[] = [];
|
||||
private responseInterceptors: ResponseInterceptor[] = [];
|
||||
private responseInterceptors: ContextResponseInterceptor[] = [];
|
||||
|
||||
constructor(url: string) {
|
||||
this.url = url.replace(/\/+$/, "");
|
||||
@@ -42,81 +161,399 @@ export class Client {
|
||||
this.state = state;
|
||||
}
|
||||
|
||||
addRequestInterceptor(i: RequestInterceptor) {
|
||||
this.requestInterceptors.push(i);
|
||||
addRequestInterceptor(interceptor: RequestInterceptor) {
|
||||
this.requestInterceptors.push(interceptor);
|
||||
}
|
||||
|
||||
addResponseInterceptor(i: ResponseInterceptor) {
|
||||
this.responseInterceptors.push(i);
|
||||
addResponseInterceptor(interceptor: ResponseInterceptor): void;
|
||||
addResponseInterceptor(interceptor: ContextResponseInterceptor): void;
|
||||
addResponseInterceptor(interceptor: ResponseInterceptor | ContextResponseInterceptor) {
|
||||
this.responseInterceptors.push(interceptor as ContextResponseInterceptor);
|
||||
}
|
||||
|
||||
async request<T>(serviceName: string, methodName: string, dto?: any): Promise<result<T>> {
|
||||
const state: Record<string, string> = { ...this.state };
|
||||
for (const i of this.requestInterceptors) {
|
||||
await i(serviceName, methodName, state, dto);
|
||||
}
|
||||
let out: result<T>;
|
||||
private async interceptResponse(
|
||||
serviceName: string,
|
||||
methodName: string,
|
||||
initial: result<any>,
|
||||
requestState: Readonly<Record<string, string>>,
|
||||
response?: Response
|
||||
): Promise<result<any>> {
|
||||
let current = initial;
|
||||
const context: ResponseContext = Object.freeze(
|
||||
response === undefined ? { requestState } : { requestState, response }
|
||||
);
|
||||
for (const interceptor of this.responseInterceptors) {
|
||||
try {
|
||||
const res = await fetch(this.url + "/cell", {
|
||||
const replaced = await interceptor(serviceName, methodName, current, context);
|
||||
if (replaced) current = replaced;
|
||||
} catch (error) {
|
||||
current = failure(1, ` + "`Response interceptor failed: ${messageOf(error)}`" + `);
|
||||
}
|
||||
}
|
||||
return current;
|
||||
}
|
||||
|
||||
private async interceptRequest(
|
||||
serviceName: string,
|
||||
methodName: string,
|
||||
state: Record<string, string>,
|
||||
dto: any
|
||||
): Promise<void> {
|
||||
for (const interceptor of this.requestInterceptors) {
|
||||
await interceptor(serviceName, methodName, state, dto);
|
||||
}
|
||||
}
|
||||
|
||||
private snapshotState(state: Record<string, string>): Readonly<Record<string, string>> {
|
||||
return Object.freeze({ ...state });
|
||||
}
|
||||
|
||||
async request<T>(
|
||||
serviceName: string,
|
||||
methodName: string,
|
||||
dto?: any,
|
||||
options?: RequestOptions
|
||||
): Promise<result<T>> {
|
||||
let state: Record<string, string>;
|
||||
try {
|
||||
state = { ...this.state, ...options?.state };
|
||||
} catch (error) {
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
failure(1, ` + "`Could not prepare request state: ${messageOf(error)}`" + `),
|
||||
Object.freeze({})
|
||||
) as result<T>;
|
||||
}
|
||||
try {
|
||||
await this.interceptRequest(serviceName, methodName, state, dto);
|
||||
} catch (error) {
|
||||
let requestState: Readonly<Record<string, string>>;
|
||||
try {
|
||||
requestState = this.snapshotState(state);
|
||||
} catch (snapshotError) {
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
failure(1, ` + "`Could not snapshot request state: ${messageOf(snapshotError)}`" + `),
|
||||
Object.freeze({})
|
||||
) as result<T>;
|
||||
}
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
failure(1, ` + "`Request interceptor failed: ${messageOf(error)}`" + `),
|
||||
requestState
|
||||
) as result<T>;
|
||||
}
|
||||
let requestState: Readonly<Record<string, string>>;
|
||||
try {
|
||||
requestState = this.snapshotState(state);
|
||||
} catch (error) {
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
failure(1, ` + "`Could not snapshot request state: ${messageOf(error)}`" + `),
|
||||
Object.freeze({})
|
||||
) as result<T>;
|
||||
}
|
||||
|
||||
let body: string;
|
||||
try {
|
||||
const serialized = JSON.stringify({
|
||||
serviceName,
|
||||
methodName,
|
||||
data: dto,
|
||||
...(Object.keys(requestState).length ? { state: requestState } : {}),
|
||||
});
|
||||
if (serialized === undefined) throw new Error("serialization produced no output");
|
||||
body = serialized;
|
||||
} catch (error) {
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
failure(1, ` + "`Could not serialize request: ${messageOf(error)}`" + `),
|
||||
requestState
|
||||
) as result<T>;
|
||||
}
|
||||
|
||||
let output: result<any>;
|
||||
let response: Response | undefined;
|
||||
try {
|
||||
response = await fetch(` + "`${this.url}/cell`" + `, {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify({ serviceName, methodName, data: dto, ...(Object.keys(state).length ? { state } : {}) }),
|
||||
body,
|
||||
signal: options?.signal,
|
||||
});
|
||||
out = (await res.json()) as result<T>;
|
||||
} catch (e: any) {
|
||||
out = { status: 4, msg: (e && e.message) || "网络错误" } as result<T>;
|
||||
try {
|
||||
output = parseResult(response, await response.text());
|
||||
} catch (error) {
|
||||
output = responseReadFailure(error, response, options?.signal, false);
|
||||
}
|
||||
let cur: result<any> = out as result<any>;
|
||||
for (const i of this.responseInterceptors) {
|
||||
const replaced = await i(serviceName, methodName, cur);
|
||||
if (replaced) cur = replaced;
|
||||
} catch (error) {
|
||||
output = requestFailure(error, options?.signal, false);
|
||||
}
|
||||
return cur as result<T>;
|
||||
return await this.interceptResponse(serviceName, methodName, output, requestState, response) as result<T>;
|
||||
}
|
||||
|
||||
async stream<T>(
|
||||
serviceName: string,
|
||||
methodName: string,
|
||||
dto: any | undefined,
|
||||
onMessage: (data: T) => void
|
||||
): Promise<void> {
|
||||
const state: Record<string, string> = { ...this.state };
|
||||
for (const i of this.requestInterceptors) {
|
||||
await i(serviceName, methodName, state, dto);
|
||||
onMessage: (data: T) => unknown,
|
||||
options?: StreamOptions
|
||||
): Promise<result<void>> {
|
||||
let state: Record<string, string>;
|
||||
try {
|
||||
state = { ...this.state, ...options?.state };
|
||||
} catch (error) {
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
failure(1, ` + "`Could not prepare request state: ${messageOf(error)}`" + `),
|
||||
Object.freeze({})
|
||||
);
|
||||
}
|
||||
const res = await fetch(this.url + "/cell", {
|
||||
try {
|
||||
await this.interceptRequest(serviceName, methodName, state, dto);
|
||||
} catch (error) {
|
||||
let requestState: Readonly<Record<string, string>>;
|
||||
try {
|
||||
requestState = this.snapshotState(state);
|
||||
} catch (snapshotError) {
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
failure(1, ` + "`Could not snapshot request state: ${messageOf(snapshotError)}`" + `),
|
||||
Object.freeze({})
|
||||
);
|
||||
}
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
failure(1, ` + "`Request interceptor failed: ${messageOf(error)}`" + `),
|
||||
requestState
|
||||
);
|
||||
}
|
||||
let requestState: Readonly<Record<string, string>>;
|
||||
try {
|
||||
requestState = this.snapshotState(state);
|
||||
} catch (error) {
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
failure(1, ` + "`Could not snapshot request state: ${messageOf(error)}`" + `),
|
||||
Object.freeze({})
|
||||
);
|
||||
}
|
||||
|
||||
let body: string;
|
||||
try {
|
||||
const serialized = JSON.stringify({
|
||||
serviceName,
|
||||
methodName,
|
||||
data: dto,
|
||||
...(Object.keys(requestState).length ? { state: requestState } : {}),
|
||||
});
|
||||
if (serialized === undefined) throw new Error("serialization produced no output");
|
||||
body = serialized;
|
||||
} catch (error) {
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
failure(1, ` + "`Could not serialize request: ${messageOf(error)}`" + `),
|
||||
requestState
|
||||
);
|
||||
}
|
||||
|
||||
let response: Response;
|
||||
try {
|
||||
response = await fetch(` + "`${this.url}/cell`" + `, {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify({ serviceName, methodName, data: dto, ...(Object.keys(state).length ? { state } : {}) }),
|
||||
body,
|
||||
signal: options?.signal,
|
||||
});
|
||||
if (!res.ok) return;
|
||||
const anyResult: result<any> = { status: 0 };
|
||||
for (const i of this.responseInterceptors) {
|
||||
await i(serviceName, methodName, anyResult);
|
||||
} catch (error) {
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
requestFailure(error, options?.signal, true),
|
||||
requestState
|
||||
);
|
||||
}
|
||||
if (!res.body) return;
|
||||
const reader = res.body.getReader();
|
||||
const decoder = new TextDecoder();
|
||||
|
||||
if (!response.ok) {
|
||||
let text: string;
|
||||
try {
|
||||
text = await response.text();
|
||||
} catch (error) {
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
responseReadFailure(error, response, options?.signal, true),
|
||||
requestState,
|
||||
response
|
||||
);
|
||||
}
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
parseResult(response, text),
|
||||
requestState,
|
||||
response
|
||||
);
|
||||
}
|
||||
|
||||
if (mediaType(response) !== "application/x-ndjson") {
|
||||
let text: string;
|
||||
try {
|
||||
text = await response.text();
|
||||
} catch (error) {
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
responseReadFailure(error, response, options?.signal, true),
|
||||
requestState,
|
||||
response
|
||||
);
|
||||
}
|
||||
const rpcResult = parseResult(response, text);
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
rpcResult.status === 0
|
||||
? failure(1, "Expected application/x-ndjson response")
|
||||
: rpcResult,
|
||||
requestState,
|
||||
response
|
||||
);
|
||||
}
|
||||
|
||||
if (!response.body) {
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
{ status: 0 },
|
||||
requestState,
|
||||
response
|
||||
);
|
||||
}
|
||||
|
||||
let reader: ReadableStreamDefaultReader<Uint8Array>;
|
||||
try {
|
||||
reader = response.body.getReader();
|
||||
} catch (error) {
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
responseReadFailure(error, response, options?.signal, true),
|
||||
requestState,
|
||||
response
|
||||
);
|
||||
}
|
||||
const decoder = new TextDecoder("utf-8", { fatal: true });
|
||||
let buffer = "";
|
||||
let lineNumber = 0;
|
||||
let failed: result<any> | undefined;
|
||||
let cause: unknown;
|
||||
|
||||
const emitLine = async (line: string) => {
|
||||
const payload = line.replace(/\r$/, "").trim();
|
||||
if (!payload) return;
|
||||
let data: T;
|
||||
try {
|
||||
data = JSON.parse(payload) as T;
|
||||
} catch (error) {
|
||||
failed = failure(1, ` + "`Invalid NDJSON at line ${lineNumber}: ${excerpt(payload)}`" + `);
|
||||
cause = error;
|
||||
return;
|
||||
}
|
||||
try {
|
||||
await onMessage(data);
|
||||
} catch (error) {
|
||||
failed = failure(1, ` + "`Stream callback failed: ${messageOf(error)}`" + `);
|
||||
cause = error;
|
||||
}
|
||||
};
|
||||
|
||||
try {
|
||||
for (;;) {
|
||||
const { done, value } = await reader.read();
|
||||
if (done) break;
|
||||
buffer += decoder.decode(value, { stream: true });
|
||||
const lines = buffer.split("\n");
|
||||
buffer = lines.pop() ?? "";
|
||||
for (const line of lines) {
|
||||
const payload = line.trim();
|
||||
if (!payload) continue;
|
||||
const data = JSON.parse(payload) as T;
|
||||
onMessage(data);
|
||||
let part: ReadableStreamReadResult<Uint8Array>;
|
||||
try {
|
||||
part = await reader.read();
|
||||
} catch (error) {
|
||||
cause = error;
|
||||
if (isTimeout(error, options?.signal)) {
|
||||
failed = failure(5, "Stream timed out");
|
||||
} else if (options?.signal?.aborted === true) {
|
||||
failed = failure(4, "Stream aborted");
|
||||
} else {
|
||||
failed = failure(4, ` + "`Stream read failed: ${messageOf(error)}`" + `);
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (part.done) break;
|
||||
try {
|
||||
buffer += decoder.decode(part.value, { stream: true });
|
||||
} catch (error) {
|
||||
failed = failure(1, ` + "`Invalid UTF-8 stream data: ${messageOf(error)}`" + `);
|
||||
cause = error;
|
||||
break;
|
||||
}
|
||||
for (;;) {
|
||||
const newline = buffer.indexOf("\n");
|
||||
if (newline < 0) break;
|
||||
const line = buffer.slice(0, newline);
|
||||
buffer = buffer.slice(newline + 1);
|
||||
lineNumber++;
|
||||
await emitLine(line);
|
||||
if (failed) break;
|
||||
}
|
||||
if (failed) break;
|
||||
}
|
||||
|
||||
if (!failed) {
|
||||
try {
|
||||
buffer += decoder.decode();
|
||||
} catch (error) {
|
||||
failed = failure(1, ` + "`Invalid UTF-8 stream data: ${messageOf(error)}`" + `);
|
||||
cause = error;
|
||||
}
|
||||
}
|
||||
if (!failed && buffer.length > 0) {
|
||||
lineNumber++;
|
||||
await emitLine(buffer);
|
||||
}
|
||||
|
||||
} finally {
|
||||
if (failed) {
|
||||
try {
|
||||
await reader.cancel(cause);
|
||||
} catch {
|
||||
// The reader may already be closed by the runtime.
|
||||
}
|
||||
}
|
||||
try {
|
||||
reader.releaseLock();
|
||||
} catch {
|
||||
// The reader may already be errored or released.
|
||||
}
|
||||
}
|
||||
return await this.interceptResponse(
|
||||
serviceName,
|
||||
methodName,
|
||||
failed || { status: 0 },
|
||||
requestState,
|
||||
response
|
||||
);
|
||||
}
|
||||
}`
|
||||
}
|
||||
|
||||
func (ctx templateTs) genDefaultServiceTemplate() string {
|
||||
return `import { Client, type result } from "./client";
|
||||
return `import { Client } from "./client";
|
||||
{{- range .GenServiceList}}
|
||||
import {{.ServiceName}} from "./{{.ServiceName}}";
|
||||
{{- end}}
|
||||
@@ -138,7 +575,7 @@ export default class api {
|
||||
}
|
||||
|
||||
func (ctx templateTs) genServiceTemplate() string {
|
||||
return `import { Client, type result } from "./client"
|
||||
return `import { Client{{if .IsIncludeRequest}}, type result, type RequestOptions{{end}}{{if .IsIncludeStream}}{{if not .IsIncludeRequest}}, type result{{end}}, type StreamOptions{{end}} } from "./client";
|
||||
{{- range .GenImport}}
|
||||
import type {{.Name}} from "./{{.Name}}";
|
||||
{{- end}}
|
||||
@@ -150,10 +587,10 @@ export default class {{.ServiceName}} {
|
||||
}
|
||||
{{- $serviceName := .ServiceName }}
|
||||
{{- range .GenMethodTypeList}}
|
||||
{{if .IsStream }}async {{.MethodName}}({{.DtoText}}{{if .DtoText}},{{end}}onMessage: (data: {{.GenericTypeText}}) => void): Promise<void> {
|
||||
return await this.client.stream<{{.GenericTypeText}}>("{{$serviceName}}", "{{.MethodName}}", {{if .DtoText}}dto{{else}}undefined{{end}}, onMessage)
|
||||
}{{else}}async {{.MethodName}}({{.DtoText}}): Promise<{{.ReturnValueText}}> {
|
||||
return await this.client.request<{{.GenericTypeText}}>("{{$serviceName}}", "{{.MethodName}}"{{.ArgsText}})
|
||||
{{if .IsStream }}async {{.MethodName}}({{if .DtoText}}{{.DtoText}}, {{end}}onMessage: (data: {{.GenericTypeText}}) => unknown, options?: StreamOptions): Promise<result<void>> {
|
||||
return await this.client.stream<{{.GenericTypeText}}>("{{$serviceName}}", "{{.MethodName}}", {{if .DtoText}}dto{{else}}undefined{{end}}, onMessage, options)
|
||||
}{{else}}async {{.MethodName}}({{if .DtoText}}{{.DtoText}}, {{end}}options?: RequestOptions): Promise<{{.ReturnValueText}}> {
|
||||
return await this.client.request<{{.GenericTypeText}}>("{{$serviceName}}", "{{.MethodName}}", {{if .DtoText}}dto{{else}}undefined{{end}}, options)
|
||||
}{{end}}
|
||||
{{- end}}
|
||||
}`
|
||||
|
||||
Reference in New Issue
Block a user