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

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# @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)
 
 

package/dist/datasource.d.ts

@@ -1,5 +1,14 @@
 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,11 +1,79 @@
 "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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9kYXRhc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEseUNBQXNDO0FBRXRDLDRFQUF3RTtBQUV4RSxNQUFxQixhQUFjLFNBQVEsMENBQW1CO0lBQzVELFlBQVksYUFBcUI7UUFDL0IsS0FBSyxDQUFDLElBQUkscUJBQVMsQ0FBQyxhQUFhLEVBQUUsRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQzFELENBQUM7Q0FDRjtBQUpELGdDQUlDIn0=
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/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/utils/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJyYXktdHlwZS1nZXR0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvYXJyYXktdHlwZS1nZXR0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSx5Q0FBa0Q7QUFFbEQsTUFBcUIsZUFBZTtJQWdEbEMsWUFBWSxTQUFvQjtRQTdDZixVQUFLLEdBQUc7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0EyQ3hCLENBQUM7UUFHQSxJQUFJLENBQUMsU0FBUyxHQUFHLFNBQVMsQ0FBQztRQUMzQiw4REFBOEQ7UUFDOUQsSUFBSSxDQUFDLFNBQVMsR0FBSSxJQUFJLENBQUMsU0FBUyxDQUFDLGlCQUFpQixFQUFFLENBQUMsY0FBc0IsQ0FBQyxTQUFTLENBQUM7SUFDeEYsQ0FBQztJQUVELEtBQUssQ0FBQyxPQUFPLENBQ1gsU0FBaUIsRUFDakIsVUFBa0I7UUFFbEIsTUFBTSxZQUFZLEdBQUcsRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLENBQUM7UUFFL0MsTUFBTSxDQUFDLEVBQUUsSUFBSSxFQUFFLE9BQU8sRUFBRSxDQUFDLEdBQUcsTUFBTSxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsS0FBSyxFQUFFO1lBQ2pFLFlBQVk7WUFDWixJQUFJLEVBQUUsc0JBQVUsQ0FBQyxNQUFNO1NBQ3hCLENBQUMsQ0FBQztRQUVILE9BQU87WUFDTCxJQUFJLEVBQUUsSUFBSSxDQUFDLFdBQVcsRUFBRTtZQUN4QixPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFO1NBQ2hELENBQUM7SUFDSixDQUFDO0NBQ0Y7QUF0RUQsa0NBc0VDIn0=

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

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

@@ -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, 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.d.ts

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

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forestadmin/datasource-sql",
-  "version": "1.0.0-beta.5",
+  "version": "1.0.0-beta.6",
   "main": "dist/index.js",
   "license": "GPL-3.0",
   "publishConfig": {