@rozenite/sqlite-plugin 2.1.0 → 2.3.0

package/dist/react-native/cjs/src/shared/sql.js

@@ -0,0 +1,339 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.escapeSqlString = exports.quoteSqlIdentifier = exports.statementReturnsRows = exports.classifySqlStatement = exports.normalizeSingleStatementSql = exports.getStatementAtCursor = exports.splitSqlStatements = exports.countSqlStatements = void 0;
+const isWhitespace = (char) => /\s/.test(char);
+const countSqlStatements = (sql) => {
+    let count = 0;
+    let hasToken = false;
+    let i = 0;
+    let mode = null;
+    while (i < sql.length) {
+        const char = sql[i];
+        const next = sql[i + 1];
+        if (mode === 'line-comment') {
+            if (char === '\n') {
+                mode = null;
+            }
+            i += 1;
+            continue;
+        }
+        if (mode === 'block-comment') {
+            if (char === '*' && next === '/') {
+                mode = null;
+                i += 2;
+                continue;
+            }
+            i += 1;
+            continue;
+        }
+        if (mode === 'single-quote') {
+            if (char === "'" && next === "'") {
+                i += 2;
+                continue;
+            }
+            if (char === "'") {
+                mode = null;
+            }
+            i += 1;
+            continue;
+        }
+        if (mode === 'double-quote') {
+            if (char === '"' && next === '"') {
+                i += 2;
+                continue;
+            }
+            if (char === '"') {
+                mode = null;
+            }
+            i += 1;
+            continue;
+        }
+        if (mode === 'backtick') {
+            if (char === '`' && next === '`') {
+                i += 2;
+                continue;
+            }
+            if (char === '`') {
+                mode = null;
+            }
+            i += 1;
+            continue;
+        }
+        if (mode === 'bracket') {
+            if (char === ']' && next === ']') {
+                i += 2;
+                continue;
+            }
+            if (char === ']') {
+                mode = null;
+            }
+            i += 1;
+            continue;
+        }
+        if (char === '-' && next === '-') {
+            mode = 'line-comment';
+            i += 2;
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            mode = 'block-comment';
+            i += 2;
+            continue;
+        }
+        if (char === "'") {
+            mode = 'single-quote';
+            hasToken = true;
+            i += 1;
+            continue;
+        }
+        if (char === '"') {
+            mode = 'double-quote';
+            hasToken = true;
+            i += 1;
+            continue;
+        }
+        if (char === '`') {
+            mode = 'backtick';
+            hasToken = true;
+            i += 1;
+            continue;
+        }
+        if (char === '[') {
+            mode = 'bracket';
+            hasToken = true;
+            i += 1;
+            continue;
+        }
+        if (char === ';') {
+            if (hasToken) {
+                count += 1;
+                hasToken = false;
+            }
+            i += 1;
+            continue;
+        }
+        if (!isWhitespace(char)) {
+            hasToken = true;
+        }
+        i += 1;
+    }
+    if (hasToken) {
+        count += 1;
+    }
+    return count;
+};
+exports.countSqlStatements = countSqlStatements;
+const splitSqlStatements = (sql) => {
+    const segments = [];
+    let hasToken = false;
+    let segmentStart = 0;
+    let i = 0;
+    let mode = null;
+    const pushSegment = (end) => {
+        const text = sql.slice(segmentStart, end).trim();
+        if (text) {
+            segments.push({
+                text,
+                start: segmentStart,
+                end,
+            });
+        }
+        segmentStart = end + 1;
+        hasToken = false;
+    };
+    while (i < sql.length) {
+        const char = sql[i];
+        const next = sql[i + 1];
+        if (mode === 'line-comment') {
+            if (char === '\n') {
+                mode = null;
+            }
+            i += 1;
+            continue;
+        }
+        if (mode === 'block-comment') {
+            if (char === '*' && next === '/') {
+                mode = null;
+                i += 2;
+                continue;
+            }
+            i += 1;
+            continue;
+        }
+        if (mode === 'single-quote') {
+            if (char === "'" && next === "'") {
+                i += 2;
+                continue;
+            }
+            if (char === "'") {
+                mode = null;
+            }
+            i += 1;
+            continue;
+        }
+        if (mode === 'double-quote') {
+            if (char === '"' && next === '"') {
+                i += 2;
+                continue;
+            }
+            if (char === '"') {
+                mode = null;
+            }
+            i += 1;
+            continue;
+        }
+        if (mode === 'backtick') {
+            if (char === '`' && next === '`') {
+                i += 2;
+                continue;
+            }
+            if (char === '`') {
+                mode = null;
+            }
+            i += 1;
+            continue;
+        }
+        if (mode === 'bracket') {
+            if (char === ']' && next === ']') {
+                i += 2;
+                continue;
+            }
+            if (char === ']') {
+                mode = null;
+            }
+            i += 1;
+            continue;
+        }
+        if (char === '-' && next === '-') {
+            mode = 'line-comment';
+            i += 2;
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            mode = 'block-comment';
+            i += 2;
+            continue;
+        }
+        if (char === "'") {
+            mode = 'single-quote';
+            hasToken = true;
+            i += 1;
+            continue;
+        }
+        if (char === '"') {
+            mode = 'double-quote';
+            hasToken = true;
+            i += 1;
+            continue;
+        }
+        if (char === '`') {
+            mode = 'backtick';
+            hasToken = true;
+            i += 1;
+            continue;
+        }
+        if (char === '[') {
+            mode = 'bracket';
+            hasToken = true;
+            i += 1;
+            continue;
+        }
+        if (char === ';') {
+            if (hasToken) {
+                pushSegment(i);
+            }
+            else {
+                segmentStart = i + 1;
+            }
+            i += 1;
+            continue;
+        }
+        if (!isWhitespace(char)) {
+            hasToken = true;
+        }
+        i += 1;
+    }
+    if (hasToken) {
+        pushSegment(sql.length);
+    }
+    return segments;
+};
+exports.splitSqlStatements = splitSqlStatements;
+const getStatementAtCursor = (sql, cursor) => {
+    const segments = (0, exports.splitSqlStatements)(sql);
+    if (segments.length === 0) {
+        return null;
+    }
+    const match = segments.find((segment) => cursor >= segment.start && cursor <= segment.end + 1);
+    return match ?? segments[0];
+};
+exports.getStatementAtCursor = getStatementAtCursor;
+const normalizeSingleStatementSql = (sql) => {
+    const statementCount = (0, exports.countSqlStatements)(sql);
+    if (statementCount === 0) {
+        throw new Error('Query cannot be empty.');
+    }
+    if (statementCount > 1) {
+        throw new Error('Only a single SQL statement is supported in v1.');
+    }
+    return sql.trim().replace(/;\s*$/, '').trim();
+};
+exports.normalizeSingleStatementSql = normalizeSingleStatementSql;
+const readLeadingKeyword = (sql) => {
+    let i = 0;
+    while (i < sql.length) {
+        const char = sql[i];
+        const next = sql[i + 1];
+        if (isWhitespace(char)) {
+            i += 1;
+            continue;
+        }
+        if (char === '-' && next === '-') {
+            i += 2;
+            while (i < sql.length && sql[i] !== '\n') {
+                i += 1;
+            }
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            i += 2;
+            while (i < sql.length && !(sql[i] === '*' && sql[i + 1] === '/')) {
+                i += 1;
+            }
+            i += 2;
+            continue;
+        }
+        break;
+    }
+    const start = i;
+    while (i < sql.length && /[A-Za-z]/.test(sql[i])) {
+        i += 1;
+    }
+    return sql.slice(start, i).toLowerCase();
+};
+const classifySqlStatement = (sql) => {
+    const keyword = readLeadingKeyword(sql);
+    if (keyword === 'select' ||
+        keyword === 'insert' ||
+        keyword === 'update' ||
+        keyword === 'delete' ||
+        keyword === 'pragma' ||
+        keyword === 'create' ||
+        keyword === 'alter' ||
+        keyword === 'drop' ||
+        keyword === 'explain' ||
+        keyword === 'with') {
+        return keyword;
+    }
+    return 'other';
+};
+exports.classifySqlStatement = classifySqlStatement;
+const statementReturnsRows = (statementType) => statementType === 'select' ||
+    statementType === 'pragma' ||
+    statementType === 'explain' ||
+    statementType === 'with';
+exports.statementReturnsRows = statementReturnsRows;
+const quoteSqlIdentifier = (identifier) => `"${identifier.replace(/"/g, '""')}"`;
+exports.quoteSqlIdentifier = quoteSqlIdentifier;
+const escapeSqlString = (value) => `'${value.replace(/'/g, "''")}'`;
+exports.escapeSqlString = escapeSqlString;

