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

package/dist/schema/types.d.cts

@@ -0,0 +1,104 @@
+//#region src/schema/types.d.ts
+/**
+ * Column information from SQLite PRAGMA table_info
+ */
+interface ColumnInfo {
+  /** Column name */
+  name: string;
+  /** SQLite type (INTEGER, TEXT, REAL, BLOB, etc.) */
+  type: string;
+  /** Whether the column has NOT NULL constraint */
+  notnull: boolean;
+  /** Whether this column is part of the primary key */
+  pk: number;
+  /** Default value for the column */
+  dfltValue: unknown;
+}
+/**
+ * Foreign key information from SQLite PRAGMA foreign_key_list
+ */
+interface ForeignKeyInfo {
+  /** Foreign key id */
+  id: number;
+  /** Sequence number for composite foreign keys */
+  seq: number;
+  /** Referenced table */
+  table: string;
+  /** Column in this table */
+  from: string;
+  /** Column in referenced table */
+  to: string;
+  /** ON UPDATE action */
+  onUpdate: string;
+  /** ON DELETE action */
+  onDelete: string;
+  /** MATCH clause */
+  match: string;
+}
+/**
+ * Index information from SQLite PRAGMA index_list
+ */
+interface IndexInfo {
+  /** Index sequence number */
+  seq: number;
+  /** Index name */
+  name: string;
+  /** Whether this is a unique index */
+  unique: boolean;
+  /** Origin of the index (c = CREATE INDEX, u = UNIQUE constraint, pk = PRIMARY KEY) */
+  origin: string;
+  /** Whether the index is partial */
+  partial: boolean;
+}
+/**
+ * Complete schema information for a single table
+ */
+interface TableSchema {
+  /** Table name */
+  name: string;
+  /** Column definitions */
+  columns: ColumnInfo[];
+  /** Primary key column names */
+  primaryKey: string[];
+  /** Foreign key relationships */
+  foreignKeys: ForeignKeyInfo[];
+  /** Indexes on this table */
+  indexes: IndexInfo[];
+}
+/**
+ * Raw PRAGMA table_info result row
+ */
+interface PragmaTableInfoRow {
+  cid: number;
+  name: string;
+  type: string;
+  notnull: number;
+  dflt_value: unknown;
+  pk: number;
+}
+/**
+ * Raw PRAGMA foreign_key_list result row
+ */
+interface PragmaForeignKeyRow {
+  id: number;
+  seq: number;
+  table: string;
+  from: string;
+  to: string;
+  on_update: string;
+  on_delete: string;
+  match: string;
+}
+/**
+ * Raw PRAGMA index_list result row
+ */
+interface PragmaIndexListRow {
+  seq: number;
+  name: string;
+  unique: number;
+  origin: string;
+  partial: number;
+}
+//#endregion
+export { ColumnInfo, ForeignKeyInfo, IndexInfo, PragmaForeignKeyRow, PragmaIndexListRow, PragmaTableInfoRow, TableSchema };
+//# sourceMappingURL=types.d.cts.map

