@rozenite/sqlite-plugin 2.2.0 → 2.3.0

package/dist/react-native/src/react-native/useRozeniteSqlitePlugin.js

@@ -0,0 +1,174 @@
+import { useRozeniteDevToolsClient } from '@rozenite/plugin-bridge';
+import { useEffect, useMemo, useRef } from 'react';
+import { formatSqliteError } from '../shared/bridge-values';
+import { PLUGIN_ID } from '../shared/protocol';
+import { normalizeSingleStatementSql, splitSqlStatements } from '../shared/sql';
+import { createSqliteDatabaseViews } from './sqlite-view';
+import { useSqliteAgentTools } from './useSqliteAgentTools';
+const safeError = (error) => formatSqliteError(error);
+const isExecuteStatementsError = (error) => error instanceof Error && ('completedResults' in error || 'failedStatementIndex' in error);
+export const useRozeniteSqlitePlugin = ({ adapters }) => {
+    const views = useMemo(() => createSqliteDatabaseViews(adapters), [adapters]);
+    useSqliteAgentTools(views);
+    const client = useRozeniteDevToolsClient({
+        pluginId: PLUGIN_ID,
+    });
+    const subscriptionsRef = useRef([]);
+    const databaseQueuesRef = useRef(new Map());
+    useEffect(() => {
+        if (!client) {
+            return;
+        }
+        const enqueueDatabaseTask = async (databaseId, task) => {
+            const queue = databaseQueuesRef.current.get(databaseId) ?? Promise.resolve();
+            const next = queue.catch(() => undefined).then(task);
+            databaseQueuesRef.current.set(databaseId, next.then(() => undefined, () => undefined));
+            return next;
+        };
+        const resolveDatabase = (databaseId) => {
+            const database = views.find((view) => view.id === databaseId);
+            if (!database) {
+                throw new Error(`Unknown database "${databaseId}".`);
+            }
+            return database;
+        };
+        const executeStatements = async (databaseId, statements) => {
+            const database = resolveDatabase(databaseId);
+            const normalizedStatements = statements.map(({ sql, params }) => ({
+                sql: normalizeSingleStatementSql(sql),
+                params,
+            }));
+            const results = await database.executeStatements(normalizedStatements);
+            if (results.length !== normalizedStatements.length) {
+                throw new Error(`Expected ${normalizedStatements.length} statement result(s), received ${results.length}.`);
+            }
+            return {
+                inputs: normalizedStatements,
+                results,
+            };
+        };
+        const executeSingleQuery = async (databaseId, sql, params) => {
+            const execution = await executeStatements(databaseId, [
+                {
+                    sql,
+                    params,
+                },
+            ]);
+            const result = execution.results[0];
+            if (!result) {
+                throw new Error('The query completed without a result payload.');
+            }
+            return result;
+        };
+        client.send('sqlite:ready', { timestamp: Date.now() });
+        subscriptionsRef.current.push(client.onMessage('sqlite:list-databases', ({ requestId }) => {
+            client.send('sqlite:list-databases:result', {
+                requestId,
+                databases: views.map(({ id, name, adapterId, adapterName }) => ({
+                    id,
+                    name,
+                    adapterId,
+                    adapterName,
+                })),
+            });
+        }));
+        subscriptionsRef.current.push(client.onMessage('sqlite:query', async ({ requestId, databaseId, sql, params }) => {
+            try {
+                const result = await enqueueDatabaseTask(databaseId, () => executeSingleQuery(databaseId, sql, params));
+                client.send('sqlite:query:result', {
+                    requestId,
+                    databaseId,
+                    result,
+                });
+            }
+            catch (error) {
+                client.send('sqlite:query:result', {
+                    requestId,
+                    databaseId,
+                    error: safeError(error),
+                });
+            }
+        }));
+        subscriptionsRef.current.push(client.onMessage('sqlite:execute-script', async ({ requestId, databaseId, sql }) => {
+            try {
+                const result = await enqueueDatabaseTask(databaseId, async () => {
+                    const statementSegments = splitSqlStatements(sql);
+                    if (statementSegments.length === 0) {
+                        throw new Error('Query cannot be empty.');
+                    }
+                    const statementInputs = statementSegments.map((statement) => ({
+                        sql: statement.text,
+                    }));
+                    try {
+                        const execution = await executeStatements(databaseId, statementInputs);
+                        return {
+                            statements: statementSegments.map((statement, index) => ({
+                                index,
+                                start: statement.start,
+                                end: statement.end,
+                                input: execution.inputs[index],
+                                execution: {
+                                    input: execution.inputs[index],
+                                    result: execution.results[index],
+                                },
+                            })),
+                            totalStatementCount: statementSegments.length,
+                            failedStatementIndex: null,
+                        };
+                    }
+                    catch (error) {
+                        if (!isExecuteStatementsError(error)) {
+                            throw error;
+                        }
+                        const failedStatementIndex = Math.max(0, Math.min(typeof error.failedStatementIndex === 'number'
+                            ? error.failedStatementIndex
+                            : (error.completedResults?.length ?? 0), statementSegments.length - 1));
+                        const completedResults = (error.completedResults ?? []).slice(0, failedStatementIndex);
+                        const completedStatements = completedResults.map((queryResult, index) => ({
+                            index,
+                            start: statementSegments[index].start,
+                            end: statementSegments[index].end,
+                            input: statementInputs[index],
+                            execution: {
+                                input: statementInputs[index],
+                                result: queryResult,
+                            },
+                        }));
+                        return {
+                            statements: [
+                                ...completedStatements,
+                                {
+                                    index: failedStatementIndex,
+                                    start: statementSegments[failedStatementIndex].start,
+                                    end: statementSegments[failedStatementIndex].end,
+                                    input: statementInputs[failedStatementIndex],
+                                    error: safeError(error),
+                                },
+                            ],
+                            totalStatementCount: statementSegments.length,
+                            failedStatementIndex,
+                        };
+                    }
+                });
+                client.send('sqlite:execute-script:result', {
+                    requestId,
+                    databaseId,
+                    result,
+                });
+            }
+            catch (error) {
+                client.send('sqlite:execute-script:result', {
+                    requestId,
+                    databaseId,
+                    error: safeError(error),
+                });
+            }
+        }));
+        return () => {
+            subscriptionsRef.current.forEach((subscription) => subscription.remove());
+            subscriptionsRef.current = [];
+            databaseQueuesRef.current.clear();
+        };
+    }, [client, views]);
+    return client;
+};

