@forestadmin/datasource-sql 1.0.0-beta.47 → 1.0.0-beta.48

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+# @forestadmin/datasource-sql [1.0.0-beta.48](https://github.com/ForestAdmin/agent-nodejs/compare/@forestadmin/datasource-sql@1.0.0-beta.47...@forestadmin/datasource-sql@1.0.0-beta.48) (2022-09-08)
+
+
+
+
+
+### Dependencies
+
+* **@forestadmin/datasource-sequelize:** upgraded to 1.0.0-beta.41
+* **@forestadmin/datasource-toolkit:** upgraded to 1.0.0-beta.31
+
 # @forestadmin/datasource-sql [1.0.0-beta.47](https://github.com/ForestAdmin/agent-nodejs/compare/@forestadmin/datasource-sql@1.0.0-beta.46...@forestadmin/datasource-sql@1.0.0-beta.47) (2022-09-07)
 
 

package/dist/index.d.ts

@@ -1,3 +1,5 @@
-import { DataSourceFactory } from '@forestadmin/datasource-toolkit';
+import { DataSourceFactory, Logger } from '@forestadmin/datasource-toolkit';
+import { Sequelize } from 'sequelize';
+export declare function buildSequelizeInstance(connectionUri: string, logger: Logger): Promise<Sequelize>;
 export declare function createSqlDataSource(connectionUri: string): DataSourceFactory;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -3,17 +3,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSqlDataSource = void 0;
