@rozenite/sqlite-plugin 1.7.0-rc.0

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

@@ -0,0 +1,310 @@
+import { describe, expect, it } from 'vitest';
+import type { SqliteEntity } from '../sqlite-introspection';
+import {
+  SQLITE_HIDDEN_ROWID_COLUMN_ID,
+  buildRowDeleteMutation,
+  buildRowUpdateMutation,
+  getAvailableRowIdIdentifier,
+  getCompatibleValueKinds,
+  getEditableColumns,
+  getPrimaryKeyColumns,
+  getRowMutationDescriptor,
+} from '../sqlite-row-mutations';
+
+const buildEntity = (sql: string): SqliteEntity => ({
+  schemaName: 'main',
+  name: 'projects',
+  type: 'table',
+  sql,
+});
+
+describe('sqlite row mutation helpers', () => {
+  it('extracts primary-key columns in SQLite order', () => {
+    expect(
+      getPrimaryKeyColumns([
+        {
+          cid: 0,
+          name: 'name',
+          type: 'TEXT',
+          notNull: true,
+          defaultValue: null,
+          primaryKeyOrder: 2,
+          hidden: 0,
+        },
+        {
+          cid: 1,
+          name: 'id',
+          type: 'INTEGER',
+          notNull: true,
+          defaultValue: null,
+          primaryKeyOrder: 1,
+          hidden: 0,
+        },
+      ]).map((column) => column.name),
+    ).toEqual(['id', 'name']);
+  });
+
+  it('keeps only non-hidden, non-primary columns editable', () => {
+    expect(
+      getEditableColumns([
+        {
+          cid: 0,
+          name: 'id',
+          type: 'INTEGER',
+          notNull: true,
+          defaultValue: null,
+          primaryKeyOrder: 1,
+          hidden: 0,
+        },
+        {
+          cid: 1,
+          name: 'title',
+          type: 'TEXT',
+          notNull: false,
+          defaultValue: null,
+          primaryKeyOrder: 0,
+          hidden: 0,
+        },
+        {
+          cid: 2,
+          name: 'generated_value',
+          type: 'TEXT',
+          notNull: false,
+          defaultValue: null,
+          primaryKeyOrder: 0,
+          hidden: 2,
+        },
+      ]).map((column) => column.name),
+    ).toEqual(['title']);
+  });
+
+  it('falls back to a usable rowid alias for tables without a primary key', () => {
+    const columns = [
+      {
+        cid: 0,
+        name: 'rowid',
+        type: 'INTEGER',
+        notNull: false,
+        defaultValue: null,
+        primaryKeyOrder: 0,
+        hidden: 0,
+      },
+      {
+        cid: 1,
+        name: 'title',
+        type: 'TEXT',
+        notNull: false,
+        defaultValue: null,
+        primaryKeyOrder: 0,
+        hidden: 0,
+      },
+    ];
+
+    expect(getAvailableRowIdIdentifier(columns)).toBe('_rowid_');
+    expect(
+      getRowMutationDescriptor(
+        buildEntity('CREATE TABLE projects(rowid INTEGER, title TEXT)'),
+        columns,
+      ),
+    ).toEqual({
+      mode: 'rowid',
+      rowIdIdentifier: '_rowid_',
+    });
+  });
+
+  it('limits editable kinds to text-compatible inputs for TEXT columns', () => {
+    expect(
+      getCompatibleValueKinds(
+        {
+          cid: 0,
+          name: 'title',
+          type: 'TEXT',
+          notNull: false,
+          defaultValue: null,
+          primaryKeyOrder: 0,
+          hidden: 0,
+        },
+        'alpha',
+      ),
+    ).toEqual(['text']);
+  });
+
+  it('limits editable kinds to numeric-compatible inputs for numeric columns', () => {
+    expect(
+      getCompatibleValueKinds(
+        {
+          cid: 0,
+          name: 'progress',
+          type: 'INTEGER',
+          notNull: false,
+          defaultValue: null,
+          primaryKeyOrder: 0,
+          hidden: 0,
+        },
+        1,
+      ),
+    ).toEqual(['number']);
+  });
+
+  it('limits editable kinds to boolean-compatible inputs for BOOLEAN columns', () => {
+    expect(
+      getCompatibleValueKinds(
+        {
+          cid: 0,
+          name: 'enabled',
+          type: 'BOOLEAN',
+          notNull: false,
+          defaultValue: null,
+          primaryKeyOrder: 0,
+          hidden: 0,
+        },
+        true,
+      ),
+    ).toEqual(['boolean']);
+  });
+
+  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',
+        ),
+        [
+          {
+            cid: 0,
+            name: 'title',
+            type: 'TEXT',
+            notNull: false,
+            defaultValue: null,
+            primaryKeyOrder: 0,
+            hidden: 0,
+          },
+        ],
+      ),
+    ).toBeNull();
+  });
+
+  it('builds an UPDATE statement that matches by primary key', () => {
+    expect(
+      buildRowUpdateMutation({
+        entity: buildEntity(
+          'CREATE TABLE projects(id INTEGER PRIMARY KEY, title TEXT, archived INTEGER)',
+        ),
+        columns: [
+          {
+            cid: 0,
+            name: 'id',
+            type: 'INTEGER',
+            notNull: true,
+            defaultValue: null,
+            primaryKeyOrder: 1,
+            hidden: 0,
+          },
+          {
+            cid: 1,
+            name: 'title',
+            type: 'TEXT',
+            notNull: false,
+            defaultValue: null,
+            primaryKeyOrder: 0,
+            hidden: 0,
+          },
+          {
+            cid: 2,
+            name: 'archived',
+            type: 'INTEGER',
+            notNull: false,
+            defaultValue: null,
+            primaryKeyOrder: 0,
+            hidden: 0,
+          },
+        ],
+        row: {
+          id: 7,
+          title: 'Before',
+          archived: 0,
+        },
+        descriptor: {
+          mode: 'primary-key',
+          primaryKeyColumns: [
+            {
+              cid: 0,
+              name: 'id',
+              type: 'INTEGER',
+              notNull: true,
+              defaultValue: null,
+              primaryKeyOrder: 1,
+              hidden: 0,
+            },
+          ],
+        },
+        nextValues: {
+          title: 'After',
+          archived: 1,
+        },
+      }),
+    ).toEqual({
+      sql: 'UPDATE "main"."projects" SET "title" = ?, "archived" = ? WHERE "id" = ?',
+      params: ['After', 1, 7],
+    });
+  });
+
+  it('builds a DELETE statement that matches by composite primary key', () => {
+    expect(
+      buildRowDeleteMutation({
+        entity: buildEntity(
+          'CREATE TABLE projects(tenant_id INTEGER, slug TEXT, PRIMARY KEY (tenant_id, slug))',
+        ),
+        row: {
+          tenant_id: 42,
+          slug: 'alpha',
+        },
+        descriptor: {
+          mode: 'primary-key',
+          primaryKeyColumns: [
+            {
+              cid: 0,
+              name: 'tenant_id',
+              type: 'INTEGER',
+              notNull: true,
+              defaultValue: null,
+              primaryKeyOrder: 1,
+              hidden: 0,
+            },
+            {
+              cid: 1,
+              name: 'slug',
+              type: 'TEXT',
+              notNull: true,
+              defaultValue: null,
+              primaryKeyOrder: 2,
+              hidden: 0,
+            },
+          ],
+        },
+      }),
+    ).toEqual({
+      sql: 'DELETE FROM "main"."projects" WHERE "tenant_id" = ? AND "slug" = ?',
+      params: [42, 'alpha'],
+    });
+  });
+
+  it('builds rowid-backed mutations for tables without primary keys', () => {
+    expect(
+      buildRowDeleteMutation({
+        entity: buildEntity('CREATE TABLE projects(title TEXT)'),
+        row: {
+          title: 'Draft',
+          [SQLITE_HIDDEN_ROWID_COLUMN_ID]: 13,
+        },
+        descriptor: {
+          mode: 'rowid',
+          rowIdIdentifier: 'rowid',
+        },
+      }),
+    ).toEqual({
+      sql: 'DELETE FROM "main"."projects" WHERE rowid = ?',
+      params: [13],
+    });
+  });
+});

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

