@forestadmin/datasource-sql 1.0.0-beta.5 → 1.0.0-beta.50

package/dist/introspection/helpers/default-value-parser.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+class DefaultValueParser {
+    constructor(dialect) {
+        this.dialect = dialect;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    parse(expression, type) {
+        if (expression === null || expression === undefined)
+            return undefined;
+        if (typeof expression === 'string' && expression.startsWith('NULL'))
+            return null;
+        // FA backend not handle correctly
+        if (type.key === sequelize_1.DataTypes.ARRAY.key) {
+            return undefined;
+        }
+        try {
+            const result = this.parseGeneric(expression, type);
+            return result !== undefined ? result : (0, sequelize_1.literal)(expression);
+        }
+        catch (e) {
+            return (0, sequelize_1.literal)(expression);
+        }
+    }
+    parseGeneric(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expression, type) {
+        let sanitizedExpression = expression;
+        // sanitize string
+        if (typeof expression === 'string') {
+            sanitizedExpression = this.sanitizeExpression(expression);
+        }
+        if (type.key === sequelize_1.DataTypes.ENUM.key) {
+            return sanitizedExpression;
+        }
+        switch (type) {
+            case sequelize_1.DataTypes.BOOLEAN:
+                return [true, 'true', 'TRUE', "b'1'", '1'].includes(sanitizedExpression);
+            case sequelize_1.DataTypes.NUMBER:
+            case sequelize_1.DataTypes.BIGINT:
+            case sequelize_1.DataTypes.FLOAT:
+            case sequelize_1.DataTypes.DOUBLE:
+                return this.parseNumber(sanitizedExpression);
+            case sequelize_1.DataTypes.DATE:
+            case sequelize_1.DataTypes.DATEONLY:
+                return this.literalUnlessMatch(/^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})|(\d{4}-\d{2}-\d{2})|(\d{2}:\d{2}:\d{2})$/, sanitizedExpression);
+            case sequelize_1.DataTypes.STRING:
+                return sanitizedExpression;
+            case sequelize_1.DataTypes.JSON:
+            case sequelize_1.DataTypes.JSONB:
+                return JSON.parse(sanitizedExpression);
+            default:
+                return undefined;
+        }
+    }
+    sanitizeExpression(expression) {
+        let sanitizedExpression = expression;
+        if (/^'.*'$/.test(sanitizedExpression)) {
+            sanitizedExpression = expression.substring(1, expression.length - 1);
+        }
+        if (this.dialect === 'mssql') {
+            // Sequelize send default values with weird char at the beginning (`(Ndefault value`)
+            sanitizedExpression = sanitizedExpression.replace(/\(N/, '');
+            while (/^\(.*\)$/.test(sanitizedExpression)) {
+                sanitizedExpression = sanitizedExpression.substring(1, sanitizedExpression.length - 1);
+            }
+        }
+        return sanitizedExpression;
+    }
+    literalUnlessMatch(regexp, expression) {
+        return regexp.test(expression) ? expression : (0, sequelize_1.literal)(expression);
+    }
+    parseNumber(expression) {
+        const result = Number.parseFloat(expression);
+        return Number.isNaN(result) ? (0, sequelize_1.literal)(expression) : result;
+    }
+}
+exports.default = DefaultValueParser;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/introspection/helpers/sql-type-converter.d.ts

@@ -0,0 +1,14 @@
+import { AbstractDataType, AbstractDataTypeConstructor, ColumnDescription, Sequelize } from 'sequelize';
+export default class SqlTypeConverter {
+    private readonly enumRegex;
+    private readonly arrayTypeGetter;
+    constructor(sequelize: Sequelize);
+    private typeMatch;
+    private typeStartsWith;
+    private typeContains;
+    private convertToEnum;
+    private getTypeForUserDefined;
+    private getTypeForArray;
+    convert(tableName: string, columnName: string, columnInfo: ColumnDescription): Promise<AbstractDataType | AbstractDataTypeConstructor>;
+}
+//# sourceMappingURL=sql-type-converter.d.ts.map

