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

package/src/key-value/schema.test.ts

@@ -1,405 +0,0 @@
-import { expect, test } from "vitest";
-import { openLix } from "../lix/open-lix.js";
-import { createVersion } from "../version/create-version.js";
-import { sql } from "kysely";
-
-test("inserts, updates, deletes are handled", async () => {
-	const lix = await openLix({});
-
-	await lix.db
-		.insertInto("key_value")
-		.values({ key: "key0", value: "value0" })
-		.execute();
-
-	const viewAfterInsert = await lix.db
-		.selectFrom("key_value")
-		.where("key", "=", "key0")
-		.selectAll()
-		.executeTakeFirst();
-
-	expect(viewAfterInsert).toMatchObject({
-		key: "key0",
-		value: "value0",
-		// version_id: null,
-		// created_at: expect.any(String),
-	});
-
-	await lix.db
-		.updateTable("key_value")
-		.where("key", "=", "key0")
-		.set({ value: "value1" })
-		.execute();
-
-	await lix.db.deleteFrom("key_value").where("key", "=", "key0").execute();
-
-	const viewAfterDelete = await lix.db
-		.selectFrom("key_value")
-		.where("key", "=", "key0")
-		.selectAll()
-		.execute();
-
-	expect(viewAfterDelete).toMatchObject([]);
-
-	const changes = await lix.db
-		.selectFrom("change")
-
-		.where("schema_key", "=", "lix_key_value")
-		.where("change.entity_id", "=", "key0")
-		.selectAll()
-		.orderBy("change.created_at", "asc")
-		.execute();
-
-	expect(changes.map((change) => change.snapshot_content)).toMatchObject([
-		{
-			key: "key0",
-			value: "value0",
-		},
-		{
-			key: "key0",
-			value: "value1",
-		},
-		null,
-	]);
-});
-
-// NOTE ON SQLITE JSON1 AND BOOLEANS
-// ---------------------------------
-// SQLite JSON1 does not have a native boolean type at the SQL level.
-// When projecting a JSON boolean with json_extract(...), SQLite returns
-// SQL-native scalars: true -> 1 and false -> 0. Objects/arrays are
-// returned as JSON text unless wrapped, and strings are TEXT.
-//
-// Historically this test compared directly against JS booleans because
-// values were stored as strings (e.g. "true") and parsed elsewhere.
-// Now that we store proper JSON and project with json_extract, the view
-// returns 1/0 for booleans. This test therefore expects 1 for true and
-// 0 for false to reflect SQLite’s behavior.
-test("arbitrary json is allowed", async () => {
-	const lix = await openLix({});
-
-	const kvs = [
-		{ key: "key0", value: { foo: "bar" } },
-		{ key: "key1", value: ["foo", "bar"] },
-		{ key: "key2", value: "foo" },
-		{ key: "key3", value: 42 },
-		{ key: "key4", value: true },
-		{ key: "key5", value: null },
-	];
-
-	await lix.db.insertInto("key_value").values(kvs).execute();
-
-	const viewAfterInsert = await lix.db
-		.selectFrom("key_value")
-		.select(["key", "value"])
-		.where(
-			"key",
-			"in",
-			kvs.map((kv) => kv.key)
-		)
-		.execute();
-
-	const expected = kvs.map((kv) => ({
-		key: kv.key,
-		value: typeof kv.value === "boolean" ? (kv.value ? 1 : 0) : kv.value,
-	}));
-
-	expect(viewAfterInsert).toEqual(expected);
-});
-
-test("key_value insert stores proper JSON in state_by_version (no double encoding)", async () => {
-	const lix = await openLix({});
-
-	const kvs = [
-		{ key: "key0", value: { foo: "bar" } },
-		{ key: "key1", value: ["foo", "bar"] },
-		{ key: "key2", value: "foo" },
-		{ key: "key3", value: 42 },
-		{ key: "key4", value: true },
-		{ key: "key5", value: null },
-	];
-
-	await lix.db.insertInto("key_value").values(kvs).execute();
-
-	const rows = await lix.db
-		.selectFrom("state_by_version")
-		.where("schema_key", "=", "lix_key_value")
-		.where(
-			"entity_id",
-			"in",
-			kvs.map((kv) => kv.key)
-		)
-		.select(["entity_id", sql`json(snapshot_content)`.as("snapshot_content")])
-		.execute();
-
-	// map by key
-	const byKey = new Map(rows.map((r) => [r.entity_id, r as any]));
-
-	expect(byKey.get("key0")?.snapshot_content.value).toEqual({ foo: "bar" });
-	expect(byKey.get("key1")?.snapshot_content.value).toEqual(["foo", "bar"]);
-	expect(byKey.get("key2")?.snapshot_content.value).toBe("foo");
-	expect(byKey.get("key3")?.snapshot_content.value).toBe(42);
-	// With json(snapshot_content), driver decodes JSON booleans to true/false
-	// SQLite JSON1 surfaces booleans as 1/0
-	expect(byKey.get("key4")?.snapshot_content.value).toBe(true);
-	expect(byKey.get("key5")?.snapshot_content.value).toBeNull();
-});
-
-test("boolean representation matches between key_value view and state view", async () => {
-	const lix = await openLix({});
-
-	// Insert booleans via entity view
-	await lix.db
-		.insertInto("key_value")
-		.values([
-			{ key: "bool_true", value: true },
-			{ key: "bool_false", value: false },
-		])
-		.execute();
-
-	// Read from key_value view
-	const viewRows = await lix.db
-		.selectFrom("key_value")
-		.where("key", "in", ["bool_true", "bool_false"])
-		.select(["key", "value"])
-		.orderBy("key")
-		.execute();
-
-	// Read from state view (active version) and extract JSON value
-	const stateRows = await lix.db
-		.selectFrom("state")
-		.where("schema_key", "=", "lix_key_value")
-		.where("entity_id", "in", ["bool_true", "bool_false"])
-		.select([
-			"entity_id",
-			// json_extract returns SQLite-native scalars (1/0), matching the key_value view's behavior
-			sql`json_extract(snapshot_content, '$.value')`.as("value"),
-		])
-		.orderBy("entity_id")
-		.execute();
-
-	const viewMap = new Map(viewRows.map((r) => [r.key, r.value]));
-	const stateMap = new Map(stateRows.map((r: any) => [r.entity_id, r.value]));
-
-	expect(viewMap.get("bool_true")).toBe(stateMap.get("bool_true"));
-	expect(viewMap.get("bool_false")).toBe(stateMap.get("bool_false"));
-});
-
-test("view should show changes across versions", async () => {
-	const lix = await openLix({});
-
-	// creating a new version
-	const versionA = await createVersion({ lix, id: "versionA" });
-
-	// inserting a key-value pair in version A
-	await lix.db
-		.insertInto("key_value_by_version")
-		.values({
-			key: "foo",
-			value: "bar",
-			lixcol_version_id: versionA.id,
-		})
-		.execute();
-
-	const kvAfterInsert = await lix.db
-		.selectFrom("key_value_by_version")
-		.where("key", "=", "foo")
-		.selectAll()
-		.execute();
-
-	expect(kvAfterInsert).toMatchObject([
-		{
-			key: "foo",
-			value: "bar",
-			lixcol_version_id: versionA.id,
-		},
-	]);
-
-	// creating a new version from the active version
-	const versionB = await createVersion({
-		lix,
-		id: "versionB",
-		name: "versionB",
-		from: versionA,
-	});
-
-	const kvAfterInsertInVersionB = await lix.db
-		.selectFrom("key_value_by_version")
-		.where("key", "=", "foo")
-		.selectAll()
-		.execute();
-
-	expect(kvAfterInsertInVersionB).toMatchObject([
-		{
-			key: "foo",
-			value: "bar",
-			lixcol_version_id: versionA.id,
-		},
-		{
-			key: "foo",
-			value: "bar",
-			lixcol_version_id: versionB.id,
-		},
-	]);
-
-	await lix.db
-		.updateTable("key_value_by_version")
-		.where("key", "=", "foo")
-		.where("lixcol_version_id", "=", versionB.id)
-		.set({ value: "bar_updated" })
-		.execute();
-
-	const kvAfterUpdate = await lix.db
-		.selectFrom("key_value_by_version")
-		.where("key", "=", "foo")
-		.selectAll()
-		.execute();
-
-	expect(kvAfterUpdate).toMatchObject([
-		{
-			key: "foo",
-			value: "bar",
-			lixcol_version_id: versionA.id,
-		},
-		{
-			key: "foo",
-			value: "bar_updated",
-			lixcol_version_id: versionB.id,
-		},
-	]);
-});
-
-test("can update individual JSON properties using SQLite JSON functions", async () => {
-	const lix = await openLix({});
-
-	// Insert a complex JSON object
-	await lix.db
-		.insertInto("key_value")
-		.values({
-			key: "test_config",
-			value: {
-				enabled: true,
-				settings: {
-					theme: "dark",
-					language: "en",
-					notifications: true,
-				},
-				features: ["feature1", "feature2"],
-				count: 42,
-			},
-		})
-		.execute();
-
-	// First check the initial insert worked
-	const initialValue = await lix.db
-		.selectFrom("key_value")
-		.where("key", "=", "test_config")
-		.select("value")
-		.executeTakeFirst();
-
-	expect(initialValue?.value).toBeDefined();
-
-	// Update a single nested property using json_set
-	await lix.db
-		.updateTable("key_value")
-		.set({
-			value: sql`json_set(value, '$.settings.theme', 'light')`,
-		})
-		.where("key", "=", "test_config")
-		.execute();
-
-	const afterThemeUpdate = await lix.db
-		.selectFrom("key_value")
-		.where("key", "=", "test_config")
-		.select("value")
-		.executeTakeFirst();
-
-	expect(afterThemeUpdate?.value).toMatchObject({
-		enabled: true,
-		settings: {
-			theme: "light", // Changed
-			language: "en",
-			notifications: true,
-		},
-		features: ["feature1", "feature2"],
-		count: 42,
-	});
-
-	// Update multiple properties at once
-	await lix.db
-		.updateTable("key_value")
-		.set({
-			value: sql`json_set(value, '$.enabled', false, '$.count', 100, '$.settings.notifications', false)`,
-		})
-		.where("key", "=", "test_config")
-		.execute();
-
-	const afterMultiUpdate = await lix.db
-		.selectFrom("key_value")
-		.where("key", "=", "test_config")
-		.select("value")
-		.executeTakeFirst();
-
-	expect(afterMultiUpdate?.value).toMatchObject({
-		enabled: 0, // Changed - SQLite stores false as 0
-		settings: {
-			theme: "light",
-			language: "en",
-			notifications: 0, // Changed - SQLite stores false as 0
-		},
-		features: ["feature1", "feature2"],
-		count: 100, // Changed
-	});
-
-	// Read specific properties using JSON operators
-	const specificProps = await lix.db
-		.selectFrom("key_value")
-		.where("key", "=", "test_config")
-		.select([
-			sql<boolean>`value ->> '$.enabled'`.as("enabled"),
-			sql<string>`value ->> '$.settings.theme'`.as("theme"),
-			sql<number>`value ->> '$.count'`.as("count"),
-		])
-		.executeTakeFirst();
-
-	expect(specificProps).toEqual({
-		enabled: 0, // SQLite returns 0 for false
-		theme: "light",
-		count: 100,
-	});
-});
-
-test("key_value preserves '1' as string when inserted as string", async () => {
-	const lix = await openLix({});
-
-	await lix.db
-		.insertInto("key_value")
-		.values({ key: "type_test_string", value: "1" })
-		.execute();
-
-	const row = await lix.db
-		.selectFrom("key_value")
-		.selectAll()
-		.where("key", "=", "type_test_string")
-		.executeTakeFirstOrThrow();
-
-	expect(typeof row.value).toBe("string");
-	expect(row.value).toBe("1");
-});
-
-test("key_value preserves 1 as number when inserted as number", async () => {
-	const lix = await openLix({});
-
-	await lix.db
-		.insertInto("key_value")
-		.values({ key: "type_test_number", value: 1 })
-		.execute();
-
-	const row = await lix.db
-		.selectFrom("key_value")
-		.selectAll()
-		.where("key", "=", "type_test_number")
-		.executeTakeFirstOrThrow();
-
-	expect(typeof row.value).toBe("number");
-	expect(row.value).toBe(1);
-});

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

