@apifuse/connector-sdk 2.0.0-beta.1

package/src/__tests__/session.test.ts

@@ -0,0 +1,231 @@
+import { describe, expect, it } from "bun:test";
+
+import {
+	createSessionStore,
+	createSqliteSessionStore,
+	type SessionFetch,
+	SupabaseSessionStore,
+} from "../runtime/session";
+
+type StoredSecretRecord = {
+	connection_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/connection_secrets") {
+			return new Response("not found", { status: 404 });
+		}
+
+		if (method === "GET") {
+			const connectionId = requestUrl.searchParams
+				.get("connection_id")
+				?.replace("eq.", "");
+			const result =
+				storedRecord && storedRecord.connection_id === connectionId
+					? [
+							{
+								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 connectionId = requestUrl.searchParams
+				.get("connection_id")
+				?.replace("eq.", "");
+			if (storedRecord?.connection_id === connectionId) {
+				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({
+			connectionId: "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",
+			connectionId: "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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "bun:test";
+import { z } from "zod";
+
+import { defineConnector } from "../define";
+import * as sdk from "../index";
+import {
+	describeTransform,
+	runStandardTests,
+	snapshotTransform,
+	toMatchShape,
+} from "../testing";
+
+const testConnector = defineConnector({
+	id: "test-connector",
+	version: "1.0.0",
+	runtime: "standard",
+	meta: {
+		displayName: "Test Connector",
+		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(testConnector);
+
+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");
+	});
+});