@adecore/database 0.39.0 → 0.40.0

package/src/grid/focused-value.ts

@@ -8,16 +8,20 @@ export const wholeValueOf = (cell: Shown): Value | undefined =>
 /* What a cell holds as far as it goes: the whole value, or the preview of a long text or a binary value. */
 export const previewValueOf = (cell: Shown): Value => {
     const whole = wholeValueOf(cell);
+
     if (whole !== undefined) {
         return whole;
     }
+
     if (cell !== null && typeof cell === 'object') {
         if (cell.kind === 'longText') {
             return cell.preview;
         }
+
         if (cell.kind === 'binary') {
             return { kind: 'binary', hex: cell.hex };
         }
     }
+
     return null;
 };

package/src/grid/layout.ts

@@ -3,14 +3,19 @@ export const ROW_HEIGHT = 28;
 export const HEADER_HEIGHT = 32;
 export const MIN_COLUMN_WIDTH = 64;
 export const MAX_COLUMN_WIDTH = 320;
+
 /* How far a drag may widen a column; the estimate stops at `MAX_COLUMN_WIDTH`, a person may go further. */
 export const MAX_RESIZED_WIDTH = 1200;
+
 /* How wide fitting a column to its content may make it. */
 export const MAX_FIT_WIDTH = 640;
+
 /* The window of drawn rows moves in blocks of this many rows, so a scroll within a block draws nothing. */
 export const ROW_BLOCK = 16;
+
 /* Two presses on a resize handle this close are a double click. */
 export const DOUBLE_CLICK_MS = 350;
+
 /* What a viewport is taken to be until it is measured, so a first paint already holds rows. */
 export const FALLBACK_VIEWPORT_HEIGHT = 600;
 
@@ -20,6 +25,7 @@ const CELL_PADDING = 24;
 const KEY_ICON_ROOM = 18;
 const GUTTER_MIN_WIDTH = 40;
 const SAMPLE_ROWS = 50;
+
 /* The arrow and the position number a sorted header carries after its name. */
 const SORT_ROOM = 24;
 
@@ -42,10 +48,12 @@ export const drawnRange = (block: number, height: number, count: number): Visibl
     if (count <= 0 || height <= 0) {
         return { start: 0, end: 0 };
     }
+
     const page = Math.ceil(height / ROW_HEIGHT);
     const top = Math.max(0, block) * ROW_BLOCK;
     const start = Math.max(0, Math.floor((top - page) / ROW_BLOCK) * ROW_BLOCK);
     const end = Math.min(count, Math.ceil((top + ROW_BLOCK + 2 * page) / ROW_BLOCK) * ROW_BLOCK);
+
     return { start: Math.min(start, end), end };
 };
 
@@ -57,18 +65,22 @@ export const scrollToReveal = (start: number, size: number, scroll: number, view
     if (start < scroll + leading) {
         return Math.max(0, start - leading);
     }
+
     if (start + size > scroll + viewport) {
         return Math.max(0, start + size - viewport);
     }
+
     return scroll;
 };
 
 /* The left edge of every column, counted from the first one. */
 export const columnOffsets = (widths: readonly number[]): number[] => {
     let offset = 0;
+
     return widths.map((width) => {
         const left = offset;
         offset += width;
+
         return left;
     });
 };

package/src/grid/navigation.ts

@@ -30,9 +30,11 @@ export const moveFocus = (from: CellPosition | null, input: NavigationKey, size:
     if (size.rows === 0 || size.columns === 0) {
         return null;
     }
+
     if (from === null && ENTERING_KEYS.has(input.key)) {
         return { row: 0, column: 0 };
     }
+
     const lastRow = size.rows - 1;
     const lastColumn = size.columns - 1;
     const start = from ?? { row: 0, column: 0 };
@@ -61,11 +63,14 @@ export const moveFocus = (from: CellPosition | null, input: NavigationKey, size:
                 if (column > 0) {
                     return { row, column: column - 1 };
                 }
+
                 return row > 0 ? { row: row - 1, column: lastColumn } : null;
             }
+
             if (column < lastColumn) {
                 return { row, column: column + 1 };
             }
+
             return row < lastRow ? { row: row + 1, column: 0 } : null;
         }
         default:

package/src/grid/row-selection.ts