package/dist/schema/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/schema/types.ts"],"mappings":";;AAGA;AAgBA;UAhBiB,UAAA;EAAA;EAAA,IAAA;EAAA;EAAA,IAAA;EAAA;EAAA,OAAA;EAAA;EAAA,EAAA;EAAA;EAAA,SAAA;AAAA;AAAA;AAgBjB;AAsBA;AAtCiB,UAgBA,cAAA;EAAA;EAAA,EAAA;EAAA;EAAA,GAAA;EAAA;EAAA,KAAA;EAAA;EAAA,IAAA;EAAA;EAAA,EAAA;EAAA;EAAA,QAAA;EAAA;EAAA,QAAA;EAAA;EAAA,KAAA;AAAA;AAAA;AAsBjB;AAgBA;AAtCiB,UAsBA,SAAA;EAAA;EAAA,GAAA;EAAA;EAAA,IAAA;EAAA;EAAA,MAAA;EAAA;EAAA,MAAA;EAAA;EAAA,OAAA;AAAA;AAAA;AAgBjB;;AAhBiB,UAgBA,WAAA;EAAA;EAAA,IAAA;EAAA;EAAA,OAAA,EAIN,UAAA;EAAA;EAAA,UAAA;EAAA;EAAA,WAAA,EAII,cAAA;EAAA;EAAA,OAAA,EAEJ,SAAA;AAAA;AAAA;;AAMX;AANW,UAMM,kBAAA;EAAA,GAAA;EAAA,IAAA;EAAA,IAAA;EAAA,OAAA;EAAA,UAAA;EAAA,EAAA;AAAA;AAAA;AAYjB;AAcA;AA1BiB,UAYA,mBAAA;EAAA,EAAA;EAAA,GAAA;EAAA,KAAA;EAAA,IAAA;EAAA,EAAA;EAAA,SAAA;EAAA,SAAA;EAAA,KAAA;AAAA;AAAA;AAcjB;;AAdiB,UAcA,kBAAA;EAAA,GAAA;EAAA,IAAA;EAAA,MAAA;EAAA,MAAA;EAAA,OAAA;AAAA"}

package/dist/schema/types.d.mts

@@ -0,0 +1,104 @@
+//#region src/schema/types.d.ts
+/**
+ * Column information from SQLite PRAGMA table_info
+ */
+interface ColumnInfo {
+  /** Column name */
+  name: string;
+  /** SQLite type (INTEGER, TEXT, REAL, BLOB, etc.) */
+  type: string;
+  /** Whether the column has NOT NULL constraint */
+  notnull: boolean;
+  /** Whether this column is part of the primary key */
+  pk: number;
+  /** Default value for the column */
+  dfltValue: unknown;
+}
+/**
+ * Foreign key information from SQLite PRAGMA foreign_key_list
+ */
+interface ForeignKeyInfo {
+  /** Foreign key id */
+  id: number;
+  /** Sequence number for composite foreign keys */
+  seq: number;
+  /** Referenced table */
+  table: string;
+  /** Column in this table */
+  from: string;
+  /** Column in referenced table */
+  to: string;
+  /** ON UPDATE action */
+  onUpdate: string;
+  /** ON DELETE action */
+  onDelete: string;
+  /** MATCH clause */
+  match: string;
+}
+/**
+ * Index information from SQLite PRAGMA index_list
+ */
+interface IndexInfo {
+  /** Index sequence number */
+  seq: number;
+  /** Index name */
+  name: string;
+  /** Whether this is a unique index */
+  unique: boolean;
+  /** Origin of the index (c = CREATE INDEX, u = UNIQUE constraint, pk = PRIMARY KEY) */
+  origin: string;
+  /** Whether the index is partial */
+  partial: boolean;
+}
+/**
+ * Complete schema information for a single table
+ */
+interface TableSchema {
+  /** Table name */
+  name: string;
+  /** Column definitions */
+  columns: ColumnInfo[];
+  /** Primary key column names */
+  primaryKey: string[];
+  /** Foreign key relationships */
+  foreignKeys: ForeignKeyInfo[];
+  /** Indexes on this table */
+  indexes: IndexInfo[];
+}
+/**
+ * Raw PRAGMA table_info result row
+ */
+interface PragmaTableInfoRow {
+  cid: number;
+  name: string;
+  type: string;
+  notnull: number;
+  dflt_value: unknown;
+  pk: number;
+}
+/**
+ * Raw PRAGMA foreign_key_list result row
+ */
+interface PragmaForeignKeyRow {
+  id: number;
+  seq: number;
+  table: string;
+  from: string;
+  to: string;
+  on_update: string;
+  on_delete: string;
+  match: string;
+}
+/**
+ * Raw PRAGMA index_list result row
+ */
+interface PragmaIndexListRow {
+  seq: number;
+  name: string;
+  unique: number;
+  origin: string;
+  partial: number;
+}
+//#endregion
+export { ColumnInfo, ForeignKeyInfo, IndexInfo, PragmaForeignKeyRow, PragmaIndexListRow, PragmaTableInfoRow, TableSchema };
+//# sourceMappingURL=types.d.mts.map

