@adecore/database 0.21.1 → 0.22.0

package/src/table/grid-rows.ts

@@ -15,13 +15,8 @@ export const parseRowKey = (key: string): RowRef =>
 
 export const buildGridColumns = (loaded: Pick<RowsResult, 'columns'>, structure: TableStructure | null): GridColumn[] => {
     const keys = { primaryKey: structure?.primaryKey ?? [], foreignKey: structure?.foreignKeys.flatMap((key) => key.columns) ?? [] };
-    return loaded.columns.map((column) =>
-        gridColumnOf(
-            column,
-            structure?.columns.find((info) => info.name === column.name),
-            keys
-        )
-    );
+    const infoOf = (name: string) => structure?.columns.find((info) => info.name === name);
+    return loaded.columns.map((column) => gridColumnOf(column, infoOf(column.name), keys));
 };
 
 export interface GridRowsInput {

package/src/table/layout-store.ts

@@ -2,7 +2,10 @@ import type { GridLayout } from '../grid/column-layout.ts';
 import type { StoredFilter } from './command-field.ts';
 import { PAGE_SIZES } from './paging.ts';
 
-/* Bump when the shape changes; a stored value of another version is ignored rather than migrated. `filters` was added alongside `where`, which still says the same thing for a value without it. */
+/*
+ * Bump when the shape changes; a stored value of another version is ignored rather than migrated. `filters`
+ * came later without a bump, since `where` still says the same thing for a value without it.
+ */
 export const LAYOUT_VERSION = 1;
 
 /* What is remembered of one table's view between visits. */
@@ -20,11 +23,11 @@ export const layoutStorageKey = (connectionId: string, schema: string, table: st
 
 const isStringList = (value: unknown): value is string[] => Array.isArray(value) && value.every((item) => typeof item === 'string');
 
+const isRecord = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === 'object' && !Array.isArray(value);
+
 const isStoredFilter = (value: unknown): value is StoredFilter =>
     isRecord(value) && typeof value.text === 'string' && typeof value.sql === 'string' && value.sql.trim() !== '';
 
-const isRecord = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === 'object' && !Array.isArray(value);
-
 export const serializeLayout = (layout: StoredLayout): string => JSON.stringify({ version: LAYOUT_VERSION, ...layout });
 
 /* The layout a stored text holds, or `null` when it is missing, broken or from another version. A field that is off is dropped alone. */

package/src/table/pending.ts

@@ -112,8 +112,6 @@ export const rowKeyOf = (structure: TableStructure, loaded: LoadedRows, row: num
     return key;
 };
 
-const numeric = (text: string): number => Number(text);
-
 /* Updates, then deletes, then inserts, all computed against the page as loaded. Throws for a change on a row without a usable key, which the grid never lets a person make. */
 export const toRowChanges = (structure: TableStructure, loaded: LoadedRows, pending: PendingChanges): RowChange[] => {
     const keyOf = (row: number): RowKey => {
@@ -124,7 +122,7 @@ export const toRowChanges = (structure: TableStructure, loaded: LoadedRows, pend
         return key;
     };
     const updates = Object.keys(pending.edits)
-        .map(numeric)
+        .map(Number)
         .filter((row) => !pending.deletes.has(row))
         .sort((left, right) => left - right)
         .map((row): RowChange => ({ kind: 'update', key: keyOf(row), values: pending.edits[row]! }));
@@ -133,11 +131,18 @@ export const toRowChanges = (structure: TableStructure, loaded: LoadedRows, pend
     return [...updates, ...deletes, ...inserts];
 };
 
+const keyValueText = (value: Value): string => {
+    if (value === null) {
+        return 'NULL';
+    }
+    if (typeof value === 'object') {
+        return `0x${value.hex}`;
+    }
+    return typeof value === 'string' ? `'${value}'` : String(value);
+};
+
 /* A key as a person would write it in a WHERE: `id = 5, tenant = 'a'`. */
 export const describeKey = (key: RowKey): string =>
     Object.entries(key)
-        .map(
-            ([column, value]) =>
-                `${column} = ${value === null ? 'NULL' : typeof value === 'object' ? `0x${value.hex}` : typeof value === 'string' ? `'${value}'` : String(value)}`
-        )
+        .map(([column, value]) => `${column} = ${keyValueText(value)}`)
         .join(', ');

package/src/table/useTableTransfer.ts

@@ -1,7 +1,7 @@
 import { useEffect, useRef, useState } from 'react';
 import { messageOf } from '@adecore/ui';
 import type { DatabaseFiles } from '../actions.ts';
-import { DatabaseRequestError, type DatabaseClient, type DatabaseSession } from '../client/types.ts';
+import { isCancelled, type DatabaseClient, type DatabaseSession } from '../client/types.ts';
 import type { FileFormat, TableStructure } from '../protocol/index.ts';
 import type { ImportSample } from './ImportDialog.tsx';
 import { formatOfPath, importableColumns, mapColumn, matchColumns, type ImportFormat } from './import-mapping.ts';
@@ -13,6 +13,9 @@ export type TransferNotice =
     | { readonly kind: 'imported'; readonly rows: number }
     | { readonly kind: 'failed'; readonly during: 'export' | 'import'; readonly message: string };
 
+/* How long a finished export or import stays on the strip. */
+const NOTICE_MS = 8000;
+
 /* The import a person is setting up. */
 export interface ImportDraft {
     readonly path: string;
@@ -68,7 +71,7 @@ export function useTableTransfer({ client, session, files, schema, table, struct
         if (notice?.kind !== 'exported' && notice?.kind !== 'imported') {
             return;
         }
-        const timer = setTimeout(() => setNotice(null), 8000);
+        const timer = setTimeout(() => setNotice(null), NOTICE_MS);
         return () => clearTimeout(timer);
     }, [notice]);
 
@@ -102,8 +105,7 @@ export function useTableTransfer({ client, session, files, schema, table, struct
                 );
                 show({ kind: 'exported', rows: result.rows });
             } catch (error) {
-                const cancelled = controller.signal.aborted || (error instanceof DatabaseRequestError && error.code === 'cancelled');
-                if (cancelled) {
+                if (controller.signal.aborted || isCancelled(error)) {
                     setNotice(null);
                 } else {
                     show({ kind: 'failed', during: 'export', message: messageOf(error) });
@@ -153,7 +155,7 @@ export function useTableTransfer({ client, session, files, schema, table, struct
                     now === null || now.path !== path ? now : { ...now, header, sample: read, mapping: matchColumns(read.columns, tableColumns, header) }
                 );
             } catch (error) {
-                if (!(error instanceof DatabaseRequestError && error.code === 'cancelled')) {
+                if (!isCancelled(error)) {
                     setImportDraft((now) => (now === null || now.path !== path ? now : { ...now, error: messageOf(error) }));
                 }
             }

package/src/testing/fake.ts

@@ -119,14 +119,18 @@ const toTables = (database: FakeDatabase): Map<string, Map<string, Table>> =>
         ])
     );
 
-const findTable = (session: Session, schema: string, name: string): Table => {
+const findSchema = (session: Session, schema: string): Map<string, Table> => {
     const tables = session.schemas.get(schema);
 
     if (tables === undefined) {
         throw new FakeError('query-failed', `Unknown database '${schema}'`, '42000');
     }
 
-    const table = tables.get(name);
+    return tables;
+};
+
+const findTable = (session: Session, schema: string, name: string): Table => {
+    const table = findSchema(session, schema).get(name);
 
     if (table === undefined) {
         throw new FakeError('query-failed', `Table '${schema}.${name}' doesn't exist`, '42S02');
@@ -334,10 +338,7 @@ const selectSchema = (session: Session, schema: string | undefined): void => {
         return;
     }
 
-    if (!session.schemas.has(schema)) {
-        throw new FakeError('query-failed', `Unknown database '${schema}'`, '42000');
-    }
-
+    findSchema(session, schema);
     session.schema = schema;
 };
 
@@ -402,12 +403,7 @@ export const fakeDatabaseTransport = (options: FakeDatabaseTransportOptions): Da
             schemas: [...sessionOf(session).schemas.keys()].map((name) => ({ name, system: SYSTEM_SCHEMAS.includes(name) }))
         }),
         tables: ({ session, schema }) => {
-            const tables = sessionOf(session).schemas.get(schema);
-
-            if (tables === undefined) {
-                throw new FakeError('query-failed', `Unknown database '${schema}'`, '42000');
-            }
-
+            const tables = findSchema(sessionOf(session), schema);
             return { tables: [...tables].map(([name, table]) => ({ name, kind: table.kind, rowEstimate: table.rows.length, comment: null })) };
         },
         structure: ({ session, schema, table: name }) => {

package/src/value/ValueEditor.tsx

@@ -96,7 +96,7 @@ export function ValueEditor({ column, value, editable, onCommit }: ValueEditorPr
         } else if (rendered !== null && rendered.kind === 'text') {
             copyText(rendered.text);
         } else {
-            copyText(draft.mode === 'value' ? draft.text : draft.mode === 'null' ? 'NULL' : 'DEFAULT');
+            copyText(placeholder ?? draft.text);
         }
     };
 

package/src/value/draft.ts

@@ -25,12 +25,7 @@ export type DraftProblem = { readonly kind: 'json'; readonly reason: string } |
 export type Conversion = { readonly ok: true; readonly value: EditValue } | { readonly ok: false; readonly problem: DraftProblem };
 
 /* The text a value is edited as: a binary value as its hex, everything else as it is written. */
-const textOf = (value: Exclude<Value, null>): string => {
-    if (typeof value === 'object') {
-        return value.hex;
-    }
-    return String(value);
-};
+const textOf = (value: Exclude<Value, null>): string => (typeof value === 'object' ? value.hex : String(value));
 
 export const sourceOf = (column: Pick<GridColumn, 'name' | 'type' | 'kind'>, value: Value): Source => {
     const binary = column.kind === 'binary' || (value !== null && typeof value === 'object');

package/src/value/json.ts

@@ -49,11 +49,11 @@ export const prettyJson = (text: string): string | null => {
             continue;
         }
         if (char === '{' || char === '[') {
-            const empty = nextToken(i + 1) === (char === '{' ? '}' : ']');
+            const close = char === '{' ? '}' : ']';
             output += char;
-            if (empty) {
-                output += char === '{' ? '}' : ']';
-                i = text.indexOf(char === '{' ? '}' : ']', i + 1) + 1;
+            if (nextToken(i + 1) === close) {
+                output += close;
+                i = text.indexOf(close, i + 1) + 1;
                 continue;
             }
             depth++;

package/src/workbench/DatabaseWorkbench.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useRef, useState, type KeyboardEvent, type Ref } from 'react';
 import clsx from 'clsx';
-import { PencilRuler, Settings2, SquareTerminal, Table, TableProperties } from 'lucide-react';
+import { PencilRuler, Settings2, SquareTerminal, Table, TableProperties, type LucideIcon } from 'lucide-react';
 import { useTranslation } from 'react-i18next';
 import {
     Button,
@@ -26,6 +26,7 @@ import type { Connection } from '../client/types.ts';
 import { ConnectionManager } from '../connections/ConnectionManager.tsx';
 import { QueryConsole } from '../console/QueryConsole.tsx';
 import { DatabaseExplorer } from '../explorer/DatabaseExplorer.tsx';
+import { useStableCallback } from '../use-stable-callback.ts';
 import { DesignerTab } from './DesignerTab.tsx';
 import { TableTab } from './TableTab.tsx';
 import {
@@ -44,7 +45,6 @@ import {
     STORAGE_KEY,
     type WorkbenchTab
 } from './tabs.ts';
-import { useStableCallback } from '../use-stable-callback.ts';
 
 export interface DatabaseWorkbenchProps {
     connections: readonly Connection[];
@@ -56,6 +56,13 @@ export interface DatabaseWorkbenchProps {
 
 const DEFAULT_WIDTH = 280;
 const MIN_WIDTH = 200;
+const CLOSE_TAB = shortcut('Mod+W');
+
+const TAB_ICON: Record<WorkbenchTab['kind'], LucideIcon> = {
+    table: Table,
+    console: SquareTerminal,
+    designer: PencilRuler
+};
 
 /*
  * The whole database view in one piece: the explorer beside closable tabs for the tables, consoles and
@@ -83,8 +90,9 @@ export function DatabaseWorkbench({ connections, onConnectionsChange, className,
     if (pruned !== state) {
         setState(pruned);
     }
-    if ([...dirty].some((id) => !state.tabs.some((tab) => tab.id === id))) {
-        setDirty(new Set([...dirty].filter((id) => state.tabs.some((tab) => tab.id === id))));
+    const isOpen = (id: string): boolean => state.tabs.some((tab) => tab.id === id);
+    if (![...dirty].every(isOpen)) {
+        setDirty(new Set([...dirty].filter(isOpen)));
     }
     const tabs = state.tabs.filter((tab) => known.has(connectionIdOf(tab)));
     const active = tabs.find((tab) => tab.id === state.activeId) ?? tabs.at(-1) ?? null;
@@ -146,7 +154,7 @@ export function DatabaseWorkbench({ connections, onConnectionsChange, className,
             active !== null &&
             e.currentTarget.contains(e.target as Node) &&
             !e.nativeEvent.isComposing &&
-            matchesShortcut(shortcut('Mod+W'), e.nativeEvent, isApplePlatform())
+            matchesShortcut(CLOSE_TAB, e.nativeEvent, isApplePlatform())
         ) {
             e.preventDefault();
             requestClose(active.id);
@@ -277,7 +285,7 @@ export function DatabaseWorkbench({ connections, onConnectionsChange, className,
                     >
                         {tabs.map((tab) => (
                             <Tabs.Tab key={tab.id} value={tab.id} onClose={() => requestClose(tab.id)}>
-                                <Icon icon={tab.kind === 'table' ? Table : tab.kind === 'console' ? SquareTerminal : PencilRuler} size={14} />
+                                <Icon icon={TAB_ICON[tab.kind]} size={14} />
                                 {titleOf(tab)}
                             </Tabs.Tab>
                         ))}

package/src/workbench/DesignerTab.tsx

@@ -3,8 +3,8 @@ import type { DatabaseAction } from '../actions.ts';
 import { useDatabaseAction, useDatabaseClient, useDatabaseFiles, useDatabaseStorage, useNumberNotation } from '../client-context.ts';
 import type { Connection } from '../client/types.ts';
 import { TableDesigner } from '../designer/TableDesigner.tsx';
-import type { WorkbenchTab } from './tabs.ts';
 import { useStableCallback } from '../use-stable-callback.ts';
+import type { WorkbenchTab } from './tabs.ts';
 
 export interface DesignerTabProps {
     connection: Connection;

package/src/workbench/tabs.ts

@@ -25,6 +25,9 @@ export const connectionIdOf = (tab: WorkbenchTab): string => (tab.kind === 'tabl
 
 const tableTabId = (ref: TableRef): string => `table:${ref.connectionId}\u0000${ref.schema}\u0000${ref.table}`;
 
+const isDesignerOf = (tab: WorkbenchTab, connectionId: string, schema: string, table: string): boolean =>
+    tab.kind === 'designer' && tab.connectionId === connectionId && tab.schema === schema && tab.table === table;
+
 const add = (state: WorkbenchState, tab: WorkbenchTab): WorkbenchState => ({ ...state, tabs: [...state.tabs, tab], activeId: tab.id });
 
 const update = (state: WorkbenchState, id: string, change: (tab: WorkbenchTab) => WorkbenchTab): WorkbenchState => {
@@ -64,10 +67,7 @@ export const openConsole = (state: WorkbenchState, connectionId: string, schema?
 
 /* A table is designed in one tab; a new table gets a tab each time. */
 export const openDesigner = (state: WorkbenchState, connectionId: string, schema: string, table?: string): WorkbenchState => {
-    const existing =
-        table === undefined
-            ? undefined
-            : state.tabs.find((tab) => tab.kind === 'designer' && tab.connectionId === connectionId && tab.schema === schema && tab.table === table);
+    const existing = table === undefined ? undefined : state.tabs.find((tab) => isDesignerOf(tab, connectionId, schema, table));
     if (existing !== undefined) {
         return focusTab(state, existing.id);
     }
@@ -87,10 +87,7 @@ export const setDesignerTable = (state: WorkbenchState, id: string, table: strin
     if (subject?.kind !== 'designer' || subject.table === table) {
         return state;
     }
-    const tabs = state.tabs.filter(
-        (tab) =>
-            tab.id === id || !(tab.kind === 'designer' && tab.connectionId === subject.connectionId && tab.schema === subject.schema && tab.table === table)
-    );
+    const tabs = state.tabs.filter((tab) => tab.id === id || !isDesignerOf(tab, subject.connectionId, subject.schema, table));
     return update({ ...state, tabs }, id, (tab) => (tab.kind === 'designer' ? { ...tab, table } : tab));
 };