@apifuse/provider-sdk 2.0.0-beta.1 → 2.1.0-beta.1

package/src/__tests__/define.test.ts

@@ -1,225 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { z } from "zod";
-
-import { defineProvider } from "../define";
-import { ProviderError, ValidationError } from "../errors";
-import type { ProviderContext } from "../types";
-
-const InputSchema = z.object({ id: z.string() });
-const OutputSchema = z.object({ name: z.string(), price: z.number() });
-
-const validConfig = {
-	id: "coingecko-prices",
-	version: "1.0.0",
-	runtime: "standard" as const,
-	meta: {
-		displayName: "CoinGecko Prices",
-		description: "Simple finance provider",
-		category: "finance",
-		tags: ["prices"],
-	},
-	operations: {
-		prices: {
-			input: InputSchema,
-			output: OutputSchema,
-			handler: async (_ctx: ProviderContext, input: unknown) => {
-				const parsed = InputSchema.parse(input);
-
-				return {
-					name: parsed.id,
-					price: 50_000,
-				};
-			},
-			fixtures: {
-				request: { id: "bitcoin" },
-				response: { name: "Bitcoin", price: 50_000 },
-			},
-		},
-	},
-};
-
-describe("defineProvider", () => {
-	it("returns provider with top-level identity fields accessible", () => {
-		const provider = defineProvider(validConfig);
-
-		expect(provider.id).toBe("coingecko-prices");
-		expect(provider.version).toBe("1.0.0");
-		expect(provider.runtime).toBe("standard");
-		expect(provider.meta.displayName).toBe("CoinGecko Prices");
-	});
-
-	it("preserves operation definitions", async () => {
-		const provider = defineProvider(validConfig);
-		await expect(
-			provider.operations.prices.handler?.({} as never, { id: "bitcoin" }),
-		).resolves.toEqual({ name: "bitcoin", price: 50_000 });
-	});
-
-	it("throws ProviderError for invalid id format - uppercase", () => {
-		expect(() =>
-			defineProvider({
-				...validConfig,
-				id: "CoinGecko",
-			}),
-		).toThrow(ProviderError);
-	});
-
-	it("throws ProviderError for invalid id format - single word", () => {
-		expect(() =>
-			defineProvider({ ...validConfig, id: "coingecko" }),
-		).not.toThrow();
-	});
-
-	it("throws ProviderError for invalid id format - spaces", () => {
-		expect(() =>
-			defineProvider({
-				...validConfig,
-				id: "coin gecko prices",
-			}),
-		).toThrow(ProviderError);
-	});
-
-	it("throws ProviderError for invalid id format - underscore", () => {
-		expect(() =>
-			defineProvider({
-				...validConfig,
-				id: "coingecko_prices",
-			}),
-		).toThrow(ProviderError);
-	});
-
-	it("throws ValidationError when operation fixture.request does not match input schema", () => {
-		const badConfig = {
-			...validConfig,
-			operations: {
-				...validConfig.operations,
-				prices: {
-					...validConfig.operations.prices,
-					fixtures: {
-						request: { wrong_field: "x" } as unknown as z.infer<
-							typeof InputSchema
-						>,
-						response: validConfig.operations.prices.fixtures.response,
-					},
-				},
-			},
-		};
-
-		expect(() => defineProvider(badConfig)).toThrow(ValidationError);
-	});
-
-	it("throws ValidationError when operation fixture.response does not match output schema", () => {
-		const badConfig = {
-			...validConfig,
-			operations: {
-				...validConfig.operations,
-				prices: {
-					...validConfig.operations.prices,
-					fixtures: {
-						request: validConfig.operations.prices.fixtures.request,
-						response: { wrong: true } as unknown as z.infer<
-							typeof OutputSchema
-						>,
-					},
-				},
-			},
-		};
-
-		expect(() => defineProvider(badConfig)).toThrow(ValidationError);
-	});
-
-	it("ValidationError includes zodError for actionable debugging", () => {
-		const badConfig = {
-			...validConfig,
-			operations: {
-				...validConfig.operations,
-				prices: {
-					...validConfig.operations.prices,
-					fixtures: {
-						request: { wrong_field: "x" } as unknown as z.infer<
-							typeof InputSchema
-						>,
-						response: validConfig.operations.prices.fixtures.response,
-					},
-				},
-			},
-		};
-
-		try {
-			defineProvider(badConfig);
-		} catch (error) {
-			expect(error instanceof ValidationError).toBe(true);
-			expect((error as ValidationError).zodError).toBeDefined();
-		}
-	});
-
-	it("ProviderError has fix hint for invalid id", () => {
-		try {
-			defineProvider({ ...validConfig, id: "BAD_ID" });
-		} catch (error) {
-			expect(error instanceof ProviderError).toBe(true);
-			expect((error as ProviderError).fix).toBeDefined();
-		}
-	});
-
-	it("throws ProviderError when no operations defined", () => {
-		expect(() => defineProvider({ ...validConfig, operations: {} })).toThrow(
-			ProviderError,
-		);
-	});
-
-	it("works without operation fixtures", () => {
-		const noFixturesConfig = {
-			...validConfig,
-			operations: {
-				...validConfig.operations,
-				prices: {
-					...validConfig.operations.prices,
-					fixtures: undefined,
-				},
-			},
-		};
-
-		const provider = defineProvider(noFixturesConfig);
-
-		expect(provider.id).toBe("coingecko-prices");
-		expect(provider.operations.prices.fixtures).toBeUndefined();
-	});
-
-	it("requires browser config when runtime is browser", () => {
-		expect(() =>
-			defineProvider({
-				...validConfig,
-				runtime: "browser",
-			}),
-		).toThrow(ProviderError);
-	});
-
-	it("rejects browser config when runtime is not browser", () => {
-		expect(() =>
-			defineProvider({
-				...validConfig,
-				browser: { engine: "nodriver" },
-			}),
-		).toThrow(ProviderError);
-	});
-
-	it("keeps operation schema inference usable for input parsing", () => {
-		const provider = defineProvider(validConfig);
-		const parsed = provider.operations.prices.input?.safeParse({
-			id: "bitcoin",
-		});
-
-		expect(parsed?.success).toBe(true);
-	});
-
-	it("keeps operation schema inference usable for output parsing", () => {
-		const provider = defineProvider(validConfig);
-		const parsed = provider.operations.prices.output?.safeParse({
-			name: "Bitcoin",
-			price: 50_000,
-		});
-
-		expect(parsed?.success).toBe(true);
-	});
-});

