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

package/src/version/create-version-from-commit.test.ts

@@ -1,211 +0,0 @@
-import { expect, test } from "vitest";
-import { openLix } from "../lix/open-lix.js";
-import { createChangeSet } from "../change-set/create-change-set.js";
-import type { Lix } from "../lix/open-lix.js";
-import type { LixChangeSet } from "../change-set/schema-definition.js";
-import type { LixCommit } from "../commit/schema-definition.js";
-import { uuidV7 } from "../engine/functions/uuid-v7.js";
-import { createVersionFromCommit } from "./create-version-from-commit.js";
-import { createVersion } from "./create-version.js";
-
-// Local test helper: create a global commit pointing to a given change set
-async function createCommit(args: {
-	lix: Lix;
-	changeSet: Pick<LixChangeSet, "id">;
-}): Promise<Pick<LixCommit, "id" | "change_set_id">> {
-	const commitId = await uuidV7({ lix: args.lix });
-	await args.lix.db
-		.insertInto("commit_by_version")
-		.values({
-			id: commitId,
-			change_set_id: args.changeSet.id,
-			lixcol_version_id: "global",
-		})
-		.execute();
-	const row = await args.lix.db
-		.selectFrom("commit_by_version")
-		.where("id", "=", commitId)
-		.where("lixcol_version_id", "=", "global")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-	return { id: row.id, change_set_id: row.change_set_id };
-}
-
-// Planning all test cases for createVersionFromCommit (empty bodies for TDD)
-
-test("creates a version pointing to the given commit", async () => {
-	const lix = await openLix({});
-
-	// Create an empty change set and a commit
-	const cs = await createChangeSet({
-		lix,
-		lixcol_version_id: "global",
-		elements: [],
-	});
-
-	const commit = await createCommit({ lix, changeSet: cs });
-
-	const version = await createVersionFromCommit({ lix, commit });
-
-	expect(version.commit_id).toBe(commit.id);
-	expect(version.id).toBeDefined();
-});
-
-test("accepts commit as { id } object", async () => {
-	const lix = await openLix({});
-
-	const cs = await createChangeSet({
-		lix,
-		lixcol_version_id: "global",
-		elements: [],
-	});
-	const commit = await createCommit({ lix, changeSet: cs });
-
-	// Pass a minimal object with only id
-	const version = await createVersionFromCommit({
-		lix,
-		commit: { id: commit.id },
-	});
-
-	expect(version.commit_id).toBe(commit.id);
-});
-
-test("sets a fresh working_commit_id backed by an empty change set", async () => {
-	const lix = await openLix({});
-
-	// Build a base commit to branch from
-	const cs = await createChangeSet({
-		lix,
-		lixcol_version_id: "global",
-		elements: [],
-	});
-	const base = await createCommit({ lix, changeSet: cs });
-
-	const v = await createVersionFromCommit({ lix, commit: base });
-
-	// working commit should be new and different from base commit
-	expect(v.working_commit_id).toBeDefined();
-	expect(v.working_commit_id).not.toBe(base.id);
-
-	// working commit should point to an empty change set
-	const workingCommit = await lix.db
-		.selectFrom("commit_by_version")
-		.where("id", "=", v.working_commit_id)
-		.where("lixcol_version_id", "=", "global")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	const elements = await lix.db
-		.selectFrom("change_set_element_by_version")
-		.where("change_set_id", "=", workingCommit.change_set_id)
-		.where("lixcol_version_id", "=", "global")
-		.selectAll()
-		.execute();
-
-	expect(elements.length).toBe(0);
-});
-
-test("defaults inheritsFrom to global when omitted", async () => {
-	const lix = await openLix({});
-
-	const cs = await createChangeSet({
-		lix,
-		lixcol_version_id: "global",
-		elements: [],
-	});
-	const commit = await createCommit({ lix, changeSet: cs });
-
-	const v = await createVersionFromCommit({ lix, commit });
-	expect(v.inherits_from_version_id).toBe("global");
-});
-
-test("allows explicit inheritsFrom: null (no inheritance)", async () => {
-	const lix = await openLix({});
-
-	const cs = await createChangeSet({
-		lix,
-		lixcol_version_id: "global",
-		elements: [],
-	});
-
-	const commit = await createCommit({ lix, changeSet: cs });
-
-	const v = await createVersionFromCommit({
-		lix,
-		commit,
-		inheritsFrom: null,
-	});
-	expect(v.inherits_from_version_id).toBeNull();
-});
-
-test("allows explicit inheritsFrom: { version }", async () => {
-	const lix = await openLix({});
-
-	// Create a parent version to inherit from
-	const parent = await createVersion({ lix, name: "parent-version" });
-
-	const cs = await createChangeSet({
-		lix,
-		lixcol_version_id: "global",
-		elements: [],
-	});
-	const commit = await createCommit({ lix, changeSet: cs });
-
-	const v = await createVersionFromCommit({
-		lix,
-		commit,
-		inheritsFrom: parent,
-	});
-
-	expect(v.inherits_from_version_id).toBe(parent.id);
-});
-
-test("supports custom id and name", async () => {
-	const lix = await openLix({});
-
-	const cs = await createChangeSet({
-		lix,
-		lixcol_version_id: "global",
-		elements: [],
-	});
-	const commit = await createCommit({ lix, changeSet: cs });
-
-	const v = await createVersionFromCommit({
-		lix,
-		commit,
-		id: "my-version-id",
-		name: "My Version",
-	});
-	expect(v.id).toBe("my-version-id");
-	expect(v.name).toBe("My Version");
-});
-
-test("throws when the commit does not exist", async () => {
-	const lix = await openLix({});
-	await expect(
-		createVersionFromCommit({ lix, commit: { id: "non-existent-commit" } })
-	).rejects.toThrow();
-});
-
-test("works within a transaction", async () => {
-	const lix = await openLix({});
-
-	const cs = await createChangeSet({
-		lix,
-		lixcol_version_id: "global",
-		elements: [],
-	});
-	const commit = await createCommit({ lix, changeSet: cs });
-
-	const v = await lix.db.transaction().execute(async (trx) => {
-		return createVersionFromCommit({ lix: { ...lix, db: trx }, commit });
-	});
-
-	// Visible outside the transaction and consistent
-	const readBack = await lix.db
-		.selectFrom("version")
-		.selectAll()
-		.where("id", "=", v.id)
-		.executeTakeFirstOrThrow();
-	expect(readBack.commit_id).toBe(commit.id);
-});

