@adecore/database 0.23.0 → 0.24.0

package/src/grid/display.ts

@@ -1,6 +1,7 @@
 import { formatBytes, formatNumeral } from '@adecore/ui/format';
 import type { BinaryValue, Cell, EditValue, ValueKind } from '../protocol/index.ts';
 import { isNumericKind } from '../sql.ts';
+import type { GridColumn } from './types.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' };
@@ -47,6 +48,18 @@ export const numeralText = (numeral: string | number, notation: NumberNotation):
     return formatted === String(numeral).trim() ? String(numeral) : formatted;
 };
 
+/* Identifiers are labels, even when the database stores their characters as a number. */
+export function columnNotation(column: GridColumn, notation: NumberNotation): NumberNotation {
+    const identifierName = (name: string): boolean => /^(?:id|.+_id)$/i.test(name) || /(?:Id|ID)$/.test(name);
+    return column.primaryKey === true ||
+        column.foreignKey === true ||
+        column.autoIncrement === true ||
+        identifierName(column.name) ||
+        (column.source !== undefined && identifierName(column.source.column))
+        ? 'database'
+        : notation;
+}
+
 const cut = (text: string): string => (text.length > DISPLAY_LIMIT ? `${text.slice(0, DISPLAY_LIMIT)}${ELLIPSIS}` : text);
 
 export const cellView = (cell: Shown, kind: ValueKind, notation: NumberNotation = 'database'): CellView => {

package/src/grid/whole-cells.ts

@@ -0,0 +1,72 @@
+import type { Value } from '../protocol/index.ts';
+import { isPreview, shownOfEdit, type Shown } from './display.ts';
+
+/* Characters of whole values one copy fetches at most, a byte of a binary value counting as two: past it the copy would hold the clipboard and the session for too long. */
+export const WHOLE_COPY_LIMIT = 16 * 1024 * 1024;
+
+/* The helper runs the requests of a session one after another, so more at once would only wait in its queue. */
+const PARALLEL_LOADS = 4;
+
+export interface WholeCells {
+    readonly rows: readonly (readonly Shown[])[];
+    /* The cells that are still previews. */
+    readonly previews: number;
+    /* Whether the previews stayed because the whole values are larger than `WHOLE_COPY_LIMIT`, rather than because they could not be loaded. */
+    readonly tooLarge: boolean;
+}
+
+interface Wanted {
+    readonly row: number;
+    readonly column: number;
+}
+
+const wholeSize = (cell: Shown): number => {
+    if (cell === null || typeof cell !== 'object' || cell.kind === 'default') {
+        return 0;
+    }
+    return cell.kind === 'longText' ? cell.length : cell.length * 2;
+};
+
+/*
+ * A block of cells with every preview replaced by the whole value `load` fetches for it, by its row and
+ * column in the block. A cell `load` resolves `undefined` for, or rejects for, stays a preview.
+ */
+export const loadWholeCells = async (
+    rows: readonly (readonly Shown[])[],
+    load: ((row: number, column: number) => Promise<Value | undefined>) | undefined
+): Promise<WholeCells> => {
+    const wanted: Wanted[] = [];
+    let size = 0;
+    rows.forEach((cells, row) =>
+        cells.forEach((cell, column) => {
+            if (isPreview(cell)) {
+                wanted.push({ row, column });
+                size += wholeSize(cell);
+            }
+        })
+    );
+    if (wanted.length === 0) {
+        return { rows, previews: 0, tooLarge: false };
+    }
+    if (load === undefined || size > WHOLE_COPY_LIMIT) {
+        return { rows, previews: wanted.length, tooLarge: load !== undefined };
+    }
+
+    const filled = rows.map((cells) => [...cells]);
+    let previews = 0;
+    let next = 0;
+    const work = async (): Promise<void> => {
+        while (next < wanted.length) {
+            const { row, column } = wanted[next]!;
+            next += 1;
+            const value = await load(row, column).catch(() => undefined);
+            if (value === undefined) {
+                previews += 1;
+            } else {
+                filled[row]![column] = shownOfEdit(value);
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(PARALLEL_LOADS, wanted.length) }, work));
+    return { rows: filled, previews, tooLarge: false };
+};

package/src/host/helper-path.ts

@@ -1,20 +1,25 @@
 import { existsSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, join, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 export interface HelperPathOptions {
     /* `process.platform` when left out. */
     readonly platform?: string;
     /* `process.arch` when left out. */
     readonly arch?: string;
+    /* `process.env` when left out. */
+    readonly env?: Readonly<Record<string, string | undefined>>;
     /* Resolves a package specifier to a file; the module resolution of this file when left out. */
     readonly resolve?: (specifier: string) => string;
     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.
+ * Finds the helper for this machine, or null when there is none. In order: the path in `ADECORE_DATABASE_HELPER`;
+ * the prebuilt binary npm installed in the `@adecore/database-<platform>-<arch>` package, absent on an
+ * unsupported platform or an install with optional dependencies off; and, when the package runs from the `src`
+ * of a checkout, the release build `helper:build` leaves in that checkout.
  *
  * 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
@@ -23,9 +28,29 @@ export interface HelperPathOptions {
 export const helperPath = ({
     platform = process.platform,
     arch = process.arch,
+    env = process.env,
     resolve = (specifier) => createRequire(import.meta.url).resolve(specifier),
     exists = existsSync
 }: HelperPathOptions = {}): string | null => {
+    const override = env.ADECORE_DATABASE_HELPER;
+
+    // Not checked for existence: a wrong override fails loudly at spawn instead of quietly running another helper.
+    if (override) {
+        return override;
+    }
+
+    const binary = platform === 'win32' ? 'adecore-database.exe' : 'adecore-database';
+
+    return packagedHelper(platform, arch, binary, resolve, exists) ?? checkoutHelper(binary, exists);
+};
+
+const packagedHelper = (
+    platform: string,
+    arch: string,
+    binary: string,
+    resolve: (specifier: string) => string,
+    exists: (path: string) => boolean
+): string | null => {
     let manifest: string;
 
     try {
@@ -34,8 +59,21 @@ export const helperPath = ({
         return null;
     }
 
-    const binary = join(dirname(manifest), 'bin', platform === 'win32' ? 'adecore-database.exe' : 'adecore-database');
-    const unpacked = binary.replace(`.asar${sep}`, `.asar.unpacked${sep}`);
+    const unpacked = join(dirname(manifest), 'bin', binary).replace(`.asar${sep}`, `.asar.unpacked${sep}`);
 
     return exists(unpacked) ? unpacked : null;
 };
+
+// The published package ships `src` without `helper`, so `Cargo.toml` is what tells a checkout apart from an install.
+const checkoutHelper = (binary: string, exists: (path: string) => boolean): string | null => {
+    const here = new URL('.', import.meta.url);
+
+    if (here.protocol !== 'file:' || !here.pathname.endsWith('/src/host/')) {
+        return null;
+    }
+
+    const helper = new URL('../../helper/', here);
+    const built = fileURLToPath(new URL(`target/release/${binary}`, helper));
+
+    return exists(fileURLToPath(new URL('Cargo.toml', helper))) && exists(built) ? built : null;
+};

package/src/host/host.ts

@@ -319,6 +319,12 @@ export const createDatabaseHost = (options: DatabaseHostOptions): DatabaseHost =
             sessions.delete(request.params.session);
         }
 
+        // The helper ends a session whose connection to the server was lost.
+        const target = sessionOf(request);
+        if (target !== null && !response.ok && response.error.code === 'unknown-session') {
+            sessions.delete(target);
+        }
+
         if (request.method !== 'open' || !response.ok) {
             return { ...response, id: request.id } as DatabaseResponse;
         }

package/src/host/validate.ts

@@ -7,6 +7,7 @@ export type ParsedRequest =
 const MAX_ID_LENGTH = 200;
 const MAX_LIMIT = 10000;
 const MAX_CELL_LIMIT = 1048576;
+const MAX_BYTES = 67108864;
 const TLS_MODES = ['disable', 'prefer', 'require', 'verify'];
 const TRANSACTION_ACTIONS = ['begin', 'commit', 'rollback'];
 const EXPORT_FORMATS = ['csv', 'tsv', 'json', 'sql'];
@@ -250,6 +251,8 @@ 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 maxBytes = (params: Dict): void => optional(params, 'maxBytes', 'params', (limit, name) => integer(limit, name, 1, MAX_BYTES));
+
 const table = (params: Dict): void => {
     filledText(params.session, 'params.session');
     filledText(params.schema, 'params.schema');
@@ -270,13 +273,14 @@ const PARAMS: { readonly [M in DatabaseMethod]: (input: unknown) => void } = {
     },
     structure: (input) => table(shape(input, 'params', TARGET)),
     rows: (input) => {
-        const params = shape(input, 'params', [...TARGET, 'offset', 'limit'], ['where', 'orderBy', 'cellLimit']);
+        const params = shape(input, 'params', [...TARGET, 'offset', 'limit'], ['where', 'orderBy', 'cellLimit', 'maxBytes']);
         table(params);
         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);
+        maxBytes(params);
     },
     count: (input) => {
         const params = shape(input, 'params', TARGET, ['where']);
@@ -301,21 +305,23 @@ const PARAMS: { readonly [M in DatabaseMethod]: (input: unknown) => void } = {
         params.changes.forEach((change, i) => rowChange(change, `params.changes[${i}]`));
     },
     execute: (input) => {
-        const params = shape(input, 'params', ['session', 'sql'], ['schema', 'limit', 'cellLimit']);
+        const params = shape(input, 'params', ['session', 'sql'], ['schema', 'limit', 'cellLimit', 'maxBytes']);
         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);
+        maxBytes(params);
     },
     page: (input) => {
-        const params = shape(input, 'params', ['session', 'sql', 'offset', 'limit'], ['schema', 'cellLimit']);
+        const params = shape(input, 'params', ['session', 'sql', 'offset', 'limit'], ['schema', 'cellLimit', 'maxBytes']);
         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);
+        maxBytes(params);
     },
     transaction: (input) => {
         const params = shape(input, 'params', ['session', 'action']);

package/src/index.ts

@@ -34,6 +34,7 @@ export { useDatabaseClient } from './client-context.ts';
 export type { NumberNotation } from './grid/display.ts';
 export { QueryConsole, type QueryConsoleProps } from './console/QueryConsole.tsx';
 export type { QueryConsoleEditorHandle, QueryConsoleEditorProps, QueryConsoleRunScope } from './console/editor-slot.ts';
+export { RUN_ALL_SHORTCUT, RUN_SHORTCUT, runScopeOf } from './console/shortcuts.ts';
 export { StructureView, type StructureViewProps } from './structure/StructureView.tsx';
 export { TableView, type TableViewProps } from './table/TableView.tsx';
 export { DatabaseWorkbench, type DatabaseWorkbenchProps } from './workbench/DatabaseWorkbench.tsx';