package/dist/react-native/src/react-native/useSqliteAgentTools.d.ts

@@ -0,0 +1,2 @@
+import type { SqliteDatabaseView } from './sqlite-view';
+export declare const useSqliteAgentTools: (views: SqliteDatabaseView[]) => void;

package/dist/react-native/src/react-native/useSqliteAgentTools.js

@@ -0,0 +1,111 @@
+import { useCallback } from 'react';
+import { useRozenitePluginAgentTool } from '@rozenite/agent-bridge';
+import { formatSqliteError } from '../shared/bridge-values';
+import { normalizeSingleStatementSql, splitSqlStatements } from '../shared/sql';
+const pluginId = '@rozenite/sqlite-plugin';
+const listDatabasesTool = {
+    name: 'list-databases',
+    description: 'List all registered SQLite databases.',
+    inputSchema: { type: 'object', properties: {} },
+};
+const executeSqlTool = {
+    name: 'execute-sql',
+    description: 'Execute one or more SQL statements against a database. Supports SELECT, INSERT, UPDATE, DELETE, PRAGMA, DDL, and multi-statement scripts. Returns per-statement results including rows, columns, and metadata. Statements are executed in order and stop on first error.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            databaseId: {
+                type: 'string',
+                description: 'Database ID from list-databases.',
+            },
+            sql: {
+                type: 'string',
+                description: 'SQL to execute. May contain multiple semicolon-separated statements.',
+            },
+        },
+        required: ['databaseId', 'sql'],
+    },
+};
+const isExecuteStatementsError = (error) => error instanceof Error && ('completedResults' in error || 'failedStatementIndex' in error);
+export const useSqliteAgentTools = (views) => {
+    const resolveDatabase = useCallback((databaseId) => {
+        const database = views.find((view) => view.id === databaseId);
+        if (!database) {
+            const available = views.map((v) => v.id).join(', ');
+            throw new Error(`Unknown databaseId "${databaseId}". Available: ${available || '(none)'}`);
+        }
+        return database;
+    }, [views]);
+    useRozenitePluginAgentTool({
+        pluginId,
+        tool: listDatabasesTool,
+        handler: () => ({
+            databases: views.map(({ id, name, adapterId, adapterName }) => ({
+                id,
+                name,
+                adapterId,
+                adapterName,
+            })),
+        }),
+    });
+    useRozenitePluginAgentTool({
+        pluginId,
+        tool: executeSqlTool,
+        handler: async ({ databaseId, sql }) => {
+            const database = resolveDatabase(databaseId);
+            const statementSegments = splitSqlStatements(sql);
+            if (statementSegments.length === 0) {
+                throw new Error('SQL cannot be empty.');
+            }
+            const statementInputs = statementSegments.map((segment) => ({
+                sql: normalizeSingleStatementSql(segment.text),
+            }));
+            try {
+                const results = await database.executeStatements(statementInputs);
+                return {
+                    databaseId,
+                    totalStatementCount: statementSegments.length,
+                    failedStatementIndex: null,
+                    statements: statementSegments.map((_, index) => {
+                        const result = results[index];
+                        return {
+                            index,
+                            sql: statementInputs[index].sql,
+                            rows: result.rows,
+                            columns: result.columns,
+                            metadata: result.metadata,
+                        };
+                    }),
+                };
+            }
+            catch (error) {
+                if (!isExecuteStatementsError(error)) {
+                    throw new Error(formatSqliteError(error));
+                }
+                const failedStatementIndex = Math.max(0, Math.min(typeof error.failedStatementIndex === 'number'
+                    ? error.failedStatementIndex
+                    : (error.completedResults?.length ?? 0), statementSegments.length - 1));
+                const completedResults = (error.completedResults ?? []).slice(0, failedStatementIndex);
+                return {
+                    databaseId,
+                    totalStatementCount: statementSegments.length,
+                    failedStatementIndex,
+                    statements: [
+                        ...completedResults.map((result, index) => ({
+                            index,
+                            sql: statementInputs[index].sql,
+                            rows: result.rows,
+                            columns: result.columns,
+                            metadata: result.metadata,
+                        })),
+                        {
+                            index: failedStatementIndex,
+                            sql: statementInputs[failedStatementIndex].sql,
+                            error: formatSqliteError(error),
+                        },
+                    ],
+                };
+            }
+        },
+    });
+};