package/src/version/create-version-from-commit.ts

@@ -1,141 +0,0 @@
-import type { Lix } from "../lix/open-lix.js";
-import type { LixCommit } from "../commit/schema-definition.js";
-import type {
-	LixVersion,
-	LixVersionDescriptor,
-	LixVersionTip,
-} from "./schema-definition.js";
-import { createChangeSet } from "../change-set/create-change-set.js";
-import { uuidV7 } from "../engine/functions/uuid-v7.js";
-import { humanId } from "../engine/functions/generate-human-id.js";
-// Use state_by_version to write descriptor + tip; vtable commit handles persistence + cache
-
-/**
- * Creates a new version that starts at a specific commit.
- *
- * - Points the new version's `commit_id` to the provided commit.
- * - Generates a fresh `working_commit_id` that references an empty change set (global scope).
- * - Does not modify the active version or any other versions.
- * - Inheritance lineage is controlled via `inheritsFrom` and defaults to `"global"`.
- *
- * @param args.lix - The Lix instance.
- * @param args.commit - The commit to branch from (only `id` is required).
- * @param args.id - Optional explicit version id.
- * @param args.name - Optional version name.
- * @param args.inheritsFrom - Optional lineage: a parent version to inherit from, or `null` to disable; defaults to `"global"`.
- *
- * @example
- * // Branch from a commit
- * const v = await createVersionFromCommit({ lix, commit });
- *
- * @example
- * // Custom id and name
- * const v = await createVersionFromCommit({ lix, commit, id: "my-id", name: "My Branch" });
- *
- * @example
- * // Inherit from a specific version
- * const parent = await createVersion({ lix, name: "base" });
- * const v = await createVersionFromCommit({ lix, commit, inheritsFrom: parent });
- *
- * @example
- * // Opt-out of inheritance
- * const v = await createVersionFromCommit({ lix, commit, inheritsFrom: null });
- *
- * @throws If the provided commit id does not exist.
- */
-export async function createVersionFromCommit(args: {
-	lix: Lix;
-	commit: Pick<LixCommit, "id">;
-	id?: LixVersion["id"];
-	name?: LixVersion["name"];
-	inheritsFrom?: LixVersion | Pick<LixVersion, "id"> | null;
-}): Promise<LixVersion> {
-	const executeInTransaction = async (trx: Lix["db"]) => {
-		// Ensure the referenced commit exists (global scope)
-		const commitRow = await trx
-			.selectFrom("commit_by_version")
-			.where("id", "=", args.commit.id)
-			.where("lixcol_version_id", "=", "global")
-			.select(["id"])
-			.executeTakeFirst();
-		if (!commitRow) {
-			throw new Error(`Commit with id '${args.commit.id}' does not exist`);
-		}
-
-		// Create a working (empty) change set for the new version
-		const workingCs = await createChangeSet({
-			lix: { ...args.lix, db: trx },
-			lixcol_version_id: "global",
-		});
-
-		const workingCommitId = await uuidV7({ lix: args.lix });
-		await trx
-			.insertInto("commit_by_version")
-			.values({
-				id: workingCommitId,
-				change_set_id: workingCs.id,
-				lixcol_version_id: "global",
-			})
-			.execute();
-
-		// Determine inheritance
-		const inherits_from_version_id =
-			args.inheritsFrom === undefined
-				? "global"
-				: args.inheritsFrom === null
-					? null
-					: args.inheritsFrom.id;
-
-		const versionId = args.id ?? (await uuidV7({ lix: { ...args.lix } }));
-		const versionName =
-			args.name ?? (await humanId({ lix: { ...args.lix, db: trx } }));
-
-		// Insert descriptor and tip via state_by_version; vtable commit will persist+materialize
-		await trx
-			.insertInto("state_by_version")
-			.values([
-				{
-					entity_id: versionId,
-					schema_key: "lix_version_descriptor",
-					file_id: "lix",
-					version_id: "global",
-					plugin_key: "lix_sdk",
-					snapshot_content: {
-						id: versionId,
-						name: versionName,
-						inherits_from_version_id,
-						hidden: false,
-					} satisfies LixVersionDescriptor,
-					schema_version: "1.0",
-				},
-				{
-					entity_id: versionId,
-					schema_key: "lix_version_tip",
-					file_id: "lix",
-					version_id: "global",
-					plugin_key: "lix_sdk",
-					snapshot_content: {
-						id: versionId,
-						commit_id: args.commit.id,
-						working_commit_id: workingCommitId,
-					} satisfies LixVersionTip,
-					schema_version: "1.0",
-				},
-			])
-			.execute();
-
-		// Return the new merged version (descriptor + tip)
-		return {
-			id: versionId,
-			name: versionName,
-			commit_id: args.commit.id,
-			working_commit_id: workingCommitId,
-			inherits_from_version_id,
-			hidden: false,
-		} satisfies LixVersion;
-	};
-
-	return args.lix.db.isTransaction
-		? executeInTransaction(args.lix.db)
-		: args.lix.db.transaction().execute(executeInTransaction);
-}

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

