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

package/src/change-set/schema.ts

@@ -4,10 +4,13 @@ import type {
 	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 { LixDatabaseSchema } from "../database/schema.js";
+import type { Kysely } from "kysely";
 
 export function applyChangeSetDatabaseSchema(
-	sqlite: SqliteWasmDatabase
+	sqlite: SqliteWasmDatabase,
+	db: Kysely<LixDatabaseSchema>
 ): SqliteWasmDatabase {
 	// Create change_set view using the generalized entity view builder
 	createEntityViewsIfNotExists({
@@ -17,7 +20,7 @@ export function applyChangeSetDatabaseSchema(
 		pluginKey: "lix_own_entity",
 		hardcodedFileId: "lix",
 		defaultValues: {
-			id: () => nanoid(),
+			id: () => nanoId({ lix: { sqlite, db } }),
 		},
 	});
 
@@ -30,24 +33,6 @@ export function applyChangeSetDatabaseSchema(
 		hardcodedFileId: "lix",
 	});
 
-	// Create change_set_edge views
-	createEntityViewsIfNotExists({
-		lix: { sqlite },
-		schema: LixChangeSetEdgeSchema,
-		overrideName: "change_set_edge",
-		pluginKey: "lix_own_entity",
-		hardcodedFileId: "lix",
-	});
-
-	// Create change_set_thread views
-	createEntityViewsIfNotExists({
-		lix: { sqlite },
-		schema: LixChangeSetThreadSchema,
-		overrideName: "change_set_thread",
-		pluginKey: "lix_own_entity",
-		hardcodedFileId: "lix",
-	});
-
 	// Create change_set_label views
 	createEntityViewsIfNotExists({
 		lix: { sqlite },
@@ -75,25 +60,34 @@ export const LixChangeSetSchema = {
 LixChangeSetSchema satisfies LixSchemaDefinition;
 
 // Pure business logic type (inferred from schema)
-export type ChangeSet = FromLixSchemaDefinition<typeof LixChangeSetSchema>;
+export type LixChangeSet = FromLixSchemaDefinition<typeof LixChangeSetSchema>;
 
 export const LixChangeSetElementSchema = {
 	"x-lix-key": "lix_change_set_element",
 	"x-lix-version": "1.0",
-	"x-lix-foreign-keys": {
-		change_set_id: {
-			schemaKey: "lix_change_set",
-			property: "id",
+	"x-lix-foreign-keys": [
+		{
+			properties: ["change_set_id"],
+			references: {
+				schemaKey: "lix_change_set",
+				properties: ["id"],
+			},
 		},
-		change_id: {
-			schemaKey: "lix_change",
-			property: "id",
+		{
+			properties: ["change_id"],
+			references: {
+				schemaKey: "lix_change",
+				properties: ["id"],
+			},
 		},
-		schema_key: {
-			schemaKey: "lix_stored_schema",
-			property: "key",
+		{
+			properties: ["schema_key"],
+			references: {
+				schemaKey: "lix_stored_schema",
+				properties: ["key"],
+			},
 		},
-	},
+	],
 	"x-lix-primary-key": ["change_set_id", "change_id"],
 	"x-lix-unique": [["change_set_id", "entity_id", "schema_key", "file_id"]],
 	type: "object",
@@ -115,53 +109,30 @@ export const LixChangeSetElementSchema = {
 } as const;
 LixChangeSetElementSchema satisfies LixSchemaDefinition;
 
-export type ChangeSetElement = FromLixSchemaDefinition<
+export type LixChangeSetElement = FromLixSchemaDefinition<
 	typeof LixChangeSetElementSchema
 >;
 
-export const LixChangeSetEdgeSchema = {
-	"x-lix-key": "lix_change_set_edge",
-	"x-lix-version": "1.0",
-	"x-lix-primary-key": ["parent_id", "child_id"],
-	"x-lix-foreign-keys": {
-		parent_id: {
-			schemaKey: "lix_change_set",
-			property: "id",
-		},
-		child_id: {
-			schemaKey: "lix_change_set",
-			property: "id",
-		},
-	},
-	type: "object",
-	properties: {
-		parent_id: { type: "string" },
-		child_id: { type: "string" },
-	},
-	required: ["parent_id", "child_id"],
-	additionalProperties: false,
-} as const;
-LixChangeSetEdgeSchema satisfies LixSchemaDefinition;
-
-// Pure business logic type (inferred from schema)
-export type ChangeSetEdge = FromLixSchemaDefinition<
-	typeof LixChangeSetEdgeSchema
->;
-
 export const LixChangeSetLabelSchema = {
 	"x-lix-key": "lix_change_set_label",
 	"x-lix-version": "1.0",
 	"x-lix-primary-key": ["change_set_id", "label_id"],
-	"x-lix-foreign-keys": {
-		change_set_id: {
-			schemaKey: "lix_change_set",
-			property: "id",
+	"x-lix-foreign-keys": [
+		{
+			properties: ["change_set_id"],
+			references: {
+				schemaKey: "lix_change_set",
+				properties: ["id"],
+			},
 		},
-		label_id: {
-			schemaKey: "lix_label",
-			property: "id",
+		{
+			properties: ["label_id"],
+			references: {
+				schemaKey: "lix_label",
+				properties: ["id"],
+			},
 		},
-	},
+	],
 	type: "object",
 	properties: {
 		change_set_id: { type: "string" },
@@ -174,34 +145,6 @@ export const LixChangeSetLabelSchema = {
 LixChangeSetLabelSchema satisfies LixSchemaDefinition;
 
 // Pure business logic type (inferred from schema)
-export type ChangeSetLabel = FromLixSchemaDefinition<
+export type LixChangeSetLabel = FromLixSchemaDefinition<
 	typeof LixChangeSetLabelSchema
 >;
-
-export const LixChangeSetThreadSchema = {
-	"x-lix-key": "lix_change_set_thread",
-	"x-lix-version": "1.0",
-	"x-lix-primary-key": ["change_set_id", "thread_id"],
-	"x-lix-foreign-keys": {
-		change_set_id: {
-			schemaKey: "lix_change_set",
-			property: "id",
-		},
-		thread_id: {
-			schemaKey: "lix_thread",
-			property: "id",
-		},
-	},
-	type: "object",
-	properties: {
-		change_set_id: { type: "string" },
-		thread_id: { type: "string" },
-	},
-	required: ["change_set_id", "thread_id"],
-	additionalProperties: false,
-} as const;
-LixChangeSetThreadSchema satisfies LixSchemaDefinition;
-
-export type ChangeSetThread = FromLixSchemaDefinition<
-	typeof LixChangeSetThreadSchema
->;

package/src/commit/apply-commit.test.ts

@@ -0,0 +1,426 @@
+import { expect, test } from "vitest";
+import { openLix } from "../lix/open-lix.js";
+import { applyCommit } from "./apply-commit.js";
+import { createCommit } from "./create-commit.js";
+import { createChangeSet } from "../change-set/create-change-set.js";
+import { createVersion } from "../version/create-version.js";
+import {
+	mockJsonPlugin,
+	MockJsonPropertySchema,
+} from "../plugin/mock-json-plugin.js";
+
+test("applyCommit updates the active version's commit_id", async () => {
+	const lix = await openLix({
+		providePlugins: [mockJsonPlugin],
+	});
+
+	// Insert the schema
+	await lix.db
+		.insertInto("stored_schema_all")
+		.values({
+			value: MockJsonPropertySchema,
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	// Create a file
+	await lix.db
+		.insertInto("file")
+		.values({
+			id: "file1",
+			data: new TextEncoder().encode("{}"),
+			path: "/test.json",
+		})
+		.execute();
+
+	// Create some changes
+	const changes = await lix.db
+		.insertInto("change")
+		.values([
+			{
+				id: "c1",
+				file_id: "file1",
+				plugin_key: mockJsonPlugin.key,
+				entity_id: "e1",
+				schema_key: "mock_json_property",
+				snapshot_content: { value: "Value 1" },
+				schema_version: "1.0",
+			},
+		])
+		.returningAll()
+		.execute();
+
+	// Create a change set
+	const changeSet = await createChangeSet({
+		lix,
+		lixcol_version_id: "global",
+		elements: changes.map((change) => ({
+			change_id: change.id,
+			entity_id: change.entity_id,
+			schema_key: change.schema_key,
+			file_id: change.file_id,
+		})),
+	});
+
+	// Create a commit
+	const commit = await createCommit({
+		lix,
+		changeSet,
+	});
+
+	// Get the active version before applying
+	const versionBefore = await lix.db
+		.selectFrom("active_version")
+		.innerJoin("version", "version.id", "active_version.version_id")
+		.selectAll("version")
+		.executeTakeFirstOrThrow();
+
+	// Apply the commit
+	await applyCommit({
+		lix,
+		commit,
+	});
+
+	// Get the active version after applying
+	const versionAfter = await lix.db
+		.selectFrom("active_version")
+		.innerJoin("version", "version.id", "active_version.version_id")
+		.selectAll("version")
+		.executeTakeFirstOrThrow();
+
+	// Verify the version's commit_id was updated
+	expect(versionAfter.commit_id).toBe(commit.id);
+	expect(versionAfter.commit_id).not.toBe(versionBefore.commit_id);
+
+	// Verify the changes were applied to the file
+	const file = await lix.db
+		.selectFrom("file")
+		.where("id", "=", "file1")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	const fileData = JSON.parse(new TextDecoder().decode(file.data));
+	expect(fileData).toEqual({ e1: "Value 1" });
+});
+
+test("applyCommit applies to a specific version when provided", async () => {
+	const lix = await openLix({
+		providePlugins: [mockJsonPlugin],
+	});
+
+	// Insert the schema
+	await lix.db
+		.insertInto("stored_schema_all")
+		.values({
+			value: MockJsonPropertySchema,
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	// Create two versions
+	const version1 = await createVersion({
+		lix,
+		name: "version1",
+	});
+
+	const version2 = await createVersion({
+		lix,
+		name: "version2",
+	});
+
+	// Create a file
+	await lix.db
+		.insertInto("file")
+		.values({
+			id: "file1",
+			data: new TextEncoder().encode("{}"),
+			path: "/test.json",
+		})
+		.execute();
+
+	// Create changes
+	const changes = await lix.db
+		.insertInto("change")
+		.values([
+			{
+				id: "c1",
+				file_id: "file1",
+				plugin_key: mockJsonPlugin.key,
+				entity_id: "e1",
+				schema_key: "mock_json_property",
+				snapshot_content: { value: "Version 2 Value" },
+				schema_version: "1.0",
+			},
+		])
+		.returningAll()
+		.execute();
+
+	// Create a change set and commit
+	const changeSet = await createChangeSet({
+		lix,
+		lixcol_version_id: "global",
+		elements: changes.map((change) => ({
+			change_id: change.id,
+			entity_id: change.entity_id,
+			schema_key: change.schema_key,
+			file_id: change.file_id,
+		})),
+	});
+
+	const commit = await createCommit({
+		lix,
+		changeSet,
+	});
+
+	// Apply the commit to version2 specifically
+	await applyCommit({
+		lix,
+		commit,
+		version: version2,
+	});
+
+	// Check that version2 was updated
+	const updatedVersion2 = await lix.db
+		.selectFrom("version")
+		.where("id", "=", version2.id)
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	expect(updatedVersion2.commit_id).toBe(commit.id);
+
+	// Check that version1 was NOT updated
+	const unchangedVersion1 = await lix.db
+		.selectFrom("version")
+		.where("id", "=", version1.id)
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	expect(unchangedVersion1.commit_id).not.toBe(commit.id);
+});
+
+test("applyCommit works within a transaction", async () => {
+	const lix = await openLix({
+		providePlugins: [mockJsonPlugin],
+	});
+
+	// Insert the schema
+	await lix.db
+		.insertInto("stored_schema_all")
+		.values({
+			value: MockJsonPropertySchema,
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	// Create a file
+	await lix.db
+		.insertInto("file")
+		.values({
+			id: "file1",
+			data: new TextEncoder().encode("{}"),
+			path: "/test.json",
+		})
+		.execute();
+
+	// Create changes
+	const changes = await lix.db
+		.insertInto("change")
+		.values([
+			{
+				id: "c1",
+				file_id: "file1",
+				plugin_key: mockJsonPlugin.key,
+				entity_id: "e1",
+				schema_key: "mock_json_property",
+				snapshot_content: { value: "Transactional Value" },
+				schema_version: "1.0",
+			},
+		])
+		.returningAll()
+		.execute();
+
+	// Create a change set and commit
+	const changeSet = await createChangeSet({
+		lix,
+		lixcol_version_id: "global",
+		elements: changes.map((change) => ({
+			change_id: change.id,
+			entity_id: change.entity_id,
+			schema_key: change.schema_key,
+			file_id: change.file_id,
+		})),
+	});
+
+	const commit = await createCommit({
+		lix,
+		changeSet,
+	});
+
+	// Run applyCommit within a transaction
+	await lix.db.transaction().execute(async (trx) => {
+		await applyCommit({
+			lix: { ...lix, db: trx },
+			commit,
+		});
+
+		// Verify within the transaction
+		const version = await trx
+			.selectFrom("active_version")
+			.innerJoin("version", "version.id", "active_version.version_id")
+			.selectAll("version")
+			.executeTakeFirstOrThrow();
+
+		expect(version.commit_id).toBe(commit.id);
+	});
+
+	// Verify outside the transaction
+	const version = await lix.db
+		.selectFrom("active_version")
+		.innerJoin("version", "version.id", "active_version.version_id")
+		.selectAll("version")
+		.executeTakeFirstOrThrow();
+
+	expect(version.commit_id).toBe(commit.id);
+
+	// Verify the changes were applied
+	const file = await lix.db
+		.selectFrom("file")
+		.where("id", "=", "file1")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	const fileData = JSON.parse(new TextDecoder().decode(file.data));
+	expect(fileData).toEqual({ e1: "Transactional Value" });
+});
+
+test("applyCommit throws when commit doesn't exist", async () => {
+	const lix = await openLix({});
+
+	await expect(
+		applyCommit({
+			lix,
+			commit: { id: "non-existent-commit" },
+		})
+	).rejects.toThrow();
+});
+
+test("applyCommit throws when version doesn't exist", async () => {
+	const lix = await openLix({});
+
+	// Create a dummy change set and commit
+	const changeSet = await createChangeSet({
+		lix,
+		lixcol_version_id: "global",
+		elements: [],
+	});
+
+	const commit = await createCommit({
+		lix,
+		changeSet,
+	});
+
+	await expect(
+		applyCommit({
+			lix,
+			commit,
+			version: { id: "non-existent-version" },
+		})
+	).rejects.toThrow();
+});
+
+test("applyCommit applies multiple changes from the commit's change set", async () => {
+	const lix = await openLix({
+		providePlugins: [mockJsonPlugin],
+	});
+
+	// Insert the schema
+	await lix.db
+		.insertInto("stored_schema_all")
+		.values({
+			value: MockJsonPropertySchema,
+			lixcol_version_id: "global",
+		})
+		.execute();
+
+	// Create a file
+	await lix.db
+		.insertInto("file")
+		.values({
+			id: "file1",
+			data: new TextEncoder().encode("{}"),
+			path: "/test.json",
+		})
+		.execute();
+
+	// Create multiple changes
+	const changes = await lix.db
+		.insertInto("change")
+		.values([
+			{
+				id: "c1",
+				file_id: "file1",
+				plugin_key: mockJsonPlugin.key,
+				entity_id: "e1",
+				schema_key: "mock_json_property",
+				snapshot_content: { value: "Value 1" },
+				schema_version: "1.0",
+			},
+			{
+				id: "c2",
+				file_id: "file1",
+				plugin_key: mockJsonPlugin.key,
+				entity_id: "e2",
+				schema_key: "mock_json_property",
+				snapshot_content: { value: "Value 2" },
+				schema_version: "1.0",
+			},
+			{
+				id: "c3",
+				file_id: "file1",
+				plugin_key: mockJsonPlugin.key,
+				entity_id: "e3",
+				schema_key: "mock_json_property",
+				snapshot_content: { value: "Value 3" },
+				schema_version: "1.0",
+			},
+		])
+		.returningAll()
+		.execute();
+
+	// Create a change set with all changes
+	const changeSet = await createChangeSet({
+		lix,
+		lixcol_version_id: "global",
+		elements: changes.map((change) => ({
+			change_id: change.id,
+			entity_id: change.entity_id,
+			schema_key: change.schema_key,
+			file_id: change.file_id,
+		})),
+	});
+
+	const commit = await createCommit({
+		lix,
+		changeSet,
+	});
+
+	// Apply the commit
+	await applyCommit({
+		lix,
+		commit,
+	});
+
+	// Verify all changes were applied
+	const file = await lix.db
+		.selectFrom("file")
+		.where("id", "=", "file1")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	const fileData = JSON.parse(new TextDecoder().decode(file.data));
+	expect(fileData).toEqual({
+		e1: "Value 1",
+		e2: "Value 2",
+		e3: "Value 3",
+	});
+});

package/src/commit/apply-commit.ts

@@ -0,0 +1,74 @@
+import type { Lix } from "../lix/index.js";
+import type { LixCommit } from "./schema.js";
+import type { LixVersion } from "../version/schema.js";
+import { applyChangeSet } from "../change-set/apply-change-set.js";
+
+/**
+ * Applies a commit to a version by updating the version's commit_id and applying its changes.
+ *
+ * This function:
+ * 1. Updates the version to point to the new commit
+ * 2. Applies all changes from the commit's change set
+ *
+ * @example
+ * ```ts
+ * // Apply a commit to the active version
+ * await applyCommit({
+ *   lix,
+ *   commit: myCommit
+ * });
+ *
+ * // Apply a commit to a specific version
+ * await applyCommit({
+ *   lix,
+ *   commit: myCommit,
+ *   version: specificVersion
+ * });
+ * ```
+ */
+export async function applyCommit(args: {
+	lix: Lix;
+	commit: Pick<LixCommit, "id">;
+	version?: Pick<LixVersion, "id">;
+}): Promise<void> {
+	const executeInTransaction = async (trx: Lix["db"]) => {
+		// Get the target version (use active version if not specified)
+		const targetVersion = args.version
+			? await trx
+					.selectFrom("version")
+					.where("id", "=", args.version.id)
+					.selectAll()
+					.executeTakeFirstOrThrow()
+			: await trx
+					.selectFrom("active_version")
+					.innerJoin("version", "version.id", "active_version.version_id")
+					.selectAll("version")
+					.executeTakeFirstOrThrow();
+
+		// Get the commit details
+		const commit = await trx
+			.selectFrom("commit_all")
+			.where("id", "=", args.commit.id)
+			.where("lixcol_version_id", "=", "global")
+			.selectAll()
+			.executeTakeFirstOrThrow();
+
+		// Update the version to point to the new commit
+		await trx
+			.updateTable("version")
+			.set({ commit_id: commit.id })
+			.where("id", "=", targetVersion.id)
+			.execute();
+
+		// Apply the changes from the commit's change set
+		// Note: We're using the internal transaction to ensure atomicity
+		await applyChangeSet({
+			lix: { ...args.lix, db: trx },
+			changeSet: { id: commit.change_set_id },
+		});
+	};
+
+	return args.lix.db.isTransaction
+		? executeInTransaction(args.lix.db)
+		: args.lix.db.transaction().execute(executeInTransaction);
+}