@strapi/database 4.5.0-alpha.0 → 4.5.0

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

@@ -20,7 +20,7 @@ const getMorphToManyRowsLinkedToMorphOne = (rows, { uid, attributeName, typeColu
 
 const deleteRelatedMorphOneRelationsAfterMorphToManyUpdate = async (
   rows,
-  { uid, attributeName, joinTable, db }
+  { uid, attributeName, joinTable, db, transaction: trx }
 ) => {
   const { morphColumn } = joinTable;
   const { idColumn, typeColumn } = morphColumn;
@@ -50,7 +50,11 @@ const deleteRelatedMorphOneRelationsAfterMorphToManyUpdate = async (
   }
 
   if (!isEmpty(orWhere)) {
-    await createQueryBuilder(joinTable.name, db).delete().where({ $or: orWhere }).execute();
+    await createQueryBuilder(joinTable.name, db)
+      .delete()
+      .where({ $or: orWhere })
+      .transacting(trx)
+      .execute();
   }
 };
 

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

@@ -0,0 +1,281 @@
+'use strict';
+
+const { map, isEmpty } = require('lodash/fp');
+const {
+  isBidirectional,
+  isOneToAny,
+  isManyToAny,
+  isAnyToOne,
+  hasOrderColumn,
+  hasInverseOrderColumn,
+} = require('../metadata/relations');
+const { createQueryBuilder } = require('../query');
+
+/**
+ * If some relations currently exist for this oneToX relation, on the one side, this function removes them and update the inverse order if needed.
+ * @param {Object} params
+ * @param {string} params.id - entity id on which the relations for entities relIdsToadd are created
+ * @param {string} params.attribute - attribute of the relation
+ * @param {string} params.inverseRelIds - entity ids of the inverse side for which the current relations will be deleted
+ * @param {string} params.db - database instance
+ */
+const deletePreviousOneToAnyRelations = async ({
+  id,
+  attribute,
+  relIdsToadd,
+  db,
+  transaction: trx,
+}) => {
+  if (!(isBidirectional(attribute) && isOneToAny(attribute))) {
+    throw new Error(
+      'deletePreviousOneToAnyRelations can only be called for bidirectional oneToAny relations'
+    );
+  }
+  const { joinTable } = attribute;
+  const { joinColumn, inverseJoinColumn } = joinTable;
+
+  await createQueryBuilder(joinTable.name, db)
+    .delete()
+    .where({
+      [inverseJoinColumn.name]: relIdsToadd,
+      [joinColumn.name]: { $ne: id },
+    })
+    .where(joinTable.on || {})
+    .transacting(trx)
+    .execute();
+
+  await cleanOrderColumns({ attribute, db, inverseRelIds: relIdsToadd, transaction: trx });
+};
+
+/**
+ * If a relation currently exists for this xToOne relations, this function removes it and update the inverse order if needed.
+ * @param {Object} params
+ * @param {string} params.id - entity id on which the relation for entity relIdToadd is created
+ * @param {string} params.attribute - attribute of the relation
+ * @param {string} params.relIdToadd - entity id of the new relation
+ * @param {string} params.db - database instance
+ */
+const deletePreviousAnyToOneRelations = async ({
+  id,
+  attribute,
+  relIdToadd,
+  db,
+  transaction: trx,
+}) => {
+  const { joinTable } = attribute;
+  const { joinColumn, inverseJoinColumn } = joinTable;
+
+  if (!isAnyToOne(attribute)) {
+    throw new Error('deletePreviousAnyToOneRelations can only be called for anyToOne relations');
+  }
+  // handling manyToOne
+  if (isManyToAny(attribute)) {
+    // if the database integrity was not broken relsToDelete is supposed to be of length 1
+    const relsToDelete = await createQueryBuilder(joinTable.name, db)
+      .select(inverseJoinColumn.name)
+      .where({
+        [joinColumn.name]: id,
+        [inverseJoinColumn.name]: { $ne: relIdToadd },
+      })
+      .where(joinTable.on || {})
+      .transacting(trx)
+      .execute();
+
+    const relIdsToDelete = map(inverseJoinColumn.name, relsToDelete);
+
+    await createQueryBuilder(joinTable.name, db)
+      .delete()
+      .where({
+        [joinColumn.name]: id,
+        [inverseJoinColumn.name]: { $in: relIdsToDelete },
+      })
+      .where(joinTable.on || {})
+      .transacting(trx)
+      .execute();
+
+    await cleanOrderColumns({ attribute, db, inverseRelIds: relIdsToDelete, transaction: trx });
+
+    // handling oneToOne
+  } else {
+    await createQueryBuilder(joinTable.name, db)
+      .delete()
+      .where({
+        [joinColumn.name]: id,
+        [inverseJoinColumn.name]: { $ne: relIdToadd },
+      })
+      .where(joinTable.on || {})
+      .transacting(trx)
+      .execute();
+  }
+};
+
+/**
+ * Delete all or some relations of entity field
+ * @param {Object} params
+ * @param {string} params.id - entity id for which the relations will be deleted
+ * @param {string} params.attribute - attribute of the relation
+ * @param {string} params.db - database instance
+ * @param {string} params.relIdsToDelete - ids of entities to remove from the relations. Also accepts 'all'
+ * @param {string} params.relIdsToNotDelete - ids of entities to not remove from the relation when relIdsToDelete equals 'all'
+ */
+const deleteRelations = async ({
+  id,
+  attribute,
+  db,
+  relIdsToNotDelete = [],
+  relIdsToDelete = [],
+  transaction: trx,
+}) => {
+  const { joinTable } = attribute;
+  const { joinColumn, inverseJoinColumn } = joinTable;
+  const all = relIdsToDelete === 'all';
+
+  if (hasOrderColumn(attribute) || hasInverseOrderColumn(attribute)) {
+    let lastId = 0;
+    let done = false;
+    const batchSize = 100;
+    while (!done) {
+      const batchToDelete = await createQueryBuilder(joinTable.name, db)
+        .select(inverseJoinColumn.name)
+        .where({
+          [joinColumn.name]: id,
+          id: { $gt: lastId },
+          [inverseJoinColumn.name]: { $notIn: relIdsToNotDelete },
+          ...(all ? {} : { [inverseJoinColumn.name]: { $in: relIdsToDelete } }),
+        })
+        .where(joinTable.on || {})
+        .orderBy('id')
+        .limit(batchSize)
+        .transacting(trx)
+        .execute();
+      done = batchToDelete.length < batchSize;
+      lastId = batchToDelete[batchToDelete.length - 1]?.id;
+
+      const batchIds = map(inverseJoinColumn.name, batchToDelete);
+
+      await createQueryBuilder(joinTable.name, db)
+        .delete()
+        .where({
+          [joinColumn.name]: id,
+          [inverseJoinColumn.name]: { $in: batchIds },
+        })
+        .where(joinTable.on || {})
+        .transacting(trx)
+        .execute();
+
+      await cleanOrderColumns({ attribute, db, id, inverseRelIds: batchIds, transaction: trx });
+    }
+  } else {
+    await createQueryBuilder(joinTable.name, db)
+      .delete()
+      .where({
+        [joinColumn.name]: id,
+        [inverseJoinColumn.name]: { $notIn: relIdsToNotDelete },
+        ...(all ? {} : { [inverseJoinColumn.name]: { $in: relIdsToDelete } }),
+      })
+      .where(joinTable.on || {})
+      .transacting(trx)
+      .execute();
+  }
+};
+
+/**
+ * Clean the order columns by ensuring the order value are continuous (ex: 1, 2, 3 and not 1, 5, 10)
+ * @param {Object} params
+ * @param {string} params.id - entity id for which the clean will be done
+ * @param {string} params.attribute - attribute of the relation
+ * @param {string} params.db - database instance
+ * @param {string} params.inverseRelIds - entity ids of the inverse side for which the clean will be done
+ */
+const cleanOrderColumns = async ({ id, attribute, db, inverseRelIds, transaction: trx }) => {
+  if (
+    !(hasOrderColumn(attribute) && id) &&
+    !(hasInverseOrderColumn(attribute) && !isEmpty(inverseRelIds))
+  ) {
+    return;
+  }
+
+  const { joinTable } = attribute;
+  const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } = joinTable;
+  const update = [];
+  const updateBinding = [];
+  const select = ['??'];
+  const selectBinding = ['id'];
+  const where = [];
+  const whereBinding = [];
+
+  if (hasOrderColumn(attribute) && id) {
+    update.push('?? = b.src_order');
+    updateBinding.push(orderColumnName);
+    select.push('ROW_NUMBER() OVER (PARTITION BY ?? ORDER BY ??) AS src_order');
+    selectBinding.push(joinColumn.name, orderColumnName);
+    where.push('?? = ?');
+    whereBinding.push(joinColumn.name, id);
+  }
+
+  if (hasInverseOrderColumn(attribute) && !isEmpty(inverseRelIds)) {
+    update.push('?? = b.inv_order');
+    updateBinding.push(inverseOrderColumnName);
+    select.push('ROW_NUMBER() OVER (PARTITION BY ?? ORDER BY ??) AS inv_order');
+    selectBinding.push(inverseJoinColumn.name, inverseOrderColumnName);
+    where.push(`?? IN (${inverseRelIds.map(() => '?').join(', ')})`);
+    whereBinding.push(inverseJoinColumn.name, ...inverseRelIds);
+  }
+
+  // raw query as knex doesn't allow updating from a subquery
+  // https://github.com/knex/knex/issues/2504
+  switch (strapi.db.dialect.client) {
+    case 'mysql':
+      await db
+        .getConnection()
+        .raw(
+          `UPDATE
+            ?? as a,
+            (
+              SELECT ${select.join(', ')}
+              FROM ??
+              WHERE ${where.join(' OR ')}
+            ) AS b
+          SET ${update.join(', ')}
+          WHERE b.id = a.id`,
+          [joinTable.name, ...selectBinding, joinTable.name, ...whereBinding, ...updateBinding]
+        )
+        .transacting(trx);
+      break;
+    default:
+      await db
+        .getConnection()
+        .raw(
+          `UPDATE ?? as a
+            SET ${update.join(', ')}
+            FROM (
+              SELECT ${select.join(', ')}
+              FROM ??
+              WHERE ${where.join(' OR ')}
+            ) AS b
+            WHERE b.id = a.id`,
+          [joinTable.name, ...updateBinding, ...selectBinding, joinTable.name, ...whereBinding]
+        )
+        .transacting(trx);
+    /*
+      `UPDATE :joinTable: as a
+        SET :orderColumn: = b.src_order, :inverseOrderColumn: = b.inv_order
+        FROM (
+          SELECT
+            id,
+            ROW_NUMBER() OVER ( PARTITION BY :joinColumn: ORDER BY :orderColumn:) AS src_order,
+            ROW_NUMBER() OVER ( PARTITION BY :inverseJoinColumn: ORDER BY :inverseOrderColumn:) AS inv_order
+          FROM :joinTable:
+          WHERE :joinColumn: = :id OR :inverseJoinColumn: IN (:inverseRelIds)
+        ) AS b
+        WHERE b.id = a.id`,
+    */
+  }
+};
+
+module.exports = {
+  deletePreviousOneToAnyRelations,
+  deletePreviousAnyToOneRelations,
+  deleteRelations,
+  cleanOrderColumns,
+};

package/lib/metadata/index.js

@@ -9,6 +9,21 @@ class Metadata extends Map {
   add(meta) {
     return this.set(meta.uid, meta);
   }
+
+  /**
+   * Validate the DB metadata, throwing an error if a duplicate DB table name is detected
+   */
+  validate() {
+    const seenTables = new Map();
+    for (const meta of this.values()) {
+      if (seenTables.get(meta.tableName)) {
+        throw new Error(
+          `DB table "${meta.tableName}" already exists. Change the collectionName of the related content type.`
+        );
+      }
+      seenTables.set(meta.tableName, true);
+    }
+  }
 }
 
 // TODO: check if there isn't an attribute with an id already
@@ -81,6 +96,7 @@ const createMetadata = (models = []) => {
     meta.columnToAttribute = columnToAttribute;
   }
 
+  metadata.validate();
   return metadata;
 };
 
