@rozenite/sqlite-plugin 1.7.0-rc.0

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

@@ -0,0 +1,178 @@
+import { RozeniteDevToolsClient } from '../../../plugin-bridge/src/index.ts';
+
+declare type CreateExpoSqliteAdapter = createExpoSqliteAdapter_2;
+
+export declare let createExpoSqliteAdapter: CreateExpoSqliteAdapter;
+
+declare const createExpoSqliteAdapter_2: (options: CreateExpoSqliteAdapterOptions) => SqliteAdapter;
+
+export declare type CreateExpoSqliteAdapterOptions = SingleDatabaseOptions_2 | MultiDatabaseOptions_2;
+
+declare type CreateSqliteAdapter = createSqliteAdapter_2;
+
+export declare let createSqliteAdapter: CreateSqliteAdapter;
+
+declare const createSqliteAdapter_2: (options: CreateSqliteAdapterOptions) => SqliteAdapter;
+
+export declare type CreateSqliteAdapterOptions = SingleDatabaseOptions | MultiDatabaseOptions;
+
+export declare type ExpoSqliteLike = {
+    getAllAsync: (...args: any[]) => Promise<Record<string, unknown>[]>;
+    runAsync: (...args: any[]) => Promise<{
+        changes: number;
+        lastInsertRowId: number;
+    }>;
+};
+
+declare type MultiDatabaseOptions = {
+    databases: Record<string, SqliteExecuteStatementsRunner | SqliteDatabaseConfig>;
+    adapterId?: string;
+    adapterName?: string;
+};
+
+declare type MultiDatabaseOptions_2 = {
+    databases: Record<string, ExpoSqliteLike | {
+        database: ExpoSqliteLike;
+        name?: string;
+    }>;
+    adapterId?: string;
+    adapterName?: string;
+};
+
+declare type RozeniteSqlitePluginOptions = {
+    adapters: SqliteAdapter[];
+};
+
+declare type SingleDatabaseOptions = {
+    database: SqliteExecuteStatementsRunner | SqliteDatabaseConfig;
+    adapterId?: string;
+    adapterName?: string;
+    databaseName?: string;
+};
+
+declare type SingleDatabaseOptions_2 = {
+    database: ExpoSqliteLike | {
+        database: ExpoSqliteLike;
+        name?: string;
+    };
+    adapterId?: string;
+    adapterName?: string;
+    databaseName?: string;
+};
+
+export declare type SqliteAdapter = {
+    id: string;
+    name: string;
+    databases: SqliteDatabaseNode[];
+};
+
+declare type SqliteDatabaseConfig = {
+    name?: string;
+    executeStatements: SqliteExecuteStatementsRunner;
+};
+
+export declare type SqliteDatabaseInfo = {
+    id: string;
+    name: string;
+    adapterId: string;
+    adapterName: string;
+};
+
+export declare type SqliteDatabaseNode = {
+    id: string;
+    name: string;
+    executeStatements: SqliteExecuteStatementsRunner;
+};
+
+declare 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;
+    };
+};
+
+export declare type SqliteExecuteStatementsError = Error & {
+    completedResults?: SqliteQueryResult[];
+    failedStatementIndex?: number;
+};
+
+export declare type SqliteExecuteStatementsRunner = (statements: SqliteStatementInput[]) => Promise<SqliteQueryResult[]>;
+
+export declare type SqliteQueryMetadata = {
+    statementType: SqliteStatementType;
+    rowCount: number;
+    changes: number | null;
+    lastInsertRowId: number | null;
+    durationMs: number;
+};
+
+export declare type SqliteQueryParams = unknown[] | Record<string, unknown>;
+
+export declare type SqliteQueryResult = {
+    rows: Record<string, unknown>[];
+    columns: string[];
+    metadata: SqliteQueryMetadata;
+};
+
+export declare type SqliteScriptResult = {
+    statements: SqliteScriptStatementResult[];
+    totalStatementCount: number;
+    failedStatementIndex: number | null;
+};
+
+export declare type SqliteScriptStatementResult = {
+    index: number;
+    start: number;
+    end: number;
+    input: SqliteStatementInput;
+    execution?: SqliteStatementExecutionResult;
+    error?: string;
+};
+
+export declare type SqliteStatementExecutionResult = {
+    input: SqliteStatementInput;
+    result: SqliteQueryResult;
+};
+
+export declare type SqliteStatementInput = {
+    sql: string;
+    params?: SqliteQueryParams;
+};
+
+export declare type SqliteStatementType = 'select' | 'insert' | 'update' | 'delete' | 'pragma' | 'create' | 'alter' | 'drop' | 'explain' | 'with' | 'other';
+
+export declare let useRozeniteSqlitePlugin: useRozeniteSqlitePlugin_2;
+
+declare const useRozeniteSqlitePlugin_2: ({ adapters, }: RozeniteSqlitePluginOptions) => RozeniteDevToolsClient<SqliteEventMap> | null;
+
+export { }

