@strapi/database 4.5.1 → 4.5.2

package/lib/dialects/dialect.js

@@ -29,6 +29,10 @@ class Dialect {
     return false;
   }
 
+  supportsWindowFunctions() {
+    return true;
+  }
+
   async startSchemaUpdate() {
     // noop
   }

package/lib/dialects/mysql/constants.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = {
+  MYSQL: 'MYSQL',
+  MARIADB: 'MARIADB',
+};

package/lib/dialects/mysql/database-inspector.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const { MARIADB, MYSQL } = require('./constants');
+
+const SQL_QUERIES = {
+  VERSION: `SELECT version() as version`,
+};
+
+class MysqlDatabaseInspector {
+  constructor(db) {
+    this.db = db;
+  }
+
+  async getInformation() {
+    let database;
+    let versionNumber;
+    try {
+      const [results] = await this.db.connection.raw(SQL_QUERIES.VERSION);
+      const versionSplit = results[0].version.split('-');
+      const databaseName = versionSplit[1];
+      versionNumber = versionSplit[0];
+      database = databaseName && databaseName.toLowerCase() === 'mariadb' ? MARIADB : MYSQL;
+    } catch (e) {
+      return {
+        database: null,
+        version: null,
+      };
+    }
+
+    return {
+      database,
+      version: versionNumber,
+    };
+  }
+}
+
+module.exports = MysqlDatabaseInspector;

package/lib/dialects/mysql/index.js

@@ -1,13 +1,19 @@
 'use strict';
 
+const semver = require('semver');
+
 const { Dialect } = require('../dialect');
 const MysqlSchemaInspector = require('./schema-inspector');
