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

package/src/__tests__/session.test.ts

@@ -1,231 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import {
-	createSessionStore,
-	createSqliteSessionStore,
-	type SessionFetch,
-	SupabaseSessionStore,
-} from "../runtime/session";
-
-type StoredSecretRecord = {
-	credential_id: string;
-	encrypted_blob: string;
-	encryption_key_version: number;
-	iv: string;
-	tag: string;
-};
-
-function createStore() {
-	return createSqliteSessionStore({
-		databasePath: ":memory:",
-		namespace: "test-suite",
-	});
-}
-
-function createMockSupabaseFetch(seed?: StoredSecretRecord) {
-	let storedRecord = seed ?? null;
-
-	const fetchImpl: SessionFetch = async (input, init) => {
-		const requestUrl = new URL(String(input));
-		const method = init?.method ?? "GET";
-
-		if (requestUrl.pathname !== "/rest/v1/credential_secrets") {
-			return new Response("not found", { status: 404 });
-		}
-
-		if (method === "GET") {
-			const credentialId = requestUrl.searchParams
-				.get("credential_id")
-				?.replace("eq.", "");
-			const result =
-				storedRecord && storedRecord.credential_id === credentialId
-					? [
-							{
-								encrypted_blob: storedRecord.encrypted_blob,
-								encryption_key_version: storedRecord.encryption_key_version,
-								iv: storedRecord.iv,
-								tag: storedRecord.tag,
-							},
-						]
-					: [];
-
-			return Response.json(result);
-		}
-
-		if (method === "POST") {
-			const body = JSON.parse(String(init?.body)) as StoredSecretRecord[];
-			storedRecord = body[0] ?? null;
-			return new Response(null, { status: 201 });
-		}
-
-		if (method === "DELETE") {
-			const credentialId = requestUrl.searchParams
-				.get("credential_id")
-				?.replace("eq.", "");
-			if (storedRecord?.credential_id === credentialId) {
-				storedRecord = null;
-			}
-			return new Response(null, { status: 204 });
-		}
-
-		return new Response("method not allowed", { status: 405 });
-	};
-
-	return {
-		fetchImpl,
-		getStoredRecord: () => storedRecord,
-	};
-}
-
-function createSupabaseStore(seed?: StoredSecretRecord) {
-	const mock = createMockSupabaseFetch(seed);
-	return {
-		...mock,
-		store: new SupabaseSessionStore({
-			credentialId: "conn_123",
-			encryptionKey: "12345678901234567890123456789012",
-			fetch: mock.fetchImpl,
-			supabaseKey: "service-role-key",
-			supabaseUrl: "https://example.supabase.co",
-		}),
-	};
-}
-
-describe("createSessionStore", () => {
-	it("round-trips stored values", async () => {
-		const store = createStore();
-		const session = "accessToken=token-123;refreshToken=refresh-456";
-
-		await store.set("auth", session);
-
-		expect(await store.get("auth")).toEqual(session);
-	});
-
-	it("returns null for missing keys", async () => {
-		const store = createStore();
-
-		expect(await store.get("missing")).toBeNull();
-	});
-
-	it("returns null for expired keys", async () => {
-		const store = createStore();
-
-		await store.set("expired", "token=stale", "0ms");
-
-		expect(await store.get("expired")).toBeNull();
-	});
-
-	it("deletes keys", async () => {
-		const store = createStore();
-
-		await store.set("auth", "token=live");
-		await store.delete("auth");
-
-		expect(await store.get("auth")).toBeNull();
-	});
-
-	it("upserts existing keys", async () => {
-		const store = createStore();
-
-		await store.set("auth", "token=first");
-		await store.set("auth", "token=second");
-
-		expect(await store.get("auth")).toBe("token=second");
-	});
-
-	it("stores expires_at based on ttl parsing", async () => {
-		const store = createStore();
-		const startedAt = Date.now();
-
-		await store.set("auth", "token=ttl", "15m");
-
-		const record = store.__unsafeInspect("auth");
-
-		expect(record).not.toBeNull();
-		expect(record?.expiresAt).not.toBeNull();
-		expect(record?.expiresAt ?? 0).toBeGreaterThanOrEqual(
-			startedAt + 15 * 60 * 1000 - 2_000,
-		);
-		expect(record?.expiresAt ?? 0).toBeLessThanOrEqual(
-			startedAt + 15 * 60 * 1000 + 2_000,
-		);
-	});
-
-	it("creates a sqlite store via factory", async () => {
-		const store = createSessionStore({
-			backend: "sqlite",
-			dbPath: ":memory:",
-			namespace: "factory-test",
-		});
-
-		await store.set("auth", "token=factory");
-		expect(await store.get("auth")).toBe("token=factory");
-	});
-});
-
-describe("SupabaseSessionStore", () => {
-	it("encrypts and round-trips stored values", async () => {
-		const { getStoredRecord, store } = createSupabaseStore();
-
-		await store.set("accessToken", "token-123");
-		await store.set("refreshToken", "refresh-456");
-
-		expect(await store.get("accessToken")).toBe("token-123");
-		expect(await store.get("refreshToken")).toBe("refresh-456");
-
-		const record = getStoredRecord();
-		expect(record).not.toBeNull();
-		expect(record?.encrypted_blob).not.toContain("token-123");
-		expect(record?.iv).toBeTruthy();
-		expect(record?.tag).toBeTruthy();
-		expect(record?.encryption_key_version).toBe(1);
-	});
-
-	it("returns null for missing keys", async () => {
-		const { store } = createSupabaseStore();
-
-		expect(await store.get("missing")).toBeNull();
-	});
-
-	it("deletes individual keys and removes the row when empty", async () => {
-		const { getStoredRecord, store } = createSupabaseStore();
-
-		await store.set("accessToken", "token-123");
-		await store.set("refreshToken", "refresh-456");
-		await store.delete("accessToken");
-
-		expect(await store.get("accessToken")).toBeNull();
-		expect(await store.get("refreshToken")).toBe("refresh-456");
-		expect(getStoredRecord()).not.toBeNull();
-
-		await store.delete("refreshToken");
-		expect(getStoredRecord()).toBeNull();
-	});
-
-	it("creates a supabase store via factory", async () => {
-		const mock = createMockSupabaseFetch();
-		const store = createSessionStore({
-			backend: "supabase",
-			credentialId: "conn_123",
-			encryptionKey: "12345678901234567890123456789012",
-			fetch: mock.fetchImpl,
-			supabaseKey: "service-role-key",
-			supabaseUrl: "https://example.supabase.co",
-		}) as SupabaseSessionStore;
-
-		await store.set("accessToken", "factory-token");
-		expect(await store.get("accessToken")).toBe("factory-token");
-	});
-
-	it("loads the full session envelope", async () => {
-		const { store } = createSupabaseStore();
-
-		await store.set("accessToken", "token-123");
-		await store.set("refreshToken", "refresh-456");
-
-		expect(await store.loadAll()).toEqual({
-			accessToken: "token-123",
-			refreshToken: "refresh-456",
-		});
-	});
-});

