@lix-js/sdk 0.0.1 → 0.1.0

package/src/{change-queue/change-queue-settled.test.ts → file-queue/file-queue-settled.test.ts}

@@ -1,12 +1,12 @@
 import { test, expect } from "vitest";
 import { openLixInMemory } from "../lix/open-lix-in-memory.js";
-import { changeQueueSettled } from "./change-queue-settled.js";
+import { fileQueueSettled } from "./file-queue-settled.js";
 
-test("should wait until the change queue is settled", async () => {
+test("should wait until the file queue is settled", async () => {
 	const lix = await openLixInMemory({});
 
 	await lix.db
-		.insertInto("change_queue")
+		.insertInto("file_queue")
 		.values([
 			{
 				id: 1,
@@ -25,31 +25,31 @@ test("should wait until the change queue is settled", async () => {
 		])
 		.execute();
 
-	// Start a background task to remove entries from the change_queue after a delay
+	// Start a background task to remove entries from the file_queue after a delay
 	setTimeout(async () => {
-		await lix.db.deleteFrom("change_queue").where("id", "=", 1).execute();
-		await lix.db.deleteFrom("change_queue").where("id", "=", 2).execute();
+		await lix.db.deleteFrom("file_queue").where("id", "=", 1).execute();
+		await lix.db.deleteFrom("file_queue").where("id", "=", 2).execute();
 	}, 110);
 
-	await changeQueueSettled({ lix });
+	await fileQueueSettled({ lix });
 
 	const remainingEntries = await lix.db
-		.selectFrom("change_queue")
+		.selectFrom("file_queue")
 		.selectAll()
 		.execute();
 
 	expect(remainingEntries).toEqual([]);
 });
 
-test("should return immediately if the change queue is already empty", async () => {
+test("should return immediately if the file queue is already empty", async () => {
 	const lix = await openLixInMemory({});
 
-	await lix.db.deleteFrom("change_queue").execute();
+	await lix.db.deleteFrom("file_queue").execute();
 
-	await changeQueueSettled({ lix });
+	await fileQueueSettled({ lix });
 
 	const remainingEntries = await lix.db
-		.selectFrom("change_queue")
+		.selectFrom("file_queue")
 		.selectAll()
 		.execute();
 	expect(remainingEntries).toEqual([]);

package/src/{change-queue/change-queue-settled.ts → file-queue/file-queue-settled.ts}

@@ -1,21 +1,21 @@
 import type { Lix } from "../lix/open-lix.js";
 
 /**
- * Waits until the change queue is settled.
+ * Waits until the file queue is settled.
  *
  * @example
  *   ```ts
- *   await changeQueueSettled({ lix });
+ *   await fileQueueSettled({ lix });
  *   ```
  */
-export async function changeQueueSettled(args: {
+export async function fileQueueSettled(args: {
 	lix: Pick<Lix, "db">;
 }): Promise<void> {
 	let hasEntries = true;
 
 	while (hasEntries) {
 		const entries = await args.lix.db
-			.selectFrom("change_queue")
+			.selectFrom("file_queue")
 			.selectAll()
 			.limit(1)
 			.execute();

package/src/file-queue/index.ts

@@ -0,0 +1 @@
+export { fileQueueSettled } from "./file-queue-settled.js";

package/src/{change-queue/with-skip-change-queue.test.ts → file-queue/with-skip-file-queue.test.ts}

@@ -1,10 +1,10 @@
 import { expect, test } from "vitest";
 import type { LixPlugin } from "../plugin/lix-plugin.js";
 import { openLixInMemory } from "../lix/open-lix-in-memory.js";
-import { changeQueueSettled } from "./change-queue-settled.js";
-import { withSkipChangeQueue } from "./with-skip-change-queue.js";
+import { fileQueueSettled } from "./file-queue-settled.js";
+import { withSkipFileQueue } from "./with-skip-file-queue.js";
 
-test("skipping the change queue should be possible", async () => {
+test("skipping the file queue should be possible", async () => {
 	const mockPlugin: LixPlugin = {
 		key: "mock-plugin",
 		detectChangesGlob: "*",
@@ -38,7 +38,7 @@ test("skipping the change queue should be possible", async () => {
 		})
 		.execute();
 
-	await changeQueueSettled({ lix });
+	await fileQueueSettled({ lix });
 
 	const changes0 = await lix.db
 		.selectFrom("change")
@@ -50,7 +50,7 @@ test("skipping the change queue should be possible", async () => {
 	expect(changes0).toHaveLength(1);
 	expect(changes0[0]?.content).toEqual({ text: "update0" });
 
-	await withSkipChangeQueue(lix.db, async (trx) => {
+	await withSkipFileQueue(lix.db, async (trx) => {
 		await trx
 			.updateTable("file")
 			.set({
@@ -60,7 +60,7 @@ test("skipping the change queue should be possible", async () => {
 			.execute();
 	});
 
-	await changeQueueSettled({ lix });
+	await fileQueueSettled({ lix });
 
 	const changes1 = await lix.db
 		.selectFrom("change")
@@ -74,7 +74,7 @@ test("skipping the change queue should be possible", async () => {
 	expect(changes1[0]?.content).toEqual({ text: "update0" });
 });
 
-test("skipping the change queue should be possible with multiple changes", async () => {
+test("skipping the file queue should be possible with multiple changes", async () => {
 	const mockPlugin: LixPlugin = {
 		key: "mock-plugin",
 		detectChangesGlob: "*",
@@ -124,7 +124,7 @@ test("skipping the change queue should be possible with multiple changes", async
 				.execute();
 		}
 		for (const update of last50Updates) {
-			await withSkipChangeQueue(trx, async (trx) => {
+			await withSkipFileQueue(trx, async (trx) => {
 				await trx
 					.updateTable("file")
 					.set({
@@ -136,7 +136,7 @@ test("skipping the change queue should be possible with multiple changes", async
 		}
 	});
 
-	await changeQueueSettled({ lix });
+	await fileQueueSettled({ lix });
 
 	const file = await lix.db
 		.selectFrom("file")

package/src/{change-queue/with-skip-change-queue.ts → file-queue/with-skip-file-queue.ts}

@@ -1,12 +1,12 @@
 import type { Lix } from "../lix/open-lix.js";
 
-export async function withSkipChangeQueue<T>(
+export async function withSkipFileQueue<T>(
 	db: Lix["db"],
 	operation: (trx: Lix["db"]) => Promise<T>
 ): Promise<T> {
 	const executeInTransaction = async (trx: Lix["db"]) => {
 		const queryEntryBefore = await trx
-			.selectFrom("change_queue")
+			.selectFrom("file_queue")
 			.selectAll()
 			.orderBy("id desc")
 			.executeTakeFirst();
@@ -18,7 +18,7 @@ export async function withSkipChangeQueue<T>(
 		// the queue entry before the transaction
 
 		await trx
-			.deleteFrom("change_queue")
+			.deleteFrom("file_queue")
 			.where("id", ">", queryEntryBefore?.id ?? 0)
 			.execute();
 

package/src/index.ts

@@ -2,13 +2,13 @@ export * from "./account/index.js";
 export * from "./change/index.js";
 export * from "./change-set/index.js";
 export * from "./change-conflict/index.js";
-export * from "./change-queue/index.js";
+export * from "./file-queue/index.js";
 export * from "./change-schema/index.js";
 export * from "./database/index.js";
 export * from "./discussion/index.js";
 export * from "./file/index.js";
 export * from "./lix/index.js";
-export * from "./own-entity-change-control/index.js";
+export * from "./own-change-control/index.js";
 export * from "./plugin/index.js";
 export * from "./query-filter/index.js";
 export * from "./server-api-handler/index.js";

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

@@ -1,7 +1,6 @@
 import { sql } from "kysely";
 import { expect, test } from "vitest";
 import { openLixInMemory } from "../lix/open-lix-in-memory.js";
-import { validate as validateUuid } from "uuid";
 
 test("string values are accepted", async () => {
 	const lix = await openLixInMemory({});
@@ -94,7 +93,8 @@ test("using json as value should work", async () => {
 	});
 });
 
-test("it should default add a uuid lix_id if not exits", async () => {
+// 1919T IDs needed, in order to have a 1% probability of at least one collision.
+test("it should default add nano_id(18) for the lix_id if not exits", async () => {
 	const lix = await openLixInMemory({});
 
 	const result = await lix.db
@@ -103,17 +103,38 @@ test("it should default add a uuid lix_id if not exits", async () => {
 		.selectAll()
 		.executeTakeFirstOrThrow();
 
-	expect(validateUuid(result.value)).toBe(true);
+	expect(result.value).toHaveLength(18);
 });
 
-test("default value for #lix_sync to reduce conditional logic (the key is always set)", async () => {
+test("default value for lix_sync to reduce conditional logic (the key is always set)", async () => {
 	const lix = await openLixInMemory({});
 
 	const result = await lix.db
 		.selectFrom("key_value")
-		.where("key", "=", "#lix_sync")
+		.where("key", "=", "lix_sync")
 		.selectAll()
 		.executeTakeFirstOrThrow();
 
 	expect(result.value).toBe("false");
 });
+
+test("skip_change_control should default to false", async () => {
+	const lix = await openLixInMemory({});
+
+	const result = await lix.db
+		.insertInto("key_value")
+		.values({ key: "mock_key", value: "mock_value" })
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	expect(result.skip_change_control).toBeFalsy();
+
+	const updated = await lix.db
+		.updateTable("key_value")
+		.set({ skip_change_control: true })
+		.where("key", "=", "mock_key")
+		.returningAll()
+		.executeTakeFirstOrThrow();
+
+	expect(updated.skip_change_control).toBeTruthy();
+});

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

@@ -1,4 +1,4 @@
-import type { Insertable, Selectable, Updateable } from "kysely";
+import type { Generated, Insertable, Selectable, Updateable } from "kysely";
 import type { SqliteDatabase } from "sqlite-wasm-kysely";
 
 export function applyKeyValueDatabaseSchema(
@@ -7,17 +7,20 @@ export function applyKeyValueDatabaseSchema(
 	return sqlite.exec`
 	CREATE TABLE IF NOT EXISTS key_value (
 		key TEXT PRIMARY KEY,
-		value TEXT NOT NULL
+		value TEXT NOT NULL,
+
+		-- Options
+		skip_change_control INT DEFAULT FALSE
 	) STRICT;
 
 	INSERT OR IGNORE INTO key_value (key, value)
-	VALUES ('lix_id', uuid_v4());
+	VALUES ('lix_id', nano_id(18));
 
 	-- default value for lix sync to false
 	-- if not exist to remove conditional logic
 	-- if the key exists or not
-	INSERT OR IGNORE INTO key_value (key, value)
-	VALUES ('#lix_sync', 'false');
+	INSERT OR IGNORE INTO key_value (key, value, skip_change_control)
+	VALUES ('lix_sync', 'false', 1);
 `;
 }
 
@@ -45,9 +48,18 @@ export type KeyValueTable = {
 	 *
 	 */
 	value: string;
+	/**
+	 * If `true`, the key-value pair is not tracked with own change control.
+	 *
+	 * Carefull (!) when querying the database. The return value will be `0` or `1`.
+	 * SQLite does not have a boolean select type https://www.sqlite.org/datatype3.html.
+	 *
+	 * @default false
+	 */
+	skip_change_control: Generated<boolean>;
 };
 
-type PredefinedKeys = "lix_id" | "lix_server_url" | "#lix_sync";
+type PredefinedKeys = "lix_id" | "lix_server_url" | "lix_sync";
 // The string & {} ensures TypeScript recognizes KeyValueKeys
 // as a superset of string, preventing conflicts when using other string values.
 type KeyType = string & {};

package/src/lix/close-lix.ts

@@ -0,0 +1,8 @@
+import type { Lix } from "./open-lix.js";
+
+/**
+ * Closes the lix.
+ */
+export async function closeLix(args: { lix: Pick<Lix, "db"> }): Promise<void> {
+	await args.lix.db.destroy();
+}

package/src/lix/index.ts

@@ -1,6 +1,7 @@
 export { type Lix, openLix } from "./open-lix.js";
 export { openLixInMemory } from "./open-lix-in-memory.js";
 export { newLixFile } from "./new-lix.js";
+export { toBlob } from "./to-blob.js";
 // not exporting merge for api stability milestone
 // will need an overhaul to be stable
 // export { merge } from "./merge.js";

package/src/lix/merge.test.ts

@@ -13,7 +13,8 @@ import { mockJsonSnapshot } from "../snapshot/mock-json-snapshot.js";
 import { createChangeSet } from "../change-set/create-change-set.js";
 import { createDiscussion } from "../discussion/create-discussion.js";
 import { createComment } from "../discussion/create-comment.js";
-import { changeQueueSettled } from "../change-queue/change-queue-settled.js";
+import { fileQueueSettled } from "../file-queue/file-queue-settled.js";
+import { toBlob } from "./to-blob.js";
 
 test("it should copy changes from the sourceLix into the targetLix that do not exist in targetLix yet", async () => {
 	const mockSnapshots = [
@@ -441,7 +442,7 @@ test.todo("it should apply changes that are not conflicting", async () => {
 		})
 		.execute();
 
-	await changeQueueSettled({ lix: targetLix });
+	await fileQueueSettled({ lix: targetLix });
 
 	await merge({ sourceLix, targetLix });
 	const changes = await targetLix.db
@@ -687,11 +688,11 @@ test("it should copy discussion and related comments and mappings", async () =>
 		})
 		.execute();
 
-	await changeQueueSettled({ lix: lix1 });
+	await fileQueueSettled({ lix: lix1 });
 
 	// The files have to be there before we merge
 	const lix2 = await openLixInMemory({
-		blob: await lix1.toBlob(),
+		blob: await toBlob({ lix: lix1 }),
 		providePlugins: [mockPlugin],
 	});
 
@@ -720,17 +721,10 @@ test("it should copy discussion and related comments and mappings", async () =>
 		])
 	);
 
-	// TODO how do know which author to use for the discussion - we can have multiple active accounts?
-	const currentAuthorLix1 = await lix1.db
-		.selectFrom("active_account")
-		.selectAll()
-		.executeTakeFirstOrThrow();
-
 	await createDiscussion({
 		lix: lix1,
 		changeSet: await createChangeSet({ lix: lix1, changes: [changes[0]!] }),
-		content: "comment on a change",
-		createdBy: { id: currentAuthorLix1.id },
+		firstComment: { content: "comment on a change" },
 	});
 
 	await merge({ sourceLix: lix1, targetLix: lix2 });
@@ -747,21 +741,15 @@ test("it should copy discussion and related comments and mappings", async () =>
 	// lix 2 has no comments yet so after lix 1 into 2 we should be in sync
 	expect(commentsLix1).toEqual(commentsLix2AfterMerge);
 
-	const currentAuthorLix2 = await lix1.db
-		.selectFrom("active_account")
-		.selectAll()
-		.executeTakeFirstOrThrow();
 	await createComment({
 		lix: lix2,
 		parentComment: commentsLix2AfterMerge[0]!,
 		content: "wrote in lix 2",
-		createdBy: { id: currentAuthorLix2.id },
 	});
 	await createComment({
 		lix: lix1,
 		parentComment: commentsLix2AfterMerge[0]!,
 		content: "wrote in lix 1",
-		createdBy: { id: currentAuthorLix1.id },
 	});
 
 	const commentsLix1OnSecondMerge = await lix1.db
@@ -816,7 +804,7 @@ test.skip("it should copy change sets and merge memberships", async () => {
 	});
 
 	const sourceLix = await openLixInMemory({
-		blob: await targetLix.toBlob(),
+		blob: await toBlob({ lix: targetLix }),
 	});
 
 	// expand the change set to contain another change

package/src/lix/merge.ts

@@ -1,6 +1,6 @@
 import type { Lix } from "./open-lix.js";
 import { getLeafChangesOnlyInSource } from "./merge.get-leaf-changes-only-in-source.js";
-import { withSkipChangeQueue } from "../change-queue/with-skip-change-queue.js";
+import { withSkipFileQueue } from "../file-queue/with-skip-file-queue.js";
 import type { DetectedConflict } from "../plugin/lix-plugin.js";
 
 /**
@@ -45,7 +45,7 @@ export async function merge(args: {
 
 		[];
 
-	const changesPerFile: Record<string, ArrayBuffer> = {};
+	const changesPerFile: Record<string, Uint8Array> = {};
 
 	const fileIds = new Set(sourceChangesWithSnapshot.map((c) => c.file_id));
 
@@ -83,7 +83,7 @@ export async function merge(args: {
 					metadata: file.metadata,
 				};
 
-				await withSkipChangeQueue(args.targetLix.db, async (trx) => {
+				await withSkipFileQueue(args.targetLix.db, async (trx) => {
 					await trx
 						.insertInto("file")
 						.values({ ...fileToInsert })
@@ -183,7 +183,7 @@ export async function merge(args: {
 
 		for (const [fileId, fileData] of Object.entries(changesPerFile)) {
 			// update the file data with the applied changes
-			await withSkipChangeQueue(trx, async (trx) => {
+			await withSkipFileQueue(trx, async (trx) => {
 				await trx
 					.updateTable("file")
 					.set("data", fileData)

package/src/lix/new-lix.ts

@@ -3,6 +3,7 @@ import {
 	contentFromDatabase,
 } from "sqlite-wasm-kysely";
 import { initDb } from "../database/init-db.js";
+import { closeLix } from "./close-lix.js";
 
 /**
  * Creates a new lix file.
@@ -23,8 +24,6 @@ export async function newLixFile(): Promise<Blob> {
 	} catch (e) {
 		throw new Error(`Failed to create new Lix file: ${e}`, { cause: e });
 	} finally {
-		// in any case destroy the memory db
-		sqlite.close();
-		await db.destroy();
+		closeLix({ lix: { db } });
 	}
 }

package/src/lix/open-lix-in-memory.test.ts

@@ -1,5 +1,6 @@
 import { test, expect } from "vitest";
 import { openLixInMemory } from "./open-lix-in-memory.js";
+import { toBlob } from "./to-blob.js";
 
 test("it should open a lix in memory", async () => {
 	const lix = await openLixInMemory({});
@@ -10,6 +11,7 @@ test("it should open a lix in memory", async () => {
 
 test("it should open a lix in memory from a blob", async () => {
 	const lix1 = await openLixInMemory({});
+
 	await lix1.db
 		.insertInto("file")
 		.values({
@@ -18,8 +20,10 @@ test("it should open a lix in memory from a blob", async () => {
 			data: new TextEncoder().encode("hello"),
 		})
 		.execute();
-	const lix2 = await openLixInMemory({ blob: await lix1.toBlob() });
+
+	const lix2 = await openLixInMemory({ blob: await toBlob({ lix: lix1 }) });
 	const files = await lix2.db.selectFrom("file").selectAll().execute();
+
 	expect(files).toEqual([
 		expect.objectContaining({
 			id: "1",

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

@@ -2,6 +2,7 @@ import { expect, test } from "vitest";
 import { openLixInMemory } from "./open-lix-in-memory.js";
 import { newLixFile } from "./new-lix.js";
 import type { LixPlugin } from "../plugin/lix-plugin.js";
+import { toBlob } from "./to-blob.js";
 
 test("providing plugins should be possible", async () => {
 	const mockPlugin: LixPlugin = {
@@ -17,17 +18,28 @@ test("providing plugins should be possible", async () => {
 test("providing key values should be possible", async () => {
 	const lix = await openLixInMemory({
 		blob: await newLixFile(),
-		keyValues: [{ key: "key", value: "value" }],
+		keyValues: [{ key: "mock_key", value: "value" }],
 	});
-	const value = await lix.db.selectFrom("key_value").selectAll().execute();
-	expect(value).toContainEqual({ key: "key", value: "value" });
+
+	const value = await lix.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "=", "mock_key")
+		.executeTakeFirstOrThrow();
+
+	expect(value).toMatchObject({ key: "mock_key", value: "value" });
 
 	// testing overwriting key values
 	const lix1 = await openLixInMemory({
-		blob: await lix.toBlob(),
-		keyValues: [{ key: "key", value: "value2" }],
+		blob: await toBlob({ lix }),
+		keyValues: [{ key: "mock_key", value: "value2" }],
 	});
 
-	const value1 = await lix1.db.selectFrom("key_value").selectAll().execute();
-	expect(value1).toContainEqual({ key: "key", value: "value2" });
+	const value1 = await lix1.db
+		.selectFrom("key_value")
+		.selectAll()
+		.where("key", "=", "mock_key")
+
+		.executeTakeFirstOrThrow();
+	expect(value1).toMatchObject({ key: "mock_key", value: "value2" });
 });

package/src/lix/open-lix.ts

@@ -1,13 +1,12 @@
 import type { LixPlugin } from "../plugin/lix-plugin.js";
 import { loadPlugins } from "../plugin/load-plugin.js";
-import { contentFromDatabase, type SqliteDatabase } from "sqlite-wasm-kysely";
+import { type SqliteDatabase } from "sqlite-wasm-kysely";
 import { initDb } from "../database/init-db.js";
-import { initChangeQueue } from "../change-queue/init-change-queue.js";
-import { changeQueueSettled } from "../change-queue/change-queue-settled.js";
+import { initFileQueueProcess } from "../file-queue/file-queue-process.js";
 import type { Kysely } from "kysely";
 import type { LixDatabaseSchema } from "../database/schema.js";
 import { initSyncProcess } from "../sync/sync-process.js";
-import type { KeyValue } from "../key-value/database-schema.js";
+import type { NewKeyValue } from "../key-value/database-schema.js";
 
 export type Lix = {
 	/**
@@ -22,11 +21,9 @@ export type Lix = {
 	 */
 	sqlite: SqliteDatabase;
 	db: Kysely<LixDatabaseSchema>;
-	toBlob: () => Promise<Blob>;
 	plugin: {
 		getAll: () => Promise<LixPlugin[]>;
 	};
-	close: () => Promise<void>;
 };
 
 /**
@@ -52,9 +49,9 @@ export async function openLix(args: {
 	 * Set the key values when opening the lix.
 	 *
 	 * @example
-	 *   const lix = await openLix({ keyValues: [{ key: "#lix_sync", value: "false" }] })
+	 *   const lix = await openLix({ keyValues: [{ key: "lix_sync", value: "false" }] })
 	 */
-	keyValues?: KeyValue[];
+	keyValues?: NewKeyValue[];
 }): Promise<Lix> {
 	const db = initDb({ sqlite: args.database });
 
@@ -77,27 +74,13 @@ export async function openLix(args: {
 		getAll: async () => plugins,
 	};
 
-	const toBlob = async () => {
-		await changeQueueSettled({ lix: { db } });
-		return new Blob([contentFromDatabase(args.database)]);
-	};
-
-	initChangeQueue({
-		lix: { db, plugin, sqlite: args.database },
-		rawDatabase: args.database,
-	});
+	initFileQueueProcess({ lix: { db, plugin, sqlite: args.database } });
 
-	initSyncProcess({ lix: { db, plugin, toBlob } });
+	initSyncProcess({ lix: { db, plugin, sqlite: args.database } });
 
 	return {
 		db,
 		sqlite: args.database,
-		toBlob,
 		plugin,
-		close: async () => {
-			await changeQueueSettled({ lix: { db } });
-			// args.database.close();
-			// await db.destroy();
-		},
 	};
 }

package/src/lix/to-blob.ts

@@ -0,0 +1,14 @@
+import { contentFromDatabase } from "sqlite-wasm-kysely";
+import type { Lix } from "./open-lix.js";
+
+/**
+ * Convert the lix to a blob.
+ *
+ * @example
+ *   const blob = await toBlob({ lix })
+ */
+export async function toBlob(args: {
+	lix: Pick<Lix, "db" | "sqlite">;
+}): Promise<Blob> {
+	return new Blob([contentFromDatabase(args.lix.sqlite)]);
+}