@apifuse/provider-sdk 2.0.0-beta.1

package/src/__tests__/waterfall.test.ts

@@ -0,0 +1,270 @@
+import { describe, expect, it } from "bun:test";
+
+import type { Span } from "../runtime/trace";
+import { renderWaterfall, type WaterfallRequest } from "../runtime/waterfall";
+
+function assertDefined<T>(value: T | null | undefined, message?: string): T {
+	if (value === null || value === undefined) {
+		throw new Error(message ?? "Expected value to be defined");
+	}
+
+	return value;
+}
+
+function makeSpan(overrides: Partial<Span> & { name: string }): Span {
+	return {
+		id: crypto.randomUUID(),
+		name: overrides.name,
+		startedAt: overrides.startedAt ?? 1000,
+		endedAt: overrides.endedAt ?? 1100,
+		duration_ms: overrides.duration_ms ?? 100,
+		status: overrides.status ?? "ok",
+		attributes: overrides.attributes ?? {},
+		...(overrides.parentId ? { parentId: overrides.parentId } : {}),
+		...(overrides.error ? { error: overrides.error } : {}),
+		...(overrides.id ? { id: overrides.id } : {}),
+	};
+}
+
+const defaultRequest: WaterfallRequest = {
+	method: "GET",
+	path: "/v1/coingecko/prices",
+	status: 200,
+	totalMs: 289,
+};
+
+describe("renderWaterfall", () => {
+	it("renders span name and duration", () => {
+		const rootSpan = makeSpan({
+			id: "root-1",
+			name: "prices",
+			startedAt: 1000,
+			endedAt: 1289,
+			duration_ms: 289,
+		});
+
+		const child = makeSpan({
+			name: "normalizeRequest",
+			parentId: "root-1",
+			startedAt: 1000,
+			endedAt: 1001,
+			duration_ms: 0.1,
+		});
+
+		const output = renderWaterfall([rootSpan, child], defaultRequest);
+
+		expect(output).toContain("prices");
+		expect(output).toContain("289ms");
+		expect(output).toContain("normalizeRequest");
+		expect(output).toContain("0.1ms");
+	});
+
+	it("indents child spans", () => {
+		const root = makeSpan({
+			id: "root-1",
+			name: "prices",
+			startedAt: 1000,
+			endedAt: 1289,
+			duration_ms: 289,
+		});
+
+		const parent = makeSpan({
+			id: "parent-1",
+			name: "tls.fetch",
+			parentId: "root-1",
+			startedAt: 1001,
+			endedAt: 1286,
+			duration_ms: 285,
+		});
+
+		const child = makeSpan({
+			name: "dns",
+			parentId: "parent-1",
+			startedAt: 1001,
+			endedAt: 1012,
+			duration_ms: 11.3,
+		});
+
+		const output = renderWaterfall([root, parent, child], defaultRequest);
+
+		const lines = output.split("\n");
+
+		const tlsFetchLine = lines.find((l) => l.includes("tls.fetch"));
+		const dnsLine = lines.find((l) => l.includes("dns"));
+
+		expect(tlsFetchLine).toBeDefined();
+		expect(dnsLine).toBeDefined();
+
+		const stripAnsi = (s: string) =>
+			s.replace(new RegExp("\\u001b\\[[0-9;]*m", "g"), "");
+		const tlsFetchPos = stripAnsi(assertDefined(tlsFetchLine)).indexOf("├─");
+		const dnsPos = stripAnsi(assertDefined(dnsLine)).indexOf("└─");
+
+		expect(dnsPos).toBeGreaterThan(tlsFetchPos);
+	});
+
+	it("marks slow spans yellow", () => {
+		const root = makeSpan({
+			id: "root-1",
+			name: "prices",
+			startedAt: 1000,
+			endedAt: 1600,
+			duration_ms: 600,
+		});
+
+		const slowChild = makeSpan({
+			name: "tls.fetch",
+			parentId: "root-1",
+			startedAt: 1000,
+			endedAt: 1600,
+			duration_ms: 600,
+		});
+
+		const output = renderWaterfall(
+			[root, slowChild],
+			{
+				...defaultRequest,
+				totalMs: 600,
+			},
+			{ slowThresholdMs: 500 },
+		);
+
+		expect(output).toContain("\x1b[33m");
+	});
+
+	it("marks error spans red", () => {
+		const root = makeSpan({
+			id: "root-1",
+			name: "prices",
+			startedAt: 1000,
+			endedAt: 1100,
+			duration_ms: 100,
+			status: "error",
+			error: "Network failure",
+		});
+
+		const output = renderWaterfall([root], {
+			...defaultRequest,
+			status: 500,
+			totalMs: 100,
+		});
+
+		expect(output).toContain("\x1b[31m");
+	});
+
+	it("marks bottleneck with star", () => {
+		const root = makeSpan({
+			id: "root-1",
+			name: "prices",
+			startedAt: 1000,
+			endedAt: 1289,
+			duration_ms: 289,
+		});
+
+		const fast = makeSpan({
+			name: "normalizeRequest",
+			parentId: "root-1",
+			startedAt: 1000,
+			endedAt: 1001,
+			duration_ms: 0.1,
+		});
+
+		const slow = makeSpan({
+			name: "tls.fetch",
+			parentId: "root-1",
+			startedAt: 1001,
+			endedAt: 1286,
+			duration_ms: 285,
+		});
+
+		const transform = makeSpan({
+			name: "transformResponse",
+			parentId: "root-1",
+			startedAt: 1286,
+			endedAt: 1289,
+			duration_ms: 3.2,
+		});
+
+		const output = renderWaterfall(
+			[root, fast, slow, transform],
+			defaultRequest,
+		);
+
+		const lines = output.split("\n");
+		const tlsFetchLine = lines.find((l) => l.includes("tls.fetch"));
+		expect(tlsFetchLine).toContain("★");
+
+		const normalizeLine = lines.find((l) => l.includes("normalizeRequest"));
+		expect(normalizeLine).not.toContain("★");
+	});
+
+	it("returns empty string for no spans", () => {
+		const output = renderWaterfall([], defaultRequest);
+		expect(output).toBe("");
+	});
+
+	it("renders status line with method and path", () => {
+		const root = makeSpan({
+			id: "root-1",
+			name: "prices",
+			duration_ms: 100,
+		});
+
+		const output = renderWaterfall([root], defaultRequest);
+
+		expect(output).toContain("GET");
+		expect(output).toContain("/v1/coingecko/prices");
+		expect(output).toContain("200");
+		expect(output).toContain("OK");
+	});
+
+	it("renders timing bars proportional to total duration", () => {
+		const root = makeSpan({
+			id: "root-1",
+			name: "op",
+			startedAt: 1000,
+			endedAt: 1200,
+			duration_ms: 200,
+		});
+
+		const half = makeSpan({
+			name: "half",
+			parentId: "root-1",
+			startedAt: 1000,
+			endedAt: 1100,
+			duration_ms: 100,
+		});
+
+		const full = makeSpan({
+			name: "full",
+			parentId: "root-1",
+			startedAt: 1100,
+			endedAt: 1200,
+			duration_ms: 200,
+		});
+
+		const output = renderWaterfall(
+			[root, half, full],
+			{
+				...defaultRequest,
+				totalMs: 200,
+			},
+			{ maxBarWidth: 20 },
+		);
+
+		const stripAnsi = (s: string) =>
+			s.replace(new RegExp("\\u001b\\[[0-9;]*m", "g"), "");
+		const lines = output.split("\n").map(stripAnsi);
+
+		const halfLine = lines.find(
+			(l) => l.includes("half") && !l.includes("full"),
+		);
+		const fullLine = lines.find((l) => l.includes("full"));
+
+		const countBars = (s: string) => (s.match(/━/g) ?? []).length;
+		const halfBars = countBars(halfLine ?? "");
+		const fullBars = countBars(fullLine ?? "");
+
+		expect(fullBars).toBeGreaterThan(halfBars);
+	});
+});

