@strapi/database 4.11.2 → 4.11.4

package/lib/entity-manager/entity-repository.js

@@ -80,6 +80,10 @@ const createRepository = (uid, db) => {
       return db.entityManager.updateMany(uid, params);
     },
 
+    clone(id, params) {
+      return db.entityManager.clone(uid, id, params);
+    },
+
     delete(params) {
       return db.entityManager.delete(uid, params);
     },
@@ -111,6 +115,10 @@ const createRepository = (uid, db) => {
       return db.entityManager.deleteRelations(uid, id);
     },
 
+    cloneRelations(targetId, sourceId, params) {
+      return db.entityManager.cloneRelations(uid, targetId, sourceId, params);
+    },
+
     populate(entity, populate) {
       return db.entityManager.populate(uid, entity, populate);
     },

package/lib/entity-manager/index.js

@@ -1,32 +1,38 @@
 'use strict';
 
 const {
-  isUndefined,
   castArray,
   compact,
-  isNil,
+  difference,
+  differenceWith,
+  flow,
   has,
-  isString,
-  isInteger,
-  pick,
-  isPlainObject,
-  isEmpty,
   isArray,
-  isNull,
-  uniqWith,
+  isEmpty,
   isEqual,
-  differenceWith,
+  isInteger,
+  isNil,
+  isNull,
   isNumber,
+  isPlainObject,
+  isString,
+  isUndefined,
   map,
-  difference,
+  mergeWith,
+  omit,
+  pick,
   uniqBy,
+  uniqWith,
 } = require('lodash/fp');
