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

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

@@ -1,6 +1,7 @@
 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({});
@@ -61,6 +62,18 @@ test("inserts, updates, deletes are handled", async () => {
 	]);
 });
 
+// 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({});
 
@@ -85,10 +98,93 @@ test("arbitrary json is allowed", async () => {
 		)
 		.execute();
 
-	expect(viewAfterInsert).toEqual(kvs);
+	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.todo("view should show changes across versions", async () => {
+test("view should show changes across versions", async () => {
 	const lix = await openLix({});
 
 	// creating a new version
@@ -96,7 +192,7 @@ test.todo("view should show changes across versions", async () => {
 
 	// inserting a key-value pair in version A
 	await lix.db
-		.insertInto("key_value_all")
+		.insertInto("key_value_by_version")
 		.values({
 			key: "foo",
 			value: "bar",
@@ -105,7 +201,7 @@ test.todo("view should show changes across versions", async () => {
 		.execute();
 
 	const kvAfterInsert = await lix.db
-		.selectFrom("key_value_all")
+		.selectFrom("key_value_by_version")
 		.where("key", "=", "foo")
 		.selectAll()
 		.execute();
@@ -118,22 +214,16 @@ test.todo("view should show changes across versions", async () => {
 		},
 	]);
 
-	const versionAAfterKvInsert = await lix.db
-		.selectFrom("version")
-		.where("id", "=", versionA.id)
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
 	// creating a new version from the active version
 	const versionB = await createVersion({
 		lix,
 		id: "versionB",
 		name: "versionB",
-		changeSet: { id: versionAAfterKvInsert.change_set_id },
+		from: versionA,
 	});
 
 	const kvAfterInsertInVersionB = await lix.db
-		.selectFrom("key_value_all")
+		.selectFrom("key_value_by_version")
 		.where("key", "=", "foo")
 		.selectAll()
 		.execute();
@@ -152,14 +242,14 @@ test.todo("view should show changes across versions", async () => {
 	]);
 
 	await lix.db
-		.updateTable("key_value_all")
+		.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_all")
+		.selectFrom("key_value_by_version")
 		.where("key", "=", "foo")
 		.selectAll()
 		.execute();
@@ -177,3 +267,139 @@ test.todo("view should show changes across versions", async () => {
 		},
 	]);
 });
+
+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

@@ -83,9 +83,9 @@ test("should create a label with specific version_id", async () => {
 		lixcol_version_id: version.id,
 	});
 
-	// Verify the label exists in the database (use label_all to access lixcol_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_all")
+		.selectFrom("label_by_version")
 		.selectAll()
 		.where("id", "=", label.id)
 		.where("lixcol_version_id", "=", version.id)

package/src/label/create-label.ts

@@ -1,6 +1,6 @@
+import { nanoId } from "../engine/functions/index.js";
 import type { Lix } from "../lix/open-lix.js";
-import type { Label } from "./schema.js";
-import { nanoid } from "../database/nano-id.js";
+import type { LixLabel } from "./schema-definition.js";
 
 /**
  * Creates a label that can be attached to change sets.
@@ -15,18 +15,22 @@ import { nanoid } from "../database/nano-id.js";
  */
 
 export async function createLabel(args: {
-	lix: Pick<Lix, "db">;
-	id?: Label["id"];
-	name: Label["name"];
+	lix: Pick<Lix, "db" | "call">;
+	id?: LixLabel["id"];
+	name: LixLabel["name"];
 	lixcol_version_id?: string;
-}): Promise<Label> {
+}): 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 || nanoid();
+		const labelId =
+			args.id ||
+			(await nanoId({
+				lix: args.lix,
+			}));
 
 		// Insert the label (views don't support returningAll)
 		await trx
-			.insertInto("label_all")
+			.insertInto("label_by_version")
 			.values({
 				id: labelId,
 				name: args.name,
@@ -38,7 +42,7 @@ export async function createLabel(args: {
 
 		// Query back the inserted label
 		const label = await trx
-			.selectFrom("label_all")
+			.selectFrom("label_by_version")
 			.selectAll()
 			.where("id", "=", labelId)
 			.where(

package/src/label/index.ts

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

package/src/label/schema-definition.ts

@@ -0,0 +1,27 @@
+import type {
+	FromLixSchemaDefinition,
+	LixSchemaDefinition,
+} from "../schema-definition/definition.js";
+
+export type LixLabel = FromLixSchemaDefinition<typeof LixLabelSchema>;
+
+export const LixLabelSchema = {
+	"x-lix-key": "lix_label",
+	"x-lix-version": "1.0",
+	"x-lix-primary-key": ["/id"],
+	"x-lix-override-lixcols": {
+		lixcol_file_id: '"lix"',
+		lixcol_plugin_key: '"lix_sdk"',
+	},
+	type: "object",
+	properties: {
+		id: {
+			type: "string",
+			"x-lix-default": "lix_uuid_v7()",
+		},
+		name: { type: "string" },
+	},
+	required: ["id", "name"],
+	additionalProperties: false,
+} as const;
+LixLabelSchema satisfies LixSchemaDefinition;

package/src/lix/index.ts

@@ -1,5 +1,2 @@
 export { type Lix, openLix } from "./open-lix.js";
 export { newLixFile } from "./new-lix.js";
-export { type LixStorageAdapter } from "./storage/lix-storage-adapter.js";
-export { InMemoryStorage } from "./storage/in-memory.js";
-export { OpfsStorage } from "./storage/opfs.js";