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

package/src/plugin/mock-json-plugin.flatten.ts

@@ -0,0 +1,161 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
+/**
+ * VENDORED FROM https://github.com/dmester/jsflattener
+ */
+
+function isBuffer(obj) {
+	return (
+		obj &&
+		obj.constructor &&
+		typeof obj.constructor.isBuffer === "function" &&
+		obj.constructor.isBuffer(obj)
+	);
+}
+
+function keyIdentity(key) {
+	return key;
+}
+
+export function flatten(
+	target: Record<string, any>,
+	opts: any
+): Record<string, any> {
+	opts = opts || {};
+
+	const delimiter = opts.delimiter || ".";
+	const maxDepth = opts.maxDepth;
+	const transformKey = opts.transformKey || keyIdentity;
+	const output = {};
+
+	function step(object, prev, currentDepth) {
+		currentDepth = currentDepth || 1;
+		Object.keys(object).forEach(function (key) {
+			const value = object[key];
+			const isarray = opts.safe && Array.isArray(value);
+			const type = Object.prototype.toString.call(value);
+			const isbuffer = isBuffer(value);
+			const isobject = type === "[object Object]" || type === "[object Array]";
+
+			const newKey = prev
+				? prev + delimiter + transformKey(key)
+				: transformKey(key);
+
+			if (
+				!isarray &&
+				!isbuffer &&
+				isobject &&
+				Object.keys(value).length &&
+				(!opts.maxDepth || currentDepth < maxDepth)
+			) {
+				return step(value, newKey, currentDepth + 1);
+			}
+
+			output[newKey] = value;
+		});
+	}
+
+	step(target);
+
+	return output;
+}
+
+export function unflatten(
+	target: Record<string, any>,
+	opts: any
+): Record<string, any> {
+	opts = opts || {};
+
+	const delimiter = opts.delimiter || ".";
+	const overwrite = opts.overwrite || false;
+	const transformKey = opts.transformKey || keyIdentity;
+	const result = {};
+
+	const isbuffer = isBuffer(target);
+	if (
+		isbuffer ||
+		Object.prototype.toString.call(target) !== "[object Object]"
+	) {
+		return target;
+	}
+
+	// safely ensure that the key is
+	// an integer.
+	function getkey(key) {
+		const parsedKey = Number(key);
+
+		return isNaN(parsedKey) || key.indexOf(".") !== -1 || opts.object
+			? key
+			: parsedKey;
+	}
+
+	function addKeys(keyPrefix, recipient, target) {
+		return Object.keys(target).reduce(function (result, key) {
+			result[keyPrefix + delimiter + key] = target[key];
+
+			return result;
+		}, recipient);
+	}
+
+	function isEmpty(val) {
+		const type = Object.prototype.toString.call(val);
+		const isArray = type === "[object Array]";
+		const isObject = type === "[object Object]";
+
+		if (!val) {
+			return true;
+		} else if (isArray) {
+			return !val.length;
+		} else if (isObject) {
+			return !Object.keys(val).length;
+		}
+	}
+
+	target = Object.keys(target).reduce(function (result, key) {
+		const type = Object.prototype.toString.call(target[key]);
+		const isObject = type === "[object Object]" || type === "[object Array]";
+		if (!isObject || isEmpty(target[key])) {
+			result[key] = target[key];
+			return result;
+		} else {
+			return addKeys(key, result, flatten(target[key], opts));
+		}
+	}, {});
+
+	Object.keys(target).forEach(function (key) {
+		const split = key.split(delimiter).map(transformKey);
+		let key1 = getkey(split.shift());
+		let key2 = getkey(split[0]);
+		let recipient = result;
+
+		while (key2 !== undefined) {
+			if (key1 === "__proto__") {
+				return;
+			}
+
+			const type = Object.prototype.toString.call(recipient[key1]);
+			const isobject = type === "[object Object]" || type === "[object Array]";
+
+			// do not write over falsey, non-undefined values if overwrite is false
+			if (!overwrite && !isobject && typeof recipient[key1] !== "undefined") {
+				return;
+			}
+
+			if ((overwrite && !isobject) || (!overwrite && recipient[key1] == null)) {
+				recipient[key1] = typeof key2 === "number" && !opts.object ? [] : {};
+			}
+
+			recipient = recipient[key1];
+			if (split.length > 0) {
+				key1 = getkey(split.shift());
+				key2 = getkey(split[0]);
+			}
+		}
+
+		// unflatten again for 'messy objects'
+		recipient[key1] = unflatten(target[key], opts);
+	});
+
+	return result;
+}

