@forestadmin/datasource-sequelize 1.0.0-alpha.1

package/dist/collection.d.ts

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

package/dist/collection.js

@@ -0,0 +1,100 @@
+"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 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"));
+const serializer_1 = __importDefault(require("./utils/serializer"));
+const error_handler_1 = __importDefault(require("./utils/error-handler"));
+class SequelizeCollection extends datasource_toolkit_1.BaseCollection {
+    constructor(name, datasource, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    model, logger) {
+        super(name, datasource);
+        if (!model)
+            throw new Error('Invalid (null) model instance.');
+        this.model = model;
+        this.col = this.model.sequelize.col;
+        this.fn = this.model.sequelize.fn;
+        this.aggregationUtils = new aggregation_1.default(this.model);
+        this.queryConverter = new query_converter_1.default(this.model);
+        const modelSchema = model_to_collection_schema_converter_1.default.convert(this.model, logger);
+        this.enableCount();
+        this.addFields(modelSchema.fields);
+        this.addSegments(modelSchema.segments);
+    }
+    async create(caller, data) {
+        const records = await (0, error_handler_1.default)('create', () => this.model.bulkCreate(data));
+        return records.map(record => serializer_1.default.serialize(record.get({ plain: true })));
+    }
+    async list(caller, filter, projection) {
+        let include = this.queryConverter.getIncludeWithAttributesFromProjection(projection);
+        if (filter.conditionTree) {
+            include = include.concat(this.queryConverter.getIncludeFromProjection(filter.conditionTree.projection));
+        }
+        if (filter.sort) {
+            include = include.concat(this.queryConverter.getIncludeFromProjection(filter.sort.projection));
+        }
+        const query = {
+            attributes: projection.columns,
+            where: this.queryConverter.getWhereFromConditionTree(filter.conditionTree),
+            include,
+            limit: filter.page?.limit,
+            offset: filter.page?.skip,
+            order: this.queryConverter.getOrderFromSort(filter.sort),
+            subQuery: false,
+        };
+        const records = await this.model.findAll(query);
+        return records.map(record => serializer_1.default.serialize(record.get({ plain: true })));
+    }
+    async update(caller, filter, patch) {
+        const options = {
+            where: await this.queryConverter.getWhereFromConditionTreeToByPassInclude(filter.conditionTree),
+            fields: Object.keys(patch),
+        };
+        await (0, error_handler_1.default)('update', () => this.model.update(patch, options));
+    }
+    async delete(caller, filter) {
+        const options = {
+            where: await this.queryConverter.getWhereFromConditionTreeToByPassInclude(filter.conditionTree),
+        };
+        await (0, error_handler_1.default)('delete', () => this.model.destroy(options));
+    }
+    async aggregate(caller, filter, aggregation, limit) {
+        let aggregationField = aggregation.field;
+        if (aggregation.operation === 'Count' || !aggregationField) {
+            aggregationField = '*';
+        }
+        else {
+            aggregationField = this.aggregationUtils.quoteField(aggregationField);
+        }
+        const aggregationFunction = this.fn(aggregation.operation.toUpperCase(), this.col(aggregationField));
+        const aggregationAttribute = [
+            aggregationFunction,
+            this.aggregationUtils.aggregateFieldName,
+        ];
+        const { groups, attributes: groupAttributes } = this.aggregationUtils.getGroupAndAttributesFromAggregation(aggregation.groups);
+        let include = this.queryConverter.getIncludeFromProjection(aggregation.projection);
+        if (filter.conditionTree) {
+            include = include.concat(this.queryConverter.getIncludeFromProjection(filter.conditionTree.projection));
+        }
+        const order = this.aggregationUtils.getOrder(aggregationFunction);
+        const query = {
+            attributes: [...groupAttributes, aggregationAttribute],
+            group: groups,
+            where: this.queryConverter.getWhereFromConditionTree(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,15 @@
+import { BaseDataSource, Logger } from '@forestadmin/datasource-toolkit';
+import { Sequelize } from 'sequelize';
+import SequelizeCollection from './collection';
+export default class SequelizeDataSource extends BaseDataSource<SequelizeCollection> {
+    /**
+     * We can't directly use the Sequelize version we install in the package.json
+     * as the customer's version may be different.
+     * To ensure compatibility, we need to only import types from Sequelize,
+     *    and use the customer sequelize version to deal with the data manipulation.
+     */
+    protected sequelize: Sequelize;
+    constructor(sequelize: Sequelize, logger?: Logger);
+    protected createCollections(models: Sequelize['models'], logger?: Logger): void;
+}
+//# sourceMappingURL=datasource.d.ts.map

package/dist/datasource.js

@@ -0,0 +1,34 @@
+"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, logger) {
+        super();
+        /**
+         * We can't directly use the Sequelize version we install in the package.json
+         * as the customer's version may be different.
+         * To ensure compatibility, we need to only import types from Sequelize,
+         *    and use the customer sequelize version to deal with the data manipulation.
+         */
+        this.sequelize = null;
+        if (!sequelize)
+            throw new Error('Invalid (null) Sequelize instance.');
+        this.sequelize = sequelize;
+        this.createCollections(this.sequelize.models, logger);
+    }
+    createCollections(models, logger) {
+        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, logger);
+            this.addCollection(collection);
+        });
+    }
+}
+exports.default = SequelizeDataSource;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YXNvdXJjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9kYXRhc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEsd0VBQXlFO0FBR3pFLDhEQUErQztBQUUvQyxNQUFxQixtQkFBb0IsU0FBUSxtQ0FBbUM7SUFTbEYsWUFBWSxTQUFvQixFQUFFLE1BQWU7UUFDL0MsS0FBSyxFQUFFLENBQUM7UUFUVjs7Ozs7V0FLRztRQUNPLGNBQVMsR0FBYyxJQUFJLENBQUM7UUFLcEMsSUFBSSxDQUFDLFNBQVM7WUFBRSxNQUFNLElBQUksS0FBSyxDQUFDLG9DQUFvQyxDQUFDLENBQUM7UUFFdEUsSUFBSSxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUM7UUFFM0IsSUFBSSxDQUFDLGlCQUFpQixDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQ3hELENBQUM7SUFFUyxpQkFBaUIsQ0FBQyxNQUEyQixFQUFFLE1BQWU7UUFDdEUsTUFBTSxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUM7WUFDbkIsMEJBQTBCO2FBQ3pCLElBQUksQ0FBQyxDQUFDLE1BQU0sRUFBRSxNQUFNLEVBQUUsRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLElBQUksR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7YUFDOUQsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFO1lBQ2YsTUFBTSxVQUFVLEdBQUcsSUFBSSxvQkFBbUIsQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsTUFBTSxDQUFDLENBQUM7WUFDNUUsSUFBSSxDQUFDLGFBQWEsQ0FBQyxVQUFVLENBQUMsQ0FBQztRQUNqQyxDQUFDLENBQUMsQ0FBQztJQUNQLENBQUM7Q0FDRjtBQTVCRCxzQ0E0QkMifQ==

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { DataSourceFactory } from '@forestadmin/datasource-toolkit';
+import { Sequelize } from 'sequelize';
+export { default as SequelizeCollection } from './collection';
+export { default as SequelizeDataSource } from './datasource';
+export { default as TypeConverter } from './utils/type-converter';
+export declare function createSequelizeDataSource(connection: Sequelize): DataSourceFactory;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

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

