@rozenite/sqlite-plugin 1.7.0-rc.0

package/src/shared/sql.ts

@@ -0,0 +1,420 @@
+import type { SqliteStatementType } from './types';
+
+const isWhitespace = (char: string) => /\s/.test(char);
+
+export const countSqlStatements = (sql: string) => {
+  let count = 0;
+  let hasToken = false;
+  let i = 0;
+  let mode:
+    | 'single-quote'
+    | 'double-quote'
+    | 'backtick'
+    | 'bracket'
+    | 'line-comment'
+    | 'block-comment'
+    | null = 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;
+};
+
+export type SqlStatementSegment = {
+  text: string;
+  start: number;
+  end: number;
+};
+
+export const splitSqlStatements = (sql: string): SqlStatementSegment[] => {
+  const segments: SqlStatementSegment[] = [];
+  let hasToken = false;
+  let segmentStart = 0;
+  let i = 0;
+  let mode:
+    | 'single-quote'
+    | 'double-quote'
+    | 'backtick'
+    | 'bracket'
+    | 'line-comment'
+    | 'block-comment'
+    | null = null;
+
+  const pushSegment = (end: number) => {
+    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;
+};
+
+export const getStatementAtCursor = (sql: string, cursor: number) => {
+  const segments = splitSqlStatements(sql);
+
+  if (segments.length === 0) {
+    return null;
+  }
+
+  const match = segments.find(
+    (segment) => cursor >= segment.start && cursor <= segment.end + 1,
+  );
+
+  return match ?? segments[0];
+};
+
+export const normalizeSingleStatementSql = (sql: string) => {
+  const statementCount = 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();
+};
+
+const readLeadingKeyword = (sql: string) => {
+  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();
+};
+
+export const classifySqlStatement = (sql: string): SqliteStatementType => {
+  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';
+};
+
+export const statementReturnsRows = (statementType: SqliteStatementType) =>
+  statementType === 'select' ||
+  statementType === 'pragma' ||
+  statementType === 'explain' ||
+  statementType === 'with';
+
+export const quoteSqlIdentifier = (identifier: string) =>
+  `"${identifier.replace(/"/g, '""')}"`;
+
+export const escapeSqlString = (value: string) =>
+  `'${value.replace(/'/g, "''")}'`;

package/src/shared/types.ts

@@ -0,0 +1,81 @@
+export type SqliteStatementType =
+  | 'select'
+  | 'insert'
+  | 'update'
+  | 'delete'
+  | 'pragma'
+  | 'create'
+  | 'alter'
+  | 'drop'
+  | 'explain'
+  | 'with'
+  | 'other';
+
+export type SqliteQueryParams = unknown[] | Record<string, unknown>;
+
+export type SqliteStatementInput = {
+  sql: string;
+  params?: SqliteQueryParams;
+};
+
+export type SqliteQueryMetadata = {
+  statementType: SqliteStatementType;
+  rowCount: number;
+  changes: number | null;
+  lastInsertRowId: number | null;
+  durationMs: number;
+};
+
+export type SqliteQueryResult = {
+  rows: Record<string, unknown>[];
+  columns: string[];
+  metadata: SqliteQueryMetadata;
+};
+
+export type SqliteStatementExecutionResult = {
+  input: SqliteStatementInput;
+  result: SqliteQueryResult;
+};
+
+export type SqliteScriptStatementResult = {
+  index: number;
+  start: number;
+  end: number;
+  input: SqliteStatementInput;
+  execution?: SqliteStatementExecutionResult;
+  error?: string;
+};
+
+export type SqliteScriptResult = {
+  statements: SqliteScriptStatementResult[];
+  totalStatementCount: number;
+  failedStatementIndex: number | null;
+};
+
+export type SqliteExecuteStatementsRunner = (
+  statements: SqliteStatementInput[],
+) => Promise<SqliteQueryResult[]>;
+
+export type SqliteExecuteStatementsError = Error & {
+  completedResults?: SqliteQueryResult[];
+  failedStatementIndex?: number;
+};
+
+export type SqliteDatabaseNode = {
+  id: string;
+  name: string;
+  executeStatements: SqliteExecuteStatementsRunner;
+};
+
+export type SqliteAdapter = {
+  id: string;
+  name: string;
+  databases: SqliteDatabaseNode[];
+};
+
+export type SqliteDatabaseInfo = {
+  id: string;
+  name: string;
+  adapterId: string;
+  adapterName: string;
+};

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

@@ -0,0 +1,135 @@
+import { describe, expect, it } from 'vitest';
+import type {
+  SqliteColumnInfo,
+  SqliteEntity,
+  SqliteSchema,
+} from '../sqlite-introspection';
+import {
+  buildSqlCompletionSchema,
+  createSqlEditorColumnCache,
+  extractSqlEditorAliases,
+  formatSqlScript,
+  getSqlEditorColumnCompletionRequest,
+  resolveSqlEditorEntityReference,
+  setSqlEditorCachedColumns,
+  syncSqlEditorColumnCacheDatabase,
+} from '../sql-editor-utils';
+
+const schemas: SqliteSchema[] = [
+  {
+    seq: 0,
+    name: 'main',
+    file: null,
+  },
+];
+
+const entities: SqliteEntity[] = [
+  {
+    schemaName: 'main',
+    name: 'projects',
+    type: 'table',
+    sql: 'CREATE TABLE projects(id INTEGER PRIMARY KEY, name TEXT)',
+  },
+];
+
+const columns: SqliteColumnInfo[] = [
+  {
+    cid: 0,
+    name: 'id',
+    type: 'INTEGER',
+    notNull: true,
+    defaultValue: null,
+    primaryKeyOrder: 1,
+    hidden: 0,
+  },
+  {
+    cid: 1,
+    name: 'name',
+    type: 'TEXT',
+    notNull: false,
+    defaultValue: null,
+    primaryKeyOrder: 0,
+    hidden: 0,
+  },
+];
+
+describe('sql editor utilities', () => {
+  it('formats SQLite SQL with uppercase keywords and multiline layout', () => {
+    const formatted = formatSqlScript(
+      'select id, name from projects where archived = 0 order by name',
+    );
+
+    expect(formatted).toContain('SELECT');
+    expect(formatted).toContain('\nFROM\n  projects');
+    expect(formatted).toContain('\nWHERE\n  archived = 0');
+  });
+
+  it('builds a completion schema from cached table columns', () => {
+    const cache = setSqlEditorCachedColumns(
+      createSqlEditorColumnCache('db-1'),
+      'db-1',
+      'main',
+      'projects',
+      columns,
+    );
+    const namespace = buildSqlCompletionSchema({
+      columnCache: cache,
+      databaseId: 'db-1',
+      entities,
+      schemas,
+    }) as unknown as Record<
+      string,
+      {
+        children: Record<
+          string,
+          {
+            children: Array<{ label: string }>;
+            self: { detail: string };
+          }
+        >;
+      }
+    >;
+
+    expect(namespace.main.children.projects.self.detail).toBe('table');
+    expect(namespace.main.children.projects.children).toEqual([
+      expect.objectContaining({ label: 'id' }),
+      expect.objectContaining({ label: 'name' }),
+    ]);
+  });
+
+  it('resets cached columns when the selected database changes', () => {
+    const initialCache = setSqlEditorCachedColumns(
+      createSqlEditorColumnCache('db-1'),
+      'db-1',
+      'main',
+      'projects',
+      columns,
+    );
+    const nextCache = syncSqlEditorColumnCacheDatabase(initialCache, 'db-2');
+
+    expect(nextCache.databaseId).toBe('db-2');
+    expect(nextCache.entries).toEqual({});
+  });
+
+  it('resolves aliased table references for column completion', () => {
+    const sql = 'SELECT * FROM main.projects AS p WHERE p.';
+    const cursorPosition = sql.length;
+    const request = getSqlEditorColumnCompletionRequest(sql, cursorPosition);
+
+    expect(request).toEqual({
+      schemaName: null,
+      entityName: 'p',
+      from: cursorPosition,
+      to: cursorPosition,
+    });
+
+    const entity = resolveSqlEditorEntityReference({
+      aliases: extractSqlEditorAliases(sql),
+      entities,
+      request: request!,
+      selectedSchemaName: 'main',
+    });
+
+    expect(entity).toEqual(entities[0]);
+  });
+});

package/src/ui/__tests__/sqlite-row-edit-value.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { parseEditableFieldValue } from '../sqlite-row-edit-value';
+
+describe('sqlite row edit value helpers', () => {
+  it('converts blob-ish drafts into Uint8Array bind values', () => {
+    expect(
+      parseEditableFieldValue({
+        kind: 'blob-ish',
+        rawValue: '[1, 2, 255]',
+      }),
+    ).toEqual(new Uint8Array([1, 2, 255]));
+  });
+
+  it('serializes json drafts into JSON text bind values', () => {
+    expect(
+      parseEditableFieldValue({
+        kind: 'json',
+        rawValue: '{\n  "ok": true,\n  "count": 2\n}',
+      }),
+    ).toBe('{"ok":true,"count":2}');
+  });
+});