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

package/src/change/schema.test.ts

@@ -0,0 +1,284 @@
+import { expect, test } from "vitest";
+import { openLix } from "../lix/open-lix.js";
+import type { LixInternalDatabaseSchema } from "../database/schema.js";
+import { type Kysely } from "kysely";
+
+test("insert on the change view", async () => {
+	const lix = await openLix({});
+
+	const snapshotContent = { id: "entity1", name: "Test Entity" };
+
+	// Insert a change into the view with snapshot_content
+	await lix.db
+		.insertInto("change")
+		.values({
+			id: "change1",
+			entity_id: "entity1",
+			schema_key: "test_schema",
+			schema_version: "1.0",
+			file_id: "file1",
+			plugin_key: "test_plugin",
+			snapshot_content: snapshotContent,
+		})
+		.execute();
+
+	// Verify the change was inserted
+	const viewAfterInsert = await lix.db
+		.selectFrom("change")
+		.where("id", "=", "change1")
+		.selectAll()
+		.execute();
+
+	expect(viewAfterInsert).toHaveLength(1);
+	expect(viewAfterInsert[0]).toMatchObject({
+		id: "change1",
+		entity_id: "entity1",
+		schema_key: "test_schema",
+		file_id: "file1",
+		plugin_key: "test_plugin",
+		snapshot_content: snapshotContent,
+	});
+	expect(viewAfterInsert[0]?.created_at).toBeDefined();
+
+	// Verify it was also inserted into the internal_change table
+	const internalChange = await (
+		lix.db as unknown as Kysely<LixInternalDatabaseSchema>
+	)
+		.selectFrom("internal_change")
+		.where("id", "=", "change1")
+		.selectAll()
+		.execute();
+
+	expect(internalChange).toHaveLength(1);
+	expect(internalChange[0]).toMatchObject({
+		id: "change1",
+		entity_id: "entity1",
+		schema_key: "test_schema",
+		file_id: "file1",
+		plugin_key: "test_plugin",
+	});
+	// The snapshot_id should have been generated internally
+	expect(internalChange[0]?.snapshot_id).toBeDefined();
+
+	// Verify that an internal_snapshot was created
+	const internalSnapshot = await (
+		lix.db as unknown as Kysely<LixInternalDatabaseSchema>
+	)
+		.selectFrom("internal_snapshot")
+		.where("id", "=", internalChange[0]!.snapshot_id)
+		.select((eb) => eb.fn("json", [`content`]).as("content"))
+		.executeTakeFirst();
+
+	expect(internalSnapshot).toBeDefined();
+	expect(internalSnapshot!.content).toEqual(snapshotContent);
+});
+
+test("insert with default id generation", async () => {
+	const lix = await openLix({});
+
+	const snapshotContent = { id: "entity2" };
+
+	// Insert a change without specifying an id
+	await lix.db
+		.insertInto("change")
+		.values({
+			entity_id: "entity2",
+			schema_key: "test_schema",
+			schema_version: "1.0",
+			file_id: "file2",
+			plugin_key: "test_plugin",
+			snapshot_content: snapshotContent,
+		})
+		.execute();
+
+	// Verify a change was inserted with a generated ID
+	const changes = await lix.db
+		.selectFrom("change")
+		.where("entity_id", "=", "entity2")
+		.selectAll()
+		.execute();
+
+	expect(changes).toHaveLength(1);
+	expect(changes[0]?.id).toBeDefined();
+	expect(changes[0]?.id).not.toBe("");
+	expect(changes[0]).toMatchObject({
+		entity_id: "entity2",
+		schema_key: "test_schema",
+		file_id: "file2",
+		plugin_key: "test_plugin",
+		snapshot_content: snapshotContent,
+	});
+});
+
+test("insert with default timestamp", async () => {
+	const lix = await openLix({});
+
+	const snapshotContent = { id: "entity3" };
+
+	// Insert a change without specifying created_at
+	await lix.db
+		.insertInto("change")
+		.values({
+			id: "change3",
+			entity_id: "entity3",
+			schema_key: "test_schema",
+			schema_version: "1.0",
+			file_id: "file3",
+			plugin_key: "test_plugin",
+			snapshot_content: snapshotContent,
+		})
+		.execute();
+
+	// Verify the change has a timestamp
+	const change = await lix.db
+		.selectFrom("change")
+		.where("id", "=", "change3")
+		.selectAll()
+		.execute();
+
+	expect(change).toHaveLength(1);
+	expect(change[0]?.created_at).toBeDefined();
+	expect(change[0]?.created_at).not.toBe("");
+});
+
+// the default SQLite timestamp is only precise to seconds,
+// changes can happen rapidly and while the graph is usually
+// used to order changes, certain queries may require
+// more precision, so we test that the timestamp format includes milliseconds
+test("timestamp format includes milliseconds", async () => {
+	const lix = await openLix({});
+
+	const snapshotContent = { id: "entity_timestamp" };
+
+	await lix.db
+		.insertInto("change")
+		.values({
+			id: "change_timestamp",
+			entity_id: "entity_timestamp",
+			schema_key: "test_schema",
+			schema_version: "1.0",
+			file_id: "file_timestamp",
+			plugin_key: "test_plugin",
+			snapshot_content: snapshotContent,
+		})
+		.execute();
+
+	const change = await lix.db
+		.selectFrom("change")
+		.where("id", "=", "change_timestamp")
+		.selectAll()
+		.execute();
+
+	expect(change).toHaveLength(1);
+	const timestamp = change[0]?.created_at;
+	expect(timestamp).toBeDefined();
+
+	// Verify format: YYYY-MM-DDTHH:MM:SS.SSSSSSZ (ISO 8601 with fractional seconds)
+	const timestampRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{1,6}Z$/;
+	expect(timestamp).toMatch(timestampRegex);
+
+	// Verify it contains a decimal point (fractional seconds)
+	expect(timestamp).toContain(".");
+});
+
+test("can insert with custom timestamp", async () => {
+	const lix = await openLix({});
+
+	const snapshotContent = { id: "entity_custom" };
+	const customTimestamp = "2023-01-01T12:00:00.123456Z";
+
+	await lix.db
+		.insertInto("change")
+		.values({
+			id: "change_custom",
+			entity_id: "entity_custom",
+			schema_key: "test_schema",
+			schema_version: "1.0",
+			file_id: "file_custom",
+			plugin_key: "test_plugin",
+			snapshot_content: snapshotContent,
+			created_at: customTimestamp,
+		})
+		.execute();
+
+	const change = await lix.db
+		.selectFrom("change")
+		.where("id", "=", "change_custom")
+		.selectAll()
+		.execute();
+
+	expect(change).toHaveLength(1);
+	expect(change[0]?.created_at).toBe(customTimestamp);
+});
+
+test("rejects non-UTC timestamps", async () => {
+	const lix = await openLix({});
+
+	const snapshotContent = { id: "entity_invalid_tz" };
+
+	// Test various invalid timezone formats
+	const invalidTimestamps = [
+		"2023-01-01T12:00:00.123456", // No timezone
+		"2023-01-01T12:00:00.123456+05:30", // Non-UTC timezone
+		"2023-01-01T12:00:00.123456-08:00", // Non-UTC timezone
+		"2023-01-01T12:00:00.123456+00:00", // UTC but wrong format (should be Z)
+		"2023-01-01 12:00:00.123456", // Space separator, no timezone
+	];
+
+	for (const invalidTimestamp of invalidTimestamps) {
+		await expect(
+			lix.db
+				.insertInto("change")
+				.values({
+					entity_id: "entity_invalid_tz",
+					schema_key: "test_schema",
+					schema_version: "1.0",
+					file_id: "file_invalid_tz",
+					plugin_key: "test_plugin",
+					snapshot_content: snapshotContent,
+					created_at: invalidTimestamp,
+				})
+				.execute()
+		).rejects.toThrow(/CHECK constraint failed.*created_at/i);
+	}
+});
+
+test("inserting a change with snapshot_content: null uses no-content snapshot", async () => {
+	const lix = await openLix({});
+
+	// Insert a change with null snapshot_content (deletion)
+	await lix.db
+		.insertInto("change")
+		.values({
+			id: "change_deletion",
+			entity_id: "entity_to_delete",
+			schema_key: "test_schema",
+			schema_version: "1.0",
+			file_id: "file1",
+			plugin_key: "test_plugin",
+			snapshot_content: null,
+		})
+		.execute();
+
+	// Verify the change was created with null snapshot_content
+	const change = await lix.db
+		.selectFrom("change")
+		.where("id", "=", "change_deletion")
+		.selectAll()
+		.executeTakeFirst();
+
+	expect(change).toBeDefined();
+	expect(change?.snapshot_content).toBe(null);
+
+	// Verify that the internal_change references the no-content snapshot
+	const internalChange = await (
+		lix.db as unknown as Kysely<LixInternalDatabaseSchema>
+	)
+		.selectFrom("internal_change")
+		.where("id", "=", "change_deletion")
+		.selectAll()
+		.executeTakeFirst();
+
+	expect(internalChange).toBeDefined();
+	expect(internalChange?.snapshot_id).toBe("no-content");
+});