package/dist/react-native/index.js

@@ -0,0 +1,16 @@
+let t, a, i;
+const r = typeof window < "u" && window.navigator.product !== "ReactNative", d = process.env.NODE_ENV !== "production", n = typeof window > "u";
+d && !r && !n ? (t = require("./chunks/index.require.js").createSqliteAdapter, a = require("./chunks/index.require.js").createExpoSqliteAdapter, i = require("./chunks/useRozeniteSqlitePlugin.require.js").useRozeniteSqlitePlugin) : (t = (e) => ({
+  id: e.adapterId ?? "sqlite",
+  name: e.adapterName ?? "SQLite",
+  databases: []
+}), a = (e) => ({
+  id: e.adapterId ?? "expo-sqlite",
+  name: e.adapterName ?? "Expo SQLite",
+  databases: []
+}), i = () => null);
+export {
+  a as createExpoSqliteAdapter,
+  t as createSqliteAdapter,
+  i as useRozeniteSqlitePlugin
+};

package/dist/rozenite.json

@@ -0,0 +1 @@
+{"name":"@rozenite/sqlite-plugin","version":"1.7.0-rc.0","description":"SQLite inspector for Rozenite.","panels":[{"name":"SQLite","source":"/devtools/panel.html"}]}

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@rozenite/sqlite-plugin",
+  "version": "1.7.0-rc.0",
+  "description": "SQLite inspector for Rozenite.",
+  "type": "module",
+  "main": "./dist/react-native/index.cjs",
+  "module": "./dist/react-native/index.js",
+  "types": "./dist/react-native/index.d.ts",
+  "homepage": "https://github.com/callstackincubator/rozenite#readme",
+  "bugs": {
+    "url": "https://github.com/callstackincubator/rozenite/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/callstackincubator/rozenite.git"
+  },
+  "dependencies": {
+    "@rozenite/plugin-bridge": "1.6.0"
+  },
+  "devDependencies": {
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/sortable": "^8.0.0",
+    "@codemirror/autocomplete": "^6.20.1",
+    "@codemirror/commands": "^6.10.3",
+    "@codemirror/lang-sql": "^6.10.0",
+    "@codemirror/language": "^6.12.3",
+    "@codemirror/search": "^6.6.0",
+    "@codemirror/state": "^6.6.0",
+    "@codemirror/view": "^6.40.0",
+    "@heroui/react": "^3.0.1",
+    "@heroui/styles": "^3.0.1",
+    "@lezer/highlight": "^1.2.3",
+    "@tailwindcss/postcss": "^4.2.2",
+    "@tanstack/react-table": "^8.21.3",
+    "@tanstack/react-virtual": "^3.0.0",
+    "@types/react": "~19.2.2",
+    "autoprefixer": "^10.4.21",
+    "expo-sqlite": "^55.0.11",
+    "lucide-react": "^0.263.1",
+    "postcss": "^8.5.6",
+    "react": "19.2.0",
+    "react-dom": "19.2.0",
+    "react-json-tree": "^0.20.0",
+    "react-native": "0.83.1",
+    "react-native-web": "^0.21.2",
+    "sql-formatter": "^15.7.2",
+    "tailwindcss": "^4.2.2",
+    "typescript": "~5.9.3",
+    "vite": "^7.3.1",
+    "vitest": "^3.2.4",
+    "@rozenite/vite-plugin": "1.6.0",
+    "rozenite": "1.6.0"
+  },
+  "peerDependencies": {
+    "expo-sqlite": "*",
+    "react": "*",
+    "react-native": "*"
+  },
+  "peerDependenciesMeta": {
+    "expo-sqlite": {
+      "optional": true
+    }
+  },
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/react-native/index.d.ts",
+      "import": "./dist/react-native/index.js",
+      "require": "./dist/react-native/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rozenite build",
+    "dev": "rozenite dev",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "lint": "eslint .",
+    "test": "vitest --run"
+  }
+}

