@lix-js/sdk 0.5.0-preview.1 → 0.5.0

package/src/observe/create-observe.test.ts

@@ -1,5 +1,8 @@
 import { test, expect } from "vitest";
 import { openLix } from "../lix/open-lix.js";
+import { createVersion } from "../version/create-version.js";
+import { mergeVersion } from "../version/merge-version.js";
+import type { LixSchemaDefinition } from "../schema-definition/definition.js";
 
 /**
  * These tests use the key_value table as an example entity in the state.
@@ -400,6 +403,242 @@ test("observing specific key should not emit when unrelated key is inserted", as
 	await lix.close();
 });
 
+test("observing a state emits when a version merge happens", async () => {
+	const schema: LixSchemaDefinition = {
+		"x-lix-key": "observe_merge_entity",
+		"x-lix-version": "1.0",
+		type: "object",
+		properties: {
+			v: { type: "string" },
+		},
+		required: ["v"],
+		additionalProperties: false,
+	} as const;
+
+	const lix = await openLix({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true },
+				lixcol_version_id: "global",
+			},
+		],
+	});
+
+	await lix.db.insertInto("stored_schema").values({ value: schema }).execute();
+
+	const target = await createVersion({ lix, name: "target" });
+	const source = await createVersion({ lix, name: "source" });
+
+	await lix.db
+		.insertInto("state_by_version")
+		.values({
+			entity_id: "entity-from-source",
+			schema_key: "observe_merge_entity",
+			file_id: "file-observe",
+			version_id: source.id,
+			plugin_key: "test_plugin",
+			snapshot_content: { v: "from-source" },
+			schema_version: "1.0",
+		})
+		.execute();
+
+	const emissions: Array<
+		{ entity_id: string; snapshot_content: Record<string, unknown> }[]
+	> = [];
+
+	const targetVersionQuery = lix.db
+		.selectFrom("state_by_version")
+		.select(["entity_id", "snapshot_content"])
+		.where("version_id", "=", target.id)
+		.where("schema_key", "=", "observe_merge_entity");
+
+	const subscription = lix
+		.observe(targetVersionQuery)
+		.subscribe({ next: (rows) => emissions.push(rows) });
+
+	await new Promise((resolve) => setTimeout(resolve, 20));
+	expect(emissions).toHaveLength(1);
+	expect(emissions[0]).toEqual([]);
+
+	await mergeVersion({ lix, source, target });
+	await new Promise((resolve) => setTimeout(resolve, 50));
+	expect(emissions).toHaveLength(2);
+	expect(emissions[1]).toEqual([
+		{
+			entity_id: "entity-from-source",
+			snapshot_content: { v: "from-source" },
+		},
+	]);
+
+	subscription.unsubscribe();
+	await lix.close();
+});
+
+test("observing active state re-emits when active_version changes", async () => {
+	const schema: LixSchemaDefinition = {
+		"x-lix-key": "observe_active_switch_entity",
+		"x-lix-version": "1.0",
+		type: "object",
+		properties: {
+			v: { type: "string" },
+		},
+		required: ["v"],
+		additionalProperties: false,
+	} as const;
+
+	const lix = await openLix({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true },
+				lixcol_version_id: "global",
+			},
+		],
+	});
+
+	await lix.db.insertInto("stored_schema").values({ value: schema }).execute();
+
+	const versionA = await createVersion({ lix, name: "active-a" });
+	const versionB = await createVersion({ lix, name: "active-b" });
+
+	await lix.db
+		.insertInto("state_by_version")
+		.values({
+			entity_id: "active-entity",
+			schema_key: schema["x-lix-key"],
+			file_id: "file-active",
+			version_id: versionA.id,
+			plugin_key: "test_plugin",
+			snapshot_content: { v: "from-a" },
+			schema_version: schema["x-lix-version"],
+		})
+		.execute();
+
+	await lix.db
+		.insertInto("state_by_version")
+		.values({
+			entity_id: "active-entity",
+			schema_key: schema["x-lix-key"],
+			file_id: "file-active",
+			version_id: versionB.id,
+			plugin_key: "test_plugin",
+			snapshot_content: { v: "from-b" },
+			schema_version: schema["x-lix-version"],
+		})
+		.execute();
+
+	// Start from version A so the first emission includes its state.
+	await lix.db
+		.updateTable("active_version")
+		.set({ version_id: versionA.id })
+		.execute();
+
+	const emissions: Array<
+		Array<{ entity_id: string; snapshot_content: Record<string, unknown> }>
+	> = [];
+
+	const activeStateQuery = lix.db
+		.selectFrom("state")
+		.select(["entity_id", "snapshot_content"])
+		.where("schema_key", "=", schema["x-lix-key"]);
+
+	const subscription = lix
+		.observe(activeStateQuery)
+		.subscribe({ next: (rows) => emissions.push(rows) });
+
+	await new Promise((resolve) => setTimeout(resolve, 20));
+	expect(emissions).toHaveLength(1);
+	expect(emissions[0]).toEqual([
+		{ entity_id: "active-entity", snapshot_content: { v: "from-a" } },
+	]);
+
+	// Switch to version B by updating active_version; observer should re-run.
+	await lix.db.transaction().execute(async (trx) => {
+		await trx
+			.updateTable("active_version")
+			.set({ version_id: versionB.id })
+			.execute();
+	});
+
+	await new Promise((resolve) => setTimeout(resolve, 50));
+
+	expect(emissions).toHaveLength(2);
+	expect(emissions[1]).toEqual([
+		{ entity_id: "active-entity", snapshot_content: { v: "from-b" } },
+	]);
+
+	subscription.unsubscribe();
+	await lix.close();
+});
+
+test("observing entity views re-emits when active_version changes", async () => {
+	const lix = await openLix({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true },
+				lixcol_version_id: "global",
+			},
+		],
+	});
+
+	const versionA = await createVersion({ lix, name: "kv-active-a" });
+	const versionB = await createVersion({ lix, name: "kv-active-b" });
+
+	await lix.db
+		.insertInto("key_value_by_version")
+		.values({
+			key: "kv_active_key",
+			value: "from-a",
+			lixcol_version_id: versionA.id,
+		})
+		.execute();
+
+	await lix.db
+		.insertInto("key_value_by_version")
+		.values({
+			key: "kv_active_key",
+			value: "from-b",
+			lixcol_version_id: versionB.id,
+		})
+		.execute();
+
+	await lix.db
+		.updateTable("active_version")
+		.set({ version_id: versionA.id })
+		.execute();
+
+	const emissions: Array<Array<{ key: string; value: unknown }>> = [];
+
+	const subscription = lix
+		.observe(
+			lix.db
+				.selectFrom("key_value")
+				.select(["key", "value"])
+				.where("key", "=", "kv_active_key")
+		)
+		.subscribe({ next: (rows) => emissions.push(rows) });
+
+	await new Promise((resolve) => setTimeout(resolve, 20));
+	expect(emissions).toHaveLength(1);
+	expect(emissions[0]).toEqual([{ key: "kv_active_key", value: "from-a" }]);
+
+	await lix.db.transaction().execute(async (trx) => {
+		await trx
+			.updateTable("active_version")
+			.set({ version_id: versionB.id })
+			.execute();
+	});
+
+	await new Promise((resolve) => setTimeout(resolve, 50));
+	expect(emissions).toHaveLength(2);
+	expect(emissions[1]).toEqual([{ key: "kv_active_key", value: "from-b" }]);
+
+	subscription.unsubscribe();
+	await lix.close();
+});
+
 test("subscribeTakeFirst with explicit limit(1) should not double-limit", async () => {
 	const lix = await openLix({});
 	const values: any[] = [];
@@ -550,41 +789,109 @@ test("query with change table join should always re-execute", async () => {
 	await lix.close();
 });
 
-test("query with state_all table should always re-execute", async () => {
+test("state_by_version observer re-executes when observed schema changes", async () => {
 	const lix = await openLix({});
-	const stateAllEmissions: any[] = [];
+	const emissions: any[] = [];
 
-	// Observe a query that uses the state_all table
-	// This should always re-execute because state_all includes all versions
-	const stateAllSub = lix
+	const sub = lix
 		.observe(
 			lix.db
-				.selectFrom("state_all")
+				.selectFrom("state_by_version")
 				.selectAll()
-				.where("schema_key", "=", "lix_version")
+				.where("schema_key", "=", "lix_key_value")
 		)
-		.subscribe({ next: (rows) => stateAllEmissions.push(rows) });
+		.subscribe({ next: (rows) => emissions.push(rows) });
 
-	// Wait for initial emission
-	await new Promise((resolve) => setTimeout(resolve, 10));
-	expect(stateAllEmissions).toHaveLength(1);
-
-	const countBefore = stateAllEmissions.length;
+	await new Promise((r) => setTimeout(r, 10));
+	const before = emissions.length;
 
-	// Insert into key_value - should trigger state_all observer
-	// because state_all queries should always re-execute (special case)
+	// Insert into key_value (matching observed schema_key)
 	await lix.db
 		.insertInto("key_value")
 		.values({ key: "state_all_test_key", value: "state_all_test_value" })
 		.execute();
 
-	// Wait for emission
-	await new Promise((resolve) => setTimeout(resolve, 10));
+	await new Promise((r) => setTimeout(r, 10));
+	expect(emissions.length).toBe(before + 1);
+
+	sub.unsubscribe();
+	await lix.close();
+});
+
+test("state_by_version observer does not re-execute for unrelated schema changes", async () => {
+	const lix = await openLix({});
+	const emissions: any[] = [];
+
+	const sub = lix
+		.observe(
+			lix.db
+				.selectFrom("state_by_version")
+				.selectAll()
+				.where("schema_key", "=", "lix_version")
+		)
+		.subscribe({ next: (rows) => emissions.push(rows) });
+
+	await new Promise((r) => setTimeout(r, 10));
+	const before = emissions.length;
+
+	// Insert into key_value (different schema)
+	await lix.db
+		.insertInto("key_value")
+		.values({ key: "state_all_test_key2", value: "state_all_test_value2" })
+		.execute();
+
+	await new Promise((r) => setTimeout(r, 10));
+	// Should not emit again since observed schema_key does not match the change
+	expect(emissions.length).toBe(before);
+
+	sub.unsubscribe();
+	await lix.close();
+});
+
+test("state_by_version observer with version_id filter re-executes only for that version", async () => {
+	const lix = await openLix({});
+	const emissions: any[] = [];
+
+	// Create two versions
+	const vA = await (
+		await import("../version/create-version.js")
+	).createVersion({ lix, name: "obs-A" });
+	const vB = await (
+		await import("../version/create-version.js")
+	).createVersion({ lix, name: "obs-B" });
+
+	const sub = lix
+		.observe(
+			lix.db
+				.selectFrom("state_by_version")
+				.selectAll()
+				.where("schema_key", "=", "lix_key_value")
+				.where("version_id", "=", vA.id)
+		)
+		.subscribe({ next: (rows) => emissions.push(rows) });
+
+	await new Promise((r) => setTimeout(r, 10));
+	const before = emissions.length;
 
-	// state_all observer should have received an update
-	expect(stateAllEmissions).toHaveLength(countBefore + 1);
+	// Insert into different version (vB) - should NOT trigger
+	await lix.db
+		.insertInto("key_value_by_version")
+		.values({ key: "vk_b", value: "b", lixcol_version_id: vB.id })
+		.execute();
 
-	stateAllSub.unsubscribe();
+	await new Promise((r) => setTimeout(r, 10));
+	expect(emissions.length).toBe(before);
+
+	// Insert into observed version (vA) - should trigger
+	await lix.db
+		.insertInto("key_value_by_version")
+		.values({ key: "vk_a", value: "a", lixcol_version_id: vA.id })
+		.execute();
+
+	await new Promise((r) => setTimeout(r, 10));
+	expect(emissions.length).toBe(before + 1);
+
+	sub.unsubscribe();
 	await lix.close();
 });
 
@@ -834,3 +1141,191 @@ test("optimization prevents unnecessary query re-executions", async () => {
 	accountSub.unsubscribe();
 	await lix.close();
 });
+
+test("observe pools identical compiled queries (same instance)", async () => {
+	const lix = await openLix({});
+
+	// Create two separate builders that compile to the same SQL and params
+	const q1 = lix.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "like", "pool_same_%");
+	const q2 = lix.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "like", "pool_same_%");
+
+	const obs1 = lix.observe(q1);
+	const obs2 = lix.observe(q2);
+
+	// Expect a single pooled observable instance
+	expect(obs1).toBe(obs2);
+
+	const a: any[] = [];
+	const b: any[] = [];
+	const sub1 = obs1.subscribe({ next: (rows) => a.push(rows) });
+	const sub2 = obs2.subscribe({ next: (rows) => b.push(rows) });
+
+	await new Promise((r) => setTimeout(r, 10));
+	// Both receive the same initial emission
+	expect(a).toHaveLength(1);
+	expect(b).toHaveLength(1);
+	expect(a[0]).toEqual([]);
+	expect(b[0]).toEqual([]);
+
+	// Mutate and ensure both receive the update
+	await lix.db
+		.insertInto("key_value")
+		.values({ key: "pool_same_1", value: "v1" })
+		.execute();
+	await new Promise((r) => setTimeout(r, 20));
+
+	expect(a[a.length - 1]).toHaveLength(1);
+	expect(b[b.length - 1]).toHaveLength(1);
+
+	sub1.unsubscribe();
+	sub2.unsubscribe();
+	await lix.close();
+});
+
+test("pooled observable persists until last unsubscribe", async () => {
+	const lix = await openLix({});
+	const q = lix.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "like", "pool_persist_%");
+
+	const obs = lix.observe(q);
+	const values1: any[] = [];
+	const values2: any[] = [];
+	const sub1 = obs.subscribe({ next: (rows) => values1.push(rows) });
+	const sub2 = obs.subscribe({ next: (rows) => values2.push(rows) });
+
+	await new Promise((r) => setTimeout(r, 10));
+	const before = values1.length + values2.length;
+
+	// Unsub first; second remains
+	sub1.unsubscribe();
+
+	await lix.db
+		.insertInto("key_value")
+		.values({ key: "pool_persist_1", value: "v1" })
+		.execute();
+	await new Promise((r) => setTimeout(r, 20));
+
+	// Second subscriber still updates
+	expect(values2.length).toBeGreaterThan(0);
+	expect(values1.length + values2.length).toBeGreaterThan(before);
+
+	// Unsub second — pooled upstream should tear down
+	sub2.unsubscribe();
+
+	// Observing again should produce a new instance (cache entry cleaned)
+	const obs2 = lix.observe(q);
+	expect(obs2).not.toBe(obs);
+
+	await lix.close();
+});
+
+test("pooling key includes mode: array vs first", async () => {
+	const lix = await openLix({});
+	const q = lix.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "like", "pool_mode_%");
+
+	const obsArray = lix.observe(q, { mode: "array" });
+	const obsFirst = lix.observe(q, { mode: "first" });
+
+	// Different modes should not pool together
+	expect(obsArray).not.toBe(obsFirst);
+
+	await lix.close();
+});
+
+test("observe pools identical SQL even from different builder instances", async () => {
+	const lix = await openLix({});
+
+	// Construct queries in different orders that compile to identical SQL/params
+	const q1 = lix.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "=", "pool_identity_key");
+
+	const q2 = lix.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "=", "pool_identity_key");
+
+	const obs1 = lix.observe(q1);
+	const obs2 = lix.observe(q2);
+	// Same compiled SQL -> pooled
+	expect(obs1).toBe(obs2);
+
+	await lix.close();
+});
+
+test("observe does not pool different SQL (different where parameters)", async () => {
+	const lix = await openLix({});
+
+	const qa = lix.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "=", "pool_diff_a");
+	const qb = lix.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "=", "pool_diff_b");
+
+	const obsa = lix.observe(qa);
+	const obsb = lix.observe(qb);
+	// Different params -> no pooling
+	expect(obsa).not.toBe(obsb);
+
+	await lix.close();
+});
+
+test("observe does not pool across different Lix instances", async () => {
+	const lix1 = await openLix({});
+	const lix2 = await openLix({});
+
+	const q1 = lix1.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "=", "pool_cross_instance");
+	const q2 = lix2.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "=", "pool_cross_instance");
+
+	const obs1 = lix1.observe(q1);
+	const obs2 = lix2.observe(q2);
+
+	// Different Lix instances must not share the same observable
+	expect(obs1).not.toBe(obs2);
+
+	const a: any[] = [];
+	const b: any[] = [];
+	const sub1 = obs1.subscribe({ next: (rows) => a.push(rows) });
+	const sub2 = obs2.subscribe({ next: (rows) => b.push(rows) });
+
+	await new Promise((r) => setTimeout(r, 10));
+	expect(a).toHaveLength(1);
+	expect(b).toHaveLength(1);
+
+	// Mutate only lix1; lix2 should not receive updates
+	await lix1.db
+		.insertInto("key_value")
+		.values({ key: "pool_cross_instance", value: "v1" })
+		.execute();
+	await new Promise((r) => setTimeout(r, 20));
+
+	expect(a).toHaveLength(2);
+	expect(a[a.length - 1]).toHaveLength(1);
+	expect(b).toHaveLength(1); // Still just initial emission
+
+	sub1.unsubscribe();
+	sub2.unsubscribe();
+	await lix1.close();
+	await lix2.close();
+});