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

package/src/state/cache/update-state-cache.test.ts

@@ -0,0 +1,510 @@
+import { test, expect } from "vitest";
+import { openLix } from "../../lix/open-lix.js";
+import { updateStateCache } from "./update-state-cache.js";
+import { timestamp } from "../../deterministic/timestamp.js";
+import { createVersion } from "../../version/create-version.js";
+import type { Kysely } from "kysely";
+import type { LixInternalDatabaseSchema } from "../../database/schema.js";
+import type { LixChangeRaw } from "../../change/schema.js";
+import type { InternalStateCacheRow } from "./schema.js";
+
+test("inserts into cache based on change", async () => {
+	const lix = await openLix({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true, bootstrap: true },
+			},
+		],
+	});
+
+	const currentTimestamp = timestamp({ lix });
+
+	// Create a test change
+	const testChange: LixChangeRaw = {
+		id: "test-change-123",
+		entity_id: "test-entity",
+		schema_key: "lix_test",
+		schema_version: "1.0",
+		file_id: "lix",
+		plugin_key: "test_plugin",
+		snapshot_content: JSON.stringify({ id: "test-entity", value: "test-data" }),
+		created_at: currentTimestamp,
+	};
+
+	const commitId = "test-commit-456";
+	const versionId = "global";
+
+	// Call updateStateCache
+	updateStateCache({
+		lix,
+		change: testChange,
+		commit_id: commitId,
+		version_id: versionId,
+	});
+
+	// Verify cache entry was created/updated
+	const cacheEntries = await (
+		lix.db as unknown as Kysely<LixInternalDatabaseSchema>
+	)
+		.selectFrom("internal_state_cache")
+		.selectAll()
+		.where("entity_id", "=", testChange.entity_id)
+		.where("schema_key", "=", testChange.schema_key)
+		.where("file_id", "=", testChange.file_id)
+		.where("version_id", "=", versionId)
+		.execute();
+
+	expect(cacheEntries).toHaveLength(1);
+
+	const cacheEntry = cacheEntries[0]!;
+	expect(cacheEntry).toEqual({
+		entity_id: testChange.entity_id,
+		schema_key: testChange.schema_key,
+		file_id: testChange.file_id,
+		version_id: versionId,
+		plugin_key: testChange.plugin_key,
+		snapshot_content: JSON.parse(testChange.snapshot_content as any),
+		schema_version: testChange.schema_version,
+		created_at: currentTimestamp,
+		updated_at: currentTimestamp,
+		inherited_from_version_id: null,
+		inheritance_delete_marker: 0,
+		change_id: testChange.id,
+		commit_id: commitId,
+	} satisfies InternalStateCacheRow);
+});
+
+test("upserts cache entry on conflict", async () => {
+	const lix = await openLix({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true, bootstrap: true },
+			},
+		],
+	});
+
+	const initialTimestamp = timestamp({ lix });
+
+	// Create initial test change
+	const initialChange: LixChangeRaw = {
+		id: "test-change-initial",
+		entity_id: "test-entity-upsert",
+		schema_key: "lix_test",
+		schema_version: "1.0",
+		file_id: "lix",
+		plugin_key: "test_plugin",
+		snapshot_content: JSON.stringify({
+			id: "test-entity-upsert",
+			value: "initial-data",
+		}),
+		created_at: initialTimestamp,
+	};
+
+	const initialCommitId = "initial-commit-123";
+	const versionId = "global";
+
+	// First insert
+	updateStateCache({
+		lix,
+		change: initialChange,
+		commit_id: initialCommitId,
+		version_id: versionId,
+	});
+
+	// Verify initial entry exists
+	const intDb = lix.db as unknown as Kysely<LixInternalDatabaseSchema>;
+	const initialEntries = await intDb
+		.selectFrom("internal_state_cache")
+		.selectAll()
+		.where("entity_id", "=", initialChange.entity_id)
+		.where("schema_key", "=", initialChange.schema_key)
+		.where("file_id", "=", initialChange.file_id)
+		.where("version_id", "=", versionId)
+		.execute();
+
+	expect(initialEntries).toHaveLength(1);
+	expect(initialEntries[0]!.commit_id).toBe(initialCommitId);
+	expect(initialEntries[0]!.snapshot_content).toEqual(
+		JSON.parse(initialChange.snapshot_content as any)
+	);
+
+	// Now update with new data (same entity, schema, file, version - should trigger upsert)
+	const updateTimestamp = timestamp({ lix });
+	const updatedChange: LixChangeRaw = {
+		id: "test-change-updated",
+		entity_id: "test-entity-upsert", // Same entity
+		schema_key: "lix_test", // Same schema
+		schema_version: "1.1", // Different version
+		file_id: "lix", // Same file
+		plugin_key: "updated_plugin", // Different plugin
+		snapshot_content: JSON.stringify({
+			id: "test-entity-upsert",
+			value: "updated-data",
+		}), // Different content
+		created_at: updateTimestamp,
+	};
+
+	const updatedCommitId = "updated-commit-456";
+
+	// Second call should trigger onConflict upsert
+	updateStateCache({
+		lix,
+		change: updatedChange,
+		commit_id: updatedCommitId,
+		version_id: versionId,
+	});
+
+	// Verify only one entry exists (upserted, not inserted as new)
+	const finalEntries = await intDb
+		.selectFrom("internal_state_cache")
+		.selectAll()
+		.where("entity_id", "=", updatedChange.entity_id)
+		.where("schema_key", "=", updatedChange.schema_key)
+		.where("file_id", "=", updatedChange.file_id)
+		.where("version_id", "=", versionId)
+		.execute();
+
+	expect(finalEntries).toHaveLength(1);
+
+	const upsertedEntry = finalEntries[0]!;
+	expect(upsertedEntry).toEqual({
+		entity_id: updatedChange.entity_id,
+		schema_key: updatedChange.schema_key,
+		file_id: updatedChange.file_id,
+		version_id: versionId,
+		plugin_key: updatedChange.plugin_key, // Should be updated
+		snapshot_content: JSON.parse(updatedChange.snapshot_content as any), // Should be updated
+		schema_version: updatedChange.schema_version, // Should be updated
+		created_at: initialTimestamp, // Should remain from initial insert
+		updated_at: updateTimestamp, // Should be updated
+		inherited_from_version_id: null,
+		inheritance_delete_marker: 0,
+		change_id: updatedChange.id, // Should be updated
+		commit_id: updatedCommitId, // Should be updated
+	} satisfies InternalStateCacheRow);
+});
+
+test("moves cache entries to children on deletion, clears when no children remain", async () => {
+	const lix = await openLix({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true, bootstrap: true },
+			},
+		],
+	});
+
+	// Create inheritance chain: parent -> child1, child2
+	await createVersion({
+		lix,
+		id: "parent",
+		inherits_from_version_id: "global",
+	});
+	await createVersion({
+		lix,
+		id: "child1",
+		inherits_from_version_id: "parent",
+	});
+	await createVersion({
+		lix,
+		id: "child2",
+		inherits_from_version_id: "parent",
+	});
+
+	const initialTimestamp = timestamp({ lix });
+	const testEntity = "test-entity-cleanup";
+
+	// 1. Create entity in parent
+	const createChange: LixChangeRaw = {
+		id: "create-change",
+		entity_id: testEntity,
+		schema_key: "lix_test",
+		schema_version: "1.0",
+		file_id: "lix",
+		plugin_key: "test_plugin",
+		snapshot_content: JSON.stringify({ id: testEntity, value: "parent-data" }),
+		created_at: initialTimestamp,
+	};
+
+	updateStateCache({
+		lix,
+		change: createChange,
+		commit_id: "parent-commit",
+		version_id: "parent",
+	});
+
+	const intDb = lix.db as unknown as Kysely<LixInternalDatabaseSchema>;
+
+	// Verify entity exists only in parent
+	const initialCache = await intDb
+		.selectFrom("internal_state_cache")
+		.selectAll()
+		.where("entity_id", "=", testEntity)
+		.execute();
+
+	expect(initialCache).toHaveLength(1);
+	expect(initialCache[0]?.version_id).toBe("parent");
+
+	// 2. Delete from parent - should move to child1 and child2
+	const deleteFromParentTimestamp = timestamp({ lix });
+	const deleteFromParentChange: LixChangeRaw = {
+		id: "delete-from-parent",
+		entity_id: testEntity,
+		schema_key: "lix_test",
+		schema_version: "1.0",
+		file_id: "lix",
+		plugin_key: "test_plugin",
+		snapshot_content: null, // Deletion
+		created_at: deleteFromParentTimestamp,
+	};
+
+	updateStateCache({
+		lix,
+		change: deleteFromParentChange,
+		commit_id: "parent-delete-commit",
+		version_id: "parent",
+	});
+
+	// Verify entity moved to child1 and child2, parent entry removed
+	const cacheAfterParentDelete = await intDb
+		.selectFrom("internal_state_cache")
+		.selectAll()
+		.where("entity_id", "=", testEntity)
+		.orderBy("version_id", "asc")
+		.execute();
+
+	expect(cacheAfterParentDelete).toHaveLength(2);
+	expect(cacheAfterParentDelete[0]?.version_id).toBe("child1");
+	expect(cacheAfterParentDelete[1]?.version_id).toBe("child2");
+	// Both should have the same original data (Kysely auto-parses JSON)
+	expect(cacheAfterParentDelete[0]?.snapshot_content).toEqual({
+		id: testEntity,
+		value: "parent-data",
+	});
+	expect(cacheAfterParentDelete[1]?.snapshot_content).toEqual({
+		id: testEntity,
+		value: "parent-data",
+	});
+
+	// 3. Delete from child1 - should remove child1 entry but keep child2
+	const deleteFromChild1Timestamp = timestamp({ lix });
+	const deleteFromChild1Change: LixChangeRaw = {
+		id: "delete-from-child1",
+		entity_id: testEntity,
+		schema_key: "lix_test",
+		schema_version: "1.0",
+		file_id: "lix",
+		plugin_key: "test_plugin",
+		snapshot_content: null, // Deletion
+		created_at: deleteFromChild1Timestamp,
+	};
+
+	updateStateCache({
+		lix,
+		change: deleteFromChild1Change,
+		commit_id: "child1-delete-commit",
+		version_id: "child1",
+	});
+
+	// Verify only child2 has the entity now
+	const cacheAfterChild1Delete = await intDb
+		.selectFrom("internal_state_cache")
+		.selectAll()
+		.where("entity_id", "=", testEntity)
+		.execute();
+
+	expect(cacheAfterChild1Delete).toHaveLength(1);
+	expect(cacheAfterChild1Delete[0]?.version_id).toBe("child2");
+	expect(cacheAfterChild1Delete[0]?.snapshot_content).toEqual({
+		id: testEntity,
+		value: "parent-data",
+	});
+
+	// 4. Delete from child2 - should remove the entity entirely from cache
+	const deleteFromChild2Timestamp = timestamp({ lix });
+	const deleteFromChild2Change: LixChangeRaw = {
+		id: "delete-from-child2",
+		entity_id: testEntity,
+		schema_key: "lix_test",
+		schema_version: "1.0",
+		file_id: "lix",
+		plugin_key: "test_plugin",
+		snapshot_content: null, // Deletion
+		created_at: deleteFromChild2Timestamp,
+	};
+
+	updateStateCache({
+		lix,
+		change: deleteFromChild2Change,
+		commit_id: "child2-delete-commit",
+		version_id: "child2",
+	});
+
+	// Verify entity is completely removed from cache
+	const finalCache = await intDb
+		.selectFrom("internal_state_cache")
+		.selectAll()
+		.where("entity_id", "=", testEntity)
+		.execute();
+
+	expect(finalCache).toHaveLength(0);
+});
+
+test("handles inheritance chain deletions with tombstones", async () => {
+	const lix = await openLix({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true, bootstrap: true },
+			},
+		],
+	});
+
+	// Create inheritance chain: parent -> child -> subchild
+	await createVersion({
+		lix,
+		id: "parent-version",
+		inherits_from_version_id: "global",
+	});
+	await createVersion({
+		lix,
+		id: "child-version",
+		inherits_from_version_id: "parent-version",
+	});
+	await createVersion({
+		lix,
+		id: "subchild-version",
+		inherits_from_version_id: "child-version",
+	});
+
+	const baseTimestamp = timestamp({ lix });
+	const testEntity = "inherited-entity";
+
+	// 1. Create entity in parent version
+	const createChange: LixChangeRaw = {
+		id: "create-change-123",
+		entity_id: testEntity,
+		schema_key: "lix_test",
+		schema_version: "1.0",
+		file_id: "lix",
+		plugin_key: "test_plugin",
+		snapshot_content: JSON.stringify({ id: testEntity, value: "parent-data" }),
+		created_at: baseTimestamp,
+	};
+
+	updateStateCache({
+		lix,
+		change: createChange,
+		commit_id: "parent-commit-123",
+		version_id: "parent-version",
+	});
+
+	const intDb = lix.db as unknown as Kysely<LixInternalDatabaseSchema>;
+
+	// 2. Verify entity exists in parent cache
+	const parentCache = await intDb
+		.selectFrom("internal_state_cache")
+		.selectAll()
+		.where("entity_id", "=", testEntity)
+		.where("version_id", "=", "parent-version")
+		.execute();
+
+	expect(parentCache).toHaveLength(1);
+	expect(parentCache[0]?.snapshot_content).toEqual({
+		id: testEntity,
+		value: "parent-data",
+	});
+
+	// 3. Create tombstone in child version (deleting inherited entity)
+	const deleteTimestamp = timestamp({ lix });
+	const deleteChange: LixChangeRaw = {
+		id: "delete-change-456",
+		entity_id: testEntity,
+		schema_key: "lix_test",
+		schema_version: "1.0",
+		file_id: "lix",
+		plugin_key: "test_plugin",
+		snapshot_content: null, // Tombstone
+		created_at: deleteTimestamp,
+	};
+
+	updateStateCache({
+		lix,
+		change: deleteChange,
+		commit_id: "child-commit-456",
+		version_id: "child-version",
+	});
+
+	// 4. Verify parent still has the entity in cache
+	const parentCacheAfterDelete = await intDb
+		.selectFrom("internal_state_cache")
+		.selectAll()
+		.where("entity_id", "=", testEntity)
+		.where("version_id", "=", "parent-version")
+		.execute();
+
+	expect(parentCacheAfterDelete).toHaveLength(1);
+	expect(parentCacheAfterDelete[0]?.snapshot_content).toEqual({
+		id: testEntity,
+		value: "parent-data",
+	});
+
+	// 5. Verify child version HAS a tombstone cache entry
+	const childCacheAfterDelete = await intDb
+		.selectFrom("internal_state_cache")
+		.selectAll()
+		.where("entity_id", "=", testEntity)
+		.where("version_id", "=", "child-version")
+		.execute();
+
+	expect(childCacheAfterDelete).toHaveLength(1);
+	expect(childCacheAfterDelete[0]?.snapshot_content).toBeNull();
+	expect(childCacheAfterDelete[0]?.change_id).toBe("delete-change-456");
+
+	// 6. Verify subchild version has NO direct cache entry (inherits deletion from child)
+	const subchildCacheAfterDelete = await intDb
+		.selectFrom("internal_state_cache")
+		.selectAll()
+		.where("entity_id", "=", testEntity)
+		.where("version_id", "=", "subchild-version")
+		.execute();
+
+	expect(subchildCacheAfterDelete).toHaveLength(0);
+
+	// 7. Verify state_all queries return correct results (tombstones filtered out)
+	const parentStateAll = await lix.db
+		.selectFrom("state_all")
+		.selectAll()
+		.where("entity_id", "=", testEntity)
+		.where("version_id", "=", "parent-version")
+		.execute();
+
+	const childStateAll = await lix.db
+		.selectFrom("state_all")
+		.selectAll()
+		.where("entity_id", "=", testEntity)
+		.where("version_id", "=", "child-version")
+		.execute();
+
+	const subchildStateAll = await lix.db
+		.selectFrom("state_all")
+		.selectAll()
+		.where("entity_id", "=", testEntity)
+		.where("version_id", "=", "subchild-version")
+		.execute();
+
+	// Parent should show the entity through state_all
+	expect(parentStateAll).toHaveLength(1);
+	expect(parentStateAll[0]?.snapshot_content).toEqual({
+		id: testEntity,
+		value: "parent-data",
+	});
+
+	// Child should show NO entity through state_all (tombstone filtered out)
+	expect(childStateAll).toHaveLength(0);
+
+	// Subchild should show NO entity through state_all (inherits deletion from child)
+	expect(subchildStateAll).toHaveLength(0);
+});