@@ -123,7 +139,7 @@ const createCompoLinkModelMeta = (baseModelMeta) => {
         type: 'integer',
         column: {
           unsigned: true,
-          defaultTo: 0,
+          defaultTo: null,
         },
       },
     },
@@ -142,6 +158,11 @@ const createCompoLinkModelMeta = (baseModelMeta) => {
         name: `${baseModelMeta.tableName}_entity_fk`,
         columns: ['entity_id'],
       },
+      {
+        name: `${baseModelMeta.tableName}_unique`,
+        columns: ['entity_id', 'component_id', 'field', 'component_type'],
+        type: 'unique',
+      },
     ],
     foreignKeys: [
       {
@@ -183,6 +204,7 @@ const createDynamicZone = (attributeName, attribute, meta) => {
       orderBy: {
         order: 'asc',
       },
+      pivotColumns: ['entity_id', 'component_id', 'field', 'component_type'],
     },
   });
 };
@@ -205,10 +227,11 @@ const createComponent = (attributeName, attribute, meta) => {
       on: {
         field: attributeName,
       },
+      orderColumnName: 'order',
       orderBy: {
         order: 'asc',
       },
-      ...(attribute.repeatable === true ? { orderColumnName: 'order' } : {}),
+      pivotColumns: ['entity_id', 'component_id', 'field', 'component_type'],
     },
   });
 };

