@adecore/database 0.21.1 → 0.22.0

package/src/grid/display.ts

@@ -1,5 +1,6 @@
 import { formatBytes, formatNumeral } from '@adecore/ui/format';
 import type { BinaryValue, Cell, EditValue, ValueKind } from '../protocol/index.ts';
+import { isNumericKind } from '../sql.ts';
 
 /* What a cell shows: a cell of a result, or the column's default for a value an edit set to `DEFAULT`. */
 export type Shown = Cell | { readonly kind: 'default' };
@@ -22,11 +23,6 @@ export const DISPLAY_LIMIT = 200;
 /* How many bytes of a binary value the cell spells out. */
 export const BINARY_PREVIEW_BYTES = 8;
 
-const NUMERIC_KINDS: ReadonlySet<ValueKind> = new Set(['integer', 'decimal', 'float']);
-
-/* Whether the cells of a column of this kind sit against the end of their cell, as numbers do. */
-export const isNumericKind = (kind: ValueKind): boolean => NUMERIC_KINDS.has(kind);
-
 const ELLIPSIS = '…';
 
 const isObject = (cell: Shown): cell is Exclude<Shown, null | boolean | number | string> => cell !== null && typeof cell === 'object';

package/src/grid/layout.ts

@@ -78,19 +78,18 @@ export const gutterWidth = (rowCount: number): number => Math.max(GUTTER_MIN_WID
 
 export const clampColumnWidth = (width: number): number => Math.max(MIN_COLUMN_WIDTH, Math.min(Math.ceil(width), MAX_COLUMN_WIDTH));
 
-/* From the longest text among the header and the first rows. `keyed` makes room for the key icon in front of the name. */
-export const estimateColumnWidth = (header: string, samples: readonly string[], keyed: boolean): number => {
-    const body = samples.slice(0, SAMPLE_ROWS).reduce((longest, text) => Math.max(longest, text.length), 0);
-    const named = header.length * CHARACTER_WIDTH + (keyed ? KEY_ICON_ROOM : 0) + SORT_ROOM;
-    return clampColumnWidth(Math.max(body * CHARACTER_WIDTH, named) + CELL_PADDING);
-};
+const bodyWidth = (texts: readonly string[]): number => texts.reduce((longest, text) => Math.max(longest, text.length), 0) * CHARACTER_WIDTH;
+
+/* `keyed` makes room for the key icon in front of the name. */
+const headerWidth = (header: string, keyed: boolean): number => header.length * CHARACTER_WIDTH + (keyed ? KEY_ICON_ROOM : 0) + SORT_ROOM;
+
+/* From the longest text among the header and the first rows. */
+export const estimateColumnWidth = (header: string, samples: readonly string[], keyed: boolean): number =>
+    clampColumnWidth(Math.max(bodyWidth(samples.slice(0, SAMPLE_ROWS)), headerWidth(header, keyed)) + CELL_PADDING);
 
 /* Wide enough for the header and every text of the column, up to `MAX_FIT_WIDTH`. */
-export const fitColumnWidth = (header: string, texts: readonly string[], keyed: boolean): number => {
-    const body = texts.reduce((longest, text) => Math.max(longest, text.length), 0) * CHARACTER_WIDTH;
-    const named = header.length * CHARACTER_WIDTH + (keyed ? KEY_ICON_ROOM : 0) + SORT_ROOM;
-    return Math.max(MIN_COLUMN_WIDTH, Math.min(Math.ceil(Math.max(body, named) + CELL_PADDING), MAX_FIT_WIDTH));
-};
+export const fitColumnWidth = (header: string, texts: readonly string[], keyed: boolean): number =>
+    Math.max(MIN_COLUMN_WIDTH, Math.min(Math.ceil(Math.max(bodyWidth(texts), headerWidth(header, keyed)) + CELL_PADDING), MAX_FIT_WIDTH));
 
 export const isDoubleClick = (previous: number | null, now: number): boolean => previous !== null && now - previous <= DOUBLE_CLICK_MS;
 

package/src/host/helper-path.ts

@@ -2,14 +2,6 @@ import { existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, join, sep } from 'node:path';
 
-/*
- * Finds the prebuilt helper that npm installed for this machine, in the `@adecore/database-<platform>-<arch>`
- * package, or null when there is none: an unsupported platform, or an install with optional dependencies off.
- *
- * A binary cannot run from inside an Electron archive. The path is mapped from `app.asar` to
- * `app.asar.unpacked`, so the app must unpack the packages (electron-builder: `asarUnpack` with
- * `node_modules/@adecore/database-*` followed by `/**`).
- */
 export interface HelperPathOptions {
     /* `process.platform` when left out. */
     readonly platform?: string;
@@ -20,6 +12,14 @@ export interface HelperPathOptions {
     readonly exists?: (path: string) => boolean;
 }
 
+/*
+ * Finds the prebuilt helper that npm installed for this machine, in the `@adecore/database-<platform>-<arch>`
+ * package, or null when there is none: an unsupported platform, or an install with optional dependencies off.
+ *
+ * A binary cannot run from inside an Electron archive. The path is mapped from `app.asar` to
+ * `app.asar.unpacked`, so the app must unpack the packages (electron-builder: `asarUnpack` with
+ * `node_modules/@adecore/database-*` followed by `/**`).
+ */
 export const helperPath = ({
     platform = process.platform,
     arch = process.arch,

package/src/host/host.ts

@@ -7,7 +7,6 @@ const DEFAULT_READY_TIMEOUT_MS = 10000;
 /* How long a release or a dispose waits for a helper to answer its `close` requests. */
 const CLOSE_GRACE_MS = 2000;
 
-/* A failure with the code the caller gets. */
 class Failure extends Error {
     readonly code: DatabaseErrorCode;
 
@@ -41,6 +40,15 @@ const failure = (id: string, code: DatabaseErrorCode, message: string): Database
 
 const messageOf = (error: unknown): string => (error instanceof Error ? error.message : String(error));
 
+/* `undefined` for a line that is not JSON. */
+const parseLine = (line: string): unknown => {
+    try {
+        return JSON.parse(line);
+    } catch {
+        return undefined;
+    }
+};
+
 const isDict = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null && !Array.isArray(value);
 
 /* Settles when every promise has, or after the grace period; a helper that hangs must not hold up an app that quits. */
@@ -115,14 +123,7 @@ export const createDatabaseHost = (options: DatabaseHostOptions): DatabaseHost =
     };
 
     const onHandshake = (run: Run, line: string): void => {
-        let message: unknown;
-
-        try {
-            message = JSON.parse(line);
-        } catch {
-            abort(run, 'The helper did not start with a ready line.');
-            return;
-        }
+        const message = parseLine(line);
 
         if (!isDict(message) || message.event !== 'ready') {
             abort(run, 'The helper did not start with a ready line.');
@@ -140,13 +141,7 @@ export const createDatabaseHost = (options: DatabaseHostOptions): DatabaseHost =
     };
 
     const onResponse = (run: Run, line: string): void => {
-        let message: unknown;
-
-        try {
-            message = JSON.parse(line);
-        } catch {
-            return;
-        }
+        const message = parseLine(line);
 
         if (!isDict(message) || typeof message.id !== 'string') {
             return;

package/src/host/validate.ts

@@ -24,6 +24,8 @@ const fail = (message: string): never => {
 
 const isDict = (value: unknown): value is Dict => typeof value === 'object' && value !== null && !Array.isArray(value);
 
+const isRequestId = (value: unknown): value is string => typeof value === 'string' && value.length > 0 && value.length <= MAX_ID_LENGTH;
+
 /* Rejects a key nobody asked for, so a typo cannot pass for an option the helper ignores. */
 const shape = (value: unknown, label: string, required: readonly string[], optional: readonly string[] = []): Dict => {
     if (!isDict(value)) {
@@ -45,13 +47,13 @@ const shape = (value: unknown, label: string, required: readonly string[], optio
     return value;
 };
 
-const text = (value: unknown, label: string): void => {
+const filledText = (value: unknown, label: string): void => {
     if (typeof value !== 'string' || value.length === 0) {
         fail(`"${label}" must be a non-empty string.`);
     }
 };
 
-const plainText = (value: unknown, label: string): void => {
+const anyText = (value: unknown, label: string): void => {
     if (typeof value !== 'string') {
         fail(`"${label}" must be a string.`);
     }
@@ -76,7 +78,7 @@ const oneOf = (allowed: readonly string[]) => (value: unknown, label: string) =>
 };
 
 const absolutePath = (value: unknown, label: string): void => {
-    text(value, label);
+    filledText(value, label);
 
     if (!ABSOLUTE_PATH.test(value as string)) {
         fail(`"${label}" must be an absolute path.`);
@@ -148,18 +150,18 @@ const tunnel = (input: unknown, label: string): void => {
 
     if (input.kind === 'ssh') {
         const config = shape(input, label, ['kind', 'host'], ['port', 'user', 'identityFile']);
-        text(config.host, `${label}.host`);
+        filledText(config.host, `${label}.host`);
         optional(config, 'port', label, port);
-        optional(config, 'user', label, text);
-        optional(config, 'identityFile', label, text);
+        optional(config, 'user', label, filledText);
+        optional(config, 'identityFile', label, filledText);
         return;
     }
 
     if (input.kind === 'docker') {
         const config = shape(input, label, ['kind', 'container'], ['port', 'context']);
-        text(config.container, `${label}.container`);
+        filledText(config.container, `${label}.container`);
         optional(config, 'port', label, port);
-        optional(config, 'context', label, text);
+        optional(config, 'context', label, filledText);
         return;
     }
 
@@ -186,12 +188,12 @@ const connection = (input: unknown, label: string): void => {
 
         // A Docker tunnel finds the server by its container, so the host is left empty.
         const viaDocker = isDict(config.tunnel) && config.tunnel.kind === 'docker';
-        (viaDocker ? plainText : text)(config.host, `${label}.host`);
-        text(config.user, `${label}.user`);
+        (viaDocker ? anyText : filledText)(config.host, `${label}.host`);
+        filledText(config.user, `${label}.user`);
         optional(config, 'port', label, port);
-        optional(config, 'socket', label, text);
-        optional(config, 'password', label, plainText);
-        optional(config, 'database', label, plainText);
+        optional(config, 'socket', label, filledText);
+        optional(config, 'password', label, anyText);
+        optional(config, 'database', label, anyText);
         optional(config, 'tls', label, oneOf(TLS_MODES));
         optional(config, 'readOnly', label, flag);
         return;
@@ -229,17 +231,17 @@ const exportSource = (input: unknown, label: string): void => {
 
     if (input.kind === 'table') {
         const source = shape(input, label, ['kind', 'schema', 'table'], ['where', 'orderBy']);
-        text(source.schema, `${label}.schema`);
-        text(source.table, `${label}.table`);
-        optional(source, 'where', label, plainText);
-        optional(source, 'orderBy', label, plainText);
+        filledText(source.schema, `${label}.schema`);
+        filledText(source.table, `${label}.table`);
+        optional(source, 'where', label, anyText);
+        optional(source, 'orderBy', label, anyText);
         return;
     }
 
     if (input.kind === 'query') {
         const source = shape(input, label, ['kind', 'sql'], ['schema']);
-        text(source.sql, `${label}.sql`);
-        optional(source, 'schema', label, text);
+        filledText(source.sql, `${label}.sql`);
+        optional(source, 'schema', label, filledText);
         return;
     }
 
@@ -249,9 +251,9 @@ const exportSource = (input: unknown, label: string): void => {
 const cellLimit = (params: Dict): void => optional(params, 'cellLimit', 'params', (limit, name) => integer(limit, name, 1, MAX_CELL_LIMIT));
 
 const table = (params: Dict): void => {
-    text(params.session, 'params.session');
-    text(params.schema, 'params.schema');
-    text(params.table, 'params.table');
+    filledText(params.session, 'params.session');
+    filledText(params.schema, 'params.schema');
+    filledText(params.table, 'params.table');
 };
 
 const TARGET = ['session', 'schema', 'table'];
@@ -259,19 +261,19 @@ const TARGET = ['session', 'schema', 'table'];
 const PARAMS: { readonly [M in DatabaseMethod]: (input: unknown) => void } = {
     open: (input) => connection(shape(input, 'params', ['connection']).connection, 'params.connection'),
     test: (input) => connection(shape(input, 'params', ['connection']).connection, 'params.connection'),
-    close: (input) => text(shape(input, 'params', ['session']).session, 'params.session'),
-    schemas: (input) => text(shape(input, 'params', ['session']).session, 'params.session'),
+    close: (input) => filledText(shape(input, 'params', ['session']).session, 'params.session'),
+    schemas: (input) => filledText(shape(input, 'params', ['session']).session, 'params.session'),
     tables: (input) => {
         const params = shape(input, 'params', ['session', 'schema']);
-        text(params.session, 'params.session');
-        text(params.schema, 'params.schema');
+        filledText(params.session, 'params.session');
+        filledText(params.schema, 'params.schema');
     },
     structure: (input) => table(shape(input, 'params', TARGET)),
     rows: (input) => {
         const params = shape(input, 'params', [...TARGET, 'offset', 'limit'], ['where', 'orderBy', 'cellLimit']);
         table(params);
-        optional(params, 'where', 'params', plainText);
-        optional(params, 'orderBy', 'params', plainText);
+        optional(params, 'where', 'params', anyText);
+        optional(params, 'orderBy', 'params', anyText);
         integer(params.offset, 'params.offset', 0, Number.MAX_SAFE_INTEGER);
         integer(params.limit, 'params.limit', 1, MAX_LIMIT);
         cellLimit(params);
@@ -279,13 +281,13 @@ const PARAMS: { readonly [M in DatabaseMethod]: (input: unknown) => void } = {
     count: (input) => {
         const params = shape(input, 'params', TARGET, ['where']);
         table(params);
-        optional(params, 'where', 'params', plainText);
+        optional(params, 'where', 'params', anyText);
     },
     cell: (input) => {
         const params = shape(input, 'params', [...TARGET, 'key', 'column']);
         table(params);
         values(params.key, 'params.key', value, true);
-        text(params.column, 'params.column');
+        filledText(params.column, 'params.column');
     },
     apply: (input) => {
         const params = shape(input, 'params', [...TARGET, 'changes']);
@@ -300,34 +302,34 @@ const PARAMS: { readonly [M in DatabaseMethod]: (input: unknown) => void } = {
     },
     execute: (input) => {
         const params = shape(input, 'params', ['session', 'sql'], ['schema', 'limit', 'cellLimit']);
-        text(params.session, 'params.session');
-        text(params.sql, 'params.sql');
-        optional(params, 'schema', 'params', text);
+        filledText(params.session, 'params.session');
+        filledText(params.sql, 'params.sql');
+        optional(params, 'schema', 'params', filledText);
         optional(params, 'limit', 'params', (limit, name) => integer(limit, name, 1, MAX_LIMIT));
         cellLimit(params);
     },
     page: (input) => {
         const params = shape(input, 'params', ['session', 'sql', 'offset', 'limit'], ['schema', 'cellLimit']);
-        text(params.session, 'params.session');
-        text(params.sql, 'params.sql');
-        optional(params, 'schema', 'params', text);
+        filledText(params.session, 'params.session');
+        filledText(params.sql, 'params.sql');
+        optional(params, 'schema', 'params', filledText);
         integer(params.offset, 'params.offset', 0, Number.MAX_SAFE_INTEGER);
         integer(params.limit, 'params.limit', 1, MAX_LIMIT);
         cellLimit(params);
     },
     transaction: (input) => {
         const params = shape(input, 'params', ['session', 'action']);
-        text(params.session, 'params.session');
+        filledText(params.session, 'params.session');
         oneOf(TRANSACTION_ACTIONS)(params.action, 'params.action');
     },
     export: (input) => {
         const params = shape(input, 'params', ['session', 'source', 'format', 'path'], ['header', 'tableName']);
-        text(params.session, 'params.session');
+        filledText(params.session, 'params.session');
         exportSource(params.source, 'params.source');
         oneOf(EXPORT_FORMATS)(params.format, 'params.format');
         absolutePath(params.path, 'params.path');
         optional(params, 'header', 'params', flag);
-        optional(params, 'tableName', 'params', text);
+        optional(params, 'tableName', 'params', filledText);
     },
     sample: (input) => {
         const params = shape(input, 'params', ['path', 'format', 'header'], ['limit']);
@@ -350,19 +352,19 @@ const PARAMS: { readonly [M in DatabaseMethod]: (input: unknown) => void } = {
 
         params.columns.forEach((column, i) => {
             if (column !== null) {
-                text(column, `params.columns[${i}]`);
+                filledText(column, `params.columns[${i}]`);
             }
         });
     },
     discover: (input) => {
         const params = shape(input, 'params', ['kind'], ['context']);
         oneOf(['docker'])(params.kind, 'params.kind');
-        optional(params, 'context', 'params', text);
+        optional(params, 'context', 'params', filledText);
     },
     cancel: (input) => {
         const params = shape(input, 'params', ['request']);
 
-        if (typeof params.request !== 'string' || params.request.length === 0 || params.request.length > MAX_ID_LENGTH) {
+        if (!isRequestId(params.request)) {
             fail(`"params.request" must be a string of 1 to ${MAX_ID_LENGTH} characters.`);
         }
     }
@@ -370,7 +372,7 @@ const PARAMS: { readonly [M in DatabaseMethod]: (input: unknown) => void } = {
 
 /* Checks the whole request before anything reaches the helper, which then never has to defend itself against a page. */
 export const parseRequest = (input: unknown): ParsedRequest => {
-    const id = isDict(input) && typeof input.id === 'string' && input.id.length > 0 && input.id.length <= MAX_ID_LENGTH ? input.id : '';
+    const id = isDict(input) && isRequestId(input.id) ? input.id : '';
 
     try {
         const envelope = shape(input, 'request', ['id', 'method', 'params']);

package/src/protocol/messages.ts

@@ -6,7 +6,6 @@ import type { Cell, EditValue, Value } from './values.ts';
 /* Raised whenever a message changes shape, so a host refuses a helper from another release. */
 export const PROTOCOL_VERSION = 3;
 
-/* The columns of the row key and their values. */
 export type RowKey = Readonly<Record<string, Value>>;
 
 export type RowChange =

package/src/sql.ts

@@ -18,7 +18,12 @@ export interface SqlTarget {
 export type LiteralValue = Cell | Value | { readonly kind: 'default' };
 
 const NUMERIC_KINDS: ReadonlySet<ValueKind> = new Set(['integer', 'decimal', 'float']);
-const NUMERIC_TEXT = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+
+/* A number as SQL and most people write it: a sign, digits with an optional fraction, and an exponent. */
+export const NUMERIC_TEXT = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+
+/* Whether a value of this kind is a number, which a grid aligns against the end of its cell. */
+export const isNumericKind = (kind: ValueKind): boolean => NUMERIC_KINDS.has(kind);
 const ORDER_ITEM = /\s*(`(?:[^`]|``)+`|"(?:[^"]|"")+"|[A-Za-z_][\w$]*)(?:\s+(asc|desc))?\s*(,|$)/iy;
 
 const markOf = (engine: Engine): string => (engine === 'mysql' ? '`' : '"');
@@ -54,7 +59,7 @@ export const sqlLiteral = (engine: Engine, value: LiteralValue, kind?: ValueKind
             return Number.isFinite(value) ? String(value) : 'NULL';
         case 'string': {
             const trimmed = value.trim();
-            return kind !== undefined && NUMERIC_KINDS.has(kind) && NUMERIC_TEXT.test(trimmed) ? trimmed : stringLiteral(engine, value);
+            return kind !== undefined && isNumericKind(kind) && NUMERIC_TEXT.test(trimmed) ? trimmed : stringLiteral(engine, value);
         }
     }
     switch (value.kind) {

package/src/structure/StructureView.tsx

@@ -36,7 +36,6 @@ interface Answer {
 
 const TH = 'sticky top-0 h-7 bg-surface px-3 text-left text-xs font-medium whitespace-nowrap text-text-faint';
 const TD = 'h-7 border-t border-border-soft px-3 text-xs whitespace-nowrap text-text select-text';
-const MONO = CODE_TEXT;
 
 /* The columns, indexes, foreign keys and DDL of one table or view. */
 export function StructureView({ connection, schema, table, toolbarStart, className, ref }: StructureViewProps) {
@@ -44,7 +43,7 @@ export function StructureView({ connection, schema, table, toolbarStart, classNa
     const client = useDatabaseClient();
     const [answer, setAnswer] = useState<Answer | null>(null);
     const [attempt, setAttempt] = useState(0);
-    // A schema change reloads without leaving the structure on screen: the answer keeps its place until the new one arrives.
+    // A schema change reloads in place: the old answer stays on screen until the new one arrives.
     const [reloads, setReloads] = useState(0);
     const answered = answer !== null && answer.connection === connection && answer.schema === schema && answer.table === table && answer.attempt === attempt;
     const load: Load = answered ? answer.load : { status: 'loading' };
@@ -194,11 +193,11 @@ function ColumnRow({ column, primary, foreign }: { column: ColumnInfo; primary:
                     {column.name}
                 </span>
             </td>
-            <td className={clsx(TD, MONO)}>{column.type}</td>
+            <td className={clsx(TD, CODE_TEXT)}>{column.type}</td>
             <td className={clsx(TD, 'text-text-muted')}>
                 <YesNo value={column.nullable} />
             </td>
-            <td className={clsx(TD, MONO)}>{column.defaultValue}</td>
+            <td className={clsx(TD, CODE_TEXT)}>{column.defaultValue}</td>
             <td className={TD}>
                 <span className="flex gap-1">
                     {column.autoIncrement && <Pill>{t('structure.autoIncrement')}</Pill>}
@@ -220,7 +219,7 @@ function IndexesTable({ indexes }: { indexes: readonly IndexInfo[] }) {
             {indexes.map((index) => (
                 <tr key={index.name}>
                     <td className={TD}>{index.name}</td>
-                    <td className={clsx(TD, MONO)}>{index.columns.join(', ')}</td>
+                    <td className={clsx(TD, CODE_TEXT)}>{index.columns.join(', ')}</td>
                     <td className={TD}>
                         <span className="flex gap-1">
                             {index.primary && <Pill tone="accent">{t('structure.primary')}</Pill>}
@@ -252,8 +251,8 @@ function ForeignKeysTable({ foreignKeys }: { foreignKeys: readonly ForeignKeyInf
             {foreignKeys.map((key, i) => (
                 <tr key={key.name ?? i}>
                     <td className={TD}>{key.name}</td>
-                    <td className={clsx(TD, MONO)}>{key.columns.join(', ')}</td>
-                    <td className={clsx(TD, MONO)}>{referenceOf(key)}</td>
+                    <td className={clsx(TD, CODE_TEXT)}>{key.columns.join(', ')}</td>
+                    <td className={clsx(TD, CODE_TEXT)}>{referenceOf(key)}</td>
                     <td className={clsx(TD, 'text-text-muted')}>{action(key.onUpdate)}</td>
                     <td className={clsx(TD, 'text-text-muted')}>{action(key.onDelete)}</td>
                 </tr>
@@ -273,7 +272,7 @@ function Ddl({ ddl }: { ddl: string | null }) {
                 <Icon icon={Copy} size={12} />
                 {t('structure.copy')}
             </Button>
-            <pre className={clsx(MONO, 'overflow-auto p-3 pr-24 whitespace-pre text-text select-text')}>{ddl}</pre>
+            <pre className={clsx(CODE_TEXT, 'overflow-auto p-3 pr-24 whitespace-pre text-text select-text')}>{ddl}</pre>
         </div>
     );
 }

package/src/table/CommandField.tsx

@@ -25,7 +25,6 @@ export interface CommandFieldProps {
     engine: Engine;
     /* Every change of the chips applies at once, so this is told the whole list each time. */
     onChipsChange(next: Chip[]): void;
-    /* "Jump to column" was picked. */
     onJumpToColumn(name: string): void;
     /* The text input, for the owner to focus on Mod+F. */
     inputRef?: Ref<HTMLInputElement>;

package/src/table/TableView.tsx

@@ -27,7 +27,7 @@ import type { GridSort } from '../grid/sort.ts';
 import type { ColumnRequest, FocusedCell, FocusRequest, GridMenuContext } from '../grid/types.ts';
 import { RecordView } from '../grid/RecordView.tsx';
 import { ValueDock } from '../grid/ValueDock.tsx';
-import { valueOfCell, type EditValue, type RowChange, type Value } from '../protocol/index.ts';
+import { valueOfCell, type EditValue, type RowChange, type TableStructure, type Value } from '../protocol/index.ts';
 import type { SqlTarget } from '../sql.ts';
 import { useSchemaChange } from '../use-schema-change.ts';
 import { useStableCallback } from '../use-stable-callback.ts';
@@ -109,6 +109,19 @@ interface Filters {
 
 const NO_KEYS: ReadonlySet<string> = new Set();
 
+const readOnlyReasonOf = (connection: Connection, structure: TableStructure | null, t: TFunction<'database'>): string | null => {
+    if (connection.config.readOnly === true) {
+        return t('table.readOnly.connection');
+    }
+    if (structure?.kind === 'view') {
+        return t('table.readOnly.view');
+    }
+    if (structure !== null && structure.rowKey === null) {
+        return t('table.readOnly.noKey');
+    }
+    return null;
+};
+
 /* What the strip over the table, or the app's notice, says of an export or an import. */
 const transferText = (found: TransferNotice, t: TFunction<'database'>): string => {
     switch (found.kind) {
@@ -123,7 +136,6 @@ const transferText = (found: TransferNotice, t: TFunction<'database'>): string =
     }
 };
 
-/* How much of a value a menu item spells out before it cuts it. */
 const MENU_VALUE_LENGTH = 40;
 
 const FOCUS_COMMAND = shortcut('Mod+F');
@@ -210,16 +222,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
     const loaded = rowsLoad.value?.result ?? null;
     const loadedOffset = rowsLoad.value?.offset ?? 0;
 
-    const readOnlyReason =
-        connection.config.readOnly === true
-            ? t('table.readOnly.connection')
-            : structure === null
-              ? null
-              : structure.kind === 'view'
-                ? t('table.readOnly.view')
-                : structure.rowKey === null
-                  ? t('table.readOnly.noKey')
-                  : null;
+    const readOnlyReason = readOnlyReasonOf(connection, structure, t);
     const editable = readOnlyReason === null && structure !== null && loaded !== null && !rowsLoad.loading;
 
     const columns = useMemo(() => (loaded === null ? [] : buildGridColumns(loaded, structure)), [loaded, structure]);
@@ -342,7 +345,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
         }
     };
 
-    /* Every change of the chips applies at once; one that changes the page asks first when it would throw pending changes away. */
+    /* A change that leaves the SQL alone only remembers the filters and keeps the page. */
     const applyChips = (next: readonly Chip[]): void => {
         const where = chipsToWhere(next);
         const orderBy = chipsToOrderBy(engine, next);
@@ -713,27 +716,7 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
                     </Button>
                 </Banner>
             )}
-            {transfer.notice !== null && (
-                <Banner
-                    icon={transfer.notice.kind === 'failed' ? CircleAlert : transfer.notice.kind === 'exporting' ? Download : Check}
-                    tone={transfer.notice.kind === 'failed' ? 'error' : 'neutral'}
-                    message={transferText(transfer.notice, t)}
-                    className="shrink-0 pt-2"
-                >
-                    {transfer.notice.kind === 'exporting' ? (
-                        <>
-                            <Spinner size={12} label={t('table.export.running', { format: transfer.notice.format.toUpperCase() })} />
-                            <Button size="xs" onClick={transfer.cancelExport}>
-                                {t('table.export.cancel')}
-                            </Button>
-                        </>
-                    ) : (
-                        <Button size="xs" onClick={transfer.dismiss}>
-                            {t('table.dismiss')}
-                        </Button>
-                    )}
-                </Banner>
-            )}
+            {transfer.notice !== null && <TransferBanner notice={transfer.notice} onCancel={transfer.cancelExport} onDismiss={transfer.dismiss} />}
             {loaded === null ? (
                 <PanelEmpty busy={notice === null}>{notice === null ? t('table.loading') : t('table.notLoaded')}</PanelEmpty>
             ) : (
@@ -841,3 +824,34 @@ function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defa
         </div>
     );
 }
+
+interface TransferBannerProps {
+    notice: TransferNotice;
+    onCancel(): void;
+    onDismiss(): void;
+}
+
+function TransferBanner({ notice, onCancel, onDismiss }: TransferBannerProps) {
+    const { t } = useTranslation('database');
+    return (
+        <Banner
+            icon={notice.kind === 'failed' ? CircleAlert : notice.kind === 'exporting' ? Download : Check}
+            tone={notice.kind === 'failed' ? 'error' : 'neutral'}
+            message={transferText(notice, t)}
+            className="shrink-0 pt-2"
+        >
+            {notice.kind === 'exporting' ? (
+                <>
+                    <Spinner size={12} label={t('table.export.running', { format: notice.format.toUpperCase() })} />
+                    <Button size="xs" onClick={onCancel}>
+                        {t('table.export.cancel')}
+                    </Button>
+                </>
+            ) : (
+                <Button size="xs" onClick={onDismiss}>
+                    {t('table.dismiss')}
+                </Button>
+            )}
+        </Banner>
+    );
+}

package/src/table/command-field.ts

@@ -65,6 +65,8 @@ const isFilter = (chip: Chip): chip is FilterChip => chip.kind === 'filter';
 
 const isSort = (chip: Chip): chip is SortChip => chip.kind === 'sort';
 
+const sortChip = (sort: ColumnSort): SortChip => ({ kind: 'sort', column: sort.column, direction: sort.direction });
+
 /* A name as typed in SQL: bare when it can be, else in double quotes. The quotes are only for the text of a chip; `sql` quotes per engine. */
 export const identifierText = (name: string): string => (BARE_NAME.test(name) ? name : `"${name.replaceAll('"', '""')}"`);
 
@@ -95,10 +97,7 @@ export const chipsToOrderBy = (engine: Engine, chips: readonly Chip[]): string =
 export const sortsOf = (chips: readonly Chip[]): ColumnSort[] => chips.filter(isSort).map(({ column, direction }) => ({ column, direction }));
 
 /* The sorts of a header menu replace every sort and raw ORDER BY, keeping the filters where they are. */
-export const withSorts = (chips: readonly Chip[], sorts: readonly ColumnSort[]): Chip[] => [
-    ...chips.filter(isFilter),
-    ...sorts.map((sort): Chip => ({ kind: 'sort', column: sort.column, direction: sort.direction }))
-];
+export const withSorts = (chips: readonly Chip[], sorts: readonly ColumnSort[]): Chip[] => [...chips.filter(isFilter), ...sorts.map(sortChip)];
 
 /* A column that is not sorted joins as ascending; one that is flips its direction where it stands. */
 export const toggleSort = (chips: readonly Chip[], column: string): Chip[] => {
@@ -139,7 +138,7 @@ export const sortChipsOf = (engine: Engine, orderBy: string): Chip[] => {
         return [];
     }
     const sorts = parseOrderByLoose(engine, text);
-    return sorts === null ? [{ kind: 'order', text }] : sorts.map((sort): Chip => ({ kind: 'sort', column: sort.column, direction: sort.direction }));
+    return sorts === null ? [{ kind: 'order', text }] : sorts.map(sortChip);
 };
 
 export interface ChipSource {
@@ -183,13 +182,11 @@ const readOperation = (rest: string): string | null => {
         const operator = compare[1] === '==' ? '=' : compare[1] === '!=' ? '<>' : compare[1];
         return isClosed(compare[2]!) ? `${operator} ${compare[2]}` : null;
     }
-    const pattern = PATTERN.exec(rest);
-    if (pattern !== null) {
-        return isClosed(pattern[2]!) ? `${upper(pattern[1]!)} ${pattern[2]}` : null;
-    }
-    const member = MEMBER.exec(rest);
-    if (member !== null) {
-        return isClosed(member[2]!) ? `${upper(member[1]!)} ${member[2]}` : null;
+    for (const form of [PATTERN, MEMBER]) {
+        const found = form.exec(rest);
+        if (found !== null) {
+            return isClosed(found[2]!) ? `${upper(found[1]!)} ${found[2]}` : null;
+        }
     }
     const between = BETWEEN.exec(rest);
     if (between !== null) {