package/dist/schema/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/schema/types.ts"],"mappings":";;AAGA;AAgBA;UAhBiB,UAAA;EAAA;EAAA,IAAA;EAAA;EAAA,IAAA;EAAA;EAAA,OAAA;EAAA;EAAA,EAAA;EAAA;EAAA,SAAA;AAAA;AAAA;AAgBjB;AAsBA;AAtCiB,UAgBA,cAAA;EAAA;EAAA,EAAA;EAAA;EAAA,GAAA;EAAA;EAAA,KAAA;EAAA;EAAA,IAAA;EAAA;EAAA,EAAA;EAAA;EAAA,QAAA;EAAA;EAAA,QAAA;EAAA;EAAA,KAAA;AAAA;AAAA;AAsBjB;AAgBA;AAtCiB,UAsBA,SAAA;EAAA;EAAA,GAAA;EAAA;EAAA,IAAA;EAAA;EAAA,MAAA;EAAA;EAAA,MAAA;EAAA;EAAA,OAAA;AAAA;AAAA;AAgBjB;;AAhBiB,UAgBA,WAAA;EAAA;EAAA,IAAA;EAAA;EAAA,OAAA,EAIN,UAAA;EAAA;EAAA,UAAA;EAAA;EAAA,WAAA,EAII,cAAA;EAAA;EAAA,OAAA,EAEJ,SAAA;AAAA;AAAA;;AAMX;AANW,UAMM,kBAAA;EAAA,GAAA;EAAA,IAAA;EAAA,IAAA;EAAA,OAAA;EAAA,UAAA;EAAA,EAAA;AAAA;AAAA;AAYjB;AAcA;AA1BiB,UAYA,mBAAA;EAAA,EAAA;EAAA,GAAA;EAAA,KAAA;EAAA,IAAA;EAAA,EAAA;EAAA,SAAA;EAAA,SAAA;EAAA,KAAA;AAAA;AAAA;AAcjB;;AAdiB,UAcA,kBAAA;EAAA,GAAA;EAAA,IAAA;EAAA,MAAA;EAAA,MAAA;EAAA,OAAA;AAAA"}

package/dist/schema/types.mjs

@@ -0,0 +1,15 @@
+//#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
+export { SYSTEM_TABLES };
+//# sourceMappingURL=types.mjs.map

