@forestadmin/datasource-sequelize 1.0.0-alpha.1

package/dist/utils/query-converter.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const sequelize_1 = require("sequelize");
+const un_ambigous_1 = __importDefault(require("./un-ambigous"));
+class QueryConverter {
+    constructor(model) {
+        this.model = model;
+        this.dialect = this.model.sequelize.getDialect();
+        this.col = this.model.sequelize.col;
+        this.fn = this.model.sequelize.fn;
+        this.where = this.model.sequelize.where;
+    }
+    asArray(value) {
+        if (!Array.isArray(value))
+            return [value];
+        return value;
+    }
+    makeWhereClause(field, operator, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    value) {
+        if (operator === null)
+            throw new Error('Invalid (null) operator.');
+        switch (operator) {
+            case 'Blank':
+                return {
+                    [sequelize_1.Op.or]: [this.makeWhereClause(field, 'Missing'), { [sequelize_1.Op.eq]: '' }],
+                };
+            case 'Like':
+                if (this.dialect === 'sqlite')
+                    return this.where(this.col(field), 'GLOB', value.replace(/%/g, '*').replace(/_/g, '?'));
+                if (this.dialect === 'mysql' || this.dialect === 'mariadb')
+                    return this.where(this.fn('BINARY', this.col(field)), 'LIKE', value);
+                return { [sequelize_1.Op.like]: value };
+            case 'ILike':
+                if (this.dialect === 'postgres')
+                    return { [sequelize_1.Op.iLike]: value };
+                if (this.dialect === 'mysql' || this.dialect === 'mariadb' || this.dialect === 'sqlite')
+                    return { [sequelize_1.Op.like]: value };
+                return this.where(this.fn('LOWER', this.col(field)), 'LIKE', value.toLocaleLowerCase());
+            case 'NotContains':
+                return {
+                    [sequelize_1.Op.not]: this.makeWhereClause(field, 'Like', `%${value}%`),
+                };
+            case 'Equal':
+                return { [sequelize_1.Op.eq]: value };
+            case 'GreaterThan':
+                return { [sequelize_1.Op.gt]: value };
+            case 'In':
+                return { [sequelize_1.Op.in]: this.asArray(value) };
+            case 'IncludesAll':
+                return { [sequelize_1.Op.contains]: this.asArray(value) };
+            case 'LessThan':
+                return { [sequelize_1.Op.lt]: value };
+            case 'Missing':
+                return { [sequelize_1.Op.is]: null };
+            case 'NotEqual':
+                return { [sequelize_1.Op.ne]: value };
+            case 'NotIn':
+                return { [sequelize_1.Op.notIn]: this.asArray(value) };
+            case 'Present':
+                return { [sequelize_1.Op.ne]: null };
+            default:
+                throw new Error(`Unsupported operator: "${operator}".`);
+        }
+    }
+    /*
+     * Delete and update sequelize methods does not provide the include options.
+     * This method is developed to by pass this problem.
+     */
+    async getWhereFromConditionTreeToByPassInclude(conditionTree) {
+        const include = conditionTree ? this.getIncludeFromProjection(conditionTree.projection) : [];
+        const whereOptions = this.getWhereFromConditionTree(conditionTree);
+        if (include.length === 0) {
+            return whereOptions;
+        }
+        const keys = [...this.model.primaryKeyAttributes];
+        const records = await this.model.findAll({ attributes: keys, where: whereOptions, include });
+        const conditions = records.map(record => {
+            const equals = keys.map(pk => new datasource_toolkit_1.ConditionTreeLeaf(pk, 'Equal', record.get(pk)));
+            return datasource_toolkit_1.ConditionTreeFactory.intersect(...equals);
+        });
+        const union = datasource_toolkit_1.ConditionTreeFactory.union(...conditions);
+        return this.getWhereFromConditionTree(union);
+    }
+    getWhereFromConditionTree(conditionTree) {
+        if (!conditionTree)
+            return {};
+        const sequelizeWhereClause = {};
+        if (conditionTree.aggregator !== undefined) {
+            const { aggregator, conditions } = conditionTree;
+            if (aggregator === null) {
+                throw new Error('Invalid (null) aggregator.');
+            }
+            const sequelizeOperator = aggregator === 'And' ? sequelize_1.Op.and : sequelize_1.Op.or;
+            if (!Array.isArray(conditions)) {
+                throw new Error('Conditions must be an array.');
+            }
+            sequelizeWhereClause[sequelizeOperator] = conditions.map(condition => this.getWhereFromConditionTree(condition));
+        }
+        else if (conditionTree.operator !== undefined) {
+            const { field, operator, value } = conditionTree;
+            const isRelation = field.includes(':');
+            const safeField = (0, un_ambigous_1.default)(this.model, field);
+            sequelizeWhereClause[isRelation ? `$${safeField}$` : safeField] = this.makeWhereClause(safeField, operator, value);
+        }
+        else {
+            throw new Error('Invalid ConditionTree.');
+        }
+        return sequelizeWhereClause;
+    }
+    computeIncludeFromProjection(projection, withAttributes = true) {
+        return Object.entries(projection.relations).map(([relationName, relationProjection]) => {
+            return {
+                association: relationName,
+                attributes: withAttributes ? relationProjection.columns : [],
+                include: this.computeIncludeFromProjection(relationProjection, withAttributes),
+            };
+        });
+    }
+    getIncludeFromProjection(projection) {
+        return this.computeIncludeFromProjection(projection, false);
+    }
+    getIncludeWithAttributesFromProjection(projection) {
+        return this.computeIncludeFromProjection(projection);
+    }
+    getOrderFromSort(sort) {
+        return (sort ?? []).map(({ field, ascending }) => {
+            const path = field.split(':');
+            return [...path, ascending ? 'ASC' : 'DESC'];
+        });
+    }
+}
+exports.default = QueryConverter;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/serializer.d.ts