@@ -0,0 +1,83 @@
+import { describe, expect, it } from 'vitest';
+import {
+  SQLITE_ROW_NUMBER_COLUMN_ID,
+  buildEntityTableId,
+  buildQueryTableId,
+  getDefaultTableColumnOrder,
+  normalizeTableColumnOrder,
+  reorderTableColumnOrder,
+  resolveTableColumnOrderUpdate,
+} from '../sqlite-table-column-order';
+
+describe('sqlite table column order helpers', () => {
+  it('returns the default order when no stored state exists', () => {
+    expect(getDefaultTableColumnOrder(['name', 'type', 'nullable'])).toEqual([
+      'name',
+      'type',
+      'nullable',
+    ]);
+  });
+
+  it('keeps fixed leading columns in front while pruning stale ids', () => {
+    expect(
+      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',
+        ],
+      }),
+    ).toEqual([SQLITE_ROW_NUMBER_COLUMN_ID, 'type', 'name']);
+  });
+
+  it('appends newly visible columns after the stored order', () => {
+    expect(
+      normalizeTableColumnOrder({
+        columnIds: [SQLITE_ROW_NUMBER_COLUMN_ID, 'name', 'type', 'extra'],
+        fixedLeadingColumnIds: [SQLITE_ROW_NUMBER_COLUMN_ID],
+        storedColumnOrder: [SQLITE_ROW_NUMBER_COLUMN_ID, 'type', 'name'],
+      }),
+    ).toEqual([SQLITE_ROW_NUMBER_COLUMN_ID, 'type', 'name', 'extra']);
+  });
+
+  it('reorders only movable columns', () => {
+    expect(
+      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',
+        ],
+        activeColumnId: 'extra',
+        overColumnId: 'name',
+      }),
+    ).toEqual([SQLITE_ROW_NUMBER_COLUMN_ID, 'extra', 'name', 'type']);
+  });
+
+  it('normalizes updater-based changes before storing them', () => {
+    expect(
+      resolveTableColumnOrderUpdate({
+        columnIds: [SQLITE_ROW_NUMBER_COLUMN_ID, 'name', 'type', 'extra'],
+        fixedLeadingColumnIds: [SQLITE_ROW_NUMBER_COLUMN_ID],
+        storedColumnOrder: [SQLITE_ROW_NUMBER_COLUMN_ID, 'name', 'type'],
+        nextColumnOrder: (current) => ['type', ...current],
+      }),
+    ).toEqual([SQLITE_ROW_NUMBER_COLUMN_ID, 'type', 'name', 'extra']);
+  });
+
+  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"]',
+    );
+  });
+});