package/src/plugin/mock-json-plugin.test.ts

@@ -0,0 +1,214 @@
+import { expect, test } from "vitest";
+import { mockJsonPlugin } from "./mock-json-plugin.js";
+import { openLix } from "../lix/open-lix.js";
+
+test("it handles insert changes", async () => {
+	const lix = await openLix({
+		providePlugins: [mockJsonPlugin],
+	});
+	const before = new TextEncoder().encode(
+		JSON.stringify({
+			Name: "Anna",
+			Age: 20,
+		})
+	);
+	const after = new TextEncoder().encode(
+		JSON.stringify({
+			Name: "Anna",
+			Age: 20,
+			City: "Berlin",
+		})
+	);
+
+	// Insert the initial file
+	await lix.db
+		.insertInto("file")
+		.values({
+			id: "mock",
+			path: "/mock.json",
+			data: before,
+		})
+		.execute();
+
+	// Update the file with new data
+	await lix.db
+		.updateTable("file")
+		.set({ data: after })
+		.where("id", "=", "mock")
+		.execute();
+
+	const changes = await lix.db
+		.selectFrom("change")
+		.where("file_id", "=", "mock")
+		.where("plugin_key", "=", mockJsonPlugin.key)
+		.selectAll()
+		.execute();
+
+	const { fileData: applied } = mockJsonPlugin.applyChanges!({
+		file: { id: "mock", path: "/mock", data: before, metadata: {} },
+		changes,
+	});
+
+	expect(new TextDecoder().decode(applied)).toEqual(
+		new TextDecoder().decode(after)
+	);
+});
+
+test("it handles update changes", async () => {
+	const lix = await openLix({
+		providePlugins: [mockJsonPlugin],
+	});
+
+	const before = new TextEncoder().encode(
+		JSON.stringify({
+			Name: "Samuel",
+			City: "Berlin",
+		})
+	);
+	const after = new TextEncoder().encode(
+		JSON.stringify({
+			Name: "Samuel",
+			City: "New York",
+		})
+	);
+
+	// Insert the initial file
+	await lix.db
+		.insertInto("file")
+		.values({
+			id: "mock",
+			path: "/mock.json",
+			data: before,
+		})
+		.execute();
+
+	// Update the file with new data
+	await lix.db
+		.updateTable("file")
+		.set({ data: after })
+		.where("id", "=", "mock")
+		.execute();
+
+	const changes = await lix.db
+		.selectFrom("change")
+		.where("file_id", "=", "mock")
+		.where("plugin_key", "=", mockJsonPlugin.key)
+		.selectAll()
+		.execute();
+
+	const { fileData: applied } = mockJsonPlugin.applyChanges!({
+		file: { id: "mock", path: "/mock", data: before, metadata: {} },
+		changes,
+	});
+
+	expect(new TextDecoder().decode(applied)).toEqual(
+		new TextDecoder().decode(after)
+	);
+});
+
+test("it handles delete changes", async () => {
+	const lix = await openLix({
+		providePlugins: [mockJsonPlugin],
+	});
+
+	const before = new TextEncoder().encode(
+		JSON.stringify({
+			Name: "Samuel",
+			property_to_delete: "value",
+		})
+	);
+	const after = new TextEncoder().encode(
+		JSON.stringify({
+			Name: "Samuel",
+		})
+	);
+
+	// Insert the initial file
+	await lix.db
+		.insertInto("file")
+		.values({
+			id: "mock",
+			path: "/mock.json",
+			data: before,
+		})
+		.execute();
+
+	// Update the file with new data
+	await lix.db
+		.updateTable("file")
+		.set({ data: after })
+		.where("id", "=", "mock")
+		.execute();
+
+	const changes = await lix.db
+		.selectFrom("change")
+		.where("file_id", "=", "mock")
+		.where("plugin_key", "=", mockJsonPlugin.key)
+		.selectAll()
+		.execute();
+
+	const { fileData: applied } = await mockJsonPlugin.applyChanges!({
+		file: { id: "mock", path: "/mock", data: before, metadata: {} },
+		changes,
+	});
+
+	expect(new TextDecoder().decode(applied)).toEqual(
+		new TextDecoder().decode(after)
+	);
+});
+
+test("it handles nested properties and arrays", async () => {
+	const lix = await openLix({
+		providePlugins: [mockJsonPlugin],
+	});
+
+	const before = new TextEncoder().encode(
+		JSON.stringify({
+			nested: {
+				name: "Anna",
+				list: ["a", "b", "c"],
+			},
+		})
+	);
+	const after = new TextEncoder().encode(
+		JSON.stringify({
+			nested: {
+				name: "Peter",
+				list: ["a", "b", "c", "d"],
+			},
+		})
+	);
+
+	// Insert the initial file
+	await lix.db
+		.insertInto("file")
+		.values({
+			id: "mock",
+			path: "/mock.json",
+			data: before,
+		})
+		.execute();
+
+	// Update the file with new data
+	await lix.db
+		.updateTable("file")
+		.set({ data: after })
+		.where("id", "=", "mock")
+		.execute();
+
+	const changes = await lix.db
+		.selectFrom("change")
+		.where("file_id", "=", "mock")
+		.where("plugin_key", "=", mockJsonPlugin.key)
+		.selectAll()
+		.execute();
+
+	const { fileData: applied } = await mockJsonPlugin.applyChanges!({
+		file: { id: "mock", path: "/mock", data: before, metadata: {} },
+		changes,
+	});
+
+	expect(new TextDecoder().decode(applied)).toEqual(
+		new TextDecoder().decode(after)
+	);
+});

