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

package/src/file/file-handlers.ts

@@ -0,0 +1,364 @@
+import { executeSync } from "../database/execute-sync.js";
+import type { LixFile } from "./schema.js";
+import { LixFileDescriptorSchema } from "./schema.js";
+import { createLixOwnLogSync } from "../log/create-lix-own-log.js";
+import type { Lix } from "../lix/open-lix.js";
+import { lixUnknownFileFallbackPlugin } from "./unknown-file-fallback-plugin.js";
+import { storeDetectedChangeSchema } from "./store-detected-change-schema.js";
+
+function globSync(args: {
+	lix: Pick<Lix, "sqlite">;
+	glob: string;
+	path: string;
+}): boolean {
+	const columnNames: string[] = [];
+	const result = args.lix.sqlite.exec({
+		sql: `SELECT CASE WHEN ? GLOB ? THEN 1 ELSE 0 END AS matches`,
+		bind: [args.path, args.glob],
+		returnValue: "resultRows",
+		columnNames,
+	});
+
+	return (result[0]?.[0] as any) === 1;
+}
+
+export function handleFileInsert(args: {
+	lix: Pick<Lix, "sqlite" | "plugin" | "db" | "hooks">;
+	file: LixFile;
+	versionId: string;
+	untracked?: boolean;
+}): 0 | 1 {
+	// Insert the file metadata into state table
+	executeSync({
+		lix: args.lix,
+		query: args.lix.db.insertInto("state_all").values({
+			entity_id: args.file.id,
+			schema_key: LixFileDescriptorSchema["x-lix-key"],
+			file_id: args.file.id,
+			plugin_key: "lix_own_entity",
+			snapshot_content: {
+				id: args.file.id,
+				path: args.file.path,
+				metadata: args.file.metadata || null,
+			},
+			schema_version: LixFileDescriptorSchema["x-lix-version"],
+			version_id: args.versionId,
+			untracked: args.untracked || false,
+		}),
+	});
+
+	const plugins = args.lix.plugin.getAllSync();
+	let foundPlugin = false;
+	let hasChanges = false;
+
+	for (const plugin of plugins) {
+		// Check if plugin glob matches file path
+		if (
+			!plugin.detectChangesGlob ||
+			!globSync({
+				lix: args.lix,
+				path: args.file.path,
+				glob: plugin.detectChangesGlob,
+			})
+		) {
+			continue;
+		}
+
+		foundPlugin = true;
+
+		if (plugin.detectChanges === undefined) {
+			createLixOwnLogSync({
+				lix: args.lix,
+				key: "lix_file_no_plugin",
+				level: "warn",
+				message: `File inserted at ${args.file.path} but plugin does not support detecting changes`,
+			});
+			continue;
+		}
+
+		// Detect changes with the plugin
+		const detectedChanges = plugin.detectChanges({
+			after: args.file,
+		});
+
+		if (detectedChanges.length > 0) {
+			hasChanges = true;
+			// Validate and store schemas for all detected changes
+			for (const change of detectedChanges) {
+				storeDetectedChangeSchema({
+					lix: args.lix,
+					schema: change.schema,
+					untracked: args.untracked || false,
+				});
+			}
+
+			// Store plugin detected changes in state table
+			for (const change of detectedChanges) {
+				executeSync({
+					lix: args.lix,
+					query: args.lix.db.insertInto("state_all").values({
+						entity_id: change.entity_id,
+						schema_key: change.schema["x-lix-key"],
+						file_id: args.file.id,
+						plugin_key: plugin.key,
+						snapshot_content: change.snapshot_content as any,
+						schema_version: change.schema["x-lix-version"],
+						version_id: args.versionId,
+						untracked: args.untracked || false,
+					}),
+				});
+			}
+		}
+	}
+
+	// Log appropriate messages based on what happened
+	if (!foundPlugin) {
+		createLixOwnLogSync({
+			lix: args.lix,
+			key: "lix_file_no_plugin",
+			level: "warn",
+			message: `File inserted at ${args.file.path} but no plugin available to detect changes`,
+		});
+
+		// Use fallback plugin to handle the file
+		if (lixUnknownFileFallbackPlugin.detectChanges) {
+			const detectedChanges = lixUnknownFileFallbackPlugin.detectChanges({
+				after: args.file,
+			});
+
+			if (detectedChanges.length > 0) {
+				// Validate and store schemas for fallback plugin changes
+				for (const change of detectedChanges) {
+					storeDetectedChangeSchema({
+						lix: args.lix,
+						schema: change.schema,
+					});
+				}
+
+				for (const change of detectedChanges) {
+					executeSync({
+						lix: args.lix,
+						query: args.lix.db.insertInto("state_all").values({
+							entity_id: change.entity_id,
+							schema_key: change.schema["x-lix-key"],
+							file_id: args.file.id,
+							plugin_key: lixUnknownFileFallbackPlugin.key,
+							snapshot_content: change.snapshot_content as any,
+							schema_version: change.schema["x-lix-version"],
+							version_id: args.versionId,
+							untracked: args.untracked || false,
+						}),
+					});
+				}
+			}
+		}
+	} else {
+		if (!hasChanges) {
+			createLixOwnLogSync({
+				lix: args.lix,
+				key: "lix_file_no_changes_detected",
+				level: "debug",
+				message: `File inserted at ${args.file.path} but plugin detected no changes`,
+			});
+		}
+		// Do NOT invoke fallback plugin if a plugin was found, even if it returned no changes
+	}
+
+	// Emit file change event
+	args.lix.hooks._emit("file_change", {
+		fileId: args.file.id,
+		operation: "inserted",
+	});
+
+	return 0;
+}
+
+export function handleFileUpdate(args: {
+	lix: Pick<Lix, "sqlite" | "plugin" | "db" | "hooks">;
+	file: LixFile;
+	versionId: string;
+	untracked?: boolean;
+}): 0 | 1 {
+	// Update the file metadata in state table
+	executeSync({
+		lix: args.lix,
+		query: args.lix.db
+			.updateTable("state_all")
+			.set({
+				snapshot_content: {
+					id: args.file.id,
+					path: args.file.path,
+					metadata: args.file.metadata || null,
+				},
+				untracked: args.untracked || false,
+			})
+			.where("entity_id", "=", args.file.id)
+			.where("schema_key", "=", "lix_file_descriptor")
+			.where("version_id", "=", args.versionId),
+	});
+
+	// Get current file data for comparison
+	const currentFile = executeSync({
+		lix: args.lix,
+		query: args.lix.db
+			.selectFrom("file_all")
+			.where("id", "=", args.file.id)
+			.where("lixcol_version_id", "=", args.versionId)
+			.selectAll(),
+	})[0] as LixFile | undefined;
+
+	if (currentFile) {
+		const plugins = args.lix.plugin.getAllSync();
+		let foundPlugin = false;
+		let hasChanges = false;
+
+		for (const plugin of plugins) {
+			// Check if plugin glob matches file path
+			if (
+				!plugin.detectChangesGlob ||
+				!globSync({
+					lix: args.lix,
+					path: args.file.path,
+					glob: plugin.detectChangesGlob,
+				})
+			) {
+				continue;
+			}
+
+			foundPlugin = true;
+
+			if (plugin.detectChanges === undefined) {
+				createLixOwnLogSync({
+					lix: args.lix,
+					key: "lix_file_no_plugin",
+					level: "warn",
+					message: `File updated at ${args.file.path} but plugin does not support detecting changes`,
+				});
+				continue;
+			}
+
+			// Detect changes between current and updated file
+			const detectedChanges = plugin.detectChanges({
+				before: currentFile,
+				after: args.file,
+			});
+
+			if (detectedChanges.length > 0) {
+				hasChanges = true;
+				// Validate and store schemas for all detected changes
+				for (const change of detectedChanges) {
+					storeDetectedChangeSchema({
+						lix: args.lix,
+						schema: change.schema,
+						untracked: args.untracked || false,
+					});
+				}
+
+				// Update plugin detected changes in state table
+				for (const change of detectedChanges) {
+					if (change.snapshot_content === null) {
+						// Handle deletion: remove the entity from state table
+						executeSync({
+							lix: args.lix,
+							query: args.lix.db
+								.deleteFrom("state_all")
+								.where("entity_id", "=", change.entity_id)
+								.where("schema_key", "=", change.schema["x-lix-key"])
+								.where("file_id", "=", args.file.id)
+								.where("version_id", "=", args.versionId),
+						});
+					} else {
+						// Handle update/insert: upsert the entity in state table
+						executeSync({
+							lix: args.lix,
+							query: args.lix.db.insertInto("state_all").values({
+								entity_id: change.entity_id,
+								schema_key: change.schema["x-lix-key"],
+								file_id: args.file.id,
+								plugin_key: plugin.key,
+								snapshot_content: change.snapshot_content as any,
+								schema_version: change.schema["x-lix-version"],
+								version_id: args.versionId,
+								untracked: args.untracked || false,
+							}),
+						});
+					}
+				}
+			}
+		}
+
+		// Log appropriate messages based on what happened
+		if (!foundPlugin) {
+			createLixOwnLogSync({
+				lix: args.lix,
+				key: "lix_file_no_plugin",
+				level: "warn",
+				message: `File updated at ${args.file.path} but no plugin available to detect changes`,
+			});
+
+			// Use fallback plugin to handle the file
+			if (lixUnknownFileFallbackPlugin.detectChanges) {
+				const detectedChanges = lixUnknownFileFallbackPlugin.detectChanges({
+					before: currentFile,
+					after: args.file,
+				});
+
+				if (detectedChanges.length > 0) {
+					// Validate and store schemas for fallback plugin changes
+					for (const change of detectedChanges) {
+						storeDetectedChangeSchema({
+							lix: args.lix,
+							schema: change.schema,
+							untracked: args.untracked || false,
+						});
+					}
+
+					for (const change of detectedChanges) {
+						if (change.snapshot_content === null) {
+							// Handle deletion: remove the entity from state table
+							executeSync({
+								lix: args.lix,
+								query: args.lix.db
+									.deleteFrom("state_all")
+									.where("entity_id", "=", change.entity_id)
+									.where("schema_key", "=", change.schema["x-lix-key"])
+									.where("file_id", "=", args.file.id)
+									.where("version_id", "=", args.versionId),
+							});
+						} else {
+							// Handle update/insert: upsert the entity in state table
+							executeSync({
+								lix: args.lix,
+								query: args.lix.db.insertInto("state_all").values({
+									entity_id: change.entity_id,
+									schema_key: change.schema["x-lix-key"],
+									file_id: args.file.id,
+									plugin_key: lixUnknownFileFallbackPlugin.key,
+									snapshot_content: change.snapshot_content as any,
+									schema_version: change.schema["x-lix-version"],
+									version_id: args.versionId,
+									untracked: args.untracked || false,
+								}),
+							});
+						}
+					}
+				}
+			}
+		} else if (!hasChanges) {
+			createLixOwnLogSync({
+				lix: args.lix,
+				key: "lix_file_no_changes_detected",
+				level: "debug",
+				message: `File updated at ${args.file.path} but plugin detected no changes`,
+			});
+		}
+	}
+
+	// Emit file change event
+	args.lix.hooks._emit("file_change", {
+		fileId: args.file.id,
+		operation: "updated",
+	});
+
+	return 0;
+}