+
+const { mapAsync } = require('@strapi/utils');
 const types = require('../types');
 const { createField } = require('../fields');
 const { createQueryBuilder } = require('../query');
 const { createRepository } = require('./entity-repository');
 const { deleteRelatedMorphOneRelationsAfterMorphToManyUpdate } = require('./morph-relations');
 const {
+  isPolymorphic,
   isBidirectional,
   isAnyToOne,
   isOneToAny,
@@ -40,6 +46,11 @@ const {
   cleanOrderColumns,
 } = require('./regular-relations');
 const { relationsOrderer } = require('./relations-orderer');
+const {
+  replaceRegularRelations,
+  cloneRegularRelations,
+} = require('./relations/cloning/regular-relations');
+const { DatabaseError } = require('../errors');
 
 const toId = (value) => value.id || value;
 const toIds = (value) => castArray(value || []).map(toId);
@@ -359,6 +370,61 @@ const createEntityManager = (db) => {
       return result;
     },
 
+    async clone(uid, cloneId, params = {}) {
+      const states = await db.lifecycles.run('beforeCreate', uid, { params });
+
+      const metadata = db.metadata.get(uid);
+      const { data } = params;
+
+      if (!isNil(data) && !isPlainObject(data)) {
+        throw new Error('Create expects a data object');
+      }
+
+      // TODO: Handle join columns?
+      const entity = await this.findOne(uid, { where: { id: cloneId } });
+
+      const dataToInsert = flow(
+        // Omit unwanted properties
+        omit(['id', 'created_at', 'updated_at']),
+        // Merge with provided data, set attribute to null if data attribute is null
+        mergeWith(data || {}, (original, override) => (override === null ? override : original)),
+        // Process data with metadata
+        (entity) => processData(metadata, entity, { withDefaults: true })
+      )(entity);
+
+      const res = await this.createQueryBuilder(uid).insert(dataToInsert).execute();
+
+      const id = res[0].id || res[0];
+
+      const trx = await strapi.db.transaction();
+      try {
+        const cloneAttrs = Object.entries(metadata.attributes).reduce((acc, [attrName, attr]) => {
+          // TODO: handle components in the db layer
+          if (attr.type === 'relation' && attr.joinTable && !attr.component) {
+            acc.push(attrName);
+          }
+          return acc;
+        }, []);
+
+        await this.cloneRelations(uid, id, cloneId, data, { cloneAttrs, transaction: trx.get() });
+        await trx.commit();
+      } catch (e) {
+        await trx.rollback();
+        await this.createQueryBuilder(uid).where({ id }).delete().execute();
+        throw e;
+      }
+
+      const result = await this.findOne(uid, {
+        where: { id },
+        select: params.select,
+        populate: params.populate,
+      });
+
+      await db.lifecycles.run('afterCreate', uid, { params, result }, states);
+
+      return result;
+    },
+
     async delete(uid, params = {}) {
       const states = await db.lifecycles.run('beforeDelete', uid, { params });
 
@@ -1167,6 +1233,73 @@ const createEntityManager = (db) => {
       }
     },
 
+    // TODO: Clone polymorphic relations
+    /**
+     *
+     * @param {string} uid - uid of the entity to clone
+     * @param {number} targetId - id of the entity to clone into
+     * @param {number} sourceId - id of the entity to clone from
+     * @param {object} opt
+     * @param {object} opt.cloneAttrs - key value pair of attributes to clone
+     * @param {object} opt.transaction - transaction to use
+     * @example cloneRelations('user', 3, 1, { cloneAttrs: ["comments"]})
+     * @example cloneRelations('post', 5, 2, { cloneAttrs: ["comments", "likes"] })
+     */
+    async cloneRelations(uid, targetId, sourceId, data, { cloneAttrs = [], transaction }) {
+      const { attributes } = db.metadata.get(uid);
+
+      if (!attributes) {
+        return;
+      }
+
+      await mapAsync(cloneAttrs, async (attrName) => {
+        const attribute = attributes[attrName];
+
+        if (attribute.type !== 'relation') {
+          throw new DatabaseError(
+            `Attribute ${attrName} is not a relation attribute. Cloning relations is only supported for relation attributes.`
+          );
+        }
+
+        if (isPolymorphic(attribute)) {
+          // TODO: add support for cloning polymorphic relations
+          return;
+        }
+
+        if (attribute.joinColumn) {
+          // TODO: add support for cloning oneToMany relations on the owning side
+          return;
+        }
+
+        if (!attribute.joinTable) {
+          return;
+        }
+
+        let omitIds = [];
+        if (has(attrName, data)) {
+          const cleanRelationData = toAssocs(data[attrName]);
+
+          // Don't clone if the relation attr is being set
+          if (cleanRelationData.set) {
+            return;
+          }
+
+          // Disconnected relations don't need to be cloned
+          if (cleanRelationData.disconnect) {
+            omitIds = toIds(cleanRelationData.disconnect);
+          }
+        }
+
+        if (isOneToAny(attribute) && isBidirectional(attribute)) {
+          await replaceRegularRelations({ targetId, sourceId, attribute, omitIds, transaction });
+        } else {
+          await cloneRegularRelations({ targetId, sourceId, attribute, transaction });
+        }
+      });
+
+      await this.updateRelations(uid, targetId, data, { transaction });
+    },
+
     // TODO: add lifecycle events
     async populate(uid, entity, populate) {
       const entry = await this.findOne(uid, {

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

@@ -379,9 +379,103 @@ const cleanOrderColumnsForOldDatabases = async ({
   }
 };
 
+/**
+ * Use this when a relation is added or removed and its inverse order column
+ * needs to be re-calculated
+ *
+ * Example: In this following table
+ *
+ *   | joinColumn      | inverseJoinColumn | order       | inverseOrder       |
+ *   | --------------- | --------          | ----------- | ------------------ |
+ *   | 1               | 1                 | 1           | 1                  |
+ *   | 2               | 1                 | 3           | 2                  |
+ *   | 2               | 2                 | 3           | 1                  |
+ *
+ * You add a new relation { joinColumn: 1, inverseJoinColumn: 2 }
+ *
+ *   | joinColumn      | inverseJoinColumn | order       | inverseOrder       |
+ *   | --------------- | --------          | ----------- | ------------------ |
+ *   | 1               | 1                 | 1           | 1                  |
+ *   | 1               | 2                 | 2           | 1                  | <- inverseOrder should be 2
+ *   | 2               | 1                 | 3           | 2                  |
+ *   | 2               | 2                 | 3           | 1                  |
+ *
+ * This function would make such update, so all inverse order columns related
+ * to the given id (1 in this example) are following a 1, 2, 3 sequence, without gap.
+ *
+ * @param {Object} params
+ * @param {string} params.id - entity id to find which inverse order column to clean
+ * @param {Object} params.attribute - attribute of the relation
+ * @param {Object} params.trx - knex transaction
+ *
+ */
+
+const cleanInverseOrderColumn = async ({ id, attribute, trx }) => {
+  const con = strapi.db.connection;
+  const { joinTable } = attribute;
+  const { joinColumn, inverseJoinColumn, inverseOrderColumnName } = joinTable;
+
+  switch (strapi.db.dialect.client) {
+    /*
+      UPDATE `:joinTableName` AS `t1`
+      JOIN (
+          SELECT
+            `inverseJoinColumn`,
+            MAX(`:inverseOrderColumnName`) AS `max_inv_order`
+          FROM `:joinTableName`
+          GROUP BY `:inverseJoinColumn`
+      ) AS `t2`
+      ON `t1`.`:inverseJoinColumn` = `t2`.`:inverseJoinColumn`
+      SET `t1`.`:inverseOrderColumnNAme` = `t2`.`max_inv_order` + 1
+      WHERE `t1`.`:joinColumnName` = :id;
+    */
+    case 'mysql': {
+      // Group by the inverse join column and get the max value of the inverse order column
+      const subQuery = con(joinTable.name)
+        .select(inverseJoinColumn.name)
+        .max(inverseOrderColumnName, { as: 'max_inv_order' })
+        .groupBy(inverseJoinColumn.name)
+        .as('t2');
+
+      //  Update ids with the new inverse order
+      await con(`${joinTable.name} as t1`)
+        .join(subQuery, `t1.${inverseJoinColumn.name}`, '=', `t2.${inverseJoinColumn.name}`)
+        .where(joinColumn.name, id)
+        .update({
+          [inverseOrderColumnName]: con.raw('t2.max_inv_order + 1'),
+        })
+        .transacting(trx);
+      break;
+    }
+    default: {
+      /*
+        UPDATE `:joinTableName` as `t1`
+        SET `:inverseOrderColumnName` = (
+          SELECT max(`:inverseOrderColumnName`) + 1
+          FROM `:joinTableName` as `t2`
+          WHERE t2.:inverseJoinColumn = t1.:inverseJoinColumn
+        )
+        WHERE `t1`.`:joinColumnName` = :id
+      */
+      // New inverse order will be the max value + 1
+      const selectMaxInverseOrder = con.raw(`max(${inverseOrderColumnName}) + 1`);
+
+      const subQuery = con(`${joinTable.name} as t2`)
+        .select(selectMaxInverseOrder)
+        .whereRaw(`t2.${inverseJoinColumn.name} = t1.${inverseJoinColumn.name}`);
+
+      await con(`${joinTable.name} as t1`)
+        .where(`t1.${joinColumn.name}`, id)
+        .update({ [inverseOrderColumnName]: subQuery })
+        .transacting(trx);
+    }
+  }
+};
+
 module.exports = {
   deletePreviousOneToAnyRelations,
   deletePreviousAnyToOneRelations,
   deleteRelations,
   cleanOrderColumns,
+  cleanInverseOrderColumn,
 };

package/lib/entity-manager/relations/cloning/regular-relations.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const { cleanInverseOrderColumn } = require('../../regular-relations');
+
+const replaceRegularRelations = async ({
+  targetId,
+  sourceId,
+  attribute,
+  omitIds,
+  transaction: trx,
+}) => {
+  const { joinTable } = attribute;
+  const { joinColumn, inverseJoinColumn } = joinTable;
+
+  // We are effectively stealing the relation from the cloned entity
+  await strapi.db.entityManager
+    .createQueryBuilder(joinTable.name)
+    .update({ [joinColumn.name]: targetId })
+    .where({ [joinColumn.name]: sourceId })
+    .where({ $not: { [inverseJoinColumn.name]: omitIds } })
+    .onConflict([joinColumn.name, inverseJoinColumn.name])
+    .ignore()
+    .transacting(trx)
+    .execute();
+};
+
+const cloneRegularRelations = async ({ targetId, sourceId, attribute, transaction: trx }) => {
+  const { joinTable } = attribute;
+  const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } = joinTable;
+  const connection = strapi.db.getConnection();
+
+  // Get the columns to select
+  const columns = [joinColumn.name, inverseJoinColumn.name];
+  if (orderColumnName) columns.push(orderColumnName);
+  if (inverseOrderColumnName) columns.push(inverseOrderColumnName);
+  if (joinTable.on) columns.push(...Object.keys(joinTable.on));
+
+  const selectStatement = connection
+    .select(
+      // Override joinColumn with the new id
+      { [joinColumn.name]: targetId },
+      // The rest of columns will be the same
+      ...columns.slice(1)
+    )
+    .where(joinColumn.name, sourceId)
+    .from(joinTable.name)
+    .toSQL();
+
+  // Insert the clone relations
+  await strapi.db.entityManager
+    .createQueryBuilder(joinTable.name)
+    .insert(
+      strapi.db.connection.raw(
+        `(${columns.join(',')})  ${selectStatement.sql}`,
+        selectStatement.bindings
+      )
+    )
+    .onConflict([joinColumn.name, inverseJoinColumn.name])
+    .ignore()
+    .transacting(trx)
+    .execute();
+
+  // Clean the inverse order column
+  if (inverseOrderColumnName) {
+    await cleanInverseOrderColumn({
+      id: targetId,
+      attribute,
+      trx,
+    });
+  }
+};
+
+module.exports = {
+  replaceRegularRelations,
+  cloneRegularRelations,
+};

package/lib/fields/shared/parsers.js

@@ -25,6 +25,8 @@ const parseDateTimeOrTimestamp = (value) => {
 };
 
 const parseDate = (value) => {
+  if (dateFns.isDate(value)) return dateFns.format(value, 'yyyy-MM-dd');
+
   const found = isString(value) ? value.match(PARTIAL_DATE_REGEX) || [] : [];
   const extractedValue = found[0];
 

package/lib/metadata/relations.js

@@ -9,6 +9,8 @@ const _ = require('lodash/fp');
 const hasInversedBy = _.has('inversedBy');
 const hasMappedBy = _.has('mappedBy');
 
+const isPolymorphic = (attribute) =>
+  ['morphOne', 'morphMany', 'morphToOne', 'morphToMany'].includes(attribute.relation);
 const isOneToAny = (attribute) => ['oneToOne', 'oneToMany'].includes(attribute.relation);
 const isManyToAny = (attribute) => ['manyToMany', 'manyToOne'].includes(attribute.relation);
 const isAnyToOne = (attribute) => ['oneToOne', 'manyToOne'].includes(attribute.relation);
@@ -564,7 +566,7 @@ const hasInverseOrderColumn = (attribute) => isBidirectional(attribute) && isMan
 
 module.exports = {
   createRelation,
-
+  isPolymorphic,
   isBidirectional,
   isOneToAny,
   isManyToAny,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.11.2",
+  "version": "4.11.4",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -33,7 +33,7 @@
     "lint": "run -T eslint ."
   },
   "dependencies": {
-    "@strapi/utils": "4.11.2",
+    "@strapi/utils": "4.11.4",
     "date-fns": "2.30.0",
     "debug": "4.3.4",
     "fs-extra": "10.0.0",
@@ -46,5 +46,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "6f7c815c2bbe41dda7d77136eb8df736c028ff67"
+  "gitHead": "8d325a695386ab9b578b360bf768cfa25173050f"
 }