package/src/plugin/mock-json-plugin.ts

@@ -0,0 +1,113 @@
+import type { LixSchemaDefinition } from "../schema-definition/definition.js";
+import { JSONTypeSchema } from "../schema-definition/json-type.js";
+import type { DetectedChange, LixPlugin } from "./lix-plugin.js";
+import { flatten, unflatten } from "./mock-json-plugin.flatten.js";
+
+export const MockJsonPropertySchema: LixSchemaDefinition = {
+	type: "object",
+	properties: {
+		value: JSONTypeSchema,
+	},
+	required: ["value"],
+	"x-lix-key": "mock_json_property",
+	"x-lix-version": "1.0",
+} as const;
+
+/**
+ * A mock plugin that handles JSON data.
+ *
+ * Use this mock plugin for testing purposes. Do not
+ * use this plugin in production! It may change at
+ * any time.
+ *
+ * @example
+ *   const lix = await openLix({
+ *     providePlugins: [mockJsonPlugin],
+ *   });
+ */
+export const mockJsonPlugin: LixPlugin = {
+	key: "mock_json_plugin",
+	detectChangesGlob: "*.json",
+	detectChanges: ({ before, after }) => {
+		const detectedChanges: DetectedChange<any>[] = [];
+
+		const beforeParsed = before?.data
+			? JSON.parse(new TextDecoder().decode(before?.data))
+			: {};
+		const afterParsed = after?.data
+			? JSON.parse(new TextDecoder().decode(after?.data))
+			: {};
+
+		const flattenedBefore = flatten(beforeParsed, {
+			safe: true,
+		}) as Record<string, unknown>;
+		const flattenedAfter = flatten(afterParsed, {
+			safe: true,
+		}) as Record<string, unknown>;
+
+		for (const key in flattenedBefore) {
+			if (!(key in flattenedAfter)) {
+				detectedChanges.push({
+					schema: MockJsonPropertySchema,
+					entity_id: key,
+					snapshot_content: null, // Indicates deletion of this property
+				});
+			} else if (
+				JSON.stringify(flattenedBefore[key]) !==
+				JSON.stringify(flattenedAfter[key])
+			) {
+				detectedChanges.push({
+					schema: MockJsonPropertySchema,
+					entity_id: key,
+					snapshot_content: { value: flattenedAfter[key] },
+				});
+			}
+		}
+
+		for (const key in flattenedAfter) {
+			if (!(key in flattenedBefore)) {
+				detectedChanges.push({
+					schema: MockJsonPropertySchema,
+					entity_id: key,
+					snapshot_content: { value: flattenedAfter[key] },
+				});
+			}
+		}
+
+		return detectedChanges;
+	},
+	applyChanges: ({ file, changes }) => {
+		// Get the current state from the file data
+		let flattened: Record<string, any> = {};
+
+		if (file.data && file.data.length > 0) {
+			try {
+				flattened = flatten(JSON.parse(new TextDecoder().decode(file.data)), {
+					delimiter: ".",
+				});
+			} catch (error) {
+				// Handle potential parsing errors if the initial file data isn't valid JSON
+				console.error("Failed to parse existing file data:", error);
+			}
+		}
+
+		// Build a JSON object mapping entity_id to snapshot content
+		for (const change of changes) {
+			if (change.snapshot_content === null) {
+				// If the content is null, remove the entity from the state
+				delete flattened[change.entity_id];
+			} else {
+				// Update the current state with the new change content
+				// Need to decode the BLOB content from the snapshot
+				// The plugin should handle deserializing the object stored in the BLOB
+				flattened[change.entity_id] = (change.snapshot_content as any).value;
+			}
+		}
+
+		return {
+			fileData: new TextEncoder().encode(
+				JSON.stringify(unflatten(flattened, { delimiter: "." }))
+			),
+		};
+	},
+};

