@forestadmin/datasource-sql 1.0.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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/introspection/helpers/array-type-getter.d.ts

@@ -0,0 +1,12 @@
+import { Sequelize } from 'sequelize';
+export default class ArrayTypeGetter {
+    private readonly sequelize;
+    private readonly fromArray;
+    private readonly query;
+    constructor(sequelize: Sequelize);
+    getType(tableName: string, columnName: string): Promise<{
+        type: string;
+        special: string[];
+    }>;
+}
+//# sourceMappingURL=array-type-getter.d.ts.map

package/dist/introspection/helpers/array-type-getter.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+class ArrayTypeGetter {
+    constructor(sequelize) {
+        this.query = `
+  SELECT
+    (
+      CASE
+        WHEN e.udt_name = 'hstore' THEN e.udt_name
+        ELSE e.data_type
+      END
+    ) || (
+      CASE
+        WHEN e.character_maximum_length IS NOT NULL THEN '(' || e.character_maximum_length || ')'
+        ELSE ''
+      END
+    ) as "type",
+    (
+      SELECT
+        array_agg(en.enumlabel)
+      FROM
+        pg_catalog.pg_type t
+        JOIN pg_catalog.pg_enum en ON t.oid = en.enumtypid
+      WHERE
+        t.typname = e.udt_name
+    ) AS "special"
+  FROM
+    INFORMATION_SCHEMA.columns c
+    LEFT JOIN INFORMATION_SCHEMA.element_types e ON (
+      (
+        c.table_catalog,
+        c.table_schema,
+        c.table_name,
+        'TABLE',
+        c.dtd_identifier
+      ) = (
+        e.object_catalog,
+        e.object_schema,
+        e.object_name,
+        e.object_type,
+        e.collection_type_identifier
+      )
+    )
+  WHERE
+    table_name = :tableName
+    AND c.column_name = :columnName
+  ;
+  `;
+        this.sequelize = sequelize;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.fromArray = this.sequelize.getQueryInterface().queryGenerator.fromArray;
+    }
+    async getType(tableName, columnName) {
+        const replacements = { tableName, columnName };
+        const [{ type, special }] = await this.sequelize.query(this.query, {
+            replacements,
+            type: sequelize_1.QueryTypes.SELECT,
+        });
+        return {
+            type: type.toUpperCase(),
+            special: special ? this.fromArray(special) : [],
+        };
+    }
+}
+exports.default = ArrayTypeGetter;
+//# 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/introspection/helpers/sql-type-converter.d.ts

