@apifuse/provider-sdk 2.1.0-beta.0 → 2.1.0-beta.10

package/bin/apifuse-perf.ts

@@ -8,8 +8,11 @@ import { pathToFileURL } from "node:url";
 
 import {
 	type ApiFuseConfig,
+	createBypassProviderCache,
 	createHttpClient,
-	createTlsClient,
+	createProviderChoiceContext,
+	createStealthClient,
+	createSttClientFromEnv,
 	executeOperation,
 	getProviderBaseUrl,
 	type HttpClient,
@@ -18,8 +21,8 @@ import {
 	type ProviderDefinition,
 	ProviderError,
 	type Span,
-	type TlsClient,
-	type TlsResponse,
+	type StealthClient,
+	type StealthResponse,
 	wrapWithInstrumentation,
 } from "../src";
 import {
@@ -27,6 +30,7 @@ import {
 	groupSpansByName,
 	type PerfStats,
 } from "../src/runtime/perf";
+import { createMemoryProviderRuntimeState } from "../src/runtime/state";
 import {
 	createTraceContext,
 	resolveTraceContextOptions,
@@ -41,6 +45,7 @@ type CliArgs = {
 	exportPath?: string;
 	flame: boolean;
 	operation: string;
+	params?: string;
 	runs: number;
 	warmup: number;
 };
@@ -79,6 +84,21 @@ const DEFAULT_RUNS = 10;
 const DEFAULT_WARMUP = 2;
 const DEFAULT_CONCURRENCY = 1;
 const BAR_WIDTH = 20;
+const HELP_TEXT = `Usage: apifuse perf <provider-path> --operation <operation> [options]
+
+Options:
+  --operation, -o <name>   operation to profile (required)
+  --params, -p <json>      JSON input template; falls back to fixtures.request or {}
+  --runs, -n <number>      number of runs (default: 10)
+  --warmup <number>        warmup runs (default: 2)
+  --concurrency, -c <n>    concurrent requests (default: 1)
+  --compare-proxy          run with proxy on/off and compare
+  --export <path>          export results to JSON file
+  --flame                  generate flamegraph SVG
+  --help, -h               show this help
+
+Example:
+  apifuse perf providers/korea-air-quality --operation realtime --params '{"stationName":"jongno"}' --runs 5`;
 
 export async function main() {
 	try {
@@ -92,7 +112,11 @@ export async function main() {
 		const inputSchema = getOperationSchema(provider, operation, "input");
 		const outputSchema = getOperationSchema(provider, operation, "output");
 		const fixtureReplay = await loadFixtureReplay(providerDirectory);
-		const inputTemplate = resolveInputTemplate(provider, inputSchema);
+		const inputTemplate = resolveInputTemplate(
+			provider,
+			inputSchema,
+			args.params,
+		);
 
 		const directSuite = await runProfileSuite({
 			args,
@@ -182,6 +206,7 @@ function parseArgs(argv: string[]): CliArgs {
 	let compareProxy = false;
 	let exportPath: string | undefined;
 	let flame = false;
+	let params: string | undefined;
 
 	for (let index = 0; index < argv.length; index += 1) {
 		const arg = argv[index];
@@ -199,6 +224,11 @@ function parseArgs(argv: string[]): CliArgs {
 			continue;
 		}
 
+		if (arg === "--help" || arg === "-h") {
+			console.log(HELP_TEXT);
+			process.exit(0);
+		}
+
 		if (arg === "--compare-proxy") {
 			compareProxy = true;
 			continue;
@@ -220,6 +250,22 @@ function parseArgs(argv: string[]): CliArgs {
 			continue;
 		}
 
+		if (arg === "--params" || arg === "-p") {
+			params = requireArgValue(argv, index, arg);
+			index += 1;
+			continue;
+		}
+
+		if (arg.startsWith("--params=")) {
+			params = arg.slice("--params=".length);
+			continue;
+		}
+
+		if (arg.startsWith("-p=")) {
+			params = arg.slice("-p=".length);
+			continue;
+		}
+
 		if (arg.startsWith("-o=")) {
 			operation = arg.slice("-o=".length);
 			continue;
@@ -292,20 +338,7 @@ function parseArgs(argv: string[]): CliArgs {
 	}
 
 	if (!providerPath || !operation) {
-		throw new Error(
-			[
-				"Usage: apifuse perf <provider-path> [options]",
-				"",
-				"Options:",
-				"  --operation, -o <name>   operation to profile (required)",
-				"  --runs, -n <number>      number of runs (default: 10)",
-				"  --warmup <number>        warmup runs (default: 2)",
-				"  --concurrency, -c <n>    concurrent requests (default: 1)",
-				"  --compare-proxy          run with proxy on/off and compare",
-				"  --export <path>          export results to JSON file",
-				"  --flame                  generate flamegraph SVG",
-			].join("\n"),
-		);
+		throw new Error(HELP_TEXT);
 	}
 
 	return {
@@ -315,6 +348,7 @@ function parseArgs(argv: string[]): CliArgs {
 		exportPath,
 		flame,
 		operation,
+		params,
 		runs,
 		warmup,
 	};
@@ -409,7 +443,18 @@ function isSchema(value: unknown): value is { parse(input: unknown): unknown } {
 function resolveInputTemplate(
 	provider: ProviderDefinition,
 	inputSchema: { parse(input: unknown): unknown },
+	params: string | undefined,
 ): unknown {
+	if (params !== undefined) {
+		try {
+			return inputSchema.parse(JSON.parse(params));
+		} catch (error) {
+			throw new Error(
+				`Failed to parse --params JSON or validate input: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+	}
+
 	const firstOp = Object.values(provider.operations)[0];
 	if (firstOp?.fixtures?.request !== undefined) {
 		return firstOp.fixtures.request;
@@ -440,12 +485,12 @@ async function loadFixtureReplay(
 }
 
 function assertProxyConfigured(config: ApiFuseConfig): void {
-	if (config.proxy?.url || process.env.APIFUSE_PROXY_URL) {
+	if (config.proxy?.url || process.env.APIFUSE__PROXY__URL) {
 		return;
 	}
 
 	throw new Error(
-		"--compare-proxy requires a proxy URL in apifuse.config.ts or APIFUSE_PROXY_URL.",
+		"--compare-proxy requires a proxy URL in apifuse.config.ts or APIFUSE__PROXY__URL.",
 	);
 }
 
@@ -637,30 +682,44 @@ function createBaseContext(options: {
 					apifuseConfig,
 					upstream,
 				});
-	const tls =
+	const stealth =
 		options.forceFixtureReplay && options.fixtureReplay
-			? createFixtureTlsClient(options.fixtureReplay.rawText)
-			: createTlsClient(getProviderBaseUrl(options.provider), {
+			? createFixtureStealthClient(options.fixtureReplay.rawText)
+			: createStealthClient(getProviderBaseUrl(options.provider), {
 					apifuseConfig,
 					upstream,
 				});
 
+	const env = {
+		get: (key: string) => process.env[key],
+	};
+	const credential = {
+		mode: "none" as const,
+		get: () => undefined,
+		getAll: () => ({}),
+		getAccessToken: () => undefined,
+		getScopes: () => [],
+	};
+	const state = createMemoryProviderRuntimeState();
 	return {
-		env: {
-			get: (key: string) => process.env[key],
-		},
-		credential: {
-			mode: "none",
-			get: () => undefined,
-			getAll: () => ({}),
-			getAccessToken: () => undefined,
-			getScopes: () => [],
-		},
+		env,
+		credential,
+		request: { headers: {} },
 		http,
-		tls,
+		cache: createBypassProviderCache({ providerId: options.provider.id }),
+		state,
+		stealth,
 		browser: createBrowserStub(),
 		trace: options.traceContext,
 		auth: createAuthStub(),
+		stt: createSttClientFromEnv(options.provider.stt),
+		choice: createProviderChoiceContext({
+			providerId: options.provider.id,
+			env,
+			request: { headers: {} },
+			credential,
+			state,
+		}),
 	};
 }
 
@@ -695,16 +754,25 @@ function createFixtureResponse(raw: unknown) {
 	};
 }
 
-function createFixtureTlsClient(rawText: string): TlsClient {
-	const createResponse = async (): Promise<TlsResponse> => ({
-		status: 200,
-		ok: true,
-		headers: { "content-type": "application/json" },
-		rawHeaders: [["content-type", "application/json"]],
-		body: rawText,
-		cookies: { get: () => undefined, getAll: () => ({}), toString: () => "" },
-		json: async <T>() => JSON.parse(rawText) as T,
-	});
+function createFixtureStealthClient(rawText: string): StealthClient {
+	const createResponse = async (): Promise<StealthResponse> => {
+		const bodyBytes = new TextEncoder().encode(rawText);
+		return {
+			status: 200,
+			ok: true,
+			headers: { "content-type": "application/json" },
+			rawHeaders: [["content-type", "application/json"]],
+			body: rawText,
+			cookies: { get: () => undefined, getAll: () => ({}), toString: () => "" },
+			json: async <T>() => JSON.parse(rawText) as T,
+			arrayBuffer: async () =>
+				bodyBytes.buffer.slice(
+					bodyBytes.byteOffset,
+					bodyBytes.byteOffset + bodyBytes.byteLength,
+				) as ArrayBuffer,
+			bytes: async () => new Uint8Array(bodyBytes),
+		};
+	};
 
 	return {
 		fetch: async () => createResponse(),
@@ -720,6 +788,7 @@ function createFixtureTlsClient(rawText: string): TlsClient {
 function createBrowserStub(): BrowserClient {
 	return {
 		engine: "playwright-stealth",
+		async close() {},
 		async newPage() {
 			throw new ProviderError(
 				"Browser runtime is not supported by apifuse perf yet.",
@@ -728,6 +797,30 @@ function createBrowserStub(): BrowserClient {
 				},
 			);
 		},
+		async rawPage() {
+			throw new ProviderError(
+				"Browser runtime is not supported by apifuse perf yet.",
+				{
+					code: "BROWSER_RUNTIME_UNSUPPORTED",
+				},
+			);
+		},
+		async withIsolatedContext() {
+			throw new ProviderError(
+				"Browser runtime is not supported by apifuse perf yet.",
+				{
+					code: "BROWSER_RUNTIME_UNSUPPORTED",
+				},
+			);
+		},
+		async solveChallenge() {
+			throw new ProviderError(
+				"Browser runtime is not supported by apifuse perf yet.",
+				{
+					code: "BROWSER_RUNTIME_UNSUPPORTED",
+				},
+			);
+		},
 	};
 }
 
@@ -738,7 +831,7 @@ function buildInsights(
 ): string[] {
 	const insights: string[] = [];
 	const allSpans = runs.flatMap((run) => run.spans);
-	const tlsSpans = allSpans.filter((span) => span.name === "tls.fetch");
+	const stealthSpans = allSpans.filter((span) => span.name === "stealth.fetch");
 	const dnsSpans = allSpans.filter((span) => span.name === "dns");
 	const transform = breakdown.find(
 		(entry) => entry.name === "transformResponse",
@@ -746,7 +839,7 @@ function buildInsights(
 	const responseSizes = allSpans
 		.map((span) => span.attributes.response_size)
 		.filter((value): value is number => typeof value === "number");
-	const reuseFlags = tlsSpans
+	const reuseFlags = stealthSpans
 		.map((span) => span.attributes.connection_reused)
 		.filter((value): value is boolean => typeof value === "boolean");
 
@@ -756,8 +849,8 @@ function buildInsights(
 		);
 		insights.push(
 			reusePercent >= 80
-				? `✓ TLS connection reuse: ${reusePercent}% (good)`
-				: `⚠ TLS connection reuse: ${reusePercent}% — consider session reuse`,
+				? `✓ Stealth connection reuse: ${reusePercent}% (good)`
+				: `⚠ Stealth connection reuse: ${reusePercent}% — consider session reuse`,
 		);
 	}
 
@@ -1091,7 +1184,7 @@ function cloneValue<T>(value: T): T {
 
 function handleCliError(error: unknown): never {
 	const message = error instanceof Error ? error.message : String(error);
-	console.error(message);
+	console.error(`[apifuse perf] ${message}`);
 	process.exit(1);
 }