package/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    '@tailwindcss/postcss': {},
+    autoprefixer: {},
+  },
+};

package/react-native.ts

@@ -0,0 +1,55 @@
+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';
+
+type CreateSqliteAdapter =
+  typeof import('./src/react-native/adapters').createSqliteAdapter;
+type CreateExpoSqliteAdapter =
+  typeof import('./src/react-native/adapters').createExpoSqliteAdapter;
+
+export let createSqliteAdapter: CreateSqliteAdapter;
+export let createExpoSqliteAdapter: CreateExpoSqliteAdapter;
+export let useRozeniteSqlitePlugin: typeof import('./src/react-native/useRozeniteSqlitePlugin').useRozeniteSqlitePlugin;
+
+const isWeb =
+  typeof window !== 'undefined' && window.navigator.product !== 'ReactNative';
+const isDev = process.env.NODE_ENV !== 'production';
+const isServer = typeof window === '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;
+} 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;
+}

package/rozenite.config.ts

@@ -0,0 +1,8 @@
+export default {
+  panels: [
+    {
+      name: 'SQLite',
+      source: './src/ui/panel.tsx',
+    },
+  ],
+};

package/src/react-native/adapters/__tests__/expo-sqlite.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createExpoSqliteAdapter } from '../expo-sqlite';
+
+describe('createExpoSqliteAdapter', () => {
+  it('executes statement arrays sequentially and preserves result order', async () => {
+    const database = {
+      getAllAsync: vi.fn(async () => [{ id: 1, name: 'Ada' }]),
+      runAsync: vi.fn(async () => ({ changes: 1, lastInsertRowId: 7 })),
+    };
+
+    const adapter = createExpoSqliteAdapter({
+      database,
+      databaseName: 'main.db',
+    });
+    const [mainDatabase] = adapter.databases;
+
+    const results = await mainDatabase.executeStatements([
+      { sql: 'SELECT id, name FROM users;' },
+      { sql: "INSERT INTO users(name) VALUES('Grace');" },
+    ]);
+
+    expect(database.getAllAsync).toHaveBeenCalledWith(
+      'SELECT id, name FROM users',
+    );
+    expect(database.runAsync).toHaveBeenCalledWith(
+      "INSERT INTO users(name) VALUES('Grace')",
+    );
+    expect(results).toHaveLength(2);
+    expect(results[0]?.metadata.statementType).toBe('select');
+    expect(results[1]?.metadata.statementType).toBe('insert');
+    expect(results[1]?.metadata.lastInsertRowId).toBe(7);
+  });
+
+  it('allows explicit transaction statements to run as normal statements', async () => {
+    const database = {
+      getAllAsync: vi.fn(),
+      runAsync: vi.fn(async () => ({ changes: 0, lastInsertRowId: 0 })),
+    };
+
+    const adapter = createExpoSqliteAdapter({
+      database,
+      databaseName: 'main.db',
+    });
+    const [mainDatabase] = adapter.databases;
+
+    const results = await mainDatabase.executeStatements([
+      { sql: 'BEGIN;' },
+      { sql: 'ROLLBACK;' },
+    ]);
+
+    expect(database.runAsync).toHaveBeenNthCalledWith(1, 'BEGIN');
+    expect(database.runAsync).toHaveBeenNthCalledWith(2, 'ROLLBACK');
+    expect(results.map((result) => result.metadata.statementType)).toEqual([
+      'other',
+      'other',
+    ]);
+  });
+
+  it('throws batch execution metadata when a later statement fails', async () => {
+    const database = {
+      getAllAsync: vi.fn(async () => [{ id: 1 }]),
+      runAsync: vi.fn(async (sql: string) => {
+        if (sql === "INSERT INTO logs(message) VALUES('boom')") {
+          throw new Error('constraint failed');
+        }
+
+        return { changes: 1, lastInsertRowId: 1 };
+      }),
+    };
+
+    const adapter = createExpoSqliteAdapter({
+      database,
+      databaseName: 'main.db',
+    });
+    const [mainDatabase] = adapter.databases;
+
+    await expect(
+      mainDatabase.executeStatements([
+        { sql: 'SELECT id FROM users;' },
+        { sql: "INSERT INTO logs(message) VALUES('boom');" },
+      ]),
+    ).rejects.toMatchObject({
+      message: 'constraint failed',
+      failedStatementIndex: 1,
+      completedResults: [
+        {
+          metadata: {
+            statementType: 'select',
+          },
+        },
+      ],
+    });
+  });
+});

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