@@ -0,0 +1,6 @@
+import { RecordData } from '@forestadmin/datasource-toolkit';
+export default class Serializer {
+    static serialize(record: RecordData): RecordData;
+    static serializeValue(value: unknown): unknown;
+}
+//# sourceMappingURL=serializer.d.ts.map

package/dist/utils/serializer.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Serializer {
+    static serialize(record) {
+        Object.entries(record).forEach(([name, value]) => {
+            if (value instanceof Date)
+                record[name] = this.serializeValue(value);
+            if (Array.isArray(value))
+                this.serializeValue(value); // the change is by references
+            if (value instanceof Object)
+                return this.serialize(record[name]);
+        });
+        return record;
+    }
+    static serializeValue(value) {
+        if (value instanceof Date)
+            return value.toISOString();
+        if (Array.isArray(value)) {
+            value.forEach((v, i) => {
+                // serialize by reference to improve performances by avoiding the copies
+                if (value instanceof Date)
+                    value[i] = v.toISOString();
+            });
+        }
+        return value;
+    }
+}
+exports.default = Serializer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VyaWFsaXplci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9zZXJpYWxpemVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBRUEsTUFBcUIsVUFBVTtJQUM3QixNQUFNLENBQUMsU0FBUyxDQUFDLE1BQWtCO1FBQ2pDLE1BQU0sQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLEVBQUUsRUFBRTtZQUMvQyxJQUFJLEtBQUssWUFBWSxJQUFJO2dCQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUMsY0FBYyxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQ3JFLElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUM7Z0JBQUUsSUFBSSxDQUFDLGNBQWMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLDhCQUE4QjtZQUNwRixJQUFJLEtBQUssWUFBWSxNQUFNO2dCQUFFLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztRQUNuRSxDQUFDLENBQUMsQ0FBQztRQUVILE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7SUFFRCxNQUFNLENBQUMsY0FBYyxDQUFDLEtBQWM7UUFDbEMsSUFBSSxLQUFLLFlBQVksSUFBSTtZQUFFLE9BQU8sS0FBSyxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBRXRELElBQUksS0FBSyxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRTtZQUN4QixLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxFQUFFO2dCQUNyQix3RUFBd0U7Z0JBQ3hFLElBQUksS0FBSyxZQUFZLElBQUk7b0JBQUUsS0FBSyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxXQUFXLEVBQUUsQ0FBQztZQUN4RCxDQUFDLENBQUMsQ0FBQztTQUNKO1FBRUQsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0NBQ0Y7QUF2QkQsNkJBdUJDIn0=

