@adecore/database 0.39.0 → 0.40.1

package/src/ddl/parse.ts

@@ -13,8 +13,10 @@ interface Spot {
 function* unquoted(text: string, backslash: boolean): Generator<Spot> {
     let depth = 0;
     let closer: string | null = null;
+
     for (let i = 0; i < text.length; i++) {
         const char = text[i]!;
+
         if (closer !== null) {
             if (backslash && char === '\\' && closer === "'") {
                 i++;
@@ -25,16 +27,22 @@ function* unquoted(text: string, backslash: boolean): Generator<Spot> {
                     closer = null;
                 }
             }
+
             continue;
         }
+
         if (char in CLOSERS) {
             closer = CLOSERS[char]!;
+
             continue;
         }
+
         if (char === ')') {
             depth--;
         }
+
         yield { index: i, char, depth };
+
         if (char === '(') {
             depth++;
         }
@@ -53,11 +61,13 @@ export const definitionOf = (ddl: string | null): Definition | null => {
     if (ddl === null) {
         return null;
     }
+
     // Only a MySQL statement reads a backslash as an escape, and only a MySQL statement quotes with backticks.
     const backslash = ddl.includes('`');
     let open = -1;
     let close = -1;
     const commas: number[] = [];
+
     for (const { index, char, depth } of unquoted(ddl, backslash)) {
         if (open < 0) {
             if (char === '(' && depth === 0) {
@@ -71,10 +81,13 @@ export const definitionOf = (ddl: string | null): Definition | null => {
             }
         }
     }
+
     if (open < 0 || close < 0) {
         return null;
     }
+
     const bounds = [open, ...commas, close];
+
     return {
         items: bounds.slice(1).map((end, at) => ddl.slice(bounds[at]! + 1, end).trim()),
         tail: ddl.slice(close + 1)
@@ -84,14 +97,19 @@ export const definitionOf = (ddl: string | null): Definition | null => {
 /* The name a definition starts with, unquoted. */
 const leadingName = (item: string): string | null => {
     const mark = item[0];
+
     if (mark === '`' || mark === '"') {
         const end = item.indexOf(mark, 1);
+
         return end < 0 ? null : item.slice(1, end).replaceAll(mark + mark, mark);
     }
+
     if (mark === '[') {
         const end = item.indexOf(']');
+
         return end < 0 ? null : item.slice(1, end);
     }
+
     return /^[^\s(]+/.exec(item)?.[0] ?? null;
 };
 
@@ -103,34 +121,44 @@ const generatedClauseOf = (item: string): string | null => {
     // A default or a comment may hold the words, so the strings are blanked before the search.
     const masked = item.replace(/'(?:[^']|'')*'/g, (text) => ' '.repeat(text.length));
     const start = AS_OPEN.exec(masked);
+
     if (start === null) {
         return null;
     }
+
     const open = start.index + start[0].length - 1;
     let end = -1;
+
     for (const { index, char, depth } of unquoted(masked.slice(open), false)) {
         if (char === ')' && depth === 0) {
             end = open + index + 1;
+
             break;
         }
     }
+
     if (end < 0) {
         return null;
     }
+
     const suffix = AS_SUFFIX.exec(masked.slice(end));
+
     return item.slice(start.index, end + (suffix?.[0].length ?? 0)).trim();
 };
 
 /* The generated clause of every generated column in a table's DDL, by column name. */
 export const generatedClausesOf = (ddl: string | null): ReadonlyMap<string, string> => {
     const clauses = new Map<string, string>();
+
     for (const item of definitionOf(ddl)?.items ?? []) {
         const name = leadingName(item);
         const clause = name === null ? null : generatedClauseOf(item);
+
         if (name !== null && clause !== null) {
             clauses.set(name, clause);
         }
     }
+
     return clauses;
 };
 
@@ -148,8 +176,11 @@ export const NO_OPTIONS: TableOptions = { engine: '', charset: '', collation: ''
 
 export const optionsOf = (structure: Pick<TableStructure, 'ddl'>): TableOptions => {
     const tail = definitionOf(structure.ddl)?.tail ?? '';
+
     const word = (pattern: RegExp): string => pattern.exec(tail)?.[1] ?? '';
+
     const comment = /\bCOMMENT\s*=?\s*'((?:[^'\\]|''|\\.)*)'/i.exec(tail)?.[1] ?? '';
+
     return {
         engine: word(/\bENGINE\s*=\s*(\w+)/i),
         charset: word(/\b(?:DEFAULT\s+)?(?:CHARSET|CHARACTER\s+SET)\s*=?\s*(\w+)/i),

package/src/ddl/types.ts

@@ -50,10 +50,13 @@ export const collationSuggestionsOf = (charset: string): readonly string[] => {
     if (charset === '') {
         return [];
     }
+
     if (charset === 'binary') {
         return ['binary'];
     }
+
     const suggestions = [`${charset}_general_ci`, `${charset}_unicode_ci`, `${charset}_bin`];
+
     return charset === 'utf8mb4' ? ['utf8mb4_0900_ai_ci', 'utf8mb4_unicode_520_ci', ...suggestions] : suggestions;
 };
 

package/src/ddl/validate.ts

@@ -9,39 +9,51 @@ export interface DraftProblem {
 
 export const validateDraft = (dialect: Dialect, draft: TableDraft): DraftProblem[] => {
     const problems: DraftProblem[] = [];
+
     if (draft.name.trim() === '') {
         problems.push({ code: 'tableName', subject: '' });
     }
+
     if (draft.columns.length === 0) {
         problems.push({ code: 'noColumns', subject: '' });
     }
+
     const seen = new Set<string>();
+
     for (const column of draft.columns) {
         const folded = column.name.toLowerCase();
+
         if (column.name.trim() === '') {
             problems.push({ code: 'columnName', subject: '' });
         } else if (seen.has(folded)) {
             problems.push({ code: 'columnDuplicate', subject: column.name });
         }
+
         seen.add(folded);
+
         if (dialect.engine === 'mysql' && column.type.trim() === '' && column.name.trim() !== '') {
             problems.push({ code: 'columnType', subject: column.name });
         }
     }
+
     for (const index of draft.indexes) {
         if (index.columns.length === 0) {
             problems.push({ code: 'indexColumns', subject: index.name });
         }
+
         if (dialect.engine === 'sqlite' && index.name.trim() === '') {
             problems.push({ code: 'indexName', subject: '' });
         }
     }
+
     for (const foreignKey of draft.foreignKeys) {
         const complete =
             foreignKey.columns.length > 0 && foreignKey.referencedTable !== '' && foreignKey.referencedColumns.length === foreignKey.columns.length;
+
         if (!complete) {
             problems.push({ code: 'foreignKey', subject: foreignKey.name });
         }
     }
+
     return problems;
 };

package/src/designer/ColumnsEditor.tsx

@@ -17,6 +17,7 @@ export function ColumnsEditor({ draft, dialect, disabled, onChange, className, r
     const listId = useId();
     const mysql = dialect.engine === 'mysql';
     const defaultType = typeSuggestionsOf(dialect)[0]!;
+
     return (
         <div ref={ref} className={clsx('flex min-h-0 flex-col', className)}>
             {draft.columns.length === 0 ? (
@@ -103,7 +104,9 @@ function ColumnRow({ draft, column, at, mysql, listId, disabled, onChange }: Col
     const { t } = useTranslation('database');
     const keyAt = draft.primaryKey.indexOf(column.name);
     const locked = disabled || column.generated;
+
     const patch = (change: Partial<ColumnDraft>): void => onChange(patchColumn(draft, column.key, change));
+
     return (
         <tr>
             <td className={clsx(TD, 'whitespace-nowrap')}>

package/src/designer/DesignerView.tsx

@@ -73,12 +73,14 @@ export function DesignerView({
 }: DesignerViewProps) {
     const { t } = useTranslation('database');
     const disabled = readOnlyReason !== null;
+
     const applyReason =
         readOnlyReason ?? (plan.problems.length > 0 ? t('designer.fixProblems') : plan.statements.length === 0 ? t('designer.noChanges') : null);
 
     function handleKeyDown(event: KeyboardEvent<HTMLDivElement>): void {
         if (matchesShortcut(APPLY_SHORTCUT, event.nativeEvent, isApplePlatform())) {
             event.preventDefault();
+
             if (applyReason === null) {
                 onRequestApply();
             }

package/src/designer/ForeignKeysEditor.tsx

@@ -22,18 +22,22 @@ const DEFAULT_ACTION = 'default';
 export function ForeignKeysEditor({ draft, schema, tables, referenceColumns, disabled, onChange, className, ref }: ForeignKeysEditorProps) {
     const { t } = useTranslation('database');
     const columns = draft.columns.map((column) => column.name);
+
     const actions = [
         { value: DEFAULT_ACTION, label: t('designer.foreignKeys.engineDefault') },
         ...FOREIGN_KEY_ACTIONS.map((action) => ({ value: action, label: action }))
     ];
+
     return (
         <div ref={ref} className={clsx('flex min-h-0 flex-col', className)}>
             <div>
                 {draft.foreignKeys.length === 0 && <EmptyState>{t('designer.foreignKeys.empty')}</EmptyState>}
                 {draft.foreignKeys.map((foreignKey) => {
                     const referenced = foreignKey.referencedTable === '' ? [] : referenceColumns(foreignKey.referencedTable);
+
                     const choices =
                         tables.includes(foreignKey.referencedTable) || foreignKey.referencedTable === '' ? tables : [...tables, foreignKey.referencedTable];
+
                     return (
                         <div key={foreignKey.key} className="flex flex-col gap-3 border-b border-border-soft px-3 py-3">
                             <div className="flex items-end gap-3">

package/src/designer/IndexesEditor.tsx

@@ -10,6 +10,7 @@ import { addIndex, patchIndex, removeIndex, toggleIndexColumn } from './edit.ts'
 export function IndexesEditor({ draft, disabled, onChange, className, ref }: EditorProps) {
     const { t } = useTranslation('database');
     const columns = draft.columns.map((column) => column.name);
+
     return (
         <div ref={ref} className={clsx('flex min-h-0 flex-col', className)}>
             <div>

package/src/designer/NamePicker.tsx

@@ -20,11 +20,13 @@ export interface NamePickerProps {
 /* Picks some of a few names, such as the columns of an index, and numbers the picks once there is more than one. */
 export function NamePicker({ options, value, onToggle, label, disabled = false, className, ref }: NamePickerProps) {
     const { t } = useTranslation('database');
+
     return (
         <div ref={ref} role="group" aria-label={label} className={clsx('flex flex-wrap items-center gap-1', className)}>
             {options.length === 0 && <span className="text-xs text-text-faint">{t('designer.noColumnsToPick')}</span>}
             {options.map((name) => {
                 const position = value.indexOf(name);
+
                 return (
                     <Button
                         key={name}

package/src/designer/OptionsEditor.tsx

@@ -11,7 +11,9 @@ export function OptionsEditor({ draft, dialect, disabled, onChange, className, r
     const { t } = useTranslation('database');
     const id = useId();
     const { options } = draft;
+
     const patch = (change: Parameters<typeof patchOptions>[1]): void => onChange(patchOptions(draft, change));
+
     if (dialect.engine === 'sqlite') {
         return (
             <div ref={ref} className={clsx('flex flex-col gap-4 p-3', className)}>
@@ -32,6 +34,7 @@ export function OptionsEditor({ draft, dialect, disabled, onChange, className, r
             </div>
         );
     }
+
     return (
         <div ref={ref} className={clsx('flex max-w-xl flex-col gap-4 p-3', className)}>
             <SuggestedField
@@ -106,6 +109,7 @@ function SuggestedField({
     onValueChange(value: string): void;
 }) {
     const { t } = useTranslation('database');
+
     return (
         <>
             <datalist id={listId}>

package/src/designer/SqlPreview.tsx

@@ -16,6 +16,7 @@ export interface SqlPreviewProps {
 /* The sentence a problem of the draft is read as. */
 function ProblemText({ problem }: { problem: DraftProblem }) {
     const { t } = useTranslation('database');
+
     return <>{t(`ddl.problem.${problem.code}`, { subject: problem.subject })}</>;
 }
 
@@ -23,6 +24,7 @@ function ProblemText({ problem }: { problem: DraftProblem }) {
 export function SqlPreview({ plan, className, ref }: SqlPreviewProps) {
     const { t } = useTranslation('database');
     const script = scriptOf(plan.statements);
+
     return (
         <section
             ref={ref}

package/src/designer/TableDesigner.tsx

@@ -59,15 +59,18 @@ export function TableDesigner({ connection, schema, table, toolbarStart, classNa
     const loaded = useLoaded<Snapshot>(
         async (signal) => {
             const session = client.session(connection);
+
             const [server, structure, tables] = await Promise.all([
                 session.server({ signal }),
                 subject.current === null ? Promise.resolve(null) : session.structure(schema, subject.current, { signal }),
                 session.tables(schema, { signal })
             ]);
+
             return { dialect: dialectOf(server), structure, tables: tables.filter((info) => info.kind === 'table').map((info) => info.name) };
         },
         JSON.stringify([connection.id, schema, subject.current])
     );
+
     const snapshot = loaded.value;
 
     // The apply of this designer reloads by itself; a change from elsewhere replaces an untouched draft and warns about an edited one.
@@ -89,6 +92,7 @@ export function TableDesigner({ connection, schema, table, toolbarStart, classNa
         setEditing({ snapshot, baseline, draft: baseline });
         setShapeChanged(false);
     }
+
     const draft = editing.draft;
 
     const plan = useMemo(() => (snapshot === null ? null : planOf(snapshot.dialect, schema, snapshot.structure, draft)), [snapshot, schema, draft]);
@@ -101,30 +105,40 @@ export function TableDesigner({ connection, schema, table, toolbarStart, classNa
         if (snapshot === null || plan === null) {
             return;
         }
+
         const session = client.session(connection);
         const statements = plan.statements;
         const wasNew = snapshot.structure === null;
+
         const settle = (message: string | null): void => {
             setFailure(message);
             setConfirming(false);
         };
+
         let outcome: ExecuteResult;
         applying.current = true;
+
         try {
             outcome = await session.execute(statements.join(';\n'), { schema });
         } catch (e) {
             settle(messageOf(e, t('designer.failed')));
+
             return;
         } finally {
             applying.current = false;
         }
+
         const failed = outcome.results.find((result) => result.kind === 'error');
+
         if (failed?.kind === 'error') {
             await recoverFrom(session, statements, failed.sql, outcome.inTransaction);
             settle(failed.error.message);
+
             return;
         }
+
         settle(null);
+
         // The client has told its listeners already: `execute` does for a statement that creates, alters or drops.
         if (wasNew || draft.name !== draft.originalName) {
             setSubject({ requested: table, current: draft.name });

package/src/designer/edit.ts

@@ -18,13 +18,17 @@ export const addColumn = (draft: TableDraft, type: string): TableDraft => ({
 /* A rename carries along every key, index and foreign key that names the column. */
 export const patchColumn = (draft: TableDraft, key: string, patch: Partial<ColumnDraft>): TableDraft => {
     const before = draft.columns.find((column) => column.key === key);
+
     if (before === undefined) {
         return draft;
     }
+
     const inKey = draft.primaryKey.includes(before.name);
     const applied: Partial<ColumnDraft> = inKey && patch.nullable === true ? { ...patch, nullable: false } : patch;
     const after = { ...before, ...applied };
+
     const follow = (names: readonly string[]): string[] => names.map((name) => (name === before.name ? after.name : name));
+
     return {
         ...draft,
         columns: replaceAt(draft.columns, key, () => after),
@@ -37,9 +41,11 @@ export const patchColumn = (draft: TableDraft, key: string, patch: Partial<Colum
 /* What names the column goes with it: an index keeps its other columns, a foreign key on it is dropped. */
 export const removeColumn = (draft: TableDraft, key: string): TableDraft => {
     const gone = draft.columns.find((column) => column.key === key);
+
     if (gone === undefined) {
         return draft;
     }
+
     return {
         ...draft,
         columns: draft.columns.filter((column) => column.key !== key),
@@ -54,22 +60,28 @@ export const removeColumn = (draft: TableDraft, key: string): TableDraft => {
 export const moveColumn = (draft: TableDraft, key: string, offset: -1 | 1): TableDraft => {
     const from = draft.columns.findIndex((column) => column.key === key);
     const to = from + offset;
+
     if (from < 0 || to < 0 || to >= draft.columns.length) {
         return draft;
     }
+
     const columns = [...draft.columns];
     [columns[from], columns[to]] = [columns[to]!, columns[from]!];
+
     return { ...draft, columns };
 };
 
 /* A column in the primary key cannot be null, so putting it there says so. */
 export const togglePrimaryKey = (draft: TableDraft, key: string): TableDraft => {
     const column = draft.columns.find((candidate) => candidate.key === key);
+
     if (column === undefined) {
         return draft;
     }
+
     const joining = !draft.primaryKey.includes(column.name);
     const toggledKey = { ...draft, primaryKey: toggled(draft.primaryKey, column.name) };
+
     return joining ? patchColumn(toggledKey, key, { nullable: false }) : toggledKey;
 };
 
@@ -133,5 +145,6 @@ export const removeForeignKey = (draft: TableDraft, key: string): TableDraft =>
 /* A collation belongs to a character set, so choosing another set empties it. */
 export const patchOptions = (draft: TableDraft, patch: Partial<TableOptions>): TableDraft => {
     const charsetChanged = patch.charset !== undefined && patch.charset !== draft.options.charset;
+
     return { ...draft, options: { ...draft.options, ...(charsetChanged ? { collation: '' } : {}), ...patch } };
 };

package/src/designer/plan.ts

@@ -12,12 +12,15 @@ export interface Plan {
 
 export const planOf = (dialect: Dialect, schema: string, structure: TableStructure | null, draft: TableDraft): Plan => {
     const problems = validateDraft(dialect, draft);
+
     if (problems.length > 0) {
         return { problems, statements: [], destructive: false };
     }
+
     if (structure === null) {
         return { problems, statements: createTableSql(dialect, schema, draft), destructive: false };
     }
+
     return { problems, statements: alterTableSql(dialect, schema, structure, draft), destructive: dropsColumns(draftOf(structure), draft) };
 };
 

package/src/designer/recover.ts

@@ -11,6 +11,7 @@ export async function recoverFrom(session: DatabaseSession, statements: readonly
         if (inTransaction && statements.includes('BEGIN') && failedSql.trim().toUpperCase() !== 'BEGIN') {
             await session.transaction('rollback');
         }
+
         if (statements[0] === REBUILD_START) {
             await session.execute('PRAGMA foreign_keys=ON');
         }

package/src/designer/useReferenceColumns.ts

@@ -21,17 +21,21 @@ export function useReferenceColumns(
     const scope = `${connection.id}\u0000${schema}`;
     const [cache, setCache] = useState<Cache>({ scope, columns: {} });
     const known = cache.scope === scope ? cache.columns : {};
+
     const wanted = [...new Set(draft.foreignKeys.map((foreignKey) => foreignKey.referencedTable))]
         .filter((table) => table !== '' && table !== draft.name && !(table in known))
         .sort();
+
     const wantedKey = wanted.join('\u0000');
 
     useEffect(() => {
         if (wantedKey === '') {
             return undefined;
         }
+
         let current = true;
         const session = client.session(connection);
+
         for (const table of wantedKey.split('\u0000')) {
             session
                 .structure(schema, table)
@@ -45,6 +49,7 @@ export function useReferenceColumns(
                     }
                 });
         }
+
         return () => {
             current = false;
         };