@@ -0,0 +1,15 @@
+import { ColumnDescription, Sequelize } from 'sequelize';
+import { ColumnType } from '../types';
+export default class SqlTypeConverter {
+    private readonly enumRegex;
+    private readonly arrayTypeGetter;
+    constructor(sequelize: Sequelize);
+    private typeMatch;
+    private typeStartsWith;
+    private typeContains;
+    private convertToEnum;
+    private getTypeForUserDefined;
+    private getTypeForArray;
+    convert(tableName: string, columnName: string, columnInfo: ColumnDescription): Promise<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,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

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVsYXRpb24tZXh0cmFjdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL29ybS1idWlsZGVyL2hlbHBlcnMvcmVsYXRpb24tZXh0cmFjdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBR0EsTUFBcUIsaUJBQWlCO0lBQ3BDLE1BQU0sQ0FBQyxhQUFhLENBQUMsU0FBaUIsRUFBRSxNQUFlO1FBQ3JELE1BQU0sU0FBUyxHQUFlLEVBQUUsQ0FBQztRQUVqQyxLQUFLLE1BQU0sS0FBSyxJQUFJLE1BQU0sRUFBRTtZQUMxQixTQUFTLENBQUMsSUFBSSxDQUFDLEdBQUcsSUFBSSxDQUFDLG1CQUFtQixDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7WUFDbkQsU0FBUyxDQUFDLElBQUksQ0FBQyxHQUFHLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO1NBQ3REO1FBRUQsT0FBTyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksS0FBSyxTQUFTLENBQUMsQ0FBQztJQUNyRCxDQUFDO0lBRU8sTUFBTSxDQUFDLG1CQUFtQixDQUFDLEtBQVk7UUFDN0MsTUFBTSxTQUFTLEdBQWUsRUFBRSxDQUFDO1FBRWpDLEtBQUssTUFBTSxNQUFNLElBQUksS0FBSyxDQUFDLE9BQU8sRUFBRTtZQUNsQyxLQUFLLE1BQU0sVUFBVSxJQUFJLE1BQU0sQ0FBQyxXQUFXLEVBQUU7Z0JBQzNDLFNBQVMsQ0FBQyxJQUFJLENBQUM7b0JBQ2IsSUFBSSxFQUFFLFdBQVc7b0JBQ2pCLElBQUksRUFBRSxLQUFLLENBQUMsSUFBSTtvQkFDaEIsRUFBRSxFQUFFLFVBQVUsQ0FBQyxLQUFLO29CQUNwQixVQUFVLEVBQUUsTUFBTSxDQUFDLElBQUk7b0JBQ3ZCLGdCQUFnQixFQUFFLFVBQVUsQ0FBQyxNQUFNO2lCQUNwQyxDQUFDLENBQUM7Z0JBRUgsa0NBQWtDO2dCQUNsQyxJQUFJLENBQUMsSUFBSSxDQUFDLGVBQWUsQ0FBQyxLQUFLLENBQUM7b0JBQzlCLFNBQVMsQ0FBQyxJQUFJLENBQUM7d0JBQ2IsSUFBSSxFQUFFLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsU0FBUzt3QkFDMUMsSUFBSSxFQUFFLFVBQVUsQ0FBQyxLQUFLO3dCQUN0QixFQUFFLEVBQUUsS0FBSyxDQUFDLElBQUk7d0JBQ2QsU0FBUyxFQUFFLE1BQU0sQ0FBQyxJQUFJO3dCQUN0QixlQUFlLEVBQUUsVUFBVSxDQUFDLE1BQU07cUJBQ25DLENBQUMsQ0FBQzthQUNOO1NBQ0Y7UUFFRCxPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDO0lBRU8sTUFBTSxDQUFDLHFCQUFxQixDQUFDLEtBQVk7UUFDL0MsTUFBTSxTQUFTLEdBQWUsRUFBRSxDQUFDO1FBQ2pDLE1BQU0sT0FBTyxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLFVBQVUsSUFBSSxDQUFDLENBQUMsV0FBVyxDQUFDLE1BQU0sS0FBSyxDQUFDLENBQUMsQ0FBQztRQUV0RixJQUFJLElBQUksQ0FBQyxlQUFlLENBQUMsS0FBSyxDQUFDLEVBQUU7WUFDL0IsTUFBTSxDQUFDLE9BQU8sRUFBRSxPQUFPLENBQUMsR0FBRyxPQUFPLENBQUM7WUFFbkMsU0FBUyxDQUFDLElBQUksQ0FBQztnQkFDYixJQUFJLEVBQUUsZUFBZTtnQkFDckIsSUFBSSxFQUFFLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSztnQkFDbEMsRUFBRSxFQUFFLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSztnQkFDaEMsT0FBTyxFQUFFLEtBQUssQ0FBQyxJQUFJO2dCQUNuQixTQUFTLEVBQUUsT0FBTyxDQUFDLElBQUk7Z0JBQ3ZCLFVBQVUsRUFBRSxPQUFPLENBQUMsSUFBSTtnQkFDeEIsZUFBZSxFQUFFLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTTtnQkFDOUMsZ0JBQWdCLEVBQUUsT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNO2FBQ2hELENBQUMsQ0FBQztZQUVILFNBQVMsQ0FBQyxJQUFJLENBQUM7Z0JBQ2IsSUFBSSxFQUFFLGVBQWU7Z0JBQ3JCLElBQUksRUFBRSxPQUFPLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUs7Z0JBQ2xDLEVBQUUsRUFBRSxPQUFPLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUs7Z0JBQ2hDLE9BQU8sRUFBRSxLQUFLLENBQUMsSUFBSTtnQkFDbkIsU0FBUyxFQUFFLE9BQU8sQ0FBQyxJQUFJO2dCQUN2QixVQUFVLEVBQUUsT0FBTyxDQUFDLElBQUk7Z0JBQ3hCLGVBQWUsRUFBRSxPQUFPLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQyxDQUFDLE1BQU07Z0JBQzlDLGdCQUFnQixFQUFFLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTTthQUNoRCxDQUFDLENBQUM7U0FDSjtRQUVELE9BQU8sU0FBUyxDQUFDO0lBQ25CLENBQUM7SUFFTyxNQUFNLENBQUMsZUFBZSxDQUFDLEtBQVk7UUFDekMsT0FBTyxLQUFLLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxVQUFVLElBQUksQ0FBQyxDQUFDLFdBQVcsQ0FBQyxNQUFNLEtBQUssQ0FBQyxDQUFDLENBQUMsTUFBTSxLQUFLLENBQUMsQ0FBQztJQUM1RixDQUFDO0NBQ0Y7QUE1RUQsb0NBNEVDIn0=

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