@strapi/database 5.12.1 → 5.12.2

package/dist/entity-manager/index.js

@@ -0,0 +1,1186 @@
+'use strict';
+
+var _ = require('lodash/fp');
+var types = require('../utils/types.js');
+var index = require('../fields/index.js');
+var queryBuilder = require('../query/query-builder.js');
+var entityRepository = require('./entity-repository.js');
+var morphRelations = require('./morph-relations.js');
+var relations = require('../metadata/relations.js');
+require('../utils/identifiers/index.js');
+var regularRelations = require('./regular-relations.js');
+var relationsOrderer = require('./relations-orderer.js');
+
+const isRecord = (value)=>_.isObject(value) && !_.isNil(value);
+const toId = (value)=>{
+    if (isRecord(value) && 'id' in value && isValidId(value.id)) {
+        return value.id;
+    }
+    if (isValidId(value)) {
+        return value;
+    }
+    throw new Error(`Invalid id, expected a string or integer, got ${JSON.stringify(value)}`);
+};
+const toIds = (value)=>_.castArray(value || []).map(toId);
+const isValidId = (value)=>_.isString(value) || _.isInteger(value);
+const isValidObjectId = (value)=>isRecord(value) && 'id' in value && isValidId(value.id);
+const toIdArray = (data)=>{
+    const array = _.castArray(data).filter((datum)=>!_.isNil(datum)).map((datum)=>{
+        // if it is a string or an integer return an obj with id = to datum
+        if (isValidId(datum)) {
+            return {
+                id: datum,
+                __pivot: {}
+            };
+        }
+        // if it is an object check it has at least a valid id
+        if (!isValidObjectId(datum)) {
+            throw new Error(`Invalid id, expected a string or integer, got ${datum}`);
+        }
+        return datum;
+    });
+    return _.uniqWith(_.isEqual, array);
+};
+const toAssocs = (data)=>{
+    if (_.isArray(data) || _.isString(data) || _.isNumber(data) || _.isNull(data) || isRecord(data) && 'id' in data) {
+        return {
+            set: _.isNull(data) ? data : toIdArray(data)
+        };
+    }
+    if (data?.set) {
+        return {
+            set: _.isNull(data.set) ? data.set : toIdArray(data.set)
+        };
+    }
+    return {
+        options: {
+            strict: data?.options?.strict
+        },
+        connect: toIdArray(data?.connect).map((elm)=>({
+                id: elm.id,
+                position: elm.position ? elm.position : {
+                    end: true
+                },
+                __pivot: elm.__pivot ?? {},
+                __type: elm.__type
+            })),
+        disconnect: toIdArray(data?.disconnect)
+    };
+};
+const processData = (metadata, data = {}, { withDefaults = false } = {})=>{
+    const { attributes } = metadata;
+    const obj = {};
+    for (const attributeName of Object.keys(attributes)){
+        const attribute = attributes[attributeName];
+        if (types.isScalarAttribute(attribute)) {
+            const field = index.createField(attribute);
+            if (_.isUndefined(data[attributeName])) {
+                if (!_.isUndefined(attribute.default) && withDefaults) {
+                    if (typeof attribute.default === 'function') {
+                        obj[attributeName] = attribute.default();
+                    } else {
+                        obj[attributeName] = attribute.default;
+                    }
+                }
+                continue;
+            }
+            if ('validate' in field && typeof field.validate === 'function' && data[attributeName] !== null) {
+                field.validate(data[attributeName]);
+            }
+            const val = data[attributeName] === null ? null : field.toDB(data[attributeName]);
+            obj[attributeName] = val;
+        }
+        if (types.isRelationalAttribute(attribute)) {
+            // oneToOne & manyToOne
+            if ('joinColumn' in attribute && attribute.joinColumn && attribute.owner) {
+                const joinColumnName = attribute.joinColumn.name;
+                // allow setting to null
+                const attrValue = !_.isUndefined(data[attributeName]) ? data[attributeName] : data[joinColumnName];
+                if (_.isNull(attrValue)) {
+                    obj[joinColumnName] = attrValue;
+                } else if (!_.isUndefined(attrValue)) {
+                    obj[joinColumnName] = toId(attrValue);
+                }
+                continue;
+            }
+            if ('morphColumn' in attribute && attribute.morphColumn && attribute.owner) {
+                const { idColumn, typeColumn, typeField = '__type' } = attribute.morphColumn;
+                const value = data[attributeName];
+                if (value === null) {
+                    Object.assign(obj, {
+                        [idColumn.name]: null,
+                        [typeColumn.name]: null
+                    });
+                    continue;
+                }
+                if (!_.isUndefined(value)) {
+                    if (!_.has('id', value) || !_.has(typeField, value)) {
+                        throw new Error(`Expects properties ${typeField} an id to make a morph association`);
+                    }
+                    Object.assign(obj, {
+                        [idColumn.name]: value.id,
+                        [typeColumn.name]: value[typeField]
+                    });
+                }
+            }
+        }
+    }
+    return obj;
+};
+const createEntityManager = (db)=>{
+    const repoMap = {};
+    return {
+        async findOne (uid, params) {
+            const states = await db.lifecycles.run('beforeFindOne', uid, {
+                params
+            });
+            const result = await this.createQueryBuilder(uid).init(params).first().execute();
+            await db.lifecycles.run('afterFindOne', uid, {
+                params,
+                result
+            }, states);
+            return result;
+        },
+        // should we name it findOne because people are used to it ?
+        async findMany (uid, params) {
+            const states = await db.lifecycles.run('beforeFindMany', uid, {
+                params
+            });
+            const result = await this.createQueryBuilder(uid).init(params).execute();
+            await db.lifecycles.run('afterFindMany', uid, {
+                params,
+                result
+            }, states);
+            return result;
+        },
+        async count (uid, params = {}) {
+            const states = await db.lifecycles.run('beforeCount', uid, {
+                params
+            });
+            const res = await this.createQueryBuilder(uid).init(_.pick([
+                '_q',
+                'where',
+                'filters'
+            ], params)).count().first().execute();
+            const result = Number(res.count);
+            await db.lifecycles.run('afterCount', uid, {
+                params,
+                result
+            }, states);
+            return result;
+        },
+        async create (uid, params = {}) {
+            const states = await db.lifecycles.run('beforeCreate', uid, {
+                params
+            });
+            const metadata = db.metadata.get(uid);
+            const { data } = params;
+            if (!_.isPlainObject(data)) {
+                throw new Error('Create expects a data object');
+            }
+            const dataToInsert = processData(metadata, data, {
+                withDefaults: true
+            });
+            const res = await this.createQueryBuilder(uid).insert(dataToInsert).execute();
+            const id = isRecord(res[0]) ? res[0].id : res[0];
+            const trx = await strapi.db.transaction();
+            try {
+                await this.attachRelations(uid, id, data, {
+                    transaction: trx.get()
+                });
+                await trx.commit();
+            } catch (e) {
+                await trx.rollback();
+                await this.createQueryBuilder(uid).where({
+                    id
+                }).delete().execute();
+                throw e;
+            }
+            // TODO: in case there is no select or populate specified return the inserted data ?
+            // TODO: do not trigger the findOne lifecycles ?
+            const result = await this.findOne(uid, {
+                where: {
+                    id
+                },
+                select: params.select,
+                populate: params.populate,
+                filters: params.filters
+            });
+            await db.lifecycles.run('afterCreate', uid, {
+                params,
+                result
+            }, states);
+            return result;
+        },
+        // TODO: where do we handle relation processing for many queries ?
+        async createMany (uid, params = {}) {
+            const states = await db.lifecycles.run('beforeCreateMany', uid, {
+                params
+            });
+            const metadata = db.metadata.get(uid);
+            const { data } = params;
+            if (!_.isArray(data)) {
+                throw new Error('CreateMany expects data to be an array');
+            }
+            const dataToInsert = data.map((datum)=>processData(metadata, datum, {
+                    withDefaults: true
+                }));
+            if (_.isEmpty(dataToInsert)) {
+                throw new Error('Nothing to insert');
+            }
+            const createdEntries = await this.createQueryBuilder(uid).insert(dataToInsert).execute();
+            const result = {
+                count: data.length,
+                ids: createdEntries.map((entry)=>typeof entry === 'object' ? entry?.id : entry)
+            };
+            await db.lifecycles.run('afterCreateMany', uid, {
+                params,
+                result
+            }, states);
+            return result;
+        },
+        async update (uid, params = {}) {
+            const states = await db.lifecycles.run('beforeUpdate', uid, {
+                params
+            });
+            const metadata = db.metadata.get(uid);
+            const { where, data } = params;
+            if (!_.isPlainObject(data)) {
+                throw new Error('Update requires a data object');
+            }
+            if (_.isEmpty(where)) {
+                throw new Error('Update requires a where parameter');
+            }
+            const entity = await this.createQueryBuilder(uid).select('*').where(where).first().execute({
+                mapResults: false
+            });
+            if (!entity) {
+                return null;
+            }
+            const { id } = entity;
+            const dataToUpdate = processData(metadata, data);
+            if (!_.isEmpty(dataToUpdate)) {
+                await this.createQueryBuilder(uid).where({
+                    id
+                }).update(dataToUpdate).execute();
+            }
+            const trx = await strapi.db.transaction();
+            try {
+                await this.updateRelations(uid, id, data, {
+                    transaction: trx.get()
+                });
+                await trx.commit();
+            } catch (e) {
+                await trx.rollback();
+                await this.createQueryBuilder(uid).where({
+                    id
+                }).update(entity).execute();
+                throw e;
+            }
+            // TODO: do not trigger the findOne lifecycles ?
+            const result = await this.findOne(uid, {
+                where: {
+                    id
+                },
+                select: params.select,
+                populate: params.populate,
+                filters: params.filters
+            });
+            await db.lifecycles.run('afterUpdate', uid, {
+                params,
+                result
+            }, states);
+            return result;
+        },
+        // TODO: where do we handle relation processing for many queries ?
+        async updateMany (uid, params = {}) {
+            const states = await db.lifecycles.run('beforeUpdateMany', uid, {
+                params
+            });
+            const metadata = db.metadata.get(uid);
+            const { where, data } = params;
+            const dataToUpdate = processData(metadata, data);
+            if (_.isEmpty(dataToUpdate)) {
+                throw new Error('Update requires data');
+            }
+            const updatedRows = await this.createQueryBuilder(uid).where(where).update(dataToUpdate).execute();
+            const result = {
+                count: updatedRows
+            };
+            await db.lifecycles.run('afterUpdateMany', uid, {
+                params,
+                result
+            }, states);
+            return result;
+        },
+        async delete (uid, params = {}) {
+            const states = await db.lifecycles.run('beforeDelete', uid, {
+                params
+            });
+            const { where, select, populate } = params;
+            if (_.isEmpty(where)) {
+                throw new Error('Delete requires a where parameter');
+            }
+            // TODO: do not trigger the findOne lifecycles ?
+            const entity = await this.findOne(uid, {
+                select: select && [
+                    'id'
+                ].concat(select),
+                where,
+                populate
+            });
+            if (!entity) {
+                return null;
+            }
+            const { id } = entity;
+            await this.createQueryBuilder(uid).where({
+                id
+            }).delete().execute();
+            const trx = await strapi.db.transaction();
+            try {
+                await this.deleteRelations(uid, id, {
+                    transaction: trx.get()
+                });
+                await trx.commit();
+            } catch (e) {
+                await trx.rollback();
+                throw e;
+            }
+            await db.lifecycles.run('afterDelete', uid, {
+                params,
+                result: entity
+            }, states);
+            return entity;
+        },
+        // TODO: where do we handle relation processing for many queries ?
+        async deleteMany (uid, params = {}) {
+            const states = await db.lifecycles.run('beforeDeleteMany', uid, {
+                params
+            });
+            const { where } = params;
+            const deletedRows = await this.createQueryBuilder(uid).where(where).delete().execute({
+                mapResults: false
+            });
+            const result = {
+                count: deletedRows
+            };
+            await db.lifecycles.run('afterDeleteMany', uid, {
+                params,
+                result
+            }, states);
+            return result;
+        },
+        /**
+     * Attach relations to a new entity
+     */ async attachRelations (uid, id, data, options) {
+            const { attributes } = db.metadata.get(uid);
+            const { transaction: trx } = options ?? {};
+            for (const attributeName of Object.keys(attributes)){
+                const attribute = attributes[attributeName];
+                const isValidLink = _.has(attributeName, data) && !_.isNil(data[attributeName]);
+                if (attribute.type !== 'relation' || !isValidLink) {
+                    continue;
+                }
+                const cleanRelationData = toAssocs(data[attributeName]);
+                if (attribute.relation === 'morphOne' || attribute.relation === 'morphMany') {
+                    /**
+           * morphOne and morphMany relations
+           */ const { target, morphBy } = attribute;
+                    const targetAttribute = db.metadata.get(target).attributes[morphBy];
+                    if (targetAttribute.type !== 'relation') {
+                        throw new Error(`Expected target attribute ${target}.${morphBy} to be a relation attribute`);
+                    }
+                    if (targetAttribute.relation === 'morphToOne') {
+                        // set columns
+                        const { idColumn, typeColumn } = targetAttribute.morphColumn;
+                        const relId = toId(cleanRelationData.set?.[0]);
+                        await this.createQueryBuilder(target).update({
+                            [idColumn.name]: id,
+                            [typeColumn.name]: uid
+                        }).where({
+                            id: relId
+                        }).transacting(trx).execute();
+                    } else if (targetAttribute.relation === 'morphToMany') {
+                        const { joinTable } = targetAttribute;
+                        const { joinColumn, morphColumn } = joinTable;
+                        const { idColumn, typeColumn } = morphColumn;
+                        if (_.isEmpty(cleanRelationData.set)) {
+                            continue;
+                        }
+                        const rows = cleanRelationData.set?.map((data, idx)=>{
+                            return {
+                                [joinColumn.name]: data.id,
+                                [idColumn.name]: id,
+                                [typeColumn.name]: uid,
+                                ...'on' in joinTable && joinTable.on || {},
+                                ...data.__pivot || {},
+                                order: idx + 1,
+                                field: attributeName
+                            };
+                        }) ?? [];
+                        await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
+                    }
+                    continue;
+                } else if (attribute.relation === 'morphToOne') {
+                    continue;
+                } else if (attribute.relation === 'morphToMany') {
+                    /**
+           * morphToMany
+           */ const { joinTable } = attribute;
+                    const { joinColumn, morphColumn } = joinTable;
+                    const { idColumn, typeColumn, typeField = '__type' } = morphColumn;
+                    if (_.isEmpty(cleanRelationData.set) && _.isEmpty(cleanRelationData.connect)) {
+                        continue;
+                    }
+                    // set happens before connect/disconnect
+                    const dataset = cleanRelationData.set || cleanRelationData.connect || [];
+                    const rows = dataset.map((data, idx)=>({
+                            [joinColumn.name]: id,
+                            [idColumn.name]: data.id,
+                            [typeColumn.name]: data[typeField],
+                            ...'on' in joinTable && joinTable.on || {},
+                            ...data.__pivot || {},
+                            order: idx + 1
+                        }));
+                    const orderMap = relationsOrderer.relationsOrderer([], morphColumn.idColumn.name, 'order', true // Always make a strict connect when inserting
+                    ).connect(// Merge id & __type to get a single id key
+                    dataset.map(morphRelations.encodePolymorphicRelation({
+                        idColumn: 'id',
+                        typeColumn: typeField
+                    }))).get()// set the order based on the order of the ids
+                    .reduce((acc, rel, idx)=>({
+                            ...acc,
+                            [rel.id]: idx + 1
+                        }), {});
+                    rows.forEach((row)=>{
+                        const rowId = row[morphColumn.idColumn.name];
+                        const rowType = row[morphColumn.typeColumn.name];
+                        const encodedId = morphRelations.encodePolymorphicId(rowId, rowType);
+                        row.order = orderMap[encodedId];
+                    });
+                    // delete previous relations
+                    await morphRelations.deleteRelatedMorphOneRelationsAfterMorphToManyUpdate(rows, {
+                        uid,
+                        attributeName,
+                        joinTable,
+                        db,
+                        transaction: trx
+                    });
+                    await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
+                    continue;
+                }
+                if ('joinColumn' in attribute && attribute.joinColumn && attribute.owner) {
+                    const relIdsToAdd = toIds(cleanRelationData.set);
+                    if (attribute.relation === 'oneToOne' && relations.isBidirectional(attribute) && relIdsToAdd.length) {
+                        await this.createQueryBuilder(uid).where({
+                            [attribute.joinColumn.name]: relIdsToAdd,
+                            id: {
+                                $ne: id
+                            }
+                        }).update({
+                            [attribute.joinColumn.name]: null
+                        }).transacting(trx).execute();
+                    }
+                    continue;
+                }
+                // oneToOne oneToMany on the non owning side
+                if ('joinColumn' in attribute && attribute.joinColumn && !attribute.owner) {
+                    // need to set the column on the target
+                    const { target } = attribute;
+                    // TODO: check it is an id & the entity exists (will throw due to FKs otherwise so not a big pbl in SQL)
+                    const relIdsToAdd = toIds(cleanRelationData.set);
+                    await this.createQueryBuilder(target).where({
+                        [attribute.joinColumn.referencedColumn]: id
+                    }).update({
+                        [attribute.joinColumn.referencedColumn]: null
+                    }).transacting(trx).execute();
+                    await this.createQueryBuilder(target).update({
+                        [attribute.joinColumn.referencedColumn]: id
+                    })// NOTE: works if it is an array or a single id
+                    .where({
+                        id: relIdsToAdd
+                    }).transacting(trx).execute();
+                }
+                if ('joinTable' in attribute && attribute.joinTable) {
+                    // need to set the column on the target
+                    const { joinTable } = attribute;
+                    const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } = joinTable;
+                    const relsToAdd = (cleanRelationData.set || cleanRelationData.connect) ?? [];
+                    const relIdsToadd = toIds(relsToAdd);
+                    if (relations.isBidirectional(attribute) && relations.isOneToAny(attribute)) {
+                        await regularRelations.deletePreviousOneToAnyRelations({
+                            id,
+                            attribute,
+                            relIdsToadd,
+                            db,
+                            transaction: trx
+                        });
+                    }
+                    // prepare new relations to insert
+                    const insert = _.uniqBy('id', relsToAdd).map((data)=>{
+                        return {
+                            [joinColumn.name]: id,
+                            [inverseJoinColumn.name]: data.id,
+                            ...'on' in joinTable && joinTable.on || {},
+                            ...data.__pivot || {}
+                        };
+                    });
+                    // add order value
+                    if (cleanRelationData.set && relations.hasOrderColumn(attribute)) {
+                        insert.forEach((data, idx)=>{
+                            data[orderColumnName] = idx + 1;
+                        });
+                    } else if (cleanRelationData.connect && relations.hasOrderColumn(attribute)) {
+                        // use position attributes to calculate order
+                        const orderMap = relationsOrderer.relationsOrderer([], inverseJoinColumn.name, joinTable.orderColumnName, true // Always make an strict connect when inserting
+                        ).connect(relsToAdd).get()// set the order based on the order of the ids
+                        .reduce((acc, rel, idx)=>({
+                                ...acc,
+                                [rel.id]: idx
+                            }), {});
+                        insert.forEach((row)=>{
+                            row[orderColumnName] = orderMap[row[inverseJoinColumn.name]];
+                        });
+                    }
+                    // add inv_order value
+                    if (relations.hasInverseOrderColumn(attribute)) {
+                        const maxResults = await db.getConnection().select(inverseJoinColumn.name).max(inverseOrderColumnName, {
+                            as: 'max'
+                        }).whereIn(inverseJoinColumn.name, relIdsToadd).where(joinTable.on || {}).groupBy(inverseJoinColumn.name).from(joinTable.name).transacting(trx);
+                        const maxMap = maxResults.reduce((acc, res)=>Object.assign(acc, {
+                                [res[inverseJoinColumn.name]]: res.max
+                            }), {});
+                        insert.forEach((rel)=>{
+                            rel[inverseOrderColumnName] = (maxMap[rel[inverseJoinColumn.name]] || 0) + 1;
+                        });
+                    }
+                    if (insert.length === 0) {
+                        continue;
+                    }
+                    // insert new relations
+                    await this.createQueryBuilder(joinTable.name).insert(insert).transacting(trx).execute();
+                }
+            }
+        },
+        /**
+     * Updates relations of an existing entity
+     */ // TODO: check relation exists (handled by FKs except for polymorphics)
+        async updateRelations (uid, id, data, options) {
+            const { attributes } = db.metadata.get(uid);
+            const { transaction: trx } = options ?? {};
+            for (const attributeName of Object.keys(attributes)){
+                const attribute = attributes[attributeName];
+                if (attribute.type !== 'relation' || !_.has(attributeName, data)) {
+                    continue;
+                }
+                const cleanRelationData = toAssocs(data[attributeName]);
+                if (attribute.relation === 'morphOne' || attribute.relation === 'morphMany') {
+                    const { target, morphBy } = attribute;
+                    const targetAttribute = db.metadata.get(target).attributes[morphBy];
+                    if (targetAttribute.type === 'relation' && targetAttribute.relation === 'morphToOne') {
+                        // set columns
+                        const { idColumn, typeColumn } = targetAttribute.morphColumn;
+                        // update instead of deleting because the relation is directly on the entity table
+                        // and not in a join table
+                        await this.createQueryBuilder(target).update({
+                            [idColumn.name]: null,
+                            [typeColumn.name]: null
+                        }).where({
+                            [idColumn.name]: id,
+                            [typeColumn.name]: uid
+                        }).transacting(trx).execute();
+                        if (!_.isNull(cleanRelationData.set)) {
+                            const relId = toIds(cleanRelationData.set?.[0]);
+                            await this.createQueryBuilder(target).update({
+                                [idColumn.name]: id,
+                                [typeColumn.name]: uid
+                            }).where({
+                                id: relId
+                            }).transacting(trx).execute();
+                        }
+                    } else if (targetAttribute.type === 'relation' && targetAttribute.relation === 'morphToMany') {
+                        const { joinTable } = targetAttribute;
+                        const { joinColumn, morphColumn } = joinTable;
+                        const { idColumn, typeColumn } = morphColumn;
+                        const hasSet = !_.isEmpty(cleanRelationData.set);
+                        const hasConnect = !_.isEmpty(cleanRelationData.connect);
+                        const hasDisconnect = !_.isEmpty(cleanRelationData.disconnect);
+                        // for connect/disconnect without a set, only modify those relations
+                        if (!hasSet && (hasConnect || hasDisconnect)) {
+                            // delete disconnects and connects (to prevent duplicates when we add them later)
+                            const idsToDelete = [
+                                ...cleanRelationData.disconnect || [],
+                                ...cleanRelationData.connect || []
+                            ];
+                            if (!_.isEmpty(idsToDelete)) {
+                                const where = {
+                                    $or: idsToDelete.map((item)=>{
+                                        return {
+                                            [idColumn.name]: id,
+                                            [typeColumn.name]: uid,
+                                            [joinColumn.name]: item.id,
+                                            ...joinTable.on || {},
+                                            field: attributeName
+                                        };
+                                    })
+                                };
+                                await this.createQueryBuilder(joinTable.name).delete().where(where).transacting(trx).execute();
+                            }
+                            // connect relations
+                            if (hasConnect) {
+                                // Query database to find the order of the last relation
+                                const start = await this.createQueryBuilder(joinTable.name).where({
+                                    [idColumn.name]: id,
+                                    [typeColumn.name]: uid,
+                                    ...joinTable.on || {},
+                                    ...data.__pivot || {}
+                                }).max('order').first().transacting(trx).execute();
+                                const startOrder = start?.max || 0;
+                                const rows = (cleanRelationData.connect ?? []).map((data, idx)=>({
+                                        [joinColumn.name]: data.id,
+                                        [idColumn.name]: id,
+                                        [typeColumn.name]: uid,
+                                        ...joinTable.on || {},
+                                        ...data.__pivot || {},
+                                        order: startOrder + idx + 1,
+                                        field: attributeName
+                                    }));
+                                await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
+                            }
+                            continue;
+                        }
+                        // delete all relations
+                        await this.createQueryBuilder(joinTable.name).delete().where({
+                            [idColumn.name]: id,
+                            [typeColumn.name]: uid,
+                            ...joinTable.on || {},
+                            field: attributeName
+                        }).transacting(trx).execute();
+                        if (hasSet) {
+                            const rows = (cleanRelationData.set ?? []).map((data, idx)=>({
+                                    [joinColumn.name]: data.id,
+                                    [idColumn.name]: id,
+                                    [typeColumn.name]: uid,
+                                    ...joinTable.on || {},
+                                    ...data.__pivot || {},
+                                    order: idx + 1,
+                                    field: attributeName
+                                }));
+                            await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
+                        }
+                    }
+                    continue;
+                }
+                if (attribute.relation === 'morphToOne') {
+                    continue;
+                }
+                if (attribute.relation === 'morphToMany') {
+                    const { joinTable } = attribute;
+                    const { joinColumn, morphColumn } = joinTable;
+                    const { idColumn, typeColumn, typeField = '__type' } = morphColumn;
+                    const hasSet = !_.isEmpty(cleanRelationData.set);
+                    const hasConnect = !_.isEmpty(cleanRelationData.connect);
+                    const hasDisconnect = !_.isEmpty(cleanRelationData.disconnect);
+                    // for connect/disconnect without a set, only modify those relations
+                    if (!hasSet && (hasConnect || hasDisconnect)) {
+                        // delete disconnects and connects (to prevent duplicates when we add them later)
+                        const idsToDelete = [
+                            ...cleanRelationData.disconnect || [],
+                            ...cleanRelationData.connect || []
+                        ];
+                        const rowsToDelete = [
+                            ...(cleanRelationData.disconnect ?? []).map((data, idx)=>({
+                                    [joinColumn.name]: id,
+                                    [idColumn.name]: data.id,
+                                    [typeColumn.name]: data[typeField],
+                                    ...'on' in joinTable && joinTable.on || {},
+                                    ...data.__pivot || {},
+                                    order: idx + 1
+                                })),
+                            ...(cleanRelationData.connect ?? []).map((data, idx)=>({
+                                    [joinColumn.name]: id,
+                                    [idColumn.name]: data.id,
+                                    // @ts-expect-error TODO
+                                    [typeColumn.name]: data[typeField],
+                                    ...'on' in joinTable && joinTable.on || {},
+                                    ...data.__pivot || {},
+                                    order: idx + 1
+                                }))
+                        ];
+                        const adjacentRelations = await this.createQueryBuilder(joinTable.name).where({
+                            $or: [
+                                {
+                                    [joinColumn.name]: id,
+                                    [idColumn.name]: {
+                                        $in: _.compact(cleanRelationData.connect?.map((r)=>r.position?.after || r.position?.before))
+                                    }
+                                },
+                                {
+                                    [joinColumn.name]: id,
+                                    order: this.createQueryBuilder(joinTable.name).max('order').where({
+                                        [joinColumn.name]: id
+                                    }).where(joinTable.on || {}).transacting(trx).getKnexQuery()
+                                }
+                            ]
+                        }).where(joinTable.on || {}).transacting(trx).execute();
+                        if (!_.isEmpty(idsToDelete)) {
+                            const where = {
+                                $or: idsToDelete.map((item)=>{
+                                    return {
+                                        [idColumn.name]: item.id,
+                                        [typeColumn.name]: item[typeField],
+                                        [joinColumn.name]: id,
+                                        ...joinTable.on || {}
+                                    };
+                                })
+                            };
+                            // delete previous relations
+                            await this.createQueryBuilder(joinTable.name).delete().where(where).transacting(trx).execute();
+                            await morphRelations.deleteRelatedMorphOneRelationsAfterMorphToManyUpdate(rowsToDelete, {
+                                uid,
+                                attributeName,
+                                joinTable,
+                                db,
+                                transaction: trx
+                            });
+                        }
+                        // connect relations
+                        if (hasConnect) {
+                            const dataset = cleanRelationData.connect || [];
+                            const rows = dataset.map((data)=>({
+                                    [joinColumn.name]: id,
+                                    [idColumn.name]: data.id,
+                                    [typeColumn.name]: data[typeField],
+                                    ...joinTable.on || {},
+                                    ...data.__pivot || {},
+                                    field: attributeName
+                                }));
+                            const orderMap = relationsOrderer.relationsOrderer(// Merge id & __type to get a single id key
+                            adjacentRelations.map(morphRelations.encodePolymorphicRelation({
+                                idColumn: idColumn.name,
+                                typeColumn: typeColumn.name
+                            })), idColumn.name, 'order', cleanRelationData.options?.strict).connect(// Merge id & __type to get a single id key
+                            dataset.map(morphRelations.encodePolymorphicRelation({
+                                idColumn: 'id',
+                                typeColumn: '__type'
+                            }))).getOrderMap();
+                            rows.forEach((row)=>{
+                                const rowId = row[idColumn.name];
+                                const rowType = row[typeColumn.name];
+                                const encodedId = morphRelations.encodePolymorphicId(rowId, rowType);
+                                row.order = orderMap[encodedId];
+                            });
+                            await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
+                        }
+                        continue;
+                    }
+                    if (hasSet) {
+                        // delete all relations for this entity
+                        await this.createQueryBuilder(joinTable.name).delete().where({
+                            [joinColumn.name]: id,
+                            ...joinTable.on || {}
+                        }).transacting(trx).execute();
+                        const rows = (cleanRelationData.set ?? []).map((data, idx)=>({
+                                [joinColumn.name]: id,
+                                [idColumn.name]: data.id,
+                                [typeColumn.name]: data[typeField],
+                                field: attributeName,
+                                ...joinTable.on || {},
+                                ...data.__pivot || {},
+                                order: idx + 1
+                            }));
+                        await morphRelations.deleteRelatedMorphOneRelationsAfterMorphToManyUpdate(rows, {
+                            uid,
+                            attributeName,
+                            joinTable,
+                            db,
+                            transaction: trx
+                        });
+                        await this.createQueryBuilder(joinTable.name).insert(rows).transacting(trx).execute();
+                    }
+                    continue;
+                }
+                if ('joinColumn' in attribute && attribute.joinColumn && attribute.owner) {
+                    continue;
+                }
+                // oneToOne oneToMany on the non owning side.
+                // Since it is a join column no need to remove previous relations
+                if ('joinColumn' in attribute && attribute.joinColumn && !attribute.owner) {
+                    // need to set the column on the target
+                    const { target } = attribute;
+                    await this.createQueryBuilder(target).where({
+                        [attribute.joinColumn.referencedColumn]: id
+                    }).update({
+                        [attribute.joinColumn.referencedColumn]: null
+                    }).transacting(trx).execute();
+                    if (!_.isNull(cleanRelationData.set)) {
+                        const relIdsToAdd = toIds(cleanRelationData.set);
+                        await this.createQueryBuilder(target).where({
+                            id: relIdsToAdd
+                        }).update({
+                            [attribute.joinColumn.referencedColumn]: id
+                        }).transacting(trx).execute();
+                    }
+                }
+                if (attribute.joinTable) {
+                    const { joinTable } = attribute;
+                    const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } = joinTable;
+                    const select = [
+                        joinColumn.name,
+                        inverseJoinColumn.name
+                    ];
+                    if (relations.hasOrderColumn(attribute)) {
+                        select.push(orderColumnName);
+                    }
+                    if (relations.hasInverseOrderColumn(attribute)) {
+                        select.push(inverseOrderColumnName);
+                    }
+                    // only delete relations
+                    if (_.isNull(cleanRelationData.set)) {
+                        await regularRelations.deleteRelations({
+                            id,
+                            attribute,
+                            db,
+                            relIdsToDelete: 'all',
+                            transaction: trx
+                        });
+                    } else {
+                        const isPartialUpdate = !_.has('set', cleanRelationData);
+                        let relIdsToaddOrMove;
+                        if (isPartialUpdate) {
+                            if (relations.isAnyToOne(attribute)) ;
+                            relIdsToaddOrMove = toIds(cleanRelationData.connect);
+                            const relIdsToDelete = toIds(_.differenceWith(_.isEqual, cleanRelationData.disconnect, cleanRelationData.connect ?? []));
+                            if (!_.isEmpty(relIdsToDelete)) {
+                                await regularRelations.deleteRelations({
+                                    id,
+                                    attribute,
+                                    db,
+                                    relIdsToDelete,
+                                    transaction: trx
+                                });
+                            }
+                            if (_.isEmpty(cleanRelationData.connect)) {
+                                continue;
+                            }
+                            // Fetch current relations to handle ordering
+                            let currentMovingRels = [];
+                            if (relations.hasOrderColumn(attribute) || relations.hasInverseOrderColumn(attribute)) {
+                                currentMovingRels = await this.createQueryBuilder(joinTable.name).select(select).where({
+                                    [joinColumn.name]: id,
+                                    [inverseJoinColumn.name]: {
+                                        $in: relIdsToaddOrMove
+                                    }
+                                }).where(joinTable.on || {}).transacting(trx).execute();
+                            }
+                            // prepare relations to insert
+                            const insert = _.uniqBy('id', cleanRelationData.connect).map((relToAdd)=>({
+                                    [joinColumn.name]: id,
+                                    [inverseJoinColumn.name]: relToAdd.id,
+                                    ...joinTable.on || {},
+                                    ...relToAdd.__pivot || {}
+                                }));
+                            if (relations.hasOrderColumn(attribute)) {
+                                // Get all adjacent relations and the one with the highest order
+                                const adjacentRelations = await this.createQueryBuilder(joinTable.name).where({
+                                    $or: [
+                                        {
+                                            [joinColumn.name]: id,
+                                            [inverseJoinColumn.name]: {
+                                                $in: _.compact(cleanRelationData.connect?.map((r)=>r.position?.after || r.position?.before))
+                                            }
+                                        },
+                                        {
+                                            [joinColumn.name]: id,
+                                            [orderColumnName]: this.createQueryBuilder(joinTable.name).max(orderColumnName).where({
+                                                [joinColumn.name]: id
+                                            }).where(joinTable.on || {}).transacting(trx).getKnexQuery()
+                                        }
+                                    ]
+                                }).where(joinTable.on || {}).transacting(trx).execute();
+                                const orderMap = relationsOrderer.relationsOrderer(adjacentRelations, inverseJoinColumn.name, joinTable.orderColumnName, cleanRelationData.options?.strict).connect(cleanRelationData.connect ?? []).getOrderMap();
+                                insert.forEach((row)=>{
+                                    row[orderColumnName] = orderMap[row[inverseJoinColumn.name]];
+                                });
+                            }
+                            // add inv order value
+                            if (relations.hasInverseOrderColumn(attribute)) {
+                                const nonExistingRelsIds = _.difference(relIdsToaddOrMove, _.map(inverseJoinColumn.name, currentMovingRels));
+                                const maxResults = await db.getConnection().select(inverseJoinColumn.name).max(inverseOrderColumnName, {
+                                    as: 'max'
+                                }).whereIn(inverseJoinColumn.name, nonExistingRelsIds).where(joinTable.on || {}).groupBy(inverseJoinColumn.name).from(joinTable.name).transacting(trx);
+                                const maxMap = maxResults.reduce((acc, res)=>Object.assign(acc, {
+                                        [res[inverseJoinColumn.name]]: res.max
+                                    }), {});
+                                insert.forEach((row)=>{
+                                    row[inverseOrderColumnName] = (maxMap[row[inverseJoinColumn.name]] || 0) + 1;
+                                });
+                            }
+                            // insert rows
+                            const query = this.createQueryBuilder(joinTable.name).insert(insert).onConflict(joinTable.pivotColumns).transacting(trx);
+                            if (relations.hasOrderColumn(attribute)) {
+                                query.merge([
+                                    orderColumnName
+                                ]);
+                            } else {
+                                query.ignore();
+                            }
+                            await query.execute();
+                            // remove gap between orders
+                            await regularRelations.cleanOrderColumns({
+                                attribute,
+                                db,
+                                id,
+                                transaction: trx
+                            });
+                        } else {
+                            if (relations.isAnyToOne(attribute)) {
+                                cleanRelationData.set = cleanRelationData.set?.slice(-1);
+                            }
+                            // overwrite all relations
+                            relIdsToaddOrMove = toIds(cleanRelationData.set);
+                            await regularRelations.deleteRelations({
+                                id,
+                                attribute,
+                                db,
+                                relIdsToDelete: 'all',
+                                relIdsToNotDelete: relIdsToaddOrMove,
+                                transaction: trx
+                            });
+                            if (_.isEmpty(cleanRelationData.set)) {
+                                continue;
+                            }
+                            const insert = _.uniqBy('id', cleanRelationData.set).map((relToAdd)=>({
+                                    [joinColumn.name]: id,
+                                    [inverseJoinColumn.name]: relToAdd.id,
+                                    ...joinTable.on || {},
+                                    ...relToAdd.__pivot || {}
+                                }));
+                            // add order value
+                            if (relations.hasOrderColumn(attribute)) {
+                                insert.forEach((row, idx)=>{
+                                    row[orderColumnName] = idx + 1;
+                                });
+                            }
+                            // add inv order value
+                            if (relations.hasInverseOrderColumn(attribute)) {
+                                const existingRels = await this.createQueryBuilder(joinTable.name).select(inverseJoinColumn.name).where({
+                                    [joinColumn.name]: id,
+                                    [inverseJoinColumn.name]: {
+                                        $in: relIdsToaddOrMove
+                                    }
+                                }).where(joinTable.on || {}).transacting(trx).execute();
+                                const inverseRelsIds = _.map(inverseJoinColumn.name, existingRels);
+                                const nonExistingRelsIds = _.difference(relIdsToaddOrMove, inverseRelsIds);
+                                const maxResults = await db.getConnection().select(inverseJoinColumn.name).max(inverseOrderColumnName, {
+                                    as: 'max'
+                                }).whereIn(inverseJoinColumn.name, nonExistingRelsIds).where(joinTable.on || {}).groupBy(inverseJoinColumn.name).from(joinTable.name).transacting(trx);
+                                const maxMap = maxResults.reduce((acc, res)=>Object.assign(acc, {
+                                        [res[inverseJoinColumn.name]]: res.max
+                                    }), {});
+                                insert.forEach((row)=>{
+                                    row[inverseOrderColumnName] = (maxMap[row[inverseJoinColumn.name]] || 0) + 1;
+                                });
+                            }
+                            // insert rows
+                            const query = this.createQueryBuilder(joinTable.name).insert(insert).onConflict(joinTable.pivotColumns).transacting(trx);
+                            if (relations.hasOrderColumn(attribute)) {
+                                query.merge([
+                                    orderColumnName
+                                ]);
+                            } else {
+                                query.ignore();
+                            }
+                            await query.execute();
+                        }
+                        // Delete the previous relations for oneToAny relations
+                        if (relations.isBidirectional(attribute) && relations.isOneToAny(attribute)) {
+                            await regularRelations.deletePreviousOneToAnyRelations({
+                                id,
+                                attribute,
+                                relIdsToadd: relIdsToaddOrMove,
+                                db,
+                                transaction: trx
+                            });
+                        }
+                        // Delete the previous relations for anyToOne relations
+                        if (relations.isAnyToOne(attribute)) {
+                            await regularRelations.deletePreviousAnyToOneRelations({
+                                id,
+                                attribute,
+                                relIdToadd: relIdsToaddOrMove[0],
+                                db,
+                                transaction: trx
+                            });
+                        }
+                    }
+                }
+            }
+        },
+        /**
+     * Delete relational associations of an existing entity
+     * This removes associations but doesn't do cascade deletions for components for example. This will be handled on the entity service layer instead
+     * NOTE: Most of the deletion should be handled by ON DELETE CASCADE for dialects that have FKs
+     *
+     * @param {EntityManager} em - entity manager instance
+     * @param {Metadata} metadata - model metadta
+     * @param {ID} id - entity ID
+     */ async deleteRelations (uid, id, options) {
+            const { attributes } = db.metadata.get(uid);
+            const { transaction: trx } = options ?? {};
+            for (const attributeName of Object.keys(attributes)){
+                const attribute = attributes[attributeName];
+                if (attribute.type !== 'relation') {
+                    continue;
+                }
+                /*
+          if morphOne | morphMany
+            if morphBy is morphToOne
+              set null
+            if morphBy is morphToOne
+              delete links
+        */ if (attribute.relation === 'morphOne' || attribute.relation === 'morphMany') {
+                    const { target, morphBy } = attribute;
+                    const targetAttribute = db.metadata.get(target).attributes[morphBy];
+                    if (targetAttribute.type === 'relation' && targetAttribute.relation === 'morphToOne') {
+                        // set columns
+                        const { idColumn, typeColumn } = targetAttribute.morphColumn;
+                        await this.createQueryBuilder(target).update({
+                            [idColumn.name]: null,
+                            [typeColumn.name]: null
+                        }).where({
+                            [idColumn.name]: id,
+                            [typeColumn.name]: uid
+                        }).transacting(trx).execute();
+                    } else if (targetAttribute.type === 'relation' && targetAttribute.relation === 'morphToMany') {
+                        const { joinTable } = targetAttribute;
+                        const { morphColumn } = joinTable;
+                        const { idColumn, typeColumn } = morphColumn;
+                        await this.createQueryBuilder(joinTable.name).delete().where({
+                            [idColumn.name]: id,
+                            [typeColumn.name]: uid,
+                            ...joinTable.on || {},
+                            field: attributeName
+                        }).transacting(trx).execute();
+                    }
+                    continue;
+                }
+                /*
+          if morphToOne
+            nothing to do
+        */ if (attribute.relation === 'morphToOne') ;
+                /*
+            if morphToMany
+            delete links
+        */ if (attribute.relation === 'morphToMany') {
+                    const { joinTable } = attribute;
+                    const { joinColumn } = joinTable;
+                    await this.createQueryBuilder(joinTable.name).delete().where({
+                        [joinColumn.name]: id,
+                        ...joinTable.on || {}
+                    }).transacting(trx).execute();
+                    continue;
+                }
+                // do not need to delete links when using foreign keys
+                if (db.dialect.usesForeignKeys()) {
+                    return;
+                }
+                // NOTE: we do not remove existing associations with the target as it should handled by unique FKs instead
+                if ('joinColumn' in attribute && attribute.joinColumn && attribute.owner) {
+                    continue;
+                }
+                // oneToOne oneToMany on the non owning side.
+                if ('joinColumn' in attribute && attribute.joinColumn && !attribute.owner) {
+                    // need to set the column on the target
+                    const { target } = attribute;
+                    await this.createQueryBuilder(target).where({
+                        [attribute.joinColumn.referencedColumn]: id
+                    }).update({
+                        [attribute.joinColumn.referencedColumn]: null
+                    }).transacting(trx).execute();
+                }
+                if ('joinTable' in attribute && attribute.joinTable) {
+                    await regularRelations.deleteRelations({
+                        id,
+                        attribute,
+                        db,
+                        relIdsToDelete: 'all',
+                        transaction: trx
+                    });
+                }
+            }
+        },
+        // TODO: add lifecycle events
+        async populate (uid, entity, populate) {
+            const entry = await this.findOne(uid, {
+                select: [
+                    'id'
+                ],
+                where: {
+                    id: entity.id
+                },
+                populate
+            });
+            return {
+                ...entity,
+                ...entry
+            };
+        },
+        // TODO: add lifecycle events
+        async load (uid, entity, fields, populate) {
+            const { attributes } = db.metadata.get(uid);
+            const fieldsArr = _.castArray(fields);
+            fieldsArr.forEach((field)=>{
+                const attribute = attributes[field];
+                if (!attribute || attribute.type !== 'relation') {
+                    throw new Error(`Invalid load. Expected ${field} to be a relational attribute`);
+                }
+            });
+            const entry = await this.findOne(uid, {
+                select: [
+                    'id'
+                ],
+                where: {
+                    id: entity.id
+                },
+                populate: fieldsArr.reduce((acc, field)=>{
+                    acc[field] = populate || true;
+                    return acc;
+                }, {})
+            });
+            if (!entry) {
+                return null;
+            }
+            if (Array.isArray(fields)) {
+                return _.pick(fields, entry);
+            }
+            return entry[fields];
+        },
+        // cascading
+        // aggregations
+        // -> avg
+        // -> min
+        // -> max
+        // -> grouping
+        // formulas
+        // custom queries
+        // utilities
+        // -> map result
+        // -> map input
+        // extra features
+        // -> virtuals
+        // -> private
+        createQueryBuilder (uid) {
+            return queryBuilder(uid, db);
+        },
+        getRepository (uid) {
+            if (!repoMap[uid]) {
+                repoMap[uid] = entityRepository.createRepository(uid, db);
+            }
+            return repoMap[uid];
+        }
+    };
+};
+
+exports.createEntityManager = createEntityManager;
+//# sourceMappingURL=index.js.map