package/dist/schema/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","names":[],"sources":["../../src/schema/types.ts"],"sourcesContent":["/**\n * Column information from SQLite PRAGMA table_info\n */\nexport interface ColumnInfo {\n  /** Column name */\n  name: string;\n  /** SQLite type (INTEGER, TEXT, REAL, BLOB, etc.) */\n  type: string;\n  /** Whether the column has NOT NULL constraint */\n  notnull: boolean;\n  /** Whether this column is part of the primary key */\n  pk: number;\n  /** Default value for the column */\n  dfltValue: unknown;\n}\n\n/**\n * Foreign key information from SQLite PRAGMA foreign_key_list\n */\nexport interface ForeignKeyInfo {\n  /** Foreign key id */\n  id: number;\n  /** Sequence number for composite foreign keys */\n  seq: number;\n  /** Referenced table */\n  table: string;\n  /** Column in this table */\n  from: string;\n  /** Column in referenced table */\n  to: string;\n  /** ON UPDATE action */\n  onUpdate: string;\n  /** ON DELETE action */\n  onDelete: string;\n  /** MATCH clause */\n  match: string;\n}\n\n/**\n * Index information from SQLite PRAGMA index_list\n */\nexport interface IndexInfo {\n  /** Index sequence number */\n  seq: number;\n  /** Index name */\n  name: string;\n  /** Whether this is a unique index */\n  unique: boolean;\n  /** Origin of the index (c = CREATE INDEX, u = UNIQUE constraint, pk = PRIMARY KEY) */\n  origin: string;\n  /** Whether the index is partial */\n  partial: boolean;\n}\n\n/**\n * Complete schema information for a single table\n */\nexport interface TableSchema {\n  /** Table name */\n  name: string;\n  /** Column definitions */\n  columns: ColumnInfo[];\n  /** Primary key column names */\n  primaryKey: string[];\n  /** Foreign key relationships */\n  foreignKeys: ForeignKeyInfo[];\n  /** Indexes on this table */\n  indexes: IndexInfo[];\n}\n\n/**\n * Raw PRAGMA table_info result row\n */\nexport interface PragmaTableInfoRow {\n  cid: number;\n  name: string;\n  type: string;\n  notnull: number;\n  dflt_value: unknown;\n  pk: number;\n}\n\n/**\n * Raw PRAGMA foreign_key_list result row\n */\nexport interface PragmaForeignKeyRow {\n  id: number;\n  seq: number;\n  table: string;\n  from: string;\n  to: string;\n  on_update: string;\n  on_delete: string;\n  match: string;\n}\n\n/**\n * Raw PRAGMA index_list result row\n */\nexport interface PragmaIndexListRow {\n  seq: number;\n  name: string;\n  unique: number;\n  origin: string;\n  partial: number;\n}\n\n/**\n * System tables that should be excluded from introspection\n */\nexport const SYSTEM_TABLES = [\n  \"sqlite_sequence\",\n  \"sqlite_stat1\",\n  \"sqlite_stat2\",\n  \"sqlite_stat3\",\n  \"sqlite_stat4\",\n] as const;\n"],"mappings":";;;;AA8GA,MAAa,gBAAgB;CAC3B;CACA;CACA;CACA;CACA;CACD"}

package/dist/sqlite-afs.cjs