package/src/file/index.ts

@@ -1 +1,5 @@
-export { validateFilePath, isValidFilePath } from "./validate-file-path.js";
+export {
+	LixFileDescriptorSchema,
+	type LixFileDescriptor,
+	type LixFile,
+} from "./schema.js";

package/src/file/materialize-file-data-at-changeset.ts

@@ -0,0 +1,123 @@
+import { executeSync } from "../database/execute-sync.js";
+import type { Lix } from "../lix/open-lix.js";
+import type { LixFile } from "./schema.js";
+import { lixUnknownFileFallbackPlugin } from "./unknown-file-fallback-plugin.js";
+
+function globSync(args: {
+	lix: Pick<Lix, "sqlite">;
+	glob: string;
+	path: string;
+}): boolean {
+	const columnNames: string[] = [];
+	const result = args.lix.sqlite.exec({
+		sql: `SELECT CASE WHEN ? GLOB ? THEN 1 ELSE 0 END AS matches`,
+		bind: [args.path, args.glob],
+		returnValue: "resultRows",
+		columnNames,
+	});
+
+	return (result[0]?.[0] as any) === 1;
+}
+
+export function materializeFileDataAtChangeset(args: {
+	lix: Pick<Lix, "sqlite" | "plugin" | "db">;
+	file: Omit<LixFile, "data">;
+	changeSetId: string;
+	depth: number;
+}): Uint8Array {
+	const plugins = args.lix.plugin.getAllSync();
+
+	// First, try to find a specific plugin that can handle this file (excluding fallback)
+	for (const plugin of plugins) {
+		if (
+			!plugin.detectChangesGlob ||
+			!globSync({
+				lix: args.lix,
+				path: args.file.path,
+				glob: plugin.detectChangesGlob,
+			})
+		) {
+			continue;
+		}
+
+		if (!plugin.applyChanges) {
+			continue;
+		}
+
+		// Get plugin changes from state_history table
+		const changes = executeSync({
+			lix: args.lix,
+			query: args.lix.db
+				.selectFrom("state_history")
+				.where("plugin_key", "=", plugin.key)
+				.where("file_id", "=", args.file.id)
+				.where("change_set_id", "=", args.changeSetId)
+				.where("depth", "=", args.depth)
+				.select([
+					"entity_id",
+					"schema_key",
+					"file_id",
+					"plugin_key",
+					"snapshot_content",
+					"change_set_id as version_id", // Map to maintain compatibility
+				]),
+		});
+
+		// Format changes for plugin
+		const formattedChanges = changes.map((change) => ({
+			...change,
+			snapshot_content:
+				typeof change.snapshot_content === "string"
+					? JSON.parse(change.snapshot_content)
+					: change.snapshot_content,
+		}));
+
+		const file = plugin.applyChanges({
+			file: args.file,
+			changes: formattedChanges,
+		});
+
+		return file.fileData;
+	}
+
+	// If no specific plugin matched, use the fallback plugin
+	const changes = executeSync({
+		lix: args.lix,
+		query: args.lix.db
+			.selectFrom("state_history")
+			.where("plugin_key", "=", lixUnknownFileFallbackPlugin.key)
+			.where("file_id", "=", args.file.id)
+			.where("change_set_id", "=", args.changeSetId)
+			.where("depth", "=", args.depth)
+			.select([
+				"entity_id",
+				"schema_key",
+				"file_id",
+				"plugin_key",
+				"snapshot_content",
+				"change_set_id as version_id", // Map to maintain compatibility
+			]),
+	});
+
+	// Format changes for plugin
+	const formattedChanges = changes.map((change) => ({
+		...change,
+		snapshot_content:
+			typeof change.snapshot_content === "string"
+				? JSON.parse(change.snapshot_content)
+				: change.snapshot_content,
+	}));
+
+	if (formattedChanges.length === 0) {
+		throw new Error(
+			`[materializeFileDataAtChangeset] No changes found for file ${args.file.id} with plugin ${lixUnknownFileFallbackPlugin.key} at changeset ${args.changeSetId} depth ${args.depth}. Cannot materialize file data.`
+		);
+	}
+
+	const file = lixUnknownFileFallbackPlugin.applyChanges!({
+		file: args.file,
+		changes: formattedChanges,
+	});
+
+	return file.fileData;
+}

