@strapi/database 4.3.7 → 4.3.9

package/lib/{entity-manager.js → entity-manager/index.js}

@@ -1,19 +1,32 @@
 'use strict';
 
-const _ = require('lodash/fp');
-const types = require('./types');
-const { createField } = require('./fields');
-const { createQueryBuilder } = require('./query');
+const {
+  isUndefined,
+  castArray,
+  isNil,
+  has,
+  isString,
+  isInteger,
+  pick,
+  isPlainObject,
+  isEmpty,
+  isArray,
+  isNull,
+} = require('lodash/fp');
+const types = require('../types');
+const { createField } = require('../fields');
+const { createQueryBuilder } = require('../query');
 const { createRepository } = require('./entity-repository');
-const { isBidirectional, isOneToAny } = require('./metadata/relations');
+const { isBidirectional, isOneToAny } = require('../metadata/relations');
+const { deleteRelatedMorphOneRelationsAfterMorphToManyUpdate } = require('./morph-relations');
 
 const toId = (value) => value.id || value;
-const toIds = (value) => _.castArray(value || []).map(toId);
+const toIds = (value) => castArray(value || []).map(toId);
 
-const isValidId = (value) => _.isString(value) || _.isInteger(value);
+const isValidId = (value) => isString(value) || isInteger(value);
 const toAssocs = (data) => {
-  return _.castArray(data)
-    .filter((datum) => !_.isNil(datum))
+  return 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)) {
@@ -21,7 +34,7 @@ const toAssocs = (data) => {
       }
 
       // if it is an object check it has at least a valid id
-      if (!_.has('id', datum) || !isValidId(datum.id)) {
+      if (!has('id', datum) || !isValidId(datum.id)) {
         throw new Error(`Invalid id, expected a string or integer, got ${datum}`);
       }
 
@@ -34,14 +47,14 @@ const processData = (metadata, data = {}, { withDefaults = false } = {}) => {
 
   const obj = {};
 
-  for (const attributeName in attributes) {
+  for (const attributeName of Object.keys(attributes)) {
     const attribute = attributes[attributeName];
 
     if (types.isScalar(attribute.type)) {
       const field = createField(attribute);
 
-      if (_.isUndefined(data[attributeName])) {
-        if (!_.isUndefined(attribute.default) && withDefaults) {
+      if (isUndefined(data[attributeName])) {
+        if (!isUndefined(attribute.default) && withDefaults) {
           if (typeof attribute.default === 'function') {
             obj[attributeName] = attribute.default();
           } else {
@@ -66,11 +79,11 @@ const processData = (metadata, data = {}, { withDefaults = false } = {}) => {
         const joinColumnName = attribute.joinColumn.name;
 
         // allow setting to null
-        const attrValue = !_.isUndefined(data[attributeName])
+        const attrValue = !isUndefined(data[attributeName])
           ? data[attributeName]
           : data[joinColumnName];
 
-        if (!_.isUndefined(attrValue)) {
+        if (!isUndefined(attrValue)) {
           obj[joinColumnName] = attrValue;
         }
 
@@ -91,8 +104,8 @@ const processData = (metadata, data = {}, { withDefaults = false } = {}) => {
           continue;
         }
 
-        if (!_.isUndefined(value)) {
-          if (!_.has('id', value) || !_.has(typeField, value)) {
+        if (!isUndefined(value)) {
+          if (!has('id', value) || !has(typeField, value)) {
             throw new Error(`Expects properties ${typeField} an id to make a morph association`);
           }
 
@@ -137,7 +150,7 @@ const createEntityManager = (db) => {
       const states = await db.lifecycles.run('beforeCount', uid, { params });
 
       const res = await this.createQueryBuilder(uid)
-        .init(_.pick(['_q', 'where', 'filters'], params))
+        .init(pick(['_q', 'where', 'filters'], params))
         .count()
         .first()
         .execute();
@@ -155,7 +168,7 @@ const createEntityManager = (db) => {
       const metadata = db.metadata.get(uid);
       const { data } = params;
 
-      if (!_.isPlainObject(data)) {
+      if (!isPlainObject(data)) {
         throw new Error('Create expects a data object');
       }
 
@@ -187,7 +200,7 @@ const createEntityManager = (db) => {
       const metadata = db.metadata.get(uid);
       const { data } = params;
 
-      if (!_.isArray(data)) {
+      if (!isArray(data)) {
         throw new Error('CreateMany expects data to be an array');
       }
 
@@ -195,7 +208,7 @@ const createEntityManager = (db) => {
         processData(metadata, datum, { withDefaults: true })
       );
 
-      if (_.isEmpty(dataToInsert)) {
+      if (isEmpty(dataToInsert)) {
         throw new Error('Nothing to insert');
       }
 
@@ -214,11 +227,11 @@ const createEntityManager = (db) => {
       const metadata = db.metadata.get(uid);
       const { where, data } = params;
 
-      if (!_.isPlainObject(data)) {
+      if (!isPlainObject(data)) {
         throw new Error('Update requires a data object');
       }
 
-      if (_.isEmpty(where)) {
+      if (isEmpty(where)) {
         throw new Error('Update requires a where parameter');
       }
 
@@ -232,7 +245,7 @@ const createEntityManager = (db) => {
 
       const dataToUpdate = processData(metadata, data);
 
-      if (!_.isEmpty(dataToUpdate)) {
+      if (!isEmpty(dataToUpdate)) {
         await this.createQueryBuilder(uid).where({ id }).update(dataToUpdate).execute();
       }
 
@@ -259,7 +272,7 @@ const createEntityManager = (db) => {
 
       const dataToUpdate = processData(metadata, data);
 
-      if (_.isEmpty(dataToUpdate)) {
+      if (isEmpty(dataToUpdate)) {
         throw new Error('Update requires data');
       }
 
@@ -280,7 +293,7 @@ const createEntityManager = (db) => {
 
       const { where, select, populate } = params;
 
-      if (_.isEmpty(where)) {
+      if (isEmpty(where)) {
         throw new Error('Delete requires a where parameter');
       }
 
@@ -333,10 +346,10 @@ const createEntityManager = (db) => {
     async attachRelations(uid, id, data) {
       const { attributes } = db.metadata.get(uid);
 
-      for (const attributeName in attributes) {
+      for (const attributeName of Object.keys(attributes)) {
         const attribute = attributes[attributeName];
 
-        const isValidLink = _.has(attributeName, data) && !_.isNil(data[attributeName]);
+        const isValidLink = has(attributeName, data) && !isNil(data[attributeName]);
 
         if (attribute.type !== 'relation' || !isValidLink) {
           continue;
@@ -373,7 +386,7 @@ const createEntityManager = (db) => {
               };
             });
 
-            if (_.isEmpty(rows)) {
+            if (isEmpty(rows)) {
               continue;
             }
 
@@ -398,10 +411,18 @@ const createEntityManager = (db) => {
             ...(data.__pivot || {}),
           }));
 
-          if (_.isEmpty(rows)) {
+          if (isEmpty(rows)) {
             continue;
           }
 
+          // delete previous relations
+          await deleteRelatedMorphOneRelationsAfterMorphToManyUpdate(rows, {
+            uid,
+            attributeName,
+            joinTable,
+            db,
+          });
+
           await this.createQueryBuilder(joinTable.name).insert(rows).execute();
 
           continue;
@@ -450,7 +471,7 @@ const createEntityManager = (db) => {
           if (isOneToAny(attribute) && isBidirectional(attribute)) {
             await this.createQueryBuilder(joinTable.name)
               .delete()
-              .where({ [inverseJoinColumn.name]: _.castArray(data[attributeName]) })
+              .where({ [inverseJoinColumn.name]: castArray(data[attributeName]) })
               .where(joinTable.on || {})
               .execute();
           }
@@ -487,10 +508,10 @@ const createEntityManager = (db) => {
     async updateRelations(uid, id, data) {
       const { attributes } = db.metadata.get(uid);
 
-      for (const attributeName in attributes) {
+      for (const attributeName of Object.keys(attributes)) {
         const attribute = attributes[attributeName];
 
-        if (attribute.type !== 'relation' || !_.has(attributeName, data)) {
+        if (attribute.type !== 'relation' || !has(attributeName, data)) {
           continue;
         }
 
@@ -503,12 +524,14 @@ const createEntityManager = (db) => {
             // 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 })
               .execute();
 
-            if (!_.isNull(data[attributeName])) {
+            if (!isNull(data[attributeName])) {
               await this.createQueryBuilder(target)
                 .update({ [idColumn.name]: id, [typeColumn.name]: uid })
                 .where({ id: toId(data[attributeName]) })
@@ -540,7 +563,7 @@ const createEntityManager = (db) => {
               field: attributeName,
             }));
 
-            if (_.isEmpty(rows)) {
+            if (isEmpty(rows)) {
               continue;
             }
 
@@ -577,10 +600,18 @@ const createEntityManager = (db) => {
             ...(data.__pivot || {}),
           }));
 
-          if (_.isEmpty(rows)) {
+          if (isEmpty(rows)) {
             continue;
           }
 
+          // delete previous relations
+          await deleteRelatedMorphOneRelationsAfterMorphToManyUpdate(rows, {
+            uid,
+            attributeName,
+            joinTable,
+            db,
+          });
+
           await this.createQueryBuilder(joinTable.name).insert(rows).execute();
 
           continue;
@@ -602,7 +633,7 @@ const createEntityManager = (db) => {
             .update({ [attribute.joinColumn.referencedColumn]: null })
             .execute();
 
-          if (!_.isNull(data[attributeName])) {
+          if (!isNull(data[attributeName])) {
             await this.createQueryBuilder(target)
               // NOTE: works if it is an array or a single id
               .where({ id: data[attributeName] })
@@ -633,7 +664,7 @@ const createEntityManager = (db) => {
               .execute();
           }
 
-          if (!_.isNull(data[attributeName])) {
+          if (!isNull(data[attributeName])) {
             const insert = toAssocs(data[attributeName]).map((data) => {
               return {
                 [joinColumn.name]: id,
@@ -667,7 +698,7 @@ const createEntityManager = (db) => {
     async deleteRelations(uid, id) {
       const { attributes } = db.metadata.get(uid);
 
-      for (const attributeName in attributes) {
+      for (const attributeName of Object.keys(attributes)) {
         const attribute = attributes[attributeName];
 
         if (attribute.type !== 'relation') {
@@ -791,7 +822,7 @@ const createEntityManager = (db) => {
     async load(uid, entity, fields, params) {
       const { attributes } = db.metadata.get(uid);
 
-      const fieldsArr = _.castArray(fields);
+      const fieldsArr = castArray(fields);
       fieldsArr.forEach((field) => {
         const attribute = attributes[field];
 
@@ -814,7 +845,7 @@ const createEntityManager = (db) => {
       }
 
       if (Array.isArray(fields)) {
-        return _.pick(fields, entry);
+        return pick(fields, entry);
       }
 
       return entry[fields];

package/lib/entity-manager/morph-relations.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const { groupBy, pipe, mapValues, map, isEmpty } = require('lodash/fp');
+const { createQueryBuilder } = require('../query');
+
+const getMorphToManyRowsLinkedToMorphOne = (rows, { uid, attributeName, typeColumn, db }) =>
+  rows.filter((row) => {
+    const relatedType = row[typeColumn.name];
+    const field = row.field;
+
+    const targetAttribute = db.metadata.get(relatedType).attributes[field];
+
+    // ensure targeted field is the right one + check if it is a morphOne
+    return (
+      targetAttribute?.target === uid &&
+      targetAttribute?.morphBy === attributeName &&
+      targetAttribute?.relation === 'morphOne'
+    );
+  });
+
+const deleteRelatedMorphOneRelationsAfterMorphToManyUpdate = async (
+  rows,
+  { uid, attributeName, joinTable, db }
+) => {
+  const { morphColumn } = joinTable;
+  const { idColumn, typeColumn } = morphColumn;
+
+  const morphOneRows = getMorphToManyRowsLinkedToMorphOne(rows, {
+    uid,
+    attributeName,
+    typeColumn,
+    db,
+  });
+
+  const groupByType = groupBy(typeColumn.name);
+  const groupByField = groupBy('field');
+
+  const typeAndFieldIdsGrouped = pipe(groupByType, mapValues(groupByField))(morphOneRows);
+
+  const orWhere = [];
+
+  for (const [type, v] of Object.entries(typeAndFieldIdsGrouped)) {
+    for (const [field, arr] of Object.entries(v)) {
+      orWhere.push({
+        [typeColumn.name]: type,
+        field,
+        [idColumn.name]: { $in: map(idColumn.name, arr) },
+      });
+    }
+  }
+
+  if (!isEmpty(orWhere)) {
+    await createQueryBuilder(joinTable.name, db).delete().where({ $or: orWhere }).execute();
+  }
+};
+
+module.exports = {
+  deleteRelatedMorphOneRelationsAfterMorphToManyUpdate,
+};

package/lib/lifecycles/index.js

@@ -54,7 +54,7 @@ const createLifecyclesProvider = (db) => {
      * @param {Map<any, any>} states
      */
     async run(action, uid, properties, states = new Map()) {
-      for (let i = 0; i < subscribers.length; i++) {
+      for (let i = 0; i < subscribers.length; i += 1) {
         const subscriber = subscribers[i];
         if (typeof subscriber === 'function') {
           const state = states.get(subscriber) || {};

package/lib/query/helpers/join.js

@@ -71,7 +71,7 @@ const applyJoin = (qb, join) => {
     inner.on(`${rootTable}.${rootColumn}`, `${alias}.${referencedColumn}`);
 
     if (on) {
-      for (const key in on) {
+      for (const key of Object.keys(on)) {
         inner.onVal(`${alias}.${key}`, on[key]);
       }
     }

package/lib/query/helpers/populate.js

@@ -8,7 +8,7 @@ const { fromRow } = require('./transform');
 const getRootLevelPopulate = (meta) => {
   const populate = {};
 
-  for (const attributeName in meta.attributes) {
+  for (const attributeName of Object.keys(meta.attributes)) {
     const attribute = meta.attributes[attributeName];
     if (attribute.type === 'relation') {
       populate[attributeName] = true;
@@ -72,7 +72,7 @@ const processPopulate = (populate, ctx) => {
   }
 
   const finalPopulate = {};
-  for (const key in populateMap) {
+  for (const key of Object.keys(populateMap)) {
     const attribute = meta.attributes[key];
 
     if (!attribute) {
@@ -119,7 +119,7 @@ const applyPopulate = async (results, populate, ctx) => {
     return results;
   }
 
-  for (const key in populate) {
+  for (const key of Object.keys(populate)) {
     const attribute = meta.attributes[key];
     const targetMeta = db.metadata.get(attribute.target);
 
@@ -540,7 +540,7 @@ const applyPopulate = async (results, populate, ctx) => {
       }, {});
 
       const map = {};
-      for (const type in idsByType) {
+      for (const type of Object.keys(idsByType)) {
         const ids = idsByType[type];
 
         // type was removed but still in morph relation
@@ -604,7 +604,7 @@ const applyPopulate = async (results, populate, ctx) => {
       }, {});
 
       const map = {};
-      for (const type in idsByType) {
+      for (const type of Object.keys(idsByType)) {
         const ids = idsByType[type];
 
         // type was removed but still in morph relation

package/lib/query/helpers/transform.js

@@ -53,7 +53,7 @@ const toRow = (meta, data = {}) => {
 
   const { attributes } = meta;
 
-  for (const key in data) {
+  for (const key of Object.keys(data)) {
     const attribute = attributes[key];
 
     if (!attribute || attribute.columnName === key) {

package/lib/query/helpers/where.js

@@ -76,7 +76,7 @@ const processAttributeWhere = (attribute, where, operator = '$eq') => {
 
   const filters = {};
 
-  for (const key in where) {
+  for (const key of Object.keys(where)) {
     const value = where[key];
 
     if (!isOperator(key)) {
@@ -119,7 +119,7 @@ const processWhere = (where, ctx) => {
   const filters = {};
 
   // for each key in where
-  for (const key in where) {
+  for (const key of Object.keys(where)) {
     const value = where[key];
 
     // if operator $and $or then loop over them

package/lib/query/query-builder.js

@@ -27,7 +27,13 @@ const createQueryBuilder = (uid, db) => {
   };
 
   let counter = 0;
-  const getAlias = () => `t${counter++}`;
+  const getAlias = () => {
+    const alias = `t${counter}`;
+
+    counter += 1;
+
+    return alias;
+  };
 
   return {
     alias: getAlias(),

package/lib/schema/builder.js

@@ -316,7 +316,7 @@ const createHelpers = (db) => {
         debug(`Creating column ${addedColumn.name}`);
 
         if (addedColumn.type === 'increments' && !db.dialect.canAddIncrements()) {
-          tableBuilder.integer(addedColumn.name).unsigned().notNullable();
+          tableBuilder.integer(addedColumn.name).unsigned();
           tableBuilder.primary(addedColumn.name);
         } else {
           createColumn(tableBuilder, addedColumn);

package/lib/schema/schema.js

@@ -25,7 +25,7 @@ const createTable = (meta) => {
     columns: [],
   };
 
-  for (const key in meta.attributes) {
+  for (const key of Object.keys(meta.attributes)) {
     const attribute = meta.attributes[key];
 
     if (types.isRelation(attribute.type)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.3.7",
+  "version": "4.3.9",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -39,8 +39,8 @@
     "umzug": "3.1.1"
   },
   "engines": {
-    "node": ">=14.19.1 <=16.x.x",
+    "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "73f523b98322cea8992c72977b94a73a624d2e79"
+  "gitHead": "8ebf58d9edb62872acf88d19d1f878b4a1632ff7"
 }