@@ -1,234 +0,0 @@
-import { test, expect } from "vitest";
-import { openLix } from "../lix/open-lix.js";
-import { createLabel } from "./create-label.js";
-import { createVersion } from "../version/create-version.js";
-
-test("should create a label with auto-generated ID", async () => {
-	const lix = await openLix({});
-
-	const labelName = "feature";
-	const label = await createLabel({
-		lix,
-		name: labelName,
-	});
-
-	// Verify the label was created
-	expect(label).toMatchObject({
-		name: labelName,
-	});
-	expect(label.id).toBeDefined();
-	expect(typeof label.id).toBe("string");
-
-	// Verify the label exists in the database
-	const dbLabel = await lix.db
-		.selectFrom("label")
-		.selectAll()
-		.where("id", "=", label.id)
-		.executeTakeFirstOrThrow();
-
-	expect(dbLabel).toMatchObject({
-		name: labelName,
-		id: label.id,
-	});
-});
-
-test("should create a label with custom ID", async () => {
-	const lix = await openLix({});
-
-	const customId = "custom-label-id";
-	const labelName = "bugfix";
-	const label = await createLabel({
-		lix,
-		id: customId,
-		name: labelName,
-	});
-
-	// Verify the label was created with the custom ID
-	expect(label).toMatchObject({
-		id: customId,
-		name: labelName,
-	});
-
-	// Verify the label exists in the database
-	const dbLabel = await lix.db
-		.selectFrom("label")
-		.selectAll()
-		.where("id", "=", customId)
-		.executeTakeFirstOrThrow();
-
-	expect(dbLabel).toMatchObject({
-		id: customId,
-		name: labelName,
-	});
-});
-
-test("should create a label with specific version_id", async () => {
-	const lix = await openLix({});
-
-	const version = await createVersion({
-		lix,
-		id: "test-version",
-	});
-
-	const labelName = "hotfix";
-	const label = await createLabel({
-		lix,
-		name: labelName,
-		lixcol_version_id: version.id,
-	});
-
-	// Verify the label was created with the specified lixcol_version_id
-	expect(label).toMatchObject({
-		name: labelName,
-		lixcol_version_id: version.id,
-	});
-
-	// Verify the label exists in the database (use label_by_version to access lixcol_version_id)
-	const dbLabel = await lix.db
-		.selectFrom("label_by_version")
-		.selectAll()
-		.where("id", "=", label.id)
-		.where("lixcol_version_id", "=", version.id)
-		.executeTakeFirstOrThrow();
-
-	expect(dbLabel).toMatchObject({
-		name: labelName,
-		lixcol_version_id: version.id,
-	});
-});
-
-test("should handle transaction correctly", async () => {
-	const lix = await openLix({});
-	const labelName = "transaction-test";
-
-	await lix.db.transaction().execute(async (trx) => {
-		const label = await createLabel({
-			lix: { ...lix, db: trx },
-			name: labelName,
-		});
-
-		expect(label.name).toBe(labelName);
-		expect(label.id).toBeDefined();
-
-		// Verify the label exists within the transaction
-		const dbLabel = await trx
-			.selectFrom("label")
-			.selectAll()
-			.where("id", "=", label.id)
-			.executeTakeFirstOrThrow();
-
-		expect(dbLabel.name).toBe(labelName);
-	});
-});
-
-test("should create multiple labels with unique IDs", async () => {
-	const lix = await openLix({});
-
-	const label1 = await createLabel({
-		lix,
-		name: "label-1",
-	});
-
-	const label2 = await createLabel({
-		lix,
-		name: "label-2",
-	});
-
-	// Verify labels have different IDs
-	expect(label1.id).not.toBe(label2.id);
-	expect(label1.name).toBe("label-1");
-	expect(label2.name).toBe("label-2");
-
-	// Verify both labels exist in the database
-	const labels = await lix.db
-		.selectFrom("label")
-		.selectAll()
-		.where("id", "in", [label1.id, label2.id])
-		.execute();
-
-	expect(labels).toHaveLength(2);
-	expect(labels.map((l) => l.name).sort()).toEqual(["label-1", "label-2"]);
-});
-
-test("should create multiple labels within a transaction", async () => {
-	const lix = await openLix({});
-
-	await lix.db.transaction().execute(async (trx) => {
-		const label1 = await createLabel({
-			lix: { ...lix, db: trx },
-			name: "tx-label-1",
-		});
-
-		const label2 = await createLabel({
-			lix: { ...lix, db: trx },
-			name: "tx-label-2",
-		});
-
-		// Labels should have unique IDs
-		expect(label1.id).not.toBe(label2.id);
-		expect(label1.name).toBe("tx-label-1");
-		expect(label2.name).toBe("tx-label-2");
-
-		// Verify both labels exist within the transaction
-		const labels = await trx
-			.selectFrom("label")
-			.selectAll()
-			.where("id", "in", [label1.id, label2.id])
-			.execute();
-
-		expect(labels).toHaveLength(2);
-	});
-});
-
-test("should use nanoid for ID generation", async () => {
-	const lix = await openLix({});
-
-	const label1 = await createLabel({
-		lix,
-		name: "nanoid-test-1",
-	});
-
-	const label2 = await createLabel({
-		lix,
-		name: "nanoid-test-2",
-	});
-
-	// Verify IDs are strings and unique (characteristic of nanoid)
-	expect(typeof label1.id).toBe("string");
-	expect(typeof label2.id).toBe("string");
-	expect(label1.id).not.toBe(label2.id);
-
-	// nanoid typically generates 21-character strings
-	expect(label1.id.length).toBeGreaterThan(0);
-	expect(label2.id.length).toBeGreaterThan(0);
-});
-
-test("should handle labels with same name but different IDs", async () => {
-	const lix = await openLix({});
-
-	const sameName = "duplicate-name";
-	const label1 = await createLabel({
-		lix,
-		name: sameName,
-	});
-
-	const label2 = await createLabel({
-		lix,
-		name: sameName,
-	});
-
-	// Verify labels have different IDs but same name
-	expect(label1.id).not.toBe(label2.id);
-	expect(label1.name).toBe(sameName);
-	expect(label2.name).toBe(sameName);
-
-	// Verify both labels exist in the database
-	const labels = await lix.db
-		.selectFrom("label")
-		.selectAll()
-		.where("name", "=", sameName)
-		.execute();
-
-	expect(labels).toHaveLength(2);
-	expect(labels.map((l) => l.id).sort()).toEqual([label1.id, label2.id].sort());
-});

