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

package/src/version/schema.ts

@@ -0,0 +1,163 @@
+import type {
+	LixSchemaDefinition,
+	FromLixSchemaDefinition,
+} from "../schema-definition/definition.js";
+import { createEntityViewsIfNotExists } from "../entity-views/entity-view-builder.js";
+import { nanoId, generateHumanId } from "../deterministic/index.js";
+import type { Lix } from "../lix/open-lix.js";
+
+export function applyVersionDatabaseSchema(
+	lix: Pick<Lix, "sqlite" | "db">
+): void {
+	// Create both primary and _all views for version with global version constraint
+	createEntityViewsIfNotExists({
+		lix,
+		schema: LixVersionSchema,
+		overrideName: "version",
+		pluginKey: "lix_own_entity",
+		hardcodedFileId: "lix",
+		hardcodedVersionId: "global",
+		defaultValues: {
+			id: () => nanoId({ lix }),
+			name: () => generateHumanId({ lix }),
+			working_commit_id: () => nanoId({ lix }),
+			// Note: inherits_from_version_id default is handled in createVersion
+			// to allow explicit null values
+			// inherits_from_version_id: () => "global",
+			hidden: () => false,
+		},
+	});
+
+	// Create active_version as an entity view manually with untracked state
+	lix.sqlite.exec(`
+		CREATE VIEW IF NOT EXISTS active_version AS
+		SELECT
+			json_extract(snapshot_content, '$.version_id') AS version_id,
+			inherited_from_version_id AS lixcol_inherited_from_version_id,
+			created_at AS lixcol_created_at,
+			updated_at AS lixcol_updated_at,
+			file_id AS lixcol_file_id,
+			change_id AS lixcol_change_id,
+			untracked AS lixcol_untracked
+		FROM state_all
+		WHERE schema_key = 'lix_active_version' AND version_id = 'global';
+
+		CREATE TRIGGER IF NOT EXISTS active_version_insert
+		INSTEAD OF INSERT ON active_version
+		BEGIN
+			INSERT INTO state_all (
+				entity_id,
+				schema_key,
+				file_id,
+				plugin_key,
+				snapshot_content,
+				schema_version,
+				version_id,
+				untracked
+			) VALUES (
+				'active',
+				'lix_active_version',
+				'lix',
+				'lix_own_entity',
+				json_object('version_id', NEW.version_id),
+				'1.0',
+				'global',
+				1
+			);
+		END;
+
+		CREATE TRIGGER IF NOT EXISTS active_version_update
+		INSTEAD OF UPDATE ON active_version
+		BEGIN
+			UPDATE state_all
+			SET
+				snapshot_content = json_object('version_id', NEW.version_id),
+				untracked = 1
+			WHERE
+				entity_id = 'active'
+				AND schema_key = 'lix_active_version'
+				AND version_id = 'global';
+		END;
+
+		CREATE TRIGGER IF NOT EXISTS active_version_delete
+		INSTEAD OF DELETE ON active_version
+		BEGIN
+			DELETE FROM state_all
+			WHERE entity_id = 'active'
+			AND schema_key = 'lix_active_version'
+			AND version_id = 'global';
+		END;
+	`);
+}
+
+export const LixVersionSchema = {
+	"x-lix-key": "lix_version",
+	"x-lix-version": "1.0",
+	"x-lix-primary-key": ["id"],
+	"x-lix-unique": [["working_commit_id"]],
+	"x-lix-foreign-keys": [
+		{
+			properties: ["commit_id"],
+			references: {
+				schemaKey: "lix_commit",
+				properties: ["id"],
+			},
+		},
+		{
+			properties: ["working_commit_id"],
+			references: {
+				schemaKey: "lix_commit",
+				properties: ["id"],
+			},
+		},
+		{
+			properties: ["inherits_from_version_id"],
+			references: {
+				schemaKey: "lix_version",
+				properties: ["id"],
+			},
+		},
+	],
+	type: "object",
+	properties: {
+		id: { type: "string", "x-lix-generated": true },
+		name: { type: "string", "x-lix-generated": true },
+		commit_id: { type: "string" },
+		working_commit_id: { type: "string", "x-lix-generated": true },
+		inherits_from_version_id: {
+			type: ["string", "null"],
+		},
+		hidden: { type: "boolean", "x-lix-generated": true },
+	},
+	required: ["id", "name", "commit_id", "working_commit_id"],
+	additionalProperties: false,
+} as const;
+LixVersionSchema satisfies LixSchemaDefinition;
+
+export const LixActiveVersionSchema = {
+	"x-lix-key": "lix_active_version",
+	"x-lix-version": "1.0",
+	"x-lix-primary-key": ["version_id"],
+	"x-lix-foreign-keys": [
+		{
+			properties: ["version_id"],
+			references: {
+				schemaKey: "lix_version",
+				properties: ["id"],
+			},
+		},
+	],
+	type: "object",
+	properties: {
+		version_id: { type: "string" },
+	},
+	required: ["version_id"],
+	additionalProperties: false,
+} as const;
+LixActiveVersionSchema satisfies LixSchemaDefinition;
+
+// Pure business logic type (inferred from schema)
+export type LixVersion = FromLixSchemaDefinition<typeof LixVersionSchema>;
+export type LixActiveVersion = FromLixSchemaDefinition<
+	typeof LixActiveVersionSchema
+>;

