@aigne/afs-sqlite 1.0.1-beta

package/lib/cjs/operations/crud.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CRUDOperations = void 0;
+const sqlite_1 = require("@aigne/sqlite");
+const builder_js_1 = require("../node/builder.js");
+const query_builder_js_1 = require("./query-builder.js");
+/**
+ * Executes a raw SQL query and returns all rows
+ */
+async function execAll(db, query) {
+    return db.all(sqlite_1.sql.raw(query)).execute();
+}
+/**
+ * Executes a raw SQL query (for INSERT, UPDATE, DELETE)
+ */
+async function execRun(db, query) {
+    await db.run(sqlite_1.sql.raw(query)).execute();
+}
+/**
+ * CRUD operations for SQLite AFS
+ */
+class CRUDOperations {
+    db;
+    schemas;
+    basePath;
+    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) {
+            // Get row count for each table
+            const countResult = await execAll(this.db, `SELECT COUNT(*) as count FROM "${name}"`);
+            const rowCount = countResult[0]?.count ?? 0;
+            entries.push((0, builder_js_1.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 = (0, query_builder_js_1.buildSelectAll)(table, {
+            limit: options?.limit ?? 100,
+            orderBy: options?.orderBy,
+        });
+        const rows = await execAll(this.db, queryStr);
+        const entries = rows.map((row) => (0, builder_js_1.buildRowEntry)(table, schema, row, buildOptions));
+        return { data: entries };
+    }
+    /**
+     * 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 rows = await execAll(this.db, (0, query_builder_js_1.buildSelectByPK)(table, schema, pk));
+        const row = rows[0];
+        if (!row) {
+            return { message: `Row with pk '${pk}' not found in table '${table}'` };
+        }
+        return { data: (0, builder_js_1.buildRowEntry)(table, schema, row, buildOptions) };
+    }
+    /**
+     * Gets table schema
+     */
+    getSchema(table) {
+        const schema = this.schemas.get(table);
+        if (!schema) {
+            return { message: `Table '${table}' not found` };
+        }
+        const buildOptions = { basePath: this.basePath };
+        return { data: (0, builder_js_1.buildSchemaEntry)(table, schema, buildOptions) };
+    }
+    /**
+     * 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 rows = await execAll(this.db, (0, query_builder_js_1.buildSelectByPK)(table, schema, pk));
+        const row = rows[0];
+        if (!row) {
+            return { data: [], message: `Row with pk '${pk}' not found` };
+        }
+        return { data: (0, builder_js_1.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` };
+        }
+        // Validate column exists
+        const colInfo = schema.columns.find((c) => c.name === column);
+        if (!colInfo) {
+            return { message: `Column '${column}' not found in table '${table}'` };
+        }
+        const buildOptions = { basePath: this.basePath };
+        const rows = await execAll(this.db, (0, query_builder_js_1.buildSelectByPK)(table, schema, pk));
+        if (rows.length === 0) {
+            return { message: `Row with pk '${pk}' not found` };
+        }
+        return {
+            data: (0, builder_js_1.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 rows = await execAll(this.db, (0, query_builder_js_1.buildSelectByPK)(table, schema, pk));
+        const row = rows[0];
+        if (!row) {
+            return { message: `Row with pk '${pk}' not found` };
+        }
+        return { data: (0, builder_js_1.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 };
+        // Insert the row
+        await execRun(this.db, (0, query_builder_js_1.buildInsert)(table, schema, content));
+        // Get the last inserted rowid
+        const lastIdResult = await execAll(this.db, (0, query_builder_js_1.buildGetLastRowId)());
+        const lastId = lastIdResult[0]?.id;
+        if (lastId === undefined) {
+            throw new Error("Failed to get last inserted row ID");
+        }
+        // Fetch the inserted row
+        const pkColumn = schema.primaryKey[0] ?? "rowid";
+        const pk = content[pkColumn] !== undefined ? String(content[pkColumn]) : String(lastId);
+        const rows = await execAll(this.db, (0, query_builder_js_1.buildSelectByPK)(table, schema, pk));
+        const row = rows[0];
+        if (!row) {
+            throw new Error("Failed to fetch inserted row");
+        }
+        return { data: (0, builder_js_1.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 };
+        // Update the row
+        await execRun(this.db, (0, query_builder_js_1.buildUpdate)(table, schema, pk, content));
+        // Fetch the updated row
+        const rows = await execAll(this.db, (0, query_builder_js_1.buildSelectByPK)(table, schema, pk));
+        const row = rows[0];
+        if (!row) {
+            throw new Error(`Row with pk '${pk}' not found after update`);
+        }
+        return { data: (0, builder_js_1.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`);
+        }
+        // Check if row exists first
+        const existing = await execAll(this.db, (0, query_builder_js_1.buildSelectByPK)(table, schema, pk));
+        if (existing.length === 0) {
+            return { message: `Row with pk '${pk}' not found in table '${table}'` };
+        }
+        // Delete the row
+        await execRun(this.db, (0, query_builder_js_1.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;
+    }
+}
+exports.CRUDOperations = CRUDOperations;

package/lib/cjs/operations/query-builder.d.ts

@@ -0,0 +1,37 @@
+import type { TableSchema } from "../schema/types.js";
+/**
+ * Builds a SELECT query string for a single row by primary key
+ */
+export declare function buildSelectByPK(tableName: string, schema: TableSchema, pk: string): string;
+/**
+ * Builds a SELECT query string for listing rows with optional limit and offset
+ */
+export declare function buildSelectAll(tableName: string, options?: {
+    limit?: number;
+    offset?: number;
+    orderBy?: [string, "asc" | "desc"][];
+}): string;
+/**
+ * Builds an INSERT query string from content object
+ */
+export declare function buildInsert(tableName: string, schema: TableSchema, content: Record<string, unknown>): string;
+/**
+ * Builds an UPDATE query string from content object
+ */
+export declare function buildUpdate(tableName: string, schema: TableSchema, pk: string, content: Record<string, unknown>): string;
+/**
+ * Builds a DELETE query string by primary key
+ */
+export declare function buildDelete(tableName: string, schema: TableSchema, pk: string): string;
+/**
+ * Formats a value for SQL insertion
+ */
+export declare function formatValue(value: unknown): string;
+/**
+ * Escapes a string for safe SQL insertion
+ */
+export declare function escapeSQLString(str: string): string;
+/**
+ * Gets the last inserted rowid query string
+ */
+export declare function buildGetLastRowId(): string;

package/lib/cjs/operations/query-builder.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSelectByPK = buildSelectByPK;
+exports.buildSelectAll = buildSelectAll;
+exports.buildInsert = buildInsert;
+exports.buildUpdate = buildUpdate;
+exports.buildDelete = buildDelete;
+exports.formatValue = formatValue;
+exports.escapeSQLString = escapeSQLString;
+exports.buildGetLastRowId = buildGetLastRowId;
+/**
+ * Builds a SELECT query string for a single row by primary key
+ */
+function buildSelectByPK(tableName, schema, pk) {
+    const pkColumn = schema.primaryKey[0] ?? "rowid";
+    return `SELECT * FROM "${tableName}" WHERE "${pkColumn}" = '${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 !== undefined) {
+        query += ` LIMIT ${options.limit}`;
+    }
+    if (options?.offset !== undefined) {
+        query += ` OFFSET ${options.offset}`;
+    }
+    return query;
+}
+/**
+ * Builds an INSERT query string from content object
+ */
+function buildInsert(tableName, schema, content) {
+    // Filter to only valid columns
+    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}`);
+    }
+    const columns = entries.map(([key]) => `"${key}"`).join(", ");
+    const values = entries.map(([, value]) => formatValue(value)).join(", ");
+    return `INSERT INTO "${tableName}" (${columns}) VALUES (${values})`;
+}
+/**
+ * Builds an UPDATE query string from content object
+ */
+function buildUpdate(tableName, schema, pk, content) {
+    const pkColumn = schema.primaryKey[0] ?? "rowid";
+    // Filter to only valid columns, excluding PK
+    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}`);
+    }
+    const setClauses = entries.map(([key, value]) => `"${key}" = ${formatValue(value)}`).join(", ");
+    return `UPDATE "${tableName}" SET ${setClauses} WHERE "${pkColumn}" = '${escapeSQLString(pk)}'`;
+}
+/**
+ * Builds a DELETE query string by primary key
+ */
+function buildDelete(tableName, schema, pk) {
+    const pkColumn = schema.primaryKey[0] ?? "rowid";
+    return `DELETE FROM "${tableName}" WHERE "${pkColumn}" = '${escapeSQLString(pk)}'`;
+}
+/**
+ * Formats a value for SQL insertion
+ */
+function formatValue(value) {
+    if (value === null || value === undefined) {
+        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";
+}

package/lib/cjs/operations/search.d.ts

@@ -0,0 +1,75 @@
+import type { AFSSearchOptions, AFSSearchResult } from "@aigne/afs";
+import type { LibSQLDatabase } from "drizzle-orm/libsql";
+import type { TableSchema } from "../schema/types.js";
+/**
+ * FTS5 search configuration for a table
+ */
+export interface FTSTableConfig {
+    /** Columns to include in FTS index */
+    columns: string[];
+    /** Whether FTS table has been created */
+    initialized?: boolean;
+}
+/**
+ * FTS5 search configuration
+ */
+export interface FTSConfig {
+    /** Whether FTS is enabled */
+    enabled: boolean;
+    /** Per-table FTS configuration */
+    tables: Map<string, FTSTableConfig>;
+}
+/**
+ * FTS5 Search operations for SQLite AFS
+ */
+export declare class FTSSearch {
+    private db;
+    private schemas;
+    private config;
+    private basePath;
+    constructor(db: LibSQLDatabase, schemas: Map<string, TableSchema>, config: FTSConfig, basePath?: string);
+    /**
+     * Performs full-text search across configured tables
+     */
+    search(query: string, options?: AFSSearchOptions & {
+        /** Specific tables to search (defaults to all FTS-enabled tables) */
+        tables?: string[];
+    }): Promise<AFSSearchResult>;
+    /**
+     * Searches within a specific table
+     */
+    searchTable(tableName: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+    /**
+     * Checks if FTS is configured for a table
+     */
+    hasFTS(tableName: string): boolean;
+    /**
+     * Gets FTS configuration for a table
+     */
+    getFTSConfig(tableName: string): FTSTableConfig | undefined;
+    /**
+     * Checks if an FTS table exists
+     */
+    private ftsTableExists;
+    /**
+     * Prepares a query string for FTS5
+     * Handles special characters and case sensitivity
+     */
+    private prepareFTSQuery;
+    /**
+     * Updates the schemas map (after refresh)
+     */
+    setSchemas(schemas: Map<string, TableSchema>): void;
+    /**
+     * Simple search fallback when FTS is not available
+     * Uses LIKE queries on specified columns
+     */
+    simpleLikeSearch(tableName: string, query: string, columns: string[], options?: AFSSearchOptions): Promise<AFSSearchResult>;
+}
+/**
+ * Creates FTS configuration from options
+ */
+export declare function createFTSConfig(options?: {
+    enabled?: boolean;
+    tables?: Record<string, string[]>;
+}): FTSConfig;

package/lib/cjs/operations/search.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FTSSearch = void 0;
+exports.createFTSConfig = createFTSConfig;
+const sqlite_1 = require("@aigne/sqlite");
+const builder_js_1 = require("../node/builder.js");
+/**
+ * Executes a raw SQL query and returns all rows
+ */
+async function execAll(db, query) {
+    return db.all(sqlite_1.sql.raw(query)).execute();
+}
+/**
+ * FTS5 Search operations for SQLite AFS
+ */
+class FTSSearch {
+    db;
+    schemas;
+    config;
+    basePath;
+    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 };
+        // Determine which tables to search
+        const tablesToSearch = options?.tables
+            ? options.tables.filter((t) => this.config.tables.has(t))
+            : Array.from(this.config.tables.keys());
+        // Escape and prepare the query for FTS5
+        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 {
+                // Check if FTS table exists
+                const ftsExists = await this.ftsTableExists(ftsTableName);
+                if (!ftsExists)
+                    continue;
+                // Get the first column for highlighting
+                const highlightColumn = tableConfig.columns[0] ?? "";
+                const highlightIndex = highlightColumn ? tableConfig.columns.indexOf(highlightColumn) : 0;
+                // Build FTS query with highlight
+                const rows = await execAll(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((0, builder_js_1.buildSearchEntry)(tableName, schema, rowData, snippet, buildOptions));
+                }
+            }
+            catch (error) {
+                // Log but continue with other tables
+                console.warn(`FTS search failed for table ${tableName}:`, error);
+            }
+            // Stop if we have enough results
+            if (results.length >= limit)
+                break;
+        }
+        return {
+            data: results.slice(0, limit),
+            message: results.length === 0 ? `No results found for "${query}"` : undefined,
+        };
+    }
+    /**
+     * 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) {
+        const result = await execAll(this.db, `SELECT name FROM sqlite_master WHERE type = 'table' AND name = '${ftsTableName}'`);
+        return result.length > 0;
+    }
+    /**
+     * Prepares a query string for FTS5
+     * Handles special characters and case sensitivity
+     */
+    prepareFTSQuery(query, _caseSensitive) {
+        // Escape special FTS5 characters
+        let prepared = query
+            .replace(/"/g, '""') // Escape double quotes
+            .replace(/'/g, "''"); // Escape single quotes
+        // For case-insensitive search (default), we don't need to modify
+        // FTS5 is case-insensitive by default for ASCII
+        // If the query contains multiple words, search for the phrase
+        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, "''");
+        // Build LIKE conditions for each column
+        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" };
+        }
+        const rows = await execAll(this.db, `SELECT * FROM "${tableName}" WHERE ${conditions} LIMIT ${limit}`);
+        return {
+            data: rows.map((row) => (0, builder_js_1.buildSearchEntry)(tableName, schema, row, undefined, buildOptions)),
+        };
+    }
+}
+exports.FTSSearch = FTSSearch;
+/**
+ * Creates FTS configuration from options
+ */
+function createFTSConfig(options) {
+    const config = {
+        enabled: options?.enabled ?? false,
+        tables: new Map(),
+    };
+    if (options?.tables) {
+        for (const [table, columns] of Object.entries(options.tables)) {
+            config.tables.set(table, { columns });
+        }
+    }
+    return config;
+}

package/lib/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/lib/cjs/router/path-router.d.ts

@@ -0,0 +1,38 @@
+import { type RadixRouter } from "radix3";
+import type { RouteData, RouteMatch } from "./types.js";
+export type { RouteData };
+/**
+ * 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
+ */
+export declare function createPathRouter(): RadixRouter<RouteData>;
+/**
+ * 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
+ */
+export declare function matchPath(router: RadixRouter<RouteData>, path: string): RouteMatch | undefined;
+/**
+ * Builds a path from components
+ */
+export declare function buildPath(table?: string, pk?: string, suffix?: string): string;
+/**
+ * Checks if a path segment is a virtual path (@attr, @meta, @actions, @schema)
+ */
+export declare function isVirtualPath(segment: string): boolean;
+/**
+ * Gets the type of virtual path
+ */
+export declare function getVirtualPathType(segment: string): "attr" | "meta" | "actions" | "schema" | null;