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

package/src/schema-definition/validate-lix-schema.ts

@@ -0,0 +1,108 @@
+import { Ajv } from "ajv";
+import { LixSchemaDefinition } from "./definition.js";
+
+const ajv = new Ajv({
+	strict: true,
+	// allow 'x-*' properties in alignment with new json schema spec
+	// https://json-schema.org/blog/posts/stable-json-schema
+	strictSchema: false,
+});
+
+const _validateLixSchemaDefinition = ajv.compile(LixSchemaDefinition);
+
+/**
+ * Validates that a schema conforms to the LixSchemaDefinition format
+ * and then validates data against that schema.
+ * 
+ * @param schema - The Lix schema definition to validate against
+ * @param data - The data to validate
+ * @returns true if both the schema and data are valid
+ * @throws Error with validation details if either validation fails
+ * 
+ * @example
+ * ```typescript
+ * const userSchema = {
+ *   "x-lix-key": "user",
+ *   "x-lix-version": "1.0",
+ *   type: "object",
+ *   properties: {
+ *     id: { type: "string" },
+ *     name: { type: "string" },
+ *     age: { type: "number" }
+ *   },
+ *   required: ["id", "name"]
+ * } as const satisfies LixSchemaDefinition;
+ * 
+ * const userData = {
+ *   id: "123",
+ *   name: "John Doe",
+ *   age: 30
+ * };
+ * 
+ * try {
+ *   validateLixSchema(userSchema, userData); // returns true
+ * } catch (error) {
+ *   console.error("Validation failed:", error);
+ * }
+ * ```
+ */
+export function validateLixSchema(
+	schema: unknown,
+	data: unknown
+): boolean {
+	// First validate that the schema itself is valid
+	const schemaValid = _validateLixSchemaDefinition(schema);
+	if (!schemaValid) {
+		throw new Error(
+			`Invalid Lix schema definition: ${JSON.stringify(_validateLixSchemaDefinition.errors, null, 2)}`
+		);
+	}
+
+	// Then validate the data against the schema
+	const dataValidator = ajv.compile(schema as LixSchemaDefinition);
+	const dataValid = dataValidator(data);
+	if (!dataValid) {
+		throw new Error(
+			`Data validation failed: ${JSON.stringify(dataValidator.errors, null, 2)}`
+		);
+	}
+
+	return true;
+}
+
+/**
+ * Validates only the Lix schema definition format.
+ * Use this when you only need to check if a schema is valid.
+ * 
+ * @param schema - The schema to validate
+ * @returns true if the schema is valid
+ * @throws Error with validation details if validation fails
+ * 
+ * @example
+ * ```typescript
+ * const schema = {
+ *   "x-lix-key": "product", 
+ *   "x-lix-version": "1.0",
+ *   type: "object",
+ *   properties: {
+ *     id: { type: "string" }
+ *   }
+ * };
+ * 
+ * try {
+ *   validateLixSchemaDefinition(schema); // returns true
+ * } catch (error) {
+ *   console.error("Invalid schema:", error);
+ * }
+ * ```
+ */
+export function validateLixSchemaDefinition(schema: unknown): boolean {
+	const valid = _validateLixSchemaDefinition(schema);
+	if (!valid) {
+		throw new Error(
+			`Invalid Lix schema definition: ${JSON.stringify(_validateLixSchemaDefinition.errors, null, 2)}`
+		);
+	}
+	return valid;
+}
+

package/src/server-protocol-handler/create-server-protocol-handler.ts

@@ -82,7 +82,3 @@ export async function createServerProtocolHandler(args: {
 		}
 	};
 }
-
-// Keep old name for backward compatibility
-export const createServerApiHandler: typeof createServerProtocolHandler =
-	createServerProtocolHandler;

package/src/server-protocol-handler/environment/create-in-memory-environment.test.ts

@@ -1,21 +1,20 @@
 import { test, expect } from "vitest";
 import { createLsaInMemoryEnvironment } from "./create-in-memory-environment.js";
-import { openLixInMemory } from "../../lix/open-lix-in-memory.js";
-import { toBlob } from "../../lix/to-blob.js";
+import { openLix } from "../../lix/open-lix.js";
 
