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

package/dist/observe/create-observe.test.js

@@ -0,0 +1,638 @@
+import { test, expect } from "vitest";
+import { openLix } from "../lix/open-lix.js";
+/**
+ * These tests use the key_value table as an example entity in the state.
+ * The key_value table is a built-in table in Lix that stores configuration
+ * and metadata. We use it here because it's always available in any Lix instance.
+ *
+ * In real applications, you would observe your own domain-specific tables
+ * like "users", "documents", "settings", etc.
+ */
+test("observe should emit initial values and updates for key_value table", async () => {
+    const lix = await openLix({});
+    const values = [];
+    // 3.1 Full result-set stream - filtered to test keys only
+    const subscription = lix
+        .observe(lix.db.selectFrom("key_value").selectAll().where("key", "like", "test_%"))
+        .subscribe({ next: (rows) => values.push(rows) });
+    // Wait for initial emission
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(values).toHaveLength(1);
+    expect(values[0]).toEqual([]);
+    // Insert a test key-value pair
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "test_key", value: "test_value" })
+        .execute();
+    // Wait for update
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Should have received an update
+    expect(values).toHaveLength(2);
+    expect(values[1]).toHaveLength(1);
+    expect(values[1][0]).toMatchObject({
+        key: "test_key",
+        value: "test_value",
+    });
+    subscription.unsubscribe();
+    await lix.close();
+});
+test("subscribeTakeFirst should emit first row or undefined", async () => {
+    const lix = await openLix({});
+    const values = [];
+    // 3.2 Track latest change-set (row || undefined)
+    // Using key_value table as example, filtered to demo_ prefix
+    const subscription = lix
+        .observe(lix.db
+        .selectFrom("key_value")
+        .selectAll()
+        .where("key", "like", "demo_%")
+        .orderBy("key", "asc"))
+        .subscribeTakeFirst({ next: (row) => values.push(row) });
+    // Wait for initial emission
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Should have initial undefined (no demo_ keys yet)
+    expect(values).toHaveLength(1);
+    expect(values[0]).toBeUndefined();
+    // Insert a demo key
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "demo_first", value: "first_value" })
+        .execute();
+    // Wait for update
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Should have received an update with the new first row
+    expect(values).toHaveLength(2);
+    expect(values[1]).toMatchObject({
+        key: "demo_first",
+        value: "first_value",
+    });
+    // Insert another demo key that comes first alphabetically
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "demo_aaa", value: "aaa_value" })
+        .execute();
+    // Wait for update
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Should now get the alphabetically first key
+    expect(values).toHaveLength(3);
+    expect(values[2]).toMatchObject({
+        key: "demo_aaa",
+        value: "aaa_value",
+    });
+    subscription.unsubscribe();
+    await lix.close();
+});
+test("subscribeTakeFirstOrThrow should error when no rows exist", async () => {
+    const lix = await openLix({});
+    const values = [];
+    const errors = [];
+    // 3.3 Strict singleton (error when empty)
+    // Query for specific non-existent key
+    const subscription = lix
+        .observe(lix.db
+        .selectFrom("key_value")
+        .selectAll()
+        .where("key", "=", "singleton_test_key"))
+        .subscribeTakeFirstOrThrow({
+        next: (row) => values.push(row),
+        error: (err) => errors.push(err),
+    });
+    // Wait for initial emission (error)
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Should have received an error
+    expect(values).toHaveLength(0);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toBeInstanceOf(Error);
+    expect(errors[0].message).toBe("Query returned no rows");
+    subscription.unsubscribe();
+    await lix.close();
+});
+test("subscribeTakeFirstOrThrow should emit value when row exists", async () => {
+    const lix = await openLix({});
+    const values = [];
+    const errors = [];
+    // First insert a singleton row
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "singleton_test_key", value: "singleton_value" })
+        .execute();
+    // Then observe it
+    const subscription = lix
+        .observe(lix.db
+        .selectFrom("key_value")
+        .selectAll()
+        .where("key", "=", "singleton_test_key"))
+        .subscribeTakeFirstOrThrow({
+        next: (row) => values.push(row),
+        error: (err) => errors.push(err),
+    });
+    // Wait for initial emission
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Should have received the row
+    expect(errors).toHaveLength(0);
+    expect(values).toHaveLength(1);
+    expect(values[0]).toMatchObject({
+        key: "singleton_test_key",
+        value: "singleton_value",
+    });
+    // Update the singleton value
+    await lix.db
+        .updateTable("key_value")
+        .set({ value: "updated_singleton" })
+        .where("key", "=", "singleton_test_key")
+        .execute();
+    // Wait for update
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Should have received the updated row
+    expect(values).toHaveLength(2);
+    expect(values[1]).toMatchObject({
+        key: "singleton_test_key",
+        value: "updated_singleton",
+    });
+    subscription.unsubscribe();
+    await lix.close();
+});
+test("unsubscribe should stop receiving updates", async () => {
+    const lix = await openLix({});
+    const values = [];
+    const subscription = lix
+        .observe(lix.db.selectFrom("key_value").selectAll().where("key", "like", "unsub_%"))
+        .subscribe({ next: (rows) => values.push(rows) });
+    // Wait for initial emission
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    const countBeforeUnsubscribe = values.length;
+    // Unsubscribe
+    subscription.unsubscribe();
+    // Make changes after unsubscribe
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "unsub_after", value: "should_not_see" })
+        .execute();
+    // Small delay to ensure no updates are received
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    // Should not have received any more updates
+    expect(values.length).toBe(countBeforeUnsubscribe);
+    await lix.close();
+});
+test("multiple subscriptions should work independently", async () => {
+    const lix = await openLix({});
+    const values1 = [];
+    const values2 = [];
+    // Two different queries with different filters
+    const sub1 = lix
+        .observe(lix.db
+        .selectFrom("key_value")
+        .selectAll()
+        .where("key", "like", "scope1_%"))
+        .subscribe({ next: (rows) => values1.push(rows) });
+    const sub2 = lix
+        .observe(lix.db
+        .selectFrom("key_value")
+        .selectAll()
+        .where("key", "like", "scope2_%"))
+        .subscribe({ next: (rows) => values2.push(rows) });
+    // Wait for initial emissions
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Insert keys for different scopes
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "scope1_key", value: "scope1_value" })
+        .execute();
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "scope2_key", value: "scope2_value" })
+        .execute();
+    // Wait for updates from both insertions
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    // First subscription should only see scope1 keys
+    const lastResult1 = values1[values1.length - 1];
+    expect(lastResult1).toHaveLength(1);
+    expect(lastResult1[0]).toMatchObject({
+        key: "scope1_key",
+        value: "scope1_value",
+    });
+    // Second subscription should only see scope2 keys
+    const lastResult2 = values2[values2.length - 1];
+    expect(lastResult2).toHaveLength(1);
+    expect(lastResult2[0]).toMatchObject({
+        key: "scope2_key",
+        value: "scope2_value",
+    });
+    sub1.unsubscribe();
+    sub2.unsubscribe();
+    await lix.close();
+});
+test("query errors should be delivered to error handler", async () => {
+    const lix = await openLix({});
+    const errors = [];
+    const values = [];
+    // Create an invalid query (selecting from non-existent table)
+    const subscription = lix
+        .observe(lix.db.selectFrom("non_existent_table").selectAll())
+        .subscribe({
+        next: (rows) => values.push(rows),
+        error: (err) => errors.push(err),
+    });
+    // Wait for error
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Should have received an error
+    expect(values).toHaveLength(0);
+    expect(errors).toHaveLength(1);
+    expect(errors[0]).toBeInstanceOf(Error);
+    // Subscription should be terminated after error
+    // (no cleanup needed, but calling unsubscribe should be safe)
+    subscription.unsubscribe();
+    await lix.close();
+});
+test("Symbol.observable interop should work", async () => {
+    const lix = await openLix({});
+    const observable = lix.observe(lix.db.selectFrom("key_value").selectAll().where("key", "like", "interop_%"));
+    // Should implement Symbol.observable
+    expect(observable[Symbol.observable]).toBeDefined();
+    expect(observable[Symbol.observable]()).toBe(observable);
+    await lix.close();
+});
+test("observing specific key should not emit when unrelated key is inserted", async () => {
+    const lix = await openLix({});
+    const valuesA = [];
+    const valuesB = [];
+    // Observe only key A
+    const subscriptionA = lix
+        .observe(lix.db.selectFrom("key_value").selectAll().where("key", "=", "key_A"))
+        .subscribe({ next: (rows) => valuesA.push(rows) });
+    // Observe only key B
+    const subscriptionB = lix
+        .observe(lix.db.selectFrom("key_value").selectAll().where("key", "=", "key_B"))
+        .subscribe({ next: (rows) => valuesB.push(rows) });
+    // Wait for initial emissions
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(valuesA).toHaveLength(1);
+    expect(valuesA[0]).toEqual([]); // No key_A yet
+    expect(valuesB).toHaveLength(1);
+    expect(valuesB[0]).toEqual([]); // No key_B yet
+    // Insert key A
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "key_A", value: "value_A" })
+        .execute();
+    // Wait for update
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Key A observer should get an update
+    expect(valuesA).toHaveLength(2);
+    expect(valuesA[1]).toHaveLength(1);
+    expect(valuesA[1][0]).toMatchObject({ key: "key_A", value: "value_A" });
+    // Key B observer should NOT get an update (only key A was inserted)
+    expect(valuesB).toHaveLength(1); // Still only initial emission
+    const countABeforeKeyB = valuesA.length;
+    const countBBeforeKeyB = valuesB.length;
+    // Insert key B
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "key_B", value: "value_B" })
+        .execute();
+    // Wait to see if we get emissions
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Key A observer should NOT get an update (only key B was inserted)
+    expect(valuesA).toHaveLength(countABeforeKeyB); // No new emission
+    // Key B observer should get an update
+    expect(valuesB).toHaveLength(countBBeforeKeyB + 1);
+    expect(valuesB[valuesB.length - 1]).toHaveLength(1);
+    expect(valuesB[valuesB.length - 1][0]).toMatchObject({
+        key: "key_B",
+        value: "value_B",
+    });
+    subscriptionA.unsubscribe();
+    subscriptionB.unsubscribe();
+    await lix.close();
+});
+test("subscribeTakeFirst with explicit limit(1) should not double-limit", async () => {
+    const lix = await openLix({});
+    const values = [];
+    // Insert multiple test keys
+    await lix.db
+        .insertInto("key_value")
+        .values([
+        { key: "limit_test_1", value: "value_1" },
+        { key: "limit_test_2", value: "value_2" },
+        { key: "limit_test_3", value: "value_3" },
+    ])
+        .execute();
+    // User already provides limit(1) in their query
+    const subscription = lix
+        .observe(lix.db
+        .selectFrom("key_value")
+        .selectAll()
+        .where("key", "like", "limit_test_%")
+        .orderBy("key", "asc")
+        .limit(1))
+        .subscribeTakeFirst({ next: (row) => values.push(row) });
+    // Wait for initial emission
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Should work correctly even with double limit
+    expect(values).toHaveLength(1);
+    expect(values[0]).toMatchObject({
+        key: "limit_test_1",
+        value: "value_1",
+    });
+    subscription.unsubscribe();
+    await lix.close();
+});
+test("query should only re-execute when observed entity changes", async () => {
+    const lix = await openLix({});
+    const keyValueEmissions = [];
+    // Observe key_value table
+    const keyValueSub = lix
+        .observe(lix.db
+        .selectFrom("key_value")
+        .selectAll()
+        .where("key", "like", "opt_test_%"))
+        .subscribe({ next: (rows) => keyValueEmissions.push(rows) });
+    // Wait for initial emissions
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(keyValueEmissions).toHaveLength(1);
+    const keyValueCountBefore = keyValueEmissions.length;
+    // Insert into key_value - should trigger key_value observer
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "opt_test_key", value: "opt_test_value" })
+        .execute();
+    // Wait for emissions
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    // key_value observer should have received an update
+    expect(keyValueEmissions).toHaveLength(keyValueCountBefore + 1);
+    expect(keyValueEmissions[keyValueEmissions.length - 1]).toHaveLength(1);
+    keyValueSub.unsubscribe();
+    await lix.close();
+});
+test("query with innerJoin should handle schema key detection correctly", async () => {
+    const lix = await openLix({});
+    const joinEmissions = [];
+    // Test that innerJoin queries can be properly parsed by determineSchemaKeys
+    // This demonstrates that the optimization system can handle complex join queries
+    const joinQuery = lix.db
+        .selectFrom("key_value")
+        .innerJoin("label", "key_value.value", "label.id")
+        .selectAll("key_value")
+        .where("key_value.key", "like", "join_test_%");
+    const joinSub = lix
+        .observe(joinQuery)
+        .subscribe({ next: (rows) => joinEmissions.push(rows) });
+    // Wait for initial emission
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(joinEmissions).toHaveLength(1);
+    // The test passes by verifying that innerJoin queries can be observed
+    // and that the optimization system doesn't crash on complex queries
+    expect(joinEmissions[0]).toEqual([]);
+    // Verify that both schema keys are detected in the join query
+    const { determineSchemaKeys } = await import("./determine-schema-keys.js");
+    const schemaKeys = determineSchemaKeys(joinQuery.compile());
+    expect(schemaKeys).toContain("lix_key_value");
+    expect(schemaKeys).toContain("lix_label");
+    joinSub.unsubscribe();
+    await lix.close();
+});
+test("query with change table join should always re-execute", async () => {
+    const lix = await openLix({});
+    const changeJoinEmissions = [];
+    // Observe a join query that includes the change table
+    // This should always re-execute because change table mutates frequently
+    const changeJoinSub = lix
+        .observe(lix.db
+        .selectFrom("key_value")
+        .leftJoin("change", "change.entity_id", "key_value.key")
+        .selectAll()
+        .where("key_value.key", "like", "change_test_%"))
+        .subscribe({ next: (rows) => changeJoinEmissions.push(rows) });
+    // Wait for initial emission
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(changeJoinEmissions).toHaveLength(1);
+    const countBefore = changeJoinEmissions.length;
+    // Insert into key_value - should trigger change join observer
+    // because it joins with the change table (special case)
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "change_test_key", value: "change_test_value" })
+        .execute();
+    // Wait for emission
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Change join observer should have received an update
+    expect(changeJoinEmissions).toHaveLength(countBefore + 1);
+    changeJoinSub.unsubscribe();
+    await lix.close();
+});
+test("query with state_all table should always re-execute", async () => {
+    const lix = await openLix({});
+    const stateAllEmissions = [];
+    // Observe a query that uses the state_all table
+    // This should always re-execute because state_all includes all versions
+    const stateAllSub = lix
+        .observe(lix.db
+        .selectFrom("state_all")
+        .selectAll()
+        .where("schema_key", "=", "lix_version"))
+        .subscribe({ next: (rows) => stateAllEmissions.push(rows) });
+    // Wait for initial emission
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(stateAllEmissions).toHaveLength(1);
+    const countBefore = stateAllEmissions.length;
+    // Insert into key_value - should trigger state_all observer
+    // because state_all queries should always re-execute (special case)
+    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));
+    // state_all observer should have received an update
+    expect(stateAllEmissions).toHaveLength(countBefore + 1);
+    stateAllSub.unsubscribe();
+    await lix.close();
+});
+test("multiple observers with different entities should not interfere", async () => {
+    const lix = await openLix({});
+    const keyValueEmissions = [];
+    const labelEmissions = [];
+    const accountEmissions = [];
+    // Three observers on different tables
+    const keyValueSub = lix
+        .observe(lix.db
+        .selectFrom("key_value")
+        .selectAll()
+        .where("key", "like", "multi_test_%"))
+        .subscribe({ next: (rows) => keyValueEmissions.push(rows) });
+    const labelSub = lix
+        .observe(lix.db.selectFrom("label").selectAll().where("id", "like", "multi_test_%"))
+        .subscribe({ next: (rows) => labelEmissions.push(rows) });
+    const accountSub = lix
+        .observe(lix.db
+        .selectFrom("account")
+        .selectAll()
+        .where("id", "like", "multi_test_%"))
+        .subscribe({ next: (rows) => accountEmissions.push(rows) });
+    // Wait for initial emissions
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(keyValueEmissions).toHaveLength(1);
+    expect(labelEmissions).toHaveLength(1);
+    expect(accountEmissions).toHaveLength(1);
+    const keyValueCountBefore = keyValueEmissions.length;
+    const labelCountBefore = labelEmissions.length;
+    const accountCountBefore = accountEmissions.length;
+    // Insert into key_value - should only trigger key_value observer
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "multi_test_key", value: "multi_test_value" })
+        .execute();
+    // Wait for emissions
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    // Only key_value observer should have received an update (optimization working)
+    expect(keyValueEmissions).toHaveLength(keyValueCountBefore + 1);
+    expect(labelEmissions).toHaveLength(labelCountBefore);
+    expect(accountEmissions).toHaveLength(accountCountBefore);
+    // Test all three tables to make sure they all work independently
+    const keyValueCountAfterFirst = keyValueEmissions.length;
+    const labelCountAfterFirst = labelEmissions.length;
+    const accountCountAfterFirst = accountEmissions.length;
+    // Insert into label - should only trigger label observer
+    await lix.db
+        .insertInto("label")
+        .values({
+        id: "multi_test_label",
+        name: "Multi Test Label",
+    })
+        .execute();
+    // Wait for emissions
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    // Only label observer should have received an update
+    expect(keyValueEmissions).toHaveLength(keyValueCountAfterFirst);
+    expect(labelEmissions).toHaveLength(labelCountAfterFirst + 1);
+    expect(accountEmissions).toHaveLength(accountCountAfterFirst);
+    keyValueSub.unsubscribe();
+    labelSub.unsubscribe();
+    accountSub.unsubscribe();
+    await lix.close();
+});
+test("subquery should re-execute when parent or child entities change", async () => {
+    const lix = await openLix({});
+    const subqueryEmissions = [];
+    // Insert test data
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "subquery_parent", value: "parent_value" })
+        .execute();
+    // Observe a query with a subquery
+    const subquerySub = lix
+        .observe(lix.db
+        .selectFrom("key_value as parent")
+        .selectAll()
+        .where("parent.key", "like", "subquery_parent%")
+        .where("parent.value", "in", lix.db
+        .selectFrom("key_value as child")
+        .select("child.value")
+        .where("child.key", "like", "subquery_child%")))
+        .subscribe({ next: (rows) => subqueryEmissions.push(rows) });
+    // Wait for initial emission
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(subqueryEmissions).toHaveLength(1);
+    const countBefore = subqueryEmissions.length;
+    // Insert into the subquery table - should trigger re-execution
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "subquery_child", value: "parent_value" })
+        .execute();
+    // Wait for emission
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    // Subquery observer should have received an update
+    expect(subqueryEmissions).toHaveLength(countBefore + 1);
+    subquerySub.unsubscribe();
+    await lix.close();
+});
+test("optimization prevents unnecessary query re-executions", async () => {
+    const lix = await openLix({});
+    const keyValueEmissions = [];
+    const labelEmissions = [];
+    const accountEmissions = [];
+    // Set up observers for different tables
+    const keyValueSub = lix
+        .observe(lix.db
+        .selectFrom("key_value")
+        .selectAll()
+        .where("key", "like", "opt_prevent_%"))
+        .subscribe({ next: (rows) => keyValueEmissions.push(rows) });
+    const labelSub = lix
+        .observe(lix.db
+        .selectFrom("label")
+        .selectAll()
+        .where("id", "like", "opt_prevent_%"))
+        .subscribe({ next: (rows) => labelEmissions.push(rows) });
+    const accountSub = lix
+        .observe(lix.db
+        .selectFrom("account")
+        .selectAll()
+        .where("id", "like", "opt_prevent_%"))
+        .subscribe({ next: (rows) => accountEmissions.push(rows) });
+    // Wait for initial emissions
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(keyValueEmissions).toHaveLength(1);
+    expect(labelEmissions).toHaveLength(1);
+    expect(accountEmissions).toHaveLength(1);
+    // Track counts before any mutations
+    const initialCounts = {
+        keyValue: keyValueEmissions.length,
+        label: labelEmissions.length,
+        account: accountEmissions.length,
+    };
+    // Test 1: Insert into key_value should only affect key_value observer
+    await lix.db
+        .insertInto("key_value")
+        .values({ key: "opt_prevent_key1", value: "value1" })
+        .execute();
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(keyValueEmissions).toHaveLength(initialCounts.keyValue + 1);
+    expect(labelEmissions).toHaveLength(initialCounts.label); // Should NOT change
+    expect(accountEmissions).toHaveLength(initialCounts.account); // Should NOT change
+    // Test 2: Insert into label should only affect label observer
+    const countsAfterKeyValue = {
+        keyValue: keyValueEmissions.length,
+        label: labelEmissions.length,
+        account: accountEmissions.length,
+    };
+    await lix.db
+        .insertInto("label")
+        .values({
+        id: "opt_prevent_label1",
+        name: "Prevent Test Label",
+    })
+        .execute();
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(keyValueEmissions).toHaveLength(countsAfterKeyValue.keyValue); // Should NOT change
+    expect(labelEmissions).toHaveLength(countsAfterKeyValue.label + 1);
+    expect(accountEmissions).toHaveLength(countsAfterKeyValue.account); // Should NOT change
+    // Test 3: Insert into account should only affect account observer
+    const countsAfterLabel = {
+        keyValue: keyValueEmissions.length,
+        label: labelEmissions.length,
+        account: accountEmissions.length,
+    };
+    await lix.db
+        .insertInto("account")
+        .values({
+        id: "opt_prevent_account1",
+        name: "Prevent Test Account",
+    })
+        .execute();
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(keyValueEmissions).toHaveLength(countsAfterLabel.keyValue); // Should NOT change
+    expect(labelEmissions).toHaveLength(countsAfterLabel.label); // Should NOT change
+    expect(accountEmissions).toHaveLength(countsAfterLabel.account + 1);
+    // Verify the optimization is working by checking that we have the expected pattern:
+    // - Each observer only increased when its own table was modified
+    // - No observer increased when other tables were modified
+    expect(keyValueEmissions).toHaveLength(initialCounts.keyValue + 1); // Only 1 increase
+    expect(labelEmissions).toHaveLength(initialCounts.label + 1); // Only 1 increase
+    expect(accountEmissions).toHaveLength(initialCounts.account + 1); // Only 1 increase
+    keyValueSub.unsubscribe();
+    labelSub.unsubscribe();
+    accountSub.unsubscribe();
+    await lix.close();
+});
+//# sourceMappingURL=create-observe.test.js.map