package/src/query-filter/change-has-label.test.ts

@@ -1,39 +1,66 @@
 import { test, expect } from "vitest";
 import { changeHasLabel } from "./change-has-label.js";
-import { openLixInMemory } from "../lix/open-lix-in-memory.js";
+import { openLix } from "../lix/open-lix.js";
 import { createChangeSet } from "../change-set/create-change-set.js";
 
 test("should only return changes with the given label", async () => {
-	const lix = await openLixInMemory({});
+	const lix = await openLix({});
 
 	await lix.db
+		.insertInto("stored_schema")
+		.values({
+			value: {
+				"x-lix-key": "mock_schema",
+				"x-lix-version": "1.0",
+				type: "object",
+			},
+		})
+		.execute();
+
+	const changes0 = await lix.db
 		.insertInto("change")
 		.values([
 			{
 				id: "change1",
-				snapshot_id: "no-content",
+				snapshot_content: null,
 				entity_id: "mock",
 				file_id: "mock",
+				schema_version: "1.0",
 				plugin_key: "mock",
-				schema_key: "mock",
+				schema_key: "mock_schema",
 			},
 			{
 				id: "change2",
-				snapshot_id: "no-content",
+				snapshot_content: null,
 				entity_id: "mock",
 				file_id: "mock",
+				schema_version: "1.0",
 				plugin_key: "mock",
-				schema_key: "mock",
+				schema_key: "mock_schema",
 			},
 		])
+		.returningAll()
 		.execute();
 
-	const set = await createChangeSet({ lix, changes: [{ id: "change1" }] });
+	const set = await createChangeSet({
+		lix,
+		elements: [
+			{
+				change_id: changes0[0]!.id,
+				entity_id: changes0[0]!.entity_id,
+				schema_key: changes0[0]!.schema_key,
+				file_id: changes0[0]!.file_id,
+			},
+		],
+		labels: [],
+	});
+
+	await lix.db.insertInto("label").values({ name: "mocked" }).execute();
 
 	const label = await lix.db
-		.insertInto("label")
-		.values({ name: "mocked" })
-		.returningAll()
+		.selectFrom("label")
+		.where("name", "=", "mocked")
+		.selectAll()
 		.executeTakeFirstOrThrow();
 
 	await lix.db
@@ -43,7 +70,7 @@ test("should only return changes with the given label", async () => {
 
 	const changes = await lix.db
 		.selectFrom("change")
-		.where(changeHasLabel("mocked"))
+		.where(changeHasLabel({ name: "mocked" }))
 		.selectAll()
 		.execute();
 

package/src/query-filter/change-has-label.ts

@@ -7,7 +7,7 @@ import type { LixDatabaseSchema } from "../database/schema.js";
  * @example
  *   ```ts
  *   await lix.db.selectFrom("change")
- *      .where(changeHasLabel("checkpoint"))
+ *      .where(changeHasLabel({ name: "checkpoint" }))
  *      .selectAll()
  *      .execute();
  *   ```
@@ -17,12 +17,15 @@ import type { LixDatabaseSchema } from "../database/schema.js";
  *
  *   ```ts
  *   await lix.db.selectFrom("change")
- * 		.where((eb) => eb.not(changeHasLabel("checkpoint")))
+ * 		.where((eb) => eb.not(changeHasLabel({ name: "checkpoint"})))
  * 		.selectAll()
  * 		.execute();
  *   ```
  */
-export function changeHasLabel(name: string) {
+export function changeHasLabel(
+	// lookup can happen via both id or name
+	label: { id: string; name?: string } | { name: string; id?: string }
+) {
 	return (
 		eb: ExpressionBuilder<LixDatabaseSchema, "change">
 	): ExpressionWrapper<LixDatabaseSchema, "change", SqlBool> =>
@@ -36,6 +39,7 @@ export function changeHasLabel(name: string) {
 				)
 				.innerJoin("label", "label.id", "change_set_label.label_id")
 				.select("change_set_element.change_id")
-				.where("label.name", "=", name)
+				.$if("name" in label, (eb) => eb.where("label.name", "=", label.name!))
+				.$if("id" in label, (eb) => eb.where("label.id", "=", label.id!))
 		);
 }