package/dist/utils/aggregation.d.ts

@@ -0,0 +1,20 @@
+import { AggregateResult, Aggregation } from '@forestadmin/datasource-toolkit';
+import { GroupOption, Model, ModelDefined, ProjectionAlias } from 'sequelize';
+import { Fn } from 'sequelize/types/utils';
+export default class AggregationUtils {
+    private model;
+    private dialect;
+    private col;
+    private dateAggregationConverter;
+    readonly aggregateFieldName = "__aggregate__";
+    constructor(model: ModelDefined<any, any>);
+    private getGroupFieldName;
+    quoteField(field: string): string;
+    getGroupAndAttributesFromAggregation(aggregationQueryGroup: Aggregation['groups']): {
+        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: Aggregation['groups']): AggregateResult[];
+}
+//# sourceMappingURL=aggregation.d.ts.map

package/dist/utils/aggregation.js

@@ -0,0 +1,78 @@
+"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 date_aggregation_converter_1 = __importDefault(require("./date-aggregation-converter"));
+const serializer_1 = __importDefault(require("./serializer"));
+const un_ambigous_1 = __importDefault(require("./un-ambigous"));
+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();
+        this.col = this.model.sequelize.col;
+        this.dateAggregationConverter = new date_aggregation_converter_1.default(this.model.sequelize);
+    }
+    getGroupFieldName(groupField) {
+        return `${groupField}__grouped__`;
+    }
+    quoteField(field) {
+        try {
+            const safeField = (0, un_ambigous_1.default)(this.model, field, true);
+            return this.model.sequelize.getQueryInterface().quoteIdentifiers(safeField);
+        }
+        catch {
+            throw new datasource_toolkit_1.ValidationError(`Invalid access: "${field}" on "${this.model.name}" does not exist.`);
+        }
+    }
+    getGroupAndAttributesFromAggregation(aggregationQueryGroup) {
+        const attributes = [];
+        const groups = aggregationQueryGroup?.map(group => {
+            const { field } = group;
+            const groupFieldName = this.getGroupFieldName(field);
+            const groupField = this.quoteField(field);
+            if (group.operation) {
+                const groupFunction = this.dateAggregationConverter.convertToDialect(groupField, group.operation);
+                attributes.push([groupFunction, groupFieldName]);
+                return this.dialect === 'mssql' ? groupFunction : groupFieldName;
+            }
+            attributes.push([this.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 = [this.col(this.aggregateFieldName), 'DESC NULLS LAST'];
+                break;
+            case 'mssql':
+                order = [aggregationFunction, 'DESC'];
+                break;
+            default:
+                order = [this.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] = serializer_1.default.serializeValue(aggregate[this.getGroupFieldName(field)]);
+            });
+            return aggregateResult;
+        });
+    }
+}
+exports.default = AggregationUtils;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWdncmVnYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvYWdncmVnYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFBQSx3RUFBZ0c7QUFZaEcsOEZBQW9FO0FBQ3BFLDhEQUFzQztBQUN0QyxnRUFBNEM7QUFFNUMsTUFBcUIsZ0JBQWdCO0lBVW5DLDhEQUE4RDtJQUM5RCxZQUFZLEtBQTZCO1FBSGhDLHVCQUFrQixHQUFHLGVBQWUsQ0FBQztRQUk1QyxJQUFJLENBQUMsS0FBSyxHQUFHLEtBQUssQ0FBQztRQUNuQixJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLFVBQVUsRUFBYSxDQUFDO1FBQzVELElBQUksQ0FBQyxHQUFHLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDO1FBRXBDLElBQUksQ0FBQyx3QkFBd0IsR0FBRyxJQUFJLG9DQUF3QixDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDckYsQ0FBQztJQUVPLGlCQUFpQixDQUFDLFVBQWtCO1FBQzFDLE9BQU8sR0FBRyxVQUFVLGFBQWEsQ0FBQztJQUNwQyxDQUFDO0lBRUQsVUFBVSxDQUFDLEtBQWE7UUFDdEIsSUFBSTtZQUNGLE1BQU0sU0FBUyxHQUFHLElBQUEscUJBQWUsRUFBQyxJQUFJLENBQUMsS0FBSyxFQUFFLEtBQUssRUFBRSxJQUFJLENBQUMsQ0FBQztZQUUzRCxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLGlCQUFpQixFQUFFLENBQUMsZ0JBQWdCLENBQUMsU0FBUyxDQUFDLENBQUM7U0FDN0U7UUFBQyxNQUFNO1lBQ04sTUFBTSxJQUFJLG9DQUFlLENBQ3ZCLG9CQUFvQixLQUFLLFNBQVMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLG1CQUFtQixDQUNyRSxDQUFDO1NBQ0g7SUFDSCxDQUFDO0lBRUQsb0NBQW9DLENBQUMscUJBQTRDO1FBSS9FLE1BQU0sVUFBVSxHQUFHLEVBQUUsQ0FBQztRQUN0QixNQUFNLE1BQU0sR0FBRyxxQkFBcUIsRUFBRSxHQUFHLENBQUMsS0FBSyxDQUFDLEVBQUU7WUFDaEQsTUFBTSxFQUFFLEtBQUssRUFBRSxHQUFHLEtBQUssQ0FBQztZQUN4QixNQUFNLGNBQWMsR0FBRyxJQUFJLENBQUMsaUJBQWlCLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDckQsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsQ0FBQztZQUUxQyxJQUFJLEtBQUssQ0FBQyxTQUFTLEVBQUU7Z0JBQ25CLE1BQU0sYUFBYSxHQUFHLElBQUksQ0FBQyx3QkFBd0IsQ0FBQyxnQkFBZ0IsQ0FDbEUsVUFBVSxFQUNWLEtBQUssQ0FBQyxTQUFTLENBQ2hCLENBQUM7Z0JBRUYsVUFBVSxDQUFDLElBQUksQ0FBQyxDQUFDLGFBQWEsRUFBRSxjQUFjLENBQUMsQ0FBQyxDQUFDO2dCQUVqRCxPQUFPLElBQUksQ0FBQyxPQUFPLEtBQUssT0FBTyxDQUFDLENBQUMsQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDLGNBQWMsQ0FBQzthQUNsRTtZQUVELFVBQVUsQ0FBQyxJQUFJLENBQUMsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQyxFQUFFLGNBQWMsQ0FBQyxDQUFDLENBQUM7WUFFeEQsT0FBTyxJQUFJLENBQUMsT0FBTyxLQUFLLE9BQU8sQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxjQUFjLENBQUM7UUFDaEUsQ0FBQyxDQUFDLENBQUM7UUFFSCxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxDQUFDO0lBQ2hDLENBQUM7SUFFRCxRQUFRLENBQUMsbUJBQXVCO1FBQzlCLElBQUksS0FBZ0IsQ0FBQztRQUVyQiw4QkFBOEI7UUFDOUIsUUFBUSxJQUFJLENBQUMsT0FBTyxFQUFFO1lBQ3BCLEtBQUssVUFBVTtnQkFDYixLQUFLLEdBQUcsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxFQUFFLGlCQUFpQixDQUFDLENBQUM7Z0JBQy9ELE1BQU07WUFDUixLQUFLLE9BQU87Z0JBQ1YsS0FBSyxHQUFHLENBQUMsbUJBQW1CLEVBQUUsTUFBTSxDQUFDLENBQUM7Z0JBQ3RDLE1BQU07WUFDUjtnQkFDRSxLQUFLLEdBQUcsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxrQkFBa0IsQ0FBQyxFQUFFLE1BQU0sQ0FBQyxDQUFDO1NBQ3ZEO1FBRUQsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0lBRUQsYUFBYTtJQUNYLDhEQUE4RDtJQUM5RCxJQUF1QixFQUN2QixxQkFBNEM7UUFFNUMsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxFQUFFO1lBQzFCLE1BQU0sZUFBZSxHQUFHO2dCQUN0QixLQUFLLEVBQUUsU0FBUyxDQUFDLElBQUksQ0FBQyxrQkFBa0IsQ0FBVztnQkFDbkQsS0FBSyxFQUFFLEVBQUU7YUFDVixDQUFDO1lBRUYscUJBQXFCLEVBQUUsT0FBTyxDQUFDLENBQUMsRUFBRSxLQUFLLEVBQUUsRUFBRSxFQUFFO2dCQUMzQyxlQUFlLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxHQUFHLG9CQUFVLENBQUMsY0FBYyxDQUN0RCxTQUFTLENBQUMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLEtBQUssQ0FBQyxDQUFDLENBQ3pDLENBQUM7WUFDSixDQUFDLENBQUMsQ0FBQztZQUVILE9BQU8sZUFBZSxDQUFDO1FBQ3pCLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztDQUNGO0FBdEdELG1DQXNHQyJ9

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

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

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DateAggregationConverter {
+    constructor(sequelize) {
+        this.dialect = sequelize.getDialect();
+        this.fn = sequelize.fn;
+        this.col = sequelize.col;
+        this.literal = sequelize.literal;
+    }
+    convertPostgres(field, operation) {
+        const aggregateFunction = this.fn('DATE_TRUNC', operation.toLocaleLowerCase(), this.col(field));
+        return this.fn('TO_CHAR', aggregateFunction, 'YYYY-MM-DD');
+    }
+    convertMssql(field, operation) {
+        let dateToConvert;
+        switch (operation) {
+            case 'Year':
+                dateToConvert = this.fn('DATEFROMPARTS', this.fn('DATEPART', this.literal('YEAR'), this.col(field)), '01', '01');
+                break;
+            case 'Month':
+                dateToConvert = this.fn('DATEFROMPARTS', this.fn('DATEPART', this.literal('YEAR'), this.col(field)), this.fn('DATEPART', this.literal('MONTH'), this.col(field)), '01');
+                break;
+            case 'Week':
+                dateToConvert = this.fn('DATEADD', this.literal('DAY'), this.literal(`-DATEPART(dw, ${field})+2`), this.col(field));
+                break;
+            case 'Day':
+                dateToConvert = this.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 this.fn('CONVERT', this.literal('varchar(10)'), dateToConvert, 23);
+    }
+    convertMysql(field, operation) {
+        let format = '%Y-%m-%d';
+        let dateToConvert = this.col(field);
+        switch (operation) {
+            case 'Year':
+                format = '%Y-01-01';
+                break;
+            case 'Month':
+                format = '%Y-%m-01';
+                break;
+            case 'Week':
+                dateToConvert = this.fn('DATE_SUB', this.col(field), this.literal(`INTERVAL(WEEKDAY(${field})) DAY`));
+                break;
+            case 'Day':
+                break;
+            default:
+                throw new Error(`Unknown Date operation: "${operation}"`);
+        }
+        return this.fn('DATE_FORMAT', dateToConvert, format);
+    }
+    convertSqlite(field, operation) {
+        if (operation === 'Week') {
+            return this.fn('DATE', this.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 this.fn('STRFTIME', format, this.col(field));
+    }
+    convertToDialect(field, operation) {
+        switch (this.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: "${this.dialect}"`);
+        }
+    }
+}
+exports.default = DateAggregationConverter;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils/error-handler.d.ts

@@ -0,0 +1,4 @@
+declare type Callback<T> = () => T;
+export default function handleErrors<T>(method: 'create' | 'update' | 'delete', callback: Callback<T>): Promise<T>;
+export {};
+//# sourceMappingURL=error-handler.d.ts.map

package/dist/utils/error-handler.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+async function handleErrors(method, callback) {
+    try {
+        const result = await callback();
+        return result;
+    }
+    catch (e) {
+        if (e instanceof sequelize_1.UniqueConstraintError) {
+            const message = 'The query violates a unicity constraint in the database. ' +
+                'Please ensure that you are not duplicating information across records.';
+            throw new datasource_toolkit_1.ValidationError(message);
+        }
+        if (e instanceof sequelize_1.ForeignKeyConstraintError) {
+            let message = 'The query violates a foreign key constraint in the database. ';
+            if (method === 'create' || method === 'update') {
+                message += 'Please ensure that you are not linking to a relation which was deleted.';
+            }
+            else {
+                message += 'Please ensure that no records are linked to the one that you wish to delete.';
+            }
+            throw new datasource_toolkit_1.ValidationError(message);
+        }
+        throw e;
+    }
+}
+exports.default = handleErrors;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3ItaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlscy9lcnJvci1oYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEseUNBQTZFO0FBQzdFLHdFQUFrRTtBQUluRCxLQUFLLFVBQVUsWUFBWSxDQUN4QyxNQUFzQyxFQUN0QyxRQUFxQjtJQUVyQixJQUFJO1FBQ0YsTUFBTSxNQUFNLEdBQUcsTUFBTSxRQUFRLEVBQUUsQ0FBQztRQUVoQyxPQUFPLE1BQU0sQ0FBQztLQUNmO0lBQUMsT0FBTyxDQUFDLEVBQUU7UUFDVixJQUFJLENBQUMsWUFBWSxpQ0FBcUIsRUFBRTtZQUN0QyxNQUFNLE9BQU8sR0FDWCwyREFBMkQ7Z0JBQzNELHdFQUF3RSxDQUFDO1lBRTNFLE1BQU0sSUFBSSxvQ0FBZSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1NBQ3BDO1FBRUQsSUFBSSxDQUFDLFlBQVkscUNBQXlCLEVBQUU7WUFDMUMsSUFBSSxPQUFPLEdBQUcsK0RBQStELENBQUM7WUFFOUUsSUFBSSxNQUFNLEtBQUssUUFBUSxJQUFJLE1BQU0sS0FBSyxRQUFRLEVBQUU7Z0JBQzlDLE9BQU8sSUFBSSx5RUFBeUUsQ0FBQzthQUN0RjtpQkFBTTtnQkFDTCxPQUFPLElBQUksOEVBQThFLENBQUM7YUFDM0Y7WUFFRCxNQUFNLElBQUksb0NBQWUsQ0FBQyxPQUFPLENBQUMsQ0FBQztTQUNwQztRQUVELE1BQU0sQ0FBQyxDQUFDO0tBQ1Q7QUFDSCxDQUFDO0FBL0JELCtCQStCQyJ9

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

@@ -0,0 +1,10 @@
+import { ModelDefined } from 'sequelize';
+import { CollectionSchema, Logger } 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>, logger: Logger): CollectionSchema;
+}
+//# sourceMappingURL=model-to-collection-schema-converter.d.ts.map

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

@@ -0,0 +1,122 @@
+"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.sourceKey,
+                    foreignKey: association.otherKey,
+                    foreignKeyTarget: association.targetKey,
+                    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(modelName, associations, logger) {
+        const schemaAssociations = {};
+        if (associations) {
+            Object.entries(associations).forEach(([name, association]) => {
+                try {
+                    schemaAssociations[name] = this.convertAssociation(association);
+                }
+                catch (error) {
+                    logger?.('Warn', `Skipping association '${modelName}.${name}' (${error.message})`);
+                }
+            });
+        }
+        return schemaAssociations;
+    }
+    static convertAttribute(attribute) {
+        const sequelizeColumnType = attribute.type;
+        const columnType = type_converter_1.default.fromDataType(sequelizeColumnType);
+        const filterOperators = type_converter_1.default.operatorsForColumnType(columnType);
+        const column = {
+            columnType,
+            filterOperators,
+            type: 'Column',
+            validation: [],
+            isReadOnly: attribute.autoIncrement,
+            isSortable: true,
+        };
+        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(modelName, attributes, logger) {
+        const fields = {};
+        Object.entries(attributes).forEach(([name, attribute]) => {
+            try {
+                fields[name] = this.convertAttribute(attribute);
+            }
+            catch (error) {
+                logger?.('Warn', `Skipping column '${modelName}.${name}' (${error.message})`);
+            }
+        });
+        return fields;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static convert(model, logger) {
+        if (!model)
+            throw new Error('Invalid (null) model.');
+        return {
+            actions: {},
+            countable: true,
+            fields: {
+                ...this.convertAttributes(model.name, model.getAttributes(), logger),
+                ...this.convertAssociations(model.name, model.associations, logger),
+            },
+            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,19 @@
+import { ConditionTree, Projection, Sort } from '@forestadmin/datasource-toolkit';
+import { IncludeOptions, ModelDefined, OrderItem, WhereOptions } from 'sequelize';
+export default class QueryConverter {
+    private model;
+    private dialect;
+    private col;
+    private fn;
+    private where;
+    constructor(model: ModelDefined<unknown, unknown>);
+    private asArray;
+    private makeWhereClause;
+    getWhereFromConditionTreeToByPassInclude(conditionTree?: ConditionTree): Promise<WhereOptions>;
+    getWhereFromConditionTree(conditionTree?: ConditionTree): WhereOptions;
+    private computeIncludeFromProjection;
+    getIncludeFromProjection(projection: Projection): IncludeOptions[];
+    getIncludeWithAttributesFromProjection(projection: Projection): IncludeOptions[];
+    getOrderFromSort(sort: Sort): OrderItem[];
+}
+//# sourceMappingURL=query-converter.d.ts.map