@loopback/sequelize 0.1.0

package/dist/sequelize/sequelize.repository.base.js

@@ -0,0 +1,835 @@
+"use strict";
+// Copyright LoopBack contributors 2022. All Rights Reserved.
+// Node module: @loopback/sequelize
+// This file is licensed under the MIT License.
+// License text available at https://opensource.org/licenses/MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequelizeCrudRepository = void 0;
+const tslib_1 = require("tslib");
+const repository_1 = require("@loopback/repository");
+const debug_1 = tslib_1.__importDefault(require("debug"));
+const sequelize_1 = require("sequelize");
+const operator_translation_1 = require("./operator-translation");
+const utils_1 = require("./utils");
+const debug = (0, debug_1.default)('loopback:sequelize:repository');
+const debugModelBuilder = (0, debug_1.default)('loopback:sequelize:modelbuilder');
+/**
+ * Sequelize implementation of CRUD repository to be used with default loopback entities
+ * and SequelizeDataSource for SQL Databases
+ */
+class SequelizeCrudRepository {
+    constructor(entityClass, dataSource) {
+        this.entityClass = entityClass;
+        this.dataSource = dataSource;
+        /**
+         * Default `order` filter style if only column name is specified
+         */
+        this.DEFAULT_ORDER_STYLE = 'ASC';
+        /**
+         * Object keys used in models for set database specific settings.
+         * Example: In model property definition one can use postgresql dataType as float
+         * {
+         *   type: 'number',
+         *   postgresql: {
+         *     dataType: 'float',
+         *     precision: 20,
+         *     scale: 4,
+         *   },
+         * }
+         *
+         * This array of keys is used while building model definition for sequelize.
+         */
+        this.DB_SPECIFIC_SETTINGS_KEYS = [
+            'postgresql',
+            'mysql',
+            'sqlite3',
+        ];
+        this.inclusionResolvers = new Map();
+        if (this.dataSource.sequelize) {
+            this.sequelizeModel = this.getSequelizeModel();
+        }
+    }
+    async create(entity, options) {
+        let err = null;
+        const data = await this.sequelizeModel
+            .create(entity, options)
+            .catch(error => {
+            console.error(error);
+            err = error;
+        });
+        if (!data) {
+            throw new Error(err !== null && err !== void 0 ? err : 'Something went wrong');
+        }
+        return new this.entityClass(this.excludeHiddenProps(data.toJSON()));
+    }
+    async createAll(entities, options) {
+        const models = await this.sequelizeModel.bulkCreate(entities, options);
+        return this.toEntities(models);
+    }
+    exists(id, _options) {
+        return new Promise((resolve, reject) => {
+            this.sequelizeModel
+                .findByPk(id)
+                .then(value => {
+                resolve(!!value);
+            })
+                .catch(err => {
+                reject(err);
+            });
+        });
+    }
+    async save(entity, options) {
+        const id = this.entityClass.getIdOf(entity);
+        if (id == null) {
+            return this.create(entity, options);
+        }
+        else {
+            await this.replaceById(id, entity, options);
+            return new this.entityClass(entity.toObject());
+        }
+    }
+    update(entity, options) {
+        return this.updateById(entity.getId(), entity, options);
+    }
+    async updateById(id, data, options) {
+        if (id === undefined) {
+            throw new Error('Invalid Argument: id cannot be undefined');
+        }
+        const idProp = this.entityClass.definition.idProperties()[0];
+        const where = {};
+        where[idProp] = id;
+        const result = await this.updateAll(data, where, options);
+        if (result.count === 0) {
+            throw new repository_1.EntityNotFoundError(this.entityClass, id);
+        }
+    }
+    async updateAll(data, where, options) {
+        const [affectedCount] = await this.sequelizeModel.update(Object.assign({}, data), {
+            where: this.buildSequelizeWhere(where),
+            ...options,
+        });
+        return { count: affectedCount };
+    }
+    async delete(entity, options) {
+        return this.deleteById(entity.getId(), options);
+    }
+    async find(filter, options) {
+        var _a;
+        const data = await this.sequelizeModel
+            .findAll({
+            include: this.buildSequelizeIncludeFilter(filter === null || filter === void 0 ? void 0 : filter.include),
+            where: this.buildSequelizeWhere(filter === null || filter === void 0 ? void 0 : filter.where),
+            attributes: this.buildSequelizeAttributeFilter(filter === null || filter === void 0 ? void 0 : filter.fields),
+            order: this.buildSequelizeOrder(filter === null || filter === void 0 ? void 0 : filter.order),
+            limit: filter === null || filter === void 0 ? void 0 : filter.limit,
+            offset: (_a = filter === null || filter === void 0 ? void 0 : filter.offset) !== null && _a !== void 0 ? _a : filter === null || filter === void 0 ? void 0 : filter.skip,
+            ...options,
+        })
+            .catch(err => {
+            debug('findAll() error:', err);
+            throw new Error(err);
+        });
+        return this.includeReferencesIfRequested(data, this.entityClass, filter === null || filter === void 0 ? void 0 : filter.include);
+    }
+    async findOne(filter, options) {
+        var _a;
+        const data = await this.sequelizeModel
+            .findOne({
+            include: this.buildSequelizeIncludeFilter(filter === null || filter === void 0 ? void 0 : filter.include),
+            where: this.buildSequelizeWhere(filter === null || filter === void 0 ? void 0 : filter.where),
+            attributes: this.buildSequelizeAttributeFilter(filter === null || filter === void 0 ? void 0 : filter.fields),
+            order: this.buildSequelizeOrder(filter === null || filter === void 0 ? void 0 : filter.order),
+            offset: (_a = filter === null || filter === void 0 ? void 0 : filter.offset) !== null && _a !== void 0 ? _a : filter === null || filter === void 0 ? void 0 : filter.skip,
+            ...options,
+        })
+            .catch(err => {
+            debug('findOne() error:', err);
+            throw new Error(err);
+        });
+        if (data === null) {
+            return Promise.resolve(null);
+        }
+        const resolved = await this.includeReferencesIfRequested([data], this.entityClass, filter === null || filter === void 0 ? void 0 : filter.include);
+        return resolved[0];
+    }
+    async findById(id, filter, options) {
+        var _a;
+        const data = await this.sequelizeModel.findByPk(id, {
+            order: this.buildSequelizeOrder(filter === null || filter === void 0 ? void 0 : filter.order),
+            attributes: this.buildSequelizeAttributeFilter(filter === null || filter === void 0 ? void 0 : filter.fields),
+            include: this.buildSequelizeIncludeFilter(filter === null || filter === void 0 ? void 0 : filter.include),
+            limit: filter === null || filter === void 0 ? void 0 : filter.limit,
+            offset: (_a = filter === null || filter === void 0 ? void 0 : filter.offset) !== null && _a !== void 0 ? _a : filter === null || filter === void 0 ? void 0 : filter.skip,
+            ...options,
+        });
+        if (!data) {
+            throw new repository_1.EntityNotFoundError(this.entityClass, id);
+        }
+        const resolved = await this.includeReferencesIfRequested([data], this.entityClass, filter === null || filter === void 0 ? void 0 : filter.include);
+        return resolved[0];
+    }
+    async replaceById(id, data, options) {
+        const idProp = this.entityClass.definition.idProperties()[0];
+        if (idProp in data) {
+            delete data[idProp];
+        }
+        await this.updateById(id, data, options);
+    }
+    async deleteAll(where, options) {
+        const count = await this.sequelizeModel.destroy({
+            where: this.buildSequelizeWhere(where),
+            ...options,
+        });
+        return { count };
+    }
+    async deleteById(id, options) {
+        const idProp = this.entityClass.definition.idProperties()[0];
+        if (id === undefined) {
+            throw new Error(`Invalid Argument: ${idProp} cannot be undefined`);
+        }
+        const where = {};
+        where[idProp] = id;
+        const count = await this.sequelizeModel.destroy({
+            where: this.buildSequelizeWhere(where),
+            ...options,
+        });
+        if (count === 0) {
+            throw new repository_1.EntityNotFoundError(this.entityClass, id);
+        }
+    }
+    async count(where, options) {
+        const count = await this.sequelizeModel.count({
+            where: this.buildSequelizeWhere(where),
+            ...options,
+        });
+        return { count };
+    }
+    async execute(..._args) {
+        throw new Error('RAW Query execution is currently NOT supported for Sequelize CRUD Repository.');
+    }
+    toEntities(models) {
+        return models.map(m => new this.entityClass(m.toJSON()));
+    }
+    /**
+     * Get Sequelize Operator
+     * @param key Name of the operator used in loopback eg. lt
+     * @returns Equivalent operator symbol if available in Sequelize eg `Op.lt`
+     */
+    getSequelizeOperator(key) {
+        const sequelizeOperator = operator_translation_1.operatorTranslations[key];
+        if (!sequelizeOperator) {
+            throw Error(`There is no equivalent operator for "${key}" in sequelize.`);
+        }
+        return sequelizeOperator;
+    }
+    /**
+     * Get Sequelize `attributes` filter value from `fields` of loopback.
+     * @param fields Loopback styles `fields` options. eg. `["name", "age"]`, `{ id: false }`
+     * @returns Sequelize Compatible Object/Array based on the fields provided. eg. `{ "exclude": ["id"] }`
+     */
+    buildSequelizeAttributeFilter(fields) {
+        var _a, _b;
+        if (fields === undefined) {
+            return undefined;
+        }
+        if (Array.isArray(fields)) {
+            // Both (sequelize and loopback filters) consider array as "only columns to include"
+            return fields;
+        }
+        const sequelizeFields = {
+            include: [],
+            exclude: [],
+        };
+        // Push column having `false` values in `exclude` key and columns
+        // having `true` in `include` key
+        if ((0, utils_1.isTruelyObject)(fields)) {
+            for (const key in fields) {
+                if (fields[key] === true) {
+                    (_a = sequelizeFields.include) === null || _a === void 0 ? void 0 : _a.push(key);
+                }
+                else if (fields[key] === false) {
+                    (_b = sequelizeFields.exclude) === null || _b === void 0 ? void 0 : _b.push(key);
+                }
+            }
+        }
+        if (Array.isArray(sequelizeFields.include) &&
+            sequelizeFields.include.length > 0) {
+            delete sequelizeFields.exclude;
+            return sequelizeFields.include;
+        }
+        if (Array.isArray(sequelizeFields.exclude) &&
+            sequelizeFields.exclude.length > 0) {
+            delete sequelizeFields.include;
+        }
+        return sequelizeFields;
+    }
+    /**
+     * Get Sequelize Order filter value from loopback style order value
+     * @param order Sorting order in loopback style filter. eg. `title ASC`, `["id DESC", "age ASC"]`
+     * @returns Sequelize compatible order filter value
+     */
+    buildSequelizeOrder(order) {
+        if (order === undefined) {
+            return undefined;
+        }
+        if (typeof order === 'string') {
+            const [columnName, orderType] = order.trim().split(' ');
+            return [[columnName, orderType !== null && orderType !== void 0 ? orderType : this.DEFAULT_ORDER_STYLE]];
+        }
+        return order.map(orderStr => {
+            const [columnName, orderType] = orderStr.trim().split(' ');
+            return [columnName, orderType !== null && orderType !== void 0 ? orderType : this.DEFAULT_ORDER_STYLE];
+        });
+    }
+    /**
+     * Build Sequelize compatible `include` filter
+     * @param inclusionFilters - loopback style `where` condition
+     * @param sourceModel - sequelize model instance
+     * @returns Sequelize compatible `Includeable` array
+     */
+    buildSequelizeIncludeFilter(inclusionFilters, sourceModel) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        if (!inclusionFilters || inclusionFilters.length === 0) {
+            return [];
+        }
+        if (!sourceModel) {
+            sourceModel = this.sequelizeModel;
+        }
+        const includable = [];
+        for (const filter of inclusionFilters) {
+            if (typeof filter === 'string') {
+                if (filter in sourceModel.associations) {
+                    includable.push(filter);
+                }
+                else {
+                    debug(`Relation '${filter}' is not available in sequelize model associations. If it's referencesMany relation it will fallback to loopback inclusion resolver.`);
+                }
+            }
+            else if (typeof filter === 'object') {
+                if (!(filter.relation in sourceModel.associations)) {
+                    debug(`Relation '${filter.relation}' is not available in sequelize model associations. If it's referencesMany relation it will fallback to loopback inclusion resolver.`);
+                    continue;
+                }
+                const targetAssociation = sourceModel.associations[filter.relation];
+                includable.push({
+                    model: targetAssociation.target,
+                    /**
+                     * Exclude through model data from response to be backward compatible
+                     * with loopback response style for hasMany through relation.
+                     * Does not work with sqlite3
+                     */
+                    ...(targetAssociation.associationType === 'BelongsToMany' &&
+                        targetAssociation.isMultiAssociation
+                        ? { through: { attributes: [] } }
+                        : {}),
+                    where: this.buildSequelizeWhere((_a = filter.scope) === null || _a === void 0 ? void 0 : _a.where),
+                    limit: (_c = (_b = filter.scope) === null || _b === void 0 ? void 0 : _b.totalLimit) !== null && _c !== void 0 ? _c : (_d = filter.scope) === null || _d === void 0 ? void 0 : _d.limit,
+                    attributes: this.buildSequelizeAttributeFilter((_e = filter.scope) === null || _e === void 0 ? void 0 : _e.fields),
+                    include: this.buildSequelizeIncludeFilter((_f = filter.scope) === null || _f === void 0 ? void 0 : _f.include, targetAssociation.target),
+                    order: this.buildSequelizeOrder((_g = filter.scope) === null || _g === void 0 ? void 0 : _g.order),
+                    as: filter.relation,
+                    /**
+                     * If true, uses an inner join, which means that the parent model will only be loaded if it has any matching children.
+                     */
+                    required: !!filter.required,
+                    /**
+                     * saperate: true is required for `order` and `limit` filter to work, it runs include in saperate queries
+                     */
+                    separate: !!((_h = filter.scope) === null || _h === void 0 ? void 0 : _h.order) ||
+                        !!((_k = (_j = filter.scope) === null || _j === void 0 ? void 0 : _j.totalLimit) !== null && _k !== void 0 ? _k : (_l = filter.scope) === null || _l === void 0 ? void 0 : _l.limit),
+                });
+            }
+        }
+        return includable;
+    }
+    /**
+     * Build Sequelize compatible where condition object
+     * @param where loopback style `where` condition
+     * @returns Sequelize compatible where options to be used in queries
+     */
+    buildSequelizeWhere(where) {
+        if (!where) {
+            return {};
+        }
+        const sequelizeWhere = {};
+        /**
+         * Handle model attribute conditions like `{ age: { gt: 18 } }`, `{ email: "a@b.c" }`
+         * Transform Operators - eg. `{ gt: 0, lt: 10 }` to `{ [Op.gt]: 0, [Op.lt]: 10 }`
+         */
+        for (const columnName in where) {
+            const conditionValue = (where[columnName]);
+            if ((0, utils_1.isTruelyObject)(conditionValue)) {
+                sequelizeWhere[columnName] = {};
+                for (const lb4Operator of Object.keys(conditionValue)) {
+                    const sequelizeOperator = this.getSequelizeOperator(lb4Operator);
+                    sequelizeWhere[columnName][sequelizeOperator] =
+                        conditionValue[lb4Operator];
+                }
+            }
+            else if (['and', 'or'].includes(columnName) &&
+                Array.isArray(conditionValue)) {
+                /**
+                 * Eg. {and: [{title: 'My Post'}, {content: 'Hello'}]}
+                 */
+                const sequelizeOperator = this.getSequelizeOperator(columnName);
+                const conditions = conditionValue.map((condition) => {
+                    return this.buildSequelizeWhere(condition);
+                });
+                Object.assign(sequelizeWhere, {
+                    [sequelizeOperator]: conditions,
+                });
+            }
+            else {
+                // Equals
+                sequelizeWhere[columnName] = {
+                    [sequelize_1.Op.eq]: conditionValue,
+                };
+            }
+        }
+        return sequelizeWhere;
+    }
+    /**
+     * Get Sequelize Model
+     * @returns Sequelize Model Instance based on the definitions from `entityClass`
+     */
+    getSequelizeModel(entityClass = this.entityClass) {
+        if (!this.dataSource.sequelize) {
+            throw Error(`The datasource "${this.dataSource.name}" doesn't have sequelize instance bound to it.`);
+        }
+        if (this.dataSource.sequelize.models[entityClass.modelName]) {
+            // Model Already Defined by Sequelize before
+            return this.dataSource.sequelize.models[entityClass.modelName];
+        }
+        // TODO: Make it more flexible, check support of all possible definition props
+        const sourceModel = this.dataSource.sequelize.define(entityClass.modelName, this.getSequelizeModelAttributes(entityClass.definition.properties), {
+            timestamps: false,
+            tableName: entityClass.modelName.toLowerCase(),
+            freezeTableName: true,
+        });
+        // Setup associations
+        for (const key in entityClass.definition.relations) {
+            const targetModel = this.getSequelizeModel(entityClass.definition.relations[key].target());
+            debugModelBuilder(`Setting up relation`, entityClass.definition.relations[key]);
+            if (entityClass.definition.relations[key].type ===
+                repository_1.RelationType.belongsTo) {
+                const foreignKey = entityClass.definition.relations[key].keyTo;
+                sourceModel.belongsTo(targetModel, {
+                    foreignKey: { name: foreignKey },
+                    // Which client will pass on in loopback style include filter, eg. `include: ["thisName"]`
+                    as: entityClass.definition.relations[key].name,
+                });
+            }
+            else if (entityClass.definition.relations[key].type ===
+                repository_1.RelationType.hasOne) {
+                const foreignKey = entityClass.definition.relations[key].keyTo;
+                sourceModel.hasOne(targetModel, {
+                    foreignKey: foreignKey,
+                    as: entityClass.definition.relations[key].name,
+                });
+            }
+            else if (entityClass.definition.relations[key].type ===
+                repository_1.RelationType.hasMany) {
+                const relationDefinition = entityClass.definition.relations[key];
+                const through = relationDefinition.through;
+                const foreignKey = relationDefinition.keyTo;
+                if (through) {
+                    const keyTo = through.keyTo;
+                    const keyFrom = through.keyFrom;
+                    // Setup hasMany through
+                    const throughModel = this.getSequelizeModel(through.model());
+                    sourceModel.belongsToMany(targetModel, {
+                        through: { model: throughModel },
+                        otherKey: keyTo,
+                        foreignKey: keyFrom,
+                        as: entityClass.definition.relations[key].name,
+                    });
+                }
+                else {
+                    sourceModel.hasMany(targetModel, {
+                        foreignKey: foreignKey,
+                        as: entityClass.definition.relations[key].name,
+                    });
+                }
+            }
+        }
+        debugModelBuilder('Table name supplied to sequelize'.concat(`"${entityClass.modelName.toLowerCase()}"`));
+        return sourceModel;
+    }
+    /**
+     * Run CREATE TABLE query for the target sequelize model, Useful for quick testing
+     * @param options Sequelize Sync Options
+     */
+    async syncSequelizeModel(options = {}) {
+        var _a;
+        await ((_a = this.dataSource.sequelize) === null || _a === void 0 ? void 0 : _a.models[this.entityClass.modelName].sync(options).catch(console.error));
+    }
+    /**
+     * Run CREATE TABLE query for the all sequelize models, Useful for quick testing
+     * @param options Sequelize Sync Options
+     */
+    async syncLoadedSequelizeModels(options = {}) {
+        var _a;
+        await ((_a = this.dataSource.sequelize) === null || _a === void 0 ? void 0 : _a.sync(options).catch(console.error));
+    }
+    /**
+     * Get Sequelize Model Attributes
+     * @param definition property definition received from loopback entityClass eg. `{ id: { type: "Number", id: true } }`
+     * @returns model attributes supported in sequelize model definiotion
+     *
+     * TODO: Verify all possible loopback types https://loopback.io/doc/en/lb4/LoopBack-types.html
+     */
+    getSequelizeModelAttributes(definition) {
+        var _a;
+        debugModelBuilder('loopback model definition', definition);
+        const sequelizeDefinition = {};
+        for (const propName in definition) {
+            // Set data type, defaults to `DataTypes.STRING`
+            let dataType = sequelize_1.DataTypes.STRING;
+            const isString = definition[propName].type === String ||
+                ['String', 'string'].includes(definition[propName].type.toString());
+            if (definition[propName].type === Number ||
+                ['Number', 'number'].includes(definition[propName].type.toString())) {
+                dataType = sequelize_1.DataTypes.NUMBER;
+                // handle float
+                for (const dbKey of this.DB_SPECIFIC_SETTINGS_KEYS) {
+                    if (!(dbKey in definition[propName])) {
+                        continue;
+                    }
+                    const dbSpecificSetting = definition[propName][dbKey];
+                    if (['double precision', 'float', 'real'].includes(dbSpecificSetting.dataType)) {
+                        // TODO: Handle precision
+                        dataType = sequelize_1.DataTypes.FLOAT;
+                    }
+                }
+            }
+            if (definition[propName].type === Boolean ||
+                ['Boolean', 'boolean'].includes(definition[propName].type.toString())) {
+                dataType = sequelize_1.DataTypes.BOOLEAN;
+            }
+            if (definition[propName].type === Array ||
+                ['Array', 'array'].includes(definition[propName].type.toString())) {
+                // Postgres only
+                dataType = sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.INTEGER);
+            }
+            if (definition[propName].type === Object ||
+                ['object', 'Object'].includes(definition[propName].type.toString())) {
+                // Postgres only, JSON dataType
+                dataType = sequelize_1.DataTypes.JSON;
+            }
+            if (definition[propName].type === Date ||
+                ['date', 'Date'].includes(definition[propName].type.toString())) {
+                dataType = sequelize_1.DataTypes.DATE;
+            }
+            if (dataType === sequelize_1.DataTypes.STRING && !isString) {
+                throw Error(`Unhandled DataType "${definition[propName].type.toString()}" for column "${propName}" in sequelize extension`);
+            }
+            const columnOptions = {
+                type: dataType,
+                ...('default' in definition[propName]
+                    ? { defaultValue: definition[propName].default }
+                    : {}),
+            };
+            // Set column as `primaryKey` when id is set to true (which is loopback way to define primary key)
+            if (definition[propName].id === true) {
+                if (columnOptions.type === sequelize_1.DataTypes.NUMBER) {
+                    columnOptions.type = sequelize_1.DataTypes.INTEGER;
+                }
+                Object.assign(columnOptions, {
+                    primaryKey: true,
+                    /**
+                     * `autoIncrement` needs to be true even if DataType is not INTEGER else it will pass the ID in the query set to NULL.
+                     */
+                    autoIncrement: !!definition[propName].generated,
+                });
+            }
+            // TODO: Get the column name casing using actual methods / conventions used in different sql connectors for loopback
+            columnOptions.field =
+                (_a = definition[propName]['name']) !== null && _a !== void 0 ? _a : propName.toLowerCase();
+            sequelizeDefinition[propName] = columnOptions;
+        }
+        debugModelBuilder('Sequelize model definition', sequelizeDefinition);
+        return sequelizeDefinition;
+    }
+    /**
+     * Remove hidden properties specified in model from response body. (See:  https://github.com/sourcefuse/loopback4-sequelize/issues/3)
+     * @param entity normalized entity. You can use `entity.toJSON()`'s value
+     * @returns normalized entity excluding the hiddenProperties
+     */
+    excludeHiddenProps(entity) {
+        const hiddenProps = this.entityClass.definition.settings.hiddenProperties;
+        if (!hiddenProps) {
+            return entity;
+        }
+        for (const propertyName of hiddenProps) {
+            delete entity[propertyName];
+        }
+        return entity;
+    }
+    /**
+     * Include related entities of `@referencesMany` relation
+     *
+     * referencesMany relation is NOT handled by `sequelizeModel.findAll` as it doesn't have any direct alternative to it,
+     * so to include relation data of referencesMany, we're manually fetching related data requested
+     *
+     * @param parentEntities source table data
+     * @param filter actual payload passed in request
+     * @param parentEntityClass loopback entity class for the parent entity
+     * @returns entities with related models in them
+     */
+    async includeReferencesIfRequested(parentEntities, parentEntityClass, inclusionFilters) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        if (!parentEntityClass) {
+            parentEntityClass = this.entityClass;
+        }
+        /**
+         * All columns names defined in model with `@referencesMany`
+         */
+        const allReferencesColumns = [];
+        for (const key in parentEntityClass.definition.relations) {
+            if (parentEntityClass.definition.relations[key].type ===
+                repository_1.RelationType.referencesMany) {
+                const loopbackRelationObject = parentEntityClass.definition.relations[key];
+                if (loopbackRelationObject.keyFrom) {
+                    allReferencesColumns.push(loopbackRelationObject.keyFrom);
+                }
+            }
+        }
+        // Validate data type of items in any column having references
+        // For eg. convert ["1", "2"] into [1, 2] if `itemType` specified is `number[]`
+        const normalizedParentEntities = parentEntities.map(entity => {
+            const data = entity.toJSON();
+            for (const columnName in data) {
+                if (!allReferencesColumns.includes(columnName)) {
+                    // Column is not the one used for referencesMany relation. Eg. "programmingLanguageIds"
+                    continue;
+                }
+                const columnDefinition = parentEntityClass.definition.properties[columnName];
+                if (columnDefinition.type !== Array ||
+                    !Array.isArray(data[columnName])) {
+                    // Column type or data received is not array, wrong configuration/data
+                    continue;
+                }
+                // Loop over all references in array received
+                const items = data[columnName];
+                for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+                    if (columnDefinition.itemType === Number &&
+                        typeof items[itemIndex] === 'string') {
+                        items[itemIndex] = parseInt(items[itemIndex]);
+                    }
+                }
+                data[columnName] = items;
+            }
+            return data;
+        });
+        // Requested inclusions of referencesMany relation
+        const referencesManyInclusions = [];
+        for (let includeFilter of inclusionFilters !== null && inclusionFilters !== void 0 ? inclusionFilters : []) {
+            if (typeof includeFilter === 'string') {
+                includeFilter = { relation: includeFilter };
+            }
+            const relationName = includeFilter.relation;
+            const relation = parentEntityClass.definition.relations[relationName];
+            if (relation.type === repository_1.RelationType.referencesMany) {
+                referencesManyInclusions.push({
+                    filter: includeFilter,
+                    definition: relation,
+                    keys: [],
+                });
+            }
+        }
+        if (referencesManyInclusions.length === 0) {
+            const entityClasses = normalizedParentEntities.map(e => new parentEntityClass(e));
+            return entityClasses;
+        }
+        for (const relation of referencesManyInclusions) {
+            normalizedParentEntities.forEach(entity => {
+                if (!relation.definition.keyFrom) {
+                    return;
+                }
+                const columnValue = entity[relation.definition.keyFrom];
+                if (Array.isArray(columnValue)) {
+                    relation.keys.push(...columnValue);
+                }
+                else if (typeof columnValue === 'string' && columnValue.length > 0) {
+                    relation.keys.push(...columnValue.split(','));
+                }
+                else {
+                    // column value holding references keys isn't an array nor a string
+                    debug(`Column "${relation.definition.keyFrom}"'s value holding references keys isn't an array for ${JSON.stringify(entity)}, Can't fetch related models.`);
+                }
+            });
+            relation.keys = [...new Set(relation.keys)];
+            const foreignKey = (_a = relation.definition.keyTo) !== null && _a !== void 0 ? _a : relation.definition.target().definition.idProperties()[0];
+            // Strictly include primary key in attributes
+            const attributesToFetch = this.buildSequelizeAttributeFilter((_b = relation.filter.scope) === null || _b === void 0 ? void 0 : _b.fields);
+            let includeForeignKeyInResponse = false;
+            if (attributesToFetch !== undefined) {
+                if (Array.isArray(attributesToFetch)) {
+                    if (attributesToFetch.includes(foreignKey)) {
+                        includeForeignKeyInResponse = true;
+                    }
+                    else {
+                        attributesToFetch.push(foreignKey);
+                    }
+                }
+                else if (Array.isArray(attributesToFetch.include)) {
+                    if (attributesToFetch.include.includes(foreignKey)) {
+                        includeForeignKeyInResponse = true;
+                    }
+                    else {
+                        attributesToFetch.include.push(foreignKey);
+                    }
+                }
+            }
+            else {
+                includeForeignKeyInResponse = true;
+            }
+            const targetLoopbackModel = relation.definition.target();
+            const targetSequelizeModel = this.getSequelizeModel(targetLoopbackModel);
+            const sequelizeData = await targetSequelizeModel.findAll({
+                where: {
+                    // eg. id: { [Op.in]: [1,2,4,8] }
+                    [foreignKey]: {
+                        [sequelize_1.Op.in]: relation.keys,
+                    },
+                    ...this.buildSequelizeWhere((_c = relation.filter.scope) === null || _c === void 0 ? void 0 : _c.where),
+                },
+                attributes: attributesToFetch,
+                include: this.buildSequelizeIncludeFilter((_d = relation.filter.scope) === null || _d === void 0 ? void 0 : _d.include, targetSequelizeModel),
+                order: this.buildSequelizeOrder((_e = relation.filter.scope) === null || _e === void 0 ? void 0 : _e.order),
+                limit: (_g = (_f = relation.filter.scope) === null || _f === void 0 ? void 0 : _f.totalLimit) !== null && _g !== void 0 ? _g : (_h = relation.filter.scope) === null || _h === void 0 ? void 0 : _h.limit,
+                offset: (_k = (_j = relation.filter.scope) === null || _j === void 0 ? void 0 : _j.offset) !== null && _k !== void 0 ? _k : (_l = relation.filter.scope) === null || _l === void 0 ? void 0 : _l.skip,
+            });
+            const childModelData = await this.includeReferencesIfRequested(sequelizeData, targetLoopbackModel, (_m = relation.filter.scope) === null || _m === void 0 ? void 0 : _m.include);
+            normalizedParentEntities.forEach(entity => {
+                const foreignKeys = entity[relation.definition.keyFrom];
+                const filteredChildModels = childModelData.filter(childModel => {
+                    if (Array.isArray(foreignKeys)) {
+                        return foreignKeys === null || foreignKeys === void 0 ? void 0 : foreignKeys.includes(childModel[foreignKey]);
+                    }
+                    else {
+                        return true;
+                    }
+                });
+                Object.assign(entity, {
+                    [relation.definition.name]: filteredChildModels.map(filteredChildModel => {
+                        const safeCopy = { ...filteredChildModel };
+                        if (includeForeignKeyInResponse === false) {
+                            delete safeCopy[foreignKey];
+                        }
+                        return safeCopy;
+                    }),
+                });
+                return new parentEntityClass(entity);
+            });
+        }
+        return normalizedParentEntities;
+    }
+    /**
+     * Register an inclusion resolver for the related model name.
+     *
+     * @param relationName - Name of the relation defined on the source model
+     * @param resolver - Resolver function for getting related model entities
+     */
+    registerInclusionResolver(relationName, resolver) {
+        this.inclusionResolvers.set(relationName, resolver);
+    }
+    /**
+     * Function to create a constrained relation repository factory
+     *
+     * @example
+     * ```ts
+     * class CustomerRepository extends SequelizeCrudRepository<
+     *   Customer,
+     *   typeof Customer.prototype.id,
+     *   CustomerRelations
+     * > {
+     *   public readonly orders: HasManyRepositoryFactory<Order, typeof Customer.prototype.id>;
+     *
+     *   constructor(
+     *     protected db: SequelizeDataSource,
+     *     orderRepository: EntityCrudRepository<Order, typeof Order.prototype.id>,
+     *   ) {
+     *     super(Customer, db);
+     *     this.orders = this.createHasManyRepositoryFactoryFor(
+     *       'orders',
+     *       orderRepository,
+     *     );
+     *   }
+     * }
+     * ```
+     *
+     * @param relationName - Name of the relation defined on the source model
+     * @param targetRepo - Target repository instance
+     */
+    createHasManyRepositoryFactoryFor(relationName, targetRepositoryGetter) {
+        const meta = this.entityClass.definition.relations[relationName];
+        return (0, repository_1.createHasManyRepositoryFactory)(meta, targetRepositoryGetter);
+    }
+    /**
+     * Function to create a belongs to accessor
+     *
+     * @param relationName - Name of the relation defined on the source model
+     * @param targetRepo - Target repository instance
+     */
+    createBelongsToAccessorFor(relationName, targetRepositoryGetter) {
+        const meta = this.entityClass.definition.relations[relationName];
+        return (0, repository_1.createBelongsToAccessor)(meta, targetRepositoryGetter, this);
+    }
+    /**
+     * Function to create a constrained hasOne relation repository factory
+     *
+     * @param relationName - Name of the relation defined on the source model
+     * @param targetRepo - Target repository instance
+     */
+    createHasOneRepositoryFactoryFor(relationName, targetRepositoryGetter) {
+        const meta = this.entityClass.definition.relations[relationName];
+        return (0, repository_1.createHasOneRepositoryFactory)(meta, targetRepositoryGetter);
+    }
+    /**
+     * Function to create a constrained hasManyThrough relation repository factory
+     *
+     * @example
+     * ```ts
+     * class CustomerRepository extends SequelizeCrudRepository<
+     *   Customer,
+     *   typeof Customer.prototype.id,
+     *   CustomerRelations
+     * > {
+     *   public readonly cartItems: HasManyRepositoryFactory<CartItem, typeof Customer.prototype.id>;
+     *
+     *   constructor(
+     *     protected db: SequelizeDataSource,
+     *     cartItemRepository: EntityCrudRepository<CartItem, typeof, CartItem.prototype.id>,
+     *     throughRepository: EntityCrudRepository<Through, typeof Through.prototype.id>,
+     *   ) {
+     *     super(Customer, db);
+     *     this.cartItems = this.createHasManyThroughRepositoryFactoryFor(
+     *       'cartItems',
+     *       cartItemRepository,
+     *     );
+     *   }
+     * }
+     * ```
+     *
+     * @param relationName - Name of the relation defined on the source model
+     * @param targetRepo - Target repository instance
+     * @param throughRepo - Through repository instance
+     */
+    createHasManyThroughRepositoryFactoryFor(relationName, targetRepositoryGetter, throughRepositoryGetter) {
+        const meta = this.entityClass.definition.relations[relationName];
+        return (0, repository_1.createHasManyThroughRepositoryFactory)(meta, targetRepositoryGetter, throughRepositoryGetter);
+    }
+    /**
+     * Function to create a references many accessor
+     *
+     * @param relationName - Name of the relation defined on the source model
+     * @param targetRepo - Target repository instance
+     */
+    createReferencesManyAccessorFor(relationName, targetRepoGetter) {
+        const meta = this.entityClass.definition.relations[relationName];
+        return (0, repository_1.createReferencesManyAccessor)(meta, targetRepoGetter, this);
+    }
+}
+exports.SequelizeCrudRepository = SequelizeCrudRepository;
+//# sourceMappingURL=sequelize.repository.base.js.map