@forestadmin/datasource-sequelize 1.0.0-beta.1

package/dist/collection.d.ts

@@ -0,0 +1,13 @@
+import { ModelDefined } from 'sequelize';
+import { AggregateResult, Aggregation, BaseCollection, DataSource, Filter, PaginatedFilter, Projection, RecordData } from '@forestadmin/datasource-toolkit';
+export default class SequelizeCollection extends BaseCollection {
+    protected model: ModelDefined<any, any>;
+    private aggregationUtils;
+    constructor(name: string, datasource: DataSource, model: ModelDefined<any, any>);
+    create(data: RecordData[]): Promise<RecordData[]>;
+    list(filter: PaginatedFilter, projection: Projection): Promise<RecordData[]>;
+    update(filter: Filter, patch: RecordData): Promise<void>;
+    delete(filter: Filter): Promise<void>;
+    aggregate(filter: Filter, aggregation: Aggregation, limit?: number): Promise<AggregateResult[]>;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/collection.js

@@ -0,0 +1,89 @@
+"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_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const aggregation_1 = __importDefault(require("./utils/aggregation"));
+const model_to_collection_schema_converter_1 = __importDefault(require("./utils/model-to-collection-schema-converter"));
+const query_converter_1 = __importDefault(require("./utils/query-converter"));
+class SequelizeCollection extends datasource_toolkit_1.BaseCollection {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(name, datasource, model) {
+        super(name, datasource);
+        if (!model)
+            throw new Error('Invalid (null) model instance.');
+        this.model = model;
+        this.aggregationUtils = new aggregation_1.default(this.model);
+        const modelSchema = model_to_collection_schema_converter_1.default.convert(this.model);
+        this.addFields(modelSchema.fields);
+        this.addSegments(modelSchema.segments);
+    }
+    async create(data) {
+        const records = await this.model.bulkCreate(data);
+        return records.map(record => record.get({ plain: true }));
+    }
+    async list(filter, projection) {
+        let include = query_converter_1.default.getIncludeWithAttributesFromProjection(projection);
+        if (filter.conditionTree) {
+            include = include.concat(query_converter_1.default.getIncludeFromProjection(filter.conditionTree.projection));
+        }
+        const query = {
+            attributes: projection.columns,
+            where: query_converter_1.default.getWhereFromConditionTree(this.model, filter.conditionTree),
+            include,
+            limit: filter.page?.limit,
+            offset: filter.page?.skip,
+            order: query_converter_1.default.getOrderFromSort(filter.sort),
+            subQuery: false,
+        };
+        const records = await this.model.findAll(query);
+        return records.map(record => record.get({ plain: true }));
+    }
+    async update(filter, patch) {
+        await this.model.update(patch, {
+            where: query_converter_1.default.getWhereFromConditionTree(this.model, filter.conditionTree),
+            fields: Object.keys(patch),
+        });
+    }
+    async delete(filter) {
+        await this.model.destroy({
+            where: query_converter_1.default.getWhereFromConditionTree(this.model, filter.conditionTree),
+        });
+    }
+    async aggregate(filter, aggregation, limit) {
+        let aggregationField = aggregation.field;
+        if (aggregation.operation === 'Count' || !aggregationField) {
+            aggregationField = '*';
+        }
+        else {
+            aggregationField = this.aggregationUtils.unAmbigousField(aggregationField);
+        }
+        const aggregationFunction = (0, sequelize_1.fn)(aggregation.operation.toUpperCase(), (0, sequelize_1.col)(aggregationField));
+        const aggregationAttribute = [
+            aggregationFunction,
+            this.aggregationUtils.aggregateFieldName,
+        ];
+        const { groups, attributes: groupAttributes } = this.aggregationUtils.getGroupAndAttributesFromAggregation(aggregation.groups);
+        let include = query_converter_1.default.getIncludeFromProjection(aggregation.projection);
+        if (filter.conditionTree) {
+            include = include.concat(query_converter_1.default.getIncludeFromProjection(filter.conditionTree.projection));
+        }
+        const order = this.aggregationUtils.getOrder(aggregationFunction);
+        const query = {
+            attributes: [...groupAttributes, aggregationAttribute],
+            group: groups,
+            where: query_converter_1.default.getWhereFromConditionTree(this.model, filter.conditionTree),
+            include,
+            limit,
+            order: [order],
+            subQuery: false,
+            raw: true,
+        };
+        const rows = await this.model.findAll(query);
+        return this.aggregationUtils.computeResult(rows, aggregation.groups);
+    }
+}
+exports.default = SequelizeCollection;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/datasource.d.ts

@@ -0,0 +1,9 @@
+import { Sequelize } from 'sequelize';
+import { BaseDataSource } from '@forestadmin/datasource-toolkit';
+import SequelizeCollection from './collection';
+export default class SequelizeDataSource extends BaseDataSource<SequelizeCollection> {
+    protected sequelize: Sequelize;
+    constructor(sequelize: Sequelize);
+    protected createCollections(models: Sequelize['models']): void;
+}
+//# sourceMappingURL=datasource.d.ts.map

package/dist/datasource.js

@@ -0,0 +1,28 @@
+"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 collection_1 = __importDefault(require("./collection"));
+class SequelizeDataSource extends datasource_toolkit_1.BaseDataSource {
+    constructor(sequelize) {
+        super();
+        this.sequelize = null;
+        if (!sequelize)
+            throw new Error('Invalid (null) Sequelize instance.');
+        this.sequelize = sequelize;
+        this.createCollections(this.sequelize.models);
+    }
+    createCollections(models) {
+        Object.values(models)
+            // avoid schema reordering
+            .sort((modelA, modelB) => (modelA.name > modelB.name ? 1 : -1))
+            .forEach(model => {
+            const collection = new collection_1.default(model.name, this, model);
+            this.addCollection(collection);
+        });
+    }
+}
+exports.default = SequelizeDataSource;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9kYXRhc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBRUEsd0VBQWlFO0FBRWpFLDhEQUErQztBQUUvQyxNQUFxQixtQkFBb0IsU0FBUSxtQ0FBbUM7SUFHbEYsWUFBWSxTQUFvQjtRQUM5QixLQUFLLEVBQUUsQ0FBQztRQUhBLGNBQVMsR0FBYyxJQUFJLENBQUM7UUFLcEMsSUFBSSxDQUFDLFNBQVM7WUFBRSxNQUFNLElBQUksS0FBSyxDQUFDLG9DQUFvQyxDQUFDLENBQUM7UUFFdEUsSUFBSSxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUM7UUFFM0IsSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDaEQsQ0FBQztJQUVTLGlCQUFpQixDQUFDLE1BQTJCO1FBQ3JELE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDO1lBQ25CLDBCQUEwQjthQUN6QixJQUFJLENBQUMsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLEVBQUUsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxJQUFJLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO2FBQzlELE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRTtZQUNmLE1BQU0sVUFBVSxHQUFHLElBQUksb0JBQW1CLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxJQUFJLEVBQUUsS0FBSyxDQUFDLENBQUM7WUFDcEUsSUFBSSxDQUFDLGFBQWEsQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUNqQyxDQUFDLENBQUMsQ0FBQztJQUNQLENBQUM7Q0FDRjtBQXRCRCxzQ0FzQkMifQ==

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { default as SequelizeCollection } from './collection';
+export { default as SequelizeDataSource } from './datasource';
+export { default as TypeConverter } from './utils/type-converter';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeConverter = exports.SequelizeDataSource = exports.SequelizeCollection = void 0;
+var collection_1 = require("./collection");
+Object.defineProperty(exports, "SequelizeCollection", { enumerable: true, get: function () { return __importDefault(collection_1).default; } });
+var datasource_1 = require("./datasource");
+Object.defineProperty(exports, "SequelizeDataSource", { enumerable: true, get: function () { return __importDefault(datasource_1).default; } });
+var type_converter_1 = require("./utils/type-converter");
+Object.defineProperty(exports, "TypeConverter", { enumerable: true, get: function () { return __importDefault(type_converter_1).default; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEsMkNBQThEO0FBQXJELGtJQUFBLE9BQU8sT0FBdUI7QUFDdkMsMkNBQThEO0FBQXJELGtJQUFBLE9BQU8sT0FBdUI7QUFDdkMseURBQWtFO0FBQXpELGdJQUFBLE9BQU8sT0FBaUIifQ==

package/dist/utils/aggregation.d.ts

@@ -0,0 +1,18 @@
+import { GroupOption, Model, ModelDefined, ProjectionAlias } from 'sequelize';
+import { Fn } from 'sequelize/types/utils';
+import { AggregateResult, AggregationGroup } from '@forestadmin/datasource-toolkit';
+export default class AggregationUtils {
+    private model;
+    private dialect;
+    readonly aggregateFieldName = "__aggregate__";
+    constructor(model: ModelDefined<any, any>);
+    getGroupFieldName(groupField: string): string;
+    unAmbigousField(field: string): string;
+    getGroupAndAttributesFromAggregation(aggregationQueryGroup: AggregationGroup[]): {
+        groups: GroupOption;
+        attributes: ProjectionAlias[];
+    };
+    getOrder(aggregationFunction: Fn): [string | Fn | import("sequelize/types/utils").Col | import("sequelize/types/utils").Literal, string];
+    computeResult(rows: Model<any, any>[], aggregationQueryGroup: AggregationGroup[]): AggregateResult[];
+}
+//# sourceMappingURL=aggregation.d.ts.map

package/dist/utils/aggregation.js

@@ -0,0 +1,92 @@
+"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_toolkit_1 = require("@forestadmin/datasource-toolkit");
+const date_aggregation_converter_1 = __importDefault(require("./date-aggregation-converter"));
+class AggregationUtils {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(model) {
+        this.aggregateFieldName = '__aggregate__';
+        this.model = model;
+        this.dialect = this.model.sequelize.getDialect();
+    }
+    getGroupFieldName(groupField) {
+        return `${groupField}__grouped__`;
+    }
+    unAmbigousField(field) {
+        let tableName;
+        let fieldName;
+        if (field.includes(':')) {
+            const [associationName, nestedField] = field.split(':');
+            const association = this.model.associations[associationName];
+            if (!association) {
+                throw new datasource_toolkit_1.ValidationError(`${this.model.name} model does not have association "${associationName}".`);
+            }
+            const associationField = association.target.getAttributes()[nestedField];
+            if (!associationField) {
+                throw new datasource_toolkit_1.ValidationError(`${associationName} model does not have field "${nestedField}".`);
+            }
+            tableName = associationName;
+            fieldName = associationField.field;
+        }
+        else {
+            const modelField = this.model.getAttributes()[field];
+            if (!modelField) {
+                throw new datasource_toolkit_1.ValidationError(`${this.model.name} model does not have field "${field}".`);
+            }
+            tableName = this.model.name;
+            fieldName = modelField.field;
+        }
+        return this.model.sequelize.getQueryInterface().quoteIdentifiers(`${tableName}.${fieldName}`);
+    }
+    getGroupAndAttributesFromAggregation(aggregationQueryGroup) {
+        const attributes = [];
+        const groups = aggregationQueryGroup?.map(group => {
+            const { field } = group;
+            const groupFieldName = this.getGroupFieldName(field);
+            const groupField = this.unAmbigousField(field);
+            if (group.operation) {
+                const groupFunction = date_aggregation_converter_1.default.convertToDialect(this.dialect, groupField, group.operation);
+                attributes.push([groupFunction, groupFieldName]);
+                return this.dialect === 'mssql' ? groupFunction : groupFieldName;
+            }
+            attributes.push([(0, sequelize_1.col)(groupField), groupFieldName]);
+            return this.dialect === 'mssql' ? groupField : groupFieldName;
+        });
+        return { groups, attributes };
+    }
+    getOrder(aggregationFunction) {
+        let order;
+        // FIXME handle properly order
+        switch (this.dialect) {
+            case 'postgres':
+                order = [(0, sequelize_1.col)(this.aggregateFieldName), 'DESC NULLS LAST'];
+                break;
+            case 'mssql':
+                order = [aggregationFunction, 'DESC'];
+                break;
+            default:
+                order = [(0, sequelize_1.col)(this.aggregateFieldName), 'DESC'];
+        }
+        return order;
+    }
+    computeResult(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    rows, aggregationQueryGroup) {
+        return rows.map(aggregate => {
+            const aggregateResult = {
+                value: aggregate[this.aggregateFieldName],
+                group: {},
+            };
+            aggregationQueryGroup?.forEach(({ field }) => {
+                aggregateResult.group[field] = aggregate[this.getGroupFieldName(field)];
+            });
+            return aggregateResult;
+        });
+    }
+}
+exports.default = AggregationUtils;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdncmVnYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvYWdncmVnYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSx5Q0FRbUI7QUFHbkIsd0VBSXlDO0FBRXpDLDhGQUFvRTtBQUVwRSxNQUFxQixnQkFBZ0I7SUFPbkMsOERBQThEO0lBQzlELFlBQVksS0FBNkI7UUFIaEMsdUJBQWtCLEdBQUcsZUFBZSxDQUFDO1FBSTVDLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ25CLElBQUksQ0FBQyxPQUFPLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsVUFBVSxFQUFhLENBQUM7SUFDOUQsQ0FBQztJQUVELGlCQUFpQixDQUFDLFVBQWtCO1FBQ2xDLE9BQU8sR0FBRyxVQUFVLGFBQWEsQ0FBQztJQUNwQyxDQUFDO0lBRUQsZUFBZSxDQUFDLEtBQWE7UUFDM0IsSUFBSSxTQUFpQixDQUFDO1FBQ3RCLElBQUksU0FBaUIsQ0FBQztRQUV0QixJQUFJLEtBQUssQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEVBQUU7WUFDdkIsTUFBTSxDQUFDLGVBQWUsRUFBRSxXQUFXLENBQUMsR0FBRyxLQUFLLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ3hELE1BQU0sV0FBVyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsWUFBWSxDQUFDLGVBQWUsQ0FBQyxDQUFDO1lBRTdELElBQUksQ0FBQyxXQUFXLEVBQUU7Z0JBQ2hCLE1BQU0sSUFBSSxvQ0FBZSxDQUN2QixHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxxQ0FBcUMsZUFBZSxJQUFJLENBQzNFLENBQUM7YUFDSDtZQUVELE1BQU0sZ0JBQWdCLEdBQUcsV0FBVyxDQUFDLE1BQU0sQ0FBQyxhQUFhLEVBQUUsQ0FBQyxXQUFXLENBQUMsQ0FBQztZQUV6RSxJQUFJLENBQUMsZ0JBQWdCLEVBQUU7Z0JBQ3JCLE1BQU0sSUFBSSxvQ0FBZSxDQUFDLEdBQUcsZUFBZSwrQkFBK0IsV0FBVyxJQUFJLENBQUMsQ0FBQzthQUM3RjtZQUVELFNBQVMsR0FBRyxlQUFlLENBQUM7WUFDNUIsU0FBUyxHQUFHLGdCQUFnQixDQUFDLEtBQUssQ0FBQztTQUNwQzthQUFNO1lBQ0wsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxhQUFhLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUVyRCxJQUFJLENBQUMsVUFBVSxFQUFFO2dCQUNmLE1BQU0sSUFBSSxvQ0FBZSxDQUFDLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLCtCQUErQixLQUFLLElBQUksQ0FBQyxDQUFDO2FBQ3ZGO1lBRUQsU0FBUyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDO1lBQzVCLFNBQVMsR0FBRyxVQUFVLENBQUMsS0FBSyxDQUFDO1NBQzlCO1FBRUQsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxpQkFBaUIsRUFBRSxDQUFDLGdCQUFnQixDQUFDLEdBQUcsU0FBUyxJQUFJLFNBQVMsRUFBRSxDQUFDLENBQUM7SUFDaEcsQ0FBQztJQUVELG9DQUFvQyxDQUFDLHFCQUF5QztRQUk1RSxNQUFNLFVBQVUsR0FBRyxFQUFFLENBQUM7UUFDdEIsTUFBTSxNQUFNLEdBQUcscUJBQXFCLEVBQUUsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFO1lBQ2hELE1BQU0sRUFBRSxLQUFLLEVBQUUsR0FBRyxLQUFLLENBQUM7WUFDeEIsTUFBTSxjQUFjLEdBQUcsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQ3JELE1BQU0sVUFBVSxHQUFHLElBQUksQ0FBQyxlQUFlLENBQUMsS0FBSyxDQUFDLENBQUM7WUFFL0MsSUFBSSxLQUFLLENBQUMsU0FBUyxFQUFFO2dCQUNuQixNQUFNLGFBQWEsR0FBRyxvQ0FBd0IsQ0FBQyxnQkFBZ0IsQ0FDN0QsSUFBSSxDQUFDLE9BQU8sRUFDWixVQUFVLEVBQ1YsS0FBSyxDQUFDLFNBQVMsQ0FDaEIsQ0FBQztnQkFFRixVQUFVLENBQUMsSUFBSSxDQUFDLENBQUMsYUFBYSxFQUFFLGNBQWMsQ0FBQyxDQUFDLENBQUM7Z0JBRWpELE9BQU8sSUFBSSxDQUFDLE9BQU8sS0FBSyxPQUFPLENBQUMsQ0FBQyxDQUFDLGFBQWEsQ0FBQyxDQUFDLENBQUMsY0FBYyxDQUFDO2FBQ2xFO1lBRUQsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDLElBQUEsZUFBRyxFQUFDLFVBQVUsQ0FBQyxFQUFFLGNBQWMsQ0FBQyxDQUFDLENBQUM7WUFFbkQsT0FBTyxJQUFJLENBQUMsT0FBTyxLQUFLLE9BQU8sQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxjQUFjLENBQUM7UUFDaEUsQ0FBQyxDQUFDLENBQUM7UUFFSCxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxDQUFDO0lBQ2hDLENBQUM7SUFFRCxRQUFRLENBQUMsbUJBQXVCO1FBQzlCLElBQUksS0FBZ0IsQ0FBQztRQUVyQiw4QkFBOEI7UUFDOUIsUUFBUSxJQUFJLENBQUMsT0FBTyxFQUFFO1lBQ3BCLEtBQUssVUFBVTtnQkFDYixLQUFLLEdBQUcsQ0FBQyxJQUFBLGVBQUcsRUFBQyxJQUFJLENBQUMsa0JBQWtCLENBQUMsRUFBRSxpQkFBaUIsQ0FBQyxDQUFDO2dCQUMxRCxNQUFNO1lBQ1IsS0FBSyxPQUFPO2dCQUNWLEtBQUssR0FBRyxDQUFDLG1CQUFtQixFQUFFLE1BQU0sQ0FBQyxDQUFDO2dCQUN0QyxNQUFNO1lBQ1I7Z0JBQ0UsS0FBSyxHQUFHLENBQUMsSUFBQSxlQUFHLEVBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLEVBQUUsTUFBTSxDQUFDLENBQUM7U0FDbEQ7UUFFRCxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7SUFFRCxhQUFhO0lBQ1gsOERBQThEO0lBQzlELElBQXVCLEVBQ3ZCLHFCQUF5QztRQUV6QyxPQUFPLElBQUksQ0FBQyxHQUFHLENBQUMsU0FBUyxDQUFDLEVBQUU7WUFDMUIsTUFBTSxlQUFlLEdBQUc7Z0JBQ3RCLEtBQUssRUFBRSxTQUFTLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFXO2dCQUNuRCxLQUFLLEVBQUUsRUFBRTthQUNWLENBQUM7WUFFRixxQkFBcUIsRUFBRSxPQUFPLENBQUMsQ0FBQyxFQUFFLEtBQUssRUFBRSxFQUFFLEVBQUU7Z0JBQzNDLGVBQWUsQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLEdBQUcsU0FBUyxDQUFDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO1lBQzFFLENBQUMsQ0FBQyxDQUFDO1lBRUgsT0FBTyxlQUFlLENBQUM7UUFDekIsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0NBQ0Y7QUF2SEQsbUNBdUhDIn0=

package/dist/utils/date-aggregation-converter.d.ts

@@ -0,0 +1,11 @@
+import { Fn } from 'sequelize/types/utils';
+import { Dialect } from 'sequelize';
+import { DateOperation } from '@forestadmin/datasource-toolkit';
+export default class DateAggregationConverter {
+    private static convertPostgres;
+    private static convertMssql;
+    private static convertMysql;
+    private static convertSqlite;
+    static convertToDialect(dialect: Dialect, field: string, operation: DateOperation): Fn;
+}
+//# sourceMappingURL=date-aggregation-converter.d.ts.map

package/dist/utils/date-aggregation-converter.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+class DateAggregationConverter {
+    static convertPostgres(field, operation) {
+        const aggregateFunction = (0, sequelize_1.fn)('DATE_TRUNC', operation.toLocaleLowerCase(), (0, sequelize_1.col)(field));
+        return (0, sequelize_1.fn)('TO_CHAR', aggregateFunction, 'YYYY-MM-DD');
+    }
+    static convertMssql(field, operation) {
+        let dateToConvert;
+        switch (operation) {
+            case 'Year':
+                dateToConvert = (0, sequelize_1.fn)('DATEFROMPARTS', (0, sequelize_1.fn)('DATEPART', (0, sequelize_1.literal)('YEAR'), (0, sequelize_1.col)(field)), '01', '01');
+                break;
+            case 'Month':
+                dateToConvert = (0, sequelize_1.fn)('DATEFROMPARTS', (0, sequelize_1.fn)('DATEPART', (0, sequelize_1.literal)('YEAR'), (0, sequelize_1.col)(field)), (0, sequelize_1.fn)('DATEPART', (0, sequelize_1.literal)('MONTH'), (0, sequelize_1.col)(field)), '01');
+                break;
+            case 'Week':
+                dateToConvert = (0, sequelize_1.fn)('DATEADD', (0, sequelize_1.literal)('DAY'), (0, sequelize_1.literal)(`-DATEPART(dw, ${field})+2`), (0, sequelize_1.col)(field));
+                break;
+            case 'Day':
+                dateToConvert = (0, sequelize_1.col)(field);
+                break;
+            default:
+                throw new Error(`Unknown Date operation: "${operation}"`);
+        }
+        // eslint-disable-next-line max-len
+        // https://docs.microsoft.com/en-us/sql/t-sql/functions/cast-and-convert-transact-sql?redirectedfrom=MSDN&view=sql-server-ver15
+        return (0, sequelize_1.fn)('CONVERT', (0, sequelize_1.literal)('varchar(10)'), dateToConvert, 23);
+    }
+    static convertMysql(field, operation) {
+        let format = '%Y-%m-%d';
+        let dateToConvert = (0, sequelize_1.col)(field);
+        switch (operation) {
+            case 'Year':
+                format = '%Y-01-01';
+                break;
+            case 'Month':
+                format = '%Y-%m-01';
+                break;
+            case 'Week':
+                dateToConvert = (0, sequelize_1.fn)('DATE_SUB', (0, sequelize_1.col)(field), (0, sequelize_1.literal)(`INTERVAL(WEEKDAY(${field})) DAY`));
+                break;
+            case 'Day':
+                break;
+            default:
+                throw new Error(`Unknown Date operation: "${operation}"`);
+        }
+        return (0, sequelize_1.fn)('DATE_FORMAT', dateToConvert, format);
+    }
+    static convertSqlite(field, operation) {
+        if (operation === 'Week') {
+            return (0, sequelize_1.fn)('DATE', (0, sequelize_1.col)(field), 'weekday 0');
+        }
+        let format;
+        switch (operation) {
+            case 'Year':
+                format = '%Y-01-01';
+                break;
+            case 'Month':
+                format = '%Y-%m-01';
+                break;
+            case 'Day':
+                format = '%Y-%m-%d';
+                break;
+            default:
+                throw new Error(`Unknown Date operation: "${operation}"`);
+        }
+        return (0, sequelize_1.fn)('STRFTIME', format, (0, sequelize_1.col)(field));
+    }
+    static convertToDialect(dialect, field, operation) {
+        switch (dialect) {
+            case 'postgres':
+                return this.convertPostgres(field, operation);
+            case 'mssql':
+                return this.convertMssql(field, operation);
+            case 'mariadb':
+            case 'mysql':
+                return this.convertMysql(field, operation);
+            case 'sqlite':
+                return this.convertSqlite(field, operation);
+            default:
+                throw new Error(`Unsupported dialect: "${dialect}"`);
+        }
+    }
+}
+exports.default = DateAggregationConverter;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/model-to-collection-schema-converter.d.ts

@@ -0,0 +1,10 @@
+import { ModelDefined } from 'sequelize';
+import { CollectionSchema } from '@forestadmin/datasource-toolkit';
+export default class ModelToCollectionSchemaConverter {
+    private static convertAssociation;
+    private static convertAssociations;
+    private static convertAttribute;
+    private static convertAttributes;
+    static convert(model: ModelDefined<any, any>): CollectionSchema;
+}
+//# sourceMappingURL=model-to-collection-schema-converter.d.ts.map

package/dist/utils/model-to-collection-schema-converter.js

@@ -0,0 +1,110 @@
+"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 type_converter_1 = __importDefault(require("./type-converter"));
+class ModelToCollectionSchemaConverter {
+    static convertAssociation(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    association) {
+        switch (association.associationType) {
+            case sequelize_1.BelongsTo.name:
+                return {
+                    foreignCollection: association.target.name,
+                    foreignKey: association.foreignKey,
+                    foreignKeyTarget: association.targetKey,
+                    type: 'ManyToOne',
+                };
+            case sequelize_1.BelongsToMany.name:
+                return {
+                    foreignCollection: association.target.name,
+                    throughCollection: association.through.model.name,
+                    originKey: association.foreignKey,
+                    originKeyTarget: association.targetKey,
+                    foreignKey: association.otherKey,
+                    foreignKeyTarget: association.sourceKey,
+                    type: 'ManyToMany',
+                };
+            case sequelize_1.HasMany.name:
+                return {
+                    foreignCollection: association.target.name,
+                    originKey: association.foreignKey,
+                    originKeyTarget: association.sourceKey,
+                    type: 'OneToMany',
+                };
+            case sequelize_1.HasOne.name:
+                return {
+                    foreignCollection: association.target.name,
+                    originKey: association.foreignKey,
+                    originKeyTarget: association.sourceKey,
+                    type: 'OneToOne',
+                };
+            default:
+                throw new Error(`Unsupported association: "${association.associationType}".`);
+        }
+    }
+    static convertAssociations(associations) {
+        const schemaAssociations = {};
+        if (associations) {
+            Object.entries(associations).forEach(([key, association]) => {
+                schemaAssociations[key] = this.convertAssociation(association);
+            });
+        }
+        return schemaAssociations;
+    }
+    static convertAttribute(attribute) {
+        const sequelizeColumnType = attribute.type;
+        const columnType = type_converter_1.default.fromDataType(sequelizeColumnType);
+        const filterOperators = type_converter_1.default.operatorsForDataType(sequelizeColumnType);
+        const column = {
+            columnType,
+            filterOperators,
+            type: 'Column',
+            validation: [],
+            isReadOnly: attribute.autoIncrement,
+        };
+        if (attribute.allowNull === false &&
+            !column.isReadOnly &&
+            !attribute.defaultValue &&
+            // eslint-disable-next-line no-underscore-dangle
+            !attribute._autoGenerated) {
+            column.validation.push({ operator: 'Present' });
+        }
+        if (attribute.primaryKey)
+            column.isPrimaryKey = true;
+        if (attribute.defaultValue !== null &&
+            attribute.defaultValue !== undefined &&
+            (columnType === 'Json' || typeof attribute.defaultValue !== 'object')) {
+            column.defaultValue = attribute.defaultValue;
+        }
+        if (attribute.values) {
+            column.enumValues = [...attribute.values];
+        }
+        return column;
+    }
+    static convertAttributes(attributes) {
+        const fields = {};
+        Object.entries(attributes).forEach(([name, attribute]) => {
+            fields[name] = this.convertAttribute(attribute);
+        });
+        return fields;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static convert(model) {
+        if (!model)
+            throw new Error('Invalid (null) model.');
+        return {
+            actions: {},
+            fields: {
+                ...this.convertAttributes(model.getAttributes()),
+                ...this.convertAssociations(model.associations),
+            },
+            searchable: false,
+            segments: [],
+        };
+    }
+}
+exports.default = ModelToCollectionSchemaConverter;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,12 @@
+import { ConditionTree, Projection, Sort } from '@forestadmin/datasource-toolkit';
+import { IncludeOptions, ModelDefined, OrderItem, WhereOptions } from 'sequelize';
+export default class QueryConverter {
+    private static asArray;
+    private static makeWhereClause;
+    static getWhereFromConditionTree(model: ModelDefined<any, any>, conditionTree?: ConditionTree): WhereOptions;
+    private static computeIncludeFromProjection;
+    static getIncludeFromProjection(projection: Projection): IncludeOptions[];
+    static getIncludeWithAttributesFromProjection(projection: Projection): IncludeOptions[];
+    static getOrderFromSort(sort: Sort): OrderItem[];
+}
+//# sourceMappingURL=query-converter.d.ts.map