package/src/change/schema.ts

@@ -0,0 +1,93 @@
+import type { SqliteWasmDatabase } from "sqlite-wasm-kysely";
+import type { Selectable, Insertable, Generated } from "kysely";
+
+export function applyChangeDatabaseSchema(
+	sqlite: SqliteWasmDatabase
+): SqliteWasmDatabase {
+	return sqlite.exec(`
+  CREATE TABLE IF NOT EXISTS internal_change (
+    id TEXT PRIMARY KEY DEFAULT (uuid_v7()),
+    entity_id TEXT NOT NULL,
+    schema_key TEXT NOT NULL,
+    schema_version TEXT NOT NULL,
+    file_id TEXT NOT NULL,
+    plugin_key TEXT NOT NULL,
+    snapshot_id TEXT NOT NULL, -- Foreign key to internal_snapshot
+    created_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')) NOT NULL CHECK (created_at LIKE '%Z'),
+
+    UNIQUE (id, entity_id, file_id, schema_key),
+    FOREIGN KEY(snapshot_id) REFERENCES internal_snapshot(id)
+  ) STRICT;
+
+  CREATE VIEW IF NOT EXISTS change AS
+  SELECT 
+    c.*,
+    (SELECT json(s.content)
+     FROM internal_snapshot s
+     WHERE s.id = c.snapshot_id) AS snapshot_content
+  FROM internal_change AS c;
+
+  CREATE TRIGGER IF NOT EXISTS change_insert
+  INSTEAD OF INSERT ON change
+  BEGIN
+    -- Insert the snapshot first (if there's content)
+    INSERT INTO internal_snapshot (id, content)
+    SELECT 
+      uuid_v7(), 
+      jsonb(NEW.snapshot_content)
+    WHERE NEW.snapshot_content IS NOT NULL
+      AND NOT EXISTS (SELECT 1 FROM internal_snapshot WHERE id = 'no-content' AND NEW.snapshot_content IS NULL);
+    
+    -- Insert the change, referencing the snapshot
+    INSERT INTO internal_change (
+      id,
+      entity_id,
+      schema_key,
+      schema_version,
+      file_id,
+      plugin_key,
+      snapshot_id,
+      created_at
+    ) VALUES (
+      COALESCE(NEW.id, uuid_v7()),
+      NEW.entity_id,
+      NEW.schema_key,
+      NEW.schema_version,
+      NEW.file_id,
+      NEW.plugin_key,
+      CASE 
+        WHEN NEW.snapshot_content IS NULL THEN 'no-content'
+        ELSE (SELECT id FROM internal_snapshot WHERE content = jsonb(NEW.snapshot_content) ORDER BY id DESC LIMIT 1)
+      END,
+      COALESCE(NEW.created_at, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    );
+  END;
+`);
+}
+
+// Types for the internal_change TABLE
+export type InternalChange = Selectable<InternalChangeTable>;
+export type NewInternalChange = Insertable<InternalChangeTable>;
+export type InternalChangeTable = {
+	id: Generated<string>;
+	entity_id: string;
+	schema_key: string;
+	schema_version: string;
+	file_id: string;
+	plugin_key: string;
+	snapshot_id: string; // The foreign key
+	created_at: Generated<string>;
+};
+
+export type Change = Selectable<ChangeView>;
+export type NewChange = Insertable<ChangeView>;
+export type ChangeView = {
+	id: Generated<string>;
+	entity_id: string;
+	schema_key: string;
+	schema_version: string;
+	file_id: string;
+	plugin_key: string;
+	created_at: Generated<string>;
+	snapshot_content: Record<string, any> | null;
+};

