ormbridge 0.14.0 → 0.15.0

package/dist/parsers/efcoreMigrationReplay.js

@@ -0,0 +1,790 @@
+import { bodyStatements, flattenChain, readLambda, selectedMembers, } from './csharpChains.js';
+import { evaluate, } from './csharpSyntax.js';
+import { dropColumn, findColumn, referentialAction, renameColumn, renameTable, tableKey, } from './efcoreMigrationState.js';
+const NO_CONSTANTS = () => undefined;
+/** The parameter names of the `MigrationBuilder` methods in order, for calls that pass arguments by position. */
+const PARAMETERS = {
+    CreateTable: ['name', 'columns', 'schema', 'constraints', 'comment'],
+    DropTable: ['name', 'schema'],
+    RenameTable: ['name', 'schema', 'newName', 'newSchema'],
+    AddColumn: [
+        'name',
+        'table',
+        'type',
+        'unicode',
+        'maxLength',
+        'rowVersion',
+        'schema',
+        'nullable',
+        'defaultValue',
+        'defaultValueSql',
+        'computedColumnSql',
+        'fixedLength',
+        'comment',
+        'collation',
+        'precision',
+        'scale',
+        'stored',
+    ],
+    DropColumn: ['name', 'table', 'schema'],
+    RenameColumn: ['name', 'table', 'newName', 'schema'],
+    CreateIndex: [
+        'name',
+        'table',
+        'columns',
+        'schema',
+        'unique',
+        'filter',
+        'descending',
+    ],
+    DropIndex: ['name', 'table', 'schema'],
+    RenameIndex: ['name', 'newName', 'table', 'schema'],
+    AddForeignKey: [
+        'name',
+        'table',
+        'columns',
+        'principalTable',
+        'schema',
+        'principalSchema',
+        'principalColumns',
+        'onUpdate',
+        'onDelete',
+    ],
+    DropForeignKey: ['name', 'table', 'schema'],
+    AddPrimaryKey: ['name', 'table', 'columns', 'schema'],
+    DropPrimaryKey: ['name', 'table', 'schema'],
+    AddUniqueConstraint: ['name', 'table', 'columns', 'schema'],
+    DropUniqueConstraint: ['name', 'table', 'schema'],
+    AddCheckConstraint: ['name', 'table', 'sql', 'schema'],
+    DropCheckConstraint: ['name', 'table', 'schema'],
+    Sql: ['sql', 'suppressTransaction'],
+    // The column builder inside CreateTable.
+    Column: [
+        'type',
+        'unicode',
+        'maxLength',
+        'rowVersion',
+        'name',
+        'nullable',
+        'defaultValue',
+        'defaultValueSql',
+        'computedColumnSql',
+        'fixedLength',
+        'comment',
+        'collation',
+        'precision',
+        'scale',
+        'stored',
+    ],
+    // The constraint builder inside CreateTable.
+    ForeignKey: [
+        'name',
+        'columns',
+        'principalTable',
+        'principalSchema',
+        'principalColumns',
+        'onUpdate',
+        'onDelete',
+    ],
+};
+/** Calls that change nothing the shared model holds. */
+const IGNORED_CALLS = new Set([
+    'EnsureSchema',
+    'DropSchema',
+    'AlterDatabase',
+    'AlterTable',
+    'Annotation',
+]);
+const SEQUENCE_CALLS = new Set([
+    'CreateSequence',
+    'AlterSequence',
+    'DropSequence',
+    'RenameSequence',
+    'RestartSequence',
+]);
+const DATA_CALLS = new Set([
+    'InsertData',
+    'UpdateData',
+    'DeleteData',
+]);
+const CONTROL_STATEMENTS = new Set([
+    'if_statement',
+    'for_statement',
+    'foreach_statement',
+    'while_statement',
+    'do_statement',
+    'switch_statement',
+    'try_statement',
+    'using_statement',
+    'lock_statement',
+]);
+const SQL_TABLE = /\b(?:alter\s+table|create\s+(?:or\s+replace\s+)?(?:table|view)(?:\s+if\s+not\s+exists)?|drop\s+(?:table|view)(?:\s+if\s+exists)?|truncate(?:\s+table)?|insert\s+into|update|delete\s+from|create\s+(?:unique\s+)?index\s+\S+\s+on)\s+[[`"']?([A-Za-z0-9_.]+)/i;
+/** Where a migration statement is, for warnings: `Migrations/2024_Initial.cs:12`. */
+function placeOf(path, node) {
+    return `${path}:${node.startPosition.row + 1}`;
+}
+function shorten(text, length = 60) {
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length > length ? `${flat.slice(0, length - 3)}...` : flat;
+}
+/** The argument expressions of one call by parameter name, whether they were passed by name or by position. */
+function readArguments(call, parameters) {
+    const found = new Map();
+    const list = call.node.childForFieldName('arguments');
+    let position = 0;
+    for (const argument of list?.namedChildren ?? []) {
+        if (argument.type !== 'argument') {
+            continue;
+        }
+        const label = argument.namedChildren.find((child) => child.type === 'name_colon');
+        const value = [...argument.namedChildren]
+            .reverse()
+            .find((child) => child.type !== 'name_colon');
+        if (value === undefined) {
+            continue;
+        }
+        if (label === undefined) {
+            const name = parameters[position];
+            position += 1;
+            if (name !== undefined) {
+                found.set(name, value);
+            }
+        }
+        else {
+            found.set(label.text.replace(/:\s*$/, '').trim(), value);
+        }
+    }
+    return found;
+}
+function valueOf(args, name) {
+    const node = args.get(name);
+    return node === undefined ? undefined : evaluate(node, NO_CONSTANTS);
+}
+function textArgument(args, name) {
+    const value = valueOf(args, name);
+    return value?.kind === 'string' ? value.value : undefined;
+}
+function boolArgument(args, name) {
+    const value = valueOf(args, name);
+    return value?.kind === 'bool' ? value.value : undefined;
+}
+function numberArgument(args, name) {
+    const value = valueOf(args, name);
+    return value?.kind === 'number' ? value.value : undefined;
+}
+/** A string or an array of strings (`column: "A"`, `columns: new[] { "A", "B" }`), as a list. */
+function textList(args, single, many) {
+    for (const name of [many, single]) {
+        const value = valueOf(args, name);
+        if (value?.kind === 'string') {
+            return [value.value];
+        }
+        if (value?.kind === 'array' &&
+            value.items.every((item) => item.kind === 'string')) {
+            return value.items.map((item) => item.kind === 'string' ? item.value : '');
+        }
+    }
+    return undefined;
+}
+function boolList(args, name) {
+    const value = valueOf(args, name);
+    if (value?.kind !== 'array') {
+        return [];
+    }
+    return value.items.map((item) => item.kind === 'bool' && item.value);
+}
+/** The referential action of `onDelete: ReferentialAction.Cascade`; the database default when it is not given. */
+function actionArgument(args, name) {
+    const value = valueOf(args, name);
+    if (value === undefined) {
+        return 'noAction';
+    }
+    if (value.kind === 'member') {
+        return referentialAction(value.path[value.path.length - 1] ?? '');
+    }
+    return undefined;
+}
+/** What `.Annotation("key", value)` calls after a column, index or table say. */
+function annotationsOf(chain) {
+    const found = new Map();
+    for (const call of chain.calls) {
+        if (call.name !== 'Annotation') {
+            continue;
+        }
+        const key = call.args[0];
+        const value = call.args[1];
+        if (key === undefined || value === undefined) {
+            continue;
+        }
+        const name = evaluate(key, NO_CONSTANTS);
+        if (name.kind === 'string') {
+            found.set(name.value, evaluate(value, NO_CONSTANTS));
+        }
+    }
+    return found;
+}
+/** True when the annotations of a column make it an identity, serial or autoincrement column. */
+export function identityOf(annotations) {
+    for (const [key, value] of annotations) {
+        if (/:(?:Identity|Autoincrement)$/i.test(key)) {
+            return !(value.kind === 'bool' && !value.value);
+        }
+        if (/:ValueGenerationStrategy$/i.test(key)) {
+            const text = value.kind === 'member'
+                ? value.path.join('.')
+                : value.kind === 'string'
+                    ? value.value
+                    : '';
+            return /Identity|Serial/i.test(text);
+        }
+    }
+    return false;
+}
+export function indexAnnotations(annotations) {
+    let method;
+    let includes = [];
+    for (const [key, value] of annotations) {
+        if (/:IndexMethod$/i.test(key) && value.kind === 'string') {
+            method = value.value;
+        }
+        if (/:(?:Include|IndexInclude)$/i.test(key) && value.kind === 'array') {
+            includes = value.items.map((item) => item.kind === 'string' ? item.value : '');
+        }
+    }
+    return { ...(method === undefined ? {} : { method }), includes };
+}
+/** The column named by the arguments of `Column<T>(...)`, `AddColumn<T>(...)` or `AlterColumn<T>(...)`. */
+function columnOf(name, clrType, args, chain) {
+    const storeType = textArgument(args, 'type');
+    const maxLength = numberArgument(args, 'maxLength');
+    const precision = numberArgument(args, 'precision');
+    const scale = numberArgument(args, 'scale');
+    const isUnicode = boolArgument(args, 'unicode');
+    const defaultValue = valueOf(args, 'defaultValue');
+    const defaultSql = textArgument(args, 'defaultValueSql');
+    const computedSql = textArgument(args, 'computedColumnSql');
+    const isStored = boolArgument(args, 'stored');
+    return {
+        name,
+        clrType,
+        isNullable: boolArgument(args, 'nullable') === true,
+        isRowVersion: boolArgument(args, 'rowVersion') === true,
+        isIdentity: identityOf(annotationsOf(chain)),
+        ...(storeType === undefined ? {} : { storeType }),
+        ...(maxLength === undefined ? {} : { maxLength }),
+        ...(precision === undefined ? {} : { precision }),
+        ...(scale === undefined ? {} : { scale }),
+        ...(isUnicode === undefined ? {} : { isUnicode }),
+        ...(defaultValue === undefined || defaultValue.kind === 'null'
+            ? {}
+            : { defaultValue }),
+        ...(defaultSql === undefined ? {} : { defaultSql }),
+        ...(computedSql === undefined ? {} : { computedSql }),
+        ...(isStored === undefined ? {} : { isStored }),
+    };
+}
+/** Drops the CLR default (`""`, 0, false, 0m, an empty Guid) that EF Core writes to fill existing rows. */
+function withoutBackfill(column) {
+    const value = column.defaultValue;
+    if (value === undefined || column.isNullable) {
+        return column;
+    }
+    const isZero = (value.kind === 'string' && value.value === '') ||
+        (value.kind === 'number' && value.value === 0) ||
+        (value.kind === 'bool' && !value.value) ||
+        (value.kind === 'other' &&
+            /^(?:new\s+(?:byte\[\s*0\s*\]|Guid\(\s*"0{8}-0{4}-0{4}-0{4}-0{12}"\s*\)|DateTime\(\s*1,\s*1,\s*1,\s*0,\s*0,\s*0,\s*0(?:,\s*DateTimeKind\.\w+)?\s*\)|TimeSpan\(\s*0(?:,\s*0)*\s*\)|DateTimeOffset\(\s*0\s*,\s*TimeSpan\.Zero\s*\))|Guid\.Empty|TimeSpan\.Zero)/.test(value.text));
+    if (!isZero) {
+        return column;
+    }
+    const rest = { ...column };
+    delete rest.defaultValue;
+    return rest;
+}
+function lookupTable(ctx, node, operation, schema, name) {
+    if (name === undefined) {
+        ctx.warn(`${placeOf(ctx.path, node)}: ${operation} names no table, so it was skipped.`);
+        return undefined;
+    }
+    const table = ctx.schema.get(tableKey(schema, name));
+    if (table === undefined) {
+        ctx.warn(`${placeOf(ctx.path, node)}: ${operation} refers to the table "${name}", which no earlier migration creates; the change was skipped.`);
+    }
+    return table;
+}
+/** Finds an index or constraint by name when the call does not name its table. */
+function tableWith(ctx, schema, table, has) {
+    if (table !== undefined) {
+        return ctx.schema.get(tableKey(schema, table));
+    }
+    return [...ctx.schema.values()].find(has);
+}
+/** Reads `x => x.A` or `x => new { x.A, x.B }` into column names, through the property-to-column map. */
+function selectColumns(node, columns) {
+    if (node === undefined) {
+        return undefined;
+    }
+    const members = selectedMembers(node, NO_CONSTANTS);
+    return members?.map((member) => columns.get(member) ?? member);
+}
+function createTable(call, ctx, statement) {
+    const place = placeOf(ctx.path, statement);
+    const args = readArguments(call, PARAMETERS['CreateTable'] ?? []);
+    const name = textArgument(args, 'name');
+    if (name === undefined) {
+        ctx.warn(`${place}: CreateTable has no table name, so it was skipped.`);
+        return;
+    }
+    const schemaName = textArgument(args, 'schema');
+    const table = {
+        name,
+        columns: [],
+        uniqueKeys: [],
+        indexes: [],
+        foreignKeys: [],
+        checkConstraints: [],
+        ...(schemaName === undefined ? {} : { schema: schemaName }),
+    };
+    const key = tableKey(schemaName, name);
+    if (ctx.schema.has(key)) {
+        ctx.warn(`${place}: CreateTable creates the table "${name}" again; the earlier definition was replaced.`);
+    }
+    const columnNames = new Map();
+    const columnsNode = args.get('columns');
+    const lambda = columnsNode === undefined ? undefined : readLambda(columnsNode);
+    const body = lambda?.body;
+    if (lambda === undefined ||
+        body === undefined ||
+        body.type !== 'anonymous_object_creation_expression') {
+        ctx.warn(`${place}: the columns of the table "${name}" are not written as table => new { ... }, so none were read.`);
+    }
+    else {
+        readColumnList(body, table, columnNames, ctx);
+    }
+    const constraints = args.get('constraints');
+    const constraintLambda = constraints === undefined ? undefined : readLambda(constraints);
+    if (constraintLambda !== undefined) {
+        for (const item of bodyStatements(constraintLambda.body)) {
+            const expression = item.type === 'expression_statement'
+                ? (item.namedChild(0) ?? undefined)
+                : item;
+            const chain = expression === undefined ? undefined : flattenChain(expression);
+            const first = chain?.calls[0];
+            if (chain === undefined || first === undefined) {
+                continue;
+            }
+            readConstraint(first, table, columnNames, ctx, item);
+        }
+    }
+    ctx.schema.set(key, table);
+    ctx.changes += 1;
+}
+/** Reads `table => new { Id = table.Column<int>(...), Name = table.Column<string>(...) }`. */
+function readColumnList(body, table, columnNames, ctx) {
+    const children = body.namedChildren.flatMap((child) => child.type === 'anonymous_object_member_declarator'
+        ? child.namedChildren
+        : [child]);
+    for (let at = 0; at < children.length; at += 1) {
+        const label = children[at];
+        const expression = children[at + 1];
+        if (label === undefined || label.type !== 'name_equals') {
+            continue;
+        }
+        at += 1;
+        const propertyName = label.namedChild(0)?.text ?? label.text;
+        const chain = expression === undefined ? undefined : flattenChain(expression);
+        const call = chain?.calls[0];
+        if (chain === undefined || call === undefined || call.name !== 'Column') {
+            ctx.warn(`${placeOf(ctx.path, label)}: the column "${propertyName}" of the table "${table.name}" is not written as table.Column<T>(...), so it was skipped.`);
+            continue;
+        }
+        const args = readArguments(call, PARAMETERS['Column'] ?? []);
+        const name = textArgument(args, 'name') ?? propertyName;
+        columnNames.set(propertyName, name);
+        table.columns.push(columnOf(name, call.typeArgs[0], args, chain));
+    }
+}
+function readConstraint(call, table, columnNames, ctx, statement) {
+    const place = placeOf(ctx.path, statement);
+    switch (call.name) {
+        case 'PrimaryKey':
+        case 'UniqueConstraint': {
+            const args = readArguments(call, ['name', 'columns']);
+            const columns = selectColumns(args.get('columns'), columnNames);
+            const name = textArgument(args, 'name');
+            if (columns === undefined) {
+                ctx.warn(`${place}: the columns of the ${call.name === 'PrimaryKey' ? 'primary key' : 'unique constraint'} of the table "${table.name}" could not be read, so it was skipped.`);
+                return;
+            }
+            const key = {
+                columns,
+                ...(name === undefined ? {} : { name }),
+            };
+            if (call.name === 'PrimaryKey') {
+                table.primaryKey = key;
+            }
+            else {
+                table.uniqueKeys.push(key);
+            }
+            return;
+        }
+        case 'ForeignKey': {
+            const args = readArguments(call, PARAMETERS['ForeignKey'] ?? []);
+            const columns = selectColumns(args.get('columns') ?? args.get('column'), columnNames);
+            const principalTable = textArgument(args, 'principalTable');
+            if (columns === undefined || principalTable === undefined) {
+                ctx.warn(`${place}: a foreign key of the table "${table.name}" could not be read, so it was skipped.`);
+                return;
+            }
+            pushForeignKey(table, args, columns, principalTable, ctx, statement);
+            return;
+        }
+        case 'CheckConstraint': {
+            const args = readArguments(call, ['name', 'sql']);
+            table.checkConstraints.push(textArgument(args, 'name') ?? 'check');
+            return;
+        }
+        default:
+            ctx.warn(`${place}: table.${call.name}(...) in CreateTable of "${table.name}" is not known and was skipped.`);
+    }
+}
+function pushForeignKey(table, args, columns, principalTable, ctx, statement) {
+    const place = placeOf(ctx.path, statement);
+    const principalSchema = textArgument(args, 'principalSchema');
+    const onDelete = actionArgument(args, 'onDelete');
+    const onUpdate = actionArgument(args, 'onUpdate');
+    if (onDelete === undefined || onUpdate === undefined) {
+        ctx.warn(`${place}: the referential action of a foreign key on "${table.name}" (${columns.join(', ')}) is not a ReferentialAction member; NO ACTION was used.`);
+    }
+    // Without column names the key references the primary key of the principal table.
+    const principalColumns = textList(args, 'principalColumn', 'principalColumns') ?? [];
+    const name = textArgument(args, 'name');
+    const foreignKey = {
+        name: name ?? '',
+        columns,
+        principalTable,
+        principalColumns,
+        onDelete: onDelete ?? 'noAction',
+        onUpdate: onUpdate ?? 'noAction',
+        ...(principalSchema === undefined ? {} : { principalSchema }),
+    };
+    table.foreignKeys.push(foreignKey);
+}
+/** Applies one `migrationBuilder.X(...)` call. */
+function applyCall(chain, ctx, statement) {
+    const call = chain.calls[0];
+    if (call === undefined) {
+        return;
+    }
+    const place = placeOf(ctx.path, statement);
+    const parameters = PARAMETERS[call.name] ?? [];
+    const args = readArguments(call, parameters);
+    const schemaName = textArgument(args, 'schema');
+    const name = textArgument(args, 'name');
+    const tableName = textArgument(args, 'table');
+    ctx.changes += 1;
+    switch (call.name) {
+        case 'CreateTable':
+            createTable(call, ctx, statement);
+            return;
+        case 'DropTable': {
+            const table = lookupTable(ctx, statement, 'DropTable', schemaName, name);
+            if (table === undefined) {
+                return;
+            }
+            ctx.schema.delete(tableKey(table.schema, table.name));
+            for (const other of ctx.schema.values()) {
+                const before = other.foreignKeys.length;
+                other.foreignKeys = other.foreignKeys.filter((key) => !(key.principalTable === table.name &&
+                    key.principalSchema === table.schema));
+                if (other.foreignKeys.length !== before) {
+                    ctx.warn(`${place}: DropTable "${table.name}" also removed the foreign keys of "${other.name}" that referenced it; the migration did not drop them first.`);
+                }
+            }
+            return;
+        }
+        case 'RenameTable': {
+            const table = lookupTable(ctx, statement, 'RenameTable', schemaName, name);
+            const newName = textArgument(args, 'newName');
+            if (table === undefined) {
+                return;
+            }
+            if (newName === undefined && !args.has('newSchema')) {
+                ctx.warn(`${place}: RenameTable "${table.name}" names neither a new name nor a new schema, so it changed nothing.`);
+                return;
+            }
+            renameTable(ctx.schema, table, 
+            // A table stays in its schema only when the call says so: EF Core moves it to the default schema otherwise.
+            textArgument(args, 'newSchema'), newName ?? table.name);
+            return;
+        }
+        case 'AddColumn':
+        case 'AlterColumn': {
+            const table = lookupTable(ctx, statement, `${call.name} "${name ?? '?'}"`, schemaName, tableName);
+            if (table === undefined || name === undefined) {
+                return;
+            }
+            const fullArgs = readArguments(call, PARAMETERS['AddColumn'] ?? []);
+            const made = columnOf(name, call.typeArgs[0], fullArgs, chain);
+            // EF Core fills the rows that exist with the CLR default when it adds a column that is not nullable or makes
+            // a nullable one so; that default is a step of the migration, not part of the model.
+            const column = call.name === 'AddColumn' ||
+                (boolArgument(args, 'oldNullable') === true && !made.isNullable)
+                ? withoutBackfill(made)
+                : made;
+            const existing = findColumn(table, name);
+            if (call.name === 'AddColumn') {
+                if (existing !== undefined) {
+                    ctx.warn(`${place}: AddColumn adds "${table.name}"."${name}", which already exists; the column was replaced.`);
+                    table.columns[table.columns.indexOf(existing)] = column;
+                }
+                else {
+                    table.columns.push(column);
+                }
+            }
+            else if (existing === undefined) {
+                ctx.warn(`${place}: AlterColumn changes "${table.name}"."${name}", which no earlier migration adds; the column was added.`);
+                table.columns.push(column);
+            }
+            else {
+                table.columns[table.columns.indexOf(existing)] = column;
+            }
+            return;
+        }
+        case 'DropColumn': {
+            const table = lookupTable(ctx, statement, `DropColumn "${name ?? '?'}"`, schemaName, tableName);
+            if (table === undefined || name === undefined) {
+                return;
+            }
+            if (findColumn(table, name) === undefined) {
+                ctx.warn(`${place}: DropColumn removes "${table.name}"."${name}", which no earlier migration adds.`);
+                return;
+            }
+            dropColumn(table, name);
+            return;
+        }
+        case 'RenameColumn': {
+            const table = lookupTable(ctx, statement, `RenameColumn "${name ?? '?'}"`, schemaName, tableName);
+            const newName = textArgument(args, 'newName');
+            if (table === undefined || name === undefined || newName === undefined) {
+                return;
+            }
+            if (findColumn(table, name) === undefined) {
+                ctx.warn(`${place}: RenameColumn renames "${table.name}"."${name}", which no earlier migration adds.`);
+                return;
+            }
+            renameColumn(ctx.schema, table, name, newName);
+            return;
+        }
+        case 'CreateIndex': {
+            const table = lookupTable(ctx, statement, `CreateIndex "${name ?? '?'}"`, schemaName, tableName);
+            const columns = textList(args, 'column', 'columns');
+            if (table === undefined || name === undefined) {
+                return;
+            }
+            if (columns === undefined) {
+                ctx.warn(`${place}: the columns of the index "${name}" on "${table.name}" could not be read, so it was skipped.`);
+                return;
+            }
+            const filter = textArgument(args, 'filter');
+            const extra = indexAnnotations(annotationsOf(chain));
+            const index = {
+                name,
+                columns,
+                isUnique: boolArgument(args, 'unique') === true,
+                includes: extra.includes,
+                descending: boolList(args, 'descending'),
+                ...(filter === undefined ? {} : { filter }),
+                ...(extra.method === undefined ? {} : { method: extra.method }),
+            };
+            table.indexes = table.indexes.filter((item) => item.name !== name);
+            table.indexes.push(index);
+            return;
+        }
+        case 'DropIndex': {
+            const table = tableWith(ctx, schemaName, tableName, (candidate) => candidate.indexes.some((item) => item.name === name));
+            if (table === undefined ||
+                name === undefined ||
+                !table.indexes.some((item) => item.name === name)) {
+                ctx.warn(`${place}: DropIndex "${name ?? '?'}" refers to an index that no earlier migration creates.`);
+                return;
+            }
+            table.indexes = table.indexes.filter((item) => item.name !== name);
+            return;
+        }
+        case 'RenameIndex': {
+            const newName = textArgument(args, 'newName');
+            const table = tableWith(ctx, schemaName, tableName, (candidate) => candidate.indexes.some((item) => item.name === name));
+            const index = table?.indexes.find((item) => item.name === name);
+            if (index === undefined || newName === undefined) {
+                ctx.warn(`${place}: RenameIndex "${name ?? '?'}" refers to an index that no earlier migration creates.`);
+                return;
+            }
+            index.name = newName;
+            return;
+        }
+        case 'AddForeignKey': {
+            const table = lookupTable(ctx, statement, `AddForeignKey "${name ?? '?'}"`, schemaName, tableName);
+            const columns = textList(args, 'column', 'columns');
+            const principalTable = textArgument(args, 'principalTable');
+            if (table === undefined) {
+                return;
+            }
+            if (columns === undefined || principalTable === undefined) {
+                ctx.warn(`${place}: the foreign key "${name ?? '?'}" on "${table.name}" could not be read, so it was skipped.`);
+                return;
+            }
+            table.foreignKeys = table.foreignKeys.filter((item) => item.name !== name);
+            pushForeignKey(table, args, columns, principalTable, ctx, statement);
+            return;
+        }
+        case 'DropForeignKey': {
+            const table = tableWith(ctx, schemaName, tableName, (candidate) => candidate.foreignKeys.some((item) => item.name === name));
+            if (table === undefined ||
+                !table.foreignKeys.some((item) => item.name === name)) {
+                ctx.warn(`${place}: DropForeignKey "${name ?? '?'}" refers to a foreign key that no earlier migration creates.`);
+                return;
+            }
+            table.foreignKeys = table.foreignKeys.filter((item) => item.name !== name);
+            return;
+        }
+        case 'AddPrimaryKey':
+        case 'AddUniqueConstraint': {
+            const table = lookupTable(ctx, statement, `${call.name} "${name ?? '?'}"`, schemaName, tableName);
+            const columns = textList(args, 'column', 'columns');
+            if (table === undefined) {
+                return;
+            }
+            if (columns === undefined) {
+                ctx.warn(`${place}: the columns of ${call.name} "${name ?? '?'}" on "${table.name}" could not be read, so it was skipped.`);
+                return;
+            }
+            const key = {
+                columns,
+                ...(name === undefined ? {} : { name }),
+            };
+            if (call.name === 'AddPrimaryKey') {
+                table.primaryKey = key;
+            }
+            else {
+                table.uniqueKeys.push(key);
+            }
+            return;
+        }
+        case 'DropPrimaryKey': {
+            const table = lookupTable(ctx, statement, 'DropPrimaryKey', schemaName, tableName);
+            if (table !== undefined) {
+                delete table.primaryKey;
+            }
+            return;
+        }
+        case 'DropUniqueConstraint': {
+            const table = tableWith(ctx, schemaName, tableName, (candidate) => candidate.uniqueKeys.some((item) => item.name === name));
+            if (table === undefined ||
+                !table.uniqueKeys.some((item) => item.name === name)) {
+                ctx.warn(`${place}: DropUniqueConstraint "${name ?? '?'}" refers to a constraint that no earlier migration creates.`);
+                return;
+            }
+            table.uniqueKeys = table.uniqueKeys.filter((item) => item.name !== name);
+            return;
+        }
+        case 'AddCheckConstraint': {
+            const table = lookupTable(ctx, statement, `AddCheckConstraint "${name ?? '?'}"`, schemaName, tableName);
+            table?.checkConstraints.push(name ?? 'check');
+            return;
+        }
+        case 'DropCheckConstraint': {
+            const table = tableWith(ctx, schemaName, tableName, (candidate) => candidate.checkConstraints.includes(name ?? ''));
+            if (table !== undefined) {
+                table.checkConstraints = table.checkConstraints.filter((item) => item !== name);
+            }
+            return;
+        }
+        case 'Sql': {
+            const sql = textArgument(args, 'sql');
+            const tableMatch = sql === undefined ? null : SQL_TABLE.exec(sql);
+            ctx.warn(`${place}: the raw SQL "${shorten(sql ?? statement.text)}"${tableMatch?.[1] === undefined ? '' : ` on the table "${tableMatch[1]}"`} (migrationBuilder.Sql) is not interpreted; the rebuilt schema may differ from the real database.`);
+            return;
+        }
+        default:
+            break;
+    }
+    if (IGNORED_CALLS.has(call.name)) {
+        ctx.changes -= 1;
+    }
+    else if (SEQUENCE_CALLS.has(call.name)) {
+        ctx.warn(`${place}: ${call.name}${name === undefined ? '' : ` "${name}"`} changes a sequence, which the shared model cannot hold; it was skipped.`);
+    }
+    else if (DATA_CALLS.has(call.name)) {
+        const target = textArgument(args, 'table');
+        ctx.warn(`${place}: ${call.name}${target === undefined ? '' : ` on the table "${target}"`} changes rows, not the schema (seed data is not preserved).`);
+    }
+    else {
+        ctx.warn(`${place}: migrationBuilder.${call.name}(...) is not known and was skipped.`);
+    }
+}
+/** Runs the statements of an `Up` body, descending into `if`, loops and `try` with a warning when they change the schema. */
+function replayStatements(statements, builder, ctx) {
+    for (const statement of statements) {
+        if (statement.type === 'expression_statement') {
+            const expression = statement.namedChild(0);
+            const chain = expression === null ? undefined : flattenChain(expression);
+            if (chain !== undefined && chain.root.text === builder) {
+                applyCall(chain, ctx, statement);
+            }
+            continue;
+        }
+        if (CONTROL_STATEMENTS.has(statement.type)) {
+            const before = ctx.changes;
+            const nested = statement.namedChildren.filter((child) => child.type === 'block');
+            // Only the first block runs: the `if` branch, the loop body, the `try` body. An `else` is not applied.
+            const first = nested[0];
+            if (first !== undefined) {
+                replayStatements(bodyStatements(first), builder, ctx);
+            }
+            if (ctx.changes !== before || nested.length > 1) {
+                ctx.warn(`${placeOf(ctx.path, statement)}: ${statement.type.replace(/_statement$/, '')} contains schema changes; the first block was applied as if it always ran` +
+                    `${nested.length > 1 ? ' and the other blocks were skipped' : ''}, so the result may differ from the real database.`);
+            }
+        }
+    }
+}
+/** Finds the migration classes of a file: classes that derive from `Migration` and have an `Up` method. */
+export function findMigrations(classes, path) {
+    const found = [];
+    for (const cls of classes) {
+        if (!cls.bases.some((base) => base.name === 'Migration')) {
+            continue;
+        }
+        const up = cls.methods.find((method) => method.name === 'Up');
+        if (up?.body === undefined) {
+            continue;
+        }
+        const attribute = cls.attributes.find((item) => item.name === 'Migration');
+        const declared = attribute?.args[0] === undefined
+            ? undefined
+            : evaluate(attribute.args[0], NO_CONSTANTS);
+        const base = path.split(/[\\/]/).pop() ?? path;
+        found.push({
+            path,
+            className: cls.name,
+            id: declared?.kind === 'string'
+                ? declared.value
+                : base.replace(/\.cs$/i, ''),
+            up: up.body,
+            builder: up.parameters[0]?.name ?? 'migrationBuilder',
+        });
+    }
+    return found;
+}
+/** Replays the `Up` method of one migration into the schema. */
+export function replayMigration(migration, schema, warn) {
+    const ctx = {
+        path: migration.path,
+        schema,
+        warn,
+        changes: 0,
+    };
+    replayStatements(bodyStatements(migration.up), migration.builder, ctx);
+}
+//# sourceMappingURL=efcoreMigrationReplay.js.map