@@ -1,215 +0,0 @@
-import { test, expect } from "vitest";
-import { openLix } from "../lix/open-lix.js";
-import { createVersion } from "./create-version.js";
-
-test("should create a version from a provided version (from)", async () => {
-	const lix = await openLix({});
-	// Create a source version to get a commit_id
-	const sourceVersion = await createVersion({ lix, name: "source-version" });
-
-	const newVersion = await createVersion({
-		lix,
-		from: { id: sourceVersion.id },
-	});
-
-	// The new version should have the same commit as the source version
-	expect(newVersion.commit_id).toBe(sourceVersion.commit_id);
-	expect(newVersion.id).toBeDefined();
-	expect(newVersion.id).not.toBe(sourceVersion.id);
-	// Check if default name is assigned
-	expect(newVersion.name).toBeDefined();
-});
-
-test("should create a version with the specified name", async () => {
-	const lix = await openLix({});
-	const sourceVersion = await createVersion({ lix, name: "source-version" });
-	const versionName = "My Test Version";
-
-	const newVersion = await createVersion({
-		lix,
-		from: { id: sourceVersion.id },
-		name: versionName,
-	});
-
-	expect(newVersion.commit_id).toBe(sourceVersion.commit_id);
-	expect(newVersion.name).toBe(versionName);
-	expect(newVersion.id).toBeDefined();
-});
-
-test("should create a version with the specified id", async () => {
-	const lix = await openLix({});
-	const sourceVersion = await createVersion({ lix, name: "source-version" });
-
-	const newVersion = await createVersion({
-		lix,
-		from: sourceVersion,
-		id: "hello world",
-	});
-
-	expect(newVersion.commit_id).toBe(sourceVersion.commit_id);
-	expect(newVersion.id).toBe("hello world");
-	// Check default name assignment
-	expect(newVersion.name).toBeDefined();
-});
-
-test("should work within an existing transaction", async () => {
-	const lix = await openLix({});
-	const sourceVersion = await createVersion({ lix, name: "source-version" });
-	const versionName = "Transaction Test Version";
-
-	const newVersion = await lix.db.transaction().execute(async (trx) => {
-		return createVersion({
-			lix: { ...lix, db: trx }, // Pass the transaction object
-			from: { id: sourceVersion.id },
-			name: versionName,
-		});
-	});
-
-	expect(newVersion.commit_id).toBe(sourceVersion.commit_id);
-	expect(newVersion.name).toBe(versionName);
-	expect(newVersion.id).toBeDefined();
-
-	// Verify it's actually in the database outside the transaction
-	const dbVersion = await lix.db
-		.selectFrom("version")
-		.selectAll()
-		.where("id", "=", newVersion.id)
-		.executeTakeFirstOrThrow();
-	expect(dbVersion.name).toBe(versionName);
-});
-
-test("should fail if the provided 'from' version does not exist", async () => {
-	const lix = await openLix({});
-	const nonExistentVersionId = "non-existent-version-id";
-
-	await expect(
-		createVersion({ lix, from: { id: nonExistentVersionId } })
-	).rejects.toThrow();
-});
-
-test("should automatically create inheritance from global version", async () => {
-	const lix = await openLix({});
-
-	// Create a new version (should inherit from active version)
-	const newVersion = await createVersion({
-		lix,
-		name: "test-version",
-	});
-
-	// Check that inheritance column was set correctly
-	expect(newVersion.inherits_from_version_id).toBe("global");
-	// Should have a commit_id from the active version
-	expect(newVersion.commit_id).toBeDefined();
-});
-
-test("should default to active version's commit_id when 'from' is omitted or 'active'", async () => {
-	const lix = await openLix({});
-
-	// Get the active version
-	const activeVersion = await lix.db
-		.selectFrom("active_version")
-		.innerJoin("version", "version.id", "active_version.version_id")
-		.selectAll("version")
-		.executeTakeFirstOrThrow();
-
-	// Create a new version without from
-	const newVersion = await createVersion({
-		lix,
-		name: "branched-version",
-	});
-
-	// The new version should have the same commit_id as the active version
-	expect(newVersion.commit_id).toBe(activeVersion.commit_id);
-	expect(newVersion.id).not.toBe(activeVersion.id);
-	expect(newVersion.name).toBe("branched-version");
-});
-
-test("multiple versions created without commit_id should all point to active version's commit", async () => {
-	const lix = await openLix({});
-
-	// Get the active version's commit_id
-	const activeVersion = await lix.db
-		.selectFrom("active_version")
-		.innerJoin("version", "version.id", "active_version.version_id")
-		.selectAll("version")
-		.executeTakeFirstOrThrow();
-
-	// Create two versions without from
-	const version1 = await createVersion({
-		lix,
-		name: "version-1",
-	});
-
-	const version2 = await createVersion({
-		lix,
-		name: "version-2",
-	});
-
-	// Both should have the same commit_id as the active version
-	expect(version1.commit_id).toBe(activeVersion.commit_id);
-	expect(version2.commit_id).toBe(activeVersion.commit_id);
-	// But different version IDs
-	expect(version1.id).not.toBe(version2.id);
-});
-
-test("should allow explicit null for inheritsFrom", async () => {
-	const lix = await openLix({});
-
-	// Create a version with explicit null inheritance
-	const version = await createVersion({
-		lix,
-		name: "standalone-version",
-		inheritsFrom: null,
-	});
-
-	// Should be null, not "global"
-	expect(version.inherits_from_version_id).toBeNull();
-});
-
-test("creating a version from a version with existing state, 'copies' the state", async () => {
-	const lix = await openLix({
-		keyValues: [
-			{
-				key: "lix_deterministic_mode",
-				value: { enabled: true },
-				lixcol_version_id: "global",
-			},
-		],
-	});
-
-	const activeVersion = await lix.db
-		.selectFrom("active_version")
-		.innerJoin("version", "version.id", "active_version.version_id")
-		.selectAll("version")
-		.executeTakeFirstOrThrow();
-
-	await lix.db
-		.insertInto("key_value")
-		.values({
-			key: "test_key",
-			value: "test_value",
-		})
-		.execute();
-
-	const newVersion = await createVersion({
-		lix,
-		from: activeVersion,
-	});
-
-	// Check that the state was copied
-	const state = await lix.db
-		.selectFrom("key_value_by_version")
-		.where("lixcol_version_id", "=", newVersion.id)
-		.where("key", "=", "test_key")
-		.selectAll()
-		.execute();
-
-	expect(state).toHaveLength(1);
-	expect(state[0]).toMatchObject({
-		key: "test_key",
-		value: "test_value",
-		// crucial, we are creating a new version that under the hood points to the same commit.
-		// thus, they have the same state with no inheritance difference.
-		lixcol_inherited_from_version_id: null,
-	});
-});