package/src/__tests__/state.test.ts

@@ -1,100 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { createStateContext } from "../runtime/state";
-
-function mutateSegment(value: string): string {
-	if (value.length === 0) {
-		return "x";
-	}
-
-	const lastCharacter = value.at(-1);
-	const replacement = lastCharacter === "a" ? "b" : "a";
-
-	return `${value.slice(0, -1)}${replacement}`;
-}
-
-describe("createStateContext", () => {
-	it("round-trips sealed values", async () => {
-		const state = createStateContext();
-		const data = {
-			bookingId: "booking-123",
-			flags: ["priority", "vip"],
-		};
-
-		const token = await state.seal(data);
-
-		await expect(state.unseal(token)).resolves.toEqual(data);
-	});
-
-	it("returns null for expired tokens", async () => {
-		const state = createStateContext();
-		const token = await state.seal({ retry: true }, { ttl: "1ms" });
-
-		await new Promise((resolve) => setTimeout(resolve, 5));
-
-		await expect(state.unseal(token)).resolves.toBeNull();
-	});
-
-	it("returns null for tampered hmac values", async () => {
-		const state = createStateContext();
-		const [payload, signature] = (await state.seal({ secure: true })).split(
-			".",
-		);
-
-		await expect(
-			state.unseal(`${payload}.${mutateSegment(signature ?? "")}`),
-		).resolves.toBeNull();
-	});
-
-	it("returns null for tampered payload values", async () => {
-		const state = createStateContext();
-		const [payload, signature] = (await state.seal({ secure: true })).split(
-			".",
-		);
-
-		await expect(
-			state.unseal(`${mutateSegment(payload ?? "")}.${signature}`),
-		).resolves.toBeNull();
-	});
-
-	it("returns null for malformed tokens without throwing", async () => {
-		const state = createStateContext();
-
-		const resultPromise = state.unseal("garbage");
-		expect(resultPromise).toBeInstanceOf(Promise);
-		await expect(resultPromise).resolves.toBeNull();
-	});
-
-	it("supports custom secrets", async () => {
-		const writer = createStateContext("custom-secret");
-		const reader = createStateContext("custom-secret");
-
-		const token = await writer.seal({ secretScoped: true });
-
-		await expect(reader.unseal(token)).resolves.toEqual({ secretScoped: true });
-	});
-
-	it("round-trips null payloads", async () => {
-		const state = createStateContext();
-
-		await expect(state.unseal(await state.seal(null))).resolves.toBeNull();
-	});
-
-	it("round-trips nested objects", async () => {
-		const state = createStateContext();
-		const data = {
-			checkout: {
-				items: [
-					{ id: "item-1", quantity: 2 },
-					{ id: "item-2", quantity: 1 },
-				],
-				totals: {
-					currency: "KRW",
-					value: 42_000,
-				},
-			},
-		};
-
-		await expect(state.unseal(await state.seal(data))).resolves.toEqual(data);
-	});
-});