package/dist/introspection/helpers/sql-type-converter.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const array_type_getter_1 = __importDefault(require("./array-type-getter"));
+class SqlTypeConverter {
+    constructor(sequelize) {
+        this.enumRegex = /ENUM\((.*)\)/i;
+        this.arrayTypeGetter = new array_type_getter_1.default(sequelize);
+    }
+    typeMatch(type, value) {
+        return (type.match(value) || {}).input;
+    }
+    typeStartsWith(type, value) {
+        return this.typeMatch(type, new RegExp(`^${value}.*`, 'i'));
+    }
+    typeContains(type, value) {
+        return this.typeMatch(type, new RegExp(`${value}.*`, 'i'));
+    }
+    convertToEnum(type) {
+        const enumOptions = this.enumRegex.exec(type)?.[1];
+        return sequelize_1.DataTypes.ENUM(...enumOptions.replace(/'/g, '').split(','));
+    }
+    getTypeForUserDefined(columnInfo) {
+        const { special } = columnInfo;
+        if (special && special.length > 0) {
+            return sequelize_1.DataTypes.ENUM(...special);
+        }
+        // User-defined enum with no values will default to string
+        return sequelize_1.DataTypes.STRING;
+    }
+    async getTypeForArray(tableName, columnName) {
+        const { type, special } = await this.arrayTypeGetter.getType(tableName, columnName);
+        const arrayType = await this.convert(tableName, columnName, {
+            type,
+            special,
+        });
+        return sequelize_1.DataTypes.ARRAY(arrayType);
+    }
+    async convert(tableName, columnName, columnInfo) {
+        const { type } = columnInfo;
+        switch (type) {
+            case 'JSON':
+                return sequelize_1.DataTypes.JSON;
+            case 'TINYINT(1)': // MYSQL bool
+            case 'BIT': // NOTICE: MSSQL type.
+            case 'BOOLEAN':
+                return sequelize_1.DataTypes.BOOLEAN;
+            case 'CHARACTER VARYING':
+            case 'TEXT':
+            case 'NTEXT': // MSSQL type
+            case this.typeContains(type, 'TEXT'):
+            case this.typeContains(type, 'VARCHAR'):
+            case this.typeContains(type, 'CHAR'):
+            case 'NVARCHAR': // NOTICE: MSSQL type.
+                return sequelize_1.DataTypes.STRING;
+            case 'USER-DEFINED':
+                return this.getTypeForUserDefined(columnInfo);
+            case this.typeMatch(type, this.enumRegex):
+                return this.convertToEnum(type);
+            case 'UNIQUEIDENTIFIER':
+            case 'UUID':
+                return sequelize_1.DataTypes.UUID;
+            case 'JSONB':
+                return sequelize_1.DataTypes.JSONB;
+            case 'INTEGER':
+            case 'SERIAL':
+            case 'BIGSERIAL':
+            case this.typeStartsWith(type, 'INT'):
+            case this.typeStartsWith(type, 'SMALLINT'):
+            case this.typeStartsWith(type, 'TINYINT'):
+            case this.typeStartsWith(type, 'MEDIUMINT'):
+                return sequelize_1.DataTypes.NUMBER;
+            case this.typeStartsWith(type, 'BIGINT'):
+                return sequelize_1.DataTypes.BIGINT;
+            case this.typeContains(type, 'FLOAT'):
+                return sequelize_1.DataTypes.FLOAT;
+            case 'NUMERIC':
+            case 'REAL':
+            case 'DOUBLE':
+            case 'DOUBLE PRECISION':
+            case this.typeContains(type, 'DECIMAL'):
+                return sequelize_1.DataTypes.DOUBLE;
+            case 'DATE':
+                return sequelize_1.DataTypes.DATEONLY;
+            case this.typeStartsWith(type, 'DATETIME'):
+            case this.typeStartsWith(type, 'TIMESTAMP'):
+                return sequelize_1.DataTypes.DATE;
+            case 'TIME':
+            case 'TIME WITHOUT TIME ZONE':
+                return sequelize_1.DataTypes.TIME;
+            case 'ARRAY':
+                return this.getTypeForArray(tableName, columnName);
+            case 'INET':
+                return sequelize_1.DataTypes.INET;
+            default:
+                throw new Error(`Unsupported type: ${type}`);
+        }
+    }
+}
+exports.default = SqlTypeConverter;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/introspection/introspector.d.ts

@@ -0,0 +1,12 @@
+import { Sequelize } from 'sequelize';
+import { Logger } from '@forestadmin/datasource-toolkit';
+import { Table } from './types';
+export default class Introspector {
+    static instrospect(sequelize: Sequelize, logger?: Logger): Promise<Table[]>;
+    /** Get names of all tables in the public schema of the db */
+    private static getTableNames;
+    /** Instrospect a single table */
+    private static getTable;
+    private static getColumn;
+}
+//# sourceMappingURL=introspector.d.ts.map

package/dist/introspection/introspector.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const default_value_parser_1 = __importDefault(require("./helpers/default-value-parser"));
+const sql_type_converter_1 = __importDefault(require("./helpers/sql-type-converter"));
+class Introspector {
+    static async instrospect(sequelize, logger) {
+        const tableNames = await this.getTableNames(sequelize);
+        return Promise.all(tableNames.map(name => this.getTable(sequelize, logger, name)));
+    }
+    /** Get names of all tables in the public schema of the db */
+    static async getTableNames(sequelize) {
+        const names = await sequelize
+            .getQueryInterface()
+            .showAllTables();
+        // Fixes Sequelize behavior incorrectly implemented.
+        // Types indicate that showAllTables() should return a list of string, but it
+        // returns a list of object for both mariadb & mssql
+        // @see https://github.com/sequelize/sequelize/blob/main/src/dialects/mariadb/query.js#L295
+        return names.map(name => (typeof name === 'string' ? name : name?.tableName));
+    }
+    /** Instrospect a single table */
+    static async getTable(sequelize, logger, tableName) {
+        // Load columns descriptions, indexes and references of the current table.
+        const [columnDescriptions, tableIndexes, tableReferences] = await Promise.all([
+            sequelize.getQueryInterface().describeTable(tableName),
+            sequelize.getQueryInterface().showIndex(tableName),
+            sequelize.getQueryInterface().getForeignKeyReferencesForTable(tableName),
+        ]);
+        // Create columns
+        const columns = Object.entries(columnDescriptions).map(([name, description]) => {
+            const indexes = tableIndexes.filter(i => i.fields.find(f => f.attribute === name));
+            const references = tableReferences.filter(r => r.columnName === name);
+            const options = { name, description, indexes, references };
+            return this.getColumn(sequelize, logger, tableName, options);
+        });
+        return {
+            name: tableName,
+            columns: (await Promise.all(columns)).filter(Boolean),
+        };
+    }
+    static async getColumn(sequelize, logger, tableName, options) {
+        const { name, description, indexes, references } = options;
+        const dialect = sequelize.getDialect();
+        const typeConverter = new sql_type_converter_1.default(sequelize);
+        try {
+            const type = await typeConverter.convert(tableName, name, description);
+            const defaultValue = new default_value_parser_1.default(dialect).parse(description.defaultValue, type);
+            const unique = !!indexes.find(i => i.fields.length === 1 && i.fields[0].attribute === name && i.unique);
+            // Workaround autoincrement flag not being properly set when using postgres
+            const autoIncrement = Boolean(description.autoIncrement || description.defaultValue?.match?.(/^nextval\(.+\)$/));
+            return {
+                type,
+                autoIncrement,
+                defaultValue: autoIncrement ? null : defaultValue,
+                name,
+                allowNull: description.allowNull,
+                unique,
+                primaryKey: description.primaryKey,
+                constraints: references.map(r => ({
+                    table: r.referencedTableName,
+                    column: r.referencedColumnName,
+                })),
+            };
+        }
+        catch (e) {
+            logger?.('Warn', `Skipping column ${tableName}.${name} (${e.message})`);
+        }
+    }
+}
+exports.default = Introspector;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/introspection/types.d.ts

@@ -0,0 +1,22 @@
+import { AbstractDataType, AbstractDataTypeConstructor, QueryInterface } from 'sequelize/types';
+export declare type SequelizeIndex = Awaited<ReturnType<QueryInterface['showIndex']>>[number];
+export declare type SequelizeColumn = Awaited<ReturnType<QueryInterface['describeTable']>>[number];
+export declare type SequelizeColumnType = AbstractDataType | AbstractDataTypeConstructor;
+export declare type SequelizeReference = Awaited<ReturnType<QueryInterface['getForeignKeyReferencesForTable']>>[number];
+export declare type Table = {
+    name: string;
+    columns: {
+        name: string;
+        type: SequelizeColumnType;
+        defaultValue: unknown;
+        allowNull: boolean;
+        unique: boolean;
+        autoIncrement: boolean;
+        primaryKey: boolean;
+        constraints: {
+            table: string;
+            column: string;
+        }[];
+    }[];
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/introspection/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW50cm9zcGVjdGlvbi90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/orm-builder/helpers/relation-extractor.d.ts

@@ -0,0 +1,9 @@
+import { Relation } from '../types';
+import { Table } from '../../introspection/types';
+export default class RelationExtractor {
+    static listRelations(tableName: string, tables: Table[]): Relation[];
+    private static listDirectRelations;
+    private static listIndirectRelations;
+    private static isJunctionTable;
+}
+//# sourceMappingURL=relation-extractor.d.ts.map

package/dist/orm-builder/helpers/relation-extractor.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RelationExtractor {
+    static listRelations(tableName, tables) {
+        const relations = [];
+        for (const table of tables) {
+            relations.push(...this.listDirectRelations(table));
+            relations.push(...this.listIndirectRelations(table));
+        }
+        return relations.filter(r => r.from === tableName);
+    }
+    static listDirectRelations(table) {
+        const relations = [];
+        for (const column of table.columns) {
+            for (const constraint of column.constraints) {
+                relations.push({
+                    type: 'BelongsTo',
+                    from: table.name,
+                    to: constraint.table,
+                    foreignKey: column.name,
+                    foreignKeyTarget: constraint.column,
+                });
+                // Skip HasMany to junction tables
+                if (!this.isJunctionTable(table))
+                    relations.push({
+                        type: column.unique ? 'HasOne' : 'HasMany',
+                        from: constraint.table,
+                        to: table.name,
+                        originKey: column.name,
+                        originKeyTarget: constraint.column,
+                    });
+            }
+        }
+        return relations;
+    }
+    static listIndirectRelations(table) {
+        const relations = [];
+        const columns = table.columns.filter(c => c.primaryKey && c.constraints.length === 1);
+        if (this.isJunctionTable(table)) {
+            const [column1, column2] = columns;
+            relations.push({
+                type: 'BelongsToMany',
+                from: column1.constraints[0].table,
+                to: column2.constraints[0].table,
+                through: table.name,
+                originKey: column1.name,
+                foreignKey: column2.name,
+                originKeyTarget: column1.constraints[0].column,
+                foreignKeyTarget: column2.constraints[0].column,
+            });
+            relations.push({
+                type: 'BelongsToMany',
+                from: column2.constraints[0].table,
+                to: column1.constraints[0].table,
+                through: table.name,
+                originKey: column2.name,
+                foreignKey: column1.name,
+                originKeyTarget: column2.constraints[0].column,
+                foreignKeyTarget: column1.constraints[0].column,
+            });
+        }
+        return relations;
+    }
+    static isJunctionTable(table) {
+        return table.columns.filter(c => c.primaryKey && c.constraints.length === 1).length === 2;
+    }
+}
+exports.default = RelationExtractor;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/orm-builder/helpers/relation-name-generator.d.ts

@@ -0,0 +1,8 @@
+import { Relation } from '../types';
+import { Table } from '../../introspection/types';
+export default class RelationNameGenerator {
+    static getUniqueRelationNames(table: Table, relations: Relation[]): string[];
+    private static getSimpleName;
+    private static getUniqueName;
+}
+//# sourceMappingURL=relation-name-generator.d.ts.map

package/dist/orm-builder/helpers/relation-name-generator.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const pluralize_1 = require("pluralize");
+class RelationNameGenerator {
+    static getUniqueRelationNames(table, relations) {
+        var _a;
+        const names = relations.map(this.getSimpleName);
+        // Search for duplicates
+        const indexesByName = {};
+        for (let i = 0; i < names.length; i += 1) {
+            indexesByName[_a = names[i]] ?? (indexesByName[_a] = []);
+            indexesByName[names[i]].push(i);
+        }
+        // When a duplicate is found, use long names for all of them
+        for (const [name, indexes] of Object.entries(indexesByName)) {
+            // Legit conflicts we need to handle
+            const conflictsWithColumn = !!table.columns.find(c => c.name === name);
+            const conflictsWithOtherRelation = indexes.length > 1;
+            // Workaround sequelize bugs
+            // @see https://github.com/sequelize/sequelize/issues/8263
+            const conflictsWithTable = name === table.name;
+            const conflictsWithThroughTable = relations.find(r => r.through === name);
+            if (conflictsWithColumn ||
+                conflictsWithTable ||
+                conflictsWithOtherRelation ||
+                conflictsWithThroughTable) {
+                for (const index of indexes) {
+                    names[index] = this.getUniqueName(relations[index]);
+                }
+            }
+        }
+        return names;
+    }
+    static getSimpleName(relation) {
+        const { foreignKey } = relation;
+        let name = relation.to;
+        if (foreignKey?.length > 3 && foreignKey?.endsWith('_id'))
+            name = foreignKey.substring(0, foreignKey.length - 3);
+        if (foreignKey?.length > 2 && foreignKey?.endsWith('Id'))
+            name = foreignKey.substring(0, foreignKey.length - 2);
+        return relation.type === 'HasMany' || relation.type === 'BelongsToMany'
+            ? (0, pluralize_1.plural)(name)
+            : (0, pluralize_1.singular)(name);
+    }
+    static getUniqueName(relation) {
+        switch (relation.type) {
+            case 'BelongsTo':
+                return `${(0, pluralize_1.singular)(relation.to)}_through_${relation.foreignKey}`;
+            case 'HasOne':
+                return `${(0, pluralize_1.singular)(relation.to)}_through_${relation.from}_${relation.originKey}`;
+            case 'BelongsToMany':
+                return `${(0, pluralize_1.plural)(relation.to)}_through_${relation.through}`;
+            case 'HasMany':
+                return `${(0, pluralize_1.plural)(relation.to)}_through_${relation.from}_${relation.originKey}`;
+            default:
+                throw new Error(`Invalid relation type ${relation.type}`);
+        }
+    }
+}
+exports.default = RelationNameGenerator;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/orm-builder/model.d.ts

@@ -0,0 +1,10 @@
+import { Logger } from '@forestadmin/datasource-toolkit';
+import { Sequelize } from 'sequelize';
+import { Table } from '../introspection/types';
+export default class ModelBuilder {
+    static defineModels(sequelize: Sequelize, logger: Logger, tables: Table[]): void;
+    private static defineModel;
+    private static hasTimestamps;
+    private static isParanoid;
+}
+//# sourceMappingURL=model.d.ts.map

package/dist/orm-builder/model.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ModelBuilder {
+    static defineModels(sequelize, logger, tables) {
+        for (const table of tables) {
+            this.defineModel(sequelize, logger, table);
+        }
+    }
+    static defineModel(sequelize, logger, table) {
+        const modelAttrs = {};
+        const hasTimestamps = this.hasTimestamps(table);
+        const isParanoid = this.isParanoid(table);
+        for (const column of table.columns) {
+            const isExplicit = !(hasTimestamps && (column.name === 'updatedAt' || column.name === 'createdAt')) &&
+                !(isParanoid && column.name === 'deletedAt');
+            // Clone object, because sequelize modifies it.
+            if (isExplicit)
+                modelAttrs[column.name] = { ...column };
+        }
+        try {
+            const model = sequelize.define(table.name, modelAttrs, {
+                tableName: table.name,
+                timestamps: hasTimestamps,
+                paranoid: isParanoid,
+            });
+            // @see https://sequelize.org/docs/v6/other-topics/legacy/#primary-keys
+            // Tell sequelize NOT to invent primary keys when we don't provide them.
+            // (Note that this does not seem to work)
+            if (!modelAttrs.id && model.getAttributes().id) {
+                model.removeAttribute('id');
+            }
+        }
+        catch (e) {
+            logger?.('Warn', `Skipping table "${table.name}" because of error: ${e.message}`);
+        }
+    }
+    static hasTimestamps(table) {
+        return (!!table.columns.find(c => c.name === 'createdAt') &&
+            !!table.columns.find(c => c.name === 'updatedAt'));
+    }
+    static isParanoid(table) {
+        return !!table.columns.find(c => c.name === 'deletedAt');
+    }
+}
+exports.default = ModelBuilder;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvb3JtLWJ1aWxkZXIvbW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFJQSxNQUFxQixZQUFZO0lBQy9CLE1BQU0sQ0FBQyxZQUFZLENBQUMsU0FBb0IsRUFBRSxNQUFjLEVBQUUsTUFBZTtRQUN2RSxLQUFLLE1BQU0sS0FBSyxJQUFJLE1BQU0sRUFBRTtZQUMxQixJQUFJLENBQUMsV0FBVyxDQUFDLFNBQVMsRUFBRSxNQUFNLEVBQUUsS0FBSyxDQUFDLENBQUM7U0FDNUM7SUFDSCxDQUFDO0lBRU8sTUFBTSxDQUFDLFdBQVcsQ0FBQyxTQUFvQixFQUFFLE1BQWMsRUFBRSxLQUFZO1FBQzNFLE1BQU0sVUFBVSxHQUFvQixFQUFFLENBQUM7UUFDdkMsTUFBTSxhQUFhLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNoRCxNQUFNLFVBQVUsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBRTFDLEtBQUssTUFBTSxNQUFNLElBQUksS0FBSyxDQUFDLE9BQU8sRUFBRTtZQUNsQyxNQUFNLFVBQVUsR0FDZCxDQUFDLENBQUMsYUFBYSxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksS0FBSyxXQUFXLElBQUksTUFBTSxDQUFDLElBQUksS0FBSyxXQUFXLENBQUMsQ0FBQztnQkFDaEYsQ0FBQyxDQUFDLFVBQVUsSUFBSSxNQUFNLENBQUMsSUFBSSxLQUFLLFdBQVcsQ0FBQyxDQUFDO1lBRS9DLCtDQUErQztZQUMvQyxJQUFJLFVBQVU7Z0JBQUUsVUFBVSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFLEdBQUcsTUFBTSxFQUFFLENBQUM7U0FDekQ7UUFFRCxJQUFJO1lBQ0YsTUFBTSxLQUFLLEdBQUcsU0FBUyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLFVBQVUsRUFBRTtnQkFDckQsU0FBUyxFQUFFLEtBQUssQ0FBQyxJQUFJO2dCQUNyQixVQUFVLEVBQUUsYUFBYTtnQkFDekIsUUFBUSxFQUFFLFVBQVU7YUFDckIsQ0FBQyxDQUFDO1lBRUgsdUVBQXVFO1lBQ3ZFLHdFQUF3RTtZQUN4RSx5Q0FBeUM7WUFDekMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxFQUFFLElBQUksS0FBSyxDQUFDLGFBQWEsRUFBRSxDQUFDLEVBQUUsRUFBRTtnQkFDOUMsS0FBSyxDQUFDLGVBQWUsQ0FBQyxJQUFJLENBQUMsQ0FBQzthQUM3QjtTQUNGO1FBQUMsT0FBTyxDQUFDLEVBQUU7WUFDVixNQUFNLEVBQUUsQ0FBQyxNQUFNLEVBQUUsbUJBQW1CLEtBQUssQ0FBQyxJQUFJLHVCQUF1QixDQUFDLENBQUMsT0FBTyxFQUFFLENBQUMsQ0FBQztTQUNuRjtJQUNILENBQUM7SUFFTyxNQUFNLENBQUMsYUFBYSxDQUFDLEtBQVk7UUFDdkMsT0FBTyxDQUNMLENBQUMsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLEtBQUssV0FBVyxDQUFDO1lBQ2pELENBQUMsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLEtBQUssV0FBVyxDQUFDLENBQ2xELENBQUM7SUFDSixDQUFDO0lBRU8sTUFBTSxDQUFDLFVBQVUsQ0FBQyxLQUFZO1FBQ3BDLE9BQU8sQ0FBQyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksS0FBSyxXQUFXLENBQUMsQ0FBQztJQUMzRCxDQUFDO0NBQ0Y7QUFqREQsK0JBaURDIn0=

package/dist/orm-builder/relations.d.ts

@@ -0,0 +1,9 @@
+import { Logger } from '@forestadmin/datasource-toolkit';
+import { Sequelize } from 'sequelize';
+import { Table } from '../introspection/types';
+export default class RelationBuilder {
+    static defineRelations(sequelize: Sequelize, logger: Logger, tables: Table[]): void;
+    private static defineTableRelations;
+    private static defineRelation;
+}
+//# sourceMappingURL=relations.d.ts.map

package/dist/orm-builder/relations.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const relation_extractor_1 = __importDefault(require("./helpers/relation-extractor"));
+const relation_name_generator_1 = __importDefault(require("./helpers/relation-name-generator"));
+class RelationBuilder {
+    static defineRelations(sequelize, logger, tables) {
+        for (const table of tables) {
+            this.defineTableRelations(sequelize, logger, table, tables);
+        }
+    }
+    static defineTableRelations(sequelize, logger, table, tables) {
+        const relations = relation_extractor_1.default.listRelations(table.name, tables);
+        const relationNames = relation_name_generator_1.default.getUniqueRelationNames(table, relations);
+        for (const [index, relation] of relations.entries()) {
+            const as = relationNames[index];
+            try {
+                this.defineRelation(sequelize, relation, as);
+            }
+            catch (e) {
+                logger?.('Warn', `Skipping relation "${table.name}.${as}" because of error: ${e.message}`);
+            }
+        }
+    }
+    static defineRelation(sequelize, relation, as) {
+        const sourceModel = sequelize.model(relation.from);
+        const targetModel = sequelize.model(relation.to);
+        if (relation.type === 'BelongsTo') {
+            sourceModel.belongsTo(targetModel, {
+                as,
+                foreignKey: relation.foreignKey,
+                targetKey: relation.foreignKeyTarget,
+            });
+        }
+        else if (relation.type === 'HasMany') {
+            sourceModel.hasMany(targetModel, {
+                as,
+                foreignKey: relation.originKey,
+                sourceKey: relation.originKeyTarget,
+            });
+        }
+        else if (relation.type === 'BelongsToMany') {
+            sourceModel.belongsToMany(targetModel, {
+                as,
+                through: relation.through,
+                otherKey: relation.foreignKey,
+                foreignKey: relation.originKey,
+                targetKey: relation.foreignKeyTarget,
+                sourceKey: relation.originKeyTarget,
+            });
+        }
+        else if (relation.type === 'HasOne') {
+            sourceModel.hasOne(targetModel, {
+                as,
+                foreignKey: relation.originKey,
+                sourceKey: relation.originKeyTarget,
+            });
+        }
+    }
+}
+exports.default = RelationBuilder;
+//# sourceMappingURL=data:application/json;base64,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