@rozenite/sqlite-plugin 1.13.0 → 2.1.0

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

@@ -1,7 +1,4 @@
-export {
-  createSqliteAdapter,
-  type CreateSqliteAdapterOptions,
-} from './generic';
+export { createSqliteAdapter, type CreateSqliteAdapterOptions } from './generic';
 export {
   createExpoSqliteAdapter,
   type CreateExpoSqliteAdapterOptions,

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

@@ -1,8 +1,4 @@
-import type {
-  SqliteAdapter,
-  SqliteDatabaseInfo,
-  SqliteStatementInput,
-} from '../shared/types';
+import type { SqliteAdapter, SqliteDatabaseInfo, SqliteStatementInput } from '../shared/types';
 
 export type SqliteDatabaseView = SqliteDatabaseInfo & {
   executeStatements: (
@@ -10,9 +6,7 @@ export type SqliteDatabaseView = SqliteDatabaseInfo & {
   ) => ReturnType<SqliteAdapter['databases'][number]['executeStatements']>;
 };
 
-export const createSqliteDatabaseViews = (
-  adapters: SqliteAdapter[],
-): SqliteDatabaseView[] =>
+export const createSqliteDatabaseViews = (adapters: SqliteAdapter[]): SqliteDatabaseView[] =>
   adapters.flatMap((adapter) =>
     adapter.databases.map((database) => ({
       id: database.id,

package/src/react-native/useRozeniteSqlitePlugin.ts

@@ -18,15 +18,10 @@ export type RozeniteSqlitePluginOptions = {
 
 const safeError = (error: unknown) => formatSqliteError(error);
 
-const isExecuteStatementsError = (
-  error: unknown,
-): error is SqliteExecuteStatementsError =>
-  error instanceof Error &&
-  ('completedResults' in error || 'failedStatementIndex' in error);
-
-export const useRozeniteSqlitePlugin = ({
-  adapters,
-}: RozeniteSqlitePluginOptions) => {
+const isExecuteStatementsError = (error: unknown): error is SqliteExecuteStatementsError =>
+  error instanceof Error && ('completedResults' in error || 'failedStatementIndex' in error);
+
+export const useRozeniteSqlitePlugin = ({ adapters }: RozeniteSqlitePluginOptions) => {
   const views = useMemo(() => createSqliteDatabaseViews(adapters), [adapters]);
 
   useSqliteAgentTools(views);
@@ -45,8 +40,7 @@ export const useRozeniteSqlitePlugin = ({
       databaseId: string,
       task: () => Promise<T>,
     ): Promise<T> => {
-      const queue =
-        databaseQueuesRef.current.get(databaseId) ?? Promise.resolve();
+      const queue = databaseQueuesRef.current.get(databaseId) ?? Promise.resolve();
       const next = queue.catch(() => undefined).then(task);
 
       databaseQueuesRef.current.set(
@@ -70,10 +64,7 @@ export const useRozeniteSqlitePlugin = ({
       return database;
     };
 
-    const executeStatements = async (
-      databaseId: string,
-      statements: SqliteStatementInput[],
-    ) => {
+    const executeStatements = async (databaseId: string, statements: SqliteStatementInput[]) => {
       const database = resolveDatabase(databaseId);
       const normalizedStatements = statements.map(({ sql, params }) => ({
         sql: normalizeSingleStatementSql(sql),
@@ -130,128 +121,117 @@ export const useRozeniteSqlitePlugin = ({
     );
 
     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),
-            });
-          }
-        },
-      ),
+      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.');
+      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 statementInputs = statementSegments.map((statement) => ({
-                sql: statement.text,
+              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,
+                },
               }));
 
-              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 {
+                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 () => {

package/src/react-native/useSqliteAgentTools.ts

@@ -31,19 +31,15 @@ const executeSqlTool: AgentTool = {
       },
       sql: {
         type: 'string',
-        description:
-          'SQL to execute. May contain multiple semicolon-separated statements.',
+        description: 'SQL to execute. May contain multiple semicolon-separated statements.',
       },
     },
     required: ['databaseId', 'sql'],
   },
 };
 
-const isExecuteStatementsError = (
-  error: unknown,
-): error is SqliteExecuteStatementsError =>
-  error instanceof Error &&
-  ('completedResults' in error || 'failedStatementIndex' in error);
+const isExecuteStatementsError = (error: unknown): error is SqliteExecuteStatementsError =>
+  error instanceof Error && ('completedResults' in error || 'failedStatementIndex' in error);
 
 export const useSqliteAgentTools = (views: SqliteDatabaseView[]) => {
   const resolveDatabase = useCallback(
@@ -52,9 +48,7 @@ export const useSqliteAgentTools = (views: SqliteDatabaseView[]) => {
 
       if (!database) {
         const available = views.map((v) => v.id).join(', ');
-        throw new Error(
-          `Unknown databaseId "${databaseId}". Available: ${available || '(none)'}`,
-        );
+        throw new Error(`Unknown databaseId "${databaseId}". Available: ${available || '(none)'}`);
       }
 
       return database;
@@ -122,10 +116,7 @@ export const useSqliteAgentTools = (views: SqliteDatabaseView[]) => {
             statementSegments.length - 1,
           ),
         );
-        const completedResults = (error.completedResults ?? []).slice(
-          0,
-          failedStatementIndex,
-        );
+        const completedResults = (error.completedResults ?? []).slice(0, failedStatementIndex);
 
         return {
           databaseId,

package/src/shared/__tests__/bridge-values.test.ts

@@ -11,21 +11,16 @@ describe('sqlite bridge values', () => {
       params: [new Uint8Array([1, 2, 255]), { nested: new Uint8Array([9, 8]) }],
     };
 
-    expect(decodeSqliteBridgeValue(encodeSqliteBridgeValue(original))).toEqual(
-      original,
-    );
+    expect(decodeSqliteBridgeValue(encodeSqliteBridgeValue(original))).toEqual(original);
   });
 
   it('formats nested error details with code and cause information', () => {
-    const error = Object.assign(
-      new Error("Calling the 'runAsync' function has failed"),
-      {
-        cause: {
-          code: 'ERR_INTERNAL_SQLITE_ERROR',
-          reason: 'Invalid bind parameter',
-        },
+    const error = Object.assign(new Error("Calling the 'runAsync' function has failed"), {
+      cause: {
+        code: 'ERR_INTERNAL_SQLITE_ERROR',
+        reason: 'Invalid bind parameter',
       },
-    );
+    });
 
     expect(formatSqliteError(error)).toBe(
       "Calling the 'runAsync' function has failed\nCaused by: [ERR_INTERNAL_SQLITE_ERROR] Invalid bind parameter",

package/src/shared/__tests__/sql.test.ts

@@ -1,9 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import {
-  getStatementAtCursor,
-  normalizeSingleStatementSql,
-  splitSqlStatements,
-} from '../sql';
+import { getStatementAtCursor, normalizeSingleStatementSql, splitSqlStatements } from '../sql';
 
 describe('SQL statement helpers', () => {
   it('finds the active statement when earlier statements contain comments and quoted semicolons', () => {
@@ -26,9 +22,9 @@ describe('SQL statement helpers', () => {
   });
 
   it('rejects multiple statements', () => {
-    expect(() =>
-      normalizeSingleStatementSql('SELECT * FROM projects; DELETE FROM logs;'),
-    ).toThrow('Only a single SQL statement is supported in v1.');
+    expect(() => normalizeSingleStatementSql('SELECT * FROM projects; DELETE FROM logs;')).toThrow(
+      'Only a single SQL statement is supported in v1.',
+    );
   });
 
   it('splits statements while preserving source offsets', () => {

package/src/shared/bridge-values.ts

@@ -8,9 +8,7 @@ type SqliteEncodedBinaryValue = {
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   !!value && typeof value === 'object';
 
-const isEncodedBinaryValue = (
-  value: unknown,
-): value is SqliteEncodedBinaryValue =>
+const isEncodedBinaryValue = (value: unknown): value is SqliteEncodedBinaryValue =>
   isRecord(value) &&
   value[SQLITE_BRIDGE_BINARY_TYPE] === true &&
   Array.isArray(value.data) &&
@@ -114,8 +112,7 @@ const describeError = (error: unknown): string | null => {
     const reason = getStringField(error, 'reason');
     const message = error.message.trim();
     const detailParts = [message || null, reason].filter(
-      (part, index, parts): part is string =>
-        !!part && parts.indexOf(part) === index,
+      (part, index, parts): part is string => !!part && parts.indexOf(part) === index,
     );
     const detail = detailParts.join(' | ') || error.name;
 

package/src/shared/sql.ts

@@ -324,9 +324,7 @@ export const getStatementAtCursor = (sql: string, cursor: number) => {
     return null;
   }
 
-  const match = segments.find(
-    (segment) => cursor >= segment.start && cursor <= segment.end + 1,
-  );
+  const match = segments.find((segment) => cursor >= segment.start && cursor <= segment.end + 1);
 
   return match ?? segments[0];
 };
@@ -413,8 +411,6 @@ export const statementReturnsRows = (statementType: SqliteStatementType) =>
   statementType === 'explain' ||
   statementType === 'with';
 
-export const quoteSqlIdentifier = (identifier: string) =>
-  `"${identifier.replace(/"/g, '""')}"`;
+export const quoteSqlIdentifier = (identifier: string) => `"${identifier.replace(/"/g, '""')}"`;
 
-export const escapeSqlString = (value: string) =>
-  `'${value.replace(/'/g, "''")}'`;
+export const escapeSqlString = (value: string) => `'${value.replace(/'/g, "''")}'`;

package/src/ui/__tests__/sql-editor-utils.test.ts

@@ -1,9 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import type {
-  SqliteColumnInfo,
-  SqliteEntity,
-  SqliteSchema,
-} from '../sqlite-introspection';
+import type { SqliteColumnInfo, SqliteEntity, SqliteSchema } from '../sqlite-introspection';
 import {
   buildSqlCompletionSchema,
   createSqlEditorColumnCache,

package/src/ui/__tests__/sqlite-drop-mutations.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it } from 'vitest';
+import {
+  buildDropAllEntitiesSql,
+  buildDropEntitySql,
+  buildSetForeignKeysSql,
+  isForeignKeysEnabled,
+  orderEntitiesForDrop,
+  SQLITE_READ_FOREIGN_KEYS_SQL,
+  type SqliteDropTarget,
+} from '../sqlite-drop-mutations';
+
+describe('buildDropEntitySql', () => {
+  it('builds a DROP TABLE statement for a table entity', () => {
+    expect(
+      buildDropEntitySql({
+        schemaName: 'main',
+        name: 'projects',
+        type: 'table',
+      }),
+    ).toBe('DROP TABLE "main"."projects"');
+  });
+
+  it('builds a DROP VIEW statement for a view entity', () => {
+    expect(
+      buildDropEntitySql({
+        schemaName: 'main',
+        name: 'active_projects',
+        type: 'view',
+      }),
+    ).toBe('DROP VIEW "main"."active_projects"');
+  });
+
+  it('quotes identifiers containing double quotes by doubling them', () => {
+    expect(
+      buildDropEntitySql({
+        schemaName: 'main',
+        name: 'weird"table',
+        type: 'table',
+      }),
+    ).toBe('DROP TABLE "main"."weird""table"');
+  });
+
+  it('quotes identifiers containing dots so they are not read as separators', () => {
+    expect(
+      buildDropEntitySql({
+        schemaName: 'main',
+        name: 'schema.like.name',
+        type: 'table',
+      }),
+    ).toBe('DROP TABLE "main"."schema.like.name"');
+  });
+
+  it('quotes schema names containing double quotes and dots as well', () => {
+    expect(
+      buildDropEntitySql({
+        schemaName: 'weird"schema.name',
+        name: 'projects',
+        type: 'view',
+      }),
+    ).toBe('DROP VIEW "weird""schema.name"."projects"');
+  });
+});
+
+describe('orderEntitiesForDrop', () => {
+  it('moves all views before all tables while preserving relative order', () => {
+    const entities: SqliteDropTarget[] = [
+      { schemaName: 'main', name: 'a_table', type: 'table' },
+      { schemaName: 'main', name: 'b_view', type: 'view' },
+      { schemaName: 'main', name: 'c_table', type: 'table' },
+      { schemaName: 'main', name: 'd_view', type: 'view' },
+    ];
+
+    expect(orderEntitiesForDrop(entities).map((entity) => entity.name)).toEqual([
+      'b_view',
+      'd_view',
+      'a_table',
+      'c_table',
+    ]);
+  });
+
+  it('returns an empty array for an empty database', () => {
+    expect(orderEntitiesForDrop([])).toEqual([]);
+  });
+});
+
+describe('buildDropAllEntitiesSql', () => {
+  it('emits DROP VIEW statements before DROP TABLE statements', () => {
+    const entities: SqliteDropTarget[] = [
+      { schemaName: 'main', name: 'projects', type: 'table' },
+      { schemaName: 'main', name: 'active_projects', type: 'view' },
+    ];
+
+    expect(buildDropAllEntitiesSql(entities)).toBe(
+      'DROP VIEW "main"."active_projects";\nDROP TABLE "main"."projects";',
+    );
+  });
+
+  it('quotes every identifier in the generated script', () => {
+    const entities: SqliteDropTarget[] = [
+      { schemaName: 'main', name: 'weird"table', type: 'table' },
+      { schemaName: 'main', name: 'schema.view', type: 'view' },
+    ];
+
+    expect(buildDropAllEntitiesSql(entities)).toBe(
+      'DROP VIEW "main"."schema.view";\nDROP TABLE "main"."weird""table";',
+    );
+  });
+
+  it('returns an empty string for an empty database', () => {
+    expect(buildDropAllEntitiesSql([])).toBe('');
+  });
+});
+
+describe('foreign key pragma helpers', () => {
+  it('exposes the read-only pragma statement', () => {
+    expect(SQLITE_READ_FOREIGN_KEYS_SQL).toBe('PRAGMA foreign_keys');
+  });
+
+  it('builds a statement enabling foreign keys', () => {
+    expect(buildSetForeignKeysSql(true)).toBe('PRAGMA foreign_keys = ON');
+  });
+
+  it('builds a statement disabling foreign keys', () => {
+    expect(buildSetForeignKeysSql(false)).toBe('PRAGMA foreign_keys = OFF');
+  });
+
+  it('treats a foreign_keys value of 1 as enabled', () => {
+    expect(isForeignKeysEnabled([{ foreign_keys: 1 }])).toBe(true);
+  });
+
+  it('treats a foreign_keys value of 0 as disabled', () => {
+    expect(isForeignKeysEnabled([{ foreign_keys: 0 }])).toBe(false);
+  });
+
+  it('treats an empty result set as disabled', () => {
+    expect(isForeignKeysEnabled([])).toBe(false);
+  });
+});

package/src/ui/__tests__/sqlite-row-mutations.test.ts

@@ -166,9 +166,7 @@ describe('sqlite row mutation helpers', () => {
   it('disables row mutations for WITHOUT ROWID tables that lack a primary key', () => {
     expect(
       getRowMutationDescriptor(
-        buildEntity(
-          'CREATE TABLE projects(title TEXT, slug TEXT) WITHOUT ROWID',
-        ),
+        buildEntity('CREATE TABLE projects(title TEXT, slug TEXT) WITHOUT ROWID'),
         [
           {
             cid: 0,

package/src/ui/__tests__/sqlite-table-column-order.test.ts

@@ -23,13 +23,7 @@ describe('sqlite table column order helpers', () => {
       normalizeTableColumnOrder({
         columnIds: [SQLITE_ROW_NUMBER_COLUMN_ID, 'name', 'type'],
         fixedLeadingColumnIds: [SQLITE_ROW_NUMBER_COLUMN_ID],
-        storedColumnOrder: [
-          'type',
-          SQLITE_ROW_NUMBER_COLUMN_ID,
-          'stale',
-          'name',
-          'type',
-        ],
+        storedColumnOrder: ['type', SQLITE_ROW_NUMBER_COLUMN_ID, 'stale', 'name', 'type'],
       }),
     ).toEqual([SQLITE_ROW_NUMBER_COLUMN_ID, 'type', 'name']);
   });
@@ -49,12 +43,7 @@ describe('sqlite table column order helpers', () => {
       reorderTableColumnOrder({
         columnIds: [SQLITE_ROW_NUMBER_COLUMN_ID, 'name', 'type', 'extra'],
         fixedLeadingColumnIds: [SQLITE_ROW_NUMBER_COLUMN_ID],
-        storedColumnOrder: [
-          SQLITE_ROW_NUMBER_COLUMN_ID,
-          'name',
-          'type',
-          'extra',
-        ],
+        storedColumnOrder: [SQLITE_ROW_NUMBER_COLUMN_ID, 'name', 'type', 'extra'],
         activeColumnId: 'extra',
         overColumnId: 'name',
       }),
@@ -73,11 +62,7 @@ describe('sqlite table column order helpers', () => {
   });
 
   it('builds stable table ids for entity and query surfaces', () => {
-    expect(buildEntityTableId('data', 'db-1', 'main', 'users')).toBe(
-      'data:db-1:main:users',
-    );
-    expect(buildQueryTableId('db-1', ['id', 'name'])).toBe(
-      'query:db-1:["id","name"]',
-    );
+    expect(buildEntityTableId('data', 'db-1', 'main', 'users')).toBe('data:db-1:main:users');
+    expect(buildQueryTableId('db-1', ['id', 'name'])).toBe('query:db-1:["id","name"]');
   });
 });

package/src/ui/cell-detail-drawer.tsx

@@ -10,12 +10,7 @@ type CellDetailDrawerProps = {
   onClose: () => void;
 };
 
-export const CellDetailDrawer = ({
-  value,
-  title,
-  isOpen,
-  onClose,
-}: CellDetailDrawerProps) => {
+export const CellDetailDrawer = ({ value, title, isOpen, onClose }: CellDetailDrawerProps) => {
   const overlay = useOverlayState({
     isOpen,
     onOpenChange: (open: boolean) => {