package/dist/react-native/src/shared/bridge-values.d.ts

@@ -0,0 +1,3 @@
+export declare const encodeSqliteBridgeValue: (value: unknown) => unknown;
+export declare const decodeSqliteBridgeValue: (value: unknown) => unknown;
+export declare const formatSqliteError: (error: unknown) => string;

package/dist/react-native/src/shared/bridge-values.js

@@ -0,0 +1,120 @@
+const SQLITE_BRIDGE_BINARY_TYPE = '__rozeniteSqliteBinary';
+const isRecord = (value) => !!value && typeof value === 'object';
+const isEncodedBinaryValue = (value) => isRecord(value) &&
+    value[SQLITE_BRIDGE_BINARY_TYPE] === true &&
+    Array.isArray(value.data) &&
+    value.data.every((item) => typeof item === 'number');
+export const encodeSqliteBridgeValue = (value) => {
+    if (value == null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    if (value instanceof Uint8Array) {
+        return {
+            [SQLITE_BRIDGE_BINARY_TYPE]: true,
+            data: Array.from(value),
+        };
+    }
+    if (value instanceof ArrayBuffer) {
+        return {
+            [SQLITE_BRIDGE_BINARY_TYPE]: true,
+            data: Array.from(new Uint8Array(value)),
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map(encodeSqliteBridgeValue);
+    }
+    if (isRecord(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [
+            key,
+            encodeSqliteBridgeValue(nestedValue),
+        ]));
+    }
+    return String(value);
+};
+export const decodeSqliteBridgeValue = (value) => {
+    if (value == null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    if (isEncodedBinaryValue(value)) {
+        return new Uint8Array(value.data);
+    }
+    if (Array.isArray(value)) {
+        return value.map(decodeSqliteBridgeValue);
+    }
+    if (isRecord(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [
+            key,
+            decodeSqliteBridgeValue(nestedValue),
+        ]));
+    }
+    return value;
+};
+const getStringField = (value, key) => {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const field = value[key];
+    if (typeof field !== 'string') {
+        return null;
+    }
+    const trimmed = field.trim();
+    return trimmed ? trimmed : null;
+};
+const stringifyFallback = (value) => {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+};
+const describeError = (error) => {
+    if (error instanceof Error) {
+        const code = getStringField(error, 'code');
+        const reason = getStringField(error, 'reason');
+        const message = error.message.trim();
+        const detailParts = [message || null, reason].filter((part, index, parts) => !!part && parts.indexOf(part) === index);
+        const detail = detailParts.join(' | ') || error.name;
+        return code ? `[${code}] ${detail}` : detail;
+    }
+    if (isRecord(error)) {
+        const code = getStringField(error, 'code');
+        const message = getStringField(error, 'message');
+        const reason = getStringField(error, 'reason');
+        const detail = message ?? reason ?? stringifyFallback(error);
+        return code ? `[${code}] ${detail}` : detail;
+    }
+    if (typeof error === 'string') {
+        return error.trim() || null;
+    }
+    if (error == null) {
+        return null;
+    }
+    return stringifyFallback(error);
+};
+const getCause = (error) => {
+    if (!isRecord(error)) {
+        return undefined;
+    }
+    return error.cause;
+};
+export const formatSqliteError = (error) => {
+    const visited = new Set();
+    const parts = [];
+    let current = error;
+    while (current !== undefined && current !== null && !visited.has(current)) {
+        visited.add(current);
+        const description = describeError(current);
+        if (description && !parts.includes(description)) {
+            parts.push(description);
+        }
+        current = getCause(current);
+    }
+    return parts.join('\nCaused by: ') || 'Unknown SQLite error.';
+};

package/dist/react-native/src/shared/protocol.d.ts

@@ -0,0 +1,38 @@
+import type { SqliteDatabaseInfo, SqliteQueryParams, SqliteQueryResult, SqliteScriptResult } from './types';
+export declare const PLUGIN_ID = "@rozenite/sqlite-plugin";
+export type SqliteEventMap = {
+    'sqlite:ready': {
+        timestamp: number;
+    };
+    'sqlite:list-databases': {
+        requestId: string;
+    };
+    'sqlite:list-databases:result': {
+        requestId: string;
+        databases: SqliteDatabaseInfo[];
+        error?: string;
+    };
+    'sqlite:query': {
+        requestId: string;
+        databaseId: string;
+        sql: string;
+        params?: SqliteQueryParams;
+    };
+    'sqlite:query:result': {
+        requestId: string;
+        databaseId: string;
+        result?: SqliteQueryResult;
+        error?: string;
+    };
+    'sqlite:execute-script': {
+        requestId: string;
+        databaseId: string;
+        sql: string;
+    };
+    'sqlite:execute-script:result': {
+        requestId: string;
+        databaseId: string;
+        result?: SqliteScriptResult;
+        error?: string;
+    };
+};

package/dist/react-native/src/shared/protocol.js

@@ -0,0 +1 @@
+export const PLUGIN_ID = '@rozenite/sqlite-plugin';

package/dist/react-native/src/shared/sql.d.ts

@@ -0,0 +1,14 @@
+import type { SqliteStatementType } from './types';
+export declare const countSqlStatements: (sql: string) => number;
+export type SqlStatementSegment = {
+    text: string;
+    start: number;
+    end: number;
+};
+export declare const splitSqlStatements: (sql: string) => SqlStatementSegment[];
+export declare const getStatementAtCursor: (sql: string, cursor: number) => SqlStatementSegment | null;
+export declare const normalizeSingleStatementSql: (sql: string) => string;
+export declare const classifySqlStatement: (sql: string) => SqliteStatementType;
+export declare const statementReturnsRows: (statementType: SqliteStatementType) => statementType is "select" | "pragma" | "explain" | "with";
+export declare const quoteSqlIdentifier: (identifier: string) => string;
+export declare const escapeSqlString: (value: string) => string;