package/dist/utils/type-converter.d.ts

@@ -0,0 +1,11 @@
+import { AbstractDataType, AbstractDataTypeConstructor } from 'sequelize';
+import { ColumnType, Operator, PrimitiveTypes } from '@forestadmin/datasource-toolkit';
+export default class TypeConverter {
+    private static readonly columnTypeToDataType;
+    static fromColumnType(columnType: PrimitiveTypes): AbstractDataTypeConstructor;
+    private static getColumnTypeFromDataType;
+    static fromDataType(dataType: AbstractDataType): ColumnType;
+    private static readonly baseOperators;
+    static operatorsForColumnType(columnType: ColumnType): Set<Operator>;
+}
+//# sourceMappingURL=type-converter.d.ts.map

package/dist/utils/type-converter.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+class TypeConverter {
+    // TODO: Handle all ColumnTypes, not only PrimitiveTypes?
+    static fromColumnType(columnType) {
+        const dataType = TypeConverter.columnTypeToDataType[columnType];
+        if (!dataType)
+            throw new Error(`Unsupported column type: "${columnType}".`);
+        return dataType;
+    }
+    static getColumnTypeFromDataType(dataType) {
+        switch (dataType.key) {
+            case sequelize_1.DataTypes.BOOLEAN.key:
+                return 'Boolean';
+            case sequelize_1.DataTypes.DATE.key:
+            case sequelize_1.DataTypes.NOW.key:
+                return 'Date';
+            case sequelize_1.DataTypes.DATEONLY.key:
+                return 'Dateonly';
+            case sequelize_1.DataTypes.ENUM.key:
+                return 'Enum';
+            case sequelize_1.DataTypes.JSON.key:
+            case sequelize_1.DataTypes.JSONB.key:
+                return 'Json';
+            case sequelize_1.DataTypes.BIGINT.key:
+            case sequelize_1.DataTypes.DECIMAL.key:
+            case sequelize_1.DataTypes.DOUBLE.key:
+            case sequelize_1.DataTypes.FLOAT.key:
+            case sequelize_1.DataTypes.INTEGER.key:
+            case sequelize_1.DataTypes.MEDIUMINT.key:
+            case sequelize_1.DataTypes.NUMBER.key:
+            case sequelize_1.DataTypes.REAL.key:
+            case sequelize_1.DataTypes.SMALLINT.key:
+            case sequelize_1.DataTypes.TINYINT.key:
+                return 'Number';
+            case sequelize_1.DataTypes.CHAR.key:
+            case sequelize_1.DataTypes.CITEXT.key:
+            case sequelize_1.DataTypes.STRING.key:
+            case sequelize_1.DataTypes.TEXT.key:
+                return 'String';
+            case sequelize_1.DataTypes.TIME.key:
+                return 'Timeonly';
+            case sequelize_1.DataTypes.UUID.key:
+            case sequelize_1.DataTypes.UUIDV1.key:
+            case sequelize_1.DataTypes.UUIDV4.key:
+                return 'Uuid';
+            default:
+                throw new Error(`Unsupported data type: "${dataType}"`);
+        }
+    }
+    static fromDataType(dataType) {
+        if (dataType.key === sequelize_1.DataTypes.ARRAY.key) {
+            const arrayDataType = dataType;
+            return [TypeConverter.fromDataType(arrayDataType.type)];
+        }
+        return TypeConverter.getColumnTypeFromDataType(dataType);
+    }
+    static operatorsForColumnType(columnType) {
+        if (Array.isArray(columnType)) {
+            return new Set([...TypeConverter.baseOperators, 'In', 'IncludesAll', 'NotIn']);
+        }
+        switch (columnType) {
+            case 'Boolean':
+                return new Set([...TypeConverter.baseOperators]);
+            case 'Uuid':
+                return new Set([
+                    ...TypeConverter.baseOperators,
+                    'Contains',
+                    'EndsWith',
+                    'Like',
+                    'StartsWith',
+                ]);
+            case 'Number':
+                return new Set([
+                    ...TypeConverter.baseOperators,
+                    'GreaterThan',
+                    'In',
+                    'LessThan',
+                    'NotIn',
+                ]);
+            case 'String':
+                return new Set([
+                    ...TypeConverter.baseOperators,
+                    'In',
+                    'Like',
+                    'ILike',
+                    'LongerThan',
+                    'NotContains',
+                    'NotIn',
+                    'ShorterThan',
+                ]);
+            case 'Date':
+            case 'Dateonly':
+                return new Set([...TypeConverter.baseOperators, 'GreaterThan', 'LessThan']);
+            case 'Enum':
+                return new Set([...TypeConverter.baseOperators, 'In', 'NotIn']);
+            case 'Json':
+                return new Set([...TypeConverter.baseOperators]);
+            default:
+                return new Set();
+        }
+    }
+}
+exports.default = TypeConverter;
+// TODO: Allow to differentiate NUMBER and INTEGER.
+TypeConverter.columnTypeToDataType = {
+    Boolean: sequelize_1.DataTypes.BOOLEAN,
+    Date: sequelize_1.DataTypes.DATE,
+    Dateonly: sequelize_1.DataTypes.DATEONLY,
+    Enum: sequelize_1.DataTypes.ENUM,
+    Json: sequelize_1.DataTypes.JSON,
+    Number: sequelize_1.DataTypes.NUMBER,
+    Point: null,
+    String: sequelize_1.DataTypes.STRING,
+    Timeonly: sequelize_1.DataTypes.TIME,
+    Uuid: sequelize_1.DataTypes.UUID,
+};
+TypeConverter.baseOperators = [
+    'Blank',
+    'Equal',
+    'Missing',
+    'NotEqual',
+    'Present',
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZS1jb252ZXJ0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvdHlwZS1jb252ZXJ0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSx5Q0FBb0c7QUFJcEcsTUFBcUIsYUFBYTtJQWtCaEMseURBQXlEO0lBQ2xELE1BQU0sQ0FBQyxjQUFjLENBQUMsVUFBMEI7UUFDckQsTUFBTSxRQUFRLEdBQUcsYUFBYSxDQUFDLG9CQUFvQixDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBRWhFLElBQUksQ0FBQyxRQUFRO1lBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyw2QkFBNkIsVUFBVSxJQUFJLENBQUMsQ0FBQztRQUU1RSxPQUFPLFFBQVEsQ0FBQztJQUNsQixDQUFDO0lBRU8sTUFBTSxDQUFDLHlCQUF5QixDQUFDLFFBQTBCO1FBQ2pFLFFBQVEsUUFBUSxDQUFDLEdBQUcsRUFBRTtZQUNwQixLQUFLLHFCQUFTLENBQUMsT0FBTyxDQUFDLEdBQUc7Z0JBQ3hCLE9BQU8sU0FBUyxDQUFDO1lBQ25CLEtBQUsscUJBQVMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDO1lBQ3hCLEtBQUsscUJBQVMsQ0FBQyxHQUFHLENBQUMsR0FBRztnQkFDcEIsT0FBTyxNQUFNLENBQUM7WUFDaEIsS0FBSyxxQkFBUyxDQUFDLFFBQVEsQ0FBQyxHQUFHO2dCQUN6QixPQUFPLFVBQVUsQ0FBQztZQUNwQixLQUFLLHFCQUFTLENBQUMsSUFBSSxDQUFDLEdBQUc7Z0JBQ3JCLE9BQU8sTUFBTSxDQUFDO1lBQ2hCLEtBQUsscUJBQVMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDO1lBQ3hCLEtBQUsscUJBQVMsQ0FBQyxLQUFLLENBQUMsR0FBRztnQkFDdEIsT0FBTyxNQUFNLENBQUM7WUFDaEIsS0FBSyxxQkFBUyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUM7WUFDMUIsS0FBSyxxQkFBUyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUM7WUFDM0IsS0FBSyxxQkFBUyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUM7WUFDMUIsS0FBSyxxQkFBUyxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUM7WUFDekIsS0FBSyxxQkFBUyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUM7WUFDM0IsS0FBSyxxQkFBUyxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUM7WUFDN0IsS0FBSyxxQkFBUyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUM7WUFDMUIsS0FBSyxxQkFBUyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUM7WUFDeEIsS0FBSyxxQkFBUyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUM7WUFDNUIsS0FBSyxxQkFBUyxDQUFDLE9BQU8sQ0FBQyxHQUFHO2dCQUN4QixPQUFPLFFBQVEsQ0FBQztZQUNsQixLQUFLLHFCQUFTLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQztZQUN4QixLQUFLLHFCQUFTLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQztZQUMxQixLQUFLLHFCQUFTLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQztZQUMxQixLQUFLLHFCQUFTLENBQUMsSUFBSSxDQUFDLEdBQUc7Z0JBQ3JCLE9BQU8sUUFBUSxDQUFDO1lBQ2xCLEtBQUsscUJBQVMsQ0FBQyxJQUFJLENBQUMsR0FBRztnQkFDckIsT0FBTyxVQUFVLENBQUM7WUFDcEIsS0FBSyxxQkFBUyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUM7WUFDeEIsS0FBSyxxQkFBUyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUM7WUFDMUIsS0FBSyxxQkFBUyxDQUFDLE1BQU0sQ0FBQyxHQUFHO2dCQUN2QixPQUFPLE1BQU0sQ0FBQztZQUNoQjtnQkFDRSxNQUFNLElBQUksS0FBSyxDQUFDLDJCQUEyQixRQUFRLEdBQUcsQ0FBQyxDQUFDO1NBQzNEO0lBQ0gsQ0FBQztJQUVNLE1BQU0sQ0FBQyxZQUFZLENBQUMsUUFBMEI7UUFDbkQsSUFBSSxRQUFRLENBQUMsR0FBRyxLQUFLLHFCQUFTLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRTtZQUN4QyxNQUFNLGFBQWEsR0FBRyxRQUFzRCxDQUFDO1lBRTdFLE9BQU8sQ0FBQyxhQUFhLENBQUMsWUFBWSxDQUFDLGFBQWEsQ0FBQyxJQUFtQyxDQUFDLENBQUMsQ0FBQztTQUN4RjtRQUVELE9BQU8sYUFBYSxDQUFDLHlCQUF5QixDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQzNELENBQUM7SUFVTSxNQUFNLENBQUMsc0JBQXNCLENBQUMsVUFBc0I7UUFDekQsSUFBSSxLQUFLLENBQUMsT0FBTyxDQUFDLFVBQVUsQ0FBQyxFQUFFO1lBQzdCLE9BQU8sSUFBSSxHQUFHLENBQVcsQ0FBQyxHQUFHLGFBQWEsQ0FBQyxhQUFhLEVBQUUsSUFBSSxFQUFFLGFBQWEsRUFBRSxPQUFPLENBQUMsQ0FBQyxDQUFDO1NBQzFGO1FBRUQsUUFBUSxVQUFVLEVBQUU7WUFDbEIsS0FBSyxTQUFTO2dCQUNaLE9BQU8sSUFBSSxHQUFHLENBQVcsQ0FBQyxHQUFHLGFBQWEsQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDO1lBQzdELEtBQUssTUFBTTtnQkFDVCxPQUFPLElBQUksR0FBRyxDQUFXO29CQUN2QixHQUFHLGFBQWEsQ0FBQyxhQUFhO29CQUM5QixVQUFVO29CQUNWLFVBQVU7b0JBQ1YsTUFBTTtvQkFDTixZQUFZO2lCQUNiLENBQUMsQ0FBQztZQUNMLEtBQUssUUFBUTtnQkFDWCxPQUFPLElBQUksR0FBRyxDQUFXO29CQUN2QixHQUFHLGFBQWEsQ0FBQyxhQUFhO29CQUM5QixhQUFhO29CQUNiLElBQUk7b0JBQ0osVUFBVTtvQkFDVixPQUFPO2lCQUNSLENBQUMsQ0FBQztZQUNMLEtBQUssUUFBUTtnQkFDWCxPQUFPLElBQUksR0FBRyxDQUFXO29CQUN2QixHQUFHLGFBQWEsQ0FBQyxhQUFhO29CQUM5QixJQUFJO29CQUNKLE1BQU07b0JBQ04sT0FBTztvQkFDUCxZQUFZO29CQUNaLGFBQWE7b0JBQ2IsT0FBTztvQkFDUCxhQUFhO2lCQUNkLENBQUMsQ0FBQztZQUNMLEtBQUssTUFBTSxDQUFDO1lBQ1osS0FBSyxVQUFVO2dCQUNiLE9BQU8sSUFBSSxHQUFHLENBQVcsQ0FBQyxHQUFHLGFBQWEsQ0FBQyxhQUFhLEVBQUUsYUFBYSxFQUFFLFVBQVUsQ0FBQyxDQUFDLENBQUM7WUFDeEYsS0FBSyxNQUFNO2dCQUNULE9BQU8sSUFBSSxHQUFHLENBQVcsQ0FBQyxHQUFHLGFBQWEsQ0FBQyxhQUFhLEVBQUUsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUM7WUFDNUUsS0FBSyxNQUFNO2dCQUNULE9BQU8sSUFBSSxHQUFHLENBQVcsQ0FBQyxHQUFHLGFBQWEsQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDO1lBQzdEO2dCQUNFLE9BQU8sSUFBSSxHQUFHLEVBQVksQ0FBQztTQUM5QjtJQUNILENBQUM7O0FBbklILGdDQW9JQztBQW5JQyxtREFBbUQ7QUFDM0Isa0NBQW9CLEdBR3hDO0lBQ0YsT0FBTyxFQUFFLHFCQUFTLENBQUMsT0FBTztJQUMxQixJQUFJLEVBQUUscUJBQVMsQ0FBQyxJQUFJO0lBQ3BCLFFBQVEsRUFBRSxxQkFBUyxDQUFDLFFBQVE7SUFDNUIsSUFBSSxFQUFFLHFCQUFTLENBQUMsSUFBSTtJQUNwQixJQUFJLEVBQUUscUJBQVMsQ0FBQyxJQUFJO0lBQ3BCLE1BQU0sRUFBRSxxQkFBUyxDQUFDLE1BQU07SUFDeEIsS0FBSyxFQUFFLElBQUk7SUFDWCxNQUFNLEVBQUUscUJBQVMsQ0FBQyxNQUFNO0lBQ3hCLFFBQVEsRUFBRSxxQkFBUyxDQUFDLElBQUk7SUFDeEIsSUFBSSxFQUFFLHFCQUFTLENBQUMsSUFBSTtDQUNyQixDQUFDO0FBOERzQiwyQkFBYSxHQUFlO0lBQ2xELE9BQU87SUFDUCxPQUFPO0lBQ1AsU0FBUztJQUNULFVBQVU7SUFDVixTQUFTO0NBQ1YsQ0FBQyJ9

package/dist/utils/un-ambigous.d.ts

@@ -0,0 +1,3 @@
+import { ModelDefined } from 'sequelize/types';
+export default function unAmbigousField(model: ModelDefined<any, any>, field: string, unAmbigous?: boolean): string;
+//# sourceMappingURL=un-ambigous.d.ts.map

package/dist/utils/un-ambigous.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function unAmbigousField(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+model, field, unAmbigous = false) {
+    const isRelation = field.includes(':');
+    let safeField;
+    if (isRelation) {
+        const paths = field.split(':');
+        const relationFieldName = paths.pop();
+        const fieldName = paths
+            .reduce((acc, path) => acc.associations[path].target, model)
+            .getAttributes()[relationFieldName].field;
+        safeField = `${paths.join('.')}.${fieldName}`;
+    }
+    else {
+        safeField = model.getAttributes()[field].field;
+        if (unAmbigous)
+            safeField = `${model.name}.${safeField}`;
+    }
+    return safeField;
+}
+exports.default = unAmbigousField;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW4tYW1iaWdvdXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvdW4tYW1iaWdvdXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFQSxTQUF3QixlQUFlO0FBQ3JDLDhEQUE4RDtBQUM5RCxLQUE2QixFQUM3QixLQUFhLEVBQ2IsVUFBVSxHQUFHLEtBQUs7SUFFbEIsTUFBTSxVQUFVLEdBQUcsS0FBSyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUV2QyxJQUFJLFNBQWlCLENBQUM7SUFFdEIsSUFBSSxVQUFVLEVBQUU7UUFDZCxNQUFNLEtBQUssR0FBRyxLQUFLLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQy9CLE1BQU0saUJBQWlCLEdBQUcsS0FBSyxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBQ3RDLE1BQU0sU0FBUyxHQUFHLEtBQUs7YUFDcEIsTUFBTSxDQUFDLENBQUMsR0FBRyxFQUFFLElBQUksRUFBRSxFQUFFLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsQ0FBQyxNQUFNLEVBQUUsS0FBSyxDQUFDO2FBQzNELGFBQWEsRUFBRSxDQUFDLGlCQUFpQixDQUFDLENBQUMsS0FBSyxDQUFDO1FBQzVDLFNBQVMsR0FBRyxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksU0FBUyxFQUFFLENBQUM7S0FDL0M7U0FBTTtRQUNMLFNBQVMsR0FBRyxLQUFLLENBQUMsYUFBYSxFQUFFLENBQUMsS0FBSyxDQUFDLENBQUMsS0FBSyxDQUFDO1FBQy9DLElBQUksVUFBVTtZQUFFLFNBQVMsR0FBRyxHQUFHLEtBQUssQ0FBQyxJQUFJLElBQUksU0FBUyxFQUFFLENBQUM7S0FDMUQ7SUFFRCxPQUFPLFNBQVMsQ0FBQztBQUNuQixDQUFDO0FBdkJELGtDQXVCQyJ9

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@forestadmin/datasource-sequelize",
+  "version": "1.0.0-alpha.1",
+  "main": "dist/index.js",
+  "license": "GPL-3.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ForestAdmin/agent-nodejs.git",
+    "directory": "packages/datasource-sequelize"
+  },
+  "dependencies": {
+    "@forestadmin/datasource-toolkit": "1.0.0-alpha.1"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "clean": "rm -rf coverage dist",
+    "lint": "eslint src test",
+    "test": "jest"
+  },
+  "devDependencies": {
+    "fishery": "^2.1.0",
+    "sequelize": "6.21.3"
+  },
+  "peerDependencies": {
+    "sequelize": ">= 6.12.0 < 7"
+  }
+}