package/dist/react-native/cjs/src/shared/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/react-native/package.json

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

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

@@ -0,0 +1,15 @@
+export type { SqliteAdapter, SqliteDatabaseInfo, SqliteDatabaseNode, SqliteExecuteStatementsError, SqliteExecuteStatementsRunner, SqliteQueryMetadata, SqliteQueryParams, SqliteQueryResult, SqliteScriptResult, SqliteScriptStatementResult, SqliteStatementExecutionResult, SqliteStatementInput, SqliteStatementType, } from './src/shared/types';
+export type { CreateSqliteAdapterOptions } from './src/react-native/adapters/generic';
+export type { CreateExpoSqliteAdapterOptions, ExpoSqliteLike, } from './src/react-native/adapters/expo-sqlite';
+export type { SqlStatementSegment } from './src/shared/sql';
+type CreateSqliteAdapter = typeof import('./src/react-native/adapters').createSqliteAdapter;
+type CreateExpoSqliteAdapter = typeof import('./src/react-native/adapters').createExpoSqliteAdapter;
+export declare let createSqliteAdapter: CreateSqliteAdapter;
+export declare let createExpoSqliteAdapter: CreateExpoSqliteAdapter;
+export declare let useRozeniteSqlitePlugin: typeof import('./src/react-native/useRozeniteSqlitePlugin').useRozeniteSqlitePlugin;
+export declare let classifySqlStatement: typeof import('./src/shared/sql').classifySqlStatement;
+export declare let normalizeSingleStatementSql: typeof import('./src/shared/sql').normalizeSingleStatementSql;
+export declare let splitSqlStatements: typeof import('./src/shared/sql').splitSqlStatements;
+export declare let statementReturnsRows: typeof import('./src/shared/sql').statementReturnsRows;
+export declare let decodeSqliteBridgeValue: typeof import('./src/shared/bridge-values').decodeSqliteBridgeValue;
+export declare let formatSqliteError: typeof import('./src/shared/bridge-values').formatSqliteError;

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