package/lib/metadata/relations.js

@@ -272,6 +272,7 @@ const createMorphToMany = (attributeName, attribute, meta, metadata) => {
     orderBy: {
       order: 'asc',
     },
+    pivotColumns: [joinColumnName, typeColumnName, idColumnName],
   };
 
   attribute.joinTable = joinTable;
@@ -406,8 +407,8 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
     inverseJoinColumnName = `inv_${inverseJoinColumnName}`;
   }
 
-  const orderColumnName = _.snakeCase(`${meta.singularName}_order`);
-  let inverseOrderColumnName = _.snakeCase(`${targetMeta.singularName}_order`);
+  const orderColumnName = _.snakeCase(`${targetMeta.singularName}_order`);
+  let inverseOrderColumnName = _.snakeCase(`${meta.singularName}_order`);
 
   // if relation is self referencing
   if (attribute.relation === 'manyToMany' && joinColumnName === inverseJoinColumnName) {
@@ -444,6 +445,11 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
         name: `${joinTableName}_inv_fk`,
         columns: [inverseJoinColumnName],
       },
+      {
+        name: `${joinTableName}_unique`,
+        columns: [joinColumnName, inverseJoinColumnName],
+        type: 'unique',
+      },
     ],
     foreignKeys: [
       {
@@ -473,6 +479,7 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
       name: inverseJoinColumnName,
       referencedColumn: 'id',
     },
+    pivotColumns: [joinColumnName, inverseJoinColumnName],
   };
 
   // order
@@ -527,6 +534,7 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
       name: joinTableName,
       joinColumn: joinTable.inverseJoinColumn,
       inverseJoinColumn: joinTable.joinColumn,
+      pivotColumns: joinTable.pivotColumns,
     };
 
     if (isManyToAny(attribute)) {
@@ -539,6 +547,9 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
   }
 };
 
+const hasOrderColumn = (attribute) => isAnyToMany(attribute);
+const hasInverseOrderColumn = (attribute) => isBidirectional(attribute) && isManyToAny(attribute);
+
 module.exports = {
   createRelation,
 
@@ -547,4 +558,6 @@ module.exports = {
   isManyToAny,
   isAnyToOne,
   isAnyToMany,
+  hasOrderColumn,
+  hasInverseOrderColumn,
 };