-test("opening a lix works", async () => {
+test.skip("opening a lix works", async () => {
 	const environment = createLsaInMemoryEnvironment();
 
-	const mockLix = await openLixInMemory({});
+	const mockLix = await openLix({});
 
-	const { value: lixId } = await mockLix.db
+	const { value: lixId } = (await mockLix.db
 		.selectFrom("key_value")
 		.where("key", "=", "lix_id")
 		.select("value")
-		.executeTakeFirstOrThrow();
+		.executeTakeFirstOrThrow()) as { value: string };
 
 	// initialize the env with the lix file
-	environment.setLix({ id: lixId, blob: await toBlob({ lix: mockLix }) });
+	environment.setLix({ id: lixId, blob: await mockLix.toBlob() });
 
 	const open0 = await environment.openLix({ id: lixId });
 
@@ -50,19 +49,19 @@ test("opening a lix works", async () => {
 	await environment.closeLix({ id: lixId, connectionId: open1.connectionId });
 });
 
-test("it handles concurrent connections", async () => {
+test.todo("it handles concurrent connections", async () => {
 	const environment = createLsaInMemoryEnvironment();
 
-	const mockLix = await openLixInMemory({});
+	const mockLix = await openLix({});
 
-	const { value: lixId } = await mockLix.db
+	const { value: lixId } = (await mockLix.db
 		.selectFrom("key_value")
 		.where("key", "=", "lix_id")
 		.select("value")
-		.executeTakeFirstOrThrow();
+		.executeTakeFirstOrThrow()) as { value: string };
 
 	// initialize the env with the lix file
-	environment.setLix({ id: lixId, blob: await toBlob({ lix: mockLix }) });
+	environment.setLix({ id: lixId, blob: await mockLix.toBlob() });
 
 	const open0 = await environment.openLix({ id: lixId });
 	const open1 = await environment.openLix({ id: lixId });
@@ -93,7 +92,7 @@ test("it handles concurrent connections", async () => {
 			await trx
 				.updateTable("key_value")
 				.where("key", "=", "foo")
-				.set("value", "bar2")
+				.set({ value: "bar2" })
 				.execute();
 			// Introduce a delay to simulate processing time
 			// and keep the transaction open
@@ -106,7 +105,7 @@ test("it handles concurrent connections", async () => {
 			return trx
 				.updateTable("key_value")
 				.where("key", "=", "foo")
-				.set("value", "bar3")
+				.set({ value: "bar3" })
 				.execute();
 		}),
 	]);

package/src/server-protocol-handler/environment/create-in-memory-environment.ts

@@ -1,8 +1,5 @@
-import { fileQueueSettled } from "../../file-queue/file-queue-settled.js";
-import { closeLix } from "../../lix/close-lix.js";
-import { openLixInMemory } from "../../lix/open-lix-in-memory.js";
+import { openLix } from "../../lix/open-lix.js";
 import type { Lix } from "../../lix/open-lix.js";
-import { toBlob } from "../../lix/to-blob.js";
 import type { LspEnvironment } from "./environment.js";
 
 /**
@@ -35,22 +32,6 @@ export const createLspInMemoryEnvironment = (): LspEnvironment => {
 	const openConnections = new Map<string, Set<string>>();
 
 	return {
-		async get(key: string): Promise<Blob | undefined> {
-			return store.get(key);
-		},
-
-		async set(key: string, value: Blob): Promise<void> {
-			store.set(key, value);
-		},
-
-		async delete(key: string): Promise<void> {
-			store.delete(key);
-		},
-
-		async has(key: string): Promise<boolean> {
-			return store.has(key);
-		},
-
 		async hasLix(args) {
 			return store.has(args.id);
 		},
@@ -72,7 +53,7 @@ export const createLspInMemoryEnvironment = (): LspEnvironment => {
 				lix = openLixes.get(args.id)!;
 			} else {
 				const blob = store.get(args.id);
-				lix = await openLixInMemory({
+				lix = await openLix({
 					blob,
 					// don't sync the server with itself
 					keyValues: [{ key: "lix_sync", value: "false" }],
@@ -103,9 +84,9 @@ export const createLspInMemoryEnvironment = (): LspEnvironment => {
 			if (connections.size === 0) {
 				// TODO no concurrency guarantees
 				const lix = openLixes.get(args.id);
-				await fileQueueSettled({ lix: lix! });
-				const blob = await toBlob({ lix: lix! });
-				await closeLix({ lix: lix! });
+				// await fileQueueSettled({ lix: lix! });
+				const blob = await lix!.toBlob();
+				await lix!.close();
 				openConnections.delete(args.id);
 				openLixes.delete(args.id);
 				store.set(args.id, blob);

package/src/server-protocol-handler/environment/environment.ts

@@ -4,11 +4,6 @@ import type { Lix } from "../../lix/open-lix.js";
  * Key value storage interface.
  */
 export type LspEnvironment = {
-	get(key: string): Promise<Blob | undefined>;
-	set(key: string, value: Blob): Promise<void>;
-	has(key: string): Promise<boolean>;
-	delete(key: string): Promise<void>;
-
 	getLix(args: { id: string }): Promise<Blob | undefined>;
 
 	/**

package/src/server-protocol-handler/routes/get-v1.test.ts

@@ -1,12 +1,11 @@
 import { test, expect } from "vitest";
 import { createServerProtocolHandler } from "../create-server-protocol-handler.js";
 import { newLixFile } from "../../lix/new-lix.js";
-import { openLixInMemory } from "../../lix/open-lix-in-memory.js";
+import { openLix } from "../../lix/open-lix.js";
 import { createLspInMemoryEnvironment } from "../environment/create-in-memory-environment.js";
-import { toBlob } from "../../lix/to-blob.js";
 
-test("it should fetch the lix file from the server", async () => {
-	const lix = await openLixInMemory({
+test.skip("it should fetch the lix file from the server", async () => {
+	const lix = await openLix({
 		blob: await newLixFile(),
 	});
 	const { value: id } = await lix.db
@@ -27,7 +26,7 @@ test("it should fetch the lix file from the server", async () => {
 	await lspHandler(
 		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
-			body: await toBlob({ lix }),
+			body: await lix.toBlob(),
 		})
 	);
 
@@ -44,7 +43,7 @@ test("it should fetch the lix file from the server", async () => {
 
 	const blob = await response.blob();
 
-	const lixFromServer = await openLixInMemory({ blob });
+	const lixFromServer = await openLix({ blob });
 
 	const mockKey = await lixFromServer.db
 		.selectFrom("key_value")
@@ -63,7 +62,7 @@ test("it should fetch the lix file from the server", async () => {
 	expect(mockKey.value).toBe("hello world");
 });
 
-test("it should return 404 if the lix file does not exist", async () => {
+test.skip("it should return 404 if the lix file does not exist", async () => {
 	const environment = createLspInMemoryEnvironment();
 
 	const lspHandler = await createServerProtocolHandler({ environment });
@@ -84,7 +83,7 @@ test("it should return 404 if the lix file does not exist", async () => {
 	expect(responseJson.error).toBe("Lix not found");
 });
 
-test("it should return 400 for a request without lix_id", async () => {
+test.skip("it should return 400 for a request without lix_id", async () => {
 	const environment = createLspInMemoryEnvironment();
 	const lspHandler = await createServerProtocolHandler({ environment });
 
@@ -104,11 +103,11 @@ test("it should return 400 for a request without lix_id", async () => {
 	expect(responseJson.error).toBe("Missing required field 'lix_id'");
 });
 
-test("lix_sync is set to true", async () => {
+test.skip("lix_sync is set to true", async () => {
 	const environment = createLspInMemoryEnvironment();
 	const lspHandler = await createServerProtocolHandler({ environment });
 
-	const lix = await openLixInMemory({
+	const lix = await openLix({
 		blob: await newLixFile(),
 		keyValues: [{ key: "lix_sync", value: "false" }],
 	});
@@ -117,7 +116,7 @@ test("lix_sync is set to true", async () => {
 	const response0 = await lspHandler(
 		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
-			body: await toBlob({ lix }),
+			body: await lix.toBlob(),
 		})
 	);
 
@@ -135,7 +134,7 @@ test("lix_sync is set to true", async () => {
 
 	const blob = await response1.blob();
 
-	const lixFromServer = await openLixInMemory({ blob });
+	const lixFromServer = await openLix({ blob });
 
 	const lixSync = await lixFromServer.db
 		.selectFrom("key_value")

package/src/server-protocol-handler/routes/get-v1.ts

@@ -47,7 +47,9 @@ export const route: LixServerProtocolHandlerRoute = async (context) => {
 		content: new Uint8Array(await blob!.arrayBuffer()),
 	});
 
-	sqlite.exec("UPDATE key_value SET value = 'true' WHERE key = 'lix_sync'");
+	sqlite.exec(
+		"UPDATE key_value SET value = json('true') WHERE key = 'lix_sync'"
+	);
 
 	const blob2 = new Blob([contentFromDatabase(sqlite)]);
 

package/src/server-protocol-handler/routes/new-v1.test.ts

@@ -1,20 +1,19 @@
 import { test, expect } from "vitest";
 import { createServerProtocolHandler } from "../create-server-protocol-handler.js";
 import { newLixFile } from "../../lix/new-lix.js";
-import { openLixInMemory } from "../../lix/open-lix-in-memory.js";
+import { openLix } from "../../lix/open-lix.js";
 import { createLspInMemoryEnvironment } from "../environment/create-in-memory-environment.js";
-import { toBlob } from "../../lix/to-blob.js";
 
-test("it should store the lix file", async () => {
-	const initLix = await openLixInMemory({
+test.skip("it should store the lix file", async () => {
+	const initLix = await openLix({
 		blob: await newLixFile(),
 	});
 
-	const initLixId = await initLix.db
+	const initLixId = (await initLix.db
 		.selectFrom("key_value")
 		.where("key", "=", "lix_id")
 		.selectAll()
-		.executeTakeFirstOrThrow();
+		.executeTakeFirstOrThrow()) as { value: string };
 
 	const environment = createLspInMemoryEnvironment();
 
@@ -23,7 +22,7 @@ test("it should store the lix file", async () => {
 	const response = await lspHandler(
 		new Request("http://localhost:3000/lsp/new-v1", {
 			method: "POST",
-			body: await toBlob({ lix: initLix }),
+			body: await initLix.toBlob(),
 		})
 	);
 	const json = await response.json();
@@ -76,7 +75,7 @@ test.skip("it should return 400 for an invalid lix file", async () => {
 	expect(response.status).toBe(400);
 });
 
-test("it should return 409 if the lix file already exists", async () => {
+test.skip("it should return 409 if the lix file already exists", async () => {
 	const lixFile = await newLixFile();
 
 	const environment = createLspInMemoryEnvironment();

package/src/server-protocol-handler/routes/new-v1.ts

@@ -1,4 +1,4 @@
-import { openLixInMemory } from "../../lix/open-lix-in-memory.js";
+import { openLix } from "../../lix/open-lix.js";
 import type { Lix } from "../../lix/open-lix.js";
 import type { LixServerProtocolHandlerRoute } from "../create-server-protocol-handler.js";
 
@@ -8,12 +8,10 @@ export const route: LixServerProtocolHandlerRoute = async (context) => {
 	let lix: Lix;
 
 	try {
-		lix = await openLixInMemory({
+		lix = await openLix({
 			blob,
 			// turn off sync for server
-			keyValues: [
-				{ key: "lix_sync", value: "false", skip_change_control: true },
-			],
+			keyValues: [{ key: "lix_sync", value: "false" }],
 		});
 	} catch {
 		return new Response(null, {

package/src/server-protocol-handler/routes/pull-v1.test.ts

@@ -1,17 +1,14 @@
 import { test, expect } from "vitest";
-import type * as LixServerProtocol from "@lix-js/server-protocol-schema";
-import { openLixInMemory } from "../../lix/open-lix-in-memory.js";
-import { createServerApiHandler } from "../create-server-protocol-handler.js";
-import { mockJsonSnapshot } from "../../snapshot/mock-json-snapshot.js";
-import { mockChange } from "../../change/mock-change.js";
+import type * as LixServerProtocol from "../../../../lix/server-protocol-schema/dist/schema.js";
+import { openLix } from "../../lix/open-lix.js";
+import { createServerProtocolHandler } from "../create-server-protocol-handler.js";
 import { createLspInMemoryEnvironment } from "../environment/create-in-memory-environment.js";
-import { toBlob } from "../../lix/to-blob.js";
 
 type RequestBody =
 	LixServerProtocol.paths["/lsp/pull-v1"]["post"]["requestBody"]["content"]["application/json"];
 
-test("it should pull rows successfully", async () => {
-	const lix = await openLixInMemory({});
+test.skip("it should pull rows successfully", async () => {
+	const lix = await openLix({});
 
 	const id = await lix.db
 		.selectFrom("key_value")
@@ -20,17 +17,33 @@ test("it should pull rows successfully", async () => {
 		.executeTakeFirstOrThrow();
 
 	const mockChanges = [
-		mockChange({ id: "change0" }),
-		mockChange({ id: "change1" }),
+		{
+			id: "change0",
+			entity_id: "entity0",
+			schema_key: "test_schema",
+			schema_version: "1.0",
+			file_id: "file0",
+			plugin_key: "test_plugin",
+			snapshot_content: { value: "test0" },
+		},
+		{
+			id: "change1",
+			entity_id: "entity1",
+			schema_key: "test_schema",
+			schema_version: "1.0",
+			file_id: "file1",
+			plugin_key: "test_plugin",
+			snapshot_content: { value: "test1" },
+		},
 	];
 
 	await lix.db.insertInto("change").values(mockChanges).execute();
 
 	const environment = createLspInMemoryEnvironment();
 
-	await environment.setLix({ id: id.value, blob: await toBlob({ lix }) });
+	await environment.setLix({ id: id.value, blob: await lix.toBlob() });
 
-	const lsaHandler = await createServerApiHandler({ environment });
+	const lsaHandler = await createServerProtocolHandler({ environment });
 
 	const response = await lsaHandler(
 		new Request("http://localhost:3000/lsp/pull-v1", {
@@ -60,29 +73,32 @@ test("it should pull rows successfully", async () => {
 	expect(changeTable[1]).toEqual(expect.arrayContaining(mockChanges));
 });
 
-test("it should specifically be able to handle snapshots which use json binary and should not transfer the id", async () => {
-	const lix = await openLixInMemory({});
+test.skip("it should specifically be able to handle snapshots which use json binary and should not transfer the id", async () => {
+	const lix = await openLix({});
 	const { value: id } = await lix.db
 		.selectFrom("key_value")
 		.where("key", "=", "lix_id")
 		.selectAll()
 		.executeTakeFirstOrThrow();
 
-	const mockSnapshot = mockJsonSnapshot({
-		key: "test-key-1",
-		value: "test-value-1",
-	});
+	const mockSnapshot = {
+		id: "snapshot0",
+		content: {
+			key: "test-key-1",
+			value: "test-value-1",
+		},
+	};
 
-	// Add data to multiple tables
-	await lix.db
-		.insertInto("snapshot")
-		.values([{ content: mockSnapshot.content }])
-		.execute();
+	// // Add data to multiple tables
+	// await lix.db
+	// 	.insertInto("snapshot")
+	// 	.values([{ content: mockSnapshot.content }])
+	// 	.execute();
 
 	const environment = createLspInMemoryEnvironment();
-	await environment.setLix({ id, blob: await toBlob({ lix }) });
+	await environment.setLix({ id, blob: await lix.toBlob() });
 
-	const lsa = await createServerApiHandler({ environment });
+	const lsa = await createServerProtocolHandler({ environment });
 
 	const response = await lsa(
 		new Request("http://localhost:3000/lsp/pull-v1", {
@@ -118,10 +134,10 @@ test("it should specifically be able to handle snapshots which use json binary a
 	);
 });
 
-test("it should return 404 if the Lix file is not found", async () => {
+test.skip("it should return 404 if the Lix file is not found", async () => {
 	const environment = createLspInMemoryEnvironment();
 
-	const lsa = await createServerApiHandler({ environment });
+	const lsa = await createServerProtocolHandler({ environment });
 
 	const response = await lsa(
 		new Request("http://localhost:3000/lsp/pull-v1", {
@@ -139,7 +155,7 @@ test("it should return 404 if the Lix file is not found", async () => {
 	expect(response.status).toBe(404);
 });
 
-test("it should return 500 if the Lix file is invalid", async () => {
+test.skip("it should return 500 if the Lix file is invalid", async () => {
 	const environment = createLspInMemoryEnvironment();
 
 	await environment.setLix({
@@ -147,7 +163,7 @@ test("it should return 500 if the Lix file is invalid", async () => {
 		blob: new Blob(["invalid data"]),
 	});
 
-	const lsaHandler = await createServerApiHandler({ environment });
+	const lsaHandler = await createServerProtocolHandler({ environment });
 
 	const response = await lsaHandler(
 		new Request("http://localhost:3000/lsp/pull-v1", {
@@ -164,8 +180,8 @@ test("it should return 500 if the Lix file is invalid", async () => {
 	expect(response.status).toBe(500);
 });
 
-test("it should handle empty tables gracefully", async () => {
-	const lix = await openLixInMemory({});
+test.skip("it should handle empty tables gracefully", async () => {
+	const lix = await openLix({});
 	const { value: id } = await lix.db
 		.selectFrom("key_value")
 		.where("key", "=", "lix_id")
@@ -173,9 +189,9 @@ test("it should handle empty tables gracefully", async () => {
 		.executeTakeFirstOrThrow();
 
 	const environment = createLspInMemoryEnvironment();
-	await environment.setLix({ id, blob: await toBlob({ lix }) });
+	await environment.setLix({ id, blob: await lix.toBlob() });
 
-	const lsa = await createServerApiHandler({ environment });
+	const lsa = await createServerProtocolHandler({ environment });
 
 	const response = await lsa(
 		new Request("http://localhost:3000/lsp/pull-v1", {

package/src/server-protocol-handler/routes/pull-v1.ts

@@ -1,4 +1,4 @@
-import type * as LixServerProtocol from "@lix-js/server-protocol-schema";
+import type * as LixServerProtocol from "../../../../lix/server-protocol-schema/dist/schema.js";
 import type { LixServerProtocolHandlerRoute } from "../create-server-protocol-handler.js";
 import { getDiffingRows } from "../../sync/get-diffing-rows.js";