@@ -0,0 +1,264 @@
+const require_built_in = require('./actions/built-in.cjs');
+const require_registry = require('./actions/registry.cjs');
+const require_config = require('./config.cjs');
+const require_builder = require('./node/builder.cjs');
+const require_crud = require('./operations/crud.cjs');
+const require_search = require('./operations/search.cjs');
+const require_path_router = require('./router/path-router.cjs');
+const require_introspector = require('./schema/introspector.cjs');
+let _aigne_sqlite = require("@aigne/sqlite");
+
+//#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 = require_search.createFTSConfig(options.fts);
+		this.actions = new require_registry.ActionsRegistry();
+		require_built_in.registerBuiltInActions(this.actions);
+	}
+	/**
+	* Returns the Zod schema for configuration validation
+	*/
+	static schema() {
+		return require_config.sqliteAFSConfigSchema;
+	}
+	/**
+	* Loads a module instance from configuration
+	*/
+	static async load({ parsed }) {
+		return new SQLiteAFS(require_config.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 require_introspector.SchemaIntrospector().introspect(db, {
+			tables: this.options.tables,
+			excludeTables: this.options.excludeTables
+		});
+		this.router = require_path_router.createPathRouter();
+		this.crud = new require_crud.CRUDOperations(db, this.schemas, "");
+		this.ftsSearch = new require_search.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 = require_path_router.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 = require_path_router.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 = require_path_router.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 = require_path_router.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 = require_path_router.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 = require_path_router.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: require_builder.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 require_introspector.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.SQLiteAFS = SQLiteAFS;

package/dist/sqlite-afs.d.cts

@@ -0,0 +1,152 @@
+import { TableSchema } from "./schema/types.cjs";
+import { ActionContext } from "./actions/types.cjs";
+import { SQLiteAFSOptions } from "./config.cjs";
+import { LibSQLDatabase } from "drizzle-orm/libsql";
+import { AFSAccessMode, AFSDeleteOptions, AFSDeleteResult, AFSExecOptions, AFSExecResult, AFSListOptions, AFSListResult, AFSModule, AFSModuleLoadParams, AFSReadOptions, AFSReadResult, AFSRoot, AFSSearchOptions, AFSSearchResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+import * as zod0 from "zod";
+
+//#region src/sqlite-afs.d.ts
+/**
+ * SQLite AFS Module
+ *
+ * Exposes SQLite databases as AFS nodes with full CRUD support,
+ * schema introspection, FTS5 search, and virtual paths (@attr, @meta, @actions).
+ */
+declare class SQLiteAFS implements AFSModule {
+  private options;
+  readonly name: string;
+  readonly description: string;
+  readonly accessMode: AFSAccessMode;
+  private db;
+  private schemas;
+  private router;
+  private crud;
+  private ftsSearch;
+  private actions;
+  private ftsConfig;
+  private initialized;
+  constructor(options: SQLiteAFSOptions);
+  /**
+       * Returns the Zod schema for configuration validation
+       */
+  static schema(): zod0.ZodObject<{
+    url: zod0.ZodString;
+    name: zod0.ZodOptional<zod0.ZodString>;
+    description: zod0.ZodOptional<zod0.ZodString>;
+    accessMode: zod0.ZodOptional<zod0.ZodEnum<["readonly", "readwrite"]>>;
+    tables: zod0.ZodOptional<zod0.ZodArray<zod0.ZodString, "many">>;
+    excludeTables: zod0.ZodOptional<zod0.ZodArray<zod0.ZodString, "many">>;
+    fts: zod0.ZodOptional<zod0.ZodObject<{
+      enabled: zod0.ZodDefault<zod0.ZodBoolean>;
+      tables: zod0.ZodOptional<zod0.ZodRecord<zod0.ZodString, zod0.ZodArray<zod0.ZodString, "many">>>;
+    }, "strip", zod0.ZodTypeAny, {
+      enabled: boolean;
+      tables?: Record<string, string[]> | undefined;
+    }, {
+      tables?: Record<string, string[]> | undefined;
+      enabled?: boolean | undefined;
+    }>>;
+    wal: zod0.ZodDefault<zod0.ZodOptional<zod0.ZodBoolean>>;
+  }, "strip", zod0.ZodTypeAny, {
+    url: string;
+    wal: boolean;
+    name?: string | undefined;
+    description?: string | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    tables?: string[] | undefined;
+    excludeTables?: string[] | undefined;
+    fts?: {
+      enabled: boolean;
+      tables?: Record<string, string[]> | undefined;
+    } | undefined;
+  }, {
+    url: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    accessMode?: "readonly" | "readwrite" | undefined;
+    tables?: string[] | undefined;
+    excludeTables?: string[] | undefined;
+    fts?: {
+      tables?: Record<string, string[]> | undefined;
+      enabled?: boolean | undefined;
+    } | undefined;
+    wal?: boolean | undefined;
+  }>;
+  /**
+       * Loads a module instance from configuration
+       */
+  static load({
+    parsed
+  }: AFSModuleLoadParams): Promise<SQLiteAFS>;
+  /**
+       * Called when the module is mounted to AFS
+       */
+  onMount(_afs: AFSRoot): Promise<void>;
+  /**
+       * Initializes the database connection and introspects schema
+       */
+  private initialize;
+  /**
+       * Ensures the module is initialized
+       */
+  private ensureInitialized;
+  /**
+       * Lists entries at a path
+       */
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  /**
+       * Reads an entry at a path
+       */
+  read(path: string, _options?: AFSReadOptions): Promise<AFSReadResult>;
+  /**
+       * Writes an entry at a path
+       */
+  write(path: string, content: AFSWriteEntryPayload, _options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  /**
+       * Deletes an entry at a path
+       */
+  delete(path: string, _options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+  /**
+       * Searches for entries matching a query
+       */
+  search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  /**
+       * Executes a module operation
+       */
+  exec(path: string, args: Record<string, unknown>, _options: AFSExecOptions): Promise<AFSExecResult>;
+  /**
+       * Lists available actions for a row
+       */
+  private listActions;
+  /**
+       * Executes an action
+       */
+  private executeAction;
+  /**
+       * Refreshes the schema cache
+       */
+  refreshSchema(): Promise<void>;
+  /**
+       * Exports table data in specified format
+       */
+  exportTable(table: string, format: string): Promise<unknown>;
+  /**
+       * Registers a custom action
+       */
+  registerAction(name: string, handler: (ctx: ActionContext, params: Record<string, unknown>) => Promise<unknown>, options?: {
+    description?: string;
+    tableLevel?: boolean;
+    rowLevel?: boolean;
+  }): void;
+  /**
+       * Gets table schemas (for external access)
+       */
+  getSchemas(): Map<string, TableSchema>;
+  /**
+       * Gets the database instance (for advanced operations)
+       */
+  getDatabase(): LibSQLDatabase;
+}
+//#endregion
+export { SQLiteAFS };
+//# sourceMappingURL=sqlite-afs.d.cts.map

package/dist/sqlite-afs.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-afs.d.cts","names":[],"sources":["../src/sqlite-afs.ts"],"mappings":";;;;;;;;;AAwCA;;;;;cAAa,SAAA,YAAqB,SAAA;EAAA,QAAA,OAAA;EAAA,SAAA,IAAA;EAAA,SAAA,WAAA;EAAA,SAAA,UAAA,EAGX,aAAA;EAAA,QAAA,EAAA;EAAA,QAAA,OAAA;EAAA,QAAA,MAAA;EAAA,QAAA,IAAA;EAAA,QAAA,SAAA;EAAA,QAAA,OAAA;EAAA,QAAA,SAAA;EAAA,QAAA,WAAA;EAAA,YAAA,OAAA,EAWQ,gBAAA;EAAA;;;EAAA,OAAA,OAAA,QAYhB,SAAA;IAAA,GAAA,EAZgC,IAAA,CAAA,SAAA;IAAA,IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmBf,mBAAA,GAAsB,OAAA,CAAQ,SAAA;EAAA;;;EAAA,QAAA,IAAA,EAQxC,OAAA,GAAU,OAAA;EAAA;;;EAAA,QAAA,UAAA;EAAA;;;EAAA,QAAA,iBAAA;EAAA;;;EAAA,KAAA,IAAA,UAAA,OAAA,GA8CK,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA;;;EAAA,KAAA,IAAA,UAAA,QAAA,GAgCxB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA;;;EAAA,MAAA,IAAA,UAAA,OAAA,EAmClD,oBAAA,EAAA,QAAA,GACE,eAAA,GACV,OAAA,CAAQ,cAAA;EAAA;;;EAAA,OAAA,IAAA,UAAA,QAAA,GA4C2B,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA;;;EAAA,OAAA,IAAA,UAAA,KAAA,UAAA,OAAA,GAsBb,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA;;;EAAA,KAAA,IAAA,UAAA,IAAA,EAkBvE,MAAA,mBAAA,QAAA,EACI,cAAA,GACT,OAAA,CAAQ,aAAA;EAAA;;;EAAA,QAAA,WAAA;EAAA;;;EAAA,QAAA,aAAA;EAAA;;;EAAA,cAAA,GA8EY,OAAA;EAAA;;;EAAA,YAAA,KAAA,UAAA,MAAA,WAc2B,OAAA;EAAA;;;EAAA,eAAA,IAAA,UAAA,OAAA,GAAA,GAAA,EAkCjC,aAAA,EAAA,MAAA,EAAuB,MAAA,sBAA4B,OAAA,WAAA,OAAA;IAAA,WAAA;IAAA,UAAA;IAAA,QAAA;EAAA;EAAA;;;EAAA,WAAA,GAoBtD,GAAA,SAAY,WAAA;EAAA;;;EAAA,YAAA,GAOX,cAAA;AAAA"}