Reorganize repo structure and standards references

This commit is contained in:
david committed 2026-06-29 05:03:42 +02:00
1 parent 3cb93a81be
commit be2054274d
5885 files changed
+2588 -195

No files matched your search

@@ -0,0 +1,185 @@
import { describe, expect, it } from "vitest";
import { getAuthToken } from "./generated/core/auth.gen.js";
import { createClient } from "./generated/client/client.gen.js";
import {
buildUrl,
createConfig,
createInterceptors,
createQuerySerializer,
getParseAs,
mergeConfigs,
mergeHeaders,
setAuthParams,
} from "./generated/client/utils.gen.js";
describe("generated auth helpers", () => {
it("formats auth tokens by security scheme", async () => {
await expect(getAuthToken({ scheme: "bearer", type: "http" }, "jwt")).resolves.toBe("Bearer jwt");
await expect(getAuthToken({ scheme: "basic", type: "http" }, "user:pass")).resolves.toBe(`Basic ${btoa("user:pass")}`);
await expect(getAuthToken({ in: "query", name: "api_key", type: "apiKey" }, () => "key")).resolves.toBe("key");
await expect(getAuthToken({ type: "apiKey" }, undefined)).resolves.toBeUndefined();
});
});
describe("generated client utilities", () => {
it("serializes query parameters with global and per-parameter overrides", () => {
const querySerializer = createQuerySerializer({
allowReserved: true,
array: { explode: false, style: "pipeDelimited" },
object: { explode: false, style: "form" },
parameters: {
ids: { allowReserved: false, array: { explode: true, style: "form" } },
},
});
expect(
querySerializer({
filter: { owner: "ops/team", status: "open" },
ids: ["a/b", "c"],
q: "a/b",
skipped: undefined,
})
).toBe("filter=owner,ops/team,status,open&ids=a%2Fb&ids=c&q=a/b");
});
it("infers response parsing from content type", () => {
expect(getParseAs(null)).toBe("stream");
expect(getParseAs("application/problem+json; charset=utf-8")).toBe("json");
expect(getParseAs("multipart/form-data; boundary=x")).toBe("formData");
expect(getParseAs("image/png")).toBe("blob");
expect(getParseAs("text/csv")).toBe("text");
expect(getParseAs("")).toBe("stream");
expect(getParseAs("x-custom/value")).toBeUndefined();
});
it("sets auth in headers, query params, and cookies without overwriting existing values", async () => {
const headers = new Headers({ Authorization: "Bearer existing", Cookie: "session=abc" });
const query = { api_key: "existing" };
await setAuthParams({
auth: ({ name }) => `token-for-${name ?? "default"}`,
headers,
query,
security: [
{ in: "header", name: "Authorization", scheme: "bearer", type: "http" },
{ in: "query", name: "api_key", type: "apiKey" },
{ in: "cookie", name: "csrf", type: "apiKey" },
{ in: "header", name: "X-New-Token", type: "apiKey" },
],
});
expect(headers.get("Authorization")).toBe("Bearer existing");
expect(query.api_key).toBe("existing");
expect(headers.get("Cookie")).toBe("session=abc; csrf=token-for-csrf");
expect(headers.get("X-New-Token")).toBe("token-for-X-New-Token");
});
it("merges config and headers while honoring removals", () => {
const mergedHeaders = mergeHeaders(
{ Accept: "application/json", "X-List": ["a", "b"], "X-Json": { ok: true } },
new Headers({ Accept: "text/plain" }),
{ "X-Json": null, "X-Skip": undefined }
);
expect(mergedHeaders.get("Accept")).toBe("text/plain");
expect(mergedHeaders.get("X-List")).toBe("a, b");
expect(mergedHeaders.has("X-Json")).toBe(false);
const config = mergeConfigs({ baseUrl: "https://api.example.test/", headers: { A: "1" } }, { headers: { B: "2" } });
const configHeaders = config.headers as Headers;
expect(config.baseUrl).toBe("https://api.example.test");
expect(configHeaders.get("A")).toBe("1");
expect(configHeaders.get("B")).toBe("2");
});
it("creates default config, build URLs, and manages interceptors", () => {
const config = createConfig({ baseUrl: "https://api.example.test" });
expect(config.parseAs).toBe("auto");
expect(config.headers).toEqual({ "Content-Type": "application/json" });
expect(
buildUrl({
...config,
path: { id: "tool/a" },
query: { q: "drill" },
url: "/v1/tools/{id}",
})
).toBe("https://api.example.test/v1/tools/tool%2Fa?q=drill");
const interceptors = createInterceptors<Request, Response, unknown, { tag: string }>();
const fn = (request: Request) => request;
const id = interceptors.request.use(fn);
expect(interceptors.request.exists(id)).toBe(true);
expect(interceptors.request.update(id, fn)).toBe(id);
interceptors.request.eject(fn);
expect(interceptors.request.exists(id)).toBe(false);
interceptors.request.clear();
expect(interceptors.request.fns).toEqual([]);
});
});
describe("generated fetch client", () => {
it("builds requests, runs interceptors, validates, transforms, and returns data", async () => {
const seen: Array<string> = [];
const client = createClient({
baseUrl: "https://api.example.test",
fetch: async (requestInfo) => {
const request = requestInfo as Request;
seen.push(request.headers.get("X-Request-Interceptor") ?? "");
expect(request.method).toBe("POST");
expect(request.url).toBe("https://api.example.test/v1/tools?q=drill");
expect(await request.text()).toBe('{"name":"press"}');
return new Response('{"id":"tool_1"}', { headers: { "Content-Type": "application/json" } });
},
responseStyle: "data",
});
client.interceptors.request.use((request) => {
request.headers.set("X-Request-Interceptor", "ran");
return request;
});
client.interceptors.response.use((response) => {
response.headers.set("X-Response-Interceptor", "ran");
return response;
});
const data = await client.post({
body: { name: "press" },
query: { q: "drill" },
responseTransformer: async (body) => ({ ...(body as Record<string, unknown>), transformed: true }),
responseValidator: async (body) => {
expect(body).toEqual({ id: "tool_1" });
},
url: "/v1/tools",
});
expect(seen).toEqual(["ran"]);
expect(data).toEqual({ id: "tool_1", transformed: true });
});
it("returns structured errors when throwOnError is disabled", async () => {
const client = createClient({
baseUrl: "https://api.example.test",
fetch: async () => new Response('{"error":"nope"}', { status: 400 }),
throwOnError: false,
});
client.interceptors.error.use((error) => ({ wrapped: error }));
await expect(client.get({ url: "/v1/fail" })).resolves.toMatchObject({
error: { wrapped: { error: "nope" } },
response: { status: 400 },
});
});
it("returns typed empty responses for no-content results", async () => {
const client = createClient({
baseUrl: "https://api.example.test",
fetch: async () => new Response(null, { status: 204 }),
responseStyle: "data",
});
await expect(client.delete({ parseAs: "json", url: "/v1/tools/tool_1" })).resolves.toEqual({});
});
});