ormbridge 0.6.0 → 0.8.0

package/dist/parsers/sequelizeCollect.js

@@ -0,0 +1,1298 @@
+import { basename } from 'node:path';
+import { evaluateNode, lastSegment, } from './typescriptSyntax.js';
+const ASSOCIATION_METHODS = new Set([
+    'hasMany',
+    'hasOne',
+    'belongsTo',
+    'belongsToMany',
+]);
+/** Decorators of sequelize-typescript that make a property a column. */
+const COLUMN_DECORATORS = new Set([
+    'Column',
+    'PrimaryKey',
+    'AutoIncrement',
+    'AllowNull',
+    'NotNull',
+    'Unique',
+    'Default',
+    'CreatedAt',
+    'UpdatedAt',
+    'DeletedAt',
+    'ForeignKey',
+    'Comment',
+    'Index',
+]);
+const TIMESTAMP_DECORATORS = new Set([
+    'CreatedAt',
+    'UpdatedAt',
+    'DeletedAt',
+]);
+/** Generic wrappers that do not change the column type (`CreationOptional<number>`). */
+const TRANSPARENT_TYPES = new Set([
+    'CreationOptional',
+    'NonAttribute',
+    'ForeignKey',
+    'Promise',
+    'Awaited',
+    'Relation',
+    'Readonly',
+    'Required',
+]);
+const ASSOCIATION_DECORATORS = {
+    HasMany: 'hasMany',
+    HasOne: 'hasOne',
+    BelongsTo: 'belongsTo',
+    BelongsToMany: 'belongsToMany',
+};
+/** Model options that describe behaviour the IR cannot hold, mapped to the name used in the warning. */
+const UNSUPPORTED_MODEL_OPTIONS = {
+    hooks: 'hooks',
+    scopes: 'scopes',
+    defaultScope: 'a default scope',
+    getterMethods: 'getterMethods',
+    setterMethods: 'setterMethods',
+};
+/** Decorators of sequelize-typescript for model behaviour. */
+const UNSUPPORTED_CLASS_DECORATORS = {
+    Scopes: 'scopes',
+    DefaultScope: 'a default scope',
+};
+const HOOK_DECORATORS = new Set([
+    'BeforeCreate',
+    'AfterCreate',
+    'BeforeUpdate',
+    'AfterUpdate',
+    'BeforeDestroy',
+    'AfterDestroy',
+    'BeforeSave',
+    'AfterSave',
+    'BeforeBulkCreate',
+    'AfterBulkCreate',
+    'BeforeValidate',
+    'AfterValidate',
+    'BeforeUpsert',
+    'AfterUpsert',
+    'BeforeFind',
+    'AfterFind',
+    'BeforeSync',
+    'AfterSync',
+    'BeforeDefine',
+    'AfterDefine',
+]);
+// ---------------------------------------------------------------------------
+// Syntax helpers
+// ---------------------------------------------------------------------------
+const TRANSPARENT_NODES = new Set([
+    'parenthesized_expression',
+    'as_expression',
+    'satisfies_expression',
+    'non_null_expression',
+    'type_assertion',
+    'await_expression',
+]);
+export function stripWrappers(node) {
+    let current = node;
+    while (TRANSPARENT_NODES.has(current.type)) {
+        const inner = current.namedChildren[0];
+        if (inner === undefined) {
+            break;
+        }
+        current = inner;
+    }
+    return current;
+}
+export function describeFile(path, root) {
+    const consts = new Map();
+    const stack = [root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node === undefined) {
+            break;
+        }
+        if (node.type === 'variable_declarator') {
+            const nameNode = node.childForFieldName('name');
+            const valueNode = node.childForFieldName('value');
+            if (nameNode !== null &&
+                valueNode !== null &&
+                nameNode.type === 'identifier' &&
+                !consts.has(nameNode.text)) {
+                consts.set(nameNode.text, valueNode);
+            }
+        }
+        stack.push(...node.namedChildren);
+    }
+    return { path, label: basename(path), root, consts };
+}
+/** Follows `const x = ...` references (also across files) until a node that is not a plain name. */
+export function resolveNode(node, ctx) {
+    let current = stripWrappers(node);
+    for (let depth = 0; depth < 8; depth += 1) {
+        if (current.type !== 'identifier') {
+            break;
+        }
+        const local = ctx.file.consts.get(current.text);
+        if (local !== undefined) {
+            current = stripWrappers(local);
+            continue;
+        }
+        const shared = ctx.project.sharedConsts.get(current.text);
+        const only = shared?.length === 1 ? shared[0] : undefined;
+        if (only === undefined) {
+            break;
+        }
+        current = stripWrappers(only.node);
+    }
+    return current;
+}
+function keyText(node) {
+    switch (node.type) {
+        case 'property_identifier':
+        case 'identifier':
+            return node.text;
+        case 'string': {
+            const value = evaluateNode(node);
+            return value.kind === 'string' ? value.value : undefined;
+        }
+        case 'number':
+            return node.text;
+        default:
+            return undefined;
+    }
+}
+/** The `key: value` entries of an object literal, following identifiers and spreads of known objects. */
+export function objectEntries(node, ctx) {
+    const entries = new Map();
+    let incomplete = false;
+    const resolved = resolveNode(node, ctx);
+    if (resolved.type !== 'object') {
+        return { entries, incomplete: true };
+    }
+    for (const child of resolved.namedChildren) {
+        if (child.type === 'pair') {
+            const keyNode = child.childForFieldName('key');
+            const valueNode = child.childForFieldName('value');
+            const key = keyNode === null ? undefined : keyText(keyNode);
+            if (key === undefined || valueNode === null) {
+                incomplete = true;
+            }
+            else {
+                entries.set(key, valueNode);
+            }
+        }
+        else if (child.type === 'shorthand_property_identifier') {
+            entries.set(child.text, child);
+        }
+        else if (child.type === 'method_definition') {
+            const nameNode = child.childForFieldName('name');
+            const key = nameNode === null ? undefined : keyText(nameNode);
+            if (key !== undefined) {
+                entries.set(key, child);
+            }
+        }
+        else if (child.type === 'spread_element') {
+            const inner = child.namedChildren[0];
+            const spread = inner === undefined ? undefined : objectEntries(inner, ctx);
+            if (spread === undefined || spread.incomplete) {
+                incomplete = true;
+            }
+            for (const [key, value] of spread?.entries ?? []) {
+                entries.set(key, value);
+            }
+        }
+    }
+    return { entries, incomplete };
+}
+export function argsOf(call) {
+    const argumentsNode = call.childForFieldName('arguments');
+    return argumentsNode === null
+        ? []
+        : argumentsNode.namedChildren.filter((child) => child.type !== 'comment');
+}
+function valueOf(node, ctx) {
+    return evaluateNode(resolveNode(node, ctx));
+}
+function stringOf(node, ctx) {
+    if (node === undefined) {
+        return undefined;
+    }
+    const value = valueOf(node, ctx);
+    return value.kind === 'string' ? value.value : undefined;
+}
+function boolOf(node, ctx) {
+    if (node === undefined) {
+        return undefined;
+    }
+    const value = valueOf(node, ctx);
+    return value.kind === 'bool' ? value.value : undefined;
+}
+function numberOf(node, ctx) {
+    if (node === undefined) {
+        return undefined;
+    }
+    const value = valueOf(node, ctx);
+    return value.kind === 'number' ? value.value : undefined;
+}
+/** The text of a reference to a model: `User`, `models.User`, `sequelize.models.User`, `sequelize.model('User')`. */
+function modelReference(node, ctx) {
+    const stripped = stripWrappers(node);
+    switch (stripped.type) {
+        case 'identifier':
+        case 'member_expression':
+            return lastSegment(stripped.text.replace(/\s+/g, ''));
+        case 'string':
+            return stringOf(stripped, ctx);
+        case 'call_expression': {
+            const callee = stripped.childForFieldName('function');
+            const first = argsOf(stripped)[0];
+            return callee !== null && /\.model$/.test(callee.text)
+                ? stringOf(first, ctx)
+                : undefined;
+        }
+        case 'arrow_function':
+        case 'function_expression': {
+            // sequelize-typescript: `() => User`
+            const body = stripped.childForFieldName('body');
+            return body === null ? undefined : modelReference(body, ctx);
+        }
+        default:
+            return undefined;
+    }
+}
+// ---------------------------------------------------------------------------
+// Attributes
+// ---------------------------------------------------------------------------
+function describeThrough(node, ctx) {
+    if (node === undefined) {
+        return undefined;
+    }
+    const stripped = stripWrappers(node);
+    if (stripped.type === 'object') {
+        const { entries } = objectEntries(stripped, ctx);
+        const unique = boolOf(entries.get('unique'), ctx);
+        const described = describeThrough(entries.get('model'), ctx);
+        return unique === undefined ? described : { ...(described ?? {}), unique };
+    }
+    // A name that points at `sequelize.define(...)` is a model; only a string constant is a table name.
+    const table = stringOf(stripped, ctx);
+    if (table !== undefined) {
+        return { table };
+    }
+    const model = modelReference(stripped, ctx);
+    return model === undefined ? undefined : { model };
+}
+/**
+ * The value of `references.model`: a table name (also from a string constant), or the name of a model
+ * variable, which must not be followed to the `sequelize.define(...)` call it holds.
+ */
+function modelOrTableName(node, ctx) {
+    const stripped = stripWrappers(node);
+    const resolved = valueOf(stripped, ctx);
+    return resolved.kind === 'string' ? resolved : evaluateNode(stripped);
+}
+/** Reads one attribute definition: `{ type, allowNull, ... }` or a bare `DataTypes.X`. */
+export function readAttribute(name, node, ctx) {
+    const attribute = { name, origin: 'declared' };
+    const resolved = resolveNode(node, ctx);
+    if (resolved.type === 'object') {
+        applyAttributeEntries(attribute, objectEntries(resolved, ctx).entries, ctx);
+    }
+    else if (resolved.type === 'method_definition') {
+        attribute.hasAccessor = true;
+    }
+    else {
+        attribute.type = evaluateNode(resolved);
+    }
+    return attribute;
+}
+/** Applies the options of an attribute object (`allowNull`, `unique`, ...) to an attribute. */
+export function applyAttributeEntries(attribute, entries, ctx) {
+    for (const [key, node] of entries) {
+        switch (key) {
+            case 'type':
+                attribute.type = valueOf(node, ctx);
+                break;
+            case 'allowNull':
+                attribute.allowNull = boolOf(node, ctx) ?? attribute.allowNull;
+                break;
+            case 'primaryKey':
+                attribute.primaryKey = boolOf(node, ctx) ?? attribute.primaryKey;
+                break;
+            case 'autoIncrement':
+                attribute.autoIncrement = boolOf(node, ctx) ?? attribute.autoIncrement;
+                break;
+            case 'unique': {
+                const value = valueOf(node, ctx);
+                if (value.kind === 'bool') {
+                    if (value.value) {
+                        attribute.unique = {};
+                    }
+                    else {
+                        delete attribute.unique;
+                    }
+                }
+                else if (value.kind === 'string') {
+                    attribute.unique = { name: value.value };
+                }
+                else if (value.kind === 'object') {
+                    const unique = value.properties['name'];
+                    attribute.unique =
+                        unique !== undefined && unique.kind === 'string'
+                            ? { name: unique.value }
+                            : {};
+                }
+                break;
+            }
+            case 'defaultValue':
+                attribute.defaultValue = valueOf(node, ctx);
+                break;
+            case 'references': {
+                const resolved = resolveNode(node, ctx);
+                if (resolved.type === 'object') {
+                    const reference = objectEntries(resolved, ctx).entries;
+                    const model = reference.get('model');
+                    const referenceKey = stringOf(reference.get('key'), ctx);
+                    attribute.references = {
+                        ...(model === undefined
+                            ? {}
+                            : { model: modelOrTableName(model, ctx) }),
+                        ...(referenceKey === undefined ? {} : { key: referenceKey }),
+                    };
+                }
+                break;
+            }
+            case 'onDelete':
+                attribute.onDelete = stringOf(node, ctx) ?? attribute.onDelete;
+                break;
+            case 'onUpdate':
+                attribute.onUpdate = stringOf(node, ctx) ?? attribute.onUpdate;
+                break;
+            case 'field':
+                attribute.field = stringOf(node, ctx) ?? attribute.field;
+                break;
+            case 'comment':
+                attribute.comment = stringOf(node, ctx) ?? attribute.comment;
+                break;
+            case 'values': {
+                const value = valueOf(node, ctx);
+                if (value.kind === 'array') {
+                    attribute.enumValues = value.items.flatMap((item) => item.kind === 'string' ? [item.value] : []);
+                }
+                break;
+            }
+            case 'get':
+            case 'set':
+                attribute.hasAccessor = true;
+                break;
+            default:
+                break;
+        }
+    }
+}
+function readKey(node, ctx) {
+    if (node === undefined) {
+        return undefined;
+    }
+    const resolved = resolveNode(node, ctx);
+    if (resolved.type === 'object') {
+        const { entries } = objectEntries(resolved, ctx);
+        const name = stringOf(entries.get('name'), ctx) ??
+            stringOf(entries.get('fieldName'), ctx);
+        const attribute = {
+            name: name ?? '',
+            origin: 'foreignKey',
+        };
+        applyAttributeEntries(attribute, entries, ctx);
+        return { ...(name === undefined ? {} : { name }), attribute };
+    }
+    const name = stringOf(resolved, ctx);
+    return name === undefined
+        ? undefined
+        : { name, attribute: { name, origin: 'foreignKey' } };
+}
+export function readAssociationOptions(node, ctx) {
+    const options = { unsupported: [] };
+    if (node === undefined) {
+        return options;
+    }
+    const resolved = resolveNode(node, ctx);
+    if (resolved.type !== 'object') {
+        // `@BelongsTo(() => User, 'authorId')`
+        const foreignKey = readKey(resolved, ctx);
+        if (foreignKey !== undefined) {
+            options.foreignKey = foreignKey;
+        }
+        return options;
+    }
+    const { entries } = objectEntries(resolved, ctx);
+    for (const [key, value] of entries) {
+        switch (key) {
+            case 'as': {
+                const alias = stringOf(value, ctx);
+                if (alias !== undefined) {
+                    options.as = alias;
+                }
+                else {
+                    const object = valueOf(value, ctx);
+                    const plural = object.kind === 'object' ? object.properties['plural'] : undefined;
+                    if (plural !== undefined && plural.kind === 'string') {
+                        options.as = plural.value;
+                    }
+                }
+                break;
+            }
+            case 'foreignKey': {
+                const foreignKey = readKey(value, ctx);
+                if (foreignKey !== undefined) {
+                    options.foreignKey = foreignKey;
+                }
+                break;
+            }
+            case 'otherKey': {
+                const otherKey = readKey(value, ctx);
+                if (otherKey !== undefined) {
+                    options.otherKey = otherKey;
+                }
+                break;
+            }
+            case 'sourceKey':
+                options.sourceKey = stringOf(value, ctx);
+                break;
+            case 'targetKey':
+                options.targetKey = stringOf(value, ctx);
+                break;
+            case 'onDelete':
+                options.onDelete = stringOf(value, ctx);
+                break;
+            case 'onUpdate':
+                options.onUpdate = stringOf(value, ctx);
+                break;
+            case 'constraints':
+                options.constraints = boolOf(value, ctx);
+                break;
+            case 'through': {
+                const through = describeThrough(value, ctx);
+                if (through !== undefined) {
+                    options.through = through;
+                }
+                break;
+            }
+            case 'scope':
+                options.unsupported.push('scope (a polymorphic or scoped association)');
+                break;
+            default:
+                break;
+        }
+    }
+    return options;
+}
+// ---------------------------------------------------------------------------
+// Models: sequelize.define, Model.init
+// ---------------------------------------------------------------------------
+function newModel(ctx, style, modelName, aliases) {
+    return {
+        file: ctx.file,
+        style,
+        modelName,
+        aliases,
+        attributes: [],
+        optionEntries: new Map(),
+        decoratorOptions: {},
+        indexes: [],
+        foreignKeyHints: new Map(),
+        accessors: [],
+        unsupported: [],
+        location: `${ctx.file.label}: model "${modelName}"`,
+    };
+}
+function addAttributes(model, node, ctx) {
+    if (node === undefined) {
+        return false;
+    }
+    const { entries, incomplete } = objectEntries(node, ctx);
+    if (!incomplete || entries.size > 0) {
+        for (const [name, value] of entries) {
+            model.attributes.push(readAttribute(name, value, ctx));
+        }
+    }
+    if (incomplete && entries.size > 0) {
+        ctx.project.warnings.push(`${model.location}: the attributes are not a plain object literal (a spread, a computed key or a value that could not be followed), so some columns may be missing.`);
+    }
+    return entries.size > 0 || !incomplete;
+}
+/** The name a call expression's result is stored under: `const User = ...`, `db.User = ...`. */
+function boundName(call) {
+    let current = call.parent;
+    while (current !== null && TRANSPARENT_NODES.has(current.type)) {
+        current = current.parent;
+    }
+    if (current === null) {
+        return undefined;
+    }
+    if (current.type === 'variable_declarator') {
+        const nameNode = current.childForFieldName('name');
+        return nameNode !== null && nameNode.type === 'identifier'
+            ? nameNode.text
+            : undefined;
+    }
+    if (current.type === 'assignment_expression') {
+        const left = current.childForFieldName('left');
+        return left === null
+            ? undefined
+            : lastSegment(left.text.replace(/\s+/g, ''));
+    }
+    return undefined;
+}
+function collectDefine(call, ctx) {
+    const args = argsOf(call);
+    const nameNode = args[0];
+    const attributesNode = args[1];
+    const modelName = stringOf(nameNode, ctx);
+    if (nameNode === undefined || attributesNode === undefined) {
+        return;
+    }
+    if (modelName === undefined) {
+        ctx.project.warnings.push(`${ctx.file.label}: sequelize.define(${nameNode.text.slice(0, 40)}, ...) has a model name that is not a string literal, so the model was skipped.`);
+        return;
+    }
+    const bound = boundName(call);
+    const model = newModel(ctx, 'define', modelName, bound === undefined ? [] : [bound]);
+    if (!addAttributes(model, attributesNode, ctx)) {
+        ctx.project.warnings.push(`${model.location}: the attributes of sequelize.define could not be read statically, so the model was skipped.`);
+        return;
+    }
+    const optionsNode = args[2];
+    if (optionsNode !== undefined) {
+        model.optionEntries = objectEntries(optionsNode, ctx).entries;
+    }
+    ctx.project.models.push(model);
+}
+/** The name of the class a node is inside, or of the object `X.associate = ...` is assigned to. */
+function enclosingModelName(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (current.type === 'class_declaration' ||
+            current.type === 'abstract_class_declaration' ||
+            current.type === 'class') {
+            return current.childForFieldName('name')?.text;
+        }
+        if (current.type === 'assignment_expression') {
+            const left = current.childForFieldName('left');
+            if (left !== null && left.type === 'member_expression') {
+                const objectNode = left.childForFieldName('object');
+                if (objectNode !== null) {
+                    return lastSegment(objectNode.text.replace(/\s+/g, ''));
+                }
+            }
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+function collectInit(call, ctx) {
+    const args = argsOf(call);
+    const attributesNode = args[0];
+    const optionsNode = args[1];
+    if (attributesNode === undefined || optionsNode === undefined) {
+        return;
+    }
+    const options = objectEntries(optionsNode, ctx);
+    // `Model.init(attributes, { sequelize })` is the only shape that defines a model.
+    if (!options.entries.has('sequelize')) {
+        return;
+    }
+    const functionNode = call.childForFieldName('function');
+    const receiver = functionNode === null ? null : functionNode.childForFieldName('object');
+    if (receiver === null) {
+        return;
+    }
+    const className = receiver.type === 'identifier'
+        ? receiver.text
+        : receiver.type === 'this' || receiver.type === 'super'
+            ? enclosingModelName(call)
+            : undefined;
+    const modelName = stringOf(options.entries.get('modelName'), ctx) ?? className;
+    if (modelName === undefined) {
+        ctx.project.warnings.push(`${ctx.file.label}: a Model.init call has no modelName and no class name, so the model was skipped.`);
+        return;
+    }
+    const model = newModel(ctx, 'init', modelName, className === undefined ? [] : [className]);
+    if (!addAttributes(model, attributesNode, ctx)) {
+        ctx.project.warnings.push(`${model.location}: the attributes of Model.init could not be read statically, so the model was skipped.`);
+        return;
+    }
+    model.optionEntries = options.entries;
+    ctx.project.models.push(model);
+}
+// ---------------------------------------------------------------------------
+// Association calls
+// ---------------------------------------------------------------------------
+function collectAssociationCall(call, method, receiver, ctx) {
+    const args = argsOf(call);
+    const targetNode = args[0];
+    if (targetNode === undefined) {
+        return;
+    }
+    const target = modelReference(targetNode, ctx);
+    const source = receiver.type === 'this'
+        ? 'this'
+        : (modelReference(receiver, ctx) ??
+            lastSegment(receiver.text.replace(/\s+/g, '')));
+    if (target === undefined) {
+        ctx.project.warnings.push(`${ctx.file.label}: ${source}.${method}(${targetNode.text.slice(0, 40)}) names its target in a way that cannot be resolved statically; the association was skipped.`);
+        return;
+    }
+    ctx.project.associations.push({
+        kind: method,
+        file: ctx.file,
+        source,
+        enclosing: receiver.type === 'this' ? enclosingModelName(call) : undefined,
+        target,
+        options: readAssociationOptions(args[1], ctx),
+        label: `${source === 'this' ? (enclosingModelName(call) ?? 'this') : source}.${method}(${target})`,
+    });
+}
+// ---------------------------------------------------------------------------
+// Model options and indexes
+// ---------------------------------------------------------------------------
+function timestampOption(entries, key, fallback, ctx) {
+    const node = entries.get(key);
+    if (node !== undefined) {
+        const value = valueOf(node, ctx);
+        if (value.kind === 'string' && value.value !== '') {
+            return value.value;
+        }
+        if (value.kind === 'bool' && !value.value) {
+            return false;
+        }
+    }
+    return fallback ?? key;
+}
+/** Reads the options of a model, with the project defaults and the decorators' contributions below them. */
+export function readModelOptions(model, project) {
+    const ctx = { file: model.file, project };
+    const entries = model.optionEntries;
+    const defaults = project.defaults;
+    const flag = (key, fallback) => {
+        const value = boolOf(entries.get(key), ctx);
+        const inherited = defaults[key];
+        return value ?? (typeof inherited === 'boolean' ? inherited : fallback);
+    };
+    const decorated = model.decoratorOptions;
+    const schema = stringOf(entries.get('schema'), ctx) ?? defaults.schema;
+    const version = entries.get('version');
+    const versionValue = version === undefined ? undefined : valueOf(version, ctx);
+    const nameNode = entries.get('name');
+    const nameValue = nameNode === undefined ? undefined : valueOf(nameNode, ctx);
+    const nameProperties = nameValue !== undefined && nameValue.kind === 'object'
+        ? nameValue.properties
+        : {};
+    const singular = nameProperties['singular'];
+    const plural = nameProperties['plural'];
+    const tableName = stringOf(entries.get('tableName'), ctx) ?? decorated.tableName;
+    return {
+        ...(tableName === undefined ? {} : { tableName }),
+        freezeTableName: flag('freezeTableName', false),
+        timestamps: flag('timestamps', true),
+        paranoid: flag('paranoid', false),
+        underscored: flag('underscored', false),
+        ...(schema === undefined ? {} : { schema }),
+        createdAt: timestampOption(entries, 'createdAt', decorated.createdAt ?? defaults.createdAt, ctx),
+        updatedAt: timestampOption(entries, 'updatedAt', decorated.updatedAt ?? defaults.updatedAt, ctx),
+        deletedAt: timestampOption(entries, 'deletedAt', decorated.deletedAt ?? defaults.deletedAt, ctx),
+        ...(versionValue !== undefined &&
+            versionValue.kind === 'bool' &&
+            versionValue.value
+            ? { version: 'version' }
+            : versionValue !== undefined && versionValue.kind === 'string'
+                ? { version: versionValue.value }
+                : {}),
+        ...(singular !== undefined && singular.kind === 'string'
+            ? { nameSingular: singular.value }
+            : {}),
+        ...(plural !== undefined && plural.kind === 'string'
+            ? { namePlural: plural.value }
+            : {}),
+    };
+}
+function indexFieldOf(node, ctx) {
+    const resolved = resolveNode(node, ctx);
+    const text = stringOf(resolved, ctx);
+    if (text !== undefined) {
+        return { name: text };
+    }
+    if (resolved.type === 'object') {
+        const { entries } = objectEntries(resolved, ctx);
+        const name = stringOf(entries.get('name'), ctx) ??
+            stringOf(entries.get('attribute'), ctx);
+        if (name !== undefined) {
+            const order = stringOf(entries.get('order'), ctx);
+            const length = numberOf(entries.get('length'), ctx);
+            const operator = stringOf(entries.get('operator'), ctx);
+            return {
+                name,
+                ...(order === undefined
+                    ? {}
+                    : { order: order.toUpperCase() === 'DESC' ? 'desc' : 'asc' }),
+                ...(length === undefined ? {} : { length }),
+                ...(operator === undefined ? {} : { operator }),
+            };
+        }
+    }
+    return 'expression';
+}
+/** Reads the `indexes` option (and the `uniqueKeys` option) of a model. */
+export function readIndexes(model, project) {
+    const ctx = { file: model.file, project };
+    // sequelize-typescript lets the indexes option of @Table replace the ones its @Index decorators collect.
+    const replaced = model.indexes.length > 0 && model.optionEntries.has('indexes');
+    if (replaced) {
+        project.warnings.push(`${model.location}: the indexes option of @Table replaces the indexes declared with @Index, so sequelize-typescript ignores the latter; they were ignored.`);
+    }
+    const indexes = replaced ? [] : [...model.indexes];
+    const listNode = model.optionEntries.get('indexes');
+    const list = listNode === undefined ? undefined : resolveNode(listNode, ctx);
+    if (list !== undefined && list.type === 'array') {
+        for (const item of list.namedChildren) {
+            const raw = readIndex(item, ctx);
+            if (raw !== undefined) {
+                indexes.push(raw);
+            }
+        }
+    }
+    const keysNode = model.optionEntries.get('uniqueKeys');
+    const keys = keysNode === undefined ? undefined : resolveNode(keysNode, ctx);
+    if (keys !== undefined && keys.type === 'object') {
+        for (const [name, value] of objectEntries(keys, ctx).entries) {
+            const raw = readIndex(value, ctx);
+            if (raw !== undefined) {
+                indexes.push({ ...raw, unique: true, name: raw.name ?? name });
+            }
+        }
+    }
+    return indexes;
+}
+function readIndex(node, ctx) {
+    const { entries } = objectEntries(node, ctx);
+    const fieldsNode = entries.get('fields');
+    const fields = fieldsNode === undefined ? undefined : resolveNode(fieldsNode, ctx);
+    if (fields === undefined || fields.type !== 'array') {
+        return undefined;
+    }
+    const readFields = [];
+    let hasExpression = false;
+    for (const item of fields.namedChildren) {
+        const field = indexFieldOf(item, ctx);
+        if (field === 'expression') {
+            hasExpression = true;
+        }
+        else {
+            readFields.push(field);
+        }
+    }
+    const type = stringOf(entries.get('type'), ctx);
+    const upperType = type?.toUpperCase();
+    const name = stringOf(entries.get('name'), ctx);
+    const using = stringOf(entries.get('using'), ctx);
+    return {
+        fields: readFields,
+        unique: boolOf(entries.get('unique'), ctx) === true || upperType === 'UNIQUE',
+        ...(name === undefined ? {} : { name }),
+        ...(using === undefined ? {} : { using }),
+        ...(upperType === 'FULLTEXT' || upperType === 'SPATIAL'
+            ? { type: upperType }
+            : {}),
+        isPartial: entries.has('where'),
+        hasExpression,
+    };
+}
+/** Unsupported model options (hooks, scopes, getters, ...), as written in the options object. */
+function noteUnsupportedOptions(model) {
+    for (const [key, label] of Object.entries(UNSUPPORTED_MODEL_OPTIONS)) {
+        if (model.optionEntries.has(key) && !model.unsupported.includes(label)) {
+            model.unsupported.push(label);
+        }
+    }
+}
+function decoratorOf(node) {
+    const expression = node.namedChildren[0];
+    if (expression === undefined) {
+        return undefined;
+    }
+    if (expression.type === 'call_expression') {
+        const callee = expression.childForFieldName('function');
+        return callee === null
+            ? undefined
+            : {
+                name: lastSegment(callee.text.replace(/\s+/g, '')),
+                args: argsOf(expression),
+            };
+    }
+    return {
+        name: lastSegment(expression.text.replace(/\s+/g, '')),
+        args: [],
+    };
+}
+/** The decorators written on a node (a class, an export statement or a property). */
+function decoratorNodes(node) {
+    const decorators = [];
+    for (const child of node.namedChildren) {
+        const decorator = child.type === 'decorator' ? decoratorOf(child) : undefined;
+        if (decorator !== undefined) {
+            decorators.push(decorator);
+        }
+    }
+    return decorators;
+}
+/** The TypeScript type of a property, reduced to a name and whether null is allowed. */
+function describeTsType(property) {
+    const annotation = property.childForFieldName('type');
+    const typeNode = annotation?.namedChildren[0];
+    let nullable = property.children.some((child) => child.type === '?');
+    let name;
+    const visit = (node) => {
+        switch (node.type) {
+            case 'union_type':
+            case 'parenthesized_type':
+                node.namedChildren.forEach(visit);
+                return;
+            case 'literal_type':
+                if (node.text === 'null' || node.text === 'undefined') {
+                    nullable = true;
+                }
+                return;
+            case 'predefined_type':
+            case 'type_identifier':
+                if (node.text === 'null' || node.text === 'undefined') {
+                    nullable = true;
+                }
+                else if (name === undefined) {
+                    name = node.text;
+                }
+                return;
+            case 'generic_type': {
+                // `CreationOptional<number>`, `Promise<User>`, `Array<string>`
+                const base = node.namedChildren[0]?.text ?? '';
+                const inner = node.namedChildren[1]?.namedChildren[0];
+                if (inner !== undefined && TRANSPARENT_TYPES.has(base)) {
+                    visit(inner);
+                }
+                else if (name === undefined) {
+                    name = base;
+                }
+                return;
+            }
+            default:
+                if (name === undefined) {
+                    name = node.text;
+                }
+        }
+    };
+    if (typeNode !== undefined) {
+        visit(typeNode);
+    }
+    return { name, nullable };
+}
+function applyDecorators(attribute, decorators, model, ctx) {
+    for (const decorator of decorators) {
+        const first = decorator.args[0];
+        switch (decorator.name) {
+            case 'Column': {
+                if (first === undefined) {
+                    break;
+                }
+                const resolved = resolveNode(first, ctx);
+                if (resolved.type === 'object') {
+                    applyAttributeEntries(attribute, objectEntries(resolved, ctx).entries, ctx);
+                }
+                else {
+                    attribute.type = evaluateNode(resolved);
+                }
+                break;
+            }
+            case 'PrimaryKey':
+                attribute.primaryKey = true;
+                break;
+            case 'AutoIncrement':
+                attribute.autoIncrement = true;
+                break;
+            case 'AllowNull':
+                attribute.allowNull = boolOf(first, ctx) ?? true;
+                break;
+            case 'NotNull':
+                attribute.allowNull = false;
+                break;
+            case 'Unique': {
+                const value = first === undefined ? undefined : valueOf(first, ctx);
+                if (value !== undefined && value.kind === 'bool' && !value.value) {
+                    delete attribute.unique;
+                }
+                else if (value !== undefined && value.kind === 'string') {
+                    attribute.unique = { name: value.value };
+                }
+                else if (value !== undefined && value.kind === 'object') {
+                    const name = value.properties['name'];
+                    attribute.unique =
+                        name !== undefined && name.kind === 'string'
+                            ? { name: name.value }
+                            : {};
+                }
+                else {
+                    attribute.unique = {};
+                }
+                break;
+            }
+            case 'Default':
+                if (first !== undefined) {
+                    attribute.defaultValue = valueOf(first, ctx);
+                }
+                break;
+            case 'Comment':
+                attribute.comment = stringOf(first, ctx) ?? attribute.comment;
+                break;
+            case 'CreatedAt':
+            case 'UpdatedAt':
+            case 'DeletedAt': {
+                const kind = decorator.name === 'CreatedAt'
+                    ? 'createdAt'
+                    : decorator.name === 'UpdatedAt'
+                        ? 'updatedAt'
+                        : 'deletedAt';
+                attribute.timestamp = kind;
+                model.decoratorOptions[kind] = attribute.name;
+                break;
+            }
+            case 'ForeignKey': {
+                const target = first === undefined ? undefined : modelReference(first, ctx);
+                if (target !== undefined) {
+                    model.foreignKeyHints.set(attribute.name, target);
+                }
+                break;
+            }
+            case 'Index': {
+                model.indexes.push(...indexFromDecorator(attribute.name, decorator, ctx));
+                break;
+            }
+            default:
+                break;
+        }
+    }
+}
+/** `@Index`, `@Index('name')` and `@Index({ name, unique, using })` on a property. */
+function indexFromDecorator(attributeName, decorator, ctx) {
+    const first = decorator.args[0];
+    let name;
+    let unique = false;
+    let using;
+    let type;
+    if (first !== undefined) {
+        const resolved = resolveNode(first, ctx);
+        if (resolved.type === 'object') {
+            const { entries } = objectEntries(resolved, ctx);
+            name = stringOf(entries.get('name'), ctx);
+            unique = boolOf(entries.get('unique'), ctx) === true;
+            using = stringOf(entries.get('using'), ctx);
+            type = stringOf(entries.get('type'), ctx)?.toUpperCase();
+        }
+        else {
+            name = stringOf(resolved, ctx);
+        }
+    }
+    return [
+        {
+            fields: [{ name: attributeName }],
+            unique: unique || type === 'UNIQUE',
+            ...(name === undefined ? {} : { name }),
+            ...(using === undefined ? {} : { using }),
+            ...(type === 'FULLTEXT' || type === 'SPATIAL' ? { type } : {}),
+            isPartial: false,
+            hasExpression: false,
+        },
+    ];
+}
+/** Merges indexes that several properties contributed under one name into a composite index. */
+export function mergeNamedIndexes(indexes) {
+    const merged = [];
+    const byName = new Map();
+    for (const index of indexes) {
+        const existing = index.name === undefined ? undefined : byName.get(index.name);
+        if (existing === undefined) {
+            const copy = { ...index, fields: [...index.fields] };
+            merged.push(copy);
+            if (index.name !== undefined) {
+                byName.set(index.name, copy);
+            }
+        }
+        else if (index.fields.length === 1 && existing.fields.length > 0) {
+            const only = index.fields[0];
+            if (only !== undefined) {
+                existing.fields.push(only);
+            }
+            existing.unique = existing.unique || index.unique;
+        }
+        else {
+            merged.push(index);
+        }
+    }
+    return merged;
+}
+function collectDecoratedClass(classNode, outerDecorators, ctx) {
+    const nameNode = classNode.childForFieldName('name');
+    const bodyNode = classNode.childForFieldName('body');
+    if (nameNode === null || bodyNode === null) {
+        return;
+    }
+    const decorators = [
+        ...outerDecorators,
+        ...decoratorNodes(classNode),
+    ];
+    const table = decorators.find((decorator) => decorator.name === 'Table');
+    if (table === undefined) {
+        return;
+    }
+    const className = nameNode.text;
+    const optionsNode = table.args[0];
+    const optionEntries = optionsNode === undefined ? undefined : objectEntries(optionsNode, ctx);
+    const modelName = stringOf(optionEntries?.entries.get('modelName'), ctx) ?? className;
+    const model = newModel(ctx, 'decorators', modelName, [className]);
+    model.optionEntries = optionEntries?.entries ?? new Map();
+    for (const decorator of decorators) {
+        const unsupported = UNSUPPORTED_CLASS_DECORATORS[decorator.name];
+        if (unsupported !== undefined && !model.unsupported.includes(unsupported)) {
+            model.unsupported.push(unsupported);
+        }
+    }
+    // Properties carry their decorators; for methods (accessors, hooks) they are separate siblings before it.
+    let pending = [];
+    for (const member of bodyNode.namedChildren) {
+        if (member.type === 'decorator') {
+            const decorator = decoratorOf(member);
+            if (decorator !== undefined) {
+                pending.push(decorator);
+            }
+            continue;
+        }
+        const carried = pending;
+        pending = [];
+        if (member.type !== 'public_field_definition' &&
+            member.type !== 'method_definition' &&
+            member.type !== 'abstract_method_signature') {
+            continue;
+        }
+        const memberName = member.childForFieldName('name');
+        if (memberName === null) {
+            continue;
+        }
+        const memberDecorators = [
+            ...carried,
+            ...decoratorNodes(member),
+        ];
+        if (memberDecorators.length === 0) {
+            continue;
+        }
+        if (member.type === 'method_definition' &&
+            memberDecorators.some((decorator) => HOOK_DECORATORS.has(decorator.name))) {
+            if (!model.unsupported.includes('hooks')) {
+                model.unsupported.push('hooks');
+            }
+            continue;
+        }
+        const association = memberDecorators.find((decorator) => ASSOCIATION_DECORATORS[decorator.name] !== undefined);
+        if (association !== undefined) {
+            collectDecoratedAssociation(association, memberName.text, model, className, ctx);
+            continue;
+        }
+        if (!memberDecorators.some((decorator) => COLUMN_DECORATORS.has(decorator.name))) {
+            continue;
+        }
+        const attribute = {
+            name: memberName.text,
+            origin: 'declared',
+        };
+        if (member.type === 'public_field_definition') {
+            const tsType = describeTsType(member);
+            if (tsType.name !== undefined) {
+                attribute.tsType = tsType.name;
+            }
+            attribute.tsNullable = tsType.nullable;
+        }
+        applyDecorators(attribute, memberDecorators, model, ctx);
+        // `@CreatedAt` alone only names the timestamp column; Sequelize creates it. With `@Column` it is declared.
+        if (memberDecorators.some((decorator) => COLUMN_DECORATORS.has(decorator.name) &&
+            !TIMESTAMP_DECORATORS.has(decorator.name))) {
+            model.attributes.push(attribute);
+        }
+    }
+    ctx.project.models.push(model);
+}
+function collectDecoratedAssociation(decorator, propertyName, model, className, ctx) {
+    const kind = ASSOCIATION_DECORATORS[decorator.name];
+    const targetNode = decorator.args[0];
+    if (kind === undefined || targetNode === undefined) {
+        return;
+    }
+    const target = modelReference(targetNode, ctx);
+    if (target === undefined) {
+        ctx.project.warnings.push(`${model.location}: @${decorator.name} on "${propertyName}" names its target in a way that cannot be resolved statically; the association was skipped.`);
+        return;
+    }
+    const second = decorator.args[1];
+    let options;
+    if (kind === 'belongsToMany') {
+        // @BelongsToMany(() => Tag, () => PostTag, 'postId', 'tagId') or (() => Tag, { through })
+        const secondResolved = second === undefined ? undefined : resolveNode(second, ctx);
+        if (secondResolved !== undefined && secondResolved.type === 'object') {
+            options = readAssociationOptions(secondResolved, ctx);
+        }
+        else {
+            options = { unsupported: [] };
+            const through = describeThrough(second, ctx);
+            if (through !== undefined) {
+                options.through = through;
+            }
+            const foreignKey = readKey(decorator.args[2], ctx);
+            const otherKey = readKey(decorator.args[3], ctx);
+            if (foreignKey !== undefined) {
+                options.foreignKey = foreignKey;
+            }
+            if (otherKey !== undefined) {
+                options.otherKey = otherKey;
+            }
+        }
+    }
+    else {
+        options = readAssociationOptions(second, ctx);
+    }
+    if (options.as === undefined) {
+        options.as = propertyName;
+    }
+    ctx.project.associations.push({
+        kind,
+        file: ctx.file,
+        source: className,
+        enclosing: className,
+        target,
+        options,
+        propertyName,
+        owner: model,
+        label: `${className}.${propertyName} (@${decorator.name})`,
+    });
+}
+// ---------------------------------------------------------------------------
+// Entry point of the walk
+// ---------------------------------------------------------------------------
+function isSequelizeConstructor(node) {
+    const constructor = node.childForFieldName('constructor');
+    return constructor !== null && /(^|\.)Sequelize$/.test(constructor.text);
+}
+function readGlobalDefaults(node, ctx) {
+    const args = argsOf(node);
+    for (const arg of args) {
+        const resolved = resolveNode(arg, ctx);
+        if (resolved.type !== 'object') {
+            continue;
+        }
+        const define = objectEntries(resolved, ctx).entries.get('define');
+        if (define === undefined) {
+            continue;
+        }
+        const entries = objectEntries(define, ctx).entries;
+        const defaults = {};
+        for (const key of [
+            'freezeTableName',
+            'timestamps',
+            'paranoid',
+            'underscored',
+        ]) {
+            const value = boolOf(entries.get(key), ctx);
+            if (value !== undefined) {
+                defaults[key] = value;
+            }
+        }
+        for (const key of ['createdAt', 'updatedAt', 'deletedAt']) {
+            const entry = entries.get(key);
+            const value = entry === undefined ? undefined : valueOf(entry, ctx);
+            if (value !== undefined && value.kind === 'string') {
+                defaults[key] = value.value;
+            }
+            else if (value !== undefined && value.kind === 'bool' && !value.value) {
+                defaults[key] = false;
+            }
+        }
+        const schema = stringOf(entries.get('schema'), ctx);
+        if (schema !== undefined) {
+            defaults.schema = schema;
+        }
+        if (Object.keys(ctx.project.defaults).length === 0) {
+            Object.assign(ctx.project.defaults, defaults);
+        }
+    }
+}
+/** Walks one file and records its models, association calls and the shared `define` defaults. */
+export function collectFile(file, project) {
+    const ctx = { file, project };
+    const stack = [file.root];
+    while (stack.length > 0) {
+        const node = stack.pop();
+        if (node === undefined) {
+            break;
+        }
+        const children = node.namedChildren;
+        for (let index = children.length - 1; index >= 0; index -= 1) {
+            const child = children[index];
+            if (child !== undefined) {
+                stack.push(child);
+            }
+        }
+        switch (node.type) {
+            case 'call_expression': {
+                const callee = node.childForFieldName('function');
+                if (callee === null || callee.type !== 'member_expression') {
+                    break;
+                }
+                const property = callee.childForFieldName('property');
+                const receiver = callee.childForFieldName('object');
+                if (property === null || receiver === null) {
+                    break;
+                }
+                if (property.text === 'define') {
+                    collectDefine(node, ctx);
+                }
+                else if (property.text === 'init') {
+                    collectInit(node, ctx);
+                }
+                else if (ASSOCIATION_METHODS.has(property.text)) {
+                    collectAssociationCall(node, property.text, receiver, ctx);
+                }
+                break;
+            }
+            case 'new_expression':
+                if (isSequelizeConstructor(node)) {
+                    readGlobalDefaults(node, ctx);
+                }
+                break;
+            case 'export_statement': {
+                // `@Table(...) export class X` keeps the decorators on the export statement.
+                const decorators = decoratorNodes(node);
+                const classNode = node.namedChildren.find((child) => child.type === 'class_declaration' ||
+                    child.type === 'abstract_class_declaration' ||
+                    child.type === 'class');
+                if (classNode !== undefined && decorators.length > 0) {
+                    collectDecoratedClass(classNode, decorators, ctx);
+                }
+                break;
+            }
+            case 'class_declaration':
+            case 'abstract_class_declaration':
+                collectDecoratedClass(node, [], ctx);
+                break;
+            default:
+                break;
+        }
+    }
+    for (const model of project.models) {
+        if (model.file === file && model.optionEntries.size > 0) {
+            noteUnsupportedOptions(model);
+        }
+    }
+}
+//# sourceMappingURL=sequelizeCollect.js.map