-const sequelize_builder_1 = __importDefault(require("./sequelize-builder"));
-const datasource_factory_1 = __importDefault(require("./datasource-factory"));
-// eslint-disable-next-line import/prefer-default-export
-function createSqlDataSource(connectionUri) {
+exports.createSqlDataSource = exports.buildSequelizeInstance = void 0;
+const sequelize_1 = require("sequelize");
+const datasource_sequelize_1 = require("@forestadmin/datasource-sequelize");
+const introspector_1 = __importDefault(require("./introspection/introspector"));
+const model_1 = __importDefault(require("./orm-builder/model"));
+const relations_1 = __importDefault(require("./orm-builder/relations"));
+async function buildSequelizeInstance(connectionUri, logger) {
     if (!/.*:\/\//g.test(connectionUri))
-        throw new Error(`Connection Uri "${connectionUri}" provided to Sql data source is not valid.` +
+        throw new Error(`Connection Uri "${connectionUri}" provided to SQL data source is not valid.` +
             ' Should be <dialect>://<connection>.');
+    const logging = (sql) => logger?.('Debug', sql.substring(sql.indexOf(':') + 2));
+    const sequelize = new sequelize_1.Sequelize(connectionUri, { logging });
+    const tables = await introspector_1.default.instrospect(sequelize, logger);
+    model_1.default.defineModels(sequelize, logger, tables);
+    relations_1.default.defineRelations(sequelize, logger, tables);
+    return sequelize;
+}
+exports.buildSequelizeInstance = buildSequelizeInstance;
+function createSqlDataSource(connectionUri) {
     return async (logger) => {
-        return datasource_factory_1.default.build(new sequelize_builder_1.default(connectionUri, logger));
+        const sequelize = await buildSequelizeInstance(connectionUri, logger);
+        return new datasource_sequelize_1.SequelizeDataSource(sequelize, logger);
     };
 }
 exports.createSqlDataSource = createSqlDataSource;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBRUEsNEVBQTZEO0FBQzdELDhFQUF3RDtBQUV4RCx3REFBd0Q7QUFDeEQsU0FBZ0IsbUJBQW1CLENBQUMsYUFBcUI7SUFDdkQsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDO1FBQ2pDLE1BQU0sSUFBSSxLQUFLLENBQ2IsbUJBQW1CLGFBQWEsNkNBQTZDO1lBQzNFLHNDQUFzQyxDQUN6QyxDQUFDO0lBRUosT0FBTyxLQUFLLEVBQUUsTUFBYyxFQUFFLEVBQUU7UUFDOUIsT0FBTyw0QkFBb0IsQ0FBQyxLQUFLLENBQUMsSUFBSSwyQkFBMEIsQ0FBQyxhQUFhLEVBQUUsTUFBTSxDQUFDLENBQUMsQ0FBQztJQUMzRixDQUFDLENBQUM7QUFDSixDQUFDO0FBVkQsa0RBVUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQ0EseUNBQXNDO0FBQ3RDLDRFQUF3RTtBQUV4RSxnRkFBd0Q7QUFDeEQsZ0VBQStDO0FBQy9DLHdFQUFzRDtBQUUvQyxLQUFLLFVBQVUsc0JBQXNCLENBQzFDLGFBQXFCLEVBQ3JCLE1BQWM7SUFFZCxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUM7UUFDakMsTUFBTSxJQUFJLEtBQUssQ0FDYixtQkFBbUIsYUFBYSw2Q0FBNkM7WUFDM0Usc0NBQXNDLENBQ3pDLENBQUM7SUFFSixNQUFNLE9BQU8sR0FBRyxDQUFDLEdBQVcsRUFBRSxFQUFFLENBQUMsTUFBTSxFQUFFLENBQUMsT0FBTyxFQUFFLEdBQUcsQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3hGLE1BQU0sU0FBUyxHQUFHLElBQUkscUJBQVMsQ0FBQyxhQUFhLEVBQUUsRUFBRSxPQUFPLEVBQUUsQ0FBQyxDQUFDO0lBRTVELE1BQU0sTUFBTSxHQUFHLE1BQU0sc0JBQVksQ0FBQyxXQUFXLENBQUMsU0FBUyxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQ2pFLGVBQVksQ0FBQyxZQUFZLENBQUMsU0FBUyxFQUFFLE1BQU0sRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNyRCxtQkFBZSxDQUFDLGVBQWUsQ0FBQyxTQUFTLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBRTNELE9BQU8sU0FBUyxDQUFDO0FBQ25CLENBQUM7QUFsQkQsd0RBa0JDO0FBRUQsU0FBZ0IsbUJBQW1CLENBQUMsYUFBcUI7SUFDdkQsT0FBTyxLQUFLLEVBQUUsTUFBYyxFQUFFLEVBQUU7UUFDOUIsTUFBTSxTQUFTLEdBQUcsTUFBTSxzQkFBc0IsQ0FBQyxhQUFhLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFFdEUsT0FBTyxJQUFJLDBDQUFtQixDQUFDLFNBQVMsRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNwRCxDQUFDLENBQUM7QUFDSixDQUFDO0FBTkQsa0RBTUMifQ==

package/dist/{utils → introspection/helpers}/array-type-getter.js

@@ -64,4 +64,4 @@ class ArrayTypeGetter {
     }
 }
 exports.default = ArrayTypeGetter;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXktdHlwZS1nZXR0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvYXJyYXktdHlwZS1nZXR0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSx5Q0FBa0Q7QUFFbEQsTUFBcUIsZUFBZTtJQWdEbEMsWUFBWSxTQUFvQjtRQTdDZixVQUFLLEdBQUc7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0EyQ3hCLENBQUM7UUFHQSxJQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztRQUMzQiw4REFBOEQ7UUFDOUQsSUFBSSxDQUFDLFNBQVMsR0FBSSxJQUFJLENBQUMsU0FBUyxDQUFDLGlCQUFpQixFQUFFLENBQUMsY0FBc0IsQ0FBQyxTQUFTLENBQUM7SUFDeEYsQ0FBQztJQUVELEtBQUssQ0FBQyxPQUFPLENBQ1gsU0FBaUIsRUFDakIsVUFBa0I7UUFFbEIsTUFBTSxZQUFZLEdBQUcsRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLENBQUM7UUFFL0MsTUFBTSxDQUFDLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxDQUFDLEdBQUcsTUFBTSxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsS0FBSyxFQUFFO1lBQ2pFLFlBQVk7WUFDWixJQUFJLEVBQUUsc0JBQVUsQ0FBQyxNQUFNO1NBQ3hCLENBQUMsQ0FBQztRQUVILE9BQU87WUFDTCxJQUFJLEVBQUUsSUFBSSxDQUFDLFdBQVcsRUFBRTtZQUN4QixPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFO1NBQ2hELENBQUM7SUFDSixDQUFDO0NBQ0Y7QUF0RUQsa0NBc0VDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXktdHlwZS1nZXR0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaW50cm9zcGVjdGlvbi9oZWxwZXJzL2FycmF5LXR5cGUtZ2V0dGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEseUNBQWtEO0FBRWxELE1BQXFCLGVBQWU7SUFnRGxDLFlBQVksU0FBb0I7UUE3Q2YsVUFBSyxHQUFHOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBMkN4QixDQUFDO1FBR0EsSUFBSSxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUM7UUFDM0IsOERBQThEO1FBQzlELElBQUksQ0FBQyxTQUFTLEdBQUksSUFBSSxDQUFDLFNBQVMsQ0FBQyxpQkFBaUIsRUFBRSxDQUFDLGNBQXNCLENBQUMsU0FBUyxDQUFDO0lBQ3hGLENBQUM7SUFFRCxLQUFLLENBQUMsT0FBTyxDQUNYLFNBQWlCLEVBQ2pCLFVBQWtCO1FBRWxCLE1BQU0sWUFBWSxHQUFHLEVBQUUsU0FBUyxFQUFFLFVBQVUsRUFBRSxDQUFDO1FBRS9DLE1BQU0sQ0FBQyxFQUFFLElBQUksRUFBRSxPQUFPLEVBQUUsQ0FBQyxHQUFHLE1BQU0sSUFBSSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLEtBQUssRUFBRTtZQUNqRSxZQUFZO1lBQ1osSUFBSSxFQUFFLHNCQUFVLENBQUMsTUFBTTtTQUN4QixDQUFDLENBQUM7UUFFSCxPQUFPO1lBQ0wsSUFBSSxFQUFFLElBQUksQ0FBQyxXQUFXLEVBQUU7WUFDeEIsT0FBTyxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsRUFBRTtTQUNoRCxDQUFDO0lBQ0osQ0FBQztDQUNGO0FBdEVELGtDQXNFQyJ9

package/dist/{utils → introspection/helpers}/default-value-parser.js

@@ -77,4 +77,4 @@ class DefaultValueParser {
     }
 }
 exports.default = DefaultValueParser;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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 = await sequelize.getQueryInterface().describeTable(tableName);
+        const tableIndexes = await sequelize.getQueryInterface().showIndex(tableName);
+        const tableReferences = await 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,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

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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

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

@@ -0,0 +1,11 @@
+export declare type Relation = {
+    type: 'BelongsTo' | 'HasOne' | 'BelongsToMany' | 'HasMany';
+    from: string;
+    to: string;
+    through?: string;
+    foreignKey?: string;
+    originKey?: string;
+    foreignKeyTarget?: string;
+    originKeyTarget?: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/{utils → orm-builder}/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forestadmin/datasource-sql",
-  "version": "1.0.0-beta.47",
+  "version": "1.0.0-beta.48",
   "main": "dist/index.js",
   "license": "GPL-3.0",
   "publishConfig": {
@@ -12,8 +12,9 @@
     "directory": "packages/datasource-sql"
   },
   "dependencies": {
-    "@forestadmin/datasource-sequelize": "1.0.0-beta.40",
-    "@forestadmin/datasource-toolkit": "1.0.0-beta.30",
+    "@forestadmin/datasource-sequelize": "1.0.0-beta.41",
+    "@forestadmin/datasource-toolkit": "1.0.0-beta.31",
+    "pluralize": "^8.0.0",
     "sequelize": "6.21.3"
   },
   "files": [

package/dist/datasource-factory.d.ts

@@ -1,7 +0,0 @@
-import { DataSource } from '@forestadmin/datasource-toolkit';
-import { Builder } from './utils/types';
-export default class SqlDataSourceFactory {
-    static build(builder: Builder): Promise<DataSource>;
-    private static canDefineRelation;
-}
-//# sourceMappingURL=datasource-factory.d.ts.map

package/dist/datasource-factory.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class SqlDataSourceFactory {
-    static async build(builder) {
-        const excludedTables = new Set();
-        const tableNames = await builder.getTableNames();
-        const modelsToBuild = tableNames.map(async (tableName) => {
-            try {
-                await builder.defineModel(tableName);
-            }
-            catch (e) {
-                excludedTables.add(tableName);
-                builder.logger?.('Warn', `Skipping table "${tableName}" and its relations because of error: ${e.message}`);
-            }
-        });
-        await Promise.all(modelsToBuild);
-        const relationsToBuild = tableNames.map(async (tableName) => {
-            if (await SqlDataSourceFactory.canDefineRelation(tableName, builder, excludedTables)) {
-                await builder.defineRelation(tableName);
-            }
-        });
-        await Promise.all(relationsToBuild);
-        return builder.buildDataSource();
-    }
-    static async canDefineRelation(tableName, builder, excludedTables) {
-        if (excludedTables.has(tableName)) {
-            return false;
-        }
-        const relatedTables = await builder.getRelatedTables(tableName);
-        return !relatedTables.some(table => excludedTables.has(table));
-    }
-}
-exports.default = SqlDataSourceFactory;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS1mYWN0b3J5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2RhdGFzb3VyY2UtZmFjdG9yeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUlBLE1BQXFCLG9CQUFvQjtJQUN2QyxNQUFNLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxPQUFnQjtRQUNqQyxNQUFNLGNBQWMsR0FBRyxJQUFJLEdBQUcsRUFBVSxDQUFDO1FBQ3pDLE1BQU0sVUFBVSxHQUFHLE1BQU0sT0FBTyxDQUFDLGFBQWEsRUFBRSxDQUFDO1FBRWpELE1BQU0sYUFBYSxHQUFHLFVBQVUsQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFDLFNBQVMsRUFBQyxFQUFFO1lBQ3JELElBQUk7Z0JBQ0YsTUFBTSxPQUFPLENBQUMsV0FBVyxDQUFDLFNBQVMsQ0FBQyxDQUFDO2FBQ3RDO1lBQUMsT0FBTyxDQUFDLEVBQUU7Z0JBQ1YsY0FBYyxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsQ0FBQztnQkFDOUIsT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUNkLE1BQU0sRUFDTixtQkFBbUIsU0FBUyx5Q0FBeUMsQ0FBQyxDQUFDLE9BQU8sRUFBRSxDQUNqRixDQUFDO2FBQ0g7UUFDSCxDQUFDLENBQUMsQ0FBQztRQUNILE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQyxhQUFhLENBQUMsQ0FBQztRQUVqQyxNQUFNLGdCQUFnQixHQUFHLFVBQVUsQ0FBQyxHQUFHLENBQUMsS0FBSyxFQUFDLFNBQVMsRUFBQyxFQUFFO1lBQ3hELElBQUksTUFBTSxvQkFBb0IsQ0FBQyxpQkFBaUIsQ0FBQyxTQUFTLEVBQUUsT0FBTyxFQUFFLGNBQWMsQ0FBQyxFQUFFO2dCQUNwRixNQUFNLE9BQU8sQ0FBQyxjQUFjLENBQUMsU0FBUyxDQUFDLENBQUM7YUFDekM7UUFDSCxDQUFDLENBQUMsQ0FBQztRQUNILE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO1FBRXBDLE9BQU8sT0FBTyxDQUFDLGVBQWUsRUFBRSxDQUFDO0lBQ25DLENBQUM7SUFFTyxNQUFNLENBQUMsS0FBSyxDQUFDLGlCQUFpQixDQUFDLFNBQWlCLEVBQUUsT0FBZ0IsRUFBRSxjQUFjO1FBQ3hGLElBQUksY0FBYyxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsRUFBRTtZQUNqQyxPQUFPLEtBQUssQ0FBQztTQUNkO1FBRUQsTUFBTSxhQUFhLEdBQUcsTUFBTSxPQUFPLENBQUMsZ0JBQWdCLENBQUMsU0FBUyxDQUFDLENBQUM7UUFFaEUsT0FBTyxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxjQUFjLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDakUsQ0FBQztDQUNGO0FBckNELHVDQXFDQyJ9

package/dist/sequelize-builder.d.ts

@@ -1,33 +0,0 @@
-import { DataSource, Logger } from '@forestadmin/datasource-toolkit';
-import { SequelizeDataSource } from '@forestadmin/datasource-sequelize';
-import { Builder, Model } from './utils/types';
-export default class SequelizeDataSourceBuilder extends SequelizeDataSource implements Builder {
-    logger?: Logger;
-    constructor(connectionUri: string, logger?: Logger);
-    buildDataSource(): DataSource;
-    get models(): {
-        [modelName: string]: Model;
-    };
-    defineModel(tableName: any): Promise<void>;
-    defineRelation(tableName: string): Promise<void>;
-    getRelatedTables(tableName: string): Promise<string[]>;
-    /**
-     * 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
-     */
-    getTableNames(): Promise<string[]>;
-    private getForeignReferences;
-    private getUniqueFields;
-    private buildFieldDescriptions;
-    private isJunctionTable;
-    private buildForJunctionTable;
-    private buildOtherRelations;
-    private buildModel;
-    private static removeTimestampColumns;
-    private static isParanoid;
-    private static removeParanoidColumn;
-    private static hasTimestamps;
-}
-//# sourceMappingURL=sequelize-builder.d.ts.map

package/dist/sequelize-builder.js

@@ -1,162 +0,0 @@
-"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 datasource_sequelize_1 = require("@forestadmin/datasource-sequelize");
-const default_value_parser_1 = __importDefault(require("./utils/default-value-parser"));
-const sql_type_converter_1 = __importDefault(require("./utils/sql-type-converter"));
-class SequelizeDataSourceBuilder extends datasource_sequelize_1.SequelizeDataSource {
-    constructor(connectionUri, logger) {
-        const logging = (sql) => logger?.('Debug', sql.substring(sql.indexOf(':') + 2));
-        super(new sequelize_1.Sequelize(connectionUri, { logging }));
-        this.logger = logger;
-    }
-    buildDataSource() {
-        super.createCollections(this.sequelize.models, this.logger);
-        return this;
-    }
-    get models() {
-        return Object.keys(this.sequelize.models).reduce((models, modelName) => {
-            const model = this.sequelize.model(modelName);
-            models[modelName] = {
-                getAttributes: () => model.getAttributes(),
-                name: modelName,
-                associations: model.associations,
-            };
-            return models;
-        }, {});
-    }
-    async defineModel(tableName) {
-        const columnDescriptions = await this.sequelize.getQueryInterface().describeTable(tableName);
-        const fieldDescriptions = await this.buildFieldDescriptions(columnDescriptions, tableName);
-        this.buildModel(tableName, fieldDescriptions);
-    }
-    async defineRelation(tableName) {
-        const foreignReferences = await this.getForeignReferences(tableName);
-        if (this.isJunctionTable(tableName)) {
-            this.buildForJunctionTable(tableName, foreignReferences);
-        }
-        else {
-            const uniqueFields = await this.getUniqueFields(tableName);
-            this.buildOtherRelations(foreignReferences, tableName, uniqueFields);
-        }
-    }
-    async getRelatedTables(tableName) {
-        const foreignReferences = await this.getForeignReferences(tableName);
-        if (this.isJunctionTable(tableName)) {
-            const [{ referencedTableName: tableA }, { referencedTableName: tableB }] = foreignReferences;
-            return [tableA, tableB];
-        }
-        return foreignReferences.map(({ referencedTableName }) => referencedTableName);
-    }
-    /**
-     * 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
-     */
-    async getTableNames() {
-        const names = await this.sequelize
-            .getQueryInterface()
-            .showAllTables();
-        return names.map(name => (typeof name === 'string' ? name : name?.tableName));
-    }
-    async getForeignReferences(tableName) {
-        return this.sequelize.getQueryInterface().getForeignKeyReferencesForTable(tableName);
-    }
-    async getUniqueFields(tableName) {
-        const tableIndex = await this.sequelize.getQueryInterface().showIndex(tableName);
-        return tableIndex
-            .filter(({ primary, unique, fields }) => !primary && unique && fields.length === 1)
-            .map(({ fields }) => fields.map(({ attribute }) => attribute))
-            .flat();
-    }
-    async buildFieldDescriptions(columnDescriptions, tableName) {
-        const fields = Object.entries(columnDescriptions).map(async ([columnName, columnDescription]) => {
-            try {
-                const type = await new sql_type_converter_1.default(this.sequelize).convert(tableName, columnName, columnDescription);
-                let defaultValue = new default_value_parser_1.default(this.sequelize.getDialect()).parse(columnDescription.defaultValue, type);
-                if (columnDescription.primaryKey && defaultValue) {
-                    defaultValue = null;
-                    columnDescription.autoIncrement = true;
-                }
-                return [columnName, { ...columnDescription, type, defaultValue }];
-            }
-            catch (e) {
-                this.logger?.('Warn', `Skipping column ${tableName}.${columnName} (${e.message})`);
-            }
-        });
-        const fieldDescriptions = await Promise.all(fields);
-        return fieldDescriptions.filter(Boolean);
-    }
-    isJunctionTable(modelName) {
-        const model = this.sequelize.model(modelName);
-        const modelAttributes = model.getAttributes();
-        // remove autogenerated field to keep the belongsToMany behavior
-        const attributes = Object.values(modelAttributes);
-        const modelAttributesDefinition = attributes.filter(({ _autoGenerated }) => !_autoGenerated);
-        if (modelAttributesDefinition.length !== 2)
-            return false;
-        return !modelAttributesDefinition.some(({ primaryKey }) => !primaryKey);
-    }
-    buildForJunctionTable(modelName, foreignReferences) {
-        const [{ referencedTableName: tableA, columnName: columnA, referencedColumnName: referencedColumnA }, { referencedTableName: tableB, columnName: columnB, referencedColumnName: referencedColumnB },] = foreignReferences;
-        const model = this.sequelize.model(modelName);
-        const modelA = this.sequelize.model(tableA);
-        const modelB = this.sequelize.model(tableB);
-        const through = model.name;
-        modelA.belongsToMany(modelB, { through, foreignKey: columnA, otherKey: columnB });
-        modelB.belongsToMany(modelA, { through, foreignKey: columnB, otherKey: columnA });
-        model.belongsTo(modelA, { foreignKey: columnA, targetKey: referencedColumnA });
-        model.belongsTo(modelB, { foreignKey: columnB, targetKey: referencedColumnB });
-    }
-    buildOtherRelations(foreignReferences, modelName, uniqueFields) {
-        foreignReferences.forEach(({ columnName: foreignKey, referencedTableName, referencedColumnName: sourceKey }) => {
-            const referencedModel = this.sequelize.model(referencedTableName);
-            const model = this.sequelize.model(modelName);
-            model.belongsTo(referencedModel, { foreignKey, targetKey: sourceKey });
-            if (uniqueFields.includes(foreignKey)) {
-                referencedModel.hasOne(model, { foreignKey, sourceKey });
-            }
-            else {
-                referencedModel.hasMany(model, { foreignKey, sourceKey });
-            }
-        });
-    }
-    buildModel(tableName, fieldDescriptions) {
-        let model = Object.fromEntries(fieldDescriptions);
-        const columnNames = Object.keys(model);
-        const timestamps = SequelizeDataSourceBuilder.hasTimestamps(columnNames);
-        const paranoid = SequelizeDataSourceBuilder.isParanoid(columnNames);
-        if (timestamps) {
-            model = SequelizeDataSourceBuilder.removeTimestampColumns(model);
-        }
-        if (paranoid) {
-            model = SequelizeDataSourceBuilder.removeParanoidColumn(model);
-        }
-        this.sequelize.define(tableName, model, { tableName, timestamps, paranoid });
-    }
-    static removeTimestampColumns(modelDefinition) {
-        const copy = { ...modelDefinition };
-        delete copy.createdAt;
-        delete copy.updatedAt;
-        return copy;
-    }
-    static isParanoid(columnNames) {
-        return columnNames.includes('deletedAt');
-    }
-    static removeParanoidColumn(modelDefinition) {
-        const copy = { ...modelDefinition };
-        delete copy.deletedAt;
-        return copy;
-    }
-    static hasTimestamps(columnNames) {
-        const hasCreatedAt = columnNames.includes('createdAt');
-        const hasUpdatedAt = columnNames.includes('updatedAt');
-        return hasCreatedAt && hasUpdatedAt;
-    }
-}
-exports.default = SequelizeDataSourceBuilder;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sequelize-builder.js","sourceRoot":"","sources":["../src/sequelize-builder.ts"],"names":[],"mappings":"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"}

package/dist/utils/sql-type-converter.js

@@ -1,104 +0,0 @@
-"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/utils/types.d.ts

@@ -1,25 +0,0 @@
-import { AbstractDataType, AbstractDataTypeConstructor, ColumnDescription } from 'sequelize';
-import { DataSource, Logger } from '@forestadmin/datasource-toolkit';
-import { QueryInterface } from 'sequelize/types/dialects/abstract/query-interface';
-export declare type FieldDescription = (string | (Omit<ColumnDescription, 'defaultValue' | 'type'> & {
-    defaultValue: unknown;
-    type: AbstractDataType | AbstractDataTypeConstructor;
-}))[];
-export declare type ForeignKeyReference = Awaited<ReturnType<QueryInterface['getForeignKeyReferencesForTable']>>[number];
-export declare type Model = {
-    name: string;
-    associations: unknown;
-    getAttributes: () => unknown;
-};
-export interface Builder {
-    defineModel(tableName: string): Promise<void>;
-    defineRelation(tableName: string): Promise<void>;
-    getRelatedTables(tableName: string): Promise<string[]>;
-    buildDataSource(): DataSource;
-    getTableNames(): Promise<string[]>;
-    logger?: Logger;
-    models: {
-        [modelName: string]: Model;
-    };
-}
-//# sourceMappingURL=types.d.ts.map