package/src/config/loader.ts

@@ -0,0 +1,122 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+import type { TraceConfig } from "../types";
+
+export type ProxyOptions = {
+	url: string;
+};
+
+export type ProxyConfig = Partial<ProxyOptions> & {
+	provider?: string;
+	apiKey?: string;
+};
+
+export type BrowserConfig = {
+	executablePath?: string;
+	headless?: boolean;
+};
+
+export type SessionConfig = {
+	storage?: "sqlite" | "supabase";
+	path?: string;
+};
+
+export type ApiFuseConfig = {
+	proxy?: ProxyConfig;
+	browser?: BrowserConfig;
+	session?: SessionConfig;
+	trace?: TraceConfig;
+	credentials?: Record<string, Record<string, string>>;
+};
+
+export type ProxyResolutionOptions = {
+	proxy?: string;
+	upstream?: { proxy?: boolean };
+	apifuseConfig?: Pick<ApiFuseConfig, "proxy">;
+};
+
+export type ResolvedProxyConfig = {
+	shouldWarn: boolean;
+	url?: string;
+};
+
+function normalizeProxyUrl(url?: string): string | undefined {
+	const normalized = url?.trim();
+	return normalized ? normalized : undefined;
+}
+
+function syncProxyEnv(config: ApiFuseConfig): void {
+	const configProxyUrl = normalizeProxyUrl(config.proxy?.url);
+	if (!process.env.APIFUSE_PROXY_URL && configProxyUrl) {
+		process.env.APIFUSE_PROXY_URL = configProxyUrl;
+	}
+}
+
+export function resolveProxyConfig(
+	options: ProxyResolutionOptions = {},
+): ResolvedProxyConfig {
+	const explicitProxyUrl = normalizeProxyUrl(options.proxy);
+	if (explicitProxyUrl) {
+		return { shouldWarn: false, url: explicitProxyUrl };
+	}
+
+	if (!options.upstream?.proxy) {
+		return { shouldWarn: false };
+	}
+
+	const envProxyUrl = normalizeProxyUrl(process.env.APIFUSE_PROXY_URL);
+	if (envProxyUrl) {
+		return { shouldWarn: false, url: envProxyUrl };
+	}
+
+	const configuredProxyUrl = normalizeProxyUrl(
+		options.apifuseConfig?.proxy?.url,
+	);
+	if (configuredProxyUrl) {
+		return { shouldWarn: false, url: configuredProxyUrl };
+	}
+
+	return { shouldWarn: true };
+}
+
+export function defineConfig(config: ApiFuseConfig): ApiFuseConfig {
+	return config;
+}
+
+async function importConfig(filePath: string): Promise<ApiFuseConfig | null> {
+	try {
+		const moduleUrl = new URL(`file://${encodeURI(filePath)}`);
+		const mod = (await import(moduleUrl.href)) as { default?: ApiFuseConfig };
+		if (mod.default && typeof mod.default === "object") {
+			return mod.default;
+		}
+		console.warn(`[provider-sdk] Ignoring invalid config export: ${filePath}`);
+		return {};
+	} catch (error) {
+		console.warn(`[provider-sdk] Failed to load config ${filePath}:`, error);
+		return null;
+	}
+}
+
+export async function loadApiFuseConfig(
+	dir: string = process.cwd(),
+): Promise<ApiFuseConfig> {
+	const tsPath = path.resolve(dir, "apifuse.config.ts");
+	if (existsSync(tsPath)) {
+		const config = await importConfig(tsPath);
+		const resolvedConfig = config ?? {};
+		syncProxyEnv(resolvedConfig);
+		return resolvedConfig;
+	}
+
+	const jsPath = path.resolve(dir, "apifuse.config.js");
+	if (existsSync(jsPath)) {
+		const config = await importConfig(jsPath);
+		const resolvedConfig = config ?? {};
+		syncProxyEnv(resolvedConfig);
+		return resolvedConfig;
+	}
+
+	return {};
+}