package/src/change-author/index.ts

@@ -0,0 +1 @@
+export { LixChangeAuthorSchema, type ChangeAuthor } from "./schema.js";

package/src/change-author/schema.test.ts

@@ -0,0 +1,300 @@
+import { describe, expect, test } from "vitest";
+import { openLix } from "../lix/open-lix.js";
+import { createAccount } from "../account/create-account.js";
+
+describe("change_author", () => {
+	test("insert, update, delete on the change_author view", async () => {
+		const lix = await openLix({});
+
+		// Create account
+		const account = await createAccount({
+			lix,
+			name: "Test Author",
+		});
+
+		// Create change
+		await lix.db
+			.insertInto("change")
+			.values({
+				id: "c0",
+				entity_id: "e0",
+				schema_key: "mock_schema",
+				schema_version: "1",
+				file_id: "f0",
+				plugin_key: "test_plugin",
+				snapshot_content: { id: "e0" },
+			})
+			.execute();
+
+		await lix.db
+			.insertInto("change_author")
+			.values([
+				{
+					change_id: "c0",
+					account_id: account.id,
+				},
+			])
+			.execute();
+
+		const viewAfterInsert = await lix.db
+			.selectFrom("change_author")
+			.orderBy("change_id", "asc")
+			.selectAll()
+			.execute();
+
+		expect(viewAfterInsert).toMatchObject([
+			{
+				change_id: "c0",
+				account_id: account.id,
+			},
+		]);
+
+		await lix.db
+			.deleteFrom("change_author")
+			.where("change_id", "=", "c0")
+			.execute();
+
+		const viewAfterDelete = await lix.db
+			.selectFrom("change_author")
+			.orderBy("change_id", "asc")
+			.selectAll()
+			.execute();
+
+		expect(viewAfterDelete).toEqual([]);
+
+		// After delete, there should be no state records for the change_author
+		const allStates = await lix.db
+			.selectFrom("state_all")
+			.where("schema_key", "=", "lix_change_author")
+			.selectAll()
+			.execute();
+
+		expect(allStates).toHaveLength(0); // All records should be deleted
+	});
+
+	test("should enforce primary key constraint (change_id, account_id)", async () => {
+		const lix = await openLix({});
+
+		// Create account
+		const account = await createAccount({
+			lix,
+			name: "Test Author",
+		});
+
+		await lix.db
+			.insertInto("change")
+			.values({
+				id: "c1",
+				entity_id: "e1",
+				schema_key: "mock_schema",
+				schema_version: "1",
+				file_id: "f1",
+				plugin_key: "test_plugin",
+				snapshot_content: { id: "e1" },
+			})
+			.execute();
+
+		// Insert first change_author
+		await lix.db
+			.insertInto("change_author")
+			.values({
+				change_id: "c1",
+				account_id: account.id,
+			})
+			.execute();
+
+		// Attempt duplicate insert with same primary key
+		await expect(
+			lix.db
+				.insertInto("change_author")
+				.values({
+					change_id: "c1",
+					account_id: account.id,
+				})
+				.execute()
+		).rejects.toThrow(/Primary key constraint violation/i);
+	});
+
+	test("should enforce foreign key constraint on change_id", async () => {
+		const lix = await openLix({});
+
+		// Create account (but NOT change)
+		const account = await createAccount({
+			lix,
+			name: "Test Author",
+		});
+
+		// Attempt to insert with non-existent change_id
+		await expect(
+			lix.db
+				.insertInto("change_author")
+				.values({
+					change_id: "c_nonexistent",
+					account_id: account.id,
+				})
+				.execute()
+		).rejects.toThrow(
+			/Foreign key constraint violation.*change_id.*lix_change.id/i
+		);
+	});
+
+	test("should enforce foreign key constraint on account_id", async () => {
+		const lix = await openLix({});
+
+		await lix.db
+			.insertInto("change")
+			.values({
+				id: "c1",
+				entity_id: "e1",
+				schema_key: "mock_schema",
+				schema_version: "1",
+				file_id: "f1",
+				plugin_key: "test_plugin",
+				snapshot_content: { id: "e1" },
+			})
+			.execute();
+
+		// Attempt to insert with non-existent account_id
+		await expect(
+			lix.db
+				.insertInto("change_author")
+				.values({
+					change_id: "c1",
+					account_id: "account_nonexistent",
+				})
+				.execute()
+		).rejects.toThrow(
+			/Foreign key constraint violation.*account_id.*lix_account.id/i
+		);
+	});
+
+	test("should allow multiple authors for the same change", async () => {
+		const lix = await openLix({});
+
+		// Create accounts
+		const author1 = await createAccount({
+			lix,
+			name: "Author One",
+		});
+
+		const author2 = await createAccount({
+			lix,
+			name: "Author Two",
+		});
+
+		await lix.db
+			.insertInto("change")
+			.values({
+				id: "c1",
+				entity_id: "e1",
+				schema_key: "mock_schema",
+				schema_version: "1",
+				file_id: "f1",
+				plugin_key: "test_plugin",
+				snapshot_content: { id: "e1" },
+			})
+			.execute();
+
+		// Insert multiple authors for same change
+		await lix.db
+			.insertInto("change_author")
+			.values([
+				{
+					change_id: "c1",
+					account_id: author1.id,
+				},
+				{
+					change_id: "c1",
+					account_id: author2.id,
+				},
+			])
+			.execute();
+
+		const authors = await lix.db
+			.selectFrom("change_author")
+			.where("change_id", "=", "c1")
+			.orderBy("account_id", "asc")
+			.selectAll()
+			.execute();
+
+		expect(authors).toHaveLength(2);
+		expect(authors).toMatchObject([
+			{
+				change_id: "c1",
+				account_id: author1.id,
+			},
+			{
+				change_id: "c1",
+				account_id: author2.id,
+			},
+		]);
+	});
+
+	test("should allow same author for multiple changes", async () => {
+		const lix = await openLix({});
+
+		// Create account
+		const author = await createAccount({
+			lix,
+			name: "Prolific Author",
+		});
+
+		await lix.db
+			.insertInto("change")
+			.values([
+				{
+					id: "c1",
+					entity_id: "e1",
+					schema_key: "mock_schema",
+					schema_version: "1",
+					file_id: "f1",
+					plugin_key: "test_plugin",
+					snapshot_content: { id: "e1" },
+				},
+				{
+					id: "c2",
+					entity_id: "e2",
+					schema_key: "mock_schema",
+					schema_version: "1",
+					file_id: "f2",
+					plugin_key: "test_plugin",
+					snapshot_content: { id: "e2" },
+				},
+			])
+			.execute();
+
+		// Insert same author for multiple changes
+		await lix.db
+			.insertInto("change_author")
+			.values([
+				{
+					change_id: "c1",
+					account_id: author.id,
+				},
+				{
+					change_id: "c2",
+					account_id: author.id,
+				},
+			])
+			.execute();
+
+		const authorChanges = await lix.db
+			.selectFrom("change_author")
+			.where("account_id", "=", author.id)
+			.orderBy("change_id", "asc")
+			.selectAll()
+			.execute();
+
+		expect(authorChanges).toHaveLength(2);
+		expect(authorChanges).toMatchObject([
+			{
+				change_id: "c1",
+				account_id: author.id,
+			},
+			{
+				change_id: "c2",
+				account_id: author.id,
+			},
+		]);
+	});
+});