@@ -0,0 +1,43 @@
+export let createSqliteAdapter;
+export let createExpoSqliteAdapter;
+export let useRozeniteSqlitePlugin;
+export let classifySqlStatement;
+export let normalizeSingleStatementSql;
+export let splitSqlStatements;
+export let statementReturnsRows;
+export let decodeSqliteBridgeValue;
+export let formatSqliteError;
+const isDev = process.env.NODE_ENV !== 'production';
+const isWeb = typeof window !== 'undefined' && window.navigator.product !== 'ReactNative';
+const isServer = typeof window === 'undefined' && typeof lynx === 'undefined';
+if (isDev && !isWeb && !isServer) {
+    createSqliteAdapter = require('./src/react-native/adapters').createSqliteAdapter;
+    createExpoSqliteAdapter = require('./src/react-native/adapters').createExpoSqliteAdapter;
+    useRozeniteSqlitePlugin =
+        require('./src/react-native/useRozeniteSqlitePlugin').useRozeniteSqlitePlugin;
+    classifySqlStatement = require('./src/shared/sql').classifySqlStatement;
+    normalizeSingleStatementSql = require('./src/shared/sql').normalizeSingleStatementSql;
+    splitSqlStatements = require('./src/shared/sql').splitSqlStatements;
+    statementReturnsRows = require('./src/shared/sql').statementReturnsRows;
+    decodeSqliteBridgeValue = require('./src/shared/bridge-values').decodeSqliteBridgeValue;
+    formatSqliteError = require('./src/shared/bridge-values').formatSqliteError;
+}
+else {
+    createSqliteAdapter = (options) => ({
+        id: options.adapterId ?? 'sqlite',
+        name: options.adapterName ?? 'SQLite',
+        databases: [],
+    });
+    createExpoSqliteAdapter = (options) => ({
+        id: options.adapterId ?? 'expo-sqlite',
+        name: options.adapterName ?? 'Expo SQLite',
+        databases: [],
+    });
+    useRozeniteSqlitePlugin = () => null;
+    classifySqlStatement = () => 'other';
+    normalizeSingleStatementSql = (sql) => sql;
+    splitSqlStatements = () => [];
+    statementReturnsRows = (_type) => false;
+    decodeSqliteBridgeValue = (value) => value;
+    formatSqliteError = () => 'Unknown SQLite error.';
+}

package/dist/react-native/src/react-native/adapters/expo-sqlite.d.ts

@@ -0,0 +1,28 @@
+import type { SqliteAdapter } from '../../shared/types';
+export type ExpoSqliteLike = {
+    getAllAsync: (...args: any[]) => Promise<Record<string, unknown>[]>;
+    runAsync: (...args: any[]) => Promise<{
+        changes: number;
+        lastInsertRowId: number;
+    }>;
+};
+type SingleDatabaseOptions = {
+    database: ExpoSqliteLike | {
+        database: ExpoSqliteLike;
+        name?: string;
+    };
+    adapterId?: string;
+    adapterName?: string;
+    databaseName?: string;
+};
+type MultiDatabaseOptions = {
+    databases: Record<string, ExpoSqliteLike | {
+        database: ExpoSqliteLike;
+        name?: string;
+    }>;
+    adapterId?: string;
+    adapterName?: string;
+};
+export type CreateExpoSqliteAdapterOptions = SingleDatabaseOptions | MultiDatabaseOptions;
+export declare const createExpoSqliteAdapter: (options: CreateExpoSqliteAdapterOptions) => SqliteAdapter;
+export {};

