@adecore/database 0.39.0 → 0.40.1

package/src/console/history.ts

@@ -18,7 +18,9 @@ const isEntry = (value: unknown): value is HistoryEntry => {
     if (value === null || typeof value !== 'object') {
         return false;
     }
+
     const entry = value as Record<string, unknown>;
+
     return (
         typeof entry.sql === 'string' &&
         typeof entry.at === 'number' &&
@@ -33,8 +35,10 @@ export const parseHistory = (raw: string | null): HistoryEntry[] => {
     if (raw === null) {
         return [];
     }
+
     try {
         const parsed: unknown = JSON.parse(raw);
+
         return Array.isArray(parsed) ? parsed.filter(isEntry).slice(0, HISTORY_LIMIT) : [];
     } catch {
         return [];
@@ -46,17 +50,21 @@ export const serializeHistory = (entries: readonly HistoryEntry[]): string => JS
 /* The list with the run in front. A run of the same SQL as the latest one replaces it. */
 export const addEntry = (entries: readonly HistoryEntry[], entry: HistoryEntry): HistoryEntry[] => {
     const rest = entries[0]?.sql.trim() === entry.sql.trim() ? entries.slice(1) : entries;
+
     return [entry, ...rest].slice(0, HISTORY_LIMIT);
 };
 
 /* The entries whose SQL holds every word of the query, in any case. */
 export const searchHistory = (entries: readonly HistoryEntry[], query: string): readonly HistoryEntry[] => {
     const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+
     if (words.length === 0) {
         return entries;
     }
+
     return entries.filter((entry) => {
         const sql = entry.sql.toLowerCase();
+
         return words.every((word) => sql.includes(word));
     });
 };

package/src/console/labels.ts

@@ -3,5 +3,6 @@ const LABEL_LENGTH = 32;
 /* The tab of a statement: its SQL on one line, cut where it gets long. */
 export const statementLabel = (sql: string): string => {
     const line = sql.replace(/\s+/g, ' ').trim();
+
     return line.length > LABEL_LENGTH ? `${line.slice(0, LABEL_LENGTH - 1).trimEnd()}…` : line;
 };

package/src/console/outcome.ts

@@ -10,5 +10,6 @@ export const outcomeOf = (results: readonly StatementResult[]): { readonly ok: b
 /* Whether the helper can wrap the statement to fetch a page of it: a read that starts with `SELECT` or `WITH`. */
 export const isPageable = (sql: string, engine: Engine): boolean => {
     const keyword = firstKeyword(sql, engine);
+
     return keyword === 'SELECT' || keyword === 'WITH';
 };

package/src/console/result-keys.ts

@@ -21,11 +21,13 @@ const tableKey = ({ schema, table }: TableName): string => `${schema}\u0000${tab
 /* The tables the columns of a result come from, each once, in the order they first appear. */
 export const sourceTablesOf = (columns: readonly ResultColumn[]): TableName[] => {
     const tables = new Map<string, TableName>();
+
     for (const { source } of columns) {
         if (source !== undefined && !tables.has(tableKey(source))) {
             tables.set(tableKey(source), { schema: source.schema, table: source.table });
         }
     }
+
     return [...tables.values()];
 };
 
@@ -36,18 +38,23 @@ export const sourceTablesOf = (columns: readonly ResultColumn[]): TableName[] =>
 export const resultKeysOf = (engine: Engine, columns: readonly ResultColumn[], structures: ReadonlyMap<string, TableStructure>): ResultKeys => {
     const structureOf = (column: ResultColumn | undefined): TableStructure | undefined =>
         column?.source === undefined ? undefined : structures.get(tableKey(column.source));
+
     const foreignKeyAt = (column: number) => {
         const source = columns[column]?.source;
         const structure = structureOf(columns[column]);
+
         return source === undefined || structure === undefined ? undefined : foreignKeyOf(structure.foreignKeys, source.column);
     };
+
     return {
         columns: columns.map((column): GridColumn => {
             const structure = structureOf(column);
             const name = column.source?.column;
+
             if (structure === undefined || name === undefined) {
                 return column;
             }
+
             return {
                 ...column,
                 primaryKey: structure.primaryKey.includes(name),
@@ -58,14 +65,17 @@ export const resultKeysOf = (engine: Engine, columns: readonly ResultColumn[], s
         referenceAt: (column, cells) => {
             const key = foreignKeyAt(column);
             const source = columns[column]?.source;
+
             if (key === undefined || source === undefined) {
                 return null;
             }
+
             // The columns of the result as the columns of that table, so a join names each key column of its own table only.
             const asTable = columns.map((entry) => ({
                 name: entry.source !== undefined && tableKey(entry.source) === tableKey(source) ? entry.source.column : '',
                 kind: entry.kind
             }));
+
             return referenceOf(engine, key, asTable, cells);
         }
     };
@@ -82,11 +92,15 @@ export function useResultKeys(session: DatabaseSession | null, engine: Engine |
         if (session === null || result?.kind !== 'rows') {
             return undefined;
         }
+
         const tables = sourceTablesOf(result.columns);
+
         if (tables.length === 0) {
             return undefined;
         }
+
         const controller = new AbortController();
+
         // A table the server named but cannot describe, such as a derived one, marks no column.
         const loads = tables.map((table) =>
             session.structure(table.schema, table.table, { signal: controller.signal }).then(
@@ -94,11 +108,13 @@ export function useResultKeys(session: DatabaseSession | null, engine: Engine |
                 () => null
             )
         );
+
         void Promise.all(loads).then((entries) => {
             if (!controller.signal.aborted) {
                 setLoaded({ result, structures: new Map(entries.filter((entry) => entry !== null)) });
             }
         });
+
         return () => controller.abort();
     }, [session, result]);
 

package/src/console/shortcuts.ts

@@ -10,8 +10,10 @@ export const runScopeOf = (event: KeyLike, apple: boolean): QueryConsoleRunScope
     if (matchesShortcut(RUN_ALL_SHORTCUT, event, apple)) {
         return 'all';
     }
+
     if (matchesShortcut(RUN_SHORTCUT, event, apple)) {
         return 'selection-or-statement';
     }
+
     return null;
 };

package/src/ddl/alter-mysql.ts

@@ -16,9 +16,11 @@ const withPosition = (clause: string, position: string | null): string => (posit
 export const mysqlAlterSql = (dialect: Dialect, schema: string, original: TableDraft, draft: TableDraft, diff: TableDiff): string[] => {
     const early: string[] = [];
     const late: string[] = [];
+
     const column = (verb: 'CHANGE' | 'MODIFY' | 'ADD', target: ColumnDraft, previous: string | null, position: string | null): string => {
         const spec = columnSpecSql(dialect, target);
         const named = verb === 'CHANGE' ? `${quote(dialect, previous!)} ${quote(dialect, target.name)}` : quote(dialect, target.name);
+
         return withPosition(`${verb} COLUMN ${named} ${spec}`, position);
     };
 
@@ -29,25 +31,31 @@ export const mysqlAlterSql = (dialect: Dialect, schema: string, original: TableD
     for (const foreignKey of diff.droppedForeignKeys) {
         early.push(`DROP FOREIGN KEY ${quote(dialect, foreignKey.name)}`);
     }
+
     for (const index of diff.droppedIndexes) {
         early.push(`DROP INDEX ${quote(dialect, index.name)}`);
     }
+
     for (const { from, to } of diff.renamedIndexes) {
         early.push(`RENAME INDEX ${quote(dialect, from.name)} TO ${quote(dialect, to.name)}`);
     }
+
     if (diff.primaryKeyChanged && original.primaryKey.length > 0) {
         early.push('DROP PRIMARY KEY');
     }
+
     for (const dropped of diff.droppedColumns) {
         early.push(`DROP COLUMN ${quote(dialect, dropped.name)}`);
     }
 
     for (const kept of diff.keptColumns) {
         const verb = kept.renamed ? 'CHANGE' : 'MODIFY';
+
         if (split) {
             if (kept.renamed || kept.redefined) {
                 early.push(column(verb, kept.column, kept.original.name, null));
             }
+
             if (kept.moved) {
                 late.push(column('MODIFY', kept.column, null, positionSql(dialect, kept.after)));
             }
@@ -55,6 +63,7 @@ export const mysqlAlterSql = (dialect: Dialect, schema: string, original: TableD
             early.push(column(verb, kept.column, kept.original.name, kept.moved ? positionSql(dialect, kept.after) : null));
         }
     }
+
     for (const added of diff.addedColumns) {
         late.push(column('ADD', added.column, null, added.placed ? positionSql(dialect, added.after) : null));
     }
@@ -62,21 +71,28 @@ export const mysqlAlterSql = (dialect: Dialect, schema: string, original: TableD
     if (diff.primaryKeyChanged && draft.primaryKey.length > 0) {
         late.push(`ADD PRIMARY KEY (${columnList(dialect, draft.primaryKey)})`);
     }
+
     for (const index of diff.addedIndexes) {
         late.push(`ADD ${inlineIndexSql(dialect, index)}`);
     }
+
     for (const foreignKey of diff.addedForeignKeys) {
         late.push(`ADD ${foreignKeySql(dialect, schema, foreignKey)}`);
     }
+
     const options = diff.optionsChanged ? mysqlOptionsSql(draft.options, original.options).join(' ') : '';
+
     if (options !== '') {
         late.push(options);
     }
+
     if (diff.renamed) {
         late.push(`RENAME TO ${quote(dialect, draft.name)}`);
     }
 
     const target = tableName(dialect, schema, original.name);
+
     const statement = (clauses: readonly string[]): string[] => (clauses.length === 0 ? [] : [`ALTER TABLE ${target}\n    ${clauses.join(',\n    ')}`]);
+
     return split ? [...statement(early), ...statement(late)] : statement([...early, ...late]);
 };

package/src/ddl/alter-sqlite.ts

@@ -13,12 +13,16 @@ const addable = (column: ColumnDraft): boolean => {
     if (column.autoIncrement || (column.generated && column.generatedClause !== null && /\bSTORED\b/i.test(column.generatedClause))) {
         return false;
     }
+
     const expression = column.defaultValue?.trim() ?? '';
+
     if (expression === '') {
         return column.nullable;
     }
+
     // Only a constant may fill existing rows: not an expression, not the clock.
     const clause = defaultClause(expression);
+
     return !clause.startsWith('(') && !/^CURRENT_|^LOCALTIME|^NOW/i.test(clause) && (column.nullable || !/^NULL$/i.test(clause));
 };
 
@@ -26,19 +30,25 @@ const needsRebuild = (dialect: Dialect, original: TableDraft, diff: TableDiff):
     if (diff.optionsChanged || diff.primaryKeyChanged || diff.droppedForeignKeys.length > 0 || diff.addedForeignKeys.length > 0) {
         return true;
     }
+
     if (diff.keptColumns.some((kept) => kept.redefined || kept.moved || (kept.renamed && !atLeast(dialect, ...RENAME_COLUMN)))) {
         return true;
     }
+
     if (diff.addedColumns.some((added) => added.placed || !addable(added.column))) {
         return true;
     }
+
     if (diff.droppedColumns.length > 0 && !atLeast(dialect, ...DROP_COLUMN)) {
         return true;
     }
+
     const autoIndexed = new Set(original.indexes.filter((index) => isAutoIndex(index.name)).flatMap((index) => index.columns));
+
     if (diff.droppedColumns.some((dropped) => autoIndexed.has(dropped.name))) {
         return true;
     }
+
     return [...diff.droppedIndexes, ...diff.renamedIndexes.map(({ from }) => from)].some((index) => isAutoIndex(index.name));
 };
 
@@ -48,11 +58,13 @@ const rebuildSql = (dialect: Dialect, schema: string, original: TableDraft, draf
     const { table, indexes } = createTableParts(dialect, schema, draft, temporary);
     const copied = diff.keptColumns.filter((kept) => !kept.column.generated);
     const statements = ['PRAGMA foreign_keys=OFF', 'BEGIN', table];
+
     if (copied.length > 0) {
         const into = copied.map((kept) => quote(dialect, kept.column.name)).join(', ');
         const from = copied.map((kept) => quote(dialect, kept.original.name)).join(', ');
         statements.push(`INSERT INTO ${tableName(dialect, schema, temporary)} (${into}) SELECT ${from} FROM ${tableName(dialect, schema, original.name)}`);
     }
+
     statements.push(
         `DROP TABLE ${tableName(dialect, schema, original.name)}`,
         `ALTER TABLE ${tableName(dialect, schema, temporary)} RENAME TO ${quote(dialect, draft.name)}`,
@@ -61,6 +73,7 @@ const rebuildSql = (dialect: Dialect, schema: string, original: TableDraft, draf
         'COMMIT',
         'PRAGMA foreign_keys=ON'
     );
+
     return statements;
 };
 
@@ -69,25 +82,33 @@ export const sqliteAlterSql = (dialect: Dialect, schema: string, original: Table
     if (needsRebuild(dialect, original, diff)) {
         return rebuildSql(dialect, schema, original, draft, diff);
     }
+
     const target = tableName(dialect, schema, original.name);
     const statements: string[] = [];
+
     for (const index of [...diff.droppedIndexes, ...diff.renamedIndexes.map(({ from }) => from)]) {
         statements.push(dropIndexSql(dialect, schema, original.name, index.name));
     }
+
     for (const dropped of diff.droppedColumns) {
         statements.push(`ALTER TABLE ${target} DROP COLUMN ${quote(dialect, dropped.name)}`);
     }
+
     for (const kept of diff.keptColumns.filter((candidate) => candidate.renamed)) {
         statements.push(`ALTER TABLE ${target} RENAME COLUMN ${quote(dialect, kept.original.name)} TO ${quote(dialect, kept.column.name)}`);
     }
+
     for (const added of diff.addedColumns) {
         statements.push(`ALTER TABLE ${target} ADD COLUMN ${columnSql(dialect, added.column)}`);
     }
+
     for (const index of [...diff.addedIndexes, ...diff.renamedIndexes.map(({ to }) => to)]) {
         statements.push(createIndexSql(dialect, schema, original.name, index));
     }
+
     if (diff.renamed) {
         statements.push(`ALTER TABLE ${target} RENAME TO ${quote(dialect, draft.name)}`);
     }
+
     return statements;
 };

package/src/ddl/alter.ts

@@ -22,8 +22,10 @@ const unchanged = (diff: TableDiff): boolean =>
 export const alterTableSql = (dialect: Dialect, schema: string, structure: TableStructure, draft: TableDraft): string[] => {
     const original = draftOf(structure);
     const diff = diffOf(dialect, original, draft);
+
     if (unchanged(diff)) {
         return [];
     }
+
     return dialect.engine === 'sqlite' ? sqliteAlterSql(dialect, schema, original, draft, diff) : mysqlAlterSql(dialect, schema, original, draft, diff);
 };

package/src/ddl/column.ts

@@ -11,9 +11,11 @@ const KEYWORD = /^(?:NULL|TRUE|FALSE|CURRENT_DATE|CURRENT_TIME(?:\(\d*\))?|CURRE
  */
 export const defaultClause = (expression: string): string => {
     const text = expression.trim();
+
     if (NUMERIC_TEXT.test(text) || STRING.test(text) || KEYWORD.test(text)) {
         return text;
     }
+
     return text.startsWith('(') && text.endsWith(')') ? text : `(${text})`;
 };
 
@@ -26,34 +28,43 @@ export interface ColumnSqlOptions {
 export const columnSpecSql = (dialect: Dialect, column: ColumnDraft, { inlinePrimaryKey = false }: ColumnSqlOptions = {}): string => {
     const mysql = dialect.engine === 'mysql';
     const parts: string[] = [];
+
     if (column.type !== '') {
         parts.push(column.type);
     }
+
     if (column.generated && column.generatedClause !== null) {
         parts.push(column.generatedClause);
     }
+
     if (inlinePrimaryKey) {
         parts.push(column.autoIncrement ? 'PRIMARY KEY AUTOINCREMENT' : 'PRIMARY KEY');
     }
+
     // MariaDB takes neither NULL nor NOT NULL after the expression of a computed column.
     const statesNullability = !(column.generated && dialect.flavor === 'mariadb');
+
     if (statesNullability && !column.nullable) {
         parts.push('NOT NULL');
     } else if (statesNullability && mysql) {
         // MySQL gives a TIMESTAMP column NOT NULL unless it is told otherwise.
         parts.push('NULL');
     }
+
     if (!column.generated) {
         if (column.defaultValue !== null && column.defaultValue.trim() !== '') {
             parts.push(`DEFAULT ${defaultClause(column.defaultValue)}`);
         }
+
         if (mysql && column.autoIncrement) {
             parts.push('AUTO_INCREMENT');
         }
     }
+
     if (mysql && column.comment !== '') {
         parts.push(`COMMENT ${sqlLiteral('mysql', column.comment)}`);
     }
+
     return parts.join(' ');
 };
 

package/src/ddl/create.ts

@@ -9,22 +9,27 @@ const INDENT = '    ';
 /* `CONSTRAINT name FOREIGN KEY (...) REFERENCES t (...) ON UPDATE .. ON DELETE ..`, shared by a create and an `ADD`. */
 export const foreignKeySql = (dialect: Dialect, schema: string, foreignKey: ForeignKeyDraft): string => {
     const sqlite = dialect.engine === 'sqlite';
+
     // SQLite cannot name another schema in a reference, and MySQL needs one only for another database.
     const target =
         sqlite || foreignKey.referencedSchema === '' || foreignKey.referencedSchema === schema
             ? quote(dialect, foreignKey.referencedTable)
             : `${quote(dialect, foreignKey.referencedSchema)}.${quote(dialect, foreignKey.referencedTable)}`;
+
     const parts = [
         ...(foreignKey.name === '' ? [] : [`CONSTRAINT ${quote(dialect, foreignKey.name)}`]),
         `FOREIGN KEY (${columnList(dialect, foreignKey.columns)})`,
         `REFERENCES ${target} (${columnList(dialect, foreignKey.referencedColumns)})`
     ];
+
     if (foreignKey.onUpdate !== null) {
         parts.push(`ON UPDATE ${foreignKey.onUpdate}`);
     }
+
     if (foreignKey.onDelete !== null) {
         parts.push(`ON DELETE ${foreignKey.onDelete}`);
     }
+
     return parts.join(' ');
 };
 
@@ -33,6 +38,7 @@ export const mysqlOptionsSql = (options: TableOptions, against?: TableOptions):
     // Only a comment can be emptied; an engine, a character set or a collation has no empty value to ask for.
     const changed = (field: 'engine' | 'charset' | 'collation' | 'comment'): boolean =>
         options[field] !== against?.[field] && (options[field] !== '' || (field === 'comment' && against !== undefined));
+
     return [
         ...(changed('engine') ? [`ENGINE=${options.engine}`] : []),
         ...(changed('charset') ? [`DEFAULT CHARSET=${options.charset}`] : []),
@@ -59,16 +65,21 @@ export interface CreateParts {
 /* The `CREATE TABLE` of a draft under a name of the caller's choosing, which a rebuild uses for the table it fills before the swap. */
 export const createTableParts = (dialect: Dialect, schema: string, draft: TableDraft, name: string): CreateParts => {
     const sqlite = dialect.engine === 'sqlite';
+
     // SQLite declares AUTOINCREMENT on the column itself, which then is the whole primary key; a WITHOUT ROWID table has no rowid to count.
     const autoColumn =
         sqlite && draft.primaryKey.length === 1 && !draft.options.withoutRowid
             ? draft.columns.find((column) => column.name === draft.primaryKey[0] && column.autoIncrement)?.name
             : undefined;
+
     const lines = draft.columns.map((column) => columnSql(dialect, column, { inlinePrimaryKey: column.name === autoColumn }));
+
     if (draft.primaryKey.length > 0 && autoColumn === undefined) {
         lines.push(`PRIMARY KEY (${columnList(dialect, draft.primaryKey)})`);
     }
+
     const separate: IndexDraft[] = [];
+
     for (const index of draft.indexes) {
         if (!sqlite) {
             lines.push(inlineIndexSql(dialect, index));
@@ -78,15 +89,19 @@ export const createTableParts = (dialect: Dialect, schema: string, draft: TableD
             separate.push(index);
         }
     }
+
     for (const foreignKey of draft.foreignKeys) {
         lines.push(foreignKeySql(dialect, schema, foreignKey));
     }
+
     const options = sqlite ? sqliteOptionsSql(draft.options).join(', ') : mysqlOptionsSql(draft.options).join(' ');
     const head = `CREATE TABLE ${tableName(dialect, schema, name)} (\n${lines.map((line) => INDENT + line).join(',\n')}\n)`;
+
     return { table: options === '' ? head : `${head} ${options}`, indexes: separate };
 };
 
 export const createTableSql = (dialect: Dialect, schema: string, draft: TableDraft): string[] => {
     const { table, indexes } = createTableParts(dialect, schema, draft, draft.name);
+
     return [table, ...indexes.map((index) => createIndexSql(dialect, schema, draft.name, index))];
 };

package/src/ddl/dialect.ts

@@ -25,12 +25,15 @@ export const atLeast = (dialect: Dialect, ...wanted: number[]): boolean => {
     if (dialect.version.length === 0) {
         return true;
     }
+
     for (let i = 0; i < wanted.length; i++) {
         const have = dialect.version[i] ?? 0;
+
         if (have !== wanted[i]) {
             return have > wanted[i]!;
         }
     }
+
     return true;
 };
 
@@ -47,6 +50,7 @@ export const tableName = (dialect: Dialect, schema: string, table: string): stri
 /* SQLite puts the schema in front of the name of an index, where MySQL names the table it is on. */
 export const sqliteSchemaPrefix = (dialect: Dialect, schema: string): string => {
     const named = schemaOf(dialect, schema);
+
     return named === undefined ? '' : `${quote(dialect, named)}.`;
 };
 

package/src/ddl/diff.ts

@@ -2,6 +2,7 @@ import { sameDefinition } from './column.ts';
 import type { Dialect } from './dialect.ts';
 import type { ColumnDraft, ForeignKeyDraft, IndexDraft, TableDraft } from './draft.ts';
 import type { TableOptions } from './parse.ts';
+import { sameList } from '../same-list.ts';
 
 export interface KeptColumn {
     readonly original: ColumnDraft;
@@ -41,30 +42,34 @@ export interface TableDiff {
     readonly optionsChanged: boolean;
 }
 
-const sameList = (left: readonly string[], right: readonly string[]): boolean => left.length === right.length && left.every((name, at) => name === right[at]);
-
 /* The positions of a longest run that already is in order: those columns can stay where they are. */
 const longestRun = (positions: readonly number[]): ReadonlySet<number> => {
     const length: number[] = [];
     const previous: number[] = [];
     let best = -1;
+
     for (let i = 0; i < positions.length; i++) {
         length[i] = 1;
         previous[i] = -1;
+
         for (let before = 0; before < i; before++) {
             if (positions[before]! < positions[i]! && length[before]! + 1 > length[i]!) {
                 length[i] = length[before]! + 1;
                 previous[i] = before;
             }
         }
+
         if (best < 0 || length[i]! > length[best]!) {
             best = i;
         }
     }
+
     const run = new Set<number>();
+
     for (let at = best; at >= 0; at = previous[at]!) {
         run.add(at);
     }
+
     return run;
 };
 
@@ -82,17 +87,23 @@ const columnChanges = (dialect: Dialect, original: TableDraft, draft: TableDraft
     let survivor = 0;
     const keptColumns: KeptColumn[] = [];
     const addedColumns: AddedColumn[] = [];
+
     draft.columns.forEach((column, at) => {
         const after = at === 0 ? null : draft.columns[at - 1]!.name;
+
         if (column.originalName === null) {
             addedColumns.push({ column, placed: draft.columns.slice(at + 1).some((later) => later.originalName !== null), after });
+
             return;
         }
+
         const rank = survivor++;
         const before = original.columns.find((candidate) => candidate.name === column.originalName);
+
         if (before === undefined) {
             return;
         }
+
         keptColumns.push({
             original: before,
             column,
@@ -104,6 +115,7 @@ const columnChanges = (dialect: Dialect, original: TableDraft, draft: TableDraft
     });
 
     const droppedColumns = original.columns.filter((column) => !survivors.some((kept) => kept.originalName === column.name));
+
     return { droppedColumns, keptColumns, addedColumns };
 };
 
@@ -111,8 +123,10 @@ const indexChanges = (original: TableDraft, draft: TableDraft, project: Project)
     const droppedIndexes: IndexDraft[] = [];
     const addedIndexes = draft.indexes.filter((index) => index.originalName === null);
     const renamedIndexes: RenamedIndex[] = [];
+
     for (const before of original.indexes) {
         const after = draft.indexes.find((index) => matches(before, index));
+
         if (after === undefined) {
             droppedIndexes.push(before);
         } else if (!sameList(project(before.columns), after.columns) || before.unique !== after.unique) {
@@ -122,6 +136,7 @@ const indexChanges = (original: TableDraft, draft: TableDraft, project: Project)
             renamedIndexes.push({ from: before, to: after });
         }
     }
+
     return { droppedIndexes, addedIndexes, renamedIndexes };
 };
 
@@ -137,21 +152,26 @@ const sameForeignKey = (before: ForeignKeyDraft, after: ForeignKeyDraft, project
 const foreignKeyChanges = (original: TableDraft, draft: TableDraft, project: Project) => {
     const droppedForeignKeys: ForeignKeyDraft[] = [];
     const addedForeignKeys = draft.foreignKeys.filter((key) => key.originalName === null);
+
     for (const before of original.foreignKeys) {
         const after = draft.foreignKeys.find((key) => matches(before, key));
+
         if (after === undefined || !sameForeignKey(before, after, project)) {
             droppedForeignKeys.push(before);
+
             if (after !== undefined) {
                 addedForeignKeys.push(after);
             }
         }
     }
+
     return { droppedForeignKeys, addedForeignKeys };
 };
 
 /* What a draft changes in the table it came from, told apart by the names items kept. */
 export const diffOf = (dialect: Dialect, original: TableDraft, draft: TableDraft): TableDiff => {
     const renames = new Map(draft.columns.filter((column) => column.originalName !== null).map((column) => [column.originalName!, column.name]));
+
     const project: Project = (names) => names.map((name) => renames.get(name) ?? name);
 
     return {

package/src/ddl/draft.ts

@@ -105,6 +105,7 @@ const foreignKeyDraftOf = (foreignKey: ForeignKeyInfo, at: number): ForeignKeyDr
 /* The draft that changes nothing: what a structure already says. */
 export const draftOf = (structure: TableStructure): TableDraft => {
     const clauses = generatedClausesOf(structure.ddl);
+
     return {
         originalName: structure.name,
         name: structure.name,