package/src/version/select-active-version.ts

@@ -0,0 +1,18 @@
+import type { SelectQueryBuilder } from "kysely";
+import type { LixDatabaseSchema } from "../database/schema.js";
+import type { Lix } from "../lix/open-lix.js";
+import type { State } from "../entity-views/types.js";
+import type { LixVersion } from "./schema.js";
+
+export function selectActiveVersion(
+	lix: Lix
+): SelectQueryBuilder<
+	LixDatabaseSchema,
+	"version" | "active_version",
+	State<LixVersion>
+> {
+	return lix.db
+		.selectFrom("active_version")
+		.innerJoin("version", "active_version.version_id", "version.id")
+		.selectAll("version");
+}

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

@@ -1,292 +1,31 @@
-import { test, expect, vi } from "vitest";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
-import { switchVersion } from "./switch-version.js";
+import { expect, test } from "vitest";
+import { openLix } from "../lix/open-lix.js";
 import { createVersion } from "./create-version.js";
-import { createChange } from "../change/create-change.js";
-import type { LixPlugin } from "../plugin/lix-plugin.js";
-import { fileQueueSettled } from "../file-queue/file-queue-settled.js";
+import { switchVersion } from "./switch-version.js";
 
-test("switching versiones should update the current_version", async () => {
-	const lix = await openLixInMemory({});
+test("switching versiones should update the active_version", async () => {
+	const lix = await openLix({});
 
-	const currentVersion = await lix.db
-		.selectFrom("current_version")
-		.innerJoin("version", "current_version.id", "version.id")
+	const activeVersion = await lix.db
+		.selectFrom("active_version")
+		.innerJoin("version", "active_version.version_id", "version.id")
 		.selectAll("version")
 		.executeTakeFirstOrThrow();
 
 	const newVersion = await lix.db.transaction().execute(async (trx) => {
 		const newVersion = await createVersion({
-			lix: { db: trx },
-			from: currentVersion,
+			lix: { ...lix, db: trx },
+			commit_id: activeVersion.commit_id,
 		});
 		await switchVersion({ lix: { ...lix, db: trx }, to: newVersion });
 		return newVersion;
 	});
 
-	const currentVersionAfterSwitch = await lix.db
-		.selectFrom("current_version")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	expect(currentVersionAfterSwitch.id).toBe(newVersion?.id);
-});
-
-test("switching a version does not lead to duplicate changes", async () => {
-	const lix = await openLixInMemory({});
-
-	const account0 = await lix.db
-		.insertInto("account")
-		.values({ name: "account0" })
-		.returningAll()
-		.executeTakeFirstOrThrow();
-
-	const currentVersion = await lix.db
-		.selectFrom("current_version")
-		.innerJoin("version", "current_version.id", "version.id")
+	const activeVersionAfterSwitch = await lix.db
+		.selectFrom("active_version")
+		.innerJoin("version", "active_version.version_id", "version.id")
 		.selectAll("version")
 		.executeTakeFirstOrThrow();
 
-	const change0 = await createChange({
-		lix,
-		version: currentVersion,
-		authors: [account0],
-		entityId: "entity0",
-		fileId: "file0",
-		schemaKey: "schema0",
-		snapshotContent: null,
-		pluginKey: "plugin0",
-	});
-
-	const newVersion = await createVersion({
-		lix: lix,
-		from: currentVersion,
-	});
-
-	const changesBefore = await lix.db.selectFrom("change").selectAll().execute();
-
-	expect(changesBefore).toEqual(expect.arrayContaining([change0]));
-
-	await switchVersion({ lix, to: newVersion });
-
-	const changesAfter = await lix.db.selectFrom("change").selectAll().execute();
-
-	expect(changesAfter).toEqual(changesBefore);
-});
-
-test("switch version applies the changes of the switched to version", async () => {
-	const lix = await openLixInMemory({});
-
-	const versionA = await createVersion({ lix });
-
-	const versionB = await createVersion({ lix });
-
-	await switchVersion({ lix, to: versionA });
-
-	// version A has value foo
-	await lix.db
-		.insertInto("key_value")
-		.values({ key: "foo", value: "bar" })
-		.execute();
-
-	let keyValues = await lix.db
-		.selectFrom("key_value")
-		.where("key", "=", "foo")
-		.selectAll()
-		.execute();
-
-	expect(keyValues).toMatchObject([{ key: "foo", value: "bar" }]);
-
-	await switchVersion({ lix, to: versionB });
-
-	// version B should have no value foo
-	keyValues = await lix.db
-		.selectFrom("key_value")
-		.where("key", "=", "foo")
-		.selectAll()
-		.execute();
-
-	expect(keyValues).toHaveLength(0);
-
-	// version B has value foo
-	await lix.db
-		.insertInto("key_value")
-		.values({ key: "foo", value: "baz" })
-		.execute();
-
-	await switchVersion({ lix, to: versionA });
-
-	keyValues = await lix.db
-		.selectFrom("key_value")
-		.where("key", "=", "foo")
-		.selectAll()
-		.execute();
-
-	// expecting to see the value from version A again
-	expect(keyValues).toMatchObject([{ key: "foo", value: "bar" }]);
-});
-
-// https://github.com/opral/lix-sdk/issues/209
-test("a deleted file in one version does not impact a version which did not delete the file", async () => {
-	const mockTxtPlugin: LixPlugin = {
-		key: "mock_txt_plugin",
-		detectChangesGlob: "*.txt",
-		// @ts-expect-error - mocked
-		detectChanges: vi.fn(async ({ after }) => {
-			return [
-				{
-					entity_id: "txt_file",
-					snapshot: after
-						? {
-								text: new TextDecoder().decode(after?.data),
-							}
-						: null,
-					schema: {
-						type: "json",
-						key: "txt",
-					},
-				},
-			];
-		}),
-
-		applyChanges: vi.fn(async ({ lix, changes }) => {
-			const snapshot = await lix.db
-				.selectFrom("snapshot")
-				.where("id", "=", changes.at(-1)!.snapshot_id)
-				.selectAll()
-				.executeTakeFirstOrThrow();
-
-			return {
-				fileData: new TextEncoder().encode(snapshot.content?.text),
-			};
-		}),
-	};
-
-	const lix = await openLixInMemory({ providePlugins: [mockTxtPlugin] });
-
-	const versionA = await createVersion({ lix });
-
-	await switchVersion({ lix, to: versionA });
-
-	await lix.db
-		.insertInto("file")
-		.values({
-			id: "file0",
-			data: new TextEncoder().encode("hello world"),
-			path: "/file.txt",
-		})
-		.execute();
-
-	await fileQueueSettled({ lix });
-
-	expect(mockTxtPlugin.detectChanges).toHaveBeenCalledTimes(1);
-
-	const versionB = await createVersion({ lix, from: versionA });
-
-	await switchVersion({ lix, to: versionB });
-
-	// there is no difference in both versions
-	expect(mockTxtPlugin.applyChanges).toHaveBeenCalledTimes(0);
-
-	// deleting the file in version B
-	await lix.db.deleteFrom("file").where("id", "=", "file0").execute();
-
-	await fileQueueSettled({ lix });
-
-	// lix own change control handles file deletions
-	// expecting the plugin.detectChanges to not be invoked
-	expect(mockTxtPlugin.detectChanges).toHaveBeenCalledTimes(1);
-
-	// switching back to version A
-	// expecting file0 to be re-created
-	await switchVersion({ lix, to: versionA });
-
-	// the plugin re-applies the changes
-	expect(mockTxtPlugin.applyChanges).toHaveBeenCalledTimes(1);
-
-	// the file should still be there
-
-	const file = await lix.db
-		.selectFrom("file")
-		.where("id", "=", "file0")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
-	expect(file.data).toEqual(new TextEncoder().encode("hello world"));
-
-	// going back to version B should remove the file again
-
-	await switchVersion({ lix, to: versionB });
-
-	// lix own change control handles the file deletion
-	// expecting the plugin.detectChanges to not be invoked
-	expect(mockTxtPlugin.applyChanges).toHaveBeenCalledTimes(1);
-
-	const fileAfterSwitch = await lix.db
-		.selectFrom("file")
-		.where("id", "=", "file0")
-		.selectAll()
-		.executeTakeFirst();
-
-	expect(fileAfterSwitch).toBeUndefined();
-});
-
-test("doesn't trigger the file queue when switching versions which would lead to duplicate changes", async () => {
-	const mockTxtPlugin: LixPlugin = {
-		key: "mock_txt_plugin",
-		detectChangesGlob: "*.txt",
-		// @ts-expect-error - mocked
-		detectChanges: vi.fn(async ({ after }) => {
-			return [
-				{
-					entity_id: "txt_file",
-					snapshot: after
-						? {
-								text: new TextDecoder().decode(after?.data),
-							}
-						: null,
-					schema: {
-						type: "json",
-						key: "txt",
-					},
-				},
-			];
-		}),
-
-		applyChanges: vi.fn(async ({ lix, changes }) => {
-			const snapshot = await lix.db
-				.selectFrom("snapshot")
-				.where("id", "=", changes.at(-1)!.snapshot_id)
-				.selectAll()
-				.executeTakeFirstOrThrow();
-
-			return {
-				fileData: new TextEncoder().encode(snapshot.content?.text),
-			};
-		}),
-	};
-
-	const lix = await openLixInMemory({ providePlugins: [mockTxtPlugin] });
-
-	const versionA = await createVersion({ lix });
-	const versionB = await createVersion({ lix });
-
-	await switchVersion({ lix, to: versionA });
-
-	await lix.db
-		.insertInto("file")
-		.values({
-			id: "file0",
-			path: "/file0.txt",
-			data: new TextEncoder().encode("hello world"),
-		})
-		.execute();
-
-	await fileQueueSettled({ lix });
-
-	await switchVersion({ lix, to: versionB });
-
-	const fileQueue = await lix.db.selectFrom("file_queue").selectAll().execute();
-
-	expect(fileQueue).toHaveLength(0);
+	expect(activeVersionAfterSwitch.id).toBe(newVersion?.id);
 });

package/src/version/switch-version.ts

@@ -1,8 +1,5 @@
-import { withSkipFileQueue } from "../file-queue/with-skip-file-queue.js";
-import { applyChanges } from "../change/apply-changes.js";
-import type { Change, Version } from "../database/schema.js";
 import type { Lix } from "../lix/open-lix.js";
-import { versionChangeInSymmetricDifference } from "../query-filter/version-change-in-symmetric-difference.js";
+import type { LixVersion } from "./schema.js";
 
 /**
  * Switches the current Version to the given Version.
@@ -15,91 +12,24 @@ import { versionChangeInSymmetricDifference } from "../query-filter/version-chan
  *   ```
  *
  * @example
- *   Switching Versiones to a newly created Version.
+ *   Switching to a newly created version.
  *
  *   ```ts
  *   await lix.db.transaction().execute(async (trx) => {
- *      const newVersion = await createVersion({ lix: { db: trx }, parent: currentVersion });
+ *      const newVersion = await createVersion({ lix: { db: trx }, commit_id: currentVersion.commit_id });
  *      await switchVersion({ lix: { db: trx }, to: newVersion });
  *   });
  *   ```
  */
 export async function switchVersion(args: {
-	lix: Pick<Lix, "db" | "plugin">;
-	to: Pick<Version, "id">;
+	lix: Lix;
+	to: Pick<LixVersion, "id">;
 }): Promise<void> {
 	const executeInTransaction = async (trx: Lix["db"]) => {
-		await withSkipFileQueue(trx, async (trx) => {
-			const sourceVersion = await trx
-				.selectFrom("current_version")
-				.selectAll()
-				.executeTakeFirstOrThrow();
-
-			await trx
-				.updateTable("current_version")
-				.set({ id: args.to.id })
-				.execute();
-
-			// need symmetric difference to detect inserts and deletions
-			// that should occur when switching the version
-			const versionChangesSymmetricDifference = await trx
-				.selectFrom("version_change")
-				.innerJoin("change", "version_change.change_id", "change.id")
-				.where(versionChangeInSymmetricDifference(sourceVersion, args.to))
-				.selectAll("change")
-				.execute();
-
-			// because we use the symmetric difference, entity
-			// changes need to be de-duplicated. in the future,
-			// we could improve the symmetric difference query
-			const toBeAppliedChanges: Map<string, Change> = new Map();
-
-			for (const change of versionChangesSymmetricDifference) {
-				const existingEntityChange = await trx
-					.selectFrom("version_change")
-					.innerJoin("change", "change.id", "version_change.change_id")
-					.where("version_id", "=", args.to.id)
-					.where("change.entity_id", "=", change.entity_id)
-					.where("change.file_id", "=", change.file_id)
-					.where("change.schema_key", "=", change.schema_key)
-					.selectAll("change")
-					.executeTakeFirst();
-
-				if (existingEntityChange) {
-					toBeAppliedChanges.set(
-						`${change.file_id},${change.entity_id},${change.schema_key}`,
-						existingEntityChange
-					);
-					continue;
-				}
-				// need to remove the entity when switching the version
-				else {
-					if (
-						change.plugin_key === "lix_own_change_control" &&
-						(change.schema_key === "lix_account_table" ||
-							change.schema_key === "lix_version_table")
-					) {
-						// deleting accounts and versions when switching is
-						// not desired. a version should be able to jump to a
-						// different version and the accounts are not affected
-						continue;
-					}
-					// the entity does not exist in the switched to version
-					toBeAppliedChanges.set(
-						`${change.file_id},${change.entity_id},${change.schema_key}`,
-						{
-							...change,
-							snapshot_id: "no-content",
-						}
-					);
-				}
-			}
-
-			return await applyChanges({
-				lix: { ...args.lix, db: trx },
-				changes: toBeAppliedChanges.values().toArray(),
-			});
-		});
+		await trx
+			.updateTable("active_version")
+			.set({ version_id: args.to.id })
+			.execute();
 	};
 
 	if (args.lix.db.isTransaction) {

package/src/zettel-ast/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Re-exporting the Zettel AST to make the getting started easier.
+ *
+ * Developers need access to the Zettel AST types when dealing
+ * with comments. Forcing lix dev's to install @opral/zettel-ast
+ * as a dependency in addition to the lix SDK is not ideal.
+ *
+ * Re-exporting from a subpath to avoid name collisions.
+ */
+export * from "@opral/zettel-ast";