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

package/src/label/create-label.ts

@@ -1,6 +1,6 @@
 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.js";
+import { nanoId } from "../deterministic/index.js";
 
 /**
  * Creates a label that can be attached to change sets.
@@ -15,14 +15,14 @@ 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" | "sqlite">;
+	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 || nanoId({ lix: args.lix });
 
 		// Insert the label (views don't support returningAll)
 		await trx

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 as Label } from "./schema.js";

package/src/label/schema.ts

@@ -1,25 +1,22 @@
-import type { SqliteWasmDatabase } from "sqlite-wasm-kysely";
 import type {
 	LixSchemaDefinition,
 	FromLixSchemaDefinition,
 } from "../schema-definition/definition.js";
 import { createEntityViewsIfNotExists } from "../entity-views/entity-view-builder.js";
-import { nanoid } from "../database/nano-id.js";
+import { nanoId } from "../deterministic/index.js";
+import type { Lix } from "../lix/open-lix.js";
 
 export function applyLabelDatabaseSchema(
-	sqlite: SqliteWasmDatabase
-): SqliteWasmDatabase {
-	// Create both primary and _all views for label
+	lix: Pick<Lix, "sqlite" | "db">
+): void {
 	createEntityViewsIfNotExists({
-		lix: { sqlite },
+		lix,
 		schema: LixLabelSchema,
 		overrideName: "label",
 		pluginKey: "lix_own_entity",
 		hardcodedFileId: "lix",
-		defaultValues: { id: () => nanoid() },
+		defaultValues: { id: () => nanoId({ lix }) },
 	});
-
-	return sqlite;
 }
 
 export const LixLabelSchema = {
@@ -37,4 +34,4 @@ export const LixLabelSchema = {
 LixLabelSchema satisfies LixSchemaDefinition;
 
 // Pure business logic type (inferred from schema)
-export type Label = FromLixSchemaDefinition<typeof LixLabelSchema>;
+export type LixLabel = FromLixSchemaDefinition<typeof LixLabelSchema>;

package/src/lix/new-lix.test.ts

@@ -129,8 +129,6 @@ test("bootstrap changes include lix_name key-value in the global version", async
 		.selectAll()
 		.execute();
 
-	console.log("lix_name key-value:", kv);
-
 	expect(kv).toHaveLength(1);
 	expect(kv[0]?.key).toBe("lix_name");
 	expect(kv[0]?.value).toBeDefined();
@@ -217,3 +215,205 @@ test("newLixFile can use provided key values", async () => {
 	expect(customKv?.value).toBe("custom_value");
 	expect(customKv?.lixcol_version_id).toBe("global");
 });
+
+test("provided key values default to the active version if lixcol_version_id is not specified", async () => {
+	const blob = await newLixFile({
+		keyValues: [
+			{ key: "test_key_1", value: "test_value_1" },
+			{ key: "test_key_2", value: "test_value_2" },
+		],
+	});
+
+	const lix = await openLix({ blob });
+
+	// Get the active version
+	const activeVersion = await lix.db
+		.selectFrom("active_version")
+		.select("version_id")
+		.executeTakeFirst();
+
+	expect(activeVersion).toBeDefined();
+	expect(activeVersion?.version_id).toBeDefined();
+
+	// Check that the key values are associated with the active version
+	const kv1 = await lix.db
+		.selectFrom("key_value_all")
+		.where("key", "=", "test_key_1")
+		.selectAll()
+		.executeTakeFirst();
+
+	expect(kv1?.value).toBe("test_value_1");
+	expect(kv1?.lixcol_version_id).toBe(activeVersion?.version_id);
+
+	const kv2 = await lix.db
+		.selectFrom("key_value_all")
+		.where("key", "=", "test_key_2")
+		.selectAll()
+		.executeTakeFirst();
+
+	expect(kv2?.value).toBe("test_value_2");
+	expect(kv2?.lixcol_version_id).toBe(activeVersion?.version_id);
+
+	// The active version should be "main" (not "global")
+	const mainVersion = await lix.db
+		.selectFrom("version")
+		.where("id", "=", activeVersion!.version_id)
+		.selectAll()
+		.executeTakeFirst();
+
+	expect(mainVersion?.name).toBe("main");
+});
+
+test("deterministic mode with randomLixId: true results in different lix_ids", async () => {
+	// Create two lix files with deterministic mode but randomLixId: true
+	const blob1 = await newLixFile({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true, randomLixId: true },
+			},
+		],
+	});
+	const blob2 = await newLixFile({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true, randomLixId: true },
+			},
+		],
+	});
+
+	// The lix_ids should be different when randomLixId is true
+	expect(blob1._lix.id).toBeDefined();
+	expect(blob2._lix.id).toBeDefined();
+	expect(blob1._lix.id).not.toBe(blob2._lix.id);
+});
+
+test("deterministic mode results in identical lix_ids", async () => {
+	// Create two lix files with deterministic mode enabled
+	const blob1 = await newLixFile({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true },
+			},
+		],
+	});
+	const blob2 = await newLixFile({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true },
+			},
+		],
+	});
+
+	// The lix_ids should be identical (deterministic-lix-id)
+	expect(blob1._lix.id).toBeDefined();
+	expect(blob2._lix.id).toBeDefined();
+	expect(blob1._lix.id).toBe(blob2._lix.id);
+	expect(blob1._lix.id).toBe("deterministic-lix-id");
+});
+
+test("deterministic mode creates fully deterministic lix", async () => {
+	// Create two lix files with deterministic mode enabled
+	const blob1 = await newLixFile({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true },
+			},
+		],
+	});
+	const blob2 = await newLixFile({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true },
+			},
+		],
+	});
+
+	const lix1 = await openLix({ blob: blob1 });
+	const lix2 = await openLix({ blob: blob2 });
+
+	// Check that all changes have identical IDs and timestamps
+	const changes1 = await lix1.db
+		.selectFrom("change")
+		.select(["id", "entity_id", "created_at"])
+		.orderBy("id")
+		.execute();
+	const changes2 = await lix2.db
+		.selectFrom("change")
+		.select(["id", "entity_id", "created_at"])
+		.orderBy("id")
+		.execute();
+
+	expect(changes1).toEqual(changes2);
+
+	// Check that all entity IDs are identical
+	const versions1 = await lix1.db
+		.selectFrom("version")
+		.select(["id", "name"])
+		.orderBy("id")
+		.execute();
+	const versions2 = await lix2.db
+		.selectFrom("version")
+		.select(["id", "name"])
+		.orderBy("id")
+		.execute();
+
+	expect(versions1).toEqual(versions2);
+
+	// Check timestamps are deterministic (epoch 0)
+	expect(changes1[0]?.created_at).toBe("1970-01-01T00:00:00.000Z");
+});
+
+test("deterministic mode config is persisted correctly", async () => {
+	const blob = await newLixFile({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true, randomLixId: false },
+			},
+		],
+	});
+	const lix = await openLix({ blob });
+
+	// Check that lix_deterministic_mode exists in key_value_all
+	// Since no lixcol_version_id was specified, it should be in the main version
+	const result = await lix.db
+		.selectFrom("key_value_all")
+		.where("key", "=", "lix_deterministic_mode")
+		.select(["key", "value", "lixcol_version_id"])
+		.executeTakeFirst();
+
+	expect(result).toBeDefined();
+	expect(result?.key).toBe("lix_deterministic_mode");
+	expect(result?.value).toEqual({ enabled: true, randomLixId: false }); // JSON values are preserved
+});
+
+test("deterministic mode config with global version_id is persisted correctly", async () => {
+	const blob = await newLixFile({
+		keyValues: [
+			{
+				key: "lix_deterministic_mode",
+				value: { enabled: true, randomLixId: true },
+				lixcol_version_id: "global",
+			},
+		],
+	});
+	const lix = await openLix({ blob });
+
+	// Check that lix_deterministic_mode exists with global version_id
+	const result = await lix.db
+		.selectFrom("key_value_all")
+		.where("key", "=", "lix_deterministic_mode")
+		.where("lixcol_version_id", "=", "global")
+		.select(["key", "value"])
+		.executeTakeFirst();
+
+	expect(result).toBeDefined();
+	expect(result?.key).toBe("lix_deterministic_mode");
+	expect(result?.value).toEqual({ enabled: true, randomLixId: true }); // JSON values are preserved
+});