@@ -0,0 +1,230 @@
+import {
+  classifySqlStatement,
+  normalizeSingleStatementSql,
+  statementReturnsRows,
+} from '../../shared/sql';
+import {
+  decodeSqliteBridgeValue,
+  formatSqliteError,
+} from '../../shared/bridge-values';
+import type {
+  SqliteAdapter,
+  SqliteExecuteStatementsError,
+  SqliteExecuteStatementsRunner,
+  SqliteStatementInput,
+  SqliteQueryResult,
+} from '../../shared/types';
+import {
+  createSqliteAdapter,
+  type CreateSqliteAdapterOptions,
+} from './generic';
+
+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;
+
+const now = () =>
+  typeof performance !== 'undefined' && typeof performance.now === 'function'
+    ? performance.now()
+    : Date.now();
+
+const safeError = (error: unknown) => formatSqliteError(error);
+
+const createExecuteStatementsError = (
+  message: string,
+  options: {
+    completedResults?: SqliteQueryResult[];
+    failedStatementIndex?: number;
+    cause?: unknown;
+  } = {},
+): SqliteExecuteStatementsError => Object.assign(new Error(message), options);
+
+const toBridgeSafeValue = (value: unknown): unknown => {
+  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: Record<string, unknown>[]) =>
+  rows.map((row) =>
+    Object.fromEntries(
+      Object.entries(row).map(([key, value]) => [
+        key,
+        toBridgeSafeValue(value),
+      ]),
+    ),
+  );
+
+const executeSingleStatement = async (
+  database: ExpoSqliteLike,
+  { sql, params }: SqliteStatementInput,
+): Promise<SqliteQueryResult> => {
+  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: ExpoSqliteLike,
+): SqliteExecuteStatementsRunner => {
+  return async (statements) => {
+    const results: SqliteQueryResult[] = [];
+
+    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: ExpoSqliteLike | { database: ExpoSqliteLike; name?: string },
+) => ('database' in config ? config : { database: config });
+
+export const createExpoSqliteAdapter = (
+  options: CreateExpoSqliteAdapterOptions,
+): SqliteAdapter => {
+  const genericOptions: CreateSqliteAdapterOptions =
+    '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);
+};