@replanejs/test-suite 0.8.19 → 0.9.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
 import { ReplaneAdmin } from "@replanejs/admin";
-import { ReplaneError, ReplaneErrorCode, createReplaneClient } from "@replanejs/sdk";
+import { Replane, ReplaneError, ReplaneErrorCode } from "@replanejs/sdk";
 
 //#region src/utils.ts
 /**
@@ -209,15 +209,17 @@ function createTestContext(admin, workspaceId, projectId, environmentId, sdkKey,
 		sync,
 		async createClient(clientOptions) {
 			await sync();
-			return createReplaneClient({
+			const client = new Replane({
+				logger: options.debug ? console : silentLogger,
+				context: clientOptions?.context,
+				defaults: clientOptions?.defaults
+			});
+			await client.connect({
 				sdkKey,
 				baseUrl: options.edgeApiBaseUrl,
-				logger: silentLogger,
-				initializationTimeoutMs: defaultTimeout,
-				context: clientOptions?.context,
-				defaults: clientOptions?.defaults,
-				required: clientOptions?.required
+				connectTimeoutMs: defaultTimeout
 			});
+			return client;
 		},
 		async createConfig(name, value, configOptions) {
 			await admin.configs.create({
@@ -225,7 +227,6 @@ function createTestContext(admin, workspaceId, projectId, environmentId, sdkKey,
 				name,
 				description: configOptions?.description ?? "",
 				editors: [],
-				maintainers: [],
 				base: {
 					value,
 					schema: null,
@@ -317,7 +318,7 @@ function testSuite(options) {
 		});
 		afterAll(async () => {
 			for (const client of activeClients) try {
-				client.close();
+				client.disconnect();
 			} catch {}
 			activeClients.length = 0;
 			if (workspaceId) await admin.workspaces.delete({ workspaceId });
@@ -340,10 +341,10 @@ function testSuite(options) {
 		describe("SDK Connection", () => {
 			it("should connect and receive initial configs", async () => {
 				await ctx.createConfig("test-config", "initial-value");
-				const client = trackClient(await ctx.createClient({ required: ["test-config"] }));
+				const client = trackClient(await ctx.createClient({}));
 				const value = client.get("test-config");
 				expect(value).toBe("initial-value");
-				client.close();
+				client.disconnect();
 			});
 			it("should handle empty project (no configs)", async () => {
 				const emptyProjectRes = await admin.projects.create({
@@ -362,51 +363,49 @@ function testSuite(options) {
 					edgeApiBaseUrl,
 					sdkKey
 				});
-				const client = trackClient(await createReplaneClient({
+				const emptyClient = new Replane({ logger: silentLogger });
+				await emptyClient.connect({
 					sdkKey: emptySdkKeyRes.key,
 					baseUrl: edgeApiBaseUrl,
-					logger: silentLogger,
-					initializationTimeoutMs: defaultTimeout
-				}));
+					connectTimeoutMs: defaultTimeout
+				});
+				const client = trackClient(emptyClient);
 				expect(() => client.get("nonexistent")).toThrow();
-				client.close();
+				client.disconnect();
 				await admin.projects.delete({ projectId: emptyProjectRes.id });
 			});
 			it("should use default values when config not found", async () => {
 				const client = trackClient(await ctx.createClient({ defaults: { "missing-config": "default-value" } }));
 				const value = client.get("missing-config");
 				expect(value).toBe("default-value");
-				client.close();
-			});
-			it("should throw when required config is missing", { timeout: 15e3 }, async () => {
-				await expect(ctx.createClient({ required: ["definitely-missing-config"] })).rejects.toThrow();
+				client.disconnect();
 			});
 		});
 		describe("Get Config", () => {
 			it("should get string config", async () => {
 				await ctx.createConfig("string-config", "hello");
-				const client = trackClient(await ctx.createClient({ required: ["string-config"] }));
+				const client = trackClient(await ctx.createClient({}));
 				expect(client.get("string-config")).toBe("hello");
-				client.close();
+				client.disconnect();
 			});
 			it("should get number config", async () => {
 				await ctx.createConfig("number-config", 42);
-				const client = trackClient(await ctx.createClient({ required: ["number-config"] }));
+				const client = trackClient(await ctx.createClient({}));
 				expect(client.get("number-config")).toBe(42);
-				client.close();
+				client.disconnect();
 			});
 			it("should get boolean config", async () => {
 				await ctx.createConfig("boolean-config", true);
-				const client = trackClient(await ctx.createClient({ required: ["boolean-config"] }));
+				const client = trackClient(await ctx.createClient({}));
 				expect(client.get("boolean-config")).toBe(true);
-				client.close();
+				client.disconnect();
 			});
 			it("should get object config", async () => {
 				const objValue = { nested: { value: "deep" } };
 				await ctx.createConfig("object-config", objValue);
-				const client = trackClient(await ctx.createClient({ required: ["object-config"] }));
+				const client = trackClient(await ctx.createClient({}));
 				expect(client.get("object-config")).toEqual(objValue);
-				client.close();
+				client.disconnect();
 			});
 			it("should get array config", async () => {
 				const arrValue = [
@@ -415,21 +414,21 @@ function testSuite(options) {
 					3
 				];
 				await ctx.createConfig("array-config", arrValue);
-				const client = trackClient(await ctx.createClient({ required: ["array-config"] }));
+				const client = trackClient(await ctx.createClient({}));
 				expect(client.get("array-config")).toEqual(arrValue);
-				client.close();
+				client.disconnect();
 			});
 			it("should get null config", async () => {
 				await ctx.createConfig("null-config", null);
-				const client = trackClient(await ctx.createClient({ required: ["null-config"] }));
+				const client = trackClient(await ctx.createClient({}));
 				expect(client.get("null-config")).toBe(null);
-				client.close();
+				client.disconnect();
 			});
 			it("should return default value when config not found", async () => {
 				const client = trackClient(await ctx.createClient());
 				const value = client.get("nonexistent", { default: "fallback" });
 				expect(value).toBe("fallback");
-				client.close();
+				client.disconnect();
 			});
 			it("should throw ReplaneError when config not found and no default", async () => {
 				const client = trackClient(await ctx.createClient());
@@ -440,13 +439,13 @@ function testSuite(options) {
 					expect(error).toBeInstanceOf(ReplaneError);
 					expect(error.code).toBe(ReplaneErrorCode.NotFound);
 				}
-				client.close();
+				client.disconnect();
 			});
 		});
 		describe("Real-time Updates", () => {
 			it("should receive config updates via subscription", async () => {
 				await ctx.createConfig("live-config", "initial");
-				const client = trackClient(await ctx.createClient({ required: ["live-config"] }));
+				const client = trackClient(await ctx.createClient({}));
 				expect(client.get("live-config")).toBe("initial");
 				const updateSignal = createSignal();
 				client.subscribe("live-config", (config) => {
@@ -456,11 +455,11 @@ function testSuite(options) {
 				const newValue = await updateSignal.wait({ timeout: defaultTimeout });
 				expect(newValue).toBe("updated");
 				expect(client.get("live-config")).toBe("updated");
-				client.close();
+				client.disconnect();
 			});
 			it("should receive multiple updates in order", async () => {
 				await ctx.createConfig("multi-update-config", 0);
-				const client = trackClient(await ctx.createClient({ required: ["multi-update-config"] }));
+				const client = trackClient(await ctx.createClient({}));
 				expect(client.get("multi-update-config")).toBe(0);
 				const collector = createCollector();
 				client.subscribe("multi-update-config", (config) => {
@@ -478,11 +477,11 @@ function testSuite(options) {
 					2,
 					3
 				]);
-				client.close();
+				client.disconnect();
 			});
 			it("should handle rapid updates", async () => {
 				await ctx.createConfig("rapid-config", 0);
-				const client = trackClient(await ctx.createClient({ required: ["rapid-config"] }));
+				const client = trackClient(await ctx.createClient({}));
 				expect(client.get("rapid-config")).toBe(0);
 				const collector = createCollector();
 				client.subscribe("rapid-config", (config) => {
@@ -492,12 +491,12 @@ function testSuite(options) {
 				for (let i = 1; i <= updateCount; i++) await ctx.updateConfig("rapid-config", i);
 				await collector.waitFor((v) => v === updateCount, { timeout: defaultTimeout });
 				expect(client.get("rapid-config")).toBe(updateCount);
-				client.close();
+				client.disconnect();
 			});
 			it("should call global subscription for any config change", async () => {
 				await ctx.createConfig("config-a", "a");
 				await ctx.createConfig("config-b", "b");
-				const client = trackClient(await ctx.createClient({ required: ["config-a", "config-b"] }));
+				const client = trackClient(await ctx.createClient({}));
 				expect(client.get("config-a")).toBe("a");
 				expect(client.get("config-b")).toBe("b");
 				const collector = createCollector();
@@ -515,11 +514,11 @@ function testSuite(options) {
 				const bUpdate = values.find((v) => v.name === "config-b");
 				expect(aUpdate?.value).toBe("a-updated");
 				expect(bUpdate?.value).toBe("b-updated");
-				client.close();
+				client.disconnect();
 			});
 			it("should allow unsubscribing", async () => {
 				await ctx.createConfig("unsub-config", "initial");
-				const client = trackClient(await ctx.createClient({ required: ["unsub-config"] }));
+				const client = trackClient(await ctx.createClient({}));
 				expect(client.get("unsub-config")).toBe("initial");
 				const collector = createCollector();
 				const unsubscribe = client.subscribe("unsub-config", (config) => {
@@ -531,7 +530,7 @@ function testSuite(options) {
 				await ctx.updateConfig("unsub-config", "update-2");
 				await delay(2e3);
 				expect(collector.count()).toBe(1);
-				client.close();
+				client.disconnect();
 			});
 		});
 		describe("Override Evaluation", () => {
@@ -545,21 +544,15 @@ function testSuite(options) {
 					}],
 					value: "production-value"
 				}] });
-				const client1 = trackClient(await ctx.createClient({ required: ["env-config"] }));
+				const client1 = trackClient(await ctx.createClient({}));
 				expect(client1.get("env-config")).toBe("default");
-				client1.close();
-				const client2 = trackClient(await ctx.createClient({
-					context: { env: "production" },
-					required: ["env-config"]
-				}));
+				client1.disconnect();
+				const client2 = trackClient(await ctx.createClient({ context: { env: "production" } }));
 				expect(client2.get("env-config")).toBe("production-value");
-				client2.close();
-				const client3 = trackClient(await ctx.createClient({
-					context: { env: "staging" },
-					required: ["env-config"]
-				}));
+				client2.disconnect();
+				const client3 = trackClient(await ctx.createClient({ context: { env: "staging" } }));
 				expect(client3.get("env-config")).toBe("default");
-				client3.close();
+				client3.disconnect();
 			});
 			it("should evaluate in condition", async () => {
 				await ctx.createConfig("region-config", "default", { overrides: [{
@@ -571,24 +564,15 @@ function testSuite(options) {
 					}],
 					value: "western"
 				}] });
-				const client1 = trackClient(await ctx.createClient({
-					context: { region: "us" },
-					required: ["region-config"]
-				}));
+				const client1 = trackClient(await ctx.createClient({ context: { region: "us" } }));
 				expect(client1.get("region-config")).toBe("western");
-				client1.close();
-				const client2 = trackClient(await ctx.createClient({
-					context: { region: "eu" },
-					required: ["region-config"]
-				}));
+				client1.disconnect();
+				const client2 = trackClient(await ctx.createClient({ context: { region: "eu" } }));
 				expect(client2.get("region-config")).toBe("western");
-				client2.close();
-				const client3 = trackClient(await ctx.createClient({
-					context: { region: "asia" },
-					required: ["region-config"]
-				}));
+				client2.disconnect();
+				const client3 = trackClient(await ctx.createClient({ context: { region: "asia" } }));
 				expect(client3.get("region-config")).toBe("default");
-				client3.close();
+				client3.disconnect();
 			});
 			it("should evaluate not_in condition", async () => {
 				await ctx.createConfig("allow-config", "allowed", { overrides: [{
@@ -600,18 +584,12 @@ function testSuite(options) {
 					}],
 					value: "not-blocked"
 				}] });
-				const client1 = trackClient(await ctx.createClient({
-					context: { country: "blocked1" },
-					required: ["allow-config"]
-				}));
+				const client1 = trackClient(await ctx.createClient({ context: { country: "blocked1" } }));
 				expect(client1.get("allow-config")).toBe("allowed");
-				client1.close();
-				const client2 = trackClient(await ctx.createClient({
-					context: { country: "normal" },
-					required: ["allow-config"]
-				}));
+				client1.disconnect();
+				const client2 = trackClient(await ctx.createClient({ context: { country: "normal" } }));
 				expect(client2.get("allow-config")).toBe("not-blocked");
-				client2.close();
+				client2.disconnect();
 			});
 			it("should evaluate numeric comparison conditions", async () => {
 				await ctx.createConfig("tier-config", "free", { overrides: [{
@@ -623,24 +601,15 @@ function testSuite(options) {
 					}],
 					value: "premium"
 				}] });
-				const client1 = trackClient(await ctx.createClient({
-					context: { level: 5 },
-					required: ["tier-config"]
-				}));
+				const client1 = trackClient(await ctx.createClient({ context: { level: 5 } }));
 				expect(client1.get("tier-config")).toBe("free");
-				client1.close();
-				const client2 = trackClient(await ctx.createClient({
-					context: { level: 10 },
-					required: ["tier-config"]
-				}));
+				client1.disconnect();
+				const client2 = trackClient(await ctx.createClient({ context: { level: 10 } }));
 				expect(client2.get("tier-config")).toBe("premium");
-				client2.close();
-				const client3 = trackClient(await ctx.createClient({
-					context: { level: 15 },
-					required: ["tier-config"]
-				}));
+				client2.disconnect();
+				const client3 = trackClient(await ctx.createClient({ context: { level: 15 } }));
 				expect(client3.get("tier-config")).toBe("premium");
-				client3.close();
+				client3.disconnect();
 			});
 			it("should evaluate and condition", async () => {
 				await ctx.createConfig("combo-config", "default", { overrides: [{
@@ -659,24 +628,18 @@ function testSuite(options) {
 					}],
 					value: "enterprise-verified"
 				}] });
-				const client1 = trackClient(await ctx.createClient({
-					context: {
-						plan: "enterprise",
-						verified: true
-					},
-					required: ["combo-config"]
-				}));
+				const client1 = trackClient(await ctx.createClient({ context: {
+					plan: "enterprise",
+					verified: true
+				} }));
 				expect(client1.get("combo-config")).toBe("enterprise-verified");
-				client1.close();
-				const client2 = trackClient(await ctx.createClient({
-					context: {
-						plan: "enterprise",
-						verified: false
-					},
-					required: ["combo-config"]
-				}));
+				client1.disconnect();
+				const client2 = trackClient(await ctx.createClient({ context: {
+					plan: "enterprise",
+					verified: false
+				} }));
 				expect(client2.get("combo-config")).toBe("default");
-				client2.close();
+				client2.disconnect();
 			});
 			it("should evaluate or condition", async () => {
 				await ctx.createConfig("either-config", "default", { overrides: [{
@@ -695,24 +658,15 @@ function testSuite(options) {
 					}],
 					value: "privileged"
 				}] });
-				const client1 = trackClient(await ctx.createClient({
-					context: { role: "admin" },
-					required: ["either-config"]
-				}));
+				const client1 = trackClient(await ctx.createClient({ context: { role: "admin" } }));
 				expect(client1.get("either-config")).toBe("privileged");
-				client1.close();
-				const client2 = trackClient(await ctx.createClient({
-					context: { role: "superadmin" },
-					required: ["either-config"]
-				}));
+				client1.disconnect();
+				const client2 = trackClient(await ctx.createClient({ context: { role: "superadmin" } }));
 				expect(client2.get("either-config")).toBe("privileged");
-				client2.close();
-				const client3 = trackClient(await ctx.createClient({
-					context: { role: "user" },
-					required: ["either-config"]
-				}));
+				client2.disconnect();
+				const client3 = trackClient(await ctx.createClient({ context: { role: "user" } }));
 				expect(client3.get("either-config")).toBe("default");
-				client3.close();
+				client3.disconnect();
 			});
 			it("should allow per-request context override", async () => {
 				await ctx.createConfig("dynamic-config", "default", { overrides: [{
@@ -724,11 +678,11 @@ function testSuite(options) {
 					}],
 					value: "feature-on"
 				}] });
-				const client = trackClient(await ctx.createClient({ required: ["dynamic-config"] }));
+				const client = trackClient(await ctx.createClient({}));
 				expect(client.get("dynamic-config")).toBe("default");
 				expect(client.get("dynamic-config", { context: { feature: "enabled" } })).toBe("feature-on");
 				expect(client.get("dynamic-config")).toBe("default");
-				client.close();
+				client.disconnect();
 			});
 			it("should apply first matching override", async () => {
 				await ctx.createConfig("priority-config", "default", { overrides: [
@@ -760,22 +714,19 @@ function testSuite(options) {
 						value: "has-score"
 					}
 				] });
-				const client = trackClient(await ctx.createClient({
-					context: {
-						tier: "gold",
-						score: 100
-					},
-					required: ["priority-config"]
-				}));
+				const client = trackClient(await ctx.createClient({ context: {
+					tier: "gold",
+					score: 100
+				} }));
 				expect(client.get("priority-config")).toBe("gold-value");
-				client.close();
+				client.disconnect();
 			});
 		});
 		describe("Snapshot", () => {
 			it("should create snapshot with current configs", async () => {
 				await ctx.createConfig("snap-config-1", "value-1");
 				await ctx.createConfig("snap-config-2", "value-2");
-				const client = trackClient(await ctx.createClient({ required: ["snap-config-1", "snap-config-2"] }));
+				const client = trackClient(await ctx.createClient({}));
 				const snapshot = client.getSnapshot();
 				expect(snapshot.configs).toMatchInlineSnapshot(`
           [
@@ -792,42 +743,32 @@ function testSuite(options) {
           ]
         `);
 				expect(snapshot.configs.map((c) => c.name).sort()).toEqual(["snap-config-1", "snap-config-2"]);
-				client.close();
-			});
-			it("should include context in snapshot", async () => {
-				await ctx.createConfig("ctx-config", "value");
-				const client = trackClient(await ctx.createClient({
-					context: { userId: "123" },
-					required: ["ctx-config"]
-				}));
-				const snapshot = client.getSnapshot();
-				expect(snapshot.context).toEqual({ userId: "123" });
-				client.close();
+				client.disconnect();
 			});
 		});
 		describe("Error Handling", () => {
 			it("should throw on invalid SDK key", async () => {
-				await expect(createReplaneClient({
+				const invalidClient = new Replane({ logger: silentLogger });
+				await expect(invalidClient.connect({
 					sdkKey: "invalid-key",
 					baseUrl: edgeApiBaseUrl,
-					logger: silentLogger,
-					initializationTimeoutMs: 2e3
+					connectTimeoutMs: 2e3
 				})).rejects.toThrow();
 			});
-			it("should handle closed client gracefully", async () => {
+			it("should handle disconnected client gracefully", async () => {
 				await ctx.createConfig("close-test", "value");
-				const client = trackClient(await ctx.createClient({ required: ["close-test"] }));
+				const client = trackClient(await ctx.createClient({ defaults: { "close-test": "default" } }));
 				expect(client.get("close-test")).toBe("value");
-				client.close();
+				client.disconnect();
 				const cachedValue = client.get("close-test");
 				expect(cachedValue).toBe("value");
 			});
 			it("should timeout on unreachable server", async () => {
-				await expect(createReplaneClient({
+				const unreachableClient = new Replane({ logger: silentLogger });
+				await expect(unreachableClient.connect({
 					sdkKey: "rp_test",
 					baseUrl: "http://localhost:59999",
-					logger: silentLogger,
-					initializationTimeoutMs: 1e3
+					connectTimeoutMs: 1e3
 				})).rejects.toThrow();
 			});
 		});
@@ -842,23 +783,23 @@ function testSuite(options) {
 				const value = await configSignal.wait({ timeout: defaultTimeout });
 				expect(value).toBe("late-value");
 				expect(client.get("late-config")).toBe("late-value");
-				client.close();
+				client.disconnect();
 			});
 			it("should ignore config deletion on client", async () => {
 				await ctx.createConfig("delete-me", "exists");
-				const client = trackClient(await ctx.createClient({ required: ["delete-me"] }));
+				const client = trackClient(await ctx.createClient({}));
 				expect(client.get("delete-me")).toBe("exists");
 				await ctx.deleteConfig("delete-me");
 				await delay(1e3);
 				expect(client.get("delete-me")).toBe("exists");
-				client.close();
+				client.disconnect();
 			});
 		});
 		describe("Concurrent Clients", () => {
 			it("should handle multiple clients with same SDK key", async () => {
 				await ctx.createConfig("shared-config", "initial");
-				const client1 = trackClient(await ctx.createClient({ required: ["shared-config"] }));
-				const client2 = trackClient(await ctx.createClient({ required: ["shared-config"] }));
+				const client1 = trackClient(await ctx.createClient({}));
+				const client2 = trackClient(await ctx.createClient({}));
 				expect(client1.get("shared-config")).toBe("initial");
 				expect(client2.get("shared-config")).toBe("initial");
 				const signal1 = createSignal();
@@ -873,8 +814,8 @@ function testSuite(options) {
 				const [v1, v2] = await Promise.all([signal1.wait({ timeout: defaultTimeout }), signal2.wait({ timeout: defaultTimeout })]);
 				expect(v1).toBe("updated");
 				expect(v2).toBe("updated");
-				client1.close();
-				client2.close();
+				client1.disconnect();
+				client2.disconnect();
 			});
 			it("should isolate context between clients", async () => {
 				await ctx.createConfig("context-config", "default", { overrides: [{
@@ -886,18 +827,12 @@ function testSuite(options) {
 					}],
 					value: "prod-value"
 				}] });
-				const client1 = trackClient(await ctx.createClient({
-					context: { env: "prod" },
-					required: ["context-config"]
-				}));
-				const client2 = trackClient(await ctx.createClient({
-					context: { env: "dev" },
-					required: ["context-config"]
-				}));
+				const client1 = trackClient(await ctx.createClient({ context: { env: "prod" } }));
+				const client2 = trackClient(await ctx.createClient({ context: { env: "dev" } }));
 				expect(client1.get("context-config")).toBe("prod-value");
 				expect(client2.get("context-config")).toBe("default");
-				client1.close();
-				client2.close();
+				client1.disconnect();
+				client2.disconnect();
 			});
 		});
 	});