package/dist/react-native/src/react-native/adapters/expo-sqlite.js

@@ -0,0 +1,117 @@
+import { classifySqlStatement, normalizeSingleStatementSql, statementReturnsRows, } from '../../shared/sql';
+import { decodeSqliteBridgeValue, formatSqliteError } from '../../shared/bridge-values';
+import { createSqliteAdapter } from './generic';
+const now = () => typeof performance !== 'undefined' && typeof performance.now === 'function'
+    ? performance.now()
+    : Date.now();
+const safeError = (error) => formatSqliteError(error);
+const createExecuteStatementsError = (message, options = {}) => Object.assign(new Error(message), options);
+const toBridgeSafeValue = (value) => {
+    if (value == null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    if (value instanceof Uint8Array) {
+        return Array.from(value);
+    }
+    if (value instanceof ArrayBuffer) {
+        return Array.from(new Uint8Array(value));
+    }
+    if (Array.isArray(value)) {
+        return value.map(toBridgeSafeValue);
+    }
+    if (typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [key, toBridgeSafeValue(nestedValue)]));
+    }
+    return String(value);
+};
+const normalizeRows = (rows) => rows.map((row) => Object.fromEntries(Object.entries(row).map(([key, value]) => [key, toBridgeSafeValue(value)])));
+const executeSingleStatement = async (database, { sql, params }) => {
+    const normalizedSql = normalizeSingleStatementSql(sql);
+    const statementType = classifySqlStatement(normalizedSql);
+    const startedAt = now();
+    const decodedParams = params === undefined ? undefined : decodeSqliteBridgeValue(params);
+    if (statementReturnsRows(statementType)) {
+        const rows = normalizeRows(decodedParams === undefined
+            ? await database.getAllAsync(normalizedSql)
+            : await database.getAllAsync(normalizedSql, decodedParams));
+        const durationMs = now() - startedAt;
+        return {
+            rows,
+            columns: Object.keys(rows[0] ?? {}),
+            metadata: {
+                statementType,
+                rowCount: rows.length,
+                changes: null,
+                lastInsertRowId: null,
+                durationMs,
+            },
+        };
+    }
+    const result = decodedParams === undefined
+        ? await database.runAsync(normalizedSql)
+        : await database.runAsync(normalizedSql, decodedParams);
+    const durationMs = now() - startedAt;
+    return {
+        rows: [],
+        columns: [],
+        metadata: {
+            statementType,
+            rowCount: 0,
+            changes: typeof result.changes === 'number' ? result.changes : null,
+            lastInsertRowId: typeof result.lastInsertRowId === 'number' ? result.lastInsertRowId : null,
+            durationMs,
+        },
+    };
+};
+const createExpoExecuteStatementsRunner = (database) => {
+    return async (statements) => {
+        const results = [];
+        for (let index = 0; index < statements.length; index += 1) {
+            try {
+                results.push(await executeSingleStatement(database, statements[index]));
+            }
+            catch (error) {
+                throw createExecuteStatementsError(safeError(error), {
+                    completedResults: results,
+                    failedStatementIndex: index,
+                    cause: error,
+                });
+            }
+        }
+        return results;
+    };
+};
+const resolveDatabaseConfig = (config) => ('database' in config ? config : { database: config });
+export const createExpoSqliteAdapter = (options) => {
+    const genericOptions = 'databases' in options
+        ? {
+            adapterId: options.adapterId ?? 'expo-sqlite',
+            adapterName: options.adapterName ?? 'Expo SQLite',
+            databases: Object.fromEntries(Object.entries(options.databases).map(([key, config]) => {
+                const resolved = resolveDatabaseConfig(config);
+                return [
+                    key,
+                    {
+                        name: resolved.name ?? key,
+                        executeStatements: createExpoExecuteStatementsRunner(resolved.database),
+                    },
+                ];
+            })),
+        }
+        : {
+            adapterId: options.adapterId ?? 'expo-sqlite',
+            adapterName: options.adapterName ?? 'Expo SQLite',
+            databaseName: options.databaseName,
+            database: (() => {
+                const resolved = resolveDatabaseConfig(options.database);
+                return {
+                    name: resolved.name ?? options.databaseName,
+                    executeStatements: createExpoExecuteStatementsRunner(resolved.database),
+                };
+            })(),
+        };
+    return createSqliteAdapter(genericOptions);
+};