package/src/version/create-version.ts

@@ -1,50 +0,0 @@
-import type { Lix } from "../lix/open-lix.js";
-import type { LixVersion } from "./schema-definition.js";
-import { createVersionFromCommit } from "./create-version-from-commit.js";
-
-/**
- * Creates a new version branching from a version's commit id (defaults to active when `from` is omitted).
- *
- * For branching from a specific commit id, use `createVersionFromCommit`.
- */
-export async function createVersion(args: {
-	lix: Lix;
-	id?: LixVersion["id"];
-	name?: LixVersion["name"];
-	from?: LixVersion | Pick<LixVersion, "id">;
-	inheritsFrom?: LixVersion | Pick<LixVersion, "id"> | null;
-}): Promise<LixVersion> {
-	const executeInTransaction = async (trx: Lix["db"]) => {
-		// Resolve base commit from from/active
-		let baseCommitId: string;
-		if (args.from) {
-			const base = await trx
-				.selectFrom("version")
-				.select(["commit_id"])
-				.where("id", "=", args.from.id)
-				.executeTakeFirstOrThrow();
-			baseCommitId = base.commit_id;
-		} else {
-			const active = await trx
-				.selectFrom("active_version")
-				.innerJoin("version", "version.id", "active_version.version_id")
-				.select("version.commit_id")
-				.executeTakeFirstOrThrow();
-			baseCommitId = active.commit_id;
-		}
-
-		return createVersionFromCommit({
-			lix: { ...args.lix, db: trx },
-			commit: { id: baseCommitId },
-			id: args.id,
-			name: args.name,
-			inheritsFrom: args.inheritsFrom,
-		});
-	};
-
-	if (args.lix.db.isTransaction) {
-		return executeInTransaction(args.lix.db);
-	} else {
-		return args.lix.db.transaction().execute(executeInTransaction);
-	}
-}

package/src/version/index.ts

@@ -1,15 +0,0 @@
-export {
-	type LixVersion,
-	type LixActiveVersion,
-	type LixVersionDescriptor,
-	type LixVersionTip,
-	LixVersionTipSchema,
-	LixVersionDescriptorSchema,
-	LixActiveVersionSchema,
-} from "./schema-definition.js";
-
-export { createVersion } from "./create-version.js";
-export { switchVersion } from "./switch-version.js";
-export { createVersionFromCommit } from "./create-version-from-commit.js";
-export { selectVersionDiff } from "./select-version-diff.js";
-export { mergeVersion } from "./merge-version.js";