ormbridge 0.7.0 → 0.8.0

package/dist/parsers/sequelize.js

@@ -0,0 +1,906 @@
+import { toPascalCase, toSnakeCase } from '../naming.js';
+import { describeThrown, err, ok } from '../result.js';
+import { linkAssociations, } from './sequelizeAssociations.js';
+import { collectFile, describeFile, mergeNamedIndexes, readIndexes, readModelOptions, } from './sequelizeCollect.js';
+import { pluralize, singularize, underscore } from './sequelizeInflection.js';
+import { resolveDataType } from './sequelizeTypes.js';
+import { getTypeScriptParser } from './typescriptSyntax.js';
+// ---------------------------------------------------------------------------
+// Static tables
+// ---------------------------------------------------------------------------
+/** A file that mentions neither Sequelize nor its data types nor @Table cannot define a model. */
+const SEQUELIZE_HINT = /sequelize|DataTypes?\b|@Table\b/i;
+const ON_ACTION_MAP = {
+    CASCADE: 'cascade',
+    'SET NULL': 'setNull',
+    RESTRICT: 'restrict',
+    'NO ACTION': 'noAction',
+    'SET DEFAULT': 'setDefault',
+};
+/** Index access methods the IR spells the way Prisma does. */
+const INDEX_METHODS = {
+    btree: 'BTree',
+    hash: 'Hash',
+    gin: 'Gin',
+    gist: 'Gist',
+    spgist: 'SpGist',
+    brin: 'BRIN',
+};
+/** TypeScript property types that sequelize-typescript turns into a column type. */
+const TS_TYPES = {
+    string: { type: 'string', maxLength: 255 },
+    number: { type: 'int' },
+    bigint: { type: 'bigInt' },
+    boolean: { type: 'boolean' },
+    Date: { type: 'dateTime' },
+    Buffer: { type: 'bytes' },
+};
+const NOW_SQL = /^\(?(now\(\)|current_timestamp(\(\d*\))?|localtimestamp(\(\d*\))?|transaction_timestamp\(\)|sysdatetime\(\)|getdate\(\)|datetime\('now'\)|strftime\(.*'now'.*\))\)?$/i;
+const UUID_SQL = /^(uuid_generate_v[14]\(\)|gen_random_uuid\(\)|uuid\(\)|newid\(\))$/i;
+const QUOTED_SQL = /^'((?:[^']|'')*)'(::[\w\s]+)?$/;
+// ---------------------------------------------------------------------------
+// Public entry point
+// ---------------------------------------------------------------------------
+/**
+ * Parses Sequelize 6 models into the shared IR using tree-sitter. The source is only read: nothing is
+ * imported or run, so models built in loops or from run-time values are not seen.
+ */
+export async function parseSequelize(sources, options) {
+    const parserResult = await getTypeScriptParser();
+    if (!parserResult.ok) {
+        return parserResult;
+    }
+    const parser = parserResult.value;
+    const project = {
+        files: [],
+        models: [],
+        associations: [],
+        sharedConsts: new Map(),
+        defaults: {},
+        warnings: [],
+    };
+    // The trees are kept alive until the schema is built: the syntax nodes below point into them.
+    const trees = [];
+    try {
+        for (const source of sources) {
+            if (!SEQUELIZE_HINT.test(source.text)) {
+                continue;
+            }
+            const tree = parser.parse(source.text);
+            trees.push(tree);
+            const file = describeFile(source.path, tree.rootNode);
+            project.files.push(file);
+            if (tree.rootNode.hasError) {
+                project.warnings.push(`${file.label}: the file contains syntax errors; some models or attributes may be missing from the output.`);
+            }
+            for (const [name, node] of file.consts) {
+                const shared = project.sharedConsts.get(name) ?? [];
+                shared.push({ file, node });
+                project.sharedConsts.set(name, shared);
+            }
+        }
+        for (const file of project.files) {
+            collectFile(file, project);
+        }
+        if (project.models.length === 0) {
+            const checkedPaths = sources
+                .map((source) => source.path)
+                .join(', ');
+            return err('NO_MODELS_FOUND', `No Sequelize models were found in: ${checkedPaths}. A model is \`sequelize.define('Name', { ... })\`, ` +
+                `\`class Name extends Model\` with \`Name.init({ ... }, { sequelize })\`, or a sequelize-typescript class with @Table.`);
+        }
+        return ok(buildSchema(project, options));
+    }
+    catch (thrown) {
+        return err('PARSE_FAILED', `Failed to read the Sequelize models: ${describeThrown(thrown)}`);
+    }
+    finally {
+        for (const tree of trees) {
+            tree.delete();
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Naming
+// ---------------------------------------------------------------------------
+/** The IR model name: the Sequelize model name, in PascalCase when it is written as `user` or `blog_post`. */
+function irModelName(modelName) {
+    return /^[A-Z][A-Za-z0-9]*$/.test(modelName)
+        ? modelName
+        : toPascalCase(modelName) || modelName;
+}
+function tableNameOf(modelName, options) {
+    if (options.tableName !== undefined) {
+        return options.tableName;
+    }
+    if (options.freezeTableName) {
+        return modelName;
+    }
+    const plural = pluralize(modelName);
+    return options.underscored ? underscore(plural) : plural;
+}
+function columnName(options, attribute) {
+    return (attribute.field ??
+        (options.underscored ? underscore(attribute.name) : attribute.name));
+}
+function lowerFirst(text) {
+    return text.charAt(0).toLowerCase() + text.slice(1);
+}
+function describeNode(value) {
+    const text = value.kind === 'name'
+        ? value.value
+        : value.kind === 'other'
+            ? value.text
+            : value.kind;
+    const collapsed = text.replace(/\s+/g, ' ');
+    return collapsed.length > 60 ? `${collapsed.slice(0, 57)}...` : collapsed;
+}
+// ---------------------------------------------------------------------------
+// Preparation: options, names, the attributes Sequelize adds itself
+// ---------------------------------------------------------------------------
+const DATE_TYPE = { kind: 'name', value: 'DataTypes.DATE' };
+const INTEGER_TYPE = { kind: 'name', value: 'DataTypes.INTEGER' };
+/** Adds the `id` and timestamp columns that `Model.init` adds when the model does not declare them. */
+function addDefaultAttributes(model, options) {
+    const attributes = model.attributes;
+    if (!attributes.some((attribute) => attribute.primaryKey)) {
+        if (attributes.some((attribute) => attribute.name === 'id')) {
+            model.unsupported.push('an "id" column that is not a primary key (Sequelize refuses such a model)');
+        }
+        else {
+            attributes.unshift({
+                name: 'id',
+                origin: 'id',
+                type: INTEGER_TYPE,
+                allowNull: false,
+                primaryKey: true,
+                autoIncrement: true,
+            });
+        }
+    }
+    if (options.timestamps) {
+        const timestamps = [
+            ['createdAt', options.createdAt, false],
+            ['updatedAt', options.updatedAt, false],
+            ['deletedAt', options.paranoid ? options.deletedAt : false, true],
+        ];
+        for (const [kind, name, nullable] of timestamps) {
+            if (name === false) {
+                continue;
+            }
+            const existing = attributes.find((attribute) => attribute.name === name);
+            if (existing !== undefined) {
+                existing.timestamp = kind;
+            }
+            else {
+                attributes.push({
+                    name,
+                    origin: 'timestamp',
+                    type: DATE_TYPE,
+                    timestamp: kind,
+                    ...(nullable ? {} : { allowNull: false }),
+                });
+            }
+        }
+    }
+    if (options.version !== undefined &&
+        !attributes.some((attribute) => attribute.name === options.version)) {
+        attributes.push({
+            name: options.version,
+            origin: 'declared',
+            type: INTEGER_TYPE,
+            allowNull: false,
+            defaultValue: { kind: 'number', value: 0 },
+        });
+    }
+}
+function prepareModels(project) {
+    const prepared = [];
+    const modelNames = new Set();
+    const irNames = new Set();
+    for (const model of project.models) {
+        if (modelNames.has(model.modelName)) {
+            project.warnings.push(`${model.location}: another model with the same name was already read; this one was skipped.`);
+            continue;
+        }
+        const irName = irModelName(model.modelName);
+        if (irNames.has(irName)) {
+            project.warnings.push(`${model.location}: the name "${irName}" is already taken by another model; this one was skipped.`);
+            continue;
+        }
+        modelNames.add(model.modelName);
+        irNames.add(irName);
+        const options = readModelOptions(model, project);
+        model.indexes = mergeNamedIndexes(readIndexes(model, project));
+        addDefaultAttributes(model, options);
+        prepared.push({
+            raw: model,
+            options,
+            irName,
+            tableName: tableNameOf(model.modelName, options),
+        });
+    }
+    return prepared;
+}
+// ---------------------------------------------------------------------------
+// Foreign keys declared with `references`
+// ---------------------------------------------------------------------------
+/** The model or table a `references.model` value names. */
+function referencedName(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    switch (value.kind) {
+        case 'string':
+            return value.value;
+        case 'name':
+            return value.value.split('.').pop();
+        case 'call':
+            // `User.getTableName()`
+            return value.callee.split('.').slice(-2, -1)[0];
+        case 'object': {
+            const table = value.properties['tableName'];
+            return table !== undefined && table.kind === 'string'
+                ? table.value
+                : undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+function findReferencedModel(name, prepared) {
+    const lower = name.toLowerCase();
+    return (prepared.find((model) => model.tableName.toLowerCase() === lower) ??
+        prepared.find((model) => model.raw.modelName === name) ??
+        prepared.find((model) => model.raw.aliases.includes(name)));
+}
+/** Turns `references: { model, key }` on an attribute into a foreign key link. */
+function resolveReferences(prepared, project) {
+    for (const model of prepared) {
+        for (const attribute of model.raw.attributes) {
+            if (attribute.references === undefined || attribute.link !== undefined) {
+                continue;
+            }
+            const name = referencedName(attribute.references.model);
+            if (name === undefined) {
+                project.warnings.push(`${model.raw.location}, field "${attribute.name}": the model in references could not be read statically, so no relation was created.`);
+                continue;
+            }
+            const target = findReferencedModel(name, prepared);
+            const key = attribute.references.key;
+            const keyAttribute = target === undefined
+                ? undefined
+                : target.raw.attributes.find((candidate) => candidate.name === key ||
+                    (key !== undefined &&
+                        columnName(target.options, candidate) === key));
+            const link = {
+                target: target?.raw,
+                targetName: target?.irName ?? irModelName(toPascalCase(singularize(name))),
+                keyAttribute: keyAttribute?.name,
+                ...(key === undefined || keyAttribute !== undefined
+                    ? {}
+                    : { keyColumn: key }),
+                ...(attribute.onDelete === undefined
+                    ? {}
+                    : { onDelete: attribute.onDelete }),
+                ...(attribute.onUpdate === undefined
+                    ? {}
+                    : { onUpdate: attribute.onUpdate }),
+                constraint: true,
+            };
+            attribute.link = link;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Types, defaults, enums
+// ---------------------------------------------------------------------------
+function enumMemberName(value) {
+    const snake = toSnakeCase(value).toUpperCase();
+    if (snake === '') {
+        return 'EMPTY';
+    }
+    return /^[0-9]/.test(snake) ? `V_${snake}` : snake;
+}
+function enumValuesOf(values) {
+    const used = new Set();
+    return values.map((dbValue) => {
+        let name = enumMemberName(dbValue);
+        while (used.has(name)) {
+            name = `${name}_`;
+        }
+        used.add(name);
+        return { name, dbValue };
+    });
+}
+function resolveAttributeType(model, attribute, project) {
+    const label = `${model.raw.location}, field "${attribute.name}"`;
+    if (attribute.type !== undefined) {
+        const resolved = resolveDataType(attribute.type);
+        if (resolved === undefined) {
+            project.warnings.push(`${label}: the data type (${describeNode(attribute.type)}) is not a Sequelize data type that could be read statically; the field was read as unsupported.`);
+            return { type: 'unsupported', unsupportedType: 'unknown' };
+        }
+        if (resolved.enumValues !== undefined &&
+            resolved.enumValues.length === 0 &&
+            attribute.enumValues !== undefined) {
+            return { ...resolved, enumValues: attribute.enumValues };
+        }
+        return resolved;
+    }
+    if (attribute.tsType !== undefined) {
+        const inferred = TS_TYPES[attribute.tsType];
+        if (inferred !== undefined) {
+            return inferred;
+        }
+        project.warnings.push(`${label}: sequelize-typescript cannot infer a column type from the TypeScript type "${attribute.tsType}"; name it in @Column(DataType.X). The field was read as unsupported.`);
+        return { type: 'unsupported', unsupportedType: attribute.tsType };
+    }
+    project.warnings.push(`${label}: the attribute has no data type; the field was read as unsupported.`);
+    return { type: 'unsupported', unsupportedType: 'unknown' };
+}
+function jsonText(value) {
+    switch (value.kind) {
+        case 'string':
+            return JSON.stringify(value.value);
+        case 'number':
+            return String(value.value);
+        case 'bool':
+            return value.value ? 'true' : 'false';
+        case 'null':
+            return 'null';
+        case 'array': {
+            const items = value.items.map(jsonText);
+            return items.every((item) => item !== undefined)
+                ? `[${items.join(',')}]`
+                : undefined;
+        }
+        case 'object': {
+            const parts = [];
+            for (const [key, item] of Object.entries(value.properties)) {
+                const text = jsonText(item);
+                if (text === undefined) {
+                    return undefined;
+                }
+                parts.push(`${JSON.stringify(key)}:${text}`);
+            }
+            return `{${parts.join(',')}}`;
+        }
+        default:
+            return undefined;
+    }
+}
+function convertSqlDefault(sql, field, enumeration) {
+    const trimmed = sql.trim();
+    if (NOW_SQL.test(trimmed)) {
+        return { kind: 'now' };
+    }
+    if (UUID_SQL.test(trimmed)) {
+        return { kind: 'uuid' };
+    }
+    if (/^null$/i.test(trimmed)) {
+        return undefined;
+    }
+    if (/^(true|false)$/i.test(trimmed)) {
+        return { kind: 'literal', value: trimmed.toLowerCase() === 'true' };
+    }
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+        return field.type === 'string' || field.type === 'text'
+            ? { kind: 'literal', value: trimmed }
+            : { kind: 'literal', value: Number(trimmed) };
+    }
+    const quoted = QUOTED_SQL.exec(trimmed);
+    if (quoted !== null) {
+        const text = (quoted[1] ?? '').replace(/''/g, "'");
+        const member = enumeration?.values.find((candidate) => candidate.dbValue === text);
+        return member === undefined
+            ? { kind: 'literal', value: text }
+            : { kind: 'enumValue', value: member.name };
+    }
+    return { kind: 'dbExpression', expression: trimmed };
+}
+/** `Sequelize.fn('now')` as SQL text: `now()`. Arguments must be literals. */
+function callText(callee, args) {
+    const rendered = [];
+    for (const arg of args.slice(1)) {
+        if (arg.kind === 'string') {
+            rendered.push(`'${arg.value.replace(/'/g, "''")}'`);
+        }
+        else if (arg.kind === 'number') {
+            rendered.push(String(arg.value));
+        }
+        else {
+            return undefined;
+        }
+    }
+    const first = args[0];
+    return first !== undefined && first.kind === 'string' && callee !== ''
+        ? `${first.value}(${rendered.join(', ')})`
+        : undefined;
+}
+function convertDefault(value, field, enumeration, label, project) {
+    switch (value.kind) {
+        case 'null':
+            return undefined;
+        case 'bool':
+        case 'number':
+            return { kind: 'literal', value: value.value };
+        case 'string': {
+            const member = enumeration?.values.find((candidate) => candidate.dbValue === value.value);
+            if (member !== undefined) {
+                return { kind: 'enumValue', value: member.name };
+            }
+            if (/^-?\d+(\.\d+)?$/.test(value.value) &&
+                (field.type === 'decimal' ||
+                    field.type === 'int' ||
+                    field.type === 'bigInt' ||
+                    field.type === 'float')) {
+                return { kind: 'literal', value: Number(value.value) };
+            }
+            return { kind: 'literal', value: value.value };
+        }
+        case 'name':
+        case 'call': {
+            const callee = value.kind === 'name' ? value.value : value.callee;
+            if (/(^|\.)NOW$/.test(callee)) {
+                return { kind: 'now' };
+            }
+            const version = /(^|\.)UUIDV([14])$/.exec(callee);
+            if (version !== null) {
+                // Version 4 is what an unversioned IR default means.
+                return version[2] === '4'
+                    ? { kind: 'uuid' }
+                    : { kind: 'uuid', version: Number(version[2]) };
+            }
+            if (value.kind === 'call' && /(^|\.)literal$/.test(callee)) {
+                const sql = value.args[0];
+                if (sql !== undefined && sql.kind === 'string') {
+                    return convertSqlDefault(sql.value, field, enumeration);
+                }
+            }
+            if (value.kind === 'call' && /(^|\.)fn$/.test(callee)) {
+                const text = callText(callee, value.args);
+                if (text !== undefined) {
+                    return convertSqlDefault(text, field, enumeration);
+                }
+            }
+            break;
+        }
+        case 'object':
+        case 'array': {
+            const text = jsonText(value);
+            if (text !== undefined &&
+                field.type === 'json' &&
+                field.arrayDepth === undefined) {
+                return { kind: 'literal', value: text };
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    project.warnings.push(`${label}: the default value (${describeNode(value)}) is computed at run time or cannot be read statically and was dropped.`);
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Fields
+// ---------------------------------------------------------------------------
+function registerEnum(context, model, attribute, values) {
+    let name = `${model.irName}${toPascalCase(attribute.name)}`;
+    while (context.enums.some((item) => item.name === name)) {
+        name = `${name}Enum`;
+    }
+    const created = {
+        name,
+        values: enumValuesOf(values),
+        ...(model.options.schema === undefined
+            ? {}
+            : { schema: model.options.schema }),
+    };
+    context.enums.push(created);
+    return created;
+}
+function buildField(context, model, attribute) {
+    const label = `${model.raw.location}, field "${attribute.name}"`;
+    const resolved = resolveAttributeType(model, attribute, context.project);
+    if (resolved.isVirtual === true) {
+        context.project.warnings.push(`${label}: DataTypes.VIRTUAL has no database column, so the field was skipped.`);
+        return undefined;
+    }
+    if (resolved.note !== undefined) {
+        context.project.warnings.push(`${label}: ${resolved.note}.`);
+    }
+    const isPrimaryKey = attribute.primaryKey === true;
+    if (attribute.tsNullable === true && attribute.allowNull === false) {
+        context.project.warnings.push(`${label}: the TypeScript type allows null (or the property is optional) but the column is NOT NULL (allowNull: false); the column was read as NOT NULL.`);
+    }
+    const field = {
+        name: attribute.name,
+        columnName: columnName(model.options, attribute),
+        type: resolved.type,
+        isPrimaryKey,
+        isUnique: false,
+        isNullable: !isPrimaryKey && attribute.allowNull !== false,
+        isAutoUpdated: attribute.timestamp === 'updatedAt',
+        ...(resolved.maxLength === undefined
+            ? {}
+            : { maxLength: resolved.maxLength }),
+        ...(resolved.maxDigits === undefined
+            ? {}
+            : { maxDigits: resolved.maxDigits }),
+        ...(resolved.decimalPlaces === undefined
+            ? {}
+            : { decimalPlaces: resolved.decimalPlaces }),
+        ...(resolved.arrayDepth === undefined
+            ? {}
+            : { arrayDepth: resolved.arrayDepth }),
+        ...(resolved.rangeOf === undefined ? {} : { rangeOf: resolved.rangeOf }),
+        ...(resolved.unsupportedType === undefined
+            ? {}
+            : { unsupportedType: resolved.unsupportedType }),
+    };
+    let enumeration;
+    if (resolved.enumValues !== undefined) {
+        if (resolved.enumValues.length === 0) {
+            context.project.warnings.push(`${label}: an ENUM column without values was read as a plain string.`);
+            field.maxLength = 255;
+        }
+        else {
+            enumeration = registerEnum(context, model, attribute, resolved.enumValues);
+            field.enumName = enumeration.name;
+        }
+    }
+    if (attribute.autoIncrement === true) {
+        field.default = { kind: 'autoIncrement' };
+    }
+    else if (attribute.defaultValue !== undefined) {
+        const converted = convertDefault(attribute.defaultValue, field, enumeration, label, context.project);
+        if (converted !== undefined) {
+            field.default = converted;
+        }
+    }
+    return field;
+}
+// ---------------------------------------------------------------------------
+// Models
+// ---------------------------------------------------------------------------
+function mapAction(value, label, what, project) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const mapped = ON_ACTION_MAP[value.toUpperCase()];
+    if (mapped === undefined) {
+        project.warnings.push(`${label}: ${what} "${value}" has no equivalent and was read as NO ACTION.`);
+        return 'noAction';
+    }
+    return mapped;
+}
+/** The accessor name for a foreign key without a `belongsTo`: `authorId` becomes `author`. */
+function derivedRelationName(attribute, taken) {
+    const stripped = lowerFirst(attribute.name.replace(/(_id|Id|ID)$/, ''));
+    return stripped === '' || stripped === attribute.name || taken.has(stripped)
+        ? attribute.name
+        : stripped;
+}
+function primaryKeyAttributes(attributes) {
+    return attributes.filter((attribute) => attribute.primaryKey === true);
+}
+function indexMethod(using, label, project) {
+    if (using === undefined) {
+        return undefined;
+    }
+    const method = INDEX_METHODS[using.toLowerCase()];
+    if (method === undefined) {
+        project.warnings.push(`${label}: the index method "${using}" has no equivalent and was dropped.`);
+    }
+    return method;
+}
+function buildModel(context, model) {
+    const { project, links } = context;
+    const label = model.raw.location;
+    const attributes = model.raw.attributes;
+    // Shared `unique: 'name'` values make a composite unique constraint. Sequelize creates the tables with
+    // the model's uniqueKeys option when there is one, and then ignores the names given on attributes.
+    const uniqueGroups = new Map();
+    const ignoredUniqueNames = [];
+    for (const attribute of attributes) {
+        const name = attribute.unique?.name;
+        if (name === undefined) {
+            continue;
+        }
+        if (model.raw.optionEntries.has('uniqueKeys')) {
+            ignoredUniqueNames.push(name);
+            delete attribute.unique;
+        }
+        else {
+            uniqueGroups.set(name, [...(uniqueGroups.get(name) ?? []), attribute]);
+        }
+    }
+    if (ignoredUniqueNames.length > 0) {
+        project.warnings.push(`${label}: the uniqueKeys option replaces the unique constraints named on attributes (${[...new Set(ignoredUniqueNames)].join(', ')}), so Sequelize does not create them; they were ignored.`);
+    }
+    const isGrouped = (attribute) => {
+        const name = attribute.unique?.name;
+        return name !== undefined && (uniqueGroups.get(name)?.length ?? 0) > 1;
+    };
+    // A single-field unique index without a name is the same as `unique: true`.
+    const uniqueByIndex = new Set();
+    const modelIndexes = [];
+    for (const index of model.raw.indexes) {
+        const only = index.fields[0];
+        if (index.unique &&
+            index.name === undefined &&
+            index.fields.length === 1 &&
+            only !== undefined &&
+            !index.isPartial &&
+            !index.hasExpression &&
+            index.type === undefined &&
+            index.using === undefined) {
+            uniqueByIndex.add(only.name);
+        }
+        else {
+            modelIndexes.push(index);
+        }
+    }
+    const isUniqueAttribute = (attribute) => (attribute.unique !== undefined && !isGrouped(attribute)) ||
+        uniqueByIndex.has(attribute.name) ||
+        uniqueByIndex.has(columnName(model.options, attribute));
+    const fields = [];
+    const relations = [];
+    /** Attribute name and column name -> the name the IR uses (a relation for foreign keys). */
+    const irNames = new Map();
+    const takenNames = new Set();
+    const foreignKeys = [];
+    for (const attribute of attributes) {
+        if (attribute.link?.constraint === true) {
+            foreignKeys.push(attribute);
+        }
+        else {
+            takenNames.add(attribute.name);
+        }
+    }
+    for (const attribute of attributes) {
+        if (attribute.link?.constraint === true) {
+            continue;
+        }
+        const field = buildField(context, model, attribute);
+        if (field === undefined) {
+            continue;
+        }
+        if (isUniqueAttribute(attribute) && !field.isPrimaryKey) {
+            field.isUnique = true;
+            if (attribute.unique?.name !== undefined) {
+                field.uniqueName = attribute.unique.name;
+            }
+        }
+        fields.push(field);
+        irNames.set(attribute.name, field.name);
+        irNames.set(field.columnName, field.name);
+    }
+    const pkAttributes = primaryKeyAttributes(attributes);
+    for (const attribute of foreignKeys) {
+        const link = attribute.link;
+        if (link === undefined) {
+            continue;
+        }
+        const alias = links.aliases.get(attribute);
+        const reverse = links.reverses.get(attribute);
+        let name = alias ?? derivedRelationName(attribute, takenNames);
+        if (takenNames.has(name)) {
+            name = attribute.name;
+        }
+        takenNames.add(name);
+        const isPrimary = pkAttributes.length === 1 && pkAttributes[0] === attribute;
+        const isOneToOne = isPrimary || isUniqueAttribute(attribute);
+        if (reverse?.kind === 'hasOne' && !isOneToOne) {
+            project.warnings.push(`${label}: ${reverse.label} does not make "${attribute.name}" unique, so the relation was read as a foreign key; add unique: true to the column for a one-to-one relation.`);
+        }
+        const target = link.target;
+        const targetPrepared = context.prepared.find((candidate) => candidate.raw === target);
+        const targetPrimary = primaryKeyAttributes(target?.attributes ?? [])[0];
+        const onDelete = mapAction(link.onDelete, `${label}, field "${attribute.name}"`, 'onDelete', project);
+        const onUpdate = mapAction(link.onUpdate, `${label}, field "${attribute.name}"`, 'onUpdate', project);
+        const isNullable = attribute.primaryKey !== true && attribute.allowNull !== false;
+        relations.push({
+            name,
+            kind: isOneToOne ? 'oneToOne' : 'foreignKey',
+            targetModel: targetPrepared?.irName ?? link.targetName,
+            columnName: columnName(model.options, attribute),
+            isNullable,
+            onDelete: onDelete ?? 'noAction',
+            ...(reverse === undefined ? {} : { relatedName: reverse.name }),
+            ...(link.keyAttribute === undefined ||
+                link.keyAttribute === targetPrimary?.name ||
+                target === undefined
+                ? {}
+                : { toField: link.keyAttribute }),
+            ...(isPrimary ? { isPrimaryKey: true } : {}),
+            // ON UPDATE CASCADE is what Sequelize adds to every key; only a different action is worth recording.
+            ...(onUpdate === undefined || onUpdate === 'cascade' ? {} : { onUpdate }),
+        });
+        irNames.set(attribute.name, name);
+        irNames.set(columnName(model.options, attribute), name);
+    }
+    for (const link of links.manyToMany) {
+        if (link.owner !== model) {
+            continue;
+        }
+        relations.push(manyToManyRelation(link, takenNames, project));
+    }
+    // Indexes ----------------------------------------------------------------
+    const indexes = [];
+    for (const [name, group] of uniqueGroups) {
+        if (group.length < 2) {
+            continue;
+        }
+        indexes.push({
+            fields: group.map((attribute) => irNames.get(attribute.name) ?? attribute.name),
+            isUnique: true,
+            name,
+        });
+    }
+    for (const raw of modelIndexes) {
+        const names = raw.fields.map((field) => irNames.get(field.name) ?? field.name);
+        const known = new Set([
+            ...fields.map((field) => field.name),
+            ...relations.map((relation) => relation.name),
+        ]);
+        const missing = names.filter((name) => !known.has(name));
+        if (raw.hasExpression || raw.fields.length === 0) {
+            project.warnings.push(`${label}: an index on an expression (Sequelize.literal) cannot be represented and was skipped.`);
+            continue;
+        }
+        if (missing.length > 0) {
+            project.warnings.push(`${label}: the index on (${raw.fields.map((field) => field.name).join(', ')}) refers to "${missing.join('", "')}", which is not a column of the model; it was skipped.`);
+            continue;
+        }
+        if (raw.isPartial) {
+            project.warnings.push(`${label}: the where condition of the index on (${names.join(', ')}) cannot be represented and was dropped.`);
+        }
+        if (raw.type === 'SPATIAL') {
+            project.warnings.push(`${label}: the SPATIAL index on (${names.join(', ')}) was read as an ordinary index.`);
+        }
+        const method = indexMethod(raw.using, label, project);
+        const fieldOptions = {};
+        for (const field of raw.fields) {
+            const options = {
+                ...(field.order === undefined ? {} : { sort: field.order }),
+                ...(field.length === undefined ? {} : { length: field.length }),
+                ...(field.operator === undefined ? {} : { ops: field.operator }),
+            };
+            if (Object.keys(options).length > 0) {
+                fieldOptions[irNames.get(field.name) ?? field.name] = options;
+            }
+        }
+        indexes.push({
+            fields: names,
+            isUnique: raw.unique,
+            ...(raw.name === undefined ? {} : { name: raw.name }),
+            ...(raw.type === 'FULLTEXT' && !raw.unique ? { kind: 'fulltext' } : {}),
+            ...(method === undefined ? {} : { method }),
+            ...(Object.keys(fieldOptions).length === 0 ? {} : { fieldOptions }),
+        });
+    }
+    // Primary key ------------------------------------------------------------
+    let compositePrimaryKey;
+    if (pkAttributes.length === 0) {
+        project.warnings.push(`${label}: the model has no primary key; most ORMs need one, so add primaryKey: true to a column.`);
+    }
+    else if (pkAttributes.length > 1) {
+        compositePrimaryKey = pkAttributes.map((attribute) => irNames.get(attribute.name) ?? attribute.name);
+        for (const field of fields) {
+            if (compositePrimaryKey.includes(field.name)) {
+                field.isPrimaryKey = false;
+                field.isUnique = false;
+            }
+        }
+        for (const relation of relations) {
+            delete relation.isPrimaryKey;
+        }
+    }
+    // Behaviour that is not schema --------------------------------------------
+    const accessors = attributes
+        .filter((attribute) => attribute.hasAccessor === true)
+        .map((attribute) => attribute.name);
+    if (accessors.length > 0) {
+        project.warnings.push(`${label}: custom getters or setters on ${accessors.join(', ')} are behaviour, not schema, and were ignored.`);
+    }
+    if (model.raw.unsupported.length > 0) {
+        project.warnings.push(`${label}: ${model.raw.unsupported.join(', ')} ${model.raw.unsupported.length === 1 ? 'is' : 'are'} not part of the database schema and ${model.raw.unsupported.length === 1 ? 'was' : 'were'} ignored.`);
+    }
+    return {
+        name: model.irName,
+        tableName: model.tableName,
+        appLabel: context.options.appLabel,
+        fields,
+        relations,
+        indexes,
+        ...(compositePrimaryKey === undefined ? {} : { compositePrimaryKey }),
+        ...(model.options.schema === undefined
+            ? {}
+            : { schema: model.options.schema }),
+    };
+}
+function manyToManyRelation(link, takenNames, project) {
+    let name = link.name;
+    while (takenNames.has(name)) {
+        name = `${name}_`;
+    }
+    takenNames.add(name);
+    // Other formats derive the join table from the two models; say what does not survive.
+    const isSelf = link.owner === link.target;
+    const expectedTable = `${link.owner.tableName}_${name}`;
+    const expectedOwner = `${isSelf ? 'from_' : ''}${toSnakeCase(link.owner.irName)}_id`;
+    const expectedTarget = `${isSelf ? 'to_' : ''}${toSnakeCase(link.target.irName)}_id`;
+    if (link.table !== expectedTable ||
+        link.ownerColumn !== expectedOwner ||
+        link.targetColumn !== expectedTarget) {
+        project.warnings.push(`${link.owner.raw.location}: the join table "${link.table}" (columns ${link.ownerColumn}, ${link.targetColumn}) of ${link.label} is not preserved by name; ` +
+            `formats that derive join tables will use "${expectedTable}" (columns ${expectedOwner}, ${expectedTarget}).`);
+    }
+    return {
+        name,
+        kind: 'manyToMany',
+        targetModel: link.target.irName,
+        columnName: `${toSnakeCase(name)}_id`,
+        isNullable: false,
+        onDelete: 'cascade',
+        ...(link.relatedName === undefined
+            ? {}
+            : { relatedName: link.relatedName }),
+    };
+}
+// ---------------------------------------------------------------------------
+// Schema
+// ---------------------------------------------------------------------------
+function addStubModels(models, 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 target = relation.targetModel;
+            if (known.has(target)) {
+                continue;
+            }
+            known.add(target);
+            stubs.push({
+                name: target,
+                tableName: toSnakeCase(target),
+                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 "${target}", which is not a model in the input. ` +
+                `A stub model with an auto-increment id was generated; replace it with the real definition.`);
+        }
+    }
+    models.push(...stubs);
+}
+function buildSchema(project, options) {
+    const prepared = prepareModels(project);
+    const links = linkAssociations(prepared, project);
+    resolveReferences(prepared, project);
+    const context = {
+        project,
+        options,
+        enums: [],
+        prepared,
+        links,
+    };
+    const models = prepared.map((model) => buildModel(context, model));
+    addStubModels(models, project.warnings, options);
+    return { models, enums: context.enums, warnings: project.warnings };
+}
+//# sourceMappingURL=sequelize.js.map