@strapi/database 4.4.3 → 4.5.0-beta.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,283 @@
+'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 (!(isBidirectional(attribute) && isAnyToOne(attribute))) {
+    throw new Error(
+      'deletePreviousAnyToOneRelations can only be called for bidirectional 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

@@ -123,7 +123,7 @@ const createCompoLinkModelMeta = (baseModelMeta) => {
         type: 'integer',
         column: {
           unsigned: true,
-          defaultTo: 0,
+          defaultTo: null,
         },
       },
     },
@@ -142,6 +142,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 +188,7 @@ const createDynamicZone = (attributeName, attribute, meta) => {
       orderBy: {
         order: 'asc',
       },
+      pivotColumns: ['entity_id', 'component_id', 'field', 'component_type'],
     },
   });
 };
@@ -205,9 +211,11 @@ const createComponent = (attributeName, attribute, meta) => {
       on: {
         field: attributeName,
       },
+      orderColumnName: 'order',
       orderBy: {
         order: 'asc',
       },
+      pivotColumns: ['entity_id', 'component_id', 'field', 'component_type'],
     },
   });
 };

package/lib/metadata/relations.js

@@ -10,6 +10,9 @@ const hasInversedBy = _.has('inversedBy');
 const hasMappedBy = _.has('mappedBy');
 
 const isOneToAny = (attribute) => ['oneToOne', 'oneToMany'].includes(attribute.relation);
+const isManyToAny = (attribute) => ['manyToMany', 'manyToOne'].includes(attribute.relation);
+const isAnyToOne = (attribute) => ['oneToOne', 'manyToOne'].includes(attribute.relation);
+const isAnyToMany = (attribute) => ['oneToMany', 'manyToMany'].includes(attribute.relation);
 const isBidirectional = (attribute) => hasInversedBy(attribute) || hasMappedBy(attribute);
 const isOwner = (attribute) => !isBidirectional(attribute) || hasInversedBy(attribute);
 const shouldUseJoinTable = (attribute) => attribute.useJoinTable !== false;
@@ -269,6 +272,7 @@ const createMorphToMany = (attributeName, attribute, meta, metadata) => {
     orderBy: {
       order: 'asc',
     },
+    pivotColumns: [joinColumnName, typeColumnName, idColumnName],
   };
 
   attribute.joinTable = joinTable;
@@ -398,12 +402,20 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
   const joinColumnName = _.snakeCase(`${meta.singularName}_id`);
   let inverseJoinColumnName = _.snakeCase(`${targetMeta.singularName}_id`);
 
-  // if relation is slef referencing
+  // if relation is self referencing
   if (joinColumnName === inverseJoinColumnName) {
     inverseJoinColumnName = `inv_${inverseJoinColumnName}`;
   }
 
-  metadata.add({
+  const orderColumnName = _.snakeCase(`${targetMeta.singularName}_order`);
+  let inverseOrderColumnName = _.snakeCase(`${meta.singularName}_order`);
+
+  // if relation is self referencing
+  if (attribute.relation === 'manyToMany' && joinColumnName === inverseJoinColumnName) {
+    inverseOrderColumnName = `inv_${inverseOrderColumnName}`;
+  }
+
+  const metadataSchema = {
     uid: joinTableName,
     tableName: joinTableName,
     attributes: {
@@ -433,6 +445,11 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
         name: `${joinTableName}_inv_fk`,
         columns: [inverseJoinColumnName],
       },
+      {
+        name: `${joinTableName}_unique`,
+        columns: [joinColumnName, inverseJoinColumnName],
+        type: 'unique',
+      },
     ],
     foreignKeys: [
       {
@@ -450,7 +467,7 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
         onDelete: 'CASCADE',
       },
     ],
-  });
+  };
 
   const joinTable = {
     name: joinTableName,
@@ -462,8 +479,46 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
       name: inverseJoinColumnName,
       referencedColumn: 'id',
     },
+    pivotColumns: [joinColumnName, inverseJoinColumnName],
   };
 