package/src/label/create-label.ts

@@ -1,65 +0,0 @@
-import { nanoId } from "../engine/functions/index.js";
-import type { Lix } from "../lix/open-lix.js";
-import type { LixLabel } from "./schema-definition.js";
-
-/**
- * Creates a label that can be attached to change sets.
- *
- * Labels help categorise change sets, for example "checkpoint" or
- * "reviewed". They are simple name identifiers stored per version.
- *
- * @example
- * ```ts
- * const label = await createLabel({ lix, name: "checkpoint" })
- * ```
- */
-
-export async function createLabel(args: {
-	lix: Pick<Lix, "db" | "call">;
-	id?: LixLabel["id"];
-	name: LixLabel["name"];
-	lixcol_version_id?: string;
-}): Promise<LixLabel> {
-	const executeInTransaction = async (trx: Lix["db"]) => {
-		// Generate ID if not provided (views handle this, but we need it for querying back)
-		const labelId =
-			args.id ||
-			(await nanoId({
-				lix: args.lix,
-			}));
-
-		// Insert the label (views don't support returningAll)
-		await trx
-			.insertInto("label_by_version")
-			.values({
-				id: labelId,
-				name: args.name,
-				lixcol_version_id:
-					args.lixcol_version_id ??
-					trx.selectFrom("active_version").select("version_id"),
-			})
-			.execute();
-
-		// Query back the inserted label
-		const label = await trx
-			.selectFrom("label_by_version")
-			.selectAll()
-			.where("id", "=", labelId)
-			.where(
-				"lixcol_version_id",
-				"=",
-				args.lixcol_version_id ??
-					trx.selectFrom("active_version").select("version_id")
-			)
-			.executeTakeFirstOrThrow();
-
-		return label;
-	};
-
-	// user provided an open transaction
-	if (args.lix.db.isTransaction) {
-		return executeInTransaction(args.lix.db);
-	} else {
-		return args.lix.db.transaction().execute(executeInTransaction);
-	}
-}

package/src/label/index.ts

@@ -1,2 +0,0 @@
-export { createLabel } from "./create-label.js";
-export { LixLabelSchema, type LixLabel } from "./schema-definition.js";