package/src/ui/__tests__/value-utils.test.tsx

@@ -0,0 +1,12 @@
+import { describe, expect, it } from 'vitest';
+import { getValuePreview, stringifyValue } from '../value-utils';
+
+describe('value utils', () => {
+  it('stringifyValue returns a string for undefined values', () => {
+    expect(stringifyValue(undefined)).toBe('undefined');
+  });
+
+  it('getValuePreview does not crash for undefined values', () => {
+    expect(getValuePreview(undefined)).toBe('undefined');
+  });
+});

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

@@ -0,0 +1,65 @@
+import { Modal, useOverlayState } from '@heroui/react';
+import { Rows } from 'lucide-react';
+import { SqliteModalCloseButton } from './sqlite-modal-controls';
+import { renderStructuredValue } from './value-utils';
+
+type CellDetailDrawerProps = {
+  value: unknown;
+  title: string;
+  isOpen: boolean;
+  onClose: () => void;
+};
+
+export const CellDetailDrawer = ({
+  value,
+  title,
+  isOpen,
+  onClose,
+}: CellDetailDrawerProps) => {
+  const overlay = useOverlayState({
+    isOpen,
+    onOpenChange: (open: boolean) => {
+      if (!open) {
+        onClose();
+      }
+    },
+  });
+
+  return (
+    <Modal state={overlay}>
+      <Modal.Backdrop
+        variant="blur"
+        isDismissable
+        className="bg-[rgba(5,10,16,0.24)] backdrop-blur-[2px]"
+      >
+        <Modal.Container placement="center" size="lg" scroll="inside">
+          <Modal.Dialog
+            aria-label={title}
+            className="w-full max-w-4xl overflow-hidden border border-white/10 bg-[#0a121b] p-0 text-white shadow-[0_30px_90px_rgba(0,0,0,0.42)]"
+          >
+            <div className="flex items-center justify-between gap-4 border-b border-white/8 px-5 py-5">
+              <div>
+                <div className="flex items-center gap-2">
+                  <Rows aria-hidden="true" className="h-4 w-4 text-sky-300" />
+                  <h2 className="text-lg font-semibold text-white">{title}</h2>
+                </div>
+                <p className="mt-1 text-sm text-slate-400">
+                  Inspect the selected row in full detail.
+                </p>
+              </div>
+              <SqliteModalCloseButton onClose={onClose} />
+            </div>
+
+            <Modal.Body className="space-y-0 p-0">
+              <div className="px-5 py-5">
+                <div className="max-h-[70vh] overflow-auto rounded-[22px] border border-white/8 bg-white/[0.02] p-4">
+                  {renderStructuredValue(value)}
+                </div>
+              </div>
+            </Modal.Body>
+          </Modal.Dialog>
+        </Modal.Container>
+      </Modal.Backdrop>
+    </Modal>
+  );
+};