package/src/__tests__/errors.test.ts

@@ -1,69 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
-	AuthError,
-	ProviderError,
-	SDKError,
-	TransportError,
-	ValidationError,
-} from "../errors";
-
-describe("ProviderError", () => {
-	it("should include fix hint", () => {
-		const err = new ProviderError("Something broke", { fix: "Try again" });
-		expect(err.fix).toBe("Try again");
-		expect(err.message).toBe("Something broke");
-		expect(err.name).toBe("ProviderError");
-	});
-
-	it("should include code", () => {
-		const err = new ProviderError("Error", { code: "E001" });
-		expect(err.code).toBe("E001");
-	});
-
-	it("should be instanceof Error", () => {
-		const err = new ProviderError("test");
-		expect(err instanceof Error).toBe(true);
-		expect(err instanceof ProviderError).toBe(true);
-	});
-});
-
-describe("AuthError", () => {
-	it("should be instanceof ProviderError", () => {
-		const err = new AuthError("Unauthorized", {
-			code: "refresh_failed",
-			fix: "Re-authenticate",
-		});
-		expect(err instanceof ProviderError).toBe(true);
-		expect(err instanceof AuthError).toBe(true);
-		expect(err.name).toBe("AuthError");
-		expect(err.code).toBe("refresh_failed");
-	});
-});
-
-describe("ValidationError", () => {
-	it("should store zodError", () => {
-		const zodErr = { issues: [{ path: ["id"], message: "Required" }] };
-		const err = new ValidationError("Invalid input", {
-			zodError: zodErr,
-			fix: "Check id field",
-		});
-		expect(err.zodError).toEqual(zodErr);
-		expect(err instanceof ProviderError).toBe(true);
-	});
-});
-
-describe("TransportError", () => {
-	it("should store HTTP status", () => {
-		const err = new TransportError("Connection failed", { status: 502 });
-		expect(err.status).toBe(502);
-		expect(err instanceof ProviderError).toBe(true);
-	});
-});
-
-describe("SDKError", () => {
-	it("should be instanceof ProviderError", () => {
-		const err = new SDKError("Internal SDK error");
-		expect(err instanceof ProviderError).toBe(true);
-		expect(err.name).toBe("SDKError");
-	});
-});

package/src/__tests__/executor.test.ts

