ormbridge 0.0.0-stage → 0.3.0

package/dist/parsers/gorm.js

@@ -0,0 +1,1857 @@
+import { singularize, toCamelCase, toSnakeCase } from '../naming.js';
+import { describeThrown, err, ok } from '../result.js';
+import { defaultImportName, describeGoType, getGoParser, lookupStructTag, readGoFile, } from './goSyntax.js';
+// ---------------------------------------------------------------------------
+// GORM naming conventions (gorm.io/gorm/schema NamingStrategy)
+// ---------------------------------------------------------------------------
+/** Initialisms GORM keeps together when it converts a Go name to snake_case, in GORM's priority order. */
+const COMMON_INITIALISMS = [
+    'API',
+    'ASCII',
+    'CPU',
+    'CSS',
+    'DNS',
+    'EOF',
+    'GUID',
+    'HTML',
+    'HTTP',
+    'HTTPS',
+    'ID',
+    'IP',
+    'JSON',
+    'LHS',
+    'QPS',
+    'RAM',
+    'RHS',
+    'RPC',
+    'SLA',
+    'SMTP',
+    'SSH',
+    'TLS',
+    'TTL',
+    'UID',
+    'UI',
+    'UUID',
+    'URI',
+    'URL',
+    'UTF8',
+    'VM',
+    'XML',
+    'XSRF',
+    'XSS',
+];
+const INITIALISM_PATTERN = new RegExp(COMMON_INITIALISMS.join('|'), 'g');
+function isUpperAscii(character) {
+    return character !== undefined && character >= 'A' && character <= 'Z';
+}
+function isDigit(character) {
+    return character !== undefined && character >= '0' && character <= '9';
+}
+/** GORM's default column name for a Go field name: `PublicID` becomes `public_id`. */
+export function gormColumnName(goName) {
+    if (goName === '') {
+        return '';
+    }
+    const value = goName.replace(INITIALISM_PATTERN, (initialism) => initialism.charAt(0) + initialism.slice(1).toLowerCase());
+    let result = '';
+    let lastIsUpper = false;
+    let currentIsUpper = isUpperAscii(value.charAt(0));
+    for (let index = 0; index < value.length - 1; index += 1) {
+        const character = value.charAt(index);
+        const nextIsUpper = isUpperAscii(value.charAt(index + 1));
+        const nextIsDigit = isDigit(value.charAt(index + 1));
+        if (currentIsUpper) {
+            if (lastIsUpper && (nextIsUpper || nextIsDigit)) {
+                result += character.toLowerCase();
+            }
+            else {
+                if (index > 0 &&
+                    value.charAt(index - 1) !== '_' &&
+                    value.charAt(index + 1) !== '_') {
+                    result += '_';
+                }
+                result += character.toLowerCase();
+            }
+        }
+        else {
+            result += character;
+        }
+        lastIsUpper = currentIsUpper;
+        currentIsUpper = nextIsUpper;
+    }
+    const lastCharacter = value.charAt(value.length - 1);
+    if (currentIsUpper) {
+        if (!lastIsUpper && value.length > 1) {
+            result += '_';
+        }
+        result += lastCharacter.toLowerCase();
+    }
+    else {
+        result += lastCharacter;
+    }
+    return result;
+}
+const UNCOUNTABLE_WORDS = [
+    'equipment',
+    'information',
+    'rice',
+    'money',
+    'species',
+    'series',
+    'fish',
+    'sheep',
+    'jeans',
+    'police',
+];
+const IRREGULAR_PLURALS = [
+    ['person', 'people'],
+    ['man', 'men'],
+    ['child', 'children'],
+    ['sex', 'sexes'],
+    ['move', 'moves'],
+    ['mombie', 'mombies'],
+];
+/** The plural rules of github.com/jinzhu/inflection (which GORM uses), in the order they are tried. */
+const PLURAL_RULES = [
+    [/(quiz)$/, '$1zes'],
+    [/^(oxen)$/, '$1'],
+    [/^(ox)$/, '$1en'],
+    [/^(m|l)ice$/, '$1ice'],
+    [/^(m|l)ouse$/, '$1ice'],
+    [/(matr|vert|ind)(?:ix|ex)$/, '$1ices'],
+    [/(x|ch|ss|sh)$/, '$1es'],
+    [/([^aeiouy]|qu)y$/, '$1ies'],
+    [/(hive)$/, '$1s'],
+    [/(?:([^f])fe|([lr])f)$/, '$1$2ves'],
+    [/sis$/, 'ses'],
+    [/([ti])a$/, '$1a'],
+    [/([ti])um$/, '$1a'],
+    [/(buffal|tomat)o$/, '$1oes'],
+    [/(bu)s$/, '$1ses'],
+    [/(alias|status)$/, '$1es'],
+    [/(octop|vir)i$/, '$1i'],
+    [/(octop|vir)us$/, '$1i'],
+    [/^(ax|test)is$/, '$1es'],
+    [/s$/, 's'],
+    [/([a-z])$/, '$1s'],
+];
+function pluralize(word) {
+    if (UNCOUNTABLE_WORDS.includes(word.toLowerCase())) {
+        return word;
+    }
+    for (const [singular, plural] of IRREGULAR_PLURALS) {
+        if (word.endsWith(singular)) {
+            return word.slice(0, word.length - singular.length) + plural;
+        }
+    }
+    for (const [pattern, replacement] of PLURAL_RULES) {
+        if (pattern.test(word)) {
+            return word.replace(pattern, replacement);
+        }
+    }
+    return word;
+}
+/** GORM's default table name for a struct: `PostTag` becomes `post_tags`. */
+export function gormTableName(structName) {
+    return pluralize(gormColumnName(structName));
+}
+function upperFirst(text) {
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}
+/** The IR name of a Go field: `PublicID` becomes `publicId`. */
+function irFieldName(goName) {
+    return toCamelCase(goName);
+}
+// ---------------------------------------------------------------------------
+// Static tables
+// ---------------------------------------------------------------------------
+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\(\)|\(uuid\(\)\)|newid\(\)|newsequentialid\(\)|sys_guid\(\))$/i;
+/** Library types by `<package>.<Name>`, where the package is the import's last path element. */
+const KNOWN_TYPES = {
+    'time.Time': { type: 'dateTime', goKind: 'time' },
+    'time.Duration': { type: 'bigInt', goKind: 'int' },
+    'gorm.DeletedAt': { type: 'dateTime', goKind: 'time', nullable: true },
+    'sql.NullString': { type: 'text', goKind: 'string', nullable: true },
+    'sql.NullInt64': { type: 'bigInt', goKind: 'int', nullable: true },
+    'sql.NullInt32': { type: 'int', goKind: 'int', nullable: true },
+    'sql.NullInt16': { type: 'int', goKind: 'int', nullable: true },
+    'sql.NullByte': { type: 'int', goKind: 'int', nullable: true },
+    'sql.NullFloat64': { type: 'float', goKind: 'float', nullable: true },
+    'sql.NullBool': { type: 'boolean', goKind: 'bool', nullable: true },
+    'sql.NullTime': { type: 'dateTime', goKind: 'time', nullable: true },
+    'sql.RawBytes': { type: 'bytes', goKind: 'other' },
+    'uuid.UUID': { type: 'uuid', goKind: 'other' },
+    'uuid.NullUUID': { type: 'uuid', goKind: 'other', nullable: true },
+    'decimal.Decimal': { type: 'decimal', goKind: 'float' },
+    'decimal.NullDecimal': { type: 'decimal', goKind: 'float', nullable: true },
+    'datatypes.JSON': { type: 'json', goKind: 'other' },
+    'datatypes.JSONMap': { type: 'json', goKind: 'other' },
+    'datatypes.Date': { type: 'date', goKind: 'time' },
+    'datatypes.Time': { type: 'time', goKind: 'time' },
+    'datatypes.UUID': { type: 'uuid', goKind: 'other' },
+    'datatypes.BinUUID': { type: 'uuid', goKind: 'other' },
+    'json.RawMessage': { type: 'json', goKind: 'other' },
+    'net.IP': { type: 'ipAddress', goKind: 'other' },
+    'netip.Addr': { type: 'ipAddress', goKind: 'other' },
+    'pq.StringArray': { type: 'text', goKind: 'string', arrayDepth: 1 },
+    'pq.Int64Array': { type: 'bigInt', goKind: 'int', arrayDepth: 1 },
+    'pq.Int32Array': { type: 'int', goKind: 'int', arrayDepth: 1 },
+    'pq.Float64Array': { type: 'float', goKind: 'float', arrayDepth: 1 },
+    'pq.BoolArray': { type: 'boolean', goKind: 'bool', arrayDepth: 1 },
+    'pq.ByteaArray': { type: 'bytes', goKind: 'other', arrayDepth: 1 },
+    'null.String': { type: 'text', goKind: 'string', nullable: true },
+    'null.Int': { type: 'bigInt', goKind: 'int', nullable: true },
+    'null.Int32': { type: 'int', goKind: 'int', nullable: true },
+    'null.Float': { type: 'float', goKind: 'float', nullable: true },
+    'null.Bool': { type: 'boolean', goKind: 'bool', nullable: true },
+    'null.Time': { type: 'dateTime', goKind: 'time', nullable: true },
+};
+/** Generic library types whose single type argument is the stored value. */
+const GENERIC_JSON_TYPES = new Set([
+    'datatypes.JSONType',
+    'datatypes.JSONSlice',
+]);
+const INTEGER_KINDS = {
+    int: { bits: 64, unsigned: false },
+    int8: { bits: 8, unsigned: false },
+    int16: { bits: 16, unsigned: false },
+    int32: { bits: 32, unsigned: false },
+    int64: { bits: 64, unsigned: false },
+    rune: { bits: 32, unsigned: false },
+    uint: { bits: 64, unsigned: true },
+    uint8: { bits: 8, unsigned: true },
+    byte: { bits: 8, unsigned: true },
+    uint16: { bits: 16, unsigned: true },
+    uint32: { bits: 32, unsigned: true },
+    uint64: { bits: 64, unsigned: true },
+    uintptr: { bits: 64, unsigned: true },
+};
+/** An integer column is `int` up to 32 bits and `bigInt` above; unsigned types need one more bit, as in GORM's PostgreSQL dialect. */
+function integerType(bits, unsigned) {
+    return bits + (unsigned ? 1 : 0) <= 32 ? 'int' : 'bigInt';
+}
+/**
+ * Splits a tag into its settings the way GORM's `ParseTagSetting` does: `;` (or `separator`)
+ * separates settings, `\;` escapes it, and the first `:` separates key from value.
+ */
+function parseSettings(text, separator) {
+    const entries = [];
+    const names = text.split(separator);
+    for (let position = 0; position < names.length; position += 1) {
+        let current = names[position] ?? '';
+        while (current.endsWith('\\') && position + 1 < names.length) {
+            position += 1;
+            current = current.slice(0, -1) + separator + (names[position] ?? '');
+        }
+        const parts = current.split(':');
+        const key = (parts[0] ?? '').trim().toUpperCase();
+        if (parts.length >= 2) {
+            entries.push({ key, value: parts.slice(1).join(':') });
+        }
+        else if (key !== '') {
+            entries.push({ key, value: key });
+        }
+    }
+    return entries;
+}
+function gormTagOf(field) {
+    return field.tag === undefined
+        ? ''
+        : (lookupStructTag(field.tag, 'gorm') ?? '');
+}
+/** The last value given for any of the keys (GORM keeps the last duplicate). */
+function entryValue(entries, ...keys) {
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (entry !== undefined && keys.includes(entry.key)) {
+            return entry.value;
+        }
+    }
+    return undefined;
+}
+/** True/false when a flag setting is present (`false` turns it off), undefined when absent. */
+function entryFlag(entries, ...keys) {
+    const value = entryValue(entries, ...keys);
+    if (value === undefined) {
+        return undefined;
+    }
+    return value !== '' && value.toLowerCase() !== 'false';
+}
+function entryNumber(entries, key) {
+    const value = entryValue(entries, key);
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function splitList(value) {
+    return value === undefined
+        ? []
+        : value
+            .split(',')
+            .map((item) => item.trim())
+            .filter((item) => item !== '');
+}
+/** `gorm:"-"`, `-:all` and `-:migration` leave the field out of the schema. */
+function isIgnored(entries) {
+    const value = entryValue(entries, '-');
+    return (value !== undefined &&
+        ['-', 'all', 'migration'].includes(value.toLowerCase()));
+}
+/** The `gorm.Model` struct that GORM provides for embedding. */
+const GORM_MODEL = {
+    name: 'Model',
+    path: 'gorm.io/gorm',
+    fields: [
+        {
+            name: 'ID',
+            type: { kind: 'name', name: 'uint', args: [] },
+            tag: 'gorm:"primarykey"',
+        },
+        {
+            name: 'CreatedAt',
+            type: {
+                kind: 'name',
+                name: 'Time',
+                qualifier: 'time',
+                importPath: 'time',
+                args: [],
+            },
+        },
+        {
+            name: 'UpdatedAt',
+            type: {
+                kind: 'name',
+                name: 'Time',
+                qualifier: 'time',
+                importPath: 'time',
+                args: [],
+            },
+        },
+        {
+            name: 'DeletedAt',
+            type: {
+                kind: 'name',
+                name: 'DeletedAt',
+                qualifier: 'gorm',
+                importPath: 'gorm.io/gorm',
+                args: [],
+            },
+            tag: 'gorm:"index"',
+        },
+    ],
+};
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+/** Parses GORM model structs (Go source with `gorm:"..."` tags) into the shared IR using tree-sitter. */
+export async function parseGorm(sources, options) {
+    const parserResult = await getGoParser();
+    if (!parserResult.ok) {
+        return parserResult;
+    }
+    try {
+        return readGorm(parserResult.value, sources, options);
+    }
+    catch (thrown) {
+        return err('PARSE_FAILED', `Failed to read GORM models from ${sources.map((source) => source.path).join(', ')}. ` +
+            `Underlying error: ${describeThrown(thrown)}`);
+    }
+}
+function readGorm(parser, sources, options) {
+    const warnings = [];
+    const ctx = {
+        warnings,
+        structs: new Map(),
+        namedTypes: new Map(),
+        enums: new Map(),
+        methods: new Map(),
+        consts: new Map(),
+        models: new Set(),
+    };
+    const structOrder = [];
+    const constList = [];
+    for (const source of sources) {
+        // The Go grammar needs the final statement to end in a newline, which Go inserts as a semicolon.
+        const tree = parser.parse(source.text.endsWith('\n') ? source.text : `${source.text}\n`);
+        const file = readGoFile(tree.rootNode, source.path);
+        if (file.hasErrors) {
+            warnings.push(`${source.path}: the file contains Go syntax errors; some structs or fields may be missing from the output.`);
+        }
+        for (const goStruct of file.structs) {
+            if (ctx.structs.has(goStruct.name)) {
+                warnings.push(`Duplicate struct name "${goStruct.name}" (${source.path}); only the first definition was converted.`);
+                continue;
+            }
+            ctx.structs.set(goStruct.name, goStruct);
+            structOrder.push(goStruct);
+        }
+        for (const namedType of file.namedTypes) {
+            if (!ctx.namedTypes.has(namedType.name)) {
+                ctx.namedTypes.set(namedType.name, namedType);
+            }
+        }
+        for (const goConst of file.consts) {
+            constList.push(goConst);
+            if (!ctx.consts.has(goConst.name)) {
+                ctx.consts.set(goConst.name, goConst);
+            }
+        }
+        for (const method of file.methods) {
+            const byName = ctx.methods.get(method.receiver) ?? new Map();
+            byName.set(method.name, method);
+            ctx.methods.set(method.receiver, byName);
+        }
+    }
+    buildEnums(ctx, constList);
+    ctx.models = detectModels(structOrder, ctx);
+    const rawModels = structOrder
+        .filter((goStruct) => ctx.models.has(goStruct.name))
+        .map((goStruct) => buildRawModel(goStruct, ctx));
+    if (rawModels.length === 0) {
+        const checkedPaths = sources
+            .map((source) => source.path)
+            .join(', ');
+        return err('NO_MODELS_FOUND', `No GORM models were found in: ${checkedPaths}. A model is a struct that embeds gorm.Model, has a field with a ` +
+            `gorm:"..." tag, has a field called ID, has a TableName() method, or is the target of an association from another model.`);
+    }
+    const schema = buildSchema(rawModels, ctx, options);
+    return ok(schema);
+}
+// ---------------------------------------------------------------------------
+// Enums
+// ---------------------------------------------------------------------------
+/** `StatusDraft` of type `Status` is the enum member `Draft`. */
+function enumMemberName(constName, typeName) {
+    if (constName.startsWith(typeName) && constName.length > typeName.length) {
+        const rest = constName.slice(typeName.length).replace(/^_/, '');
+        if (/^[A-Z0-9]/.test(rest)) {
+            return rest;
+        }
+    }
+    return constName;
+}
+/** Named string and integer types with typed constants become enums. */
+function buildEnums(ctx, constList) {
+    for (const namedType of ctx.namedTypes.values()) {
+        const underlying = namedType.underlying;
+        if (underlying.kind !== 'name' || underlying.qualifier !== undefined) {
+            continue;
+        }
+        const members = constList.filter((candidate) => candidate.typeName === namedType.name && candidate.value !== undefined);
+        if (members.length === 0) {
+            continue;
+        }
+        if (underlying.name === 'string') {
+            const values = [];
+            for (const member of members) {
+                if (member.value?.kind === 'string') {
+                    values.push({
+                        name: enumMemberName(member.name, namedType.name),
+                        dbValue: member.value.value,
+                    });
+                }
+            }
+            if (values.length > 0) {
+                ctx.enums.set(namedType.name, {
+                    name: namedType.name,
+                    backing: 'string',
+                    values,
+                });
+            }
+        }
+        else if (underlying.name in INTEGER_KINDS) {
+            ctx.enums.set(namedType.name, {
+                name: namedType.name,
+                backing: 'int',
+                values: [],
+            });
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Which structs are models
+// ---------------------------------------------------------------------------
+/** The struct an embedded field refers to, including GORM's own `gorm.Model`. */
+function embeddedStruct(type, ctx) {
+    let current = type;
+    while (current.kind === 'pointer') {
+        current = current.elem;
+    }
+    if (current.kind !== 'name') {
+        return undefined;
+    }
+    if (current.name === 'Model' && libraryName(current) === 'gorm') {
+        return GORM_MODEL;
+    }
+    return ctx.structs.get(current.name);
+}
+/** The name of the package a qualified type comes from: the last import path element, or the qualifier as written. */
+function libraryName(type) {
+    if (type.kind !== 'name' || type.qualifier === undefined) {
+        return '';
+    }
+    return type.importPath === undefined
+        ? type.qualifier
+        : defaultImportName(type.importPath);
+}
+function isEmbeddedField(field, entries) {
+    return field.name === undefined || entryFlag(entries, 'EMBEDDED') === true;
+}
+/** Every field of a struct including those promoted from embedded structs. */
+function promotedFields(goStruct, ctx, visited = new Set()) {
+    if (visited.has(goStruct.name)) {
+        return [];
+    }
+    visited.add(goStruct.name);
+    const fields = [];
+    for (const field of goStruct.fields) {
+        const entries = parseSettings(gormTagOf(field), ';');
+        if (isEmbeddedField(field, entries)) {
+            const inner = embeddedStruct(field.type, ctx);
+            if (inner !== undefined) {
+                fields.push(...promotedFields(inner, ctx, visited));
+            }
+        }
+        else {
+            fields.push(field);
+        }
+    }
+    return fields;
+}
+function hasGormMarkers(goStruct, ctx, visited = new Set()) {
+    if (visited.has(goStruct.name)) {
+        return false;
+    }
+    visited.add(goStruct.name);
+    for (const field of goStruct.fields) {
+        const entries = parseSettings(gormTagOf(field), ';');
+        if (entries.length > 0 && !isIgnored(entries)) {
+            return true;
+        }
+        if (field.name === undefined) {
+            const inner = embeddedStruct(field.type, ctx);
+            if (inner === GORM_MODEL) {
+                return true;
+            }
+            if (inner !== undefined && hasGormMarkers(inner, ctx, visited)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/** GORM treats a field called ID as the primary key, so a struct that has one is shaped like a model. */
+function hasIdField(goStruct, ctx) {
+    return promotedFields(goStruct, ctx).some((field) => field.name === 'ID' || field.name === 'Id');
+}
+function implementsScanner(name, ctx) {
+    const methods = ctx.methods.get(name);
+    return methods?.has('Scan') === true && methods.has('Value');
+}
+/** The struct a field's type refers to through pointers and slices, when it is one of the input structs. */
+function referencedStruct(type, ctx) {
+    let current = type;
+    while (current.kind === 'pointer' ||
+        current.kind === 'slice' ||
+        current.kind === 'array') {
+        current = current.elem;
+    }
+    if (current.kind !== 'name') {
+        return undefined;
+    }
+    if (current.qualifier !== undefined &&
+        `${libraryName(current)}.${current.name}` in KNOWN_TYPES) {
+        return undefined;
+    }
+    const found = ctx.structs.get(current.name);
+    return found === undefined || implementsScanner(found.name, ctx)
+        ? undefined
+        : found;
+}
+/**
+ * GORM has no marker for a model, so a struct counts as one when it embeds gorm.Model, has a
+ * `gorm:"..."` tag, has a field called ID, has a TableName() method, or is the target of an
+ * association from a model. A struct that is only embedded in others (a shared base) is not a
+ * model of its own.
+ */
+function detectModels(structs, ctx) {
+    const embeddedNames = new Set();
+    for (const goStruct of structs) {
+        for (const field of goStruct.fields) {
+            const entries = parseSettings(gormTagOf(field), ';');
+            if (isEmbeddedField(field, entries)) {
+                const inner = embeddedStruct(field.type, ctx);
+                if (inner !== undefined) {
+                    embeddedNames.add(inner.name);
+                }
+            }
+        }
+    }
+    const models = new Set();
+    for (const goStruct of structs) {
+        const hasTableName = ctx.methods.get(goStruct.name)?.has('TableName') === true;
+        const isMarked = hasTableName ||
+            hasIdField(goStruct, ctx) ||
+            hasGormMarkers(goStruct, ctx);
+        if (isMarked && (hasTableName || !embeddedNames.has(goStruct.name))) {
+            models.add(goStruct.name);
+        }
+    }
+    // Association targets are models too, even without any marker of their own.
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const name of [...models]) {
+            const goStruct = ctx.structs.get(name);
+            if (goStruct === undefined) {
+                continue;
+            }
+            for (const field of promotedFields(goStruct, ctx)) {
+                const entries = parseSettings(gormTagOf(field), ';');
+                if (field.name === undefined ||
+                    isIgnored(entries) ||
+                    entryValue(entries, 'TYPE', 'SERIALIZER') !== undefined) {
+                    continue;
+                }
+                const target = referencedStruct(field.type, ctx);
+                if (target !== undefined && !models.has(target.name)) {
+                    models.add(target.name);
+                    changed = true;
+                }
+            }
+        }
+    }
+    return models;
+}
+// ---------------------------------------------------------------------------
+// Go types to column types
+// ---------------------------------------------------------------------------
+function classifyType(type, ctx, depth = 0) {
+    let nullable = false;
+    let current = type;
+    while (current.kind === 'pointer') {
+        nullable = true;
+        current = current.elem;
+    }
+    switch (current.kind) {
+        case 'slice':
+        case 'array': {
+            let element = current.elem;
+            while (element.kind === 'pointer') {
+                element = element.elem;
+            }
+            if (element.kind === 'name' &&
+                element.qualifier === undefined &&
+                (element.name === 'byte' || element.name === 'uint8')) {
+                return { kind: 'scalar', type: 'bytes', goKind: 'other', nullable };
+            }
+            const inner = classifyType(current.elem, ctx, depth + 1);
+            if (inner.kind === 'association') {
+                return { ...inner, many: true };
+            }
+            if (inner.kind === 'skip') {
+                return inner;
+            }
+            return {
+                ...inner,
+                nullable,
+                arrayDepth: (inner.arrayDepth ?? 0) + 1,
+                needsHint: 'slice',
+            };
+        }
+        case 'map':
+            return {
+                kind: 'scalar',
+                type: 'json',
+                goKind: 'other',
+                nullable,
+                needsHint: 'map',
+            };
+        case 'struct':
+            return {
+                kind: 'skip',
+                message: 'an inline struct type has no column mapping (declare a named struct and embed it)',
+            };
+        case 'other':
+            return { kind: 'skip' };
+        case 'name':
+            return classifyNamed(current, nullable, ctx, depth);
+        default:
+            return { kind: 'skip' };
+    }
+}
+function classifyNamed(type, nullable, ctx, depth) {
+    const qualified = type.qualifier !== undefined && type.qualifier !== '';
+    if (qualified) {
+        const key = `${libraryName(type)}.${type.name}`;
+        const known = KNOWN_TYPES[key];
+        if (known !== undefined) {
+            return {
+                kind: 'scalar',
+                type: known.type,
+                goKind: known.goKind,
+                nullable: nullable || known.nullable === true,
+                ...(known.arrayDepth === undefined
+                    ? {}
+                    : { arrayDepth: known.arrayDepth }),
+                ...(key === 'gorm.DeletedAt' ? { isSoftDelete: true } : {}),
+            };
+        }
+        if (GENERIC_JSON_TYPES.has(key)) {
+            return { kind: 'scalar', type: 'json', goKind: 'other', nullable };
+        }
+        if (key === 'sql.Null') {
+            const argument = type.args[0];
+            const inner = argument === undefined
+                ? { kind: 'skip' }
+                : classifyType(argument, ctx, depth + 1);
+            return inner.kind === 'scalar' ? { ...inner, nullable: true } : inner;
+        }
+        // A type from another package of the same project (models.Post) is looked up by name.
+        if (!ctx.structs.has(type.name) && !ctx.namedTypes.has(type.name)) {
+            return {
+                kind: 'scalar',
+                type: 'unsupported',
+                goKind: 'other',
+                nullable,
+                unsupportedType: describeGoType(type),
+            };
+        }
+    }
+    if (!qualified) {
+        if (type.name === 'string') {
+            return { kind: 'scalar', type: 'text', goKind: 'string', nullable };
+        }
+        if (type.name === 'bool') {
+            return { kind: 'scalar', type: 'boolean', goKind: 'bool', nullable };
+        }
+        if (type.name === 'float32' || type.name === 'float64') {
+            return { kind: 'scalar', type: 'float', goKind: 'float', nullable };
+        }
+        const integer = INTEGER_KINDS[type.name];
+        if (integer !== undefined) {
+            return {
+                kind: 'scalar',
+                type: integerType(integer.bits, integer.unsigned),
+                goKind: integer.unsigned ? 'uint' : 'int',
+                nullable,
+                bits: integer.bits,
+                unsigned: integer.unsigned,
+            };
+        }
+        if (type.name === 'any' || type.name === 'error') {
+            return { kind: 'skip' };
+        }
+    }
+    const namedType = ctx.namedTypes.get(type.name);
+    if (namedType !== undefined && depth < 8) {
+        const underlying = classifyType(namedType.underlying, ctx, depth + 1);
+        if (underlying.kind !== 'scalar') {
+            return underlying;
+        }
+        const enumInfo = ctx.enums.get(type.name);
+        return {
+            ...underlying,
+            nullable: nullable || underlying.nullable,
+            ...(enumInfo?.backing === 'string' ? { enumInfo } : {}),
+            ...(enumInfo?.backing === 'int' ? { intEnumName: enumInfo.name } : {}),
+        };
+    }
+    const goStruct = ctx.structs.get(type.name);
+    if (goStruct !== undefined) {
+        if (implementsScanner(goStruct.name, ctx)) {
+            return {
+                kind: 'scalar',
+                type: 'unsupported',
+                goKind: 'other',
+                nullable,
+                unsupportedType: goStruct.name,
+                needsHint: 'scanner',
+            };
+        }
+        return { kind: 'association', target: goStruct.name, many: false };
+    }
+    return {
+        kind: 'scalar',
+        type: 'unsupported',
+        goKind: 'other',
+        nullable,
+        unsupportedType: describeGoType(type),
+    };
+}
+/** Maps a `type:` tag (a SQL type such as `varchar(100)` or `numeric(10,2)`) to a column type. */
+function readDbType(raw) {
+    let text = raw.trim().toLowerCase().replace(/\s+/g, ' ');
+    let arrayDepth = 0;
+    while (text.endsWith('[]')) {
+        arrayDepth += 1;
+        text = text.slice(0, -2).trim();
+    }
+    const argumentMatch = text.match(/\(([^)]*)\)/);
+    const args = (argumentMatch?.[1] ?? '')
+        .split(',')
+        .map((item) => item.trim())
+        .filter((item) => item !== '');
+    const base = text
+        .replace(/\([^)]*\)/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    const first = args[0] !== undefined && /^\d+$/.test(args[0])
+        ? Number.parseInt(args[0], 10)
+        : undefined;
+    const second = args[1] !== undefined && /^\d+$/.test(args[1])
+        ? Number.parseInt(args[1], 10)
+        : undefined;
+    const withArray = (result) => arrayDepth > 0 ? { ...result, arrayDepth } : result;
+    if (/^(varchar|character varying|nvarchar|varchar2|nvarchar2|char|character|nchar|bpchar)\b/.test(base)) {
+        return withArray({
+            type: 'string',
+            ...(first === undefined ? {} : { maxLength: first }),
+        });
+    }
+    if (/^(text|tinytext|mediumtext|longtext|ntext|clob|citext)$/.test(base)) {
+        return withArray({ type: 'text' });
+    }
+    if (/^(bool|boolean)$/.test(base) || (base === 'tinyint' && first === 1)) {
+        return withArray({ type: 'boolean' });
+    }
+    if (/^bit$/.test(base) && (first === undefined || first === 1)) {
+        return withArray({ type: 'boolean' });
+    }
+    if (/^(bigint|int8|bigserial|serial8)( unsigned)?$/.test(base)) {
+        return withArray({
+            type: 'bigInt',
+            ...(base.includes('serial') ? { isSerial: true } : {}),
+        });
+    }
+    if (/^(smallint|int2|tinyint|mediumint|integer|int|int4|serial|serial4|smallserial|serial2)( unsigned)?$/.test(base)) {
+        return withArray({
+            type: 'int',
+            ...(base.includes('serial') ? { isSerial: true } : {}),
+        });
+    }
+    if (/^(numeric|decimal|dec|number|money)$/.test(base)) {
+        return withArray({
+            type: 'decimal',
+            ...(first === undefined ? {} : { maxDigits: first }),
+            ...(second === undefined ? {} : { decimalPlaces: second }),
+        });
+    }
+    if (/^(real|float|float4|float8|double precision|double|binary_float|binary_double)$/.test(base)) {
+        return withArray({ type: 'float' });
+    }
+    if (/^(timestamp|timestamptz|datetime|datetime2|smalldatetime|datetimeoffset)\b/.test(base)) {
+        return withArray({ type: 'dateTime' });
+    }
+    if (base === 'date') {
+        return withArray({ type: 'date' });
+    }
+    if (/^time\b/.test(base) || base === 'timetz') {
+        return withArray({ type: 'time' });
+    }
+    if (base === 'interval') {
+        return withArray({ type: 'duration' });
+    }
+    if (base === 'uuid' || base === 'uniqueidentifier') {
+        return withArray({ type: 'uuid' });
+    }
+    if (base === 'json' || base === 'jsonb') {
+        return withArray({ type: 'json' });
+    }
+    if (/^(bytea|blob|tinyblob|mediumblob|longblob|varbinary|binary|image|raw)$/.test(base)) {
+        return withArray({ type: 'bytes' });
+    }
+    if (base === 'inet' || base === 'cidr') {
+        return withArray({ type: 'ipAddress' });
+    }
+    if (base === 'hstore') {
+        return withArray({ type: 'hstore' });
+    }
+    return withArray({ type: 'unsupported', unsupportedType: raw.trim() });
+}
+// ---------------------------------------------------------------------------
+// Columns
+// ---------------------------------------------------------------------------
+function parseIndexTags(tagText) {
+    const indexTags = [];
+    for (const piece of tagText.split(';')) {
+        if (piece === '') {
+            continue;
+        }
+        const parts = piece.split(':');
+        const key = (parts[0] ?? '').trim().toUpperCase();
+        if (key !== 'INDEX' && key !== 'UNIQUEINDEX') {
+            continue;
+        }
+        const tag = parts.slice(1).join(':');
+        const comma = tag.indexOf(',');
+        const name = comma === -1 ? tag : tag.slice(0, comma);
+        const settings = parseSettings(comma === -1 ? '' : tag.slice(comma + 1), ',');
+        const className = (entryValue(settings, 'CLASS') ?? '').toUpperCase();
+        const priority = entryNumber(settings, 'PRIORITY') ?? 10;
+        const sort = (entryValue(settings, 'SORT') ?? '').toLowerCase();
+        const method = entryValue(settings, 'TYPE') ?? '';
+        const composite = entryValue(settings, 'COMPOSITE');
+        indexTags.push({
+            isUnique: key === 'UNIQUEINDEX' ||
+                entryValue(settings, 'UNIQUE') !== undefined ||
+                className === 'UNIQUE',
+            name: name === '' ? undefined : name,
+            composite,
+            priority,
+            sort: sort === 'desc' ? 'desc' : sort === 'asc' ? 'asc' : undefined,
+            length: entryNumber(settings, 'LENGTH'),
+            kind: className === 'FULLTEXT' ? 'fulltext' : undefined,
+            method: method === '' ? undefined : method,
+            hasWhere: entryValue(settings, 'WHERE') !== undefined,
+            hasExpression: entryValue(settings, 'EXPRESSION') !== undefined,
+        });
+    }
+    return indexTags;
+}
+const INDEX_METHODS = {
+    btree: 'BTree',
+    hash: 'Hash',
+    gin: 'Gin',
+    gist: 'Gist',
+    spgist: 'SpGist',
+    brin: 'Brin',
+};
+function stripQuotes(value) {
+    const trimmed = value.trim();
+    if (trimmed.length >= 2 &&
+        ((trimmed.startsWith("'") && trimmed.endsWith("'")) ||
+            (trimmed.startsWith('"') && trimmed.endsWith('"')))) {
+        return trimmed.slice(1, -1).replace(/''/g, "'");
+    }
+    return trimmed;
+}
+function isQuoted(value) {
+    return stripQuotes(value) !== value.trim();
+}
+/** Converts the value of a `default:` tag. Returns undefined when the column has no default. */
+function convertDefault(raw, field, enumInfo, location, ctx) {
+    const trimmed = raw.trim();
+    if (trimmed === '' || trimmed.toLowerCase() === 'null' || trimmed === '(-)') {
+        return undefined;
+    }
+    if (enumInfo !== undefined) {
+        const text = stripQuotes(trimmed);
+        const member = enumInfo.values.find((candidate) => candidate.dbValue === text);
+        if (member !== undefined) {
+            return { kind: 'enumValue', value: member.name };
+        }
+        ctx.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 };
+    }
+    // A function call (or any expression with parentheses) is passed to the database as written.
+    if (!isQuoted(trimmed) && trimmed.includes('(') && trimmed.includes(')')) {
+        if (UUID_SQL.test(trimmed)) {
+            return { kind: 'uuid' };
+        }
+        if (NOW_SQL.test(trimmed)) {
+            return { kind: 'now' };
+        }
+        return { kind: 'dbExpression', expression: trimmed };
+    }
+    const unquoted = stripQuotes(trimmed);
+    switch (field.type) {
+        case 'boolean':
+            if (/^(1|t|true)$/i.test(unquoted)) {
+                return { kind: 'literal', value: true };
+            }
+            if (/^(0|f|false)$/i.test(unquoted)) {
+                return { kind: 'literal', value: false };
+            }
+            break;
+        case 'int':
+        case 'bigInt':
+        case 'float':
+        case 'decimal':
+            if (/^-?\d+(\.\d+)?$/.test(unquoted)) {
+                return { kind: 'literal', value: Number(unquoted) };
+            }
+            return { kind: 'dbExpression', expression: trimmed };
+        case 'dateTime':
+        case 'date':
+        case 'time':
+            if (NOW_SQL.test(unquoted) || /^current_(date|time)$/i.test(unquoted)) {
+                return { kind: 'now' };
+            }
+            break;
+        case 'uuid':
+            if (UUID_SQL.test(unquoted)) {
+                return { kind: 'uuid' };
+            }
+            break;
+        default:
+            break;
+    }
+    return { kind: 'literal', value: unquoted };
+}
+/** Builds the column for a scalar field, or undefined when the field is not stored. */
+function buildColumn(structName, goField, entries, scalar, scope) {
+    const ctx = scope.ctx;
+    const location = `${structName}.${goField.name}`;
+    const warnings = ctx.warnings;
+    let type = scalar.type;
+    let maxLength;
+    let maxDigits;
+    let decimalPlaces;
+    let arrayDepth = scalar.arrayDepth;
+    let unsupportedType = scalar.unsupportedType;
+    let enumInfo = scalar.enumInfo;
+    let isSerial = false;
+    let goKind = scalar.goKind;
+    const typeTag = entryValue(entries, 'TYPE');
+    const serializer = entryValue(entries, 'SERIALIZER')?.toLowerCase();
+    if (typeTag !== undefined) {
+        const dbType = readDbType(typeTag);
+        type = dbType.type;
+        maxLength = dbType.maxLength;
+        maxDigits = dbType.maxDigits;
+        decimalPlaces = dbType.decimalPlaces;
+        arrayDepth = dbType.arrayDepth;
+        unsupportedType = dbType.unsupportedType;
+        isSerial = dbType.isSerial === true;
+        if (dbType.type === 'unsupported') {
+            warnings.push(`${location}: the column type "${typeTag}" has no equivalent in the shared model; it was kept as an unsupported column.`);
+        }
+        if (enumInfo !== undefined && type !== 'string' && type !== 'text') {
+            warnings.push(`${location}: the column type "${typeTag}" is not a string type, so the enum "${enumInfo.name}" was not applied.`);
+            enumInfo = undefined;
+        }
+    }
+    else if (serializer !== undefined) {
+        arrayDepth = undefined;
+        unsupportedType = undefined;
+        enumInfo = undefined;
+        if (serializer === 'json') {
+            type = 'json';
+        }
+        else if (serializer === 'gob') {
+            type = 'bytes';
+        }
+        else if (serializer === 'unixtime') {
+            type = 'bigInt';
+        }
+        else {
+            type = 'unsupported';
+            unsupportedType = `serializer:${serializer}`;
+            warnings.push(`${location}: the serializer "${serializer}" is custom; the column was kept as an unsupported column.`);
+        }
+    }
+    else if (scalar.needsHint !== undefined) {
+        if (scalar.needsHint === 'scanner') {
+            warnings.push(`${location}: "${scalar.unsupportedType ?? ''}" implements Scanner and Valuer, so GORM stores it as a column of a type ` +
+                `only the database knows; add a type:... tag to set it. The column was kept as an unsupported column.`);
+        }
+        else {
+            warnings.push(`${location}: a ${scalar.needsHint} column needs a type:... or serializer:... tag for GORM to migrate it; ` +
+                `it was read as ${scalar.needsHint === 'map' ? 'a json column' : `an array of ${type}`}.`);
+        }
+    }
+    else if (type === 'unsupported') {
+        warnings.push(`${location}: the Go type "${unsupportedType ?? ''}" has no column mapping; add a type:... tag to choose one. ` +
+            `It was kept as an unsupported column.`);
+    }
+    if (scalar.intEnumName !== undefined) {
+        warnings.push(`${location}: the type "${scalar.intEnumName}" has integer constants, which the shared model cannot represent as an enum; ` +
+            `the column was converted to a plain integer.`);
+    }
+    // size, precision and scale tags -----------------------------------------
+    const size = entryNumber(entries, 'SIZE');
+    const precision = entryNumber(entries, 'PRECISION');
+    const scale = entryNumber(entries, 'SCALE');
+    if (typeTag === undefined && serializer === undefined) {
+        if (size !== undefined &&
+            size > 0 &&
+            (type === 'text' || type === 'string') &&
+            goKind === 'string') {
+            type = 'string';
+            maxLength = size;
+        }
+        else if (size !== undefined &&
+            size > 0 &&
+            (goKind === 'int' || goKind === 'uint') &&
+            (type === 'int' || type === 'bigInt')) {
+            type = integerType(size, goKind === 'uint');
+        }
+    }
+    if (precision !== undefined &&
+        precision > 0 &&
+        (type === 'decimal' || type === 'float')) {
+        // GORM stores a float with a precision as numeric(precision, scale).
+        type = 'decimal';
+        maxDigits = precision;
+        decimalPlaces = scale;
+        goKind = 'float';
+    }
+    else if (type === 'decimal' && scale !== undefined) {
+        decimalPlaces = scale;
+    }
+    if (enumInfo !== undefined && type === 'text') {
+        type = 'string';
+    }
+    const columnName = scope.columnPrefix +
+        (entryValue(entries, 'COLUMN') ?? gormColumnName(goField.name));
+    const irName = irFieldName(scope.namePrefix + goField.name);
+    // Primary key, nullability, uniqueness -----------------------------------
+    const isPrimary = (entryFlag(entries, 'PRIMARYKEY', 'PRIMARY_KEY') ?? false) === true;
+    const notNull = entryFlag(entries, 'NOT NULL', 'NOTNULL') === true;
+    const isNullable = scalar.nullable && !notNull && !isPrimary;
+    // Timestamps GORM maintains ----------------------------------------------
+    const isTimeLike = goKind === 'time';
+    const isIntegerLike = goKind === 'int' || goKind === 'uint';
+    const createTag = entryFlag(entries, 'AUTOCREATETIME');
+    const updateTag = entryFlag(entries, 'AUTOUPDATETIME');
+    const autoCreate = createTag ??
+        (goField.name === 'CreatedAt' && (isTimeLike || isIntegerLike));
+    const autoUpdate = updateTag ??
+        (goField.name === 'UpdatedAt' && (isTimeLike || isIntegerLike));
+    if ((autoCreate || autoUpdate) &&
+        isIntegerLike &&
+        (createTag === true || updateTag === true)) {
+        warnings.push(`${location}: ${autoCreate ? 'autoCreateTime' : 'autoUpdateTime'} on an integer field stores Unix time; ` +
+            `it was read as a plain integer column.`);
+    }
+    const field = {
+        name: irName,
+        columnName,
+        type,
+        isPrimaryKey: isPrimary,
+        isUnique: !isPrimary && entryFlag(entries, 'UNIQUE') === true,
+        isNullable,
+        isAutoUpdated: autoUpdate && isTimeLike,
+        ...(maxLength === undefined || type !== 'string' ? {} : { maxLength }),
+        ...(type === 'decimal' && maxDigits !== undefined ? { maxDigits } : {}),
+        ...(type === 'decimal' && decimalPlaces !== undefined
+            ? { decimalPlaces }
+            : {}),
+        ...(arrayDepth === undefined || arrayDepth === 0 ? {} : { arrayDepth }),
+        ...(enumInfo === undefined ? {} : { enumName: enumInfo.name }),
+        ...(type === 'unsupported' && unsupportedType !== undefined
+            ? { unsupportedType }
+            : {}),
+    };
+    // Defaults ---------------------------------------------------------------
+    const defaultTag = entryValue(entries, 'DEFAULT');
+    const autoIncrementTag = entryFlag(entries, 'AUTOINCREMENT');
+    if (defaultTag !== undefined) {
+        const converted = convertDefault(defaultTag, field, enumInfo, location, ctx);
+        if (converted !== undefined) {
+            field.default = converted;
+        }
+    }
+    else if (autoCreate && isTimeLike) {
+        field.default = { kind: 'now' };
+    }
+    return {
+        kind: 'column',
+        goName: goField.name,
+        field,
+        entries,
+        indexTags: parseIndexTags(gormTagOf(goField)),
+        isPrimary,
+        autoIncrementTag: isSerial ? (autoIncrementTag ?? true) : autoIncrementTag,
+        goKind,
+        depth: scope.depth,
+    };
+}
+// ---------------------------------------------------------------------------
+// Structs to raw models
+// ---------------------------------------------------------------------------
+function collectMembers(goStruct, structName, scope, trail, soft) {
+    const ctx = scope.ctx;
+    const members = [];
+    for (const field of goStruct.fields) {
+        const entries = parseSettings(gormTagOf(field), ';');
+        if (isIgnored(entries)) {
+            continue;
+        }
+        if (isEmbeddedField(field, entries)) {
+            const inner = embeddedStruct(field.type, ctx);
+            const label = `${structName}.${field.name ?? describeGoType(field.type)}`;
+            if (inner === undefined) {
+                // An embedded scalar-like type (for example time.Time) is a column; only structs are expanded.
+                if (field.name === undefined) {
+                    ctx.warnings.push(`${label}: the embedded type is not declared in the input files, so its columns are missing. ` +
+                        `Add the file that defines it to --input.`);
+                    continue;
+                }
+            }
+            else {
+                if (trail.has(inner.name)) {
+                    ctx.warnings.push(`${label}: the embedded struct "${inner.name}" contains itself; the recursion was cut.`);
+                    continue;
+                }
+                const prefix = entryValue(entries, 'EMBEDDEDPREFIX') ?? '';
+                members.push(...collectMembers(inner, structName, {
+                    ctx,
+                    columnPrefix: scope.columnPrefix + prefix,
+                    namePrefix: scope.namePrefix + (prefix === '' ? '' : toCamelCase(prefix)),
+                    depth: scope.depth + 1,
+                }, new Set([...trail, inner.name]), soft));
+                continue;
+            }
+        }
+        const goName = field.name;
+        if (goName === undefined || !isUpperAscii(goName.charAt(0))) {
+            // Unexported fields are not part of the schema.
+            continue;
+        }
+        const location = `${structName}.${goName}`;
+        const hasColumnTag = entryValue(entries, 'TYPE', 'SERIALIZER') !== undefined;
+        const classified = classifyType(field.type, ctx);
+        if (classified.kind === 'skip') {
+            if (classified.message !== undefined) {
+                ctx.warnings.push(`${location}: ${classified.message}; it was skipped.`);
+            }
+            continue;
+        }
+        if (classified.kind === 'association') {
+            if (hasColumnTag) {
+                // An explicit column type makes the field a column, not an association.
+                const column = buildColumn(structName, { ...field, name: goName }, entries, {
+                    kind: 'scalar',
+                    type: 'json',
+                    goKind: 'other',
+                    nullable: field.type.kind === 'pointer',
+                }, scope);
+                members.push(column);
+                continue;
+            }
+            members.push({
+                kind: 'association',
+                goName,
+                irName: irFieldName(scope.namePrefix + goName),
+                target: classified.target,
+                many: classified.many,
+                entries,
+                depth: scope.depth,
+            });
+            continue;
+        }
+        if (classified.isSoftDelete === true && soft.field === undefined) {
+            soft.field = goName;
+        }
+        members.push(buildColumn(structName, { ...field, name: goName }, entries, classified, scope));
+    }
+    return members;
+}
+/** Table name from a TableName() method, or GORM's default. */
+function resolveTableName(goStruct, ctx) {
+    const method = ctx.methods
+        .get(goStruct.name)
+        ?.get('TableName');
+    const fallback = gormTableName(goStruct.name);
+    if (method === undefined) {
+        return fallback;
+    }
+    if (method.returns?.kind === 'string') {
+        return method.returns.value;
+    }
+    if (method.returns?.kind === 'identifier') {
+        const constant = ctx.consts.get(method.returns.name);
+        if (constant?.value?.kind === 'string') {
+            return constant.value.value;
+        }
+    }
+    ctx.warnings.push(`${goStruct.name}: TableName() does not return a string literal or constant, so its value cannot be read statically; ` +
+        `GORM's default table name "${fallback}" was used.`);
+    return fallback;
+}
+function buildRawModel(goStruct, ctx) {
+    const soft = { field: undefined };
+    const collected = collectMembers(goStruct, goStruct.name, { ctx, columnPrefix: '', namePrefix: '', depth: 0 }, new Set([goStruct.name]), soft);
+    // A field of the model itself shadows a promoted field of the same name.
+    const members = collected.filter((member, index) => {
+        const name = member.kind === 'column' ? member.field.name : member.irName;
+        return !collected.some((other, otherIndex) => otherIndex !== index &&
+            (other.kind === 'column' ? other.field.name : other.irName) ===
+                name &&
+            (other.depth < member.depth ||
+                (other.depth === member.depth && otherIndex < index)));
+    });
+    const columns = members.filter((member) => member.kind === 'column');
+    let primaryMembers = columns.filter((column) => column.isPrimary);
+    if (primaryMembers.length === 0) {
+        // GORM treats a field called ID as the primary key when none is declared.
+        const implicit = columns.find((column) => column.field.columnName === 'id');
+        if (implicit !== undefined) {
+            implicit.isPrimary = true;
+            implicit.field.isPrimaryKey = true;
+            implicit.field.isNullable = false;
+            implicit.field.isUnique = false;
+            primaryMembers = [implicit];
+        }
+    }
+    return {
+        name: goStruct.name,
+        struct: goStruct,
+        tableName: resolveTableName(goStruct, ctx),
+        members,
+        primaryMembers,
+        softDeleteField: soft.field,
+    };
+}
+function readConstraint(member, location, ctx) {
+    const text = entryValue(member.entries, 'CONSTRAINT');
+    if (text === undefined) {
+        return {};
+    }
+    const result = {};
+    const comma = text.indexOf(',');
+    if (comma !== -1 && /^[\w-]+$/.test(text.slice(0, comma))) {
+        result.name = text.slice(0, comma);
+    }
+    const settings = parseSettings(text, ',');
+    for (const [key, target] of [
+        ['ONDELETE', 'onDelete'],
+        ['ONUPDATE', 'onUpdate'],
+    ]) {
+        const value = entryValue(settings, key);
+        if (value === undefined || value === '') {
+            continue;
+        }
+        const mapped = ON_DELETE_MAP[value.toUpperCase()];
+        if (mapped === undefined) {
+            ctx.warnings.push(`${location}: ${target === 'onDelete' ? 'OnDelete' : 'OnUpdate'} "${value}" has no equivalent and was converted to NoAction.`);
+            result[target] = 'noAction';
+        }
+        else {
+            result[target] = mapped;
+        }
+    }
+    return result;
+}
+/** GORM looks a field up by column name first, then by Go name. */
+function lookupMember(model, name) {
+    const columns = model.members.filter((member) => member.kind === 'column');
+    return (columns.find((column) => column.field.columnName === name) ??
+        columns.find((column) => column.goName === name));
+}
+/**
+ * Finds the foreign key of an association the way GORM does. For `has`, the key lives on the
+ * target and refers to the declaring model; for `belongs`, it lives on the declaring model.
+ */
+function guessKeys(mode, declaring, target, member) {
+    const primary = mode === 'has' ? declaring : target;
+    const foreign = mode === 'has' ? target : declaring;
+    const foreignNames = splitList(entryValue(member.entries, 'FOREIGNKEY'));
+    const referenceNames = splitList(entryValue(member.entries, 'REFERENCES'));
+    let primaryFields = primary.primaryMembers;
+    if (referenceNames.length > 0) {
+        const resolved = referenceNames.map((name) => lookupMember(primary, name));
+        if (resolved.some((item) => item === undefined)) {
+            return undefined;
+        }
+        primaryFields = resolved.filter((item) => item !== undefined);
+    }
+    if (foreignNames.length > 0) {
+        const resolved = foreignNames.map((name) => lookupMember(foreign, name));
+        const found = resolved.filter((item) => item !== undefined);
+        if (found.length !== foreignNames.length ||
+            found.length !== primaryFields.length) {
+            return undefined;
+        }
+        return { foreign: found, references: primaryFields };
+    }
+    const foreignFields = [];
+    for (const primaryField of primaryFields) {
+        const base = (mode === 'belongs' ? member.goName : primary.name) + primaryField.goName;
+        const names = [base];
+        if (primaryFields.length === 1) {
+            const stem = base.slice(0, base.length - primaryField.goName.length);
+            names.push(`${stem}ID`, `${stem}Id`, gormColumnName(`${stem}ID`));
+        }
+        let found;
+        for (const name of names) {
+            found = lookupMember(foreign, name);
+            if (found !== undefined) {
+                break;
+            }
+        }
+        if (found === undefined) {
+            return undefined;
+        }
+        foreignFields.push(found);
+    }
+    return foreignFields.length === 0
+        ? undefined
+        : { foreign: foreignFields, references: primaryFields };
+}
+/**
+ * The constraint settings that GORM applies to a foreign key. When both the belongs-to field and
+ * the has-one / has-many field describe the key, GORM ignores the belongs-to field's settings.
+ */
+function effectiveConstraint(link, ctx) {
+    if (link.has === undefined) {
+        return link.belongsConstraint;
+    }
+    const ignored = link.belongsConstraint;
+    if (link.belongsTo !== undefined &&
+        (ignored.onDelete !== undefined ||
+            ignored.onUpdate !== undefined ||
+            ignored.name !== undefined)) {
+        ctx.warnings.push(`${link.belongsTo.model.name}.${link.belongsTo.member.goName}: GORM ignores the constraint:... tag of a belongs-to field when ` +
+            `${link.has.model.name}.${link.has.member.goName} describes the same foreign key; set the constraint on that field instead.`);
+    }
+    return link.hasConstraint;
+}
+/** Resolves every association tag into foreign-key links and many-to-many uses. */
+function resolveAssociations(models, ctx) {
+    const byName = new Map(models.map((model) => [model.name, model]));
+    const links = new Map();
+    const manyToMany = [];
+    for (const model of models) {
+        for (const member of model.members) {
+            if (member.kind !== 'association') {
+                continue;
+            }
+            const location = `${model.name}.${member.goName}`;
+            const target = byName.get(member.target);
+            if (target === undefined) {
+                ctx.warnings.push(`${location}: the target "${member.target}" is not a model in the input; the association was skipped.`);
+                continue;
+            }
+            const polymorphic = entryValue(member.entries, 'POLYMORPHIC');
+            if (polymorphic !== undefined) {
+                ctx.warnings.push(`${location}: the polymorphic association "${polymorphic}" (the ${polymorphic}ID and ${polymorphic}Type columns of "${target.name}") ` +
+                    `points at several models, which the shared model cannot represent; the association was dropped and the columns stay ordinary fields.`);
+                continue;
+            }
+            const joinTable = entryValue(member.entries, 'MANY2MANY');
+            if (joinTable !== undefined) {
+                const use = resolveManyToMany(model, member, target, joinTable, location, ctx);
+                if (use !== undefined) {
+                    manyToMany.push(use);
+                }
+                continue;
+            }
+            const modes = member.many
+                ? ['has']
+                : model === target
+                    ? ['belongs', 'has']
+                    : ['has', 'belongs'];
+            let resolvedMode;
+            let keys;
+            for (const mode of modes) {
+                keys = guessKeys(mode, model, target, member);
+                if (keys !== undefined) {
+                    resolvedMode = mode;
+                    break;
+                }
+            }
+            if (keys === undefined || resolvedMode === undefined) {
+                ctx.warnings.push(`${location}: no foreign key was found for the association to "${target.name}". Add a foreignKey:... tag or a ` +
+                    `${member.many ? `${model.name}ID` : `${member.goName}ID`} field; the association was skipped.`);
+                continue;
+            }
+            const owner = resolvedMode === 'has' ? target : model;
+            const referenced = resolvedMode === 'has' ? model : target;
+            const key = `${owner.name}|${keys.foreign
+                .map((column) => column.field.columnName)
+                .join(',')}|${referenced.name}`;
+            const link = links.get(key) ?? {
+                owner,
+                target: referenced,
+                keys,
+                belongsConstraint: {},
+                hasConstraint: {},
+            };
+            links.set(key, link);
+            const constraint = readConstraint(member, location, ctx);
+            if (resolvedMode === 'belongs') {
+                if (link.belongsTo === undefined) {
+                    link.belongsTo = { model, member };
+                }
+            }
+            else if (link.has === undefined) {
+                link.has = { model, member };
+            }
+            else {
+                ctx.warnings.push(`${location}: "${link.has.model.name}.${link.has.member.goName}" already describes the same foreign key; this reverse accessor was ignored.`);
+            }
+            if (resolvedMode === 'belongs') {
+                link.belongsConstraint = constraint;
+            }
+            else if (link.has?.member === member) {
+                link.hasConstraint = constraint;
+            }
+        }
+    }
+    return { links: [...links.values()], manyToMany };
+}
+function resolveManyToMany(owner, member, target, joinTable, location, ctx) {
+    if (joinTable === '' || joinTable === 'MANY2MANY') {
+        ctx.warnings.push(`${location}: many2many needs a join table name (many2many:table_name); the association was skipped.`);
+        return undefined;
+    }
+    const ownerKeyNames = splitList(entryValue(member.entries, 'FOREIGNKEY'));
+    const targetKeyNames = splitList(entryValue(member.entries, 'REFERENCES'));
+    const ownerKeys = ownerKeyNames.length === 0
+        ? owner.primaryMembers
+        : ownerKeyNames
+            .map((name) => lookupMember(owner, name))
+            .filter((item) => item !== undefined);
+    const targetKeys = targetKeyNames.length === 0
+        ? target.primaryMembers
+        : targetKeyNames
+            .map((name) => lookupMember(target, name))
+            .filter((item) => item !== undefined);
+    const ownerKey = ownerKeys[0];
+    const targetKey = targetKeys[0];
+    if (ownerKey === undefined || targetKey === undefined) {
+        ctx.warnings.push(`${location}: the keys of the many2many association could not be determined (${owner.name} or ${target.name} has no primary key); the association was skipped.`);
+        return undefined;
+    }
+    if (ownerKeys.length > 1 || targetKeys.length > 1) {
+        ctx.warnings.push(`${location}: the many2many association uses composite keys; only the first column of each key is read and the join table "${joinTable}" is not preserved.`);
+    }
+    const joinForeignKey = splitList(entryValue(member.entries, 'JOINFOREIGNKEY'))[0];
+    const joinReferences = splitList(entryValue(member.entries, 'JOINREFERENCES'))[0];
+    const ownerField = joinForeignKey === undefined
+        ? upperFirst(owner.name) + ownerKey.goName
+        : upperFirst(joinForeignKey);
+    let relatedField = joinReferences === undefined
+        ? upperFirst(target.name) + targetKey.goName
+        : upperFirst(joinReferences);
+    if (relatedField === ownerField) {
+        // A self-referencing association names the second column after the field: Friends -> FriendID.
+        relatedField =
+            member.goName !== target.name
+                ? upperFirst(toPascalSingular(member.goName)) + targetKey.goName
+                : `${target.name}Reference${targetKey.goName}`;
+    }
+    if ((ownerKeyNames.length > 0 && !ownerKey.isPrimary) ||
+        (targetKeyNames.length > 0 && !targetKey.isPrimary)) {
+        ctx.warnings.push(`${location}: the join table "${joinTable}" refers to columns that are not primary keys; the relation is read as a many-to-many on the primary keys.`);
+    }
+    return {
+        owner,
+        member,
+        target,
+        table: joinTable,
+        ownerColumn: gormColumnName(ownerField),
+        relatedColumn: gormColumnName(relatedField),
+        consumed: false,
+    };
+}
+/** `Friends` becomes `Friend` (the singular of the last word). */
+function toPascalSingular(goName) {
+    const snake = toSnakeCase(goName);
+    const singular = singularize(snake);
+    return singular
+        .split('_')
+        .map((word) => upperFirst(word))
+        .join('');
+}
+function buildIndexGroups(columns) {
+    const groups = new Map();
+    let order = 0;
+    for (const column of columns) {
+        for (const tag of column.indexTags) {
+            const key = tag.name !== undefined
+                ? `name:${tag.name}`
+                : tag.composite !== undefined
+                    ? `composite:${tag.composite}`
+                    : `field:${column.field.name}:${order}`;
+            const group = groups.get(key) ?? {
+                name: tag.name,
+                isUnique: false,
+                kind: undefined,
+                method: undefined,
+                uses: [],
+                hasWhere: false,
+                hasExpression: false,
+            };
+            group.isUnique = group.isUnique || tag.isUnique;
+            group.kind = group.kind ?? tag.kind;
+            group.method = group.method ?? tag.method;
+            group.hasWhere = group.hasWhere || tag.hasWhere;
+            group.hasExpression = group.hasExpression || tag.hasExpression;
+            group.uses.push({ member: column, tag, order });
+            order += 1;
+            groups.set(key, group);
+        }
+    }
+    return [...groups.values()];
+}
+function defaultRelationName(column, taken) {
+    const base = column.field.name;
+    const stripped = /Id$/.test(base) && base.length > 2 ? base.slice(0, -2) : base;
+    return taken.has(stripped) ? `${stripped}Ref` : stripped;
+}
+function buildSchema(rawModels, ctx, options) {
+    const warnings = ctx.warnings;
+    const { links, manyToMany } = resolveAssociations(rawModels, ctx);
+    const usedEnums = new Set();
+    const models = [];
+    for (const raw of rawModels) {
+        const columns = raw.members.filter((member) => member.kind === 'column');
+        const takenNames = new Set(raw.members.map((member) => member.kind === 'column' ? member.field.name : member.irName));
+        // Foreign keys: the key columns turn into relations --------------------
+        const consumed = new Map();
+        const orderedRelations = [];
+        const compositeKeys = [];
+        let synthesized = 0;
+        for (const link of links) {
+            if (link.owner !== raw) {
+                continue;
+            }
+            const order = link.belongsTo === undefined
+                ? raw.members.length + synthesized++
+                : raw.members.indexOf(link.belongsTo.member);
+            const first = link.keys.foreign[0];
+            if (first === undefined) {
+                continue;
+            }
+            const constraint = effectiveConstraint(link, ctx);
+            const name = link.belongsTo?.member.irName ?? defaultRelationName(first, takenNames);
+            const isNullable = link.keys.foreign.some((column) => column.field.isNullable);
+            const relatedName = link.has?.member.irName;
+            const kind = link.has !== undefined && !link.has.member.many
+                ? 'oneToOne'
+                : 'foreignKey';
+            if (link.keys.foreign.length > 1) {
+                compositeKeys.push({
+                    name,
+                    targetModel: link.target.name,
+                    fields: link.keys.foreign.map((column) => column.field.name),
+                    references: link.keys.references.map((column) => column.field.name),
+                    kind,
+                    isNullable,
+                    onDelete: constraint.onDelete ?? 'noAction',
+                    ...(constraint.onUpdate === undefined
+                        ? {}
+                        : { onUpdate: constraint.onUpdate }),
+                    ...(relatedName === undefined ? {} : { relatedName }),
+                    ...(constraint.name === undefined
+                        ? {}
+                        : { constraintName: constraint.name }),
+                });
+                continue;
+            }
+            const reference = link.keys.references[0];
+            const isTargetKey = reference !== undefined &&
+                link.target.primaryMembers.length === 1 &&
+                link.target.primaryMembers[0] === reference;
+            const unique = first.field.isUnique ||
+                first.indexTags.some((tag) => tag.isUnique &&
+                    tag.name === undefined &&
+                    tag.composite === undefined);
+            const relation = {
+                name,
+                kind: kind === 'foreignKey' && unique ? 'oneToOne' : kind,
+                targetModel: link.target.name,
+                columnName: first.field.columnName,
+                isNullable: first.isPrimary ? false : isNullable,
+                onDelete: constraint.onDelete ?? 'noAction',
+                ...(relatedName === undefined ? {} : { relatedName }),
+                ...(reference === undefined || isTargetKey
+                    ? {}
+                    : { toField: reference.field.columnName }),
+                ...(first.isPrimary ? { isPrimaryKey: true } : {}),
+                ...(constraint.onUpdate === undefined
+                    ? {}
+                    : { onUpdate: constraint.onUpdate }),
+                ...(constraint.name === undefined
+                    ? {}
+                    : { constraintName: constraint.name }),
+            };
+            consumed.set(first, name);
+            orderedRelations.push({ order, relation });
+        }
+        // Many-to-many ----------------------------------------------------------
+        for (const use of manyToMany) {
+            if (use.owner !== raw || use.consumed) {
+                continue;
+            }
+            use.consumed = true;
+            const mirror = manyToMany.find((candidate) => !candidate.consumed &&
+                candidate !== use &&
+                candidate.owner === use.target &&
+                candidate.target === use.owner &&
+                candidate.table.toLowerCase() === use.table.toLowerCase());
+            if (mirror !== undefined) {
+                mirror.consumed = true;
+            }
+            const relation = {
+                name: use.member.irName,
+                kind: 'manyToMany',
+                targetModel: use.target.name,
+                columnName: `${toSnakeCase(use.member.irName)}_id`,
+                isNullable: false,
+                onDelete: 'cascade',
+                ...(mirror === undefined ? {} : { relatedName: mirror.member.irName }),
+            };
+            orderedRelations.push({
+                order: raw.members.indexOf(use.member),
+                relation,
+            });
+            // Other formats derive the join table from the two models; say what does not survive.
+            const isSelf = use.owner === use.target;
+            const expectedTable = `${raw.tableName}_${use.member.irName}`;
+            const expectedOwner = `${isSelf ? 'from_' : ''}${toSnakeCase(use.owner.name)}_id`;
+            const expectedRelated = `${isSelf ? 'to_' : ''}${toSnakeCase(use.target.name)}_id`;
+            if (use.table !== expectedTable ||
+                use.ownerColumn !== expectedOwner ||
+                use.relatedColumn !== expectedRelated) {
+                warnings.push(`${raw.name}.${use.member.goName}: the join table "${use.table}" (columns ${use.ownerColumn}, ${use.relatedColumn}) is not preserved by name; ` +
+                    `formats that derive join tables will use "${expectedTable}" (columns ${expectedOwner}, ${expectedRelated}).`);
+            }
+        }
+        const relations = orderedRelations
+            .sort((first, second) => first.order - second.order)
+            .map((entry) => entry.relation);
+        // Fields -----------------------------------------------------------------
+        const fields = columns
+            .filter((column) => !consumed.has(column))
+            .map((column) => ({ ...column.field }));
+        const finalName = (column) => consumed.get(column) ?? column.field.name;
+        const fieldFor = (column) => fields.find((field) => field.name === column.field.name);
+        // Primary key ------------------------------------------------------------
+        const keyColumns = raw.primaryMembers;
+        let compositePrimaryKey;
+        if (keyColumns.length === 0) {
+            warnings.push(`${raw.name}: the struct has no primary key (GORM treats a field called ID, or a primaryKey tag, as one); ` +
+                `other formats expect every model to have a key.`);
+        }
+        else if (keyColumns.length > 1) {
+            compositePrimaryKey = keyColumns.map(finalName);
+            for (const column of keyColumns) {
+                const field = fieldFor(column);
+                if (field !== undefined) {
+                    field.isPrimaryKey = false;
+                    field.isUnique = false;
+                }
+            }
+            for (const relation of relations) {
+                delete relation.isPrimaryKey;
+            }
+        }
+        // The prioritized primary key of an integer type auto-increments unless told otherwise.
+        for (const column of columns) {
+            const field = fieldFor(column);
+            if (field === undefined || field.default?.kind === 'autoIncrement') {
+                continue;
+            }
+            const isInteger = field.type === 'int' || field.type === 'bigInt';
+            const isOnlyKey = keyColumns.length === 1 && keyColumns[0] === column;
+            if (isInteger &&
+                field.arrayDepth === undefined &&
+                (column.autoIncrementTag === true ||
+                    (isOnlyKey && column.autoIncrementTag === undefined)) &&
+                field.default === undefined) {
+                field.default = { kind: 'autoIncrement' };
+            }
+        }
+        // Indexes ----------------------------------------------------------------
+        const irIndexes = [];
+        for (const group of buildIndexGroups(columns)) {
+            const label = group.name === undefined ? '' : ` "${group.name}"`;
+            const sorted = [...group.uses].sort((first, second) => first.tag.priority - second.tag.priority || first.order - second.order);
+            if (group.hasExpression) {
+                warnings.push(`${raw.name}: the index${label} on (${sorted.map((use) => use.member.goName).join(', ')}) uses an expression, which cannot be represented; it was skipped.`);
+                continue;
+            }
+            if (group.hasWhere) {
+                warnings.push(`${raw.name}: the index${label} has a where condition (a partial index), which is not preserved; it was read as a full index.`);
+            }
+            const names = sorted.map((use) => finalName(use.member));
+            const only = sorted[0];
+            if (names.length === 1 &&
+                only !== undefined &&
+                group.isUnique &&
+                group.name === undefined &&
+                group.kind === undefined &&
+                only.tag.sort === undefined &&
+                only.tag.length === undefined) {
+                const field = fieldFor(only.member);
+                if (field !== undefined) {
+                    if (!field.isPrimaryKey) {
+                        field.isUnique = true;
+                    }
+                    continue;
+                }
+                if (consumed.has(only.member)) {
+                    // The unique key is a foreign key: the relation already carries it (one-to-one).
+                    continue;
+                }
+            }
+            const fieldOptions = {};
+            for (const use of sorted) {
+                const optionSet = {
+                    ...(use.tag.sort === undefined ? {} : { sort: use.tag.sort }),
+                    ...(use.tag.length === undefined ? {} : { length: use.tag.length }),
+                };
+                if (Object.keys(optionSet).length > 0) {
+                    fieldOptions[finalName(use.member)] = optionSet;
+                }
+            }
+            const method = group.method === undefined
+                ? undefined
+                : INDEX_METHODS[group.method.toLowerCase()];
+            if (group.method !== undefined && method === undefined) {
+                warnings.push(`${raw.name}: the index method "${group.method}" has no equivalent and was ignored.`);
+            }
+            irIndexes.push({
+                fields: names,
+                isUnique: group.isUnique,
+                ...(group.name === undefined ? {} : { name: group.name }),
+                ...(group.kind === undefined ? {} : { kind: group.kind }),
+                ...(method === undefined ? {} : { method }),
+                ...(Object.keys(fieldOptions).length === 0 ? {} : { fieldOptions }),
+            });
+        }
+        // Settings with no equivalent -----------------------------------------------
+        for (const column of columns) {
+            const check = entryValue(column.entries, 'CHECK');
+            if (check !== undefined) {
+                warnings.push(`${raw.name}.${column.goName}: the check constraint "${check}" has no equivalent in the shared model and was dropped.`);
+            }
+            const comment = entryValue(column.entries, 'COMMENT');
+            if (comment !== undefined) {
+                warnings.push(`${raw.name}.${column.goName}: the column comment is not preserved.`);
+            }
+            if (column.field.enumName !== undefined) {
+                usedEnums.add(column.field.enumName);
+            }
+        }
+        if (raw.softDeleteField !== undefined) {
+            warnings.push(`${raw.name}.${raw.softDeleteField}: gorm.DeletedAt is read as a nullable timestamp column; the soft-delete behavior ` +
+                `(GORM hides rows with a deletion time from queries) has no equivalent in the shared model.`);
+        }
+        models.push({
+            name: raw.name,
+            tableName: raw.tableName,
+            appLabel: options.appLabel,
+            fields,
+            relations,
+            indexes: irIndexes,
+            ...(compositePrimaryKey === undefined ? {} : { compositePrimaryKey }),
+            ...(compositeKeys.length === 0
+                ? {}
+                : { compositeForeignKeys: compositeKeys }),
+        });
+    }
+    const enums = [...ctx.enums.values()]
+        .filter((info) => info.backing === 'string' && usedEnums.has(info.name))
+        .map((info) => ({
+        name: info.name,
+        values: info.values,
+    }));
+    return { models, enums, warnings };
+}
+//# sourceMappingURL=gorm.js.map