+const MysqlDatabaseInspector = require('./database-inspector');
+const { MYSQL } = require('./constants');
 
 class MysqlDialect extends Dialect {
   constructor(db) {
     super(db);
 
     this.schemaInspector = new MysqlSchemaInspector(db);
+    this.databaseInspector = new MysqlDatabaseInspector(db);
+    this.info = null;
   }
 
   configure() {
@@ -38,6 +44,8 @@ class MysqlDialect extends Dialect {
     } catch (err) {
       // Ignore error due to lack of session permissions
     }
+
+    this.info = await this.databaseInspector.getInformation();
   }
 
   async startSchemaUpdate() {
@@ -57,6 +65,17 @@ class MysqlDialect extends Dialect {
     return true;
   }
 
+  supportsWindowFunctions() {
+    const isMysqlDB = !this.info.database || this.info.database === MYSQL;
+    const isBeforeV8 = !semver.valid(this.info.version) || semver.lt(this.info.version, '8.0.0');
+
+    if (isMysqlDB && isBeforeV8) {
+      return false;
+    }
+
+    return true;
+  }
+
   usesForeignKeys() {
     return true;
   }

package/lib/dialects/postgresql/index.js

@@ -15,7 +15,7 @@ class PostgresDialect extends Dialect {
     return true;
   }
 
-  initialize() {
+  async initialize() {
     this.db.connection.client.driver.types.setTypeParser(1082, 'text', (v) => v); // Don't cast DATE string to Date()
     this.db.connection.client.driver.types.setTypeParser(1700, 'text', parseFloat);
   }

package/lib/dialects/sqlite/index.js

@@ -5,13 +5,13 @@ const fse = require('fs-extra');
 
 const errors = require('../../errors');
 const { Dialect } = require('../dialect');
-const SqliteSchmeaInspector = require('./schema-inspector');
+const SqliteSchemaInspector = require('./schema-inspector');
 
 class SqliteDialect extends Dialect {
   constructor(db) {
     super(db);
 
-    this.schemaInspector = new SqliteSchmeaInspector(db);
+    this.schemaInspector = new SqliteSchemaInspector(db);
   }
 
   configure() {

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

@@ -1,6 +1,7 @@
 'use strict';
 
 const { map, isEmpty } = require('lodash/fp');
+
 const {
   isBidirectional,
   isOneToAny,
@@ -10,6 +11,7 @@ const {
   hasInverseOrderColumn,
 } = require('../metadata/relations');
 const { createQueryBuilder } = require('../query');
+const { addSchema } = require('../utils/knex');
 
 /**
  * If some relations currently exist for this oneToX relation, on the one side, this function removes them and update the inverse order if needed.
@@ -195,6 +197,12 @@ 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 = [];
@@ -241,7 +249,8 @@ const cleanOrderColumns = async ({ id, attribute, db, inverseRelIds, transaction
         )
         .transacting(trx);
       break;
-    default:
+    default: {
+      const joinTableName = addSchema(joinTable.name);
       await db.connection
         .raw(
           `UPDATE ?? as a
@@ -252,9 +261,10 @@ const cleanOrderColumns = async ({ id, attribute, db, inverseRelIds, transaction
                 WHERE ${where.join(' OR ')}
               ) AS b
               WHERE b.id = a.id`,
-          [joinTable.name, ...updateBinding, ...selectBinding, joinTable.name, ...whereBinding]
+          [joinTableName, ...updateBinding, ...selectBinding, joinTableName, ...whereBinding]
         )
         .transacting(trx);
+    }
     /*
       `UPDATE :joinTable: as a
         SET :orderColumn: = b.src_order, :inverseOrderColumn: = b.inv_order
@@ -271,6 +281,103 @@ const cleanOrderColumns = async ({ id, attribute, db, inverseRelIds, transaction
   }
 };
 
+const cleanOrderColumnsForOldDatabases = async ({
+  id,
+  attribute,
+  db,
+  inverseRelIds,
+  transaction: trx,
+}) => {
+  const { joinTable } = attribute;
+  const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } = joinTable;
+
+  const now = new Date().valueOf();
+
+  if (hasOrderColumn(attribute) && id) {
+    const tempOrderTableName = `tempOrderTableName_${now}`;
+    try {
+      await db.connection
+        .raw(
+          `
+          CREATE TEMPORARY TABLE :tempOrderTableName:
+            SELECT
+              id,
+              (
+                SELECT count(*)
+                FROM :joinTableName: b
+                WHERE a.:orderColumnName: >= b.:orderColumnName: AND a.:joinColumnName: = b.:joinColumnName: AND a.:joinColumnName: = :id
+              ) AS src_order
+            FROM :joinTableName: a`,
+          {
+            tempOrderTableName,
+            joinTableName: joinTable.name,
+            orderColumnName,
+            joinColumnName: joinColumn.name,
+            id,
+          }
+        )
+        .transacting(trx);
+      await db.connection
+        .raw(
+          `UPDATE ?? as a, (SELECT * FROM ??) AS b
+          SET ?? = b.src_order
+          WHERE a.id = b.id`,
+          [joinTable.name, tempOrderTableName, orderColumnName]
+        )
+        .transacting(trx);
+    } finally {
+      await db.connection
+        .raw(`DROP TEMPORARY TABLE IF EXISTS ??`, [tempOrderTableName])
+        .transacting(trx);
+    }
+  }
+
+  if (hasInverseOrderColumn(attribute) && !isEmpty(inverseRelIds)) {
+    const tempInvOrderTableName = `tempInvOrderTableName_${now}`;
+    try {
+      await db.connection
+        .raw(
+          `
+          CREATE TEMPORARY TABLE ??
+            SELECT
+              id,
+              (
+                SELECT count(*)
+                FROM ?? b
+                WHERE a.?? >= b.?? AND a.?? = b.?? AND a.?? IN (${inverseRelIds
+                  .map(() => '?')
+                  .join(', ')})
+              ) AS inv_order
+            FROM ?? a`,
+          [
+            tempInvOrderTableName,
+            joinTable.name,
+            inverseOrderColumnName,
+            inverseOrderColumnName,
+            inverseJoinColumn.name,
+            inverseJoinColumn.name,
+            inverseJoinColumn.name,
+            ...inverseRelIds,
+            joinTable.name,
+          ]
+        )
+        .transacting(trx);
+      await db.connection
+        .raw(
+          `UPDATE ?? as a, (SELECT * FROM ??) AS b
+            SET ?? = b.inv_order
+            WHERE a.id = b.id`,
+          [joinTable.name, tempInvOrderTableName, inverseOrderColumnName]
+        )
+        .transacting(trx);
+    } finally {
+      await db.connection
+        .raw(`DROP TEMPORARY TABLE IF EXISTS ??`, [tempInvOrderTableName])
+        .transacting(trx);
+    }
+  }
+};
+
 module.exports = {
   deletePreviousOneToAnyRelations,
   deletePreviousAnyToOneRelations,

package/lib/utils/knex.js

@@ -7,6 +7,16 @@ const isKnexQuery = (value) => {
   return value instanceof KnexBuilder || value instanceof KnexRaw;
 };
 
+/**
+ * Adds the name of the schema to the table name if the schema was defined by the user.
+ * Users can set the db schema only for Postgres in strapi database config.
+ */
+const addSchema = (tableName) => {
+  const schemaName = strapi.db.connection.getSchemaName();
+  return schemaName ? `${schemaName}.${tableName}` : tableName;
+};
+
 module.exports = {
   isKnexQuery,
+  addSchema,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.5.1",
+  "version": "4.5.2",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -36,11 +36,12 @@
     "fs-extra": "10.0.0",
     "knex": "1.0.7",
     "lodash": "4.17.21",
+    "semver": "7.3.8",
     "umzug": "3.1.1"
   },
   "engines": {
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "8c20ea2b5c5a115b78454086ea270dcd59b06004"
+  "gitHead": "bcb1b7f472aae2556a9b59d59ee66d241c497a3e"
 }