@@ -1,214 +0,0 @@
-import { describe, expect, it, mock } from "bun:test";
-
-import { z } from "../../node_modules/zod";
-
-import { TransportError } from "../errors";
-import { executeOperation } from "../runtime/executor";
-import type { ProviderContext, ProviderDefinition } from "../types";
-
-function createMockCtx(fetchResponse: unknown, status = 200): ProviderContext {
-	return {
-		tls: {
-			fetch: mock(async (_url: string, _opts?: unknown) => ({
-				status,
-				ok: status >= 200 && status < 300,
-				headers: {},
-				rawHeaders: [],
-				body: "",
-				cookies: {
-					get: () => undefined,
-					getAll: () => ({}),
-					toString: () => "",
-				},
-				json: async <T>() => fetchResponse as T,
-			})),
-			createSession: mock(() => ({
-				fetch: async () => ({
-					status,
-					ok: status >= 200 && status < 300,
-					headers: {},
-					rawHeaders: [] as [string, string][],
-					body: "",
-					cookies: {
-						get: () => undefined,
-						getAll: () => ({}),
-						toString: () => "",
-					},
-					json: async <T>() => ({}) as T,
-				}),
-				close: () => {},
-			})),
-		},
-		http: {} as ProviderContext["http"],
-		browser: {} as ProviderContext["browser"],
-		session: {
-			get: mock(async () => null),
-			set: mock(async () => {}),
-			delete: mock(async () => {}),
-		},
-		state: {} as ProviderContext["state"],
-		trace: {
-			span: async <T>(_name: string, fn: () => Promise<T>) => fn(),
-		},
-		auth: {
-			requestField: mock(async () => ""),
-		},
-	};
-}
-
-function createMockProvider(options?: {
-	handler?: ProviderDefinition["operations"][string]["handler"];
-	auth?: ProviderDefinition["auth"];
-}): ProviderDefinition {
-	return {
-		id: "test-provider",
-		version: "1.0.0",
-		runtime: "standard",
-		auth: options?.auth,
-		meta: {
-			displayName: "Test Provider",
-			category: "test",
-		},
-		operations: {
-			search: {
-				description: "Search",
-				input: z.object({ query: z.string() }),
-				output: z.object({ results: z.array(z.string()) }),
-				handler:
-					options?.handler ??
-					(async (_ctx: ProviderContext, input: unknown) => {
-						const parsed = z.object({ query: z.string() }).parse(input);
-
-						return {
-							results: [parsed.query],
-						};
-					}),
-			},
-		},
-	};
-}
-
-describe("executeOperation", () => {
-	it("runs the handler and validates output", async () => {
-		const ctx = createMockCtx({});
-		const provider = createMockProvider();
-
-		const result = await executeOperation(provider, "search", ctx, {
-			query: "test",
-		});
-
-		expect(result).toEqual({ results: ["test"] });
-	});
-
-	it("passes through handler output parsing", async () => {
-		const ctx = createMockCtx({});
-		const provider = createMockProvider({
-			handler: async () => ({ results: ["result1", "result2"] }),
-		});
-
-		const result = await executeOperation(provider, "search", ctx, {
-			query: "test",
-		});
-
-		expect(result).toEqual({ results: ["result1", "result2"] });
-	});
-
-	it("throws ProviderError when operation not found", async () => {
-		const ctx = createMockCtx({});
-		const provider = createMockProvider();
-
-		await expect(
-			executeOperation(provider, "nonexistent", ctx, {}),
-		).rejects.toThrow("nonexistent");
-	});
-
-	it("throws ProviderError when operation has no handler", async () => {
-		const ctx = createMockCtx({});
-		const provider: ProviderDefinition = {
-			...createMockProvider(),
-			operations: {
-				search: {
-					description: "No upstream",
-					input: z.object({ query: z.string() }),
-					output: z.object({ results: z.array(z.string()) }),
-					handler: undefined as never,
-				},
-			},
-		};
-
-		await expect(
-			executeOperation(provider, "search", ctx, { query: "test" }),
-		).rejects.toThrow(TypeError);
-	});
-
-	it("auto-refreshes on 401 response if auth is configured", async () => {
-		let callCount = 0;
-		const ctx: ProviderContext = {
-			...createMockCtx({}),
-			tls: {
-				fetch: mock(async () => {
-					callCount++;
-					const responseStatus = callCount === 1 ? 401 : 200;
-					return {
-						status: responseStatus,
-						ok: responseStatus >= 200 && responseStatus < 300,
-						headers: {},
-						rawHeaders: [],
-						body: "",
-						cookies: {
-							get: () => undefined,
-							getAll: () => ({}),
-							toString: () => "",
-						},
-						json: async <T>() => ({ items: [] }) as T,
-					};
-				}),
-				createSession: mock(() => ({
-					fetch: async () => ({
-						status: 200,
-						ok: true,
-						headers: {},
-						rawHeaders: [] as [string, string][],
-						body: "",
-						cookies: {
-							get: () => undefined,
-							getAll: () => ({}),
-							toString: () => "",
-						},
-						json: async <T>() => ({}) as T,
-					}),
-					close: () => {},
-				})),
-			},
-			session: {
-				get: mock(async (key: string) => (key === "__auth__" ? "token" : null)),
-				set: mock(async () => {}),
-				delete: mock(async () => {}),
-			},
-		};
-
-		const authRefresh = mock(async () => {});
-		const provider = createMockProvider({
-			auth: {
-				mode: "credentials",
-				refresh: authRefresh,
-			},
-			handler: async () => {
-				callCount++;
-				if (callCount === 1) {
-					throw new TransportError("Unauthorized", { status: 401 });
-				}
-
-				return { results: [] };
-			},
-		});
-
-		const result = await executeOperation(provider, "search", ctx, {
-			query: "test",
-		});
-
-		expect(authRefresh).toHaveBeenCalledTimes(1);
-		expect(callCount).toBe(2);
-		expect(result).toEqual({ results: [] });
-	});
-});