@strapi/database 4.5.2 → 4.5.4

package/lib/entity-manager/index.js

@@ -211,22 +211,19 @@ const createEntityManager = (db) => {
       }
 
       const dataToInsert = processData(metadata, data, { withDefaults: true });
-      let id;
 
-      const trx = await strapi.db.transaction();
-      try {
-        const res = await this.createQueryBuilder(uid)
-          .insert(dataToInsert)
-          .transacting(trx)
-          .execute();
+      const res = await this.createQueryBuilder(uid).insert(dataToInsert).execute();
 
-        id = res[0].id || res[0];
+      const id = res[0].id || res[0];
 
+      const trx = await strapi.db.transaction();
+      try {
         await this.attachRelations(uid, id, data, { transaction: trx });
 
         await trx.commit();
       } catch (e) {
         await trx.rollback();
+        await this.createQueryBuilder(uid).where({ id }).delete().execute();
         throw e;
       }
 
@@ -285,7 +282,11 @@ const createEntityManager = (db) => {
         throw new Error('Update requires a where parameter');
       }
 
-      const entity = await this.createQueryBuilder(uid).select('id').where(where).first().execute();
+      const entity = await this.createQueryBuilder(uid)
+        .select('*')
+        .where(where)
+        .first()
+        .execute({ mapResults: false });
 
       if (!entity) {
         return null;
@@ -293,23 +294,19 @@ const createEntityManager = (db) => {
 
       const { id } = entity;
 
-      const trx = await strapi.db.transaction();
-      try {
-        const dataToUpdate = processData(metadata, data);
+      const dataToUpdate = processData(metadata, data);
 
-        if (!isEmpty(dataToUpdate)) {
-          await this.createQueryBuilder(uid)
-            .where({ id })
-            .update(dataToUpdate)
-            .transacting(trx)
-            .execute();
-        }
+      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 });
-
         await trx.commit();
       } catch (e) {
         await trx.rollback();
+        await this.createQueryBuilder(uid).where({ id }).update(entity).execute();
         throw e;
       }
 
@@ -372,10 +369,10 @@ const createEntityManager = (db) => {
 
       const { id } = entity;
 
+      await this.createQueryBuilder(uid).where({ id }).delete().execute();
+
       const trx = await strapi.db.transaction();
       try {
-        await this.createQueryBuilder(uid).where({ id }).delete().transacting(trx).execute();
-
         await this.deleteRelations(uid, id, { transaction: trx });
 
         await trx.commit();

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

@@ -1,6 +1,7 @@
 'use strict';
 
 const { map, isEmpty } = require('lodash/fp');
+const { randomBytes } = require('crypto');
 
 const {
   isBidirectional,
@@ -197,60 +198,42 @@ const cleanOrderColumns = async ({ id, attribute, db, inverseRelIds, transaction
     return;
   }
 
-  // Handle databases that don't support window function ROW_NUMBER
-  if (!strapi.db.dialect.supportsWindowFunctions()) {
-    await cleanOrderColumnsForOldDatabases({ id, attribute, db, inverseRelIds, transaction: trx });
-    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.connection
-        .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);
+      await cleanOrderColumnsForInnoDB({ id, attribute, db, inverseRelIds, transaction: trx });
       break;
     default: {
+      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);
+      }
+
       const joinTableName = addSchema(joinTable.name);
+
+      // raw query as knex doesn't allow updating from a subquery
+      // https://github.com/knex/knex/issues/2504
       await db.connection
         .raw(
           `UPDATE ?? as a
@@ -264,24 +247,29 @@ const cleanOrderColumns = async ({ id, attribute, db, inverseRelIds, transaction
           [joinTableName, ...updateBinding, ...selectBinding, joinTableName, ...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`,
+      */
     }
-    /*
-      `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`,
-    */
   }
 };
 
-const cleanOrderColumnsForOldDatabases = async ({
+/*
+ * Ensure that orders are following a 1, 2, 3 sequence, without gap.
+ * The use of a temporary table instead of a window function makes the query compatible with MySQL 5 and prevents some deadlocks to happen in innoDB databases
+ */
+const cleanOrderColumnsForInnoDB = async ({
   id,
   attribute,
   db,
@@ -292,14 +280,15 @@ const cleanOrderColumnsForOldDatabases = async ({
   const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } = joinTable;
 
   const now = new Date().valueOf();
+  const randomHex = randomBytes(16).toString('hex');
 
   if (hasOrderColumn(attribute) && id) {
-    const tempOrderTableName = `tempOrderTableName_${now}`;
+    const tempOrderTableName = `orderTable_${now}_${randomHex}`;
     try {
       await db.connection
         .raw(
           `
-          CREATE TEMPORARY TABLE :tempOrderTableName:
+          CREATE TABLE :tempOrderTableName:
             SELECT
               id,
               (
@@ -317,6 +306,9 @@ const cleanOrderColumnsForOldDatabases = async ({
           }
         )
         .transacting(trx);
+
+      // raw query as knex doesn't allow updating from a subquery
+      // https://github.com/knex/knex/issues/2504
       await db.connection
         .raw(
           `UPDATE ?? as a, (SELECT * FROM ??) AS b
@@ -326,14 +318,12 @@ const cleanOrderColumnsForOldDatabases = async ({
         )
         .transacting(trx);
     } finally {
-      await db.connection
-        .raw(`DROP TEMPORARY TABLE IF EXISTS ??`, [tempOrderTableName])
-        .transacting(trx);
+      await db.connection.raw(`DROP TABLE IF EXISTS ??`, [tempOrderTableName]).transacting(trx);
     }
   }
 
   if (hasInverseOrderColumn(attribute) && !isEmpty(inverseRelIds)) {
-    const tempInvOrderTableName = `tempInvOrderTableName_${now}`;
+    const tempInvOrderTableName = `invOrderTable_${now}_${randomHex}`;
     try {
       await db.connection
         .raw(

package/lib/metadata/relations.js

@@ -411,7 +411,7 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
   let inverseOrderColumnName = _.snakeCase(`${meta.singularName}_order`);
 
   // if relation is self referencing
-  if (attribute.relation === 'manyToMany' && joinColumnName === inverseJoinColumnName) {
+  if (attribute.relation === 'manyToMany' && orderColumnName === inverseOrderColumnName) {
     inverseOrderColumnName = `inv_${inverseOrderColumnName}`;
   }
 

package/lib/query/helpers/populate/apply.js

@@ -446,6 +446,11 @@ const morphToMany = async (input, ctx) => {
     .where({
       [joinColumn.name]: referencedValues,
       ...(joinTable.on || {}),
+      // If the populateValue contains an "on" property,
+      // only populate the types defined in it
+      ...('on' in populateValue
+        ? { [morphColumn.typeColumn.name]: Object.keys(populateValue.on) }
+        : {}),
     })
     .orderBy([joinColumn.name, 'order'])
     .execute({ mapResults: false });
@@ -470,6 +475,8 @@ const morphToMany = async (input, ctx) => {
   }, {});
 
   const map = {};
+  const { on, ...typePopulate } = populateValue;
+
   for (const type of Object.keys(idsByType)) {
     const ids = idsByType[type];
 
@@ -483,7 +490,7 @@ const morphToMany = async (input, ctx) => {
     const qb = db.entityManager.createQueryBuilder(type);
 
     const rows = await qb
-      .init(populateValue)
+      .init(on?.[type] ?? typePopulate)
       .addSelect(`${qb.alias}.${idColumn.referencedColumn}`)
       .where({ [idColumn.referencedColumn]: ids })
       .execute({ mapResults: false });
@@ -540,6 +547,8 @@ const morphToOne = async (input, ctx) => {
   }, {});
 
   const map = {};
+  const { on, ...typePopulate } = populateValue;
+
   for (const type of Object.keys(idsByType)) {
     const ids = idsByType[type];
 
@@ -552,7 +561,7 @@ const morphToOne = async (input, ctx) => {
     const qb = db.entityManager.createQueryBuilder(type);
 
     const rows = await qb
-      .init(populateValue)
+      .init(on?.[type] ?? typePopulate)
       .addSelect(`${qb.alias}.${idColumn.referencedColumn}`)
       .where({ [idColumn.referencedColumn]: ids })
       .execute({ mapResults: false });
@@ -579,7 +588,16 @@ const morphToOne = async (input, ctx) => {
 
 //  TODO: Omit limit & offset to avoid needing a query per result to avoid making too many queries
 const pickPopulateParams = (populate) => {
-  const fieldsToPick = ['select', 'count', 'where', 'populate', 'orderBy', 'filters', 'ordering'];
+  const fieldsToPick = [
+    'select',
+    'count',
+    'where',
+    'populate',
+    'orderBy',
+    'filters',
+    'ordering',
+    'on',
+  ];
 
   if (populate.count !== true) {
     fieldsToPick.push('limit', 'offset');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.5.2",
+  "version": "4.5.4",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -32,7 +32,7 @@
   },
   "dependencies": {
     "date-fns": "2.29.2",
-    "debug": "4.3.1",
+    "debug": "4.3.4",
     "fs-extra": "10.0.0",
     "knex": "1.0.7",
     "lodash": "4.17.21",
@@ -43,5 +43,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "bcb1b7f472aae2556a9b59d59ee66d241c497a3e"
+  "gitHead": "8716ecc920130db5341b0904cf868c6e6b581a5d"
 }