package/src/file/materialize-file-data.test.ts

@@ -0,0 +1,107 @@
+import { test, expect } from "vitest";
+import { openLix } from "../lix/open-lix.js";
+import { materializeFileData } from "./materialize-file-data.js";
+import type { LixPlugin } from "../plugin/lix-plugin.js";
+
+test("materializeFileData with plugin that has changes", async () => {
+	const mockPlugin: LixPlugin = {
+		key: "test-plugin-2",
+		detectChangesGlob: "*.txt",
+		detectChanges: () => [],
+		applyChanges: ({ changes }) => {
+			// Create content based on the changes
+			const changeIds = changes.map((c) => c.entity_id).join(",");
+			return {
+				fileData: new TextEncoder().encode(`processed-${changeIds}`),
+			};
+		},
+	};
+
+	const lix = await openLix({
+		providePlugins: [mockPlugin],
+	});
+
+	const activeVersion = await lix.db
+		.selectFrom("active_version")
+		.select("version_id")
+		.executeTakeFirstOrThrow();
+
+	// Insert a file
+	await lix.db
+		.insertInto("file")
+		.values({
+			id: "test-file-2",
+			data: new TextEncoder().encode("initial-data"),
+			path: "/test.txt",
+		})
+		.execute();
+
+	// Manually insert some state data to simulate plugin changes
+	await lix.db
+		.insertInto("state_all")
+		.values({
+			entity_id: "entity1",
+			schema_key: "test_schema",
+			file_id: "test-file-2",
+			plugin_key: "test-plugin-2",
+			snapshot_content: { value: "test-content" },
+			schema_version: "1.0",
+			version_id: activeVersion.version_id,
+		})
+		.execute();
+
+	const file = await lix.db
+		.selectFrom("file")
+		.where("id", "=", "test-file-2")
+		.selectAll()
+		.executeTakeFirstOrThrow();
+
+	// Test that materializeFileData processes the changes
+	const result = materializeFileData({
+		lix,
+		file: {
+			id: file.id,
+			path: file.path,
+			metadata: file.metadata,
+		},
+		versionId: activeVersion.version_id,
+	});
+
+	expect(result).toBeInstanceOf(Uint8Array);
+	expect(new TextDecoder().decode(result)).toBe("processed-entity1");
+});
+
+test("materializeFileData throws when plugin has no applyChanges", async () => {
+	const mockPlugin: LixPlugin = {
+		key: "test-plugin-no-apply",
+		detectChangesGlob: "*.txt",
+		detectChanges: () => [],
+		// No applyChanges method - this should cause materialization to fail
+	};
+
+	const lix = await openLix({
+		providePlugins: [mockPlugin],
+	});
+
+	// Insert a file that the plugin will match but cannot materialize
+	await lix.db
+		.insertInto("file")
+		.values({
+			id: "test-file-no-apply",
+			data: new TextEncoder().encode("initial-data"),
+			path: "/test.txt",
+		})
+		.execute();
+
+	// Test that selecting the file throws when plugin cannot materialize
+	await expect(
+		async () =>
+			await lix.db
+				.selectFrom("file")
+				.where("id", "=", "test-file-no-apply")
+				.selectAll()
+				.executeTakeFirstOrThrow()
+	).rejects.toThrow(
+		"[materializeFileData] No changes found for file test-file-no-apply with plugin lix_unknown_file_fallback_plugin. Cannot materialize file data."
+	);
+});