@forestadmin/datasource-sql 1.0.0-beta.9 → 1.0.1-alpha.1

package/dist/index.d.ts

@@ -1,3 +1,9 @@
-import SqlDataSource from './datasource';
-export default SqlDataSource;
+import { DataSourceFactory, Logger } from '@forestadmin/datasource-toolkit';
+import { Sequelize } from 'sequelize';
+import { Table } from './introspection/types';
+export declare function introspect(connectionUri: string, logger?: Logger): Promise<Table[]>;
+export declare function buildSequelizeInstance(connectionUri: string, logger: Logger, introspection?: Table[]): Promise<Sequelize>;
+export declare function createSqlDataSource(connectionUri: string, options?: {
+    introspection: Table[];
+}): DataSourceFactory;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -3,6 +3,39 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const datasource_1 = __importDefault(require("./datasource"));
-exports.default = datasource_1.default;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSw4REFBeUM7QUFFekMsa0JBQWUsb0JBQWEsQ0FBQyJ9
+exports.createSqlDataSource = exports.buildSequelizeInstance = exports.introspect = 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"));
+function createEmptySequelize(connectionUri, logger) {
+    if (!/.*:\/\//g.test(connectionUri))
+        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));
+    return new sequelize_1.Sequelize(connectionUri, { logging });
+}
+async function introspect(connectionUri, logger) {
+    const sequelize = createEmptySequelize(connectionUri, logger);
+    const tables = await introspector_1.default.introspect(sequelize, logger);
+    sequelize.close();
+    return tables;
+}
+exports.introspect = introspect;
+async function buildSequelizeInstance(connectionUri, logger, introspection) {
+    const sequelize = createEmptySequelize(connectionUri, logger);
+    const tables = introspection ?? (await introspector_1.default.introspect(sequelize, logger));
+    model_1.default.defineModels(sequelize, logger, tables);
+    relations_1.default.defineRelations(sequelize, logger, tables);
+    return sequelize;
+}
+exports.buildSequelizeInstance = buildSequelizeInstance;
+function createSqlDataSource(connectionUri, options) {
+    return async (logger) => {
+        const sequelize = await buildSequelizeInstance(connectionUri, logger, options?.introspection);
+        return new datasource_sequelize_1.SequelizeDataSource(sequelize, logger);
+    };
+}
+exports.createSqlDataSource = createSqlDataSource;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQ0EseUNBQXNDO0FBQ3RDLDRFQUF3RTtBQUd4RSxnRkFBd0Q7QUFDeEQsZ0VBQStDO0FBQy9DLHdFQUFzRDtBQUV0RCxTQUFTLG9CQUFvQixDQUFDLGFBQXFCLEVBQUUsTUFBYztJQUNqRSxJQUFJLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUM7UUFDakMsTUFBTSxJQUFJLEtBQUssQ0FDYixtQkFBbUIsYUFBYSw2Q0FBNkM7WUFDM0Usc0NBQXNDLENBQ3pDLENBQUM7SUFFSixNQUFNLE9BQU8sR0FBRyxDQUFDLEdBQVcsRUFBRSxFQUFFLENBQUMsTUFBTSxFQUFFLENBQUMsT0FBTyxFQUFFLEdBQUcsQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBRXhGLE9BQU8sSUFBSSxxQkFBUyxDQUFDLGFBQWEsRUFBRSxFQUFFLE9BQU8sRUFBRSxDQUFDLENBQUM7QUFDbkQsQ0FBQztBQUVNLEtBQUssVUFBVSxVQUFVLENBQUMsYUFBcUIsRUFBRSxNQUFlO0lBQ3JFLE1BQU0sU0FBUyxHQUFHLG9CQUFvQixDQUFDLGFBQWEsRUFBRSxNQUFNLENBQUMsQ0FBQztJQUM5RCxNQUFNLE1BQU0sR0FBRyxNQUFNLHNCQUFZLENBQUMsVUFBVSxDQUFDLFNBQVMsRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNoRSxTQUFTLENBQUMsS0FBSyxFQUFFLENBQUM7SUFFbEIsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQztBQU5ELGdDQU1DO0FBRU0sS0FBSyxVQUFVLHNCQUFzQixDQUMxQyxhQUFxQixFQUNyQixNQUFjLEVBQ2QsYUFBdUI7SUFFdkIsTUFBTSxTQUFTLEdBQUcsb0JBQW9CLENBQUMsYUFBYSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQzlELE1BQU0sTUFBTSxHQUFHLGFBQWEsSUFBSSxDQUFDLE1BQU0sc0JBQVksQ0FBQyxVQUFVLENBQUMsU0FBUyxFQUFFLE1BQU0sQ0FBQyxDQUFDLENBQUM7SUFFbkYsZUFBWSxDQUFDLFlBQVksQ0FBQyxTQUFTLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQ3JELG1CQUFlLENBQUMsZUFBZSxDQUFDLFNBQVMsRUFBRSxNQUFNLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFFM0QsT0FBTyxTQUFTLENBQUM7QUFDbkIsQ0FBQztBQVpELHdEQVlDO0FBRUQsU0FBZ0IsbUJBQW1CLENBQ2pDLGFBQXFCLEVBQ3JCLE9BQW9DO0lBRXBDLE9BQU8sS0FBSyxFQUFFLE1BQWMsRUFBRSxFQUFFO1FBQzlCLE1BQU0sU0FBUyxHQUFHLE1BQU0sc0JBQXNCLENBQUMsYUFBYSxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsYUFBYSxDQUFDLENBQUM7UUFFOUYsT0FBTyxJQUFJLDBDQUFtQixDQUFDLFNBQVMsRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNwRCxDQUFDLENBQUM7QUFDSixDQUFDO0FBVEQsa0RBU0MifQ==

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/introspection/helpers/default-value-parser.d.ts

