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

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

@@ -1,161 +0,0 @@
-// 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

@@ -1,225 +0,0 @@
-import { expect, test } from "vitest";
-import { mockJsonPlugin } from "./mock-json-plugin.js";
-import { openLix } from "../lix/open-lix.js";
-
-const createPluginFile = (data: Uint8Array) => ({
-	id: "mock",
-	path: "/mock.json",
-	data,
-	metadata: {},
-	directory_id: null,
-	name: "mock",
-	extension: "json",
-	hidden: false,
-});
-
-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: createPluginFile(before),
-		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: createPluginFile(before),
-		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: createPluginFile(before),
-		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: createPluginFile(before),
-		changes,
-	});
-
-	expect(new TextDecoder().decode(applied)).toEqual(
-		new TextDecoder().decode(after)
-	);
-});

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

@@ -1,114 +0,0 @@
-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"],
-	additionalProperties: false,
-	"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/plugin/query-sync.test.ts

@@ -1,132 +0,0 @@
-import { describe, test, expect } from "vitest";
-import { openLix } from "../lix/open-lix.js";
-import { createQuerySync } from "./query-sync.js";
-
-describe("querySync", () => {
-	test("builds Kysely-like query and executes synchronously", async () => {
-		const lix = await openLix({});
-
-		// Seed a value using normal async Kysely API
-		await lix.db
-			.insertInto("key_value")
-			.values({ key: "qsync_foo", value: { hello: "world" } })
-			.execute();
-
-		const querySync = createQuerySync({ engine: lix.engine! });
-
-		// Same Kysely QB chain, but .execute() is sync
-		const rows = querySync("key_value")
-			.where("key", "=", "qsync_foo")
-			.selectAll()
-			.execute();
-
-		expect(Array.isArray(rows)).toBe(true);
-		expect(rows).toHaveLength(1);
-		// Raw JSON string semantics (matches executeSync)
-		expect(typeof rows[0].value).toBe("string");
-		expect(JSON.parse(rows[0].value)).toEqual({ hello: "world" });
-	});
-
-	test("supports executeTakeFirst helpers", async () => {
-		const lix = await openLix({});
-		await lix.db
-			.insertInto("key_value")
-			.values({ key: "qsync_first", value: "ok" })
-			.execute();
-
-		const querySync = createQuerySync({ engine: lix.engine! });
-
-		const row = querySync("key_value")
-			.where("key", "=", "qsync_first")
-			.selectAll()
-			.executeTakeFirst();
-
-		expect(row).toMatchObject({ key: "qsync_first", value: "ok" });
-
-		const rowStrict = querySync("key_value")
-			.where("key", "=", "qsync_first")
-			.selectAll()
-			.executeTakeFirstOrThrow();
-
-		expect(rowStrict).toMatchObject({ key: "qsync_first", value: "ok" });
-	});
-
-	test("executeTakeFirstOrThrow throws when no result", async () => {
-		const lix = await openLix({});
-		const querySync = createQuerySync({ engine: lix.engine! });
-
-		expect(() =>
-			querySync("key_value")
-				.where("key", "=", "does_not_exist")
-				.selectAll()
-				.executeTakeFirstOrThrow()
-		).toThrow();
-	});
-
-	test("snapshot_content parsing matches async queries", async () => {
-		const lix = await openLix({});
-
-		// Create a file which will write a file descriptor snapshot into state
-		const active = await lix.db
-			.selectFrom("active_version")
-			.select("version_id")
-			.executeTakeFirstOrThrow();
-		const versionId = active.version_id as unknown as string;
-
-		// Insert via file handler path used by the engine typically
-		const file = {
-			id: "file_parse_test",
-			path: "/a.txt",
-			data: new Uint8Array(),
-			metadata: {},
-			directory_id: null,
-			name: "a",
-			extension: "txt",
-			hidden: false,
-		} as any;
-
-		// Use engine helper: write state_by_version row for file descriptor via Kysely
-		await lix.db
-			.insertInto("state_by_version")
-			.values({
-				entity_id: file.id,
-				schema_key: "lix_file_descriptor",
-				file_id: file.id,
-				plugin_key: "lix_sdk",
-				snapshot_content: {
-					id: file.id,
-					directory_id: file.directory_id,
-					name: file.name,
-					extension: file.extension,
-					metadata: file.metadata,
-					hidden: file.hidden,
-				},
-				schema_version: "1.0",
-				version_id: versionId,
-				untracked: false,
-			})
-			.execute();
-
-		// Async Kysely query (normal behavior) – already parsed
-		const asyncRow = await lix.db
-			.selectFrom("state")
-			.where("file_id", "=", file.id)
-			.where("schema_key", "=", "lix_file_descriptor")
-			.select(["entity_id", "schema_key", "snapshot_content"])
-			.executeTakeFirstOrThrow();
-
-		// querySync – should parse snapshot_content identically
-		const rowsSync = createQuerySync({ engine: lix.engine! })("state")
-			.where("file_id", "=", file.id)
-			.where("schema_key", "=", "lix_file_descriptor")
-			.select(["entity_id", "schema_key", "snapshot_content"])
-			.execute();
-
-		expect(rowsSync).toHaveLength(1);
-		const syncRow = rowsSync[0];
-
-		expect(syncRow.snapshot_content).toEqual(asyncRow.snapshot_content);
-		expect(typeof syncRow.snapshot_content).toBe("object");
-		expect(syncRow.schema_key).toBe("lix_file_descriptor");
-	});
-});