+  // order
+  if (isAnyToMany(attribute)) {
+    metadataSchema.attributes[orderColumnName] = {
+      type: 'integer',
+      column: {
+        unsigned: true,
+        defaultTo: null,
+      },
+    };
+    metadataSchema.indexes.push({
+      name: `${joinTableName}_order_fk`,
+      columns: [orderColumnName],
+    });
+    joinTable.orderColumnName = orderColumnName;
+    joinTable.orderBy = { [orderColumnName]: 'asc' };
+  }
+
+  // inv order
+  if (isBidirectional(attribute) && isManyToAny(attribute)) {
+    metadataSchema.attributes[inverseOrderColumnName] = {
+      type: 'integer',
+      column: {
+        unsigned: true,
+        defaultTo: null,
+      },
+    };
+
+    metadataSchema.indexes.push({
+      name: `${joinTableName}_order_inv_fk`,
+      columns: [inverseOrderColumnName],
+    });
+
+    joinTable.inverseOrderColumnName = inverseOrderColumnName;
+  }
+
+  metadata.add(metadataSchema);
+
   attribute.joinTable = joinTable;
 
   if (isBidirectional(attribute)) {
@@ -479,13 +534,30 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
       name: joinTableName,
       joinColumn: joinTable.inverseJoinColumn,
       inverseJoinColumn: joinTable.joinColumn,
+      pivotColumns: joinTable.pivotColumns,
     };
+
+    if (isManyToAny(attribute)) {
+      inverseAttribute.joinTable.orderColumnName = inverseOrderColumnName;
+      inverseAttribute.joinTable.orderBy = { [inverseOrderColumnName]: 'asc' };
+    }
+    if (isAnyToMany(attribute)) {
+      inverseAttribute.joinTable.inverseOrderColumnName = orderColumnName;
+    }
   }
 };
 
+const hasOrderColumn = (attribute) => isAnyToMany(attribute);
+const hasInverseOrderColumn = (attribute) => isBidirectional(attribute) && isManyToAny(attribute);
+
 module.exports = {
   createRelation,
 
   isBidirectional,
   isOneToAny,
+  isManyToAny,
+  isAnyToOne,
+  isAnyToMany,
+  hasOrderColumn,
+  hasInverseOrderColumn,
 };

package/lib/query/helpers/join.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const createPivotJoin = (qb, joinTable, alias, tragetMeta) => {
+const createPivotJoin = (ctx, { alias, refAlias, joinTable, targetMeta }) => {
+  const { qb } = ctx;
   const joinAlias = qb.getAlias();
   qb.join({
     alias: joinAlias,
@@ -11,10 +12,10 @@ const createPivotJoin = (qb, joinTable, alias, tragetMeta) => {
     on: joinTable.on,
   });
 
-  const subAlias = qb.getAlias();
+  const subAlias = refAlias || qb.getAlias();
   qb.join({
     alias: subAlias,
-    referencedTable: tragetMeta.tableName,
+    referencedTable: targetMeta.tableName,
     referencedColumn: joinTable.inverseJoinColumn.referencedColumn,
     rootColumn: joinTable.inverseJoinColumn.name,
     rootTable: joinAlias,
@@ -23,22 +24,22 @@ const createPivotJoin = (qb, joinTable, alias, tragetMeta) => {
   return subAlias;
 };
 
-const createJoin = (ctx, { alias, attributeName, attribute }) => {
+const createJoin = (ctx, { alias, refAlias, attributeName, attribute }) => {
   const { db, qb } = ctx;
 
   if (attribute.type !== 'relation') {
     throw new Error(`Cannot join on non relational field ${attributeName}`);
   }
 
-  const tragetMeta = db.metadata.get(attribute.target);
+  const targetMeta = db.metadata.get(attribute.target);
 
   const { joinColumn } = attribute;
 
   if (joinColumn) {
-    const subAlias = qb.getAlias();
+    const subAlias = refAlias || qb.getAlias();
     qb.join({
       alias: subAlias,
-      referencedTable: tragetMeta.tableName,
+      referencedTable: targetMeta.tableName,
       referencedColumn: joinColumn.referencedColumn,
       rootColumn: joinColumn.name,
       rootTable: alias,
@@ -48,7 +49,7 @@ const createJoin = (ctx, { alias, attributeName, attribute }) => {
 
   const { joinTable } = attribute;
   if (joinTable) {
-    return createPivotJoin(qb, joinTable, alias, tragetMeta);
+    return createPivotJoin(ctx, { alias, refAlias, joinTable, targetMeta });
   }
 
   return alias;