package/src/__tests__/stealth.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { SDKError } from "../errors";
-import { getStealthProfile, listStealthProfiles } from "../stealth/profiles";
-
-describe("stealth profiles", () => {
-	it("returns the chrome-131 profile", () => {
-		const profile = getStealthProfile("chrome-131");
-
-		expect(profile.platform).toBe("macos");
-		expect(profile.tlsClientIdentifier).toBe("chrome_131");
-		expect(profile.ja4).toBe("t13d1516h2_8daaf6152771_02713d6af862");
-	});
-
-	it("returns the chrome-146 profile without unverified ja4", () => {
-		const profile = getStealthProfile("chrome-146");
-
-		expect(profile.platform).toBe("macos");
-		expect(profile.tlsClientIdentifier).toBe("chrome_146");
-		expect(profile.ja4).toBeUndefined();
-	});
-
-	it("returns the firefox-147 profile", () => {
-		const profile = getStealthProfile("firefox-147");
-
-		expect(profile.platform).toBe("macos");
-		expect(profile.tlsClientIdentifier).toBe("firefox_147");
-	});
-
-	it("returns the ios-safari-26 profile", () => {
-		const profile = getStealthProfile("ios-safari-26");
-
-		expect(profile.platform).toBe("ios");
-		expect(profile.tlsClientIdentifier).toBe("safari_ios_26_0");
-	});
-
-	it("throws SDKError for unknown profiles", () => {
-		expect(() => getStealthProfile("unknown-profile")).toThrow(SDKError);
-		expect(() => getStealthProfile("unknown-profile")).toThrow(
-			"Unknown stealth profile: unknown-profile",
-		);
-	});
-
-	it("lists 20+ bundled profiles", () => {
-		const profiles = listStealthProfiles();
-
-		expect(profiles.length).toBeGreaterThanOrEqual(20);
-		expect(profiles).toEqual(
-			expect.arrayContaining([
-				"chrome-131",
-				"chrome-146",
-				"firefox-147",
-				"ios-safari-26",
-			]),
-		);
-	});
-});

package/src/__tests__/testing.test.ts

@@ -1,97 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { z } from "zod";
-
-import { defineProvider } from "../define";
-import * as sdk from "../index";
-import {
-	describeTransform,
-	runStandardTests,
-	snapshotTransform,
-	toMatchShape,
-} from "../testing";
-
-const testProvider = defineProvider({
-	id: "test-provider",
-	version: "1.0.0",
-	runtime: "standard",
-	meta: {
-		displayName: "Test Provider",
-		category: "test",
-	},
-	operations: {
-		search: {
-			input: z.object({ q: z.string() }),
-			output: z.object({ result: z.string() }),
-			handler: async (_ctx, input: unknown) => {
-				const { q } = z.object({ q: z.string() }).parse(input);
-
-				return { result: `found: ${q}` };
-			},
-			fixtures: {
-				request: { q: "hello" },
-				response: { result: "found: hello" },
-			},
-		},
-	},
-});
-
-runStandardTests(testProvider);
-
-describeTransform("double-value", { value: 2 }, { doubled: 4 }, (raw) => ({
-	doubled: raw.value * 2,
-}));
-
-describe("toMatchShape", () => {
-	it("passes when all shape keys match", () => {
-		expect(() => {
-			toMatchShape(
-				{ name: "Alice", age: 30, extra: "ignored" },
-				{ name: "Alice", age: 30 },
-			);
-		}).not.toThrow();
-	});
-
-	it("supports nested type descriptors", () => {
-		expect(() => {
-			toMatchShape(
-				{
-					name: "Alice",
-					age: 30,
-					tags: ["pro"],
-					metadata: { source: "fixture" },
-				},
-				{
-					name: "string",
-					age: "number",
-					tags: "array",
-					metadata: { source: "string" },
-				},
-			);
-		}).not.toThrow();
-	});
-
-	it("fails when shape key does not match", () => {
-		expect(() => {
-			toMatchShape({ name: "Bob" }, { name: "Alice" });
-		}).toThrow();
-	});
-
-	it("fails when type descriptor does not match", () => {
-		expect(() => {
-			toMatchShape({ name: 123 }, { name: "string" });
-		}).toThrow();
-	});
-});
-
-describe("testing exports", () => {
-	it("re-exports testing helpers from package root", () => {
-		expect(typeof sdk.runStandardTests).toBe("function");
-		expect("describeTransform" in sdk).toBe(false);
-		expect(typeof sdk.toMatchShape).toBe("function");
-		expect(typeof sdk.snapshotTransform).toBe("function");
-	});
-
-	it("exposes snapshotTransform from testing entrypoint", () => {
-		expect(typeof snapshotTransform).toBe("function");
-	});
-});