@@ -0,0 +1,12 @@
+import { Dialect } from 'sequelize';
+import { ColumnType } from '../types';
+export default class DefaultValueParser {
+    private readonly dialect;
+    constructor(dialect: Dialect);
+    parse(expression: any, columnType: ColumnType): unknown;
+    private parseGeneric;
+    private sanitizeExpression;
+    private literalUnlessMatch;
+    private parseNumber;
+}
+//# sourceMappingURL=default-value-parser.d.ts.map

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

@@ -0,0 +1,78 @@
+"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, columnType) {
+        if (expression === null || expression === undefined)
+            return undefined;
+        if (typeof expression === 'string' && expression.startsWith('NULL'))
+            return null;
+        // FA backend not handle correctly
+        if (columnType.type === 'array')
+            return undefined;
+        try {
+            const result = this.parseGeneric(expression, columnType);
+            return result !== undefined ? result : (0, sequelize_1.literal)(expression);
+        }
+        catch (e) {
+            return (0, sequelize_1.literal)(expression);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    parseGeneric(expression, columnType) {
+        let sanitizedExpression = expression;
+        // sanitize string
+        if (typeof expression === 'string') {
+            sanitizedExpression = this.sanitizeExpression(expression);
+        }
+        if (columnType.type === 'enum') {
+            return sanitizedExpression;
+        }
+        switch (columnType.subType) {
+            case 'BOOLEAN':
+                return [true, 'true', 'TRUE', "b'1'", '1'].includes(sanitizedExpression);
+            case 'NUMBER':
+            case 'BIGINT':
+            case 'FLOAT':
+            case 'DOUBLE':
+                return this.parseNumber(sanitizedExpression);
+            case 'DATE':
+            case '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 'STRING':
+                return sanitizedExpression;
+            case 'JSON':
+            case '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/{utils → introspection/helpers}/sql-type-converter.d.ts

@@ -1,4 +1,5 @@
-import { AbstractDataType, AbstractDataTypeConstructor, ColumnDescription, Sequelize } from 'sequelize';
+import { ColumnDescription, Sequelize } from 'sequelize';
+import { ColumnType } from '../types';
 export default class SqlTypeConverter {
     private readonly enumRegex;
     private readonly arrayTypeGetter;
@@ -9,6 +10,6 @@ export default class SqlTypeConverter {
     private convertToEnum;
     private getTypeForUserDefined;
     private getTypeForArray;
-    convert(tableName: string, columnName: string, columnInfo: ColumnDescription): Promise<AbstractDataType | AbstractDataTypeConstructor>;
+    convert(tableName: string, columnName: string, columnInfo: ColumnDescription): Promise<ColumnType>;
 }
 //# sourceMappingURL=sql-type-converter.d.ts.map

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

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 { type: 'enum', values: enumOptions.replace(/'/g, '').split(',') };
+    }
+    getTypeForUserDefined(columnInfo) {
+        const { special } = columnInfo;
+        if (special && special.length > 0) {
+            return { type: 'enum', values: special };
+        }
+        // User-defined enum with no values will default to string
+        return { type: 'scalar', subType: 'STRING' };
+    }
+    async getTypeForArray(tableName, columnName) {
+        const { type, special } = await this.arrayTypeGetter.getType(tableName, columnName);
+        const columnInfo = { type, special };
+        const arrayType = await this.convert(tableName, columnName, columnInfo);
+        return { type: 'array', subType: arrayType };
+    }
+    async convert(tableName, columnName, columnInfo) {
+        const { type } = columnInfo;
+        switch (type) {
+            case 'JSON':
+                return { type: 'scalar', subType: 'JSON' };
+            case 'TINYINT(1)': // MYSQL bool
+            case 'BIT': // NOTICE: MSSQL type.
+            case 'BOOLEAN':
+                return { type: 'scalar', subType: '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 { type: 'scalar', subType: 'STRING' };
+            case 'USER-DEFINED':
+                return this.getTypeForUserDefined(columnInfo);
+            case this.typeMatch(type, this.enumRegex):
+                return this.convertToEnum(type);
+            case 'UNIQUEIDENTIFIER':
+            case 'UUID':
+                return { type: 'scalar', subType: 'UUID' };
+            case 'JSONB':
+                return { type: 'scalar', subType: '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 { type: 'scalar', subType: 'NUMBER' };
+            case this.typeStartsWith(type, 'BIGINT'):
+                return { type: 'scalar', subType: 'BIGINT' };
+            case this.typeContains(type, 'FLOAT'):
+                return { type: 'scalar', subType: 'FLOAT' };
+            case 'NUMERIC':
+            case 'REAL':
+            case 'DOUBLE':
+            case 'DOUBLE PRECISION':
+            case this.typeContains(type, 'DECIMAL'):
+                return { type: 'scalar', subType: 'DOUBLE' };
+            case 'DATE':
+                return { type: 'scalar', subType: 'DATEONLY' };
+            case this.typeStartsWith(type, 'DATETIME'):
+            case this.typeStartsWith(type, 'TIMESTAMP'):
+                return { type: 'scalar', subType: 'DATE' };
+            case 'TIME':
+            case 'TIME WITHOUT TIME ZONE':
+                return { type: 'scalar', subType: 'TIME' };
+            case 'ARRAY':
+                return this.getTypeForArray(tableName, columnName);
+            case 'INET':
+                return { type: 'scalar', subType: '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 introspect(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 introspect(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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50cm9zcGVjdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2ludHJvc3BlY3Rpb24vaW50cm9zcGVjdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBSUEsMEZBQWdFO0FBQ2hFLHNGQUE0RDtBQUU1RCxNQUFxQixZQUFZO0lBQy9CLE1BQU0sQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLFNBQW9CLEVBQUUsTUFBZTtRQUMzRCxNQUFNLFVBQVUsR0FBRyxNQUFNLElBQUksQ0FBQyxhQUFhLENBQUMsU0FBUyxDQUFDLENBQUM7UUFFdkQsT0FBTyxPQUFPLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLFNBQVMsRUFBRSxNQUFNLEVBQUUsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3JGLENBQUM7SUFFRCw2REFBNkQ7SUFDckQsTUFBTSxDQUFDLEtBQUssQ0FBQyxhQUFhLENBQUMsU0FBb0I7UUFDckQsTUFBTSxLQUFLLEdBQXVDLE1BQU0sU0FBUzthQUM5RCxpQkFBaUIsRUFBRTthQUNuQixhQUFhLEVBQUUsQ0FBQztRQUVuQixvREFBb0Q7UUFDcEQsNkVBQTZFO1FBQzdFLG9EQUFvRDtRQUNwRCwyRkFBMkY7UUFDM0YsT0FBTyxLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQyxPQUFPLElBQUksS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLFNBQVMsQ0FBQyxDQUFDLENBQUM7SUFDaEYsQ0FBQztJQUVELGlDQUFpQztJQUN6QixNQUFNLENBQUMsS0FBSyxDQUFDLFFBQVEsQ0FDM0IsU0FBb0IsRUFDcEIsTUFBYyxFQUNkLFNBQWlCO1FBRWpCLDBFQUEwRTtRQUMxRSxNQUFNLENBQUMsa0JBQWtCLEVBQUUsWUFBWSxFQUFFLGVBQWUsQ0FBQyxHQUFHLE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQztZQUM1RSxTQUFTLENBQUMsaUJBQWlCLEVBQUUsQ0FBQyxhQUFhLENBQUMsU0FBUyxDQUFDO1lBQ3RELFNBQVMsQ0FBQyxpQkFBaUIsRUFBRSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUM7WUFDbEQsU0FBUyxDQUFDLGlCQUFpQixFQUFFLENBQUMsK0JBQStCLENBQUMsU0FBUyxDQUFDO1NBQ3pFLENBQUMsQ0FBQztRQUVILGlCQUFpQjtRQUNqQixNQUFNLE9BQU8sR0FBRyxNQUFNLENBQUMsT0FBTyxDQUFDLGtCQUFrQixDQUFDLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsV0FBVyxDQUFDLEVBQUUsRUFBRTtZQUM3RSxNQUFNLE9BQU8sR0FBRyxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsU0FBUyxLQUFLLElBQUksQ0FBQyxDQUFDLENBQUM7WUFDbkYsTUFBTSxVQUFVLEdBQUcsZUFBZSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxVQUFVLEtBQUssSUFBSSxDQUFDLENBQUM7WUFDdEUsTUFBTSxPQUFPLEdBQUcsRUFBRSxJQUFJLEVBQUUsV0FBVyxFQUFFLE9BQU8sRUFBRSxVQUFVLEVBQUUsQ0FBQztZQUUzRCxPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsU0FBUyxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDL0QsQ0FBQyxDQUFDLENBQUM7UUFFSCxPQUFPO1lBQ0wsSUFBSSxFQUFFLFNBQVM7WUFDZixPQUFPLEVBQUUsQ0FBQyxNQUFNLE9BQU8sQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDO1NBQ3RELENBQUM7SUFDSixDQUFDO0lBRU8sTUFBTSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQzVCLFNBQW9CLEVBQ3BCLE1BQWMsRUFDZCxTQUFpQixFQUNqQixPQUtDO1FBRUQsTUFBTSxFQUFFLElBQUksRUFBRSxXQUFXLEVBQUUsT0FBTyxFQUFFLFVBQVUsRUFBRSxHQUFHLE9BQU8sQ0FBQztRQUMzRCxNQUFNLE9BQU8sR0FBRyxTQUFTLENBQUMsVUFBVSxFQUFhLENBQUM7UUFDbEQsTUFBTSxhQUFhLEdBQUcsSUFBSSw0QkFBZ0IsQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUV0RCxJQUFJO1lBQ0YsTUFBTSxJQUFJLEdBQUcsTUFBTSxhQUFhLENBQUMsT0FBTyxDQUFDLFNBQVMsRUFBRSxJQUFJLEVBQUUsV0FBVyxDQUFDLENBQUM7WUFDdkUsTUFBTSxZQUFZLEdBQUcsSUFBSSw4QkFBa0IsQ0FBQyxPQUFPLENBQUMsQ0FBQyxLQUFLLENBQUMsV0FBVyxDQUFDLFlBQVksRUFBRSxJQUFJLENBQUMsQ0FBQztZQUMzRixNQUFNLE1BQU0sR0FBRyxDQUFDLENBQUMsT0FBTyxDQUFDLElBQUksQ0FDM0IsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLE1BQU0sS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxTQUFTLEtBQUssSUFBSSxJQUFJLENBQUMsQ0FBQyxNQUFNLENBQ3pFLENBQUM7WUFFRiwyRUFBMkU7WUFDM0UsTUFBTSxhQUFhLEdBQUcsT0FBTyxDQUMzQixXQUFXLENBQUMsYUFBYSxJQUFJLFdBQVcsQ0FBQyxZQUFZLEVBQUUsS0FBSyxFQUFFLENBQUMsaUJBQWlCLENBQUMsQ0FDbEYsQ0FBQztZQUVGLE9BQU87Z0JBQ0wsSUFBSTtnQkFDSixhQUFhO2dCQUNiLFlBQVksRUFBRSxhQUFhLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsWUFBWTtnQkFDakQsSUFBSTtnQkFDSixTQUFTLEVBQUUsV0FBVyxDQUFDLFNBQVM7Z0JBQ2hDLE1BQU07Z0JBQ04sVUFBVSxFQUFFLFdBQVcsQ0FBQyxVQUFVO2dCQUNsQyxXQUFXLEVBQUUsVUFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUM7b0JBQ2hDLEtBQUssRUFBRSxDQUFDLENBQUMsbUJBQW1CO29CQUM1QixNQUFNLEVBQUUsQ0FBQyxDQUFDLG9CQUFvQjtpQkFDL0IsQ0FBQyxDQUFDO2FBQ0osQ0FBQztTQUNIO1FBQUMsT0FBTyxDQUFDLEVBQUU7WUFDVixNQUFNLEVBQUUsQ0FBQyxNQUFNLEVBQUUsbUJBQW1CLFNBQVMsSUFBSSxJQUFJLEtBQUssQ0FBQyxDQUFDLE9BQU8sR0FBRyxDQUFDLENBQUM7U0FDekU7SUFDSCxDQUFDO0NBQ0Y7QUE1RkQsK0JBNEZDIn0=

package/dist/introspection/types.d.ts

@@ -0,0 +1,32 @@
+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 ColumnType = {
+    type: 'scalar';
+    subType: 'BIGINT' | 'BOOLEAN' | 'DATE' | 'DATEONLY' | 'DOUBLE' | 'FLOAT' | 'INET' | 'JSON' | 'JSONB' | 'NUMBER' | 'STRING' | 'TIME' | 'UUID';
+} | {
+    type: 'array';
+    subType: ColumnType;
+} | {
+    type: 'enum';
+    values: string[];
+};
+export declare type Table = {
+    name: string;
+    columns: {
+        name: string;
+        type: ColumnType;
+        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/helpers/sequelize-type.d.ts

@@ -0,0 +1,5 @@
+import { ColumnType, SequelizeColumnType } from '../../introspection/types';
+export default class SequelizeTypeFactory {
+    static makeSequelizeType(type: ColumnType): SequelizeColumnType;
+}
+//# sourceMappingURL=sequelize-type.d.ts.map

package/dist/orm-builder/helpers/sequelize-type.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+class SequelizeTypeFactory {
+    static makeSequelizeType(type) {
+        switch (type.type) {
+            case 'scalar':
+                if (sequelize_1.DataTypes[type.subType])
+                    return sequelize_1.DataTypes[type.subType];
+                throw new Error(`Unexpected type: ${type.subType}`);
+            case 'enum':
+                return sequelize_1.DataTypes.ENUM(...type.values);
+            case 'array':
+                return sequelize_1.DataTypes.ARRAY(this.makeSequelizeType(type.subType));
+            default:
+                throw new Error();
+        }
+    }
+}
+exports.default = SequelizeTypeFactory;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VxdWVsaXplLXR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvb3JtLWJ1aWxkZXIvaGVscGVycy9zZXF1ZWxpemUtdHlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLHlDQUFzQztBQUl0QyxNQUFxQixvQkFBb0I7SUFDdkMsTUFBTSxDQUFDLGlCQUFpQixDQUFDLElBQWdCO1FBQ3ZDLFFBQVEsSUFBSSxDQUFDLElBQUksRUFBRTtZQUNqQixLQUFLLFFBQVE7Z0JBQ1gsSUFBSSxxQkFBUyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUM7b0JBQUUsT0FBTyxxQkFBUyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztnQkFDNUQsTUFBTSxJQUFJLEtBQUssQ0FBQyxvQkFBb0IsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDLENBQUM7WUFFdEQsS0FBSyxNQUFNO2dCQUNULE9BQU8scUJBQVMsQ0FBQyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUM7WUFFeEMsS0FBSyxPQUFPO2dCQUNWLE9BQU8scUJBQVMsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDO1lBRS9EO2dCQUNFLE1BQU0sSUFBSSxLQUFLLEVBQUUsQ0FBQztTQUNyQjtJQUNILENBQUM7Q0FDRjtBQWpCRCx1Q0FpQkMifQ==

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,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_type_1 = __importDefault(require("./helpers/sequelize-type"));
+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,
+                    type: sequelize_type_1.default.makeSequelizeType(column.type),
+                };
+        }
+        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/orm-builder/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forestadmin/datasource-sql",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.1-alpha.1",
   "main": "dist/index.js",
   "license": "GPL-3.0",
   "publishConfig": {
@@ -12,9 +12,10 @@
     "directory": "packages/datasource-sql"
   },
   "dependencies": {
-    "@forestadmin/datasource-sequelize": "1.0.0-beta.7",
-    "@forestadmin/datasource-toolkit": "1.0.0-beta.5",
-    "sequelize": "6.18.0"
+    "@forestadmin/datasource-sequelize": "1.0.1-alpha.1",
+    "@forestadmin/datasource-toolkit": "1.0.1-alpha.1",
+    "pluralize": "^8.0.0",
+    "sequelize": "6.21.3"
   },
   "files": [
     "dist/**/*.js",
@@ -28,7 +29,6 @@
     "test": "jest"
   },
   "devDependencies": {
-    "lodash": "^4.17.21",
-    "sequelize": "6.18.0"
+    "lodash": "^4.17.21"
   }
 }

package/CHANGELOG.md

@@ -1,97 +0,0 @@
-# @forestadmin/datasource-sql [1.0.0-beta.9](https://github.com/ForestAdmin/agent-nodejs/compare/@forestadmin/datasource-sql@1.0.0-beta.8...@forestadmin/datasource-sql@1.0.0-beta.9) (2022-04-20)
-
-
-
-
-
-### Dependencies
-
-* **@forestadmin/datasource-sequelize:** upgraded to 1.0.0-beta.7
-
-# @forestadmin/datasource-sql [1.0.0-beta.8](https://github.com/ForestAdmin/agent-nodejs/compare/@forestadmin/datasource-sql@1.0.0-beta.7...@forestadmin/datasource-sql@1.0.0-beta.8) (2022-04-19)
-
-
-
-
-
-### Dependencies
-
-* **@forestadmin/datasource-sequelize:** upgraded to 1.0.0-beta.6
-* **@forestadmin/datasource-toolkit:** upgraded to 1.0.0-beta.5
-
-# @forestadmin/datasource-sql [1.0.0-beta.7](https://github.com/ForestAdmin/agent-nodejs/compare/@forestadmin/datasource-sql@1.0.0-beta.6...@forestadmin/datasource-sql@1.0.0-beta.7) (2022-04-19)
-
-
-
-
-
-### Dependencies
-
-* **@forestadmin/datasource-sequelize:** upgraded to 1.0.0-beta.5
-
-# @forestadmin/datasource-sql [1.0.0-beta.6](https://github.com/ForestAdmin/agent-nodejs/compare/@forestadmin/datasource-sql@1.0.0-beta.5...@forestadmin/datasource-sql@1.0.0-beta.6) (2022-04-15)
-
-
-### Features
-
-* **datasource sql:** handle primitive fields and default values ([#215](https://github.com/ForestAdmin/agent-nodejs/issues/215)) ([59a56da](https://github.com/ForestAdmin/agent-nodejs/commit/59a56da2721f39d0487b14d72b11d71b38b83a1f))
-
-# @forestadmin/datasource-sql [1.0.0-beta.5](https://github.com/ForestAdmin/agent-nodejs/compare/@forestadmin/datasource-sql@1.0.0-beta.4...@forestadmin/datasource-sql@1.0.0-beta.5) (2022-04-15)
-
-
-
-
-
-### Dependencies
-
-* **@forestadmin/datasource-sequelize:** upgraded to 1.0.0-beta.4
-* **@forestadmin/datasource-toolkit:** upgraded to 1.0.0-beta.4
-
-# @forestadmin/datasource-sql [1.0.0-beta.4](https://github.com/ForestAdmin/agent-nodejs/compare/@forestadmin/datasource-sql@1.0.0-beta.3...@forestadmin/datasource-sql@1.0.0-beta.4) (2022-04-15)
-
-
-### Bug Fixes
-
-* switched from qiwi to dhoulb version of msr ([020c3e0](https://github.com/ForestAdmin/agent-nodejs/commit/020c3e04c64164c3f26aae293989db7842f82e8c))
-
-# @forestadmin/datasource-sql [1.0.0-beta.3](https://github.com/ForestAdmin/agent-nodejs/compare/@forestadmin/datasource-sql@1.0.0-beta.2...@forestadmin/datasource-sql@1.0.0-beta.3) (2022-04-15)
-
-
-### Bug Fixes
-
-* correct versions in package.json of all datasources ([540d395](https://github.com/ForestAdmin/agent-nodejs/commit/540d395bc5e42bdd7edb3dce5806ade8554f3d7a))
-
-
-
-
-
-### Dependencies
-
-* **@forestadmin/datasource-sequelize:** upgraded to 1.0.0-beta.3
-
-# @forestadmin/datasource-sql [1.0.0-beta.2](https://github.com/ForestAdmin/agent-nodejs/compare/@forestadmin/datasource-sql@1.0.0-beta.1...@forestadmin/datasource-sql@1.0.0-beta.2) (2022-04-15)
-
-
-
-
-
-### Dependencies
-
-* **@forestadmin/datasource-sequelize:** upgraded to 1.0.0-beta.2
-* **@forestadmin/datasource-toolkit:** upgraded to 1.0.0-beta.3
-
-# @forestadmin/datasource-sql 1.0.0-beta.1 (2022-04-15)
-
-
-### Bug Fixes
-
-* enable npm, git and github distribution ([bd91825](https://github.com/ForestAdmin/agent-nodejs/commit/bd91825f4d185874a259da28b0f7a6c7f557196d))
-* fix semantic release ([3a2fa73](https://github.com/ForestAdmin/agent-nodejs/commit/3a2fa738af84a50b9563db6ac039c922b77f55cc))
-
-
-
-
-
-### Dependencies
-
-* **@forestadmin/datasource-sequelize:** upgraded to 1.0.0-beta.1

package/dist/datasource.d.ts

@@ -1,14 +0,0 @@
-import { SequelizeDataSource } from '@forestadmin/datasource-sequelize';
-export default class SqlDataSource extends SequelizeDataSource {
-    private readonly queryInterface;
-    private readonly defaultValueParser;
-    private readonly sqlTypeConverter;
-    constructor(connectionUri: string);
-    build(): Promise<void>;
-    private defineModels;
-    private hasTimestamps;
-    private removeTimeStampColumns;
-    private isParanoid;
-    private removeParanoidColumn;
-}
-//# sourceMappingURL=datasource.d.ts.map

package/dist/datasource.js

@@ -1,79 +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 SqlDataSource extends datasource_sequelize_1.SequelizeDataSource {
-    constructor(connectionUri) {
-        super(new sequelize_1.Sequelize(connectionUri, { logging: false }));
-        this.queryInterface = this.sequelize.getQueryInterface();
-        this.defaultValueParser = new default_value_parser_1.default(this.sequelize.getDialect());
-        this.sqlTypeConverter = new sql_type_converter_1.default(this.sequelize);
-    }
-    async build() {
-        const tableNames = await this.queryInterface.showAllTables();
-        await this.defineModels(tableNames);
-        this.createCollections(this.sequelize.models);
-    }
-    async defineModels(tableNames) {
-        return Promise.all(tableNames.map(async (tableName) => {
-            const colmumnDescriptions = await this.queryInterface.describeTable(tableName);
-            const fieldDescriptions = await Promise.all(Object.entries(colmumnDescriptions).map(async ([columnName, colmumnDescription]) => {
-                const type = await this.sqlTypeConverter.convert(tableName, columnName, colmumnDescription);
-                let defaultValue = this.defaultValueParser.parse(colmumnDescription.defaultValue, type);
-                if (colmumnDescription.primaryKey && defaultValue) {
-                    defaultValue = null;
-                    colmumnDescription.autoIncrement = true;
-                }
-                return [
-                    columnName,
-                    {
-                        ...colmumnDescription,
-                        type,
-                        defaultValue,
-                    },
-                ];
-            }));
-            let modelDefinition = Object.fromEntries(fieldDescriptions);
-            const columnNames = Object.keys(modelDefinition);
-            const hasTimestamps = this.hasTimestamps(columnNames);
-            const isParanoid = this.isParanoid(columnNames);
-            if (hasTimestamps) {
-                modelDefinition = this.removeTimeStampColumns(modelDefinition);
-            }
-            if (isParanoid) {
-                modelDefinition = this.removeParanoidColumn(modelDefinition);
-            }
-            this.sequelize.define(tableName, modelDefinition, {
-                tableName,
-                timestamps: hasTimestamps,
-                paranoid: isParanoid,
-            });
-        }));
-    }
-    hasTimestamps(columnNames) {
-        const hasCreatedAt = columnNames.includes('createdAt');
-        const hasUpdatedAt = columnNames.includes('updatedAt');
-        return hasCreatedAt && hasUpdatedAt;
-    }
-    removeTimeStampColumns(modelDefinition) {
-        const copy = { ...modelDefinition };
-        delete copy.createdAt;
-        delete copy.updatedAt;
-        return copy;
-    }
-    isParanoid(columnNames) {
-        return columnNames.includes('deletedAt');
-    }
-    removeParanoidColumn(modelDefinition) {
-        const copy = { ...modelDefinition };
-        delete copy.deletedAt;
-        return copy;
-    }
-}
-exports.default = SqlDataSource;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9kYXRhc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEseUNBQWdGO0FBRWhGLDRFQUF3RTtBQUV4RSx3RkFBOEQ7QUFDOUQsb0ZBQTBEO0FBRTFELE1BQXFCLGFBQWMsU0FBUSwwQ0FBbUI7SUFLNUQsWUFBWSxhQUFxQjtRQUMvQixLQUFLLENBQUMsSUFBSSxxQkFBUyxDQUFDLGFBQWEsRUFBRSxFQUFFLE9BQU8sRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFFeEQsSUFBSSxDQUFDLGNBQWMsR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDLGlCQUFpQixFQUFFLENBQUM7UUFDekQsSUFBSSxDQUFDLGtCQUFrQixHQUFHLElBQUksOEJBQWtCLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxVQUFVLEVBQWEsQ0FBQyxDQUFDO1FBQ3pGLElBQUksQ0FBQyxnQkFBZ0IsR0FBRyxJQUFJLDRCQUFnQixDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUMvRCxDQUFDO0lBRUQsS0FBSyxDQUFDLEtBQUs7UUFDVCxNQUFNLFVBQVUsR0FBRyxNQUFNLElBQUksQ0FBQyxjQUFjLENBQUMsYUFBYSxFQUFFLENBQUM7UUFFN0QsTUFBTSxJQUFJLENBQUMsWUFBWSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBRXBDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ2hELENBQUM7SUFFTyxLQUFLLENBQUMsWUFBWSxDQUFDLFVBQW9CO1FBQzdDLE9BQU8sT0FBTyxDQUFDLEdBQUcsQ0FDaEIsVUFBVSxDQUFDLEdBQUcsQ0FBQyxLQUFLLEVBQUMsU0FBUyxFQUFDLEVBQUU7WUFDL0IsTUFBTSxtQkFBbUIsR0FBRyxNQUFNLElBQUksQ0FBQyxjQUFjLENBQUMsYUFBYSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1lBRS9FLE1BQU0saUJBQWlCLEdBQUcsTUFBTSxPQUFPLENBQUMsR0FBRyxDQUN6QyxNQUFNLENBQUMsT0FBTyxDQUFDLG1CQUFtQixDQUFDLENBQUMsR0FBRyxDQUFDLEtBQUssRUFBRSxDQUFDLFVBQVUsRUFBRSxrQkFBa0IsQ0FBQyxFQUFFLEVBQUU7Z0JBQ2pGLE1BQU0sSUFBSSxHQUFHLE1BQU0sSUFBSSxDQUFDLGdCQUFnQixDQUFDLE9BQU8sQ0FDOUMsU0FBUyxFQUNULFVBQVUsRUFDVixrQkFBa0IsQ0FDbkIsQ0FBQztnQkFFRixJQUFJLFlBQVksR0FBRyxJQUFJLENBQUMsa0JBQWtCLENBQUMsS0FBSyxDQUFDLGtCQUFrQixDQUFDLFlBQVksRUFBRSxJQUFJLENBQUMsQ0FBQztnQkFFeEYsSUFBSSxrQkFBa0IsQ0FBQyxVQUFVLElBQUksWUFBWSxFQUFFO29CQUNqRCxZQUFZLEdBQUcsSUFBSSxDQUFDO29CQUNwQixrQkFBa0IsQ0FBQyxhQUFhLEdBQUcsSUFBSSxDQUFDO2lCQUN6QztnQkFFRCxPQUFPO29CQUNMLFVBQVU7b0JBQ1Y7d0JBQ0UsR0FBRyxrQkFBa0I7d0JBQ3JCLElBQUk7d0JBQ0osWUFBWTtxQkFDYjtpQkFDRixDQUFDO1lBQ0osQ0FBQyxDQUFDLENBQ0gsQ0FBQztZQUVGLElBQUksZUFBZSxHQUFvQixNQUFNLENBQUMsV0FBVyxDQUFDLGlCQUFpQixDQUFDLENBQUM7WUFDN0UsTUFBTSxXQUFXLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsQ0FBQztZQUVqRCxNQUFNLGFBQWEsR0FBRyxJQUFJLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1lBQ3RELE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxVQUFVLENBQUMsV0FBVyxDQUFDLENBQUM7WUFFaEQsSUFBSSxhQUFhLEVBQUU7Z0JBQ2pCLGVBQWUsR0FBRyxJQUFJLENBQUMsc0JBQXNCLENBQUMsZUFBZSxDQUFDLENBQUM7YUFDaEU7WUFFRCxJQUFJLFVBQVUsRUFBRTtnQkFDZCxlQUFlLEdBQUcsSUFBSSxDQUFDLG9CQUFvQixDQUFDLGVBQWUsQ0FBQyxDQUFDO2FBQzlEO1lBRUQsSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsU0FBUyxFQUFFLGVBQWUsRUFBRTtnQkFDaEQsU0FBUztnQkFDVCxVQUFVLEVBQUUsYUFBYTtnQkFDekIsUUFBUSxFQUFFLFVBQVU7YUFDckIsQ0FBQyxDQUFDO1FBQ0wsQ0FBQyxDQUFDLENBQ0gsQ0FBQztJQUNKLENBQUM7SUFFTyxhQUFhLENBQUMsV0FBcUI7UUFDekMsTUFBTSxZQUFZLEdBQUcsV0FBVyxDQUFDLFFBQVEsQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUN2RCxNQUFNLFlBQVksR0FBRyxXQUFXLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBRXZELE9BQU8sWUFBWSxJQUFJLFlBQVksQ0FBQztJQUN0QyxDQUFDO0lBRU8sc0JBQXNCLENBQUMsZUFBZ0M7UUFDN0QsTUFBTSxJQUFJLEdBQUcsRUFBRSxHQUFHLGVBQWUsRUFBRSxDQUFDO1FBQ3BDLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQztRQUN0QixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUM7UUFFdEIsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRU8sVUFBVSxDQUFDLFdBQXFCO1FBQ3RDLE9BQU8sV0FBVyxDQUFDLFFBQVEsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUMzQyxDQUFDO0lBRU8sb0JBQW9CLENBQUMsZUFBZ0M7UUFDM0QsTUFBTSxJQUFJLEdBQUcsRUFBRSxHQUFHLGVBQWUsRUFBRSxDQUFDO1FBQ3BDLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQztRQUV0QixPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7Q0FDRjtBQXBHRCxnQ0FvR0MifQ==

package/dist/utils/default-value-parser.d.ts

@@ -1,11 +0,0 @@
-import { AbstractDataType, AbstractDataTypeConstructor, Dialect } from 'sequelize';
-export default class DefaultValueParser {
-    private readonly dialect;
-    constructor(dialect: Dialect);
-    parse(expression: any, type: AbstractDataType | AbstractDataTypeConstructor): unknown;
-    private parseGeneric;
-    private sanitizeExpression;
-    private literalUnlessMatch;
-    private parseNumber;
-}
-//# sourceMappingURL=default-value-parser.d.ts.map

package/dist/utils/default-value-parser.js

@@ -1,78 +0,0 @@
-"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 instanceof sequelize_1.DataTypes.ARRAY) {
-            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 instanceof sequelize_1.DataTypes.ENUM) {
-            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') {
-            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/utils/sql-type-converter.js

@@ -1,105 +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:
-                // TODO put logging warning
-                console.warn(type, columnInfo);
-        }
-    }
-}
-exports.default = SqlTypeConverter;
-//# sourceMappingURL=data:application/json;base64,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