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

package/src/database/init-db.test.ts

@@ -1,626 +0,0 @@
-import { createInMemoryDatabase } from "sqlite-wasm-kysely";
-import { test, expect } from "vitest";
-import { initDb } from "./init-db.js";
-import { validate } from "uuid";
-import { mockChange } from "../change/mock-change.js";
-import { jsonSha256 } from "../snapshot/json-sha-256.js";
-import { sql } from "kysely";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
-import { updateChangesInVersion } from "../version/update-changes-in-version.js";
-import { createVersion } from "../version/create-version.js";
-
-// file ids are always in the URL of lix apps
-// to increase sharing, the ids should be as short as possible
-//
-// 129 million file creations will lead to a 1% chance of a collision
-//
-// if someone uses lix to handle 129 million files, we can
-// increase the length of the id :D
-test("file ids should default to nano_id(10)", async () => {
-	const lix = await openLixInMemory({});
-
-	const file = await lix.db
-		.insertInto("file")
-		.values({
-			path: "/mock.txt",
-			data: new Uint8Array(),
-		})
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	expect(file.id.length).toBe(10);
-});
-
-test("change ids should default to uuid", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	const change = await db
-		.insertInto("change")
-		.values({
-			schema_key: "file",
-			entity_id: "value1",
-			file_id: "mock",
-			plugin_key: "mock-plugin",
-			snapshot_id: "no-content",
-		})
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	expect(validate(change.id)).toBe(true);
-});
-
-test("snapshot ids should default to sha256", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	const content = { a: "value" };
-
-	const snapshot = await db
-		.insertInto("snapshot")
-		.values({
-			content,
-		})
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	expect(snapshot.id).toBe(jsonSha256(content));
-});
-
-test("inserting the same snapshot multiple times should be possible and not lead to duplicates (content addressable)", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	const initialSnapshots = await db
-		.selectFrom("snapshot")
-		.selectAll()
-		.execute();
-
-	const snapshot1 = await db
-		.insertInto("snapshot")
-		.values({
-			content: { a: "some data" },
-		})
-		.onConflict((oc) => oc.doNothing())
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	const snapshot2 = await db
-		.insertInto("snapshot")
-		.values({
-			content: { a: "some data" },
-		})
-		.onConflict((oc) =>
-			oc.doUpdateSet((eb) => ({
-				content: eb.ref("excluded.content"),
-			}))
-		)
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	const snapshots = await db.selectFrom("snapshot").selectAll().execute();
-
-	expect(snapshots).toHaveLength(initialSnapshots.length + 1);
-	expect(snapshot1.id).toBe(snapshot2.id);
-});
-
-test("an empty snapshot should default to the special 'no-content' snapshot to store disk space", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-	const snapshot = await db
-		.insertInto("snapshot")
-		.values({
-			content: null,
-		})
-		.onConflict((oc) =>
-			oc.doUpdateSet((eb) => ({
-				content: eb.ref("excluded.content"),
-			}))
-		)
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	expect(snapshot.id).toBe("no-content");
-});
-
-// https://github.com/opral/lix-sdk/issues/71
-test("files should be able to have metadata", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	sqlite.createFunction({
-		name: "triggerFileQueue",
-		arity: 0,
-		// @ts-expect-error - dynamic function
-		xFunc: () => {
-			// console.log('test')
-		},
-	});
-
-	const file = await db
-		.insertInto("file")
-		.values({
-			path: "/mock.csv",
-			data: new Uint8Array(),
-			metadata: {
-				primary_key: "email",
-			},
-		})
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	expect(file.metadata?.primary_key).toBe("email");
-
-	const updatedFile = await db
-		.updateTable("file")
-		.where("path", "=", "/mock.csv")
-		.set({
-			metadata: {
-				primary_key: "something-else",
-			},
-		})
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	expect(updatedFile.metadata?.primary_key).toBe("something-else");
-});
-
-test("change graph edges can't reference themselves", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	await expect(
-		db
-			.insertInto("change_edge")
-			.values({
-				parent_id: "change1",
-				child_id: "change1",
-			})
-			.returningAll()
-			.execute()
-	).rejects.toThrowErrorMatchingInlineSnapshot(
-		`[SQLite3Error: SQLITE_CONSTRAINT_CHECK: sqlite3 result code 275: CHECK constraint failed: parent_id != child_id]`
-	);
-});
-
-test("change set items must be unique", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	await db
-		.insertInto("change_set")
-		.values({
-			id: "change-set-1",
-		})
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	await db
-		.insertInto("change")
-		.values(
-			mockChange({
-				id: "change-1",
-			})
-		)
-		.execute();
-
-	await db
-		.insertInto("change_set_element")
-		.values({
-			change_set_id: "change-set-1",
-			change_id: "change-1",
-		})
-		.execute();
-
-	expect(
-		db
-			.insertInto("change_set_element")
-			.values({
-				change_set_id: "change-set-1",
-				change_id: "change-1",
-			})
-			.returningAll()
-			.execute()
-	).rejects.toThrowErrorMatchingInlineSnapshot(
-		`[SQLite3Error: SQLITE_CONSTRAINT_PRIMARYKEY: sqlite3 result code 1555: UNIQUE constraint failed: change_set_element.change_set_id, change_set_element.change_id]`
-	);
-});
-
-// 8B IDs needed, in order to have a 1% probability of at least one collision.
-test("discussion.id are nano_id(12)", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	const changeSet = await db
-		.insertInto("change_set")
-		.defaultValues()
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	const discussion = await db
-		.insertInto("discussion")
-		.values({
-			change_set_id: changeSet.id,
-		})
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	expect(discussion.id.length).toBe(12);
-});
-
-// 499B IDs needed, in order to have a 1% probability of at least one collision.
-test("comment.id are nano_id(14)", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	const changeSet = await db
-		.insertInto("change_set")
-		.defaultValues()
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	const discussion = await db
-		.insertInto("discussion")
-		.values({
-			change_set_id: changeSet.id,
-		})
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	const comment = await db
-		.insertInto("comment")
-		.values({
-			discussion_id: discussion.id,
-			content: "mock",
-		})
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	expect(comment.id.length).toBe(14);
-});
-
-// 30T IDs needed, in order to have a 1% probability of at least one collision
-test("change_set.id are nano_id(16)", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	const changeSet = await db
-		.insertInto("change_set")
-		.defaultValues()
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	expect(changeSet.id.length).toBe(16);
-});
-
-// 2M IDs needed, in order to have a 1% probability of at least one collision.
-// it is assumed that creating 2 million labels is ... unlikely
-test("label.id is nano_id(8)", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	const label = await db
-		.insertInto("label")
-		.values({
-			name: "mock",
-		})
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	expect(label.id.length).toBe(8);
-});
-
-test("creating multiple discussions for one change set should be possible", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	const changeSet = await db
-		.insertInto("change_set")
-		.defaultValues()
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	await db
-		.insertInto("discussion")
-		.values([
-			{ id: "discussion-1", change_set_id: changeSet.id },
-			{ id: "discussion-2", change_set_id: changeSet.id },
-		])
-		.returningAll()
-		.execute();
-
-	const discussions = await db
-		.selectFrom("discussion")
-		.selectAll()
-		.where("change_set_id", "=", changeSet.id)
-		.execute();
-
-	expect(discussions).toHaveLength(2);
-});
-
-test("the checkpoint label should be created if it doesn't exist", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	const tag = await db
-		.selectFrom("label")
-		.selectAll()
-		.where("name", "=", "checkpoint")
-		.executeTakeFirst();
-
-	expect(tag).toMatchObject({
-		name: "checkpoint",
-	});
-});
-
-test("a default main version should exist", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	const version = await db
-		.selectFrom("version")
-		.selectAll()
-		.where("name", "=", "main")
-		.executeTakeFirst();
-
-	expect(version).toBeDefined();
-});
-
-test("re-opening the same database shouldn't lead to duplicate insertion of the current version", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	const newversion = await db
-		.insertInto("version")
-		.values({ name: "mock" })
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	await db.updateTable("current_version").set({ id: newversion.id }).execute();
-
-	const db2 = initDb({ sqlite });
-
-	const currentversion = await db2
-		.selectFrom("current_version")
-		.selectAll()
-		.execute();
-
-	expect(currentversion).toHaveLength(1);
-});
-
-test("invalid file paths should be rejected", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	// init the trigger function (usually defined by lix only)
-	sqlite.createFunction({
-		name: "triggerFileQueue",
-		arity: 0,
-		// @ts-expect-error - dynamic function
-		xFunc: () => {},
-	});
-
-	await expect(
-		db
-			.insertInto("file")
-			.values({
-				path: "invalid-path",
-				data: new Uint8Array(),
-			})
-			.returningAll()
-			.execute()
-	).rejects.toThrowError("File path must start with a slash");
-});
-
-test("vector clock functions", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	const vectorClockTick1 =
-		await sql`select lix_session() as session, lix_session_clock_tick() as time`.execute(
-			db
-		);
-	const vectorClockTick2 =
-		await sql`select lix_session() as session, lix_session_clock_tick() as time`.execute(
-			db
-		);
-
-	expect((vectorClockTick1.rows[0] as any)["session"]).toEqual(
-		(vectorClockTick2.rows[0] as any)["session"]
-	);
-	expect((vectorClockTick1.rows[0] as any)["time"]).toBeLessThan(
-		(vectorClockTick2.rows[0] as any)["time"]
-	);
-});
-
-test("mutation should only be recorded if sync row is not present", async () => {
-	const sqlite = await createInMemoryDatabase({
-		readOnly: false,
-	});
-	const db = initDb({ sqlite });
-
-	await db
-		.insertInto("change")
-		.values({
-			schema_key: "file",
-			entity_id: "value1",
-			file_id: "mock",
-			plugin_key: "mock-plugin",
-			snapshot_id: "no-content",
-		})
-		.returningAll()
-		.executeTakeFirstOrThrow();
-	const mutation = await db.selectFrom("mutation_log").selectAll().execute();
-
-	expect(mutation).toHaveLength(1);
-
-	await db
-		.insertInto("mutation_log")
-		.values({
-			session: "mock",
-			wall_clock: 0,
-			session_time: 0,
-			row_id: { ignored: "ignored" },
-			table_name: "mutation_log",
-			operation: "INSERT",
-		})
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	const mutationWithFlag = await db
-		.selectFrom("mutation_log")
-		.selectAll()
-		.execute();
-	expect(mutationWithFlag).toHaveLength(2);
-
-	await db
-		.insertInto("change")
-		.values({
-			schema_key: "file",
-			entity_id: "value1",
-			file_id: "mock",
-			plugin_key: "mock-plugin",
-			snapshot_id: "no-content",
-		})
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	const mutationLogAfterIgnoredChange = await db
-		.selectFrom("mutation_log")
-		.selectAll()
-		.execute();
-	expect(mutationLogAfterIgnoredChange).toHaveLength(2);
-
-	// const vectorClockTick1 =
-	// 	await sql`select lix_session() as session, lix_session_clock_tick() as time`.execute(
-	// 		db
-	// 	);
-	// const vectorClockTick2 =
-	// 	await sql`select lix_session() as session, lix_session_clock_tick() as time`.execute(
-	// 		db
-	// 	);
-});
-
-test("deleting a version cascades to version changes", async () => {
-	const lix = await openLixInMemory({});
-	const version = await lix.db
-		.insertInto("version")
-		.values({ name: "mock" })
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	const changes = await lix.db
-		.insertInto("change")
-		.values(
-			mockChange({
-				entity_id: `mock`,
-			})
-		)
-		.returningAll()
-		.execute();
-
-	await updateChangesInVersion({
-		lix,
-		version,
-		changes,
-	});
-
-	await lix.db.deleteFrom("version").where("id", "=", version.id).execute();
-
-	const versionChangesAfterDelete = await lix.db
-		.selectFrom("version_change")
-		.where("version_change.version_id", "=", version.id)
-		.selectAll()
-		.execute();
-
-	expect(versionChangesAfterDelete).toHaveLength(0);
-});
-
-test("version_change must have a unique entity_id, file_id, version_id, and schema_id", async () => {
-	const lix = await openLixInMemory({});
-
-	const version0 = await createVersion({ lix, name: "version0" });
-	const version1 = await createVersion({ lix, name: "version1" });
-
-	const mockChanges = [
-		mockChange({ entity_id: "mock0", file_id: "file0", schema_key: "file" }),
-	] as const;
-
-	await lix.db.insertInto("change").values(mockChanges).execute();
-
-	const versionChange = {
-		change_id: mockChanges[0].id,
-		file_id: mockChanges[0].file_id,
-		entity_id: mockChanges[0].entity_id,
-		schema_key: mockChanges[0].schema_key,
-	};
-
-	await lix.db
-		.insertInto("version_change")
-		.values({ ...versionChange, version_id: version0.id })
-		.execute();
-
-	// inserting the same change again should throw
-	await expect(
-		lix.db
-			.insertInto("version_change")
-			.values({ ...versionChange, version_id: version0.id })
-			.execute()
-	).rejects.toThrowErrorMatchingInlineSnapshot(
-		`[SQLite3Error: SQLITE_CONSTRAINT_UNIQUE: sqlite3 result code 2067: UNIQUE constraint failed: version_change.version_id, version_change.entity_id, version_change.schema_key, version_change.file_id]`
-	);
-
-	// insert into version 1 should work
-	await lix.db
-		.insertInto("version_change")
-		.values({ ...versionChange, version_id: version1.id })
-		.execute();
-});
-
-test("versions have a unique and default human readable name", async () => {
-	const lix = await openLixInMemory({});
-
-	const version0 = await createVersion({ lix });
-	const version1 = await createVersion({ lix });
-
-	expect(version0.name).not.toBe(version1.name);
-
-	await expect(
-		createVersion({ lix, name: version0.name }),
-		"version.name is unique"
-	).rejects.toThrow();
-});