package/dist/react-native/src/react-native/adapters/generic.d.ts

@@ -0,0 +1,19 @@
+import type { SqliteAdapter, SqliteExecuteStatementsRunner } from '../../shared/types';
+type SqliteDatabaseConfig = {
+    name?: string;
+    executeStatements: SqliteExecuteStatementsRunner;
+};
+type SingleDatabaseOptions = {
+    database: SqliteExecuteStatementsRunner | SqliteDatabaseConfig;
+    adapterId?: string;
+    adapterName?: string;
+    databaseName?: string;
+};
+type MultiDatabaseOptions = {
+    databases: Record<string, SqliteExecuteStatementsRunner | SqliteDatabaseConfig>;
+    adapterId?: string;
+    adapterName?: string;
+};
+export type CreateSqliteAdapterOptions = SingleDatabaseOptions | MultiDatabaseOptions;
+export declare const createSqliteAdapter: (options: CreateSqliteAdapterOptions) => SqliteAdapter;
+export {};

package/dist/react-native/src/react-native/adapters/generic.js

@@ -0,0 +1,29 @@
+const slugify = (value) => value
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '') || 'database';
+const createDatabaseId = (adapterId, seed, index) => `${adapterId}__${slugify(seed)}__${index.toString(36)}`;
+const resolveDatabaseConfig = (config) => typeof config === 'function' ? { executeStatements: config } : config;
+const toDatabaseNode = (adapterId, databaseKey, config, index, fallbackName) => {
+    const resolved = resolveDatabaseConfig(config);
+    const name = resolved.name ?? fallbackName ?? databaseKey;
+    return {
+        id: createDatabaseId(adapterId, `${databaseKey}-${name}`, index),
+        name,
+        executeStatements: resolved.executeStatements,
+    };
+};
+export const createSqliteAdapter = (options) => {
+    const { adapterId = 'sqlite', adapterName = 'SQLite' } = options;
+    const databases = 'databases' in options
+        ? Object.entries(options.databases).map(([key, config], index) => toDatabaseNode(adapterId, key, config, index))
+        : [
+            toDatabaseNode(adapterId, options.databaseName ?? 'default', options.database, 0, options.databaseName ?? 'Default Database'),
+        ];
+    return {
+        id: adapterId,
+        name: adapterName,
+        databases,
+    };
+};

package/dist/react-native/src/react-native/adapters/index.d.ts

@@ -0,0 +1,2 @@
+export { createSqliteAdapter, type CreateSqliteAdapterOptions } from './generic';
+export { createExpoSqliteAdapter, type CreateExpoSqliteAdapterOptions, type ExpoSqliteLike, } from './expo-sqlite';

package/dist/react-native/src/react-native/adapters/index.js

@@ -0,0 +1,2 @@
+export { createSqliteAdapter } from './generic';
+export { createExpoSqliteAdapter, } from './expo-sqlite';

package/dist/react-native/src/react-native/sqlite-view.d.ts

@@ -0,0 +1,5 @@
+import type { SqliteAdapter, SqliteDatabaseInfo, SqliteStatementInput } from '../shared/types';
+export type SqliteDatabaseView = SqliteDatabaseInfo & {
+    executeStatements: (statements: SqliteStatementInput[]) => ReturnType<SqliteAdapter['databases'][number]['executeStatements']>;
+};
+export declare const createSqliteDatabaseViews: (adapters: SqliteAdapter[]) => SqliteDatabaseView[];

package/dist/react-native/src/react-native/sqlite-view.js

@@ -0,0 +1,7 @@
+export const createSqliteDatabaseViews = (adapters) => adapters.flatMap((adapter) => adapter.databases.map((database) => ({
+    id: database.id,
+    name: database.name,
+    adapterId: adapter.id,
+    adapterName: adapter.name,
+    executeStatements: database.executeStatements,
+})));

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

@@ -0,0 +1,6 @@
+import { type SqliteEventMap } from '../shared/protocol';
+import type { SqliteAdapter } from '../shared/types';
+export type RozeniteSqlitePluginOptions = {
+    adapters: SqliteAdapter[];
+};
+export declare const useRozeniteSqlitePlugin: ({ adapters }: RozeniteSqlitePluginOptions) => import("@rozenite/plugin-bridge").RozeniteDevToolsRequestClient<SqliteEventMap> | null;