@aigne/afs-sqlite 1.1.0-beta.1 → 1.11.0-beta

package/dist/index.cjs

@@ -0,0 +1,1324 @@
+let _aigne_sqlite = require("@aigne/sqlite");
+let _aigne_afs = require("@aigne/afs");
+let zod = require("zod");
+let radix3 = require("radix3");
+
+//#region src/actions/built-in.ts
+/**
+* Executes a raw SQL query and returns all rows
+*/
+async function execAll$3(db, query) {
+	return db.all(_aigne_sqlite.sql.raw(query)).execute();
+}
+/**
+* Executes a raw SQL query (for INSERT, UPDATE, DELETE)
+*/
+async function execRun$2(db, query) {
+	await db.run(_aigne_sqlite.sql.raw(query)).execute();
+}
+/**
+* Registers built-in actions to the registry
+*/
+function registerBuiltInActions(registry) {
+	registry.register({
+		name: "refresh",
+		description: "Refresh the schema cache for this module",
+		tableLevel: true,
+		rowLevel: false,
+		handler: async (ctx) => {
+			await ctx.module.refreshSchema();
+			return {
+				success: true,
+				message: "Schema refreshed successfully"
+			};
+		}
+	});
+	registry.register({
+		name: "export",
+		description: "Export table data in specified format (json, csv)",
+		tableLevel: true,
+		rowLevel: false,
+		inputSchema: {
+			type: "object",
+			properties: { format: {
+				type: "string",
+				enum: ["json", "csv"],
+				default: "json"
+			} }
+		},
+		handler: async (ctx, params) => {
+			const format = params.format ?? "json";
+			return {
+				success: true,
+				data: await ctx.module.exportTable(ctx.table, format)
+			};
+		}
+	});
+	registry.register({
+		name: "count",
+		description: "Get the total row count for this table",
+		tableLevel: true,
+		rowLevel: false,
+		handler: async (ctx) => {
+			return {
+				success: true,
+				data: { count: (await execAll$3(ctx.db, `SELECT COUNT(*) as count FROM "${ctx.table}"`))[0]?.count ?? 0 }
+			};
+		}
+	});
+	registry.register({
+		name: "duplicate",
+		description: "Create a copy of this row",
+		tableLevel: false,
+		rowLevel: true,
+		handler: async (ctx) => {
+			if (!ctx.row) return {
+				success: false,
+				message: "Row data not available"
+			};
+			const schema = ctx.schemas.get(ctx.table);
+			if (!schema) return {
+				success: false,
+				message: `Table '${ctx.table}' not found`
+			};
+			const pkColumn = schema.primaryKey[0] ?? "rowid";
+			const rowCopy = { ...ctx.row };
+			delete rowCopy[pkColumn];
+			delete rowCopy.rowid;
+			const columns = Object.keys(rowCopy);
+			const values = columns.map((col) => formatValueForSQL(rowCopy[col]));
+			await execRun$2(ctx.db, `INSERT INTO "${ctx.table}" (${columns.map((c) => `"${c}"`).join(", ")}) VALUES (${values.join(", ")})`);
+			return {
+				success: true,
+				data: { newId: (await execAll$3(ctx.db, "SELECT last_insert_rowid() as id"))[0]?.id },
+				message: "Row duplicated successfully"
+			};
+		}
+	});
+	registry.register({
+		name: "validate",
+		description: "Validate row data against schema constraints",
+		tableLevel: false,
+		rowLevel: true,
+		handler: async (ctx) => {
+			if (!ctx.row) return {
+				success: false,
+				message: "Row data not available"
+			};
+			const schema = ctx.schemas.get(ctx.table);
+			if (!schema) return {
+				success: false,
+				message: `Table '${ctx.table}' not found`
+			};
+			const errors = [];
+			for (const col of schema.columns) if (col.notnull && (ctx.row[col.name] === null || ctx.row[col.name] === void 0)) errors.push(`Column '${col.name}' cannot be null`);
+			for (const fk of schema.foreignKeys) {
+				const value = ctx.row[fk.from];
+				if (value !== null && value !== void 0) {
+					if ((await execAll$3(ctx.db, `SELECT COUNT(*) as count FROM "${fk.table}" WHERE "${fk.to}" = '${String(value).replace(/'/g, "''")}'`))[0]?.count === 0) errors.push(`Foreign key violation: ${fk.from} references non-existent ${fk.table}.${fk.to}`);
+				}
+			}
+			return {
+				success: errors.length === 0,
+				data: {
+					errors,
+					valid: errors.length === 0
+				},
+				message: errors.length > 0 ? `Validation failed: ${errors.join("; ")}` : "Row is valid"
+			};
+		}
+	});
+}
+/**
+* Formats a value for SQL insertion
+*/
+function formatValueForSQL(value) {
+	if (value === null || value === void 0) return "NULL";
+	if (typeof value === "number") return String(value);
+	if (typeof value === "boolean") return value ? "1" : "0";
+	if (value instanceof Date) return `'${value.toISOString()}'`;
+	if (typeof value === "object") return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+	return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+//#endregion
+//#region src/actions/registry.ts
+/**
+* Registry for managing action handlers
+*/
+var ActionsRegistry = class {
+	handlers = /* @__PURE__ */ new Map();
+	/**
+	* Registers an action handler
+	*/
+	register(definition) {
+		this.handlers.set(definition.name, definition);
+	}
+	/**
+	* Registers a simple action with just name and handler
+	*/
+	registerSimple(name, handler, options) {
+		this.register({
+			name,
+			handler,
+			description: options?.description,
+			tableLevel: options?.tableLevel ?? false,
+			rowLevel: options?.rowLevel ?? true
+		});
+	}
+	/**
+	* Unregisters an action
+	*/
+	unregister(name) {
+		return this.handlers.delete(name);
+	}
+	/**
+	* Checks if an action is registered
+	*/
+	has(name) {
+		return this.handlers.has(name);
+	}
+	/**
+	* Gets an action definition
+	*/
+	get(name) {
+		return this.handlers.get(name);
+	}
+	/**
+	* Lists all registered actions
+	*/
+	list(options) {
+		const actions = Array.from(this.handlers.values());
+		if (options?.tableLevel !== void 0 || options?.rowLevel !== void 0) return actions.filter((a) => {
+			if (options.tableLevel && !a.tableLevel) return false;
+			if (options.rowLevel && !a.rowLevel) return false;
+			return true;
+		});
+		return actions;
+	}
+	/**
+	* Lists action names
+	*/
+	listNames(options) {
+		return this.list(options).map((a) => a.name);
+	}
+	/**
+	* Executes an action
+	*/
+	async execute(name, ctx, params = {}) {
+		const definition = this.handlers.get(name);
+		if (!definition) return {
+			success: false,
+			message: `Unknown action: ${name}`
+		};
+		if (ctx.pk && !definition.rowLevel) return {
+			success: false,
+			message: `Action '${name}' is not available at row level`
+		};
+		if (!ctx.pk && !definition.tableLevel) return {
+			success: false,
+			message: `Action '${name}' is not available at table level`
+		};
+		try {
+			return await definition.handler(ctx, params);
+		} catch (error) {
+			return {
+				success: false,
+				message: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}
+};
+
+//#endregion
+//#region src/config.ts
+/**
+* FTS (Full-Text Search) configuration schema
+*/
+const ftsConfigSchema = zod.z.object({
+	enabled: zod.z.boolean().default(true).describe("Whether FTS is enabled"),
+	tables: zod.z.record(zod.z.array(zod.z.string())).optional().describe("Map of table name to columns to index for FTS")
+}).optional();
+/**
+* SQLite AFS module configuration schema
+*/
+const sqliteAFSConfigSchema = zod.z.object({
+	url: zod.z.string().describe("SQLite database URL (file:./path or :memory:)"),
+	name: zod.z.string().optional().describe("Module name, defaults to 'sqlite-afs'"),
+	description: zod.z.string().optional().describe("Description of this module"),
+	accessMode: _aigne_afs.accessModeSchema,
+	tables: zod.z.array(zod.z.string()).optional().describe("Whitelist of tables to expose (if not specified, all tables are exposed)"),
+	excludeTables: zod.z.array(zod.z.string()).optional().describe("Tables to exclude from exposure"),
+	fts: ftsConfigSchema,
+	wal: zod.z.boolean().optional().default(true).describe("Enable WAL mode for better concurrency")
+});
+
+//#endregion
+//#region src/node/builder.ts
+/**
+* Builds an AFSEntry from a database row
+*/
+function buildRowEntry(table, schema, row, options) {
+	const pkColumn = schema.primaryKey[0] ?? "rowid";
+	const pk = String(row[pkColumn] ?? row.rowid);
+	const basePath = options?.basePath ?? "";
+	return {
+		id: `${table}:${pk}`,
+		path: `${basePath}/${table}/${pk}`,
+		content: row,
+		metadata: {
+			table,
+			primaryKey: pkColumn,
+			primaryKeyValue: pk
+		},
+		createdAt: parseDate(row.created_at ?? row.createdAt),
+		updatedAt: parseDate(row.updated_at ?? row.updatedAt)
+	};
+}
+/**
+* Builds an AFSEntry for a table listing
+*/
+function buildTableEntry(table, schema, options) {
+	return {
+		id: table,
+		path: `${options?.basePath ?? ""}/${table}`,
+		description: `Table: ${table} (${schema.columns.length} columns)`,
+		metadata: {
+			table,
+			columnCount: schema.columns.length,
+			primaryKey: schema.primaryKey,
+			childrenCount: options?.rowCount
+		}
+	};
+}
+/**
+* Builds an AFSEntry for table schema
+*/
+function buildSchemaEntry(table, schema, options) {
+	const basePath = options?.basePath ?? "";
+	return {
+		id: `${table}:@schema`,
+		path: `${basePath}/${table}/@schema`,
+		description: `Schema for table: ${table}`,
+		content: {
+			name: schema.name,
+			columns: schema.columns.map((col) => ({
+				name: col.name,
+				type: col.type,
+				nullable: !col.notnull,
+				primaryKey: col.pk > 0,
+				defaultValue: col.dfltValue
+			})),
+			primaryKey: schema.primaryKey,
+			foreignKeys: schema.foreignKeys.map((fk) => ({
+				column: fk.from,
+				references: {
+					table: fk.table,
+					column: fk.to
+				},
+				onUpdate: fk.onUpdate,
+				onDelete: fk.onDelete
+			})),
+			indexes: schema.indexes.map((idx) => ({
+				name: idx.name,
+				unique: idx.unique,
+				origin: idx.origin
+			}))
+		},
+		metadata: {
+			table,
+			type: "schema"
+		}
+	};
+}
+/**
+* Builds an AFSEntry for an attribute (single column value)
+*/
+function buildAttributeEntry(table, pk, column, value, options) {
+	const basePath = options?.basePath ?? "";
+	return {
+		id: `${table}:${pk}:@attr:${column}`,
+		path: `${basePath}/${table}/${pk}/@attr/${column}`,
+		content: value,
+		metadata: {
+			table,
+			primaryKeyValue: pk,
+			column,
+			type: "attribute"
+		}
+	};
+}
+/**
+* Builds an AFSEntry listing all attributes for a row
+*/
+function buildAttributeListEntry(table, schema, pk, row, options) {
+	const basePath = options?.basePath ?? "";
+	return schema.columns.map((col) => ({
+		id: `${table}:${pk}:@attr:${col.name}`,
+		path: `${basePath}/${table}/${pk}/@attr/${col.name}`,
+		summary: col.name,
+		description: `${col.type}${col.notnull ? " NOT NULL" : ""}`,
+		content: row[col.name],
+		metadata: {
+			column: col.name,
+			type: col.type
+		}
+	}));
+}
+/**
+* Builds an AFSEntry for row metadata
+*/
+function buildMetaEntry(table, schema, pk, row, options) {
+	const basePath = options?.basePath ?? "";
+	return {
+		id: `${table}:${pk}:@meta`,
+		path: `${basePath}/${table}/${pk}/@meta`,
+		content: {
+			table,
+			primaryKey: schema.primaryKey[0] ?? "rowid",
+			primaryKeyValue: pk,
+			schema: {
+				columns: schema.columns.map((c) => c.name),
+				types: Object.fromEntries(schema.columns.map((c) => [c.name, c.type]))
+			},
+			foreignKeys: schema.foreignKeys.filter((fk) => Object.keys(row).includes(fk.from)),
+			rowid: row.rowid
+		},
+		metadata: {
+			table,
+			type: "meta"
+		}
+	};
+}
+/**
+* Builds AFSEntry for actions list
+*/
+function buildActionsListEntry(table, pk, actions, options) {
+	const basePath = options?.basePath ?? "";
+	return actions.map((action) => ({
+		id: `${table}:${pk}:@actions:${action}`,
+		path: `${basePath}/${table}/${pk}/@actions/${action}`,
+		summary: action,
+		metadata: { execute: {
+			name: action,
+			description: `Execute ${action} action on ${table}:${pk}`
+		} }
+	}));
+}
+/**
+* Builds a search result entry with highlights
+*/
+function buildSearchEntry(table, schema, row, snippet, options) {
+	const entry = buildRowEntry(table, schema, row, options);
+	if (snippet) entry.summary = snippet;
+	return entry;
+}
+/**
+* Parses a date from various formats
+*/
+function parseDate(value) {
+	if (!value) return void 0;
+	if (value instanceof Date) return value;
+	if (typeof value === "string") return new Date(value);
+	if (typeof value === "number") return new Date(value);
+}
+
+//#endregion
+//#region src/operations/query-builder.ts
+/**
+* Builds a SELECT query string for a single row by primary key
+*/
+function buildSelectByPK(tableName, schema, pk) {
+	return `SELECT * FROM "${tableName}" WHERE "${schema.primaryKey[0] ?? "rowid"}" = '${escapeSQLString(pk)}'`;
+}
+/**
+* Builds a SELECT query string for listing rows with optional limit and offset
+*/
+function buildSelectAll(tableName, options) {
+	let query = `SELECT * FROM "${tableName}"`;
+	if (options?.orderBy?.length) {
+		const orderClauses = options.orderBy.map(([col, dir]) => `"${col}" ${dir.toUpperCase()}`);
+		query += ` ORDER BY ${orderClauses.join(", ")}`;
+	}
+	if (options?.limit !== void 0) query += ` LIMIT ${options.limit}`;
+	if (options?.offset !== void 0) query += ` OFFSET ${options.offset}`;
+	return query;
+}
+/**
+* Builds an INSERT query string from content object
+*/
+function buildInsert(tableName, schema, content) {
+	const validColumns = new Set(schema.columns.map((c) => c.name));
+	const entries = Object.entries(content).filter(([key]) => validColumns.has(key));
+	if (entries.length === 0) throw new Error(`No valid columns provided for INSERT into ${tableName}`);
+	return `INSERT INTO "${tableName}" (${entries.map(([key]) => `"${key}"`).join(", ")}) VALUES (${entries.map(([, value]) => formatValue(value)).join(", ")})`;
+}
+/**
+* Builds an UPDATE query string from content object
+*/
+function buildUpdate(tableName, schema, pk, content) {
+	const pkColumn = schema.primaryKey[0] ?? "rowid";
+	const validColumns = new Set(schema.columns.map((c) => c.name));
+	const entries = Object.entries(content).filter(([key]) => validColumns.has(key) && key !== pkColumn);
+	if (entries.length === 0) throw new Error(`No valid columns provided for UPDATE on ${tableName}`);
+	return `UPDATE "${tableName}" SET ${entries.map(([key, value]) => `"${key}" = ${formatValue(value)}`).join(", ")} WHERE "${pkColumn}" = '${escapeSQLString(pk)}'`;
+}
+/**
+* Builds a DELETE query string by primary key
+*/
+function buildDelete(tableName, schema, pk) {
+	return `DELETE FROM "${tableName}" WHERE "${schema.primaryKey[0] ?? "rowid"}" = '${escapeSQLString(pk)}'`;
+}
+/**
+* Formats a value for SQL insertion
+*/
+function formatValue(value) {
+	if (value === null || value === void 0) return "NULL";
+	if (typeof value === "number") return String(value);
+	if (typeof value === "boolean") return value ? "1" : "0";
+	if (value instanceof Date) return `'${value.toISOString()}'`;
+	if (typeof value === "object") return `'${escapeSQLString(JSON.stringify(value))}'`;
+	return `'${escapeSQLString(String(value))}'`;
+}
+/**
+* Escapes a string for safe SQL insertion
+*/
+function escapeSQLString(str) {
+	return str.replace(/'/g, "''");
+}
+/**
+* Gets the last inserted rowid query string
+*/
+function buildGetLastRowId() {
+	return "SELECT last_insert_rowid() as id";
+}
+
+//#endregion
+//#region src/operations/crud.ts
+/**
+* Executes a raw SQL query and returns all rows
+*/
+async function execAll$2(db, query) {
+	return db.all(_aigne_sqlite.sql.raw(query)).execute();
+}
+/**
+* Executes a raw SQL query (for INSERT, UPDATE, DELETE)
+*/
+async function execRun$1(db, query) {
+	await db.run(_aigne_sqlite.sql.raw(query)).execute();
+}
+/**
+* CRUD operations for SQLite AFS
+*/
+var CRUDOperations = class {
+	constructor(db, schemas, basePath = "") {
+		this.db = db;
+		this.schemas = schemas;
+		this.basePath = basePath;
+	}
+	/**
+	* Lists all tables
+	*/
+	async listTables() {
+		const entries = [];
+		const buildOptions = { basePath: this.basePath };
+		for (const [name, schema] of this.schemas) {
+			const rowCount = (await execAll$2(this.db, `SELECT COUNT(*) as count FROM "${name}"`))[0]?.count ?? 0;
+			entries.push(buildTableEntry(name, schema, {
+				...buildOptions,
+				rowCount
+			}));
+		}
+		return { data: entries };
+	}
+	/**
+	* Lists rows in a table
+	*/
+	async listTable(table, options) {
+		const schema = this.schemas.get(table);
+		if (!schema) return {
+			data: [],
+			message: `Table '${table}' not found`
+		};
+		const buildOptions = { basePath: this.basePath };
+		const queryStr = buildSelectAll(table, {
+			limit: options?.limit ?? 100,
+			orderBy: options?.orderBy
+		});
+		return { data: (await execAll$2(this.db, queryStr)).map((row) => buildRowEntry(table, schema, row, buildOptions)) };
+	}
+	/**
+	* Reads a single row by primary key
+	*/
+	async readRow(table, pk) {
+		const schema = this.schemas.get(table);
+		if (!schema) return { message: `Table '${table}' not found` };
+		const buildOptions = { basePath: this.basePath };
+		const row = (await execAll$2(this.db, buildSelectByPK(table, schema, pk)))[0];
+		if (!row) return { message: `Row with pk '${pk}' not found in table '${table}'` };
+		return { data: buildRowEntry(table, schema, row, buildOptions) };
+	}
+	/**
+	* Gets table schema
+	*/
+	getSchema(table) {
+		const schema = this.schemas.get(table);
+		if (!schema) return { message: `Table '${table}' not found` };
+		return { data: buildSchemaEntry(table, schema, { basePath: this.basePath }) };
+	}
+	/**
+	* Lists attributes (columns) for a row
+	*/
+	async listAttributes(table, pk) {
+		const schema = this.schemas.get(table);
+		if (!schema) return {
+			data: [],
+			message: `Table '${table}' not found`
+		};
+		const buildOptions = { basePath: this.basePath };
+		const row = (await execAll$2(this.db, buildSelectByPK(table, schema, pk)))[0];
+		if (!row) return {
+			data: [],
+			message: `Row with pk '${pk}' not found`
+		};
+		return { data: buildAttributeListEntry(table, schema, pk, row, buildOptions) };
+	}
+	/**
+	* Gets a single attribute (column value) for a row
+	*/
+	async getAttribute(table, pk, column) {
+		const schema = this.schemas.get(table);
+		if (!schema) return { message: `Table '${table}' not found` };
+		if (!schema.columns.find((c) => c.name === column)) return { message: `Column '${column}' not found in table '${table}'` };
+		const buildOptions = { basePath: this.basePath };
+		const rows = await execAll$2(this.db, buildSelectByPK(table, schema, pk));
+		if (rows.length === 0) return { message: `Row with pk '${pk}' not found` };
+		return { data: buildAttributeEntry(table, pk, column, rows[0]?.[column], buildOptions) };
+	}
+	/**
+	* Gets row metadata
+	*/
+	async getMeta(table, pk) {
+		const schema = this.schemas.get(table);
+		if (!schema) return { message: `Table '${table}' not found` };
+		const buildOptions = { basePath: this.basePath };
+		const row = (await execAll$2(this.db, buildSelectByPK(table, schema, pk)))[0];
+		if (!row) return { message: `Row with pk '${pk}' not found` };
+		return { data: buildMetaEntry(table, schema, pk, row, buildOptions) };
+	}
+	/**
+	* Creates a new row in a table
+	*/
+	async createRow(table, content) {
+		const schema = this.schemas.get(table);
+		if (!schema) throw new Error(`Table '${table}' not found`);
+		const buildOptions = { basePath: this.basePath };
+		await execRun$1(this.db, buildInsert(table, schema, content));
+		const lastId = (await execAll$2(this.db, buildGetLastRowId()))[0]?.id;
+		if (lastId === void 0) throw new Error("Failed to get last inserted row ID");
+		const pkColumn = schema.primaryKey[0] ?? "rowid";
+		const pk = content[pkColumn] !== void 0 ? String(content[pkColumn]) : String(lastId);
+		const row = (await execAll$2(this.db, buildSelectByPK(table, schema, pk)))[0];
+		if (!row) throw new Error("Failed to fetch inserted row");
+		return { data: buildRowEntry(table, schema, row, buildOptions) };
+	}
+	/**
+	* Updates an existing row
+	*/
+	async updateRow(table, pk, content) {
+		const schema = this.schemas.get(table);
+		if (!schema) throw new Error(`Table '${table}' not found`);
+		const buildOptions = { basePath: this.basePath };
+		await execRun$1(this.db, buildUpdate(table, schema, pk, content));
+		const row = (await execAll$2(this.db, buildSelectByPK(table, schema, pk)))[0];
+		if (!row) throw new Error(`Row with pk '${pk}' not found after update`);
+		return { data: buildRowEntry(table, schema, row, buildOptions) };
+	}
+	/**
+	* Deletes a row by primary key
+	*/
+	async deleteRow(table, pk) {
+		const schema = this.schemas.get(table);
+		if (!schema) throw new Error(`Table '${table}' not found`);
+		if ((await execAll$2(this.db, buildSelectByPK(table, schema, pk))).length === 0) return { message: `Row with pk '${pk}' not found in table '${table}'` };
+		await execRun$1(this.db, buildDelete(table, schema, pk));
+		return { message: `Deleted row '${pk}' from table '${table}'` };
+	}
+	/**
+	* Checks if a table exists
+	*/
+	hasTable(table) {
+		return this.schemas.has(table);
+	}
+	/**
+	* Gets the schema for a table
+	*/
+	getTableSchema(table) {
+		return this.schemas.get(table);
+	}
+	/**
+	* Updates the schemas map (after refresh)
+	*/
+	setSchemas(schemas) {
+		this.schemas = schemas;
+	}
+};
+
+//#endregion
+//#region src/operations/search.ts
+/**
+* Executes a raw SQL query and returns all rows
+*/
+async function execAll$1(db, query) {
+	return db.all(_aigne_sqlite.sql.raw(query)).execute();
+}
+/**
+* FTS5 Search operations for SQLite AFS
+*/
+var FTSSearch = class {
+	constructor(db, schemas, config, basePath = "") {
+		this.db = db;
+		this.schemas = schemas;
+		this.config = config;
+		this.basePath = basePath;
+	}
+	/**
+	* Performs full-text search across configured tables
+	*/
+	async search(query, options) {
+		if (!this.config.enabled) return {
+			data: [],
+			message: "Full-text search is not enabled"
+		};
+		const results = [];
+		const limit = options?.limit ?? 50;
+		const buildOptions = { basePath: this.basePath };
+		const tablesToSearch = options?.tables ? options.tables.filter((t) => this.config.tables.has(t)) : Array.from(this.config.tables.keys());
+		const ftsQuery = this.prepareFTSQuery(query, options?.caseSensitive);
+		for (const tableName of tablesToSearch) {
+			const tableConfig = this.config.tables.get(tableName);
+			const schema = this.schemas.get(tableName);
+			if (!tableConfig || !schema) continue;
+			const ftsTableName = `${tableName}_fts`;
+			try {
+				if (!await this.ftsTableExists(ftsTableName)) continue;
+				const highlightColumn = tableConfig.columns[0] ?? "";
+				const highlightIndex = highlightColumn ? tableConfig.columns.indexOf(highlightColumn) : 0;
+				const rows = await execAll$1(this.db, `
+            SELECT t.*, highlight("${ftsTableName}", ${highlightIndex}, '<mark>', '</mark>') as snippet
+            FROM "${ftsTableName}" fts
+            JOIN "${tableName}" t ON fts.rowid = t.rowid
+            WHERE "${ftsTableName}" MATCH '${ftsQuery}'
+            LIMIT ${Math.ceil(limit / tablesToSearch.length)}
+          `);
+				for (const row of rows) {
+					const { snippet, ...rowData } = row;
+					results.push(buildSearchEntry(tableName, schema, rowData, snippet, buildOptions));
+				}
+			} catch (error) {
+				console.warn(`FTS search failed for table ${tableName}:`, error);
+			}
+			if (results.length >= limit) break;
+		}
+		return {
+			data: results.slice(0, limit),
+			message: results.length === 0 ? `No results found for "${query}"` : void 0
+		};
+	}
+	/**
+	* Searches within a specific table
+	*/
+	async searchTable(tableName, query, options) {
+		return this.search(query, {
+			...options,
+			tables: [tableName]
+		});
+	}
+	/**
+	* Checks if FTS is configured for a table
+	*/
+	hasFTS(tableName) {
+		return this.config.enabled && this.config.tables.has(tableName);
+	}
+	/**
+	* Gets FTS configuration for a table
+	*/
+	getFTSConfig(tableName) {
+		return this.config.tables.get(tableName);
+	}
+	/**
+	* Checks if an FTS table exists
+	*/
+	async ftsTableExists(ftsTableName) {
+		return (await execAll$1(this.db, `SELECT name FROM sqlite_master WHERE type = 'table' AND name = '${ftsTableName}'`)).length > 0;
+	}
+	/**
+	* Prepares a query string for FTS5
+	* Handles special characters and case sensitivity
+	*/
+	prepareFTSQuery(query, _caseSensitive) {
+		let prepared = query.replace(/"/g, "\"\"").replace(/'/g, "''");
+		if (prepared.includes(" ") && !prepared.startsWith("\"")) prepared = `"${prepared}"`;
+		return prepared;
+	}
+	/**
+	* Updates the schemas map (after refresh)
+	*/
+	setSchemas(schemas) {
+		this.schemas = schemas;
+	}
+	/**
+	* Simple search fallback when FTS is not available
+	* Uses LIKE queries on specified columns
+	*/
+	async simpleLikeSearch(tableName, query, columns, options) {
+		const schema = this.schemas.get(tableName);
+		if (!schema) return {
+			data: [],
+			message: `Table '${tableName}' not found`
+		};
+		const buildOptions = { basePath: this.basePath };
+		const limit = options?.limit ?? 50;
+		const escapedQuery = query.replace(/'/g, "''");
+		const conditions = columns.filter((col) => schema.columns.some((c) => c.name === col)).map((col) => `"${col}" LIKE '%${escapedQuery}%'`).join(" OR ");
+		if (!conditions) return {
+			data: [],
+			message: "No valid columns to search"
+		};
+		return { data: (await execAll$1(this.db, `SELECT * FROM "${tableName}" WHERE ${conditions} LIMIT ${limit}`)).map((row) => buildSearchEntry(tableName, schema, row, void 0, buildOptions)) };
+	}
+};
+/**
+* Creates FTS configuration from options
+*/
+function createFTSConfig(options) {
+	const config = {
+		enabled: options?.enabled ?? false,
+		tables: /* @__PURE__ */ new Map()
+	};
+	if (options?.tables) for (const [table, columns] of Object.entries(options.tables)) config.tables.set(table, { columns });
+	return config;
+}
+
+//#endregion
+//#region src/router/path-router.ts
+/**
+* Creates a radix3 router for SQLite AFS path routing
+*
+* Routes:
+* - / → listTables
+* - /:table → listTable
+* - /:table/new → createRow
+* - /:table/@schema → getSchema
+* - /:table/:pk → readRow
+* - /:table/:pk/@attr → listAttributes
+* - /:table/:pk/@attr/:column → getAttribute
+* - /:table/:pk/@meta → getMeta
+* - /:table/:pk/@actions → listActions
+* - /:table/:pk/@actions/:action → executeAction
+*/
+function createPathRouter() {
+	return (0, radix3.createRouter)({ routes: {
+		"/": { action: "listTables" },
+		"/:table": { action: "listTable" },
+		"/:table/new": { action: "createRow" },
+		"/:table/@schema": { action: "getSchema" },
+		"/:table/:pk": { action: "readRow" },
+		"/:table/:pk/@attr": { action: "listAttributes" },
+		"/:table/:pk/@attr/:column": { action: "getAttribute" },
+		"/:table/:pk/@meta": { action: "getMeta" },
+		"/:table/:pk/@actions": { action: "listActions" },
+		"/:table/:pk/@actions/:action": { action: "executeAction" }
+	} });
+}
+/**
+* Parses a path and returns the matched route with params
+* @param router - The radix3 router instance
+* @param path - The path to match
+* @returns RouteMatch if matched, undefined otherwise
+*/
+function matchPath(router, path) {
+	const result = router.lookup(path);
+	if (!result) return void 0;
+	return {
+		action: result.action,
+		params: result.params ?? {}
+	};
+}
+/**
+* Builds a path from components
+*/
+function buildPath(table, pk, suffix) {
+	const parts = ["/"];
+	if (table) parts.push(table);
+	if (pk) parts.push(pk);
+	if (suffix) parts.push(suffix);
+	return parts.join("/").replace(/\/+/g, "/");
+}
+/**
+* Checks if a path segment is a virtual path (@attr, @meta, @actions, @schema)
+*/
+function isVirtualPath(segment) {
+	return segment.startsWith("@");
+}
+/**
+* Gets the type of virtual path
+*/
+function getVirtualPathType(segment) {
+	if (segment === "@attr") return "attr";
+	if (segment === "@meta") return "meta";
+	if (segment === "@actions") return "actions";
+	if (segment === "@schema") return "schema";
+	return null;
+}
+
+//#endregion
+//#region src/schema/types.ts
+/**
+* System tables that should be excluded from introspection
+*/
+const SYSTEM_TABLES = [
+	"sqlite_sequence",
+	"sqlite_stat1",
+	"sqlite_stat2",
+	"sqlite_stat3",
+	"sqlite_stat4"
+];
+
+//#endregion
+//#region src/schema/introspector.ts
+/**
+* Executes a raw SQL query and returns all rows
+*/
+async function execAll(db, query) {
+	return db.all(_aigne_sqlite.sql.raw(query)).execute();
+}
+/**
+* Executes a raw SQL query (for INSERT, UPDATE, DELETE)
+*/
+async function execRun(db, query) {
+	await db.run(_aigne_sqlite.sql.raw(query)).execute();
+}
+/**
+* Maps raw PRAGMA table_info row to ColumnInfo
+*/
+function mapColumn(row) {
+	return {
+		name: row.name,
+		type: row.type,
+		notnull: row.notnull === 1,
+		pk: row.pk,
+		dfltValue: row.dflt_value
+	};
+}
+/**
+* Maps raw PRAGMA foreign_key_list row to ForeignKeyInfo
+*/
+function mapForeignKey(row) {
+	return {
+		id: row.id,
+		seq: row.seq,
+		table: row.table,
+		from: row.from,
+		to: row.to,
+		onUpdate: row.on_update,
+		onDelete: row.on_delete,
+		match: row.match
+	};
+}
+/**
+* Maps raw PRAGMA index_list row to IndexInfo
+*/
+function mapIndex(row) {
+	return {
+		seq: row.seq,
+		name: row.name,
+		unique: row.unique === 1,
+		origin: row.origin,
+		partial: row.partial === 1
+	};
+}
+/**
+* Schema introspector that uses SQLite PRAGMA queries to discover database schema
+*/
+var SchemaIntrospector = class {
+	/**
+	* Introspects all tables in the database
+	* @param db - Drizzle database instance
+	* @param options - Introspection options
+	* @returns Map of table name to TableSchema
+	*/
+	async introspect(db, options) {
+		const schemas = /* @__PURE__ */ new Map();
+		const tablesResult = await execAll(db, `
+      SELECT name FROM sqlite_master
+      WHERE type = 'table'
+      AND name NOT LIKE 'sqlite_%'
+      AND name NOT LIKE '%_fts%'
+      ORDER BY name
+    `);
+		for (const { name } of tablesResult) {
+			if (SYSTEM_TABLES.includes(name)) continue;
+			if (options?.tables && !options.tables.includes(name)) continue;
+			if (options?.excludeTables?.includes(name)) continue;
+			const schema = await this.introspectTable(db, name);
+			schemas.set(name, schema);
+		}
+		return schemas;
+	}
+	/**
+	* Introspects a single table
+	* @param db - Drizzle database instance
+	* @param tableName - Name of the table to introspect
+	* @returns TableSchema for the specified table
+	*/
+	async introspectTable(db, tableName) {
+		const columns = (await execAll(db, `PRAGMA table_info("${tableName}")`)).map(mapColumn);
+		return {
+			name: tableName,
+			columns,
+			primaryKey: columns.filter((c) => c.pk > 0).map((c) => c.name),
+			foreignKeys: (await execAll(db, `PRAGMA foreign_key_list("${tableName}")`)).map(mapForeignKey),
+			indexes: (await execAll(db, `PRAGMA index_list("${tableName}")`)).map(mapIndex)
+		};
+	}
+	/**
+	* Gets the primary key column name for a table
+	* Returns the first PK column, or 'rowid' if no explicit PK
+	*/
+	getPrimaryKeyColumn(schema) {
+		if (schema.primaryKey.length > 0 && schema.primaryKey[0]) return schema.primaryKey[0];
+		return "rowid";
+	}
+	/**
+	* Checks if a table has FTS (Full-Text Search) enabled
+	*/
+	async hasFTS(db, tableName) {
+		return (await execAll(db, `
+      SELECT name FROM sqlite_master
+      WHERE type = 'table'
+      AND name = '${`${tableName}_fts`}'
+    `)).length > 0;
+	}
+	/**
+	* Creates FTS5 table for full-text search on specified columns
+	*/
+	async createFTS(db, tableName, columns, options) {
+		const ftsTableName = `${tableName}_fts`;
+		const contentTable = options?.contentTable ?? tableName;
+		const contentRowid = options?.contentRowid ?? "rowid";
+		const columnList = columns.join(", ");
+		await execRun(db, `
+      CREATE VIRTUAL TABLE IF NOT EXISTS "${ftsTableName}" USING fts5(
+        ${columnList},
+        content="${contentTable}",
+        content_rowid="${contentRowid}"
+      )
+    `);
+		await execRun(db, `
+      CREATE TRIGGER IF NOT EXISTS "${tableName}_ai" AFTER INSERT ON "${tableName}" BEGIN
+        INSERT INTO "${ftsTableName}"(rowid, ${columnList}) VALUES (new.${contentRowid}, ${columns.map((c) => `new."${c}"`).join(", ")});
+      END
+    `);
+		await execRun(db, `
+      CREATE TRIGGER IF NOT EXISTS "${tableName}_ad" AFTER DELETE ON "${tableName}" BEGIN
+        INSERT INTO "${ftsTableName}"("${ftsTableName}", rowid, ${columnList}) VALUES ('delete', old.${contentRowid}, ${columns.map((c) => `old."${c}"`).join(", ")});
+      END
+    `);
+		await execRun(db, `
+      CREATE TRIGGER IF NOT EXISTS "${tableName}_au" AFTER UPDATE ON "${tableName}" BEGIN
+        INSERT INTO "${ftsTableName}"("${ftsTableName}", rowid, ${columnList}) VALUES ('delete', old.${contentRowid}, ${columns.map((c) => `old."${c}"`).join(", ")});
+        INSERT INTO "${ftsTableName}"(rowid, ${columnList}) VALUES (new.${contentRowid}, ${columns.map((c) => `new."${c}"`).join(", ")});
+      END
+    `);
+	}
+	/**
+	* Rebuilds FTS index for a table (useful after bulk inserts)
+	*/
+	async rebuildFTS(db, tableName) {
+		const ftsTableName = `${tableName}_fts`;
+		await execRun(db, `INSERT INTO "${ftsTableName}"("${ftsTableName}") VALUES ('rebuild')`);
+	}
+};
+
+//#endregion
+//#region src/sqlite-afs.ts
+/**
+* SQLite AFS Module
+*
+* Exposes SQLite databases as AFS nodes with full CRUD support,
+* schema introspection, FTS5 search, and virtual paths (@attr, @meta, @actions).
+*/
+var SQLiteAFS = class SQLiteAFS {
+	name;
+	description;
+	accessMode;
+	db;
+	schemas = /* @__PURE__ */ new Map();
+	router;
+	crud;
+	ftsSearch;
+	actions;
+	ftsConfig;
+	initialized = false;
+	constructor(options) {
+		this.options = options;
+		this.name = options.name ?? "sqlite-afs";
+		this.description = options.description ?? `SQLite database: ${options.url}`;
+		this.accessMode = options.accessMode ?? "readwrite";
+		this.ftsConfig = createFTSConfig(options.fts);
+		this.actions = new ActionsRegistry();
+		registerBuiltInActions(this.actions);
+	}
+	/**
+	* Returns the Zod schema for configuration validation
+	*/
+	static schema() {
+		return sqliteAFSConfigSchema;
+	}
+	/**
+	* Loads a module instance from configuration
+	*/
+	static async load({ parsed }) {
+		return new SQLiteAFS(sqliteAFSConfigSchema.parse(parsed));
+	}
+	/**
+	* Called when the module is mounted to AFS
+	*/
+	async onMount(_afs) {
+		await this.initialize();
+	}
+	/**
+	* Initializes the database connection and introspects schema
+	*/
+	async initialize() {
+		if (this.initialized) return;
+		this.db = await (0, _aigne_sqlite.initDatabase)({
+			url: this.options.url,
+			wal: this.options.wal ?? true
+		});
+		const db = this.db;
+		this.schemas = await new SchemaIntrospector().introspect(db, {
+			tables: this.options.tables,
+			excludeTables: this.options.excludeTables
+		});
+		this.router = createPathRouter();
+		this.crud = new CRUDOperations(db, this.schemas, "");
+		this.ftsSearch = new FTSSearch(db, this.schemas, this.ftsConfig, "");
+		this.initialized = true;
+	}
+	/**
+	* Ensures the module is initialized
+	*/
+	async ensureInitialized() {
+		if (!this.initialized) await this.initialize();
+	}
+	/**
+	* Lists entries at a path
+	*/
+	async list(path, options) {
+		await this.ensureInitialized();
+		const match = matchPath(this.router, path);
+		if (!match) return { data: [] };
+		switch (match.action) {
+			case "listTables": return this.crud.listTables();
+			case "listTable":
+				if (!match.params.table) return { data: [] };
+				return this.crud.listTable(match.params.table, options);
+			case "listAttributes":
+				if (!match.params.table || !match.params.pk) return { data: [] };
+				return this.crud.listAttributes(match.params.table, match.params.pk);
+			case "listActions":
+				if (!match.params.table || !match.params.pk) return { data: [] };
+				return this.listActions(match.params.table, match.params.pk);
+			default: return { data: [] };
+		}
+	}
+	/**
+	* Reads an entry at a path
+	*/
+	async read(path, _options) {
+		await this.ensureInitialized();
+		const match = matchPath(this.router, path);
+		if (!match) return {};
+		switch (match.action) {
+			case "readRow":
+				if (!match.params.table || !match.params.pk) return {};
+				return this.crud.readRow(match.params.table, match.params.pk);
+			case "getSchema":
+				if (!match.params.table) return {};
+				return this.crud.getSchema(match.params.table);
+			case "getAttribute":
+				if (!match.params.table || !match.params.pk || !match.params.column) return {};
+				return this.crud.getAttribute(match.params.table, match.params.pk, match.params.column);
+			case "getMeta":
+				if (!match.params.table || !match.params.pk) return {};
+				return this.crud.getMeta(match.params.table, match.params.pk);
+			default: return {};
+		}
+	}
+	/**
+	* Writes an entry at a path
+	*/
+	async write(path, content, _options) {
+		await this.ensureInitialized();
+		if (this.accessMode === "readonly") throw new Error("Module is in readonly mode");
+		const match = matchPath(this.router, path);
+		if (!match) throw new Error(`Invalid path: ${path}`);
+		switch (match.action) {
+			case "createRow":
+				if (!match.params.table) throw new Error("Table name required for create");
+				return this.crud.createRow(match.params.table, content.content ?? content);
+			case "readRow":
+				if (!match.params.table || !match.params.pk) throw new Error("Table and primary key required for update");
+				return this.crud.updateRow(match.params.table, match.params.pk, content.content ?? content);
+			case "executeAction":
+				if (!match.params.table || !match.params.action) throw new Error("Table and action name required");
+				return this.executeAction(match.params.table, match.params.pk, match.params.action, content.content ?? content);
+			default: throw new Error(`Write not supported for path: ${path}`);
+		}
+	}
+	/**
+	* Deletes an entry at a path
+	*/
+	async delete(path, _options) {
+		await this.ensureInitialized();
+		if (this.accessMode === "readonly") throw new Error("Module is in readonly mode");
+		const match = matchPath(this.router, path);
+		if (!match || match.action !== "readRow") throw new Error(`Delete not supported for path: ${path}`);
+		if (!match.params.table || !match.params.pk) throw new Error("Table and primary key required for delete");
+		return this.crud.deleteRow(match.params.table, match.params.pk);
+	}
+	/**
+	* Searches for entries matching a query
+	*/
+	async search(path, query, options) {
+		await this.ensureInitialized();
+		const match = matchPath(this.router, path);
+		if (match?.params.table) return this.ftsSearch.searchTable(match.params.table, query, options);
+		return this.ftsSearch.search(query, options);
+	}
+	/**
+	* Executes a module operation
+	*/
+	async exec(path, args, _options) {
+		await this.ensureInitialized();
+		const match = matchPath(this.router, path);
+		if (match?.action === "executeAction" && match.params.table && match.params.action) return { data: (await this.executeAction(match.params.table, match.params.pk, match.params.action, args)).data };
+		throw new Error(`Exec not supported for path: ${path}`);
+	}
+	/**
+	* Lists available actions for a row
+	*/
+	listActions(table, pk) {
+		return { data: buildActionsListEntry(table, pk, this.actions.listNames({ rowLevel: true }), { basePath: "" }) };
+	}
+	/**
+	* Executes an action
+	*/
+	async executeAction(table, pk, actionName, params) {
+		if (!this.schemas.get(table)) throw new Error(`Table '${table}' not found`);
+		let row;
+		if (pk) row = (await this.crud.readRow(table, pk)).data?.content;
+		const ctx = {
+			db: this.db,
+			schemas: this.schemas,
+			table,
+			pk,
+			row,
+			module: {
+				refreshSchema: () => this.refreshSchema(),
+				exportTable: (t, f) => this.exportTable(t, f)
+			}
+		};
+		const result = await this.actions.execute(actionName, ctx, params);
+		if (!result.success) throw new Error(result.message ?? "Action failed");
+		return { data: {
+			id: `${table}:${pk ?? ""}:@actions:${actionName}`,
+			path: pk ? `/${table}/${pk}/@actions/${actionName}` : `/${table}/@actions/${actionName}`,
+			content: result.data
+		} };
+	}
+	/**
+	* Refreshes the schema cache
+	*/
+	async refreshSchema() {
+		const db = this.db;
+		this.schemas = await new SchemaIntrospector().introspect(db, {
+			tables: this.options.tables,
+			excludeTables: this.options.excludeTables
+		});
+		this.crud.setSchemas(this.schemas);
+		this.ftsSearch.setSchemas(this.schemas);
+	}
+	/**
+	* Exports table data in specified format
+	*/
+	async exportTable(table, format) {
+		const listResult = await this.crud.listTable(table, { limit: 1e4 });
+		if (format === "csv") {
+			const schema = this.schemas.get(table);
+			if (!schema) throw new Error(`Table '${table}' not found`);
+			return `${schema.columns.map((c) => c.name).join(",")}\n${listResult.data.map((entry) => {
+				const content = entry.content;
+				return schema.columns.map((c) => {
+					const val = content[c.name];
+					if (val === null || val === void 0) return "";
+					if (typeof val === "string" && (val.includes(",") || val.includes("\""))) return `"${val.replace(/"/g, "\"\"")}"`;
+					return String(val);
+				}).join(",");
+			}).join("\n")}`;
+		}
+		return listResult.data.map((entry) => entry.content);
+	}
+	/**
+	* Registers a custom action
+	*/
+	registerAction(name, handler, options) {
+		this.actions.registerSimple(name, async (ctx, params) => ({
+			success: true,
+			data: await handler(ctx, params)
+		}), options);
+	}
+	/**
+	* Gets table schemas (for external access)
+	*/
+	getSchemas() {
+		return this.schemas;
+	}
+	/**
+	* Gets the database instance (for advanced operations)
+	*/
+	getDatabase() {
+		return this.db;
+	}
+};
+
+//#endregion
+exports.ActionsRegistry = ActionsRegistry;
+exports.CRUDOperations = CRUDOperations;
+exports.FTSSearch = FTSSearch;
+exports.SQLiteAFS = SQLiteAFS;
+exports.SchemaIntrospector = SchemaIntrospector;
+exports.buildActionsListEntry = buildActionsListEntry;
+exports.buildAttributeEntry = buildAttributeEntry;
+exports.buildAttributeListEntry = buildAttributeListEntry;
+exports.buildDelete = buildDelete;
+exports.buildGetLastRowId = buildGetLastRowId;
+exports.buildInsert = buildInsert;
+exports.buildMetaEntry = buildMetaEntry;
+exports.buildPath = buildPath;
+exports.buildRowEntry = buildRowEntry;
+exports.buildSchemaEntry = buildSchemaEntry;
+exports.buildSearchEntry = buildSearchEntry;
+exports.buildSelectAll = buildSelectAll;
+exports.buildSelectByPK = buildSelectByPK;
+exports.buildTableEntry = buildTableEntry;
+exports.buildUpdate = buildUpdate;
+exports.createFTSConfig = createFTSConfig;
+exports.createPathRouter = createPathRouter;
+exports.getVirtualPathType = getVirtualPathType;
+exports.isVirtualPath = isVirtualPath;
+exports.matchPath = matchPath;
+exports.registerBuiltInActions = registerBuiltInActions;
+exports.sqliteAFSConfigSchema = sqliteAFSConfigSchema;