@@ -15,21 +15,28 @@ export interface RowClick {
  */
 export const selectRow = (keys: readonly string[], current: ReadonlySet<string>, anchor: number, index: number, click: RowClick): RowSelection => {
     const key = keys[index];
+
     if (key === undefined) {
         return { selected: current, anchor };
     }
+
     if (click.shiftKey && anchor >= 0 && anchor < keys.length) {
         const from = Math.min(anchor, index);
         const to = Math.max(anchor, index);
         const range = keys.slice(from, to + 1);
+
         return { selected: new Set(click.mod ? [...current, ...range] : range), anchor };
     }
+
     if (click.mod) {
         const next = new Set(current);
+
         if (!next.delete(key)) {
             next.add(key);
         }
+
         return { selected: next, anchor: index };
     }
+
     return { selected: new Set([key]), anchor: index };
 };

package/src/grid/sort.ts

@@ -8,5 +8,6 @@ export const sortOnly = (column: string, direction: SortDirection): GridSort[] =
 /* The sort of a column and its place among the sorts counted from one, or `null` when it is not sorted. */
 export const sortStateOf = (sorts: readonly GridSort[], column: string): { direction: SortDirection; position: number } | null => {
     const index = sorts.findIndex((sort) => sort.column === column);
+
     return index < 0 ? null : { direction: sorts[index]!.direction, position: index + 1 };
 };

package/src/grid/whole-cells.ts

@@ -24,6 +24,7 @@ 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;
 };
 
@@ -37,6 +38,7 @@ export const loadWholeCells = async (
 ): Promise<WholeCells> => {
     const wanted: Wanted[] = [];
     let size = 0;
+
     rows.forEach((cells, row) =>
         cells.forEach((cell, column) => {
             if (isPreview(cell)) {
@@ -45,9 +47,11 @@ export const loadWholeCells = async (
             }
         })
     );
+
     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 };
     }
@@ -55,11 +59,13 @@ export const loadWholeCells = async (
     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 {
@@ -67,6 +73,8 @@ export const loadWholeCells = async (
             }
         }
     };
+
     await Promise.all(Array.from({ length: Math.min(PARALLEL_LOADS, wanted.length) }, work));
+
     return { rows: filled, previews, tooLarge: false };
 };

package/src/host/host.ts

@@ -1,6 +1,6 @@
 import { PROTOCOL_VERSION, type DatabaseError, type DatabaseErrorCode, type DatabaseRequest, type DatabaseResponse } from '../protocol/index.ts';
 import type { DatabaseHost, DatabaseHostOptions, HelperProcess } from './types.ts';
-import { parseRequest } from './validate.ts';
+import { isDict, parseRequest } from './validate.ts';
 
 const DEFAULT_READY_TIMEOUT_MS = 10000;
 
@@ -49,11 +49,10 @@ const parseLine = (line: string): unknown => {
     }
 };
 
-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. */
 const settleWithin = async (promises: readonly Promise<unknown>[]): Promise<void> => {
     let timer: ReturnType<typeof setTimeout> | undefined;
+
     const grace = new Promise<void>((resolve) => {
         timer = setTimeout(resolve, CLOSE_GRACE_MS);
     });
@@ -127,11 +126,13 @@ export const createDatabaseHost = (options: DatabaseHostOptions): DatabaseHost =
 
         if (!isDict(message) || message.event !== 'ready') {
             abort(run, 'The helper did not start with a ready line.');
+
             return;
         }
 
         if (message.protocol !== PROTOCOL_VERSION) {
             abort(run, `The helper speaks protocol ${String(message.protocol)}, this host speaks ${PROTOCOL_VERSION}.`);
+
             return;
         }
 
@@ -167,11 +168,14 @@ export const createDatabaseHost = (options: DatabaseHostOptions): DatabaseHost =
         }
 
         let resolveReady = (): void => {};
+
         let rejectReady = (_error: Failure): void => {};
+
         const ready = new Promise<void>((resolve, reject) => {
             resolveReady = resolve;
             rejectReady = reject;
         });
+
         // A request awaits this; a run nobody waits for must not raise an unhandled rejection.
         ready.catch(() => {});
 
@@ -185,6 +189,7 @@ export const createDatabaseHost = (options: DatabaseHostOptions): DatabaseHost =
                 onResponse(run, line);
             }
         });
+
         child.onExit((code) => retire(run, code === null ? 'The helper exited.' : `The helper exited with code ${code}.`));
 
         return run;
@@ -208,6 +213,7 @@ export const createDatabaseHost = (options: DatabaseHostOptions): DatabaseHost =
     /* Sends a message under a helper id of the host's own; the promise never rejects. */
     const dispatch = (run: Run, method: string, params: unknown): { readonly id: string; readonly response: Promise<DatabaseResponse> } => {
         const id = `h${++counter}`;
+
         const response = new Promise<DatabaseResponse>((resolve) => {
             run.pending.set(id, resolve);
 
@@ -226,6 +232,7 @@ export const createDatabaseHost = (options: DatabaseHostOptions): DatabaseHost =
 
     const sessionOf = (request: DatabaseRequest): string | null => {
         const session = (request.params as { readonly session?: unknown }).session;
+
         return typeof session === 'string' ? session : null;
     };
 
@@ -292,6 +299,7 @@ export const createDatabaseHost = (options: DatabaseHostOptions): DatabaseHost =
     const cancelOwned = async (request: Extract<DatabaseRequest, { method: 'cancel' }>, owner: string): Promise<DatabaseResponse> => {
         const entries = inflight.get(owner);
         const target = request.id === request.params.request ? undefined : entries?.get(request.params.request);
+
         const answer = (cancelled: boolean): DatabaseResponse => ({ id: request.id, ok: true, result: { cancelled } });
 
         if (target === undefined) {
@@ -300,6 +308,7 @@ export const createDatabaseHost = (options: DatabaseHostOptions): DatabaseHost =
 
         if (target.helperId === null) {
             target.cancelled = true;
+
             return answer(true);
         }
 
@@ -310,6 +319,7 @@ export const createDatabaseHost = (options: DatabaseHostOptions): DatabaseHost =
         }
 
         const sent = await dispatch(run, 'cancel', { request: target.helperId }).response;
+
         return { ...sent, id: request.id } as DatabaseResponse;
     };
 
@@ -321,6 +331,7 @@ export const createDatabaseHost = (options: DatabaseHostOptions): DatabaseHost =
 
         // 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);
         }
@@ -341,10 +352,12 @@ export const createDatabaseHost = (options: DatabaseHostOptions): DatabaseHost =
 
         if (entry.released) {
             void dispatch(run, 'close', { session }).response;
+
             return failure(request.id, 'cancelled', 'The request was cancelled.');
         }
 
         sessions.set(session, owner);
+
         return { ...response, id: request.id } as DatabaseResponse;
     };
 

package/src/host/spawn.ts

@@ -95,6 +95,7 @@ export const spawnHelper = (path: string, options: SpawnHelperOptions = {}): Hel
             finish(null);
         }
     });
+
     child.on('close', (code, signal) => finish(code, signal));
 
     return {
@@ -109,6 +110,7 @@ export const spawnHelper = (path: string, options: SpawnHelperOptions = {}): Hel
         onExit(listener): void {
             if (finished) {
                 queueMicrotask(() => listener(exitCode, exitSignal));
+
                 return;
             }
 

package/src/host/validate.ts

@@ -23,7 +23,7 @@ const fail = (message: string): never => {
     throw new InvalidRequest(message);
 };
 
-const isDict = (value: unknown): value is Dict => typeof value === 'object' && value !== null && !Array.isArray(value);
+export 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;
 
@@ -103,6 +103,7 @@ const value = (input: unknown, label: string): void => {
         if (!Number.isFinite(input)) {
             fail(`"${label}" must be a finite number.`);
         }
+
         return;
     }
 
@@ -120,6 +121,7 @@ const value = (input: unknown, label: string): void => {
 const editValue = (input: unknown, label: string): void => {
     if (isDict(input) && input.kind === 'default') {
         shape(input, label, ['kind']);
+
         return;
     }
 
@@ -129,6 +131,7 @@ const editValue = (input: unknown, label: string): void => {
 const values = (input: unknown, label: string, check: (value: unknown, label: string) => void, atLeastOne: boolean): void => {
     if (!isDict(input)) {
         fail(`"${label}" must be an object.`);
+
         return;
     }
 
@@ -146,6 +149,7 @@ const values = (input: unknown, label: string, check: (value: unknown, label: st
 const tunnel = (input: unknown, label: string): void => {
     if (!isDict(input)) {
         fail(`"${label}" must be an object.`);
+
         return;
     }
 
@@ -155,6 +159,7 @@ const tunnel = (input: unknown, label: string): void => {
         optional(config, 'port', label, port);
         optional(config, 'user', label, filledText);
         optional(config, 'identityFile', label, filledText);
+
         return;
     }
 
@@ -163,6 +168,7 @@ const tunnel = (input: unknown, label: string): void => {
         filledText(config.container, `${label}.container`);
         optional(config, 'port', label, port);
         optional(config, 'context', label, filledText);
+
         return;
     }
 
@@ -172,6 +178,7 @@ const tunnel = (input: unknown, label: string): void => {
 const connection = (input: unknown, label: string): void => {
     if (!isDict(input)) {
         fail(`"${label}" must be an object.`);
+
         return;
     }
 
@@ -180,6 +187,7 @@ const connection = (input: unknown, label: string): void => {
         absolutePath(config.path, `${label}.path`);
         optional(config, 'create', label, flag);
         optional(config, 'readOnly', label, flag);
+
         return;
     }
 
@@ -197,6 +205,7 @@ const connection = (input: unknown, label: string): void => {
         optional(config, 'database', label, anyText);
         optional(config, 'tls', label, oneOf(TLS_MODES));
         optional(config, 'readOnly', label, flag);
+
         return;
     }
 
@@ -206,6 +215,7 @@ const connection = (input: unknown, label: string): void => {
 const rowChange = (input: unknown, label: string): void => {
     if (!isDict(input)) {
         fail(`"${label}" must be an object.`);
+
         return;
     }
 
@@ -227,6 +237,7 @@ const rowChange = (input: unknown, label: string): void => {
 const exportSource = (input: unknown, label: string): void => {
     if (!isDict(input)) {
         fail(`"${label}" must be an object.`);
+
         return;
     }
 
@@ -236,6 +247,7 @@ const exportSource = (input: unknown, label: string): void => {
         filledText(source.table, `${label}.table`);
         optional(source, 'where', label, anyText);
         optional(source, 'orderBy', label, anyText);
+
         return;
     }
 
@@ -243,6 +255,7 @@ const exportSource = (input: unknown, label: string): void => {
         const source = shape(input, label, ['kind', 'sql'], ['schema']);
         filledText(source.sql, `${label}.sql`);
         optional(source, 'schema', label, filledText);
+
         return;
     }
 
@@ -253,6 +266,19 @@ const cellLimit = (params: Dict): void => optional(params, 'cellLimit', 'params'
 
 const maxBytes = (params: Dict): void => optional(params, 'maxBytes', 'params', (limit, name) => integer(limit, name, 1, MAX_BYTES));
 
+const rowLimit = (params: Dict): void => optional(params, 'limit', 'params', (limit, name) => integer(limit, name, 1, MAX_LIMIT));
+
+const pageWindow = (params: Dict): void => {
+    integer(params.offset, 'params.offset', 0, Number.MAX_SAFE_INTEGER);
+    integer(params.limit, 'params.limit', 1, MAX_LIMIT);
+    cellLimit(params);
+    maxBytes(params);
+};
+
+const connectionParams = (input: unknown): void => connection(shape(input, 'params', ['connection']).connection, 'params.connection');
+
+const sessionParams = (input: unknown): void => filledText(shape(input, 'params', ['session']).session, 'params.session');
+
 const table = (params: Dict): void => {
     filledText(params.session, 'params.session');
     filledText(params.schema, 'params.schema');
@@ -262,10 +288,10 @@ const table = (params: Dict): void => {
 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) => filledText(shape(input, 'params', ['session']).session, 'params.session'),
-    schemas: (input) => filledText(shape(input, 'params', ['session']).session, 'params.session'),
+    open: connectionParams,
+    test: connectionParams,
+    close: sessionParams,
+    schemas: sessionParams,
     tables: (input) => {
         const params = shape(input, 'params', ['session', 'schema']);
         filledText(params.session, 'params.session');
@@ -277,10 +303,7 @@ const PARAMS: { readonly [M in DatabaseMethod]: (input: unknown) => void } = {
         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);
+        pageWindow(params);
     },
     count: (input) => {
         const params = shape(input, 'params', TARGET, ['where']);
@@ -299,6 +322,7 @@ const PARAMS: { readonly [M in DatabaseMethod]: (input: unknown) => void } = {
 
         if (!Array.isArray(params.changes)) {
             fail('"params.changes" must be a list.');
+
             return;
         }
 
@@ -309,7 +333,7 @@ const PARAMS: { readonly [M in DatabaseMethod]: (input: unknown) => void } = {
         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));
+        rowLimit(params);
         cellLimit(params);
         maxBytes(params);
     },
@@ -318,10 +342,7 @@ const PARAMS: { readonly [M in DatabaseMethod]: (input: unknown) => void } = {
         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);
+        pageWindow(params);
     },
     transaction: (input) => {
         const params = shape(input, 'params', ['session', 'action']);
@@ -342,7 +363,7 @@ const PARAMS: { readonly [M in DatabaseMethod]: (input: unknown) => void } = {
         absolutePath(params.path, 'params.path');
         oneOf(DELIMITED_FORMATS)(params.format, 'params.format');
         flag(params.header, 'params.header');
-        optional(params, 'limit', 'params', (limit, name) => integer(limit, name, 1, MAX_LIMIT));
+        rowLimit(params);
     },
     import: (input) => {
         const params = shape(input, 'params', [...TARGET, 'path', 'format', 'header', 'columns']);
@@ -353,6 +374,7 @@ const PARAMS: { readonly [M in DatabaseMethod]: (input: unknown) => void } = {
 
         if (!Array.isArray(params.columns)) {
             fail('"params.columns" must be a list.');
+
             return;
         }
 

package/src/same-list.ts

@@ -0,0 +1,2 @@
+export const sameList = (left: readonly string[], right: readonly string[]): boolean =>
+    left.length === right.length && left.every((item, index) => item === right[index]);