ormbridge 0.0.0-stage → 0.3.0

package/dist/parsers/doctrine.js

@@ -0,0 +1,1984 @@
+import { toCamelCase, toSnakeCase } from '../naming.js';
+import { err, ok } from '../result.js';
+import { attributesOf, collectDeclarations, evaluateNode, getPhpParser, lastNameSegment, readEnumDeclaration, resolveClassName, typeOf, } from './phpSyntax.js';
+// ---------------------------------------------------------------------------
+// Static tables
+// ---------------------------------------------------------------------------
+const MAPPING_NAMESPACE = 'Doctrine\\ORM\\Mapping\\';
+/** Doctrine DBAL type names mapped to the IR scalar type. */
+const DBAL_TYPES = {
+    string: 'string',
+    ascii_string: 'string',
+    text: 'text',
+    integer: 'int',
+    smallint: 'int',
+    bigint: 'bigInt',
+    boolean: 'boolean',
+    decimal: 'decimal',
+    number: 'decimal',
+    float: 'float',
+    smallfloat: 'float',
+    datetime: 'dateTime',
+    datetime_immutable: 'dateTime',
+    datetimetz: 'dateTime',
+    datetimetz_immutable: 'dateTime',
+    date: 'date',
+    date_immutable: 'date',
+    time: 'time',
+    time_immutable: 'time',
+    dateinterval: 'duration',
+    json: 'json',
+    json_array: 'json',
+    jsonb: 'json',
+    array: 'json',
+    object: 'json',
+    simple_array: 'text',
+    binary: 'bytes',
+    blob: 'bytes',
+    guid: 'uuid',
+    uuid: 'uuid',
+    ulid: 'string',
+    enum: 'string',
+};
+/** DBAL types whose storage differs from the IR type in a way worth telling the user about. */
+const APPROXIMATED_TYPES = {
+    array: 'is stored as PHP-serialized text; the IR has no equivalent, so it was converted to json',
+    object: 'is stored as PHP-serialized text; the IR has no equivalent, so it was converted to json',
+    simple_array: 'is stored as comma-separated text; the IR has no array type, so it was converted to text',
+    ulid: 'is stored as a 26 character string; it was converted to a string column',
+};
+/** Constants of `Doctrine\DBAL\Types\Types`, mapped to the type name they hold. */
+const TYPE_CONSTANTS = {
+    STRING: 'string',
+    ASCII_STRING: 'ascii_string',
+    TEXT: 'text',
+    INTEGER: 'integer',
+    SMALLINT: 'smallint',
+    BIGINT: 'bigint',
+    BOOLEAN: 'boolean',
+    DECIMAL: 'decimal',
+    NUMBER: 'number',
+    FLOAT: 'float',
+    SMALLFLOAT: 'smallfloat',
+    DATETIME_MUTABLE: 'datetime',
+    DATETIME_IMMUTABLE: 'datetime_immutable',
+    DATETIMETZ_MUTABLE: 'datetimetz',
+    DATETIMETZ_IMMUTABLE: 'datetimetz_immutable',
+    DATE_MUTABLE: 'date',
+    DATE_IMMUTABLE: 'date_immutable',
+    TIME_MUTABLE: 'time',
+    TIME_IMMUTABLE: 'time_immutable',
+    DATEINTERVAL: 'dateinterval',
+    JSON: 'json',
+    ARRAY: 'array',
+    SIMPLE_ARRAY: 'simple_array',
+    OBJECT: 'object',
+    BINARY: 'binary',
+    BLOB: 'blob',
+    GUID: 'guid',
+    ENUM: 'enum',
+    // Constants of the legacy `Doctrine\DBAL\Types\Type` class.
+    DATETIME: 'datetime',
+    DATETIMETZ: 'datetimetz',
+    TARRAY: 'array',
+    JSON_ARRAY: 'json_array',
+};
+/** Type names Doctrine infers from a PHP property type when `#[ORM\Column]` omits `type`. */
+const PHP_TYPE_TO_DBAL = {
+    int: 'integer',
+    string: 'string',
+    bool: 'boolean',
+    float: 'float',
+    array: 'json',
+    datetime: 'datetime',
+    datetimeimmutable: 'datetime_immutable',
+    dateinterval: 'dateinterval',
+};
+const ON_DELETE_MAP = {
+    CASCADE: 'cascade',
+    'SET NULL': 'setNull',
+    RESTRICT: 'restrict',
+    'NO ACTION': 'noAction',
+    'SET DEFAULT': 'setDefault',
+};
+const NOW_SQL = /^(now\(\)|current_timestamp(\(\d*\))?|getdate\(\)|sysdate|systimestamp|localtimestamp(\(\d*\))?|datetime\('now'\)|\(datetime\('now'\)\))$/i;
+const UUID_SQL = /^(uuid_generate_v[14]\(\)|gen_random_uuid\(\)|uuid\(\)|newid\(\)|newsequentialid\(\)|sys_guid\(\))$/i;
+const RELATION_ATTRIBUTES = new Set([
+    'ManyToOne',
+    'OneToOne',
+    'OneToMany',
+    'ManyToMany',
+]);
+/** Positional parameter order of each attribute constructor (Doctrine ORM 3). */
+const PARAMETER_ORDER = {
+    Entity: ['repositoryClass', 'readOnly'],
+    Table: ['name', 'schema', 'indexes', 'uniqueConstraints', 'options'],
+    Index: ['name', 'columns', 'fields', 'flags', 'options'],
+    UniqueConstraint: ['name', 'columns', 'fields', 'options'],
+    Column: [
+        'name',
+        'type',
+        'length',
+        'precision',
+        'scale',
+        'unique',
+        'nullable',
+        'insertable',
+        'updatable',
+        'enumType',
+        'options',
+        'columnDefinition',
+        'generated',
+        'index',
+    ],
+    GeneratedValue: ['strategy'],
+    CustomIdGenerator: ['class'],
+    SequenceGenerator: ['sequenceName', 'allocationSize', 'initialValue'],
+    JoinColumn: [
+        'name',
+        'referencedColumnName',
+        'deferrable',
+        'unique',
+        'nullable',
+        'onDelete',
+        'columnDefinition',
+        'fieldName',
+        'foreignKeyName',
+        'options',
+    ],
+    JoinTable: [
+        'name',
+        'schema',
+        'foreignKeyName',
+        'inverseForeignKeyName',
+        'options',
+    ],
+    ManyToOne: ['targetEntity', 'cascade', 'fetch', 'inversedBy'],
+    OneToOne: [
+        'targetEntity',
+        'mappedBy',
+        'inversedBy',
+        'cascade',
+        'fetch',
+        'orphanRemoval',
+    ],
+    OneToMany: [
+        'mappedBy',
+        'targetEntity',
+        'cascade',
+        'fetch',
+        'orphanRemoval',
+        'indexBy',
+    ],
+    ManyToMany: [
+        'targetEntity',
+        'mappedBy',
+        'inversedBy',
+        'cascade',
+        'fetch',
+        'orphanRemoval',
+        'indexBy',
+    ],
+    Embedded: ['class', 'columnPrefix'],
+    InheritanceType: ['value'],
+    DiscriminatorColumn: [
+        'name',
+        'type',
+        'length',
+        'columnDefinition',
+        'enumType',
+        'options',
+    ],
+    DiscriminatorMap: ['value'],
+};
+/** Mapping attributes that carry no schema information and are skipped without a warning. */
+const IGNORED_ATTRIBUTES = new Set([
+    'HasLifecycleCallbacks',
+    'ChangeTrackingPolicy',
+    'EntityListeners',
+    'EntityListener',
+    'Cache',
+    'OrderBy',
+    'PrePersist',
+    'PostPersist',
+    'PreUpdate',
+    'PostUpdate',
+    'PreRemove',
+    'PostRemove',
+    'PostLoad',
+    'PreFlush',
+    'ReadOnly',
+]);
+/** Attributes that define schema we cannot represent; each produces a warning. */
+const UNSUPPORTED_ATTRIBUTES = {
+    AttributeOverride: 'attribute overrides are not supported',
+    AttributeOverrides: 'attribute overrides are not supported',
+    AssociationOverride: 'association overrides are not supported',
+    AssociationOverrides: 'association overrides are not supported',
+    NamedQuery: 'named queries are not part of the schema',
+    NamedNativeQuery: 'named queries are not part of the schema',
+    SqlResultSetMapping: 'result set mappings are not part of the schema',
+};
+/** Column options handled elsewhere or known to have no IR equivalent. */
+const UNSUPPORTED_COLUMN_OPTIONS = {
+    unsigned: 'unsigned integers',
+    comment: 'a column comment',
+    collation: 'a collation',
+    charset: 'a character set',
+    fixed: 'a fixed-length (CHAR) column',
+    check: 'a column check constraint',
+    autoincrement: 'an explicit autoincrement flag',
+    version: 'a version flag',
+};
+/** Symfony UID id generators that map onto IR defaults. */
+const UUID_GENERATORS = new Set([
+    'Symfony\\Bridge\\Doctrine\\IdGenerator\\UuidGenerator',
+    'Ramsey\\Uuid\\Doctrine\\UuidGenerator',
+]);
+const ULID_GENERATORS = new Set([
+    'Symfony\\Bridge\\Doctrine\\IdGenerator\\UlidGenerator',
+]);
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+/** Parses Doctrine ORM entity files (PHP 8 attributes) into the shared IR using tree-sitter. */
+export async function parseDoctrine(sources, options) {
+    const parserResult = await getPhpParser();
+    if (!parserResult.ok) {
+        return parserResult;
+    }
+    const parser = parserResult.value;
+    const warnings = [];
+    const state = { enums: new Map(), warnings };
+    const parsedFiles = [];
+    let annotationFiles = [];
+    for (const source of sources) {
+        const tree = parser.parse(source.text);
+        if (tree.rootNode.hasError) {
+            warnings.push(`${source.path}: the file contains PHP syntax errors; some entities or columns may be missing from the output.`);
+        }
+        if (usesDocblockAnnotations(tree.rootNode)) {
+            annotationFiles = [...annotationFiles, source.path];
+            warnings.push(`${source.path}: Doctrine docblock annotations (such as @ORM\\Entity) are not supported yet; ` +
+                `convert them to PHP 8 attributes (#[ORM\\Entity]). Annotated classes were skipped.`);
+        }
+        parsedFiles.push({
+            source,
+            declarations: collectDeclarations(tree.rootNode, source.path),
+        });
+    }
+    // Enums are collected from every file first, so a column can reference an enum from another file.
+    for (const { declarations } of parsedFiles) {
+        for (const { ctx, node } of declarations) {
+            if (node.type === 'enum_declaration') {
+                registerEnum(node, ctx, state);
+            }
+        }
+    }
+    const classes = new Map();
+    for (const { declarations } of parsedFiles) {
+        for (const { ctx, node } of declarations) {
+            if (node.type !== 'class_declaration' &&
+                node.type !== 'trait_declaration') {
+                continue;
+            }
+            const rawClass = parseClass(node, ctx, state);
+            if (rawClass === undefined) {
+                continue;
+            }
+            if (classes.has(rawClass.fqn)) {
+                warnings.push(`Duplicate class name "${rawClass.fqn}" (${ctx.path}); only the first definition was converted.`);
+                continue;
+            }
+            classes.set(rawClass.fqn, rawClass);
+        }
+    }
+    const schema = buildSchema(classes, state, options);
+    if (schema.models.length === 0) {
+        const checkedPaths = sources
+            .map((source) => source.path)
+            .join(', ');
+        const annotationHint = annotationFiles.length > 0
+            ? ` Docblock annotations (@ORM\\Entity) were found in ${annotationFiles.join(', ')}; annotation mapping is not supported yet, so convert them to PHP 8 attributes.`
+            : '';
+        return err('NO_MODELS_FOUND', `No Doctrine entities were found in: ${checkedPaths}. An entity is a class marked with the #[ORM\\Entity] attribute ` +
+            `(XML and YAML mappings are not supported).${annotationHint}`);
+    }
+    return ok(schema);
+}
+// ---------------------------------------------------------------------------
+// File structure: namespaces, imports, declarations
+// ---------------------------------------------------------------------------
+function usesDocblockAnnotations(root) {
+    return root
+        .descendantsOfType('comment')
+        .some((comment) => /@(ORM\\\w+|(?:Entity|MappedSuperclass|Embeddable)\b)/.test(comment.text));
+}
+/** The Doctrine mapping attribute name (for example "Column") for an attribute, or undefined for other attributes. */
+function mappingName(attribute, ctx) {
+    const fqn = resolveClassName(attribute.rawName, ctx);
+    if (fqn.startsWith(MAPPING_NAMESPACE)) {
+        return fqn.slice(MAPPING_NAMESPACE.length);
+    }
+    // A snippet that uses the conventional alias without importing it.
+    if (attribute.rawName.startsWith('ORM\\') && !ctx.uses.has('orm')) {
+        return attribute.rawName.slice('ORM\\'.length);
+    }
+    return undefined;
+}
+function toMappingAttributes(attributes, ctx) {
+    const mapped = [];
+    for (const attribute of attributes) {
+        const name = mappingName(attribute, ctx);
+        if (name !== undefined) {
+            mapped.push({
+                name,
+                attribute,
+                args: mergeArguments(name, attribute.args, attribute.named),
+            });
+        }
+    }
+    return mapped;
+}
+function mergeArguments(name, positional, named) {
+    const merged = { ...named };
+    const order = PARAMETER_ORDER[name] ?? [];
+    positional.forEach((value, index) => {
+        const key = order[index];
+        if (key !== undefined && merged[key] === undefined) {
+            merged[key] = value;
+        }
+    });
+    return merged;
+}
+// ---------------------------------------------------------------------------
+// Value helpers
+// ---------------------------------------------------------------------------
+function stringValue(value) {
+    return value !== undefined && value.kind === 'string'
+        ? value.value
+        : undefined;
+}
+function boolValue(value) {
+    return value !== undefined && value.kind === 'bool' ? value.value : undefined;
+}
+function numberValue(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value.kind === 'number') {
+        return value.value;
+    }
+    if (value.kind === 'string' && /^\d+$/.test(value.value)) {
+        return Number(value.value);
+    }
+    return undefined;
+}
+/** The elements of an array value, or an empty list for anything else. */
+function arrayItems(value) {
+    return value !== undefined && value.kind === 'array'
+        ? value.items.map((item) => item.value)
+        : [];
+}
+/** The string elements of an array value; undefined when any element is not a plain string. */
+function stringList(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value.kind === 'string') {
+        return [value.value];
+    }
+    if (value.kind !== 'array') {
+        return undefined;
+    }
+    const strings = value.items.flatMap((item) => item.value.kind === 'string' ? [item.value.value] : []);
+    return strings.length === value.items.length ? strings : undefined;
+}
+/** The entries of a `['key' => value]` array whose keys are strings. */
+function arrayEntries(value) {
+    const entries = {};
+    if (value !== undefined && value.kind === 'array') {
+        for (const item of value.items) {
+            if (item.key !== undefined && item.key.kind === 'string') {
+                entries[item.key.value] = item.value;
+            }
+        }
+    }
+    return entries;
+}
+/** Reads `'IDENTITY'` or `ClassMetadata::GENERATOR_TYPE_IDENTITY` as upper case text. */
+function keywordValue(value, prefix) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value.kind === 'string') {
+        return value.value.toUpperCase();
+    }
+    if (value.kind === 'constant' && value.name.startsWith(prefix)) {
+        return value.name.slice(prefix.length);
+    }
+    if (value.kind === 'constant' || value.kind === 'name') {
+        const text = value.kind === 'name' ? value.value : value.name;
+        return text.toUpperCase();
+    }
+    return undefined;
+}
+/** A class name written as `Foo::class`, `'Foo'` or `'\App\Foo'`, resolved against the current file and class. */
+function entityReference(value, ctx, currentFqn) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value.kind === 'classRef') {
+        const lowered = value.name.toLowerCase();
+        if (lowered === 'self' || lowered === 'static') {
+            return currentFqn;
+        }
+        return resolveClassName(value.name, ctx);
+    }
+    if (value.kind === 'string') {
+        // Doctrine treats a string without a namespace as relative to the entity's own namespace.
+        if (value.value.startsWith('\\')) {
+            return value.value.slice(1);
+        }
+        return value.value.includes('\\') || ctx.namespace === ''
+            ? value.value
+            : `${ctx.namespace}\\${value.value}`;
+    }
+    return undefined;
+}
+function describeValue(value) {
+    switch (value.kind) {
+        case 'other':
+            return value.text;
+        case 'name':
+            return value.value;
+        case 'constant':
+            return `${value.owner}::${value.name}`;
+        case 'classRef':
+            return `${value.name}::class`;
+        default:
+            return value.kind;
+    }
+}
+// ---------------------------------------------------------------------------
+// Doctrine naming strategy (UnderscoreNamingStrategy)
+// ---------------------------------------------------------------------------
+/** Doctrine's `underscore()`: an underscore before an upper case letter that follows a lower case letter or digit. */
+function underscore(name) {
+    return name.replace(/(?<=[a-z0-9])([A-Z])/g, '_$1').toLowerCase();
+}
+function stripQuotes(columnName) {
+    return columnName.replace(/^`(.*)`$/, '$1');
+}
+function upperFirst(text) {
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
+// ---------------------------------------------------------------------------
+// Enums
+// ---------------------------------------------------------------------------
+function registerEnum(node, ctx, state) {
+    const info = readEnumDeclaration(node, ctx, state.warnings);
+    if (info === undefined) {
+        return;
+    }
+    if (state.enums.has(info.fqn)) {
+        state.warnings.push(`Duplicate enum name "${info.fqn}" (${ctx.path}); only the first definition was used.`);
+        return;
+    }
+    state.enums.set(info.fqn, info);
+}
+// ---------------------------------------------------------------------------
+// Class parsing
+// ---------------------------------------------------------------------------
+function parseClass(node, ctx, state) {
+    const nameNode = node.childForFieldName('name');
+    const bodyNode = node.childForFieldName('body');
+    if (nameNode === null || bodyNode === null) {
+        return undefined;
+    }
+    const className = nameNode.text;
+    const fqn = ctx.namespace === '' ? className : `${ctx.namespace}\\${className}`;
+    const mappings = toMappingAttributes(attributesOf(node), ctx);
+    const rawClass = {
+        name: className,
+        fqn,
+        ctx,
+        isTrait: node.type === 'trait_declaration',
+        isAbstract: node.namedChildren.some((child) => child.type === 'abstract_modifier'),
+        role: 'plain',
+        traitFqns: [],
+        members: [],
+        indexes: [],
+        discriminatorMapSize: 0,
+        hasMappedProperties: false,
+        initializers: new Map(),
+        constructorAssignments: new Map(),
+        preUpdateProperties: new Set(),
+        prePersistProperties: new Set(),
+    };
+    const baseClause = node.namedChildren.find((child) => child.type === 'base_clause');
+    const baseName = baseClause?.namedChildren[0];
+    if (baseName !== undefined) {
+        rawClass.parentFqn = resolveClassName(baseName.text.replace(/\s+/g, ''), ctx);
+    }
+    parseClassAttributes(rawClass, mappings, state);
+    for (const member of bodyNode.namedChildren) {
+        if (member.type === 'use_declaration') {
+            for (const used of member.namedChildren) {
+                if (used.type === 'name' || used.type === 'qualified_name') {
+                    rawClass.traitFqns.push(resolveClassName(used.text.replace(/\s+/g, ''), ctx));
+                }
+            }
+        }
+        else if (member.type === 'property_declaration') {
+            parsePropertyDeclaration(member, rawClass, state);
+        }
+        else if (member.type === 'method_declaration') {
+            parseConstructor(member, rawClass, state);
+            scanMethodBehaviour(member, rawClass, state);
+        }
+    }
+    applyBehaviour(rawClass, state);
+    if (rawClass.role === 'plain' &&
+        !rawClass.isTrait &&
+        rawClass.hasMappedProperties) {
+        state.warnings.push(`${className}: the class has Doctrine mapping attributes on its properties but is not marked with #[ORM\\Entity], ` +
+            `#[ORM\\MappedSuperclass] or #[ORM\\Embeddable]; it was skipped.`);
+    }
+    return rawClass;
+}
+function parseClassAttributes(rawClass, mappings, state) {
+    const className = rawClass.name;
+    for (const mapping of mappings) {
+        const args = mapping.args;
+        switch (mapping.name) {
+            case 'Entity':
+                rawClass.role = 'entity';
+                if (boolValue(args['readOnly']) === true) {
+                    state.warnings.push(`${className}: the readOnly option of #[ORM\\Entity] has no equivalent and was ignored.`);
+                }
+                break;
+            case 'MappedSuperclass':
+                rawClass.role = 'mappedSuperclass';
+                break;
+            case 'Embeddable':
+                rawClass.role = 'embeddable';
+                break;
+            case 'Table':
+                parseTableAttribute(rawClass, args, state);
+                break;
+            case 'Index':
+            case 'UniqueConstraint': {
+                const index = parseIndexAttribute(mapping.name, args, undefined, className, rawClass.ctx, state);
+                if (index !== undefined) {
+                    rawClass.indexes.push(index);
+                }
+                break;
+            }
+            case 'InheritanceType': {
+                const kind = keywordValue(args['value'], 'INHERITANCE_TYPE_');
+                if (kind === 'SINGLE_TABLE' || kind === 'JOINED' || kind === 'NONE') {
+                    rawClass.inheritanceType = kind;
+                }
+                else {
+                    state.warnings.push(`${className}: the inheritance type "${kind ?? 'unknown'}" is not supported; ` +
+                        `only SINGLE_TABLE and JOINED are converted.`);
+                }
+                break;
+            }
+            case 'DiscriminatorColumn':
+                rawClass.discriminatorName = stringValue(args['name']);
+                rawClass.discriminatorType = stringValue(args['type']);
+                {
+                    const length = numberValue(args['length']);
+                    if (length !== undefined) {
+                        rawClass.discriminatorLength = length;
+                    }
+                }
+                if (args['columnDefinition'] !== undefined) {
+                    state.warnings.push(`${className}: the columnDefinition of #[ORM\\DiscriminatorColumn] has no equivalent and was ignored.`);
+                }
+                break;
+            case 'DiscriminatorMap':
+                rawClass.discriminatorMapSize = Object.keys(arrayEntries(args['value'])).length;
+                break;
+            default: {
+                const reason = UNSUPPORTED_ATTRIBUTES[mapping.name];
+                if (reason !== undefined) {
+                    state.warnings.push(`${className}: #[ORM\\${mapping.name}] was skipped; ${reason}.`);
+                }
+                else if (!IGNORED_ATTRIBUTES.has(mapping.name)) {
+                    state.warnings.push(`${className}: the attribute #[ORM\\${mapping.name}] is not supported and was ignored.`);
+                }
+                break;
+            }
+        }
+    }
+}
+function parseTableAttribute(rawClass, args, state) {
+    const className = rawClass.name;
+    const tableName = stringValue(args['name']);
+    if (tableName !== undefined) {
+        rawClass.tableName = stripQuotes(tableName);
+    }
+    const schemaName = stringValue(args['schema']);
+    if (schemaName !== undefined) {
+        state.warnings.push(`${className}: the schema "${schemaName}" given to #[ORM\\Table] was ignored; only the table name is converted.`);
+    }
+    if (args['options'] !== undefined) {
+        state.warnings.push(`${className}: the options of #[ORM\\Table] (engine, charset and similar) have no equivalent and were ignored.`);
+    }
+    for (const key of ['indexes', 'uniqueConstraints']) {
+        for (const item of arrayItems(args[key])) {
+            const nested = nestedAttribute(item, rawClass.ctx);
+            if (nested === undefined ||
+                (nested.name !== 'Index' && nested.name !== 'UniqueConstraint')) {
+                state.warnings.push(`${className}: an entry of the "${key}" option of #[ORM\\Table] could not be read statically and was skipped.`);
+                continue;
+            }
+            const index = parseIndexAttribute(nested.name, nested.args, undefined, className, rawClass.ctx, state);
+            if (index !== undefined) {
+                rawClass.indexes.push(index);
+            }
+        }
+    }
+}
+/** Reads `new ORM\Index(...)` into the attribute name and its merged arguments. */
+function nestedAttribute(value, ctx) {
+    if (value.kind !== 'new') {
+        return undefined;
+    }
+    const created = value;
+    const name = mappingName({ rawName: created.className, args: created.args, named: created.named }, ctx);
+    return name === undefined
+        ? undefined
+        : { name, args: mergeArguments(name, created.args, created.named) };
+}
+/** Parses `#[ORM\Index]` or `#[ORM\UniqueConstraint]`. A property attribute passes the property name. */
+function parseIndexAttribute(attributeName, args, propertyName, location, _ctx, state) {
+    const columns = stringList(args['columns']);
+    const fields = stringList(args['fields']);
+    let refs = columns ?? fields;
+    if (refs === undefined && propertyName !== undefined) {
+        refs = [propertyName];
+    }
+    if (refs === undefined || refs.length === 0) {
+        state.warnings.push(`${location}: could not read the column list of #[ORM\\${attributeName}]; the ${attributeName === 'UniqueConstraint' ? 'unique constraint' : 'index'} was skipped.`);
+        return undefined;
+    }
+    const flags = (stringList(args['flags']) ?? []).map((flag) => flag.toLowerCase());
+    const options = arrayEntries(args['options']);
+    for (const option of Object.keys(options)) {
+        state.warnings.push(`${location}: the "${option}" option of #[ORM\\${attributeName}] has no equivalent and was ignored.`);
+    }
+    for (const flag of flags) {
+        if (flag !== 'fulltext' && flag !== 'clustered') {
+            state.warnings.push(`${location}: the "${flag}" flag of #[ORM\\${attributeName}] has no equivalent and was ignored.`);
+        }
+    }
+    const name = stringValue(args['name']);
+    return {
+        refs: refs.map(stripQuotes),
+        isUnique: attributeName === 'UniqueConstraint',
+        flags,
+        ...(name === undefined ? {} : { name }),
+    };
+}
+// ---------------------------------------------------------------------------
+// Property parsing
+// ---------------------------------------------------------------------------
+function parsePropertyDeclaration(node, rawClass, state) {
+    if (node.namedChildren.some((child) => child.type === 'static_modifier')) {
+        return;
+    }
+    const attributes = attributesOf(node);
+    const type = typeOf(node);
+    for (const element of node.namedChildren) {
+        if (element.type !== 'property_element') {
+            continue;
+        }
+        const variable = element.namedChildren.find((child) => child.type === 'variable_name');
+        if (variable === undefined) {
+            continue;
+        }
+        const initializer = element.namedChildren.find((child) => child.type === 'property_initializer');
+        const initialValue = initializer?.namedChildren[0];
+        if (initialValue !== undefined) {
+            rawClass.initializers.set(variable.text.replace(/^\$/, ''), initialValue);
+        }
+        parseProperty({ name: variable.text.replace(/^\$/, ''), attributes, type }, rawClass, state);
+    }
+}
+/** Constructor promotion: `public function __construct(#[ORM\Column] private string $name)`. */
+function parseConstructor(node, rawClass, state) {
+    const nameNode = node.childForFieldName('name');
+    if (nameNode === null || nameNode.text.toLowerCase() !== '__construct') {
+        return;
+    }
+    const parameters = node.childForFieldName('parameters');
+    if (parameters === null) {
+        return;
+    }
+    for (const parameter of parameters.namedChildren) {
+        if (parameter.type !== 'property_promotion_parameter') {
+            continue;
+        }
+        const variable = parameter.childForFieldName('name');
+        if (variable === null) {
+            continue;
+        }
+        parseProperty({
+            name: variable.text.replace(/^\$/, ''),
+            attributes: attributesOf(parameter),
+            type: typeOf(parameter),
+        }, rawClass, state);
+    }
+}
+function parseProperty(info, rawClass, state) {
+    const mappings = toMappingAttributes(info.attributes, rawClass.ctx);
+    if (mappings.length === 0) {
+        return;
+    }
+    rawClass.hasMappedProperties = true;
+    const location = `${rawClass.name}.${info.name}`;
+    const has = (name) => mappings.some((mapping) => mapping.name === name);
+    const relation = mappings.find((mapping) => RELATION_ATTRIBUTES.has(mapping.name));
+    const embedded = mappings.find((mapping) => mapping.name === 'Embedded');
+    if (embedded !== undefined) {
+        parseEmbedded(embedded, info, location, rawClass, state);
+    }
+    else if (relation !== undefined) {
+        parseRelation(relation, mappings, info, location, rawClass, state);
+    }
+    else if (has('Column') || has('Id')) {
+        if (!has('Column')) {
+            state.warnings.push(`${location}: #[ORM\\Id] was used without #[ORM\\Column]; Doctrine needs both, so the column was mapped from the property type.`);
+        }
+        parseColumn(mappings, info, location, rawClass, state);
+    }
+    for (const mapping of mappings) {
+        if (mapping.name === 'Index' || mapping.name === 'UniqueConstraint') {
+            const index = parseIndexAttribute(mapping.name, mapping.args, info.name, location, rawClass.ctx, state);
+            if (index !== undefined) {
+                rawClass.indexes.push(index);
+            }
+        }
+        else if (mapping.name !== 'Column' &&
+            mapping.name !== 'Id' &&
+            mapping.name !== 'Version' &&
+            mapping.name !== 'GeneratedValue' &&
+            mapping.name !== 'CustomIdGenerator' &&
+            mapping.name !== 'SequenceGenerator' &&
+            mapping.name !== 'JoinColumn' &&
+            mapping.name !== 'InverseJoinColumn' &&
+            mapping.name !== 'JoinTable' &&
+            mapping.name !== 'Embedded' &&
+            !RELATION_ATTRIBUTES.has(mapping.name) &&
+            !IGNORED_ATTRIBUTES.has(mapping.name)) {
+            state.warnings.push(`${location}: the attribute #[ORM\\${mapping.name}] is not supported and was ignored.`);
+        }
+    }
+}
+/** The DBAL type name written in `type:`, as text; undefined when absent or not a plain name. */
+function declaredTypeName(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value.kind === 'string') {
+        return value.value.toLowerCase();
+    }
+    if (value.kind === 'constant' &&
+        ['Types', 'Type'].includes(lastNameSegment(value.owner))) {
+        return TYPE_CONSTANTS[value.name];
+    }
+    return undefined;
+}
+function findEnum(fqn, state) {
+    const exact = state.enums.get(fqn);
+    if (exact !== undefined) {
+        return exact;
+    }
+    const short = lastNameSegment(fqn);
+    const candidates = [...state.enums.values()].filter((candidate) => candidate.name === short);
+    return candidates.length === 1 ? candidates[0] : undefined;
+}
+function resolveColumnType(args, type, location, rawClass, state) {
+    const ctx = rawClass.ctx;
+    const typeValue = args['type'];
+    const declared = declaredTypeName(typeValue);
+    if (typeValue !== undefined && declared === undefined) {
+        state.warnings.push(`${location}: the column type (${describeValue(typeValue)}) cannot be read statically; it was converted to a string.`);
+        return { type: 'string', dbalType: undefined };
+    }
+    // Enum-backed column: an explicit enumType, or a PHP type that is an enum.
+    const enumValue = args['enumType'];
+    let enumFqn = entityReference(enumValue, ctx, rawClass.fqn);
+    const phpName = type?.names[0];
+    if (enumFqn === undefined &&
+        phpName !== undefined &&
+        (declared === undefined || declared === 'enum')) {
+        const candidate = resolveClassName(phpName, ctx);
+        if (findEnum(candidate, state) !== undefined) {
+            enumFqn = candidate;
+        }
+    }
+    if (enumFqn !== undefined) {
+        const info = findEnum(enumFqn, state);
+        if (info === undefined) {
+            state.warnings.push(`${location}: the enum "${lastNameSegment(enumFqn)}" was not found in the input files; the column was converted to a string. ` +
+                `Add the file that defines it to --input.`);
+            return { type: 'string', dbalType: declared };
+        }
+        if (info.backing === 'none') {
+            state.warnings.push(`${location}: the enum "${info.name}" is not a backed enum, which Doctrine cannot store; the column was converted to a string.`);
+            return { type: 'string', dbalType: declared };
+        }
+        if (info.backing === 'int') {
+            state.warnings.push(`${location}: the enum "${info.name}" has integer values, which the shared model cannot represent; the column was converted to an int.`);
+            return { type: 'int', dbalType: declared ?? 'integer' };
+        }
+        return { type: 'string', dbalType: declared ?? 'string', enumInfo: info };
+    }
+    if (declared !== undefined) {
+        const mapped = DBAL_TYPES[declared];
+        if (mapped === undefined) {
+            state.warnings.push(`${location}: column type "${declared}" has no equivalent in the shared model (custom DBAL types are not resolved); it was converted to a string.`);
+            return { type: 'string', dbalType: declared };
+        }
+        const note = APPROXIMATED_TYPES[declared];
+        if (note !== undefined) {
+            state.warnings.push(`${location}: column type "${declared}" ${note}.`);
+        }
+        if (declared === 'enum') {
+            state.warnings.push(`${location}: an enum column was declared without a readable enumType; it was converted to a string.`);
+        }
+        return { type: mapped, dbalType: declared };
+    }
+    // No explicit type: Doctrine infers it from the PHP property type.
+    if (phpName === undefined || (type?.names.length ?? 0) > 1) {
+        state.warnings.push(`${location}: no column type could be inferred (add a property type or an explicit type); it was converted to a string.`);
+        return { type: 'string', dbalType: undefined };
+    }
+    const inferred = PHP_TYPE_TO_DBAL[lastNameSegment(phpName).toLowerCase()];
+    if (inferred !== undefined) {
+        return { type: DBAL_TYPES[inferred] ?? 'string', dbalType: inferred };
+    }
+    state.warnings.push(`${location}: the PHP type "${type?.text ?? phpName}" cannot be mapped to a column type; add an explicit type. It was converted to a string.`);
+    return { type: 'string', dbalType: undefined };
+}
+function parseColumn(mappings, info, location, rawClass, state) {
+    const column = mappings.find((mapping) => mapping.name === 'Column');
+    const args = column?.args ?? {};
+    const has = (name) => mappings.some((mapping) => mapping.name === name);
+    const find = (name) => mappings.find((mapping) => mapping.name === name);
+    const isPrimaryKey = has('Id');
+    const resolved = resolveColumnType(args, info.type, location, rawClass, state);
+    let irType = resolved.type;
+    const columnNameOption = stringValue(args['name']);
+    const columnName = columnNameOption === undefined
+        ? underscore(info.name)
+        : stripQuotes(columnNameOption);
+    const isNullable = !isPrimaryKey && boolValue(args['nullable']) === true;
+    const field = {
+        name: info.name,
+        columnName,
+        type: irType,
+        isPrimaryKey,
+        isUnique: boolValue(args['unique']) === true && !isPrimaryKey,
+        isNullable,
+        isAutoUpdated: false,
+        ...(resolved.enumInfo === undefined
+            ? {}
+            : { enumName: resolved.enumInfo.name }),
+    };
+    // Length and precision ---------------------------------------------------
+    const length = numberValue(args['length']);
+    if (irType === 'string' && resolved.enumInfo === undefined) {
+        field.maxLength = length ?? 255;
+    }
+    else if (irType === 'string' && length !== undefined) {
+        field.maxLength = length;
+    }
+    if (irType === 'decimal') {
+        field.maxDigits = numberValue(args['precision']) ?? 10;
+        field.decimalPlaces = numberValue(args['scale']) ?? 0;
+    }
+    // Id generation ------------------------------------------------------------
+    const generated = find('GeneratedValue');
+    const customGenerator = find('CustomIdGenerator');
+    let defaultValue;
+    if (generated !== undefined || customGenerator !== undefined) {
+        if (!isPrimaryKey) {
+            state.warnings.push(`${location}: #[ORM\\GeneratedValue] was used on a property without #[ORM\\Id]; it was ignored.`);
+        }
+        else {
+            const generatedDefault = convertGenerator(generated, customGenerator, irType, location, rawClass, state);
+            defaultValue = generatedDefault.value;
+            if (generatedDefault.type !== undefined) {
+                irType = generatedDefault.type;
+                field.type = irType;
+                delete field.maxLength;
+                if (irType === 'string') {
+                    field.maxLength = 26;
+                }
+            }
+        }
+    }
+    if (find('SequenceGenerator') !== undefined) {
+        state.warnings.push(`${location}: #[ORM\\SequenceGenerator] settings (sequence name, allocation size) have no equivalent and were ignored.`);
+    }
+    // Defaults -----------------------------------------------------------------
+    const columnOptions = arrayEntries(args['options']);
+    const optionDefault = columnOptions['default'];
+    if (optionDefault !== undefined && defaultValue === undefined) {
+        defaultValue = convertDefault(optionDefault, field, resolved.enumInfo, location, state);
+    }
+    // Version columns ----------------------------------------------------------
+    if (has('Version')) {
+        state.warnings.push(`${location}: #[ORM\\Version] was converted to a plain column${irType === 'int' ? ' defaulting to 1' : ''}; ` +
+            `Doctrine's optimistic locking is not represented.`);
+        if (irType === 'int' && defaultValue === undefined) {
+            defaultValue = { kind: 'literal', value: 1 };
+        }
+    }
+    if (defaultValue !== undefined) {
+        field.default = defaultValue;
+    }
+    // Options with no equivalent ----------------------------------------------
+    for (const key of Object.keys(columnOptions)) {
+        if (key === 'default' || key === 'jsonb') {
+            continue;
+        }
+        const description = UNSUPPORTED_COLUMN_OPTIONS[key];
+        state.warnings.push(description === undefined
+            ? `${location}: the column option "${key}" has no equivalent and was ignored.`
+            : `${location}: ${description} (option "${key}") has no equivalent and was ignored.`);
+    }
+    if (args['columnDefinition'] !== undefined) {
+        state.warnings.push(`${location}: columnDefinition has no equivalent (it is raw DDL) and was ignored; the column type was derived from the declared type.`);
+    }
+    for (const key of ['insertable', 'updatable']) {
+        if (boolValue(args[key]) === false) {
+            state.warnings.push(`${location}: ${key}: false has no equivalent and was ignored.`);
+        }
+    }
+    if (args['generated'] !== undefined) {
+        state.warnings.push(`${location}: the generated option (a database-generated column) has no equivalent and was ignored.`);
+    }
+    if (boolValue(args['index']) === true) {
+        rawClass.indexes.push({ refs: [info.name], isUnique: false, flags: [] });
+    }
+    rawClass.members.push({ kind: 'field', field });
+}
+/** Maps `#[ORM\GeneratedValue]` and `#[ORM\CustomIdGenerator]` to an IR default. */
+function convertGenerator(generated, custom, type, location, rawClass, state) {
+    const strategy = keywordValue(generated?.args['strategy'], 'GENERATOR_TYPE_') ??
+        (generated === undefined ? 'CUSTOM' : 'AUTO');
+    if (strategy === 'CUSTOM' || custom !== undefined) {
+        const generatorClass = entityReference(custom?.args['class'], rawClass.ctx, rawClass.fqn);
+        if (generatorClass !== undefined && UUID_GENERATORS.has(generatorClass)) {
+            return { value: { kind: 'uuid' }, type: 'uuid' };
+        }
+        if (generatorClass !== undefined && ULID_GENERATORS.has(generatorClass)) {
+            state.warnings.push(`${location}: the ULID id generator was converted to a client-generated string key (26 characters).`);
+            return {
+                value: { kind: 'clientGenerated', generator: 'ulid' },
+                type: 'string',
+            };
+        }
+        state.warnings.push(`${location}: the custom id generator ${generatorClass === undefined ? '(unreadable)' : `"${lastNameSegment(generatorClass)}"`} ` +
+            `has no equivalent; the key has no generated default.`);
+        return {};
+    }
+    switch (strategy) {
+        case 'NONE':
+            return {};
+        case 'UUID':
+            return { value: { kind: 'uuid' }, type: 'uuid' };
+        case 'SEQUENCE':
+            state.warnings.push(`${location}: the SEQUENCE generation strategy was converted to an auto-increment key.`);
+            return type === 'int' || type === 'bigInt'
+                ? { value: { kind: 'autoIncrement' } }
+                : {};
+        case 'AUTO':
+        case 'IDENTITY':
+            if (type === 'uuid') {
+                return { value: { kind: 'uuid' } };
+            }
+            if (type === 'int' || type === 'bigInt') {
+                return { value: { kind: 'autoIncrement' } };
+            }
+            state.warnings.push(`${location}: the ${strategy} generation strategy on a ${type} key has no equivalent; the key has no generated default.`);
+            return {};
+        default:
+            state.warnings.push(`${location}: the generation strategy "${strategy}" is not supported; the key has no generated default.`);
+            return {};
+    }
+}
+function convertDefault(value, field, enumInfo, location, state) {
+    switch (value.kind) {
+        case 'null':
+            return undefined;
+        case 'bool':
+            return { kind: 'literal', value: value.value };
+        case 'number':
+            return field.type === 'string' || field.type === 'text'
+                ? { kind: 'literal', value: String(value.value) }
+                : { kind: 'literal', value: value.value };
+        case 'string':
+            return convertStringDefault(value.value, field, enumInfo, location, state);
+        case 'constant': {
+            if (enumInfo !== undefined &&
+                lastNameSegment(value.owner) === enumInfo.name) {
+                const member = enumInfo.values.find((candidate) => candidate.name === value.name);
+                if (member !== undefined) {
+                    return { kind: 'enumValue', value: member.name };
+                }
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    state.warnings.push(`${location}: the default value (${describeValue(value)}) cannot be evaluated statically and was skipped.`);
+    return undefined;
+}
+function convertStringDefault(text, field, enumInfo, location, state) {
+    const trimmed = text.trim();
+    if (enumInfo !== undefined) {
+        const member = enumInfo.values.find((candidate) => candidate.dbValue === text);
+        if (member !== undefined) {
+            return { kind: 'enumValue', value: member.name };
+        }
+        state.warnings.push(`${location}: the default "${text}" is not a value of the enum "${enumInfo.name}"; it was kept as a literal.`);
+        return { kind: 'literal', value: text };
+    }
+    switch (field.type) {
+        case 'dateTime':
+        case 'date':
+        case 'time':
+            if (NOW_SQL.test(trimmed) || /^current_(date|time)$/i.test(trimmed)) {
+                return { kind: 'now' };
+            }
+            break;
+        case 'uuid':
+        case 'string':
+            if (UUID_SQL.test(trimmed)) {
+                return { kind: 'uuid' };
+            }
+            break;
+        case 'boolean':
+            if (/^(1|true)$/i.test(trimmed)) {
+                return { kind: 'literal', value: true };
+            }
+            if (/^(0|false)$/i.test(trimmed)) {
+                return { kind: 'literal', value: false };
+            }
+            break;
+        case 'int':
+        case 'bigInt':
+        case 'float':
+        case 'decimal':
+            if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+                return { kind: 'literal', value: Number(trimmed) };
+            }
+            break;
+        default:
+            break;
+    }
+    return { kind: 'literal', value: text };
+}
+/** Reads a `$this->name = value;` statement. */
+function thisAssignment(statement) {
+    if (statement.type !== 'expression_statement') {
+        return undefined;
+    }
+    const assignment = statement.namedChildren[0];
+    if (assignment === undefined || assignment.type !== 'assignment_expression') {
+        return undefined;
+    }
+    const target = assignment.childForFieldName('left');
+    const value = assignment.childForFieldName('right');
+    if (target === null ||
+        value === null ||
+        target.type !== 'member_access_expression') {
+        return undefined;
+    }
+    const owner = target.childForFieldName('object');
+    const name = target.childForFieldName('name');
+    if (owner === null || name === null || owner.text !== '$this') {
+        return undefined;
+    }
+    return { property: name.text, value };
+}
+/** True for `new DateTime()`, `new \DateTimeImmutable()` and `new DateTimeImmutable('now')`. */
+function isNowExpression(value) {
+    if (value.type !== 'object_creation_expression') {
+        return false;
+    }
+    const evaluated = evaluateNode(value);
+    if (evaluated.kind !== 'new') {
+        return false;
+    }
+    const className = lastNameSegment(evaluated.className);
+    if (className !== 'DateTime' && className !== 'DateTimeImmutable') {
+        return false;
+    }
+    if (evaluated.args.length === 0) {
+        return true;
+    }
+    const first = evaluated.args[0];
+    return (evaluated.args.length === 1 &&
+        first !== undefined &&
+        first.kind === 'string' &&
+        first.value.trim().toLowerCase() === 'now');
+}
+/** `self::generateUuid()` (as written by the emitter) and the common `Uuid::v4()` spellings. */
+const UUID_CALL = /^(?:(?:self|static|\$this)(?:::|->)generateUuid|\\?(?:[A-Za-z_]+\\)*Uuid::(?:uuid[47]|v[47]))\(\)(?:->(?:toRfc4122|toString)\(\))?$/i;
+/** Reads the lifecycle callbacks and `__construct` assignments of a method. */
+function scanMethodBehaviour(node, rawClass, state) {
+    const nameNode = node.childForFieldName('name');
+    const body = node.childForFieldName('body');
+    if (nameNode === null || body === null) {
+        return;
+    }
+    const methodName = nameNode.text;
+    if (methodName.toLowerCase() === '__construct') {
+        for (const statement of body.namedChildren) {
+            const assignment = thisAssignment(statement);
+            if (assignment !== undefined) {
+                rawClass.constructorAssignments.set(assignment.property, assignment.value);
+            }
+        }
+        return;
+    }
+    const callbacks = toMappingAttributes(attributesOf(node), rawClass.ctx)
+        .map((mapping) => mapping.name)
+        .filter((name) => name === 'PreUpdate' || name === 'PrePersist');
+    if (callbacks.length === 0) {
+        return;
+    }
+    for (const statement of body.namedChildren) {
+        if (statement.type === 'comment') {
+            continue;
+        }
+        const assignment = thisAssignment(statement);
+        if (assignment === undefined || !isNowExpression(assignment.value)) {
+            state.warnings.push(`${rawClass.name}::${methodName}: the lifecycle callback statement \`${statement.text.replace(/\s+/g, ' ')}\` ` +
+                `is not a plain timestamp assignment (\`$this->property = new \\DateTimeImmutable();\`); it was ignored.`);
+            continue;
+        }
+        for (const callback of callbacks) {
+            (callback === 'PreUpdate'
+                ? rawClass.preUpdateProperties
+                : rawClass.prePersistProperties).add(assignment.property);
+        }
+    }
+}
+/** Converts a statically known PHP value to a JSON value; undefined when part of it is dynamic. */
+function phpValueToJson(value) {
+    switch (value.kind) {
+        case 'string':
+        case 'number':
+        case 'bool':
+            return value.value;
+        case 'null':
+            return null;
+        case 'array': {
+            const isList = value.items.every((item) => item.key === undefined);
+            if (isList) {
+                const list = value.items.map((item) => phpValueToJson(item.value));
+                return list.includes(undefined) ? undefined : list;
+            }
+            const record = {};
+            for (const item of value.items) {
+                const key = item.key;
+                const converted = phpValueToJson(item.value);
+                if (key === undefined ||
+                    (key.kind !== 'string' && key.kind !== 'number') ||
+                    converted === undefined) {
+                    return undefined;
+                }
+                record[String(key.value)] = converted;
+            }
+            return record;
+        }
+        default:
+            return undefined;
+    }
+}
+/** Converts the value a property starts with (initialiser or constructor) to an IR default. */
+function convertInitialValue(node, field, enumInfo, location, state) {
+    const compact = node.text.replace(/\s+/g, '');
+    if (UUID_CALL.test(compact)) {
+        return field.type === 'uuid' || field.type === 'string'
+            ? { kind: 'uuid' }
+            : undefined;
+    }
+    if (isNowExpression(node)) {
+        return field.type === 'dateTime' ||
+            field.type === 'date' ||
+            field.type === 'time'
+            ? { kind: 'now' }
+            : undefined;
+    }
+    const value = evaluateNode(node);
+    if (value.kind === 'null') {
+        return undefined;
+    }
+    if (value.kind === 'new') {
+        const className = lastNameSegment(value.className);
+        const first = value.args[0];
+        if ((className === 'DateTime' || className === 'DateTimeImmutable') &&
+            first !== undefined &&
+            first.kind === 'string') {
+            return { kind: 'literal', value: first.value };
+        }
+    }
+    if (value.kind === 'array') {
+        const json = phpValueToJson(value);
+        if ((field.type === 'json' || field.arrayDepth !== undefined) &&
+            json !== undefined) {
+            return { kind: 'literal', value: JSON.stringify(json) };
+        }
+        state.warnings.push(`${location}: the initial value ${describeValue(value)} cannot be evaluated statically and was skipped.`);
+        return undefined;
+    }
+    return convertDefault(value, field, enumInfo, location, state);
+}
+/** Applies lifecycle callbacks, property initialisers and constructor assignments to the fields of a class. */
+function applyBehaviour(rawClass, state) {
+    for (const member of rawClass.members) {
+        if (member.kind !== 'field') {
+            continue;
+        }
+        const field = member.field;
+        const location = `${rawClass.name}.${field.name}`;
+        if (rawClass.preUpdateProperties.has(field.name)) {
+            field.isAutoUpdated = true;
+        }
+        else if (rawClass.prePersistProperties.has(field.name) &&
+            field.default === undefined) {
+            // Set once on insert, which is what a "now" default means.
+            field.default = { kind: 'now' };
+        }
+        if (field.default !== undefined) {
+            continue;
+        }
+        const initial = rawClass.constructorAssignments.get(field.name) ??
+            rawClass.initializers.get(field.name);
+        if (initial === undefined) {
+            continue;
+        }
+        const enumInfo = field.enumName === undefined
+            ? undefined
+            : [...state.enums.values()].find((candidate) => candidate.name === field.enumName);
+        const converted = convertInitialValue(initial, field, enumInfo, location, state);
+        if (converted !== undefined) {
+            field.default = converted;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Embedded
+// ---------------------------------------------------------------------------
+function parseEmbedded(embedded, info, location, rawClass, state) {
+    const args = embedded.args;
+    let classFqn = entityReference(args['class'], rawClass.ctx, rawClass.fqn);
+    if (classFqn === undefined && info.type?.names[0] !== undefined) {
+        classFqn = resolveClassName(info.type.names[0], rawClass.ctx);
+    }
+    if (classFqn === undefined) {
+        state.warnings.push(`${location}: the embeddable class of #[ORM\\Embedded] could not be resolved, so the columns were skipped.`);
+        return;
+    }
+    const prefixValue = args['columnPrefix'];
+    let prefix;
+    if (prefixValue !== undefined && prefixValue.kind === 'string') {
+        prefix = prefixValue.value;
+    }
+    else if (prefixValue !== undefined && prefixValue.kind === 'bool') {
+        prefix = prefixValue.value ? undefined : false;
+    }
+    rawClass.members.push({
+        kind: 'embedded',
+        property: info.name,
+        classFqn,
+        prefix,
+    });
+}
+// ---------------------------------------------------------------------------
+// Relations
+// ---------------------------------------------------------------------------
+function parseRelation(relationAttribute, mappings, info, location, rawClass, state) {
+    const args = relationAttribute.args;
+    const attributeName = relationAttribute.name;
+    let targetFqn = entityReference(args['targetEntity'], rawClass.ctx, rawClass.fqn);
+    if (targetFqn === undefined &&
+        (attributeName === 'ManyToOne' || attributeName === 'OneToOne')) {
+        // Doctrine infers the target of a to-one relation from the property type.
+        const typeName = info.type?.names[0];
+        if (typeName !== undefined) {
+            const lowered = typeName.toLowerCase();
+            targetFqn =
+                lowered === 'self' || lowered === 'static'
+                    ? rawClass.fqn
+                    : resolveClassName(typeName, rawClass.ctx);
+        }
+    }
+    if (targetFqn === undefined) {
+        state.warnings.push(`${location}: the target of #[ORM\\${attributeName}] could not be resolved (add targetEntity: Foo::class); the relation was skipped.`);
+        return;
+    }
+    const mappedBy = stringValue(args['mappedBy']);
+    const inversedBy = stringValue(args['inversedBy']);
+    const cascade = (stringList(args['cascade']) ?? []).map((item) => item.toLowerCase());
+    if (cascade.includes('remove') ||
+        cascade.includes('all') ||
+        boolValue(args['orphanRemoval']) === true) {
+        state.warnings.push(`${location}: ORM-level cascade remove / orphanRemoval is not represented; ` +
+            `use onDelete: 'CASCADE' on the join column for a database-level cascade.`);
+    }
+    const isOwner = attributeName === 'ManyToOne' ||
+        ((attributeName === 'OneToOne' || attributeName === 'ManyToMany') &&
+            mappedBy === undefined);
+    if (!isOwner) {
+        rawClass.members.push({
+            kind: 'inverse',
+            property: info.name,
+            targetFqn,
+            ...(mappedBy === undefined ? {} : { mappedBy }),
+            relationKind: attributeName === 'OneToMany'
+                ? 'oneToMany'
+                : attributeName === 'ManyToMany'
+                    ? 'manyToMany'
+                    : 'oneToOne',
+        });
+        return;
+    }
+    const kind = attributeName === 'ManyToMany'
+        ? 'manyToMany'
+        : attributeName === 'OneToOne'
+            ? 'oneToOne'
+            : 'foreignKey';
+    // Join columns ------------------------------------------------------------
+    const joinColumns = mappings
+        .filter((mapping) => mapping.name === 'JoinColumn')
+        .map((mapping) => mapping.args);
+    if (kind !== 'manyToMany' && joinColumns.length > 1) {
+        state.warnings.push(`${location}: composite foreign keys (several join columns) are not supported; the relation was skipped.`);
+        return;
+    }
+    const joinColumn = joinColumns[0];
+    if (kind === 'manyToMany') {
+        // Doctrine 2 passes joinColumns / inverseJoinColumns to JoinTable; Doctrine 3 uses #[ORM\JoinColumn] and #[ORM\InverseJoinColumn].
+        const joinTable = mappings.find((mapping) => mapping.name === 'JoinTable');
+        const customized = [
+            ...['name', 'schema', 'joinColumns', 'inverseJoinColumns'].filter((key) => joinTable?.args[key] !== undefined),
+            ...(joinColumns.length > 0 ? ['JoinColumn'] : []),
+            ...(mappings.some((mapping) => mapping.name === 'InverseJoinColumn')
+                ? ['InverseJoinColumn']
+                : []),
+        ];
+        if (customized.length > 0) {
+            state.warnings.push(`${location}: custom join table settings (${customized.join(', ')}) are not preserved; ` +
+                `the join table name and columns are derived from the models.`);
+        }
+    }
+    let explicitColumn;
+    let referencedColumn;
+    let nullableOption;
+    let onDelete = 'noAction';
+    if (joinColumn !== undefined && kind !== 'manyToMany') {
+        explicitColumn = stringValue(joinColumn['name']);
+        referencedColumn = stringValue(joinColumn['referencedColumnName']);
+        nullableOption = boolValue(joinColumn['nullable']);
+        if (joinColumn['columnDefinition'] !== undefined) {
+            state.warnings.push(`${location}: the columnDefinition of the join column has no equivalent and was ignored.`);
+        }
+        const onDeleteValue = stringValue(joinColumn['onDelete']);
+        if (onDeleteValue !== undefined) {
+            const mapped = ON_DELETE_MAP[onDeleteValue.toUpperCase()];
+            if (mapped === undefined) {
+                state.warnings.push(`${location}: onDelete "${onDeleteValue}" has no equivalent and was converted to NoAction.`);
+            }
+            else {
+                onDelete = mapped;
+            }
+        }
+    }
+    if (kind === 'manyToMany') {
+        onDelete = 'cascade';
+    }
+    const isPrimaryKey = mappings.some((mapping) => mapping.name === 'Id');
+    const relation = {
+        name: info.name,
+        kind,
+        targetModel: targetFqn,
+        columnName: explicitColumn === undefined
+            ? `${underscore(info.name)}_id`
+            : stripQuotes(explicitColumn),
+        // Doctrine join columns are nullable unless nullable: false is given.
+        isNullable: !isPrimaryKey && nullableOption !== false,
+        onDelete,
+        ...(inversedBy === undefined ? {} : { relatedName: inversedBy }),
+        ...(referencedColumn === undefined || referencedColumn === 'id'
+            ? {}
+            : { toField: stripQuotes(referencedColumn) }),
+        ...(isPrimaryKey ? { isPrimaryKey: true } : {}),
+    };
+    rawClass.members.push({
+        kind: 'relation',
+        relation,
+        hasExplicitNullable: nullableOption !== undefined,
+    });
+}
+// ---------------------------------------------------------------------------
+// Schema assembly (inheritance, embeddables, inverse sides)
+// ---------------------------------------------------------------------------
+function buildSchema(classes, state, options) {
+    const warnings = state.warnings;
+    const entities = [...classes.values()].filter((rawClass) => rawClass.role === 'entity');
+    // Inheritance: how each entity relates to the entity it extends. -----------
+    const rootOf = (rawClass) => {
+        let current = rawClass;
+        const seen = new Set([current.fqn]);
+        for (;;) {
+            const parent = nearestEntityParent(current, classes);
+            if (parent === undefined || seen.has(parent.fqn)) {
+                return current;
+            }
+            seen.add(parent.fqn);
+            current = parent;
+        }
+    };
+    const rootsWithChildren = new Set(entities.flatMap((entity) => nearestEntityParent(entity, classes) === undefined
+        ? []
+        : [rootOf(entity).fqn]));
+    const inheritanceOf = (rawClass) => {
+        const root = rootOf(rawClass);
+        if (!rootsWithChildren.has(root.fqn)) {
+            return 'NONE';
+        }
+        // Doctrine rejects an entity hierarchy without an inheritance type; single table is the closest reading.
+        return root.inheritanceType === undefined || root.inheritanceType === 'NONE'
+            ? 'SINGLE_TABLE'
+            : root.inheritanceType;
+    };
+    const modelNames = new Map();
+    const seenNames = new Set();
+    const modelClasses = [];
+    for (const entity of entities) {
+        const parent = nearestEntityParent(entity, classes);
+        const kind = inheritanceOf(entity);
+        if (parent !== undefined) {
+            const root = rootOf(entity);
+            if (root.inheritanceType === undefined) {
+                warnings.push(`${entity.name}: the entity extends the entity "${parent.name}" but "${root.name}" has no #[ORM\\InheritanceType]; ` +
+                    `single-table inheritance was assumed.`);
+            }
+            if (kind === 'SINGLE_TABLE') {
+                modelNames.set(entity.fqn, root.name);
+                continue;
+            }
+        }
+        if (seenNames.has(entity.name)) {
+            warnings.push(`Duplicate entity name "${entity.name}" (${entity.ctx.path}); only the first definition was converted.`);
+            continue;
+        }
+        seenNames.add(entity.name);
+        modelNames.set(entity.fqn, entity.name);
+        modelClasses.push(entity);
+    }
+    const models = [];
+    const inverseSides = [];
+    const joinedChildren = [];
+    for (const entity of modelClasses) {
+        const collected = collectMembers(entity, classes, state, new Set());
+        const kind = inheritanceOf(entity);
+        const parent = nearestEntityParent(entity, classes);
+        const isRoot = parent === undefined;
+        const isJoinedChild = parent !== undefined && kind === 'JOINED';
+        const descendants = isRoot && kind === 'SINGLE_TABLE'
+            ? entities.filter((candidate) => candidate !== entity &&
+                rootOf(candidate) === entity &&
+                modelNames.get(candidate.fqn) === entity.name)
+            : [];
+        const descendantMembers = descendants.map((descendant) => collectMembers(descendant, classes, state, new Set()));
+        const model = finalizeModel(entity, collected, descendantMembers, modelNames, state, options, isJoinedChild);
+        if (isRoot && (kind === 'SINGLE_TABLE' || kind === 'JOINED')) {
+            addDiscriminator(model, entity, state);
+        }
+        if (descendants.length > 0) {
+            warnings.push(`${entity.name}: single-table inheritance was flattened into the table "${model.tableName}"; the columns of ` +
+                `${descendants.map((descendant) => descendant.name).join(', ')} were merged as nullable columns ` +
+                `and the discriminator values are not preserved.`);
+        }
+        if (isJoinedChild && parent !== undefined) {
+            joinedChildren.push({ model, parentModel: parent.name });
+            warnings.push(`${entity.name}: joined-table inheritance from "${parent.name}" was converted to a one-to-one primary key ` +
+                `named "${joinedPointerName(parent.name)}".`);
+        }
+        models.push(model);
+        for (const inverse of collected.inverses) {
+            inverseSides.push({ model, inverse });
+        }
+        for (const descendant of descendantMembers) {
+            for (const inverse of descendant.inverses) {
+                inverseSides.push({ model, inverse });
+            }
+        }
+    }
+    resolveInverseSides(models, inverseSides, modelNames, classes, warnings);
+    resolveTargets(models, modelNames, classes, warnings, options);
+    patchJoinedKeys(models, joinedChildren);
+    normalizeReferencedColumns(models);
+    return { models, enums: pruneEnums(state, models), warnings };
+}
+function joinedPointerName(parentName) {
+    return `${toSnakeCase(parentName)}_ptr`;
+}
+/** The closest ancestor that is an entity, skipping mapped superclasses and other plain classes. */
+function nearestEntityParent(rawClass, classes) {
+    const seen = new Set([rawClass.fqn]);
+    let current = rawClass;
+    for (;;) {
+        if (current.parentFqn === undefined) {
+            return undefined;
+        }
+        const parent = classes.get(current.parentFqn);
+        if (parent === undefined || seen.has(parent.fqn)) {
+            return undefined;
+        }
+        if (parent.role === 'entity') {
+            return parent;
+        }
+        seen.add(parent.fqn);
+        current = parent;
+    }
+}
+function emptyCollected() {
+    return { fields: [], relations: [], inverses: [], indexes: [] };
+}
+/**
+ * Gathers the members a class contributes: its traits, then (through mapped superclasses only)
+ * its parents, then its own properties. Embedded properties are flattened into prefixed fields.
+ */
+function collectMembers(rawClass, classes, state, visiting) {
+    const inherited = emptyCollected();
+    visiting.add(rawClass.fqn);
+    if (rawClass.parentFqn !== undefined) {
+        const parent = classes.get(rawClass.parentFqn);
+        if (parent === undefined) {
+            if (rawClass.role === 'entity' || rawClass.role === 'mappedSuperclass') {
+                state.warnings.push(`${rawClass.name}: base class "${lastNameSegment(rawClass.parentFqn)}" was not found in the input files, so any columns it defines ` +
+                    `are missing. Add the file that defines it to --input.`);
+            }
+        }
+        else if (visiting.has(parent.fqn)) {
+            state.warnings.push(`${rawClass.name}: circular inheritance through "${parent.name}" was ignored.`);
+        }
+        else if (parent.role === 'mappedSuperclass') {
+            mergeCollected(inherited, collectMembers(parent, classes, state, new Set(visiting)));
+        }
+        else if (parent.role !== 'entity' && parent.hasMappedProperties) {
+            state.warnings.push(`${rawClass.name}: the base class "${parent.name}" is not marked #[ORM\\MappedSuperclass], so Doctrine ignores its mapped properties.`);
+        }
+    }
+    for (const traitFqn of rawClass.traitFqns) {
+        const trait = classes.get(traitFqn);
+        if (trait === undefined) {
+            state.warnings.push(`${rawClass.name}: the trait "${lastNameSegment(traitFqn)}" was not found in the input files, so any mapped properties it declares are missing. ` +
+                `Add the file that defines it to --input.`);
+        }
+        else if (!visiting.has(trait.fqn)) {
+            mergeCollected(inherited, collectMembers(trait, classes, state, new Set(visiting)));
+        }
+    }
+    const own = emptyCollected();
+    for (const member of rawClass.members) {
+        switch (member.kind) {
+            case 'field':
+                own.fields.push(member.field);
+                break;
+            case 'relation':
+                own.relations.push(member);
+                break;
+            case 'inverse':
+                own.inverses.push(member);
+                break;
+            case 'embedded':
+                own.fields.push(...expandEmbedded(member, `${rawClass.name}.${member.property}`, classes, state, new Set([rawClass.fqn])));
+                break;
+        }
+    }
+    own.indexes.push(...rawClass.indexes);
+    const ownFieldNames = new Set(own.fields.map((field) => field.name));
+    const ownRelationNames = new Set(own.relations.map((member) => member.relation.name));
+    const ownInverseNames = new Set(own.inverses.map((member) => member.property));
+    return {
+        fields: [
+            ...inherited.fields.filter((field) => !ownFieldNames.has(field.name)),
+            ...own.fields,
+        ],
+        relations: [
+            ...inherited.relations.filter((member) => !ownRelationNames.has(member.relation.name)),
+            ...own.relations,
+        ],
+        inverses: [
+            ...inherited.inverses.filter((member) => !ownInverseNames.has(member.property)),
+            ...own.inverses,
+        ],
+        indexes: [...inherited.indexes, ...own.indexes],
+    };
+}
+function mergeCollected(target, source) {
+    target.fields.push(...source.fields);
+    target.relations.push(...source.relations);
+    target.inverses.push(...source.inverses);
+    target.indexes.push(...source.indexes);
+}
+/** Flattens an embeddable into prefixed fields, the way Doctrine's underscore naming strategy names them. */
+function expandEmbedded(embedded, location, classes, state, visiting) {
+    const embeddable = classes.get(embedded.classFqn);
+    if (embeddable === undefined) {
+        state.warnings.push(`${location}: the embeddable "${lastNameSegment(embedded.classFqn)}" was not found in the input files, so its columns are missing. ` +
+            `Add the file that defines it to --input.`);
+        return [];
+    }
+    if (visiting.has(embeddable.fqn)) {
+        state.warnings.push(`${location}: a recursive embeddable was ignored.`);
+        return [];
+    }
+    if (embeddable.role !== 'embeddable') {
+        state.warnings.push(`${location}: "${embeddable.name}" is not marked #[ORM\\Embeddable]; Doctrine would reject it, but its columns were embedded anyway.`);
+    }
+    const collected = collectMembers(embeddable, classes, state, new Set([...visiting, embeddable.fqn]));
+    const columnPrefix = embedded.prefix === false
+        ? ''
+        : (embedded.prefix ?? `${underscore(embedded.property)}_`);
+    for (const relation of collected.relations) {
+        state.warnings.push(`${location}.${relation.relation.name}: relations inside embeddables are not supported and were skipped.`);
+    }
+    for (const inverse of collected.inverses) {
+        state.warnings.push(`${location}.${inverse.property}: relations inside embeddables are not supported and were skipped.`);
+    }
+    if (collected.indexes.length > 0) {
+        state.warnings.push(`${location}: indexes declared inside the embeddable "${embeddable.name}" were skipped.`);
+    }
+    return collected.fields.map((field) => ({
+        ...field,
+        name: toCamelCase(`${embedded.property}_${upperFirst(field.name)}`),
+        columnName: `${columnPrefix}${field.columnName}`,
+        isPrimaryKey: false,
+    }));
+}
+function finalizeModel(rawClass, collected, descendants, modelNames, state, options, isJoinedChild) {
+    const warnings = state.warnings;
+    const fields = collected.fields.map((field) => ({
+        ...field,
+    }));
+    const relationMembers = [...collected.relations];
+    const indexes = [...collected.indexes];
+    // Columns of single-table subclasses are optional for rows of other subclasses.
+    for (const descendant of descendants) {
+        for (const field of descendant.fields) {
+            if (!fields.some((existing) => existing.name === field.name)) {
+                fields.push({ ...field, isNullable: true, isPrimaryKey: false });
+            }
+        }
+        for (const member of descendant.relations) {
+            if (!relationMembers.some((existing) => existing.relation.name === member.relation.name)) {
+                relationMembers.push({
+                    ...member,
+                    relation: { ...member.relation, isNullable: true },
+                });
+            }
+        }
+        indexes.push(...descendant.indexes);
+    }
+    const relations = [];
+    /** Scalar foreign-key properties merged into relations: property name -> relation name. */
+    const renamed = new Map();
+    for (const member of relationMembers) {
+        const relation = { ...member.relation };
+        if (relation.kind !== 'manyToMany') {
+            const backing = fields.findIndex((field) => field.columnName === relation.columnName);
+            const backingField = fields[backing];
+            if (backingField !== undefined) {
+                // The entity also declares the foreign key column as a plain property
+                // (Doctrine requires insertable/updatable: false on it); the relation already represents it.
+                fields.splice(backing, 1);
+                renamed.set(backingField.name, relation.name);
+                if (!member.hasExplicitNullable) {
+                    relation.isNullable = backingField.isNullable;
+                }
+                if (backingField.isPrimaryKey) {
+                    relation.isPrimaryKey = true;
+                    relation.isNullable = false;
+                }
+            }
+        }
+        relations.push(relation);
+    }
+    const irIndexes = [];
+    for (const raw of indexes) {
+        const names = [];
+        const missing = [];
+        for (const ref of raw.refs) {
+            const resolved = resolveIndexReference(ref, fields, relations, renamed);
+            if (resolved === undefined) {
+                missing.push(ref);
+            }
+            else {
+                names.push(resolved);
+            }
+        }
+        if (missing.length > 0) {
+            warnings.push(`${rawClass.name}: the ${raw.isUnique ? 'unique constraint' : 'index'} on (${raw.refs.join(', ')}) refers to ` +
+                `"${missing.join('", "')}", which is not a column or relation of the entity; it was skipped.`);
+            continue;
+        }
+        const singleField = names.length === 1
+            ? fields.find((field) => field.name === names[0])
+            : undefined;
+        if (raw.isUnique &&
+            raw.name === undefined &&
+            singleField !== undefined &&
+            !singleField.isPrimaryKey) {
+            singleField.isUnique = true;
+            continue;
+        }
+        irIndexes.push({
+            fields: names,
+            isUnique: raw.isUnique,
+            ...(raw.name === undefined ? {} : { name: raw.name }),
+            ...(raw.flags.includes('fulltext') ? { kind: 'fulltext' } : {}),
+            ...(raw.flags.includes('clustered') ? { clustered: true } : {}),
+        });
+    }
+    // Primary key -------------------------------------------------------------
+    const primaryFields = fields.filter((field) => field.isPrimaryKey);
+    const primaryRelations = relations.filter((relation) => relation.isPrimaryKey === true);
+    const keyCount = primaryFields.length + primaryRelations.length;
+    let compositePrimaryKey;
+    if (isJoinedChild) {
+        if (keyCount > 0) {
+            warnings.push(`${rawClass.name}: a joined-table child inherits its identifier; its own #[ORM\\Id] properties were kept as ordinary columns.`);
+        }
+    }
+    else if (keyCount === 0) {
+        warnings.push(`${rawClass.name}: the entity has no identifier; Doctrine requires a property marked #[ORM\\Id].`);
+    }
+    else if (keyCount > 1) {
+        compositePrimaryKey = [
+            ...primaryFields.map((field) => field.name),
+            ...primaryRelations.map((relation) => relation.name),
+        ];
+        for (const field of primaryFields) {
+            field.isPrimaryKey = false;
+            field.isUnique = false;
+        }
+        for (const relation of primaryRelations) {
+            delete relation.isPrimaryKey;
+        }
+    }
+    if (isJoinedChild) {
+        const parentFqn = rawClass.parentFqn;
+        const parentName = parentFqn === undefined
+            ? 'Parent'
+            : (modelNames.get(parentFqn) ?? lastNameSegment(parentFqn));
+        for (const field of fields) {
+            field.isPrimaryKey = false;
+        }
+        relations.unshift({
+            name: joinedPointerName(parentName),
+            kind: 'oneToOne',
+            targetModel: parentFqn ?? parentName,
+            columnName: 'id',
+            isNullable: false,
+            onDelete: 'cascade',
+            isPrimaryKey: true,
+        });
+    }
+    return {
+        name: rawClass.name,
+        tableName: rawClass.tableName ?? underscore(rawClass.name),
+        appLabel: options.appLabel,
+        fields,
+        relations,
+        indexes: irIndexes,
+        ...(compositePrimaryKey === undefined ? {} : { compositePrimaryKey }),
+    };
+}
+/** Maps an index column (or property) reference to the IR field or relation name. */
+function resolveIndexReference(ref, fields, relations, renamed) {
+    const byColumn = fields.find((field) => field.columnName === ref);
+    if (byColumn !== undefined) {
+        return byColumn.name;
+    }
+    const relationByColumn = relations.find((relation) => relation.kind !== 'manyToMany' && relation.columnName === ref);
+    if (relationByColumn !== undefined) {
+        return relationByColumn.name;
+    }
+    const renamedTo = renamed.get(ref);
+    if (renamedTo !== undefined) {
+        return renamedTo;
+    }
+    if (fields.some((field) => field.name === ref) ||
+        relations.some((relation) => relation.name === ref)) {
+        return ref;
+    }
+    return undefined;
+}
+function addDiscriminator(model, rawClass, state) {
+    const name = rawClass.discriminatorName ?? 'dtype';
+    if (model.fields.some((field) => field.name === name || field.columnName === name)) {
+        return;
+    }
+    const type = (rawClass.discriminatorType ?? 'string').toLowerCase();
+    const isInteger = type === 'integer' || type === 'smallint';
+    if (!isInteger && type !== 'string') {
+        state.warnings.push(`${rawClass.name}: the discriminator column type "${type}" is not supported; a string column was used.`);
+    }
+    model.fields.push({
+        name,
+        columnName: name,
+        type: isInteger ? 'int' : 'string',
+        isPrimaryKey: false,
+        isUnique: false,
+        isNullable: false,
+        isAutoUpdated: false,
+        ...(isInteger ? {} : { maxLength: rawClass.discriminatorLength ?? 255 }),
+    });
+    if (rawClass.discriminatorMapSize > 0) {
+        state.warnings.push(`${rawClass.name}: the discriminator map (${rawClass.discriminatorMapSize} entries) maps values to subclasses and is not preserved; ` +
+            `the discriminator column "${name}" is kept as a plain ${isInteger ? 'integer' : 'string'} column.`);
+    }
+}
+/** Links inverse-side attributes (OneToMany, mappedBy) to the owning relation. */
+function resolveInverseSides(models, inverseSides, modelNames, classes, warnings) {
+    const byName = new Map(models.map((model) => [model.name, model]));
+    for (const { model, inverse } of inverseSides) {
+        const location = `${model.name}.${inverse.property}`;
+        const targetName = modelNames.get(inverse.targetFqn) ??
+            findByShortName(inverse.targetFqn, modelNames);
+        const target = targetName === undefined ? undefined : byName.get(targetName);
+        if (target === undefined) {
+            if (!classes.has(inverse.targetFqn)) {
+                warnings.push(`${location}: the target "${lastNameSegment(inverse.targetFqn)}" is not an entity in the input, so the reverse accessor is not linked.`);
+            }
+            continue;
+        }
+        if (inverse.mappedBy === undefined) {
+            warnings.push(`${location}: this inverse side has no mappedBy, so it could not be linked to "${target.name}".`);
+            continue;
+        }
+        const owner = target.relations.find((relation) => relation.name === inverse.mappedBy);
+        if (owner === undefined) {
+            warnings.push(`${location}: the owning side "${target.name}.${inverse.mappedBy}" was not found; the reverse accessor is not included.`);
+            continue;
+        }
+        if (owner.relatedName === undefined) {
+            owner.relatedName = inverse.property;
+        }
+        else if (owner.relatedName !== inverse.property) {
+            warnings.push(`${location}: the owning side "${target.name}.${inverse.mappedBy}" names its reverse accessor ` +
+                `"${owner.relatedName}"; "${inverse.property}" was ignored.`);
+        }
+    }
+}
+function findByShortName(fqn, modelNames) {
+    const short = lastNameSegment(fqn);
+    const matches = [...modelNames.entries()]
+        .filter(([key]) => lastNameSegment(key) === short)
+        .map(([, name]) => name);
+    return matches.length === 1 ? matches[0] : undefined;
+}
+/** Replaces the fully qualified targets stored on relations with model names, adding stubs for unknown classes. */
+function resolveTargets(models, modelNames, classes, warnings, options) {
+    const known = new Set(models.map((model) => model.name));
+    const stubs = [];
+    for (const model of models) {
+        for (const relation of model.relations) {
+            const fqn = relation.targetModel;
+            const mapped = modelNames.get(fqn) ?? findByShortName(fqn, modelNames);
+            if (mapped !== undefined) {
+                relation.targetModel = mapped;
+                continue;
+            }
+            const shortName = lastNameSegment(fqn);
+            relation.targetModel = shortName;
+            if (known.has(shortName)) {
+                continue;
+            }
+            known.add(shortName);
+            const nonEntity = classes.get(fqn);
+            stubs.push({
+                name: shortName,
+                tableName: underscore(shortName),
+                appLabel: options.appLabel,
+                fields: [
+                    {
+                        name: 'id',
+                        columnName: 'id',
+                        type: 'int',
+                        isPrimaryKey: true,
+                        isUnique: false,
+                        isNullable: false,
+                        isAutoUpdated: false,
+                        default: { kind: 'autoIncrement' },
+                    },
+                ],
+                relations: [],
+                indexes: [],
+            });
+            warnings.push(`${model.name}.${relation.name} references "${shortName}", which is not ${nonEntity === undefined ? 'an entity in the input' : 'marked #[ORM\\Entity]'}. ` +
+                `A stub model with an auto-increment id was generated; replace it with the real definition.`);
+        }
+    }
+    models.push(...stubs);
+}
+/** Joined-table children reuse the key column of their parent. */
+function patchJoinedKeys(models, joinedChildren) {
+    const byName = new Map(models.map((model) => [model.name, model]));
+    for (const { model, parentModel } of joinedChildren) {
+        const parent = byName.get(parentModel);
+        const pointer = model.relations.find((relation) => relation.isPrimaryKey === true);
+        if (parent === undefined || pointer === undefined) {
+            continue;
+        }
+        const key = parent.fields.find((field) => field.isPrimaryKey)?.columnName ??
+            parent.relations.find((relation) => relation.isPrimaryKey === true)?.columnName;
+        if (key !== undefined) {
+            pointer.columnName = key;
+        }
+    }
+}
+/** A referencedColumnName that names the target's own key is the default and is dropped. */
+function normalizeReferencedColumns(models) {
+    const byName = new Map(models.map((model) => [model.name, model]));
+    for (const model of models) {
+        for (const relation of model.relations) {
+            if (relation.toField === undefined) {
+                continue;
+            }
+            const target = byName.get(relation.targetModel);
+            const key = target?.fields.find((field) => field.isPrimaryKey);
+            if (key !== undefined && key.columnName === relation.toField) {
+                delete relation.toField;
+            }
+        }
+    }
+}
+/** Keeps only enums that a converted field refers to. */
+function pruneEnums(state, models) {
+    const used = new Set(models.flatMap((model) => model.fields.flatMap((field) => field.enumName === undefined ? [] : [field.enumName])));
+    return [...state.enums.values()]
+        .filter((info) => info.backing === 'string' && used.has(info.name))
+        .map((info) => ({
+        name: info.name,
+        values: info.values,
+    }));
+}
+//# sourceMappingURL=doctrine.js.map