@strapi/database 4.6.0-beta.2 → 4.6.1

package/lib/__tests__/index.test.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const { Database } = require('../index');
+
+jest.mock('../connection', () =>
+  jest.fn(() => {
+    const trx = {
+      commit: jest.fn(),
+      rollback: jest.fn(),
+    };
+    return {
+      ...trx,
+      transaction: jest.fn(async () => trx),
+    };
+  })
+);
+
+jest.mock('../dialects', () => ({
+  getDialect: jest.fn(() => ({
+    configure: jest.fn(),
+    initialize: jest.fn(),
+  })),
+}));
+
+jest.mock('../migrations', () => ({
+  createMigrationsProvider: jest.fn(),
+}));
+
+const config = {
+  models: [
+    {
+      tableName: 'strapi_core_store_settings',
+    },
+  ],
+  connection: {
+    client: 'postgres',
+    connection: {
+      database: 'strapi',
+      user: 'strapi',
+      password: 'strapi',
+      port: 5432,
+      host: 'localhost',
+    },
+  },
+};
+
+describe('Database', () => {
+  describe('constructor', () => {
+    it('should throw an error if no config is provided', async () => {
+      expect(async () => Database.init()).rejects.toThrowError();
+    });
+
+    it('it should intialize if config is provided', async () => {
+      expect(() => Database.init(config)).toBeDefined();
+    });
+  });
+
+  describe('Transaction', () => {
+    it('transaction should be defined', async () => {
+      const db = await Database.init(config);
+      expect(db.transaction).toBeDefined();
+    });
+
+    it('should return value if transaction is complete', async () => {
+      const db = await Database.init(config);
+      const result = await db.transaction(async () => 'test');
+      expect(result).toBe('test');
+      expect(db.connection.commit).toHaveBeenCalledTimes(1);
+    });
+
+    it('rollback is called incase of error', async () => {
+      const db = await Database.init(config);
+      try {
+        await db.transaction(async () => {
+          throw new Error('test');
+        });
+      } catch {
+        /* ignore */
+      }
+      expect(db.connection.rollback).toHaveBeenCalledTimes(1);
+    });
+
+    it('should throw error', async () => {
+      const db = await Database.init(config);
+
+      expect(async () => {
+        await db.transaction(async () => {
+          throw new Error('test');
+        });
+      }).rejects.toThrowError('test');
+    });
+  });
+});

package/lib/dialects/postgresql/index.js

@@ -16,8 +16,16 @@ class PostgresDialect extends Dialect {
   }
 
   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);
+    this.db.connection.client.driver.types.setTypeParser(
+      this.db.connection.client.driver.types.builtins.DATE,
+      'text',
+      (v) => v
+    ); // Don't cast DATE string to Date()
+    this.db.connection.client.driver.types.setTypeParser(
+      this.db.connection.client.driver.types.builtins.NUMERIC,
+      'text',
+      parseFloat
+    );
   }
 
   usesForeignKeys() {

package/lib/entity-manager/index.js

@@ -227,7 +227,7 @@ const createEntityManager = (db) => {
 
       const trx = await strapi.db.transaction();
       try {
-        await this.attachRelations(uid, id, data, { transaction: trx });
+        await this.attachRelations(uid, id, data, { transaction: trx.get() });
 
         await trx.commit();
       } catch (e) {
@@ -311,7 +311,7 @@ const createEntityManager = (db) => {
 
       const trx = await strapi.db.transaction();
       try {
-        await this.updateRelations(uid, id, data, { transaction: trx });
+        await this.updateRelations(uid, id, data, { transaction: trx.get() });
         await trx.commit();
       } catch (e) {
         await trx.rollback();
@@ -382,7 +382,7 @@ const createEntityManager = (db) => {
 
       const trx = await strapi.db.transaction();
       try {
-        await this.deleteRelations(uid, id, { transaction: trx });
+        await this.deleteRelations(uid, id, { transaction: trx.get() });
 
         await trx.commit();
       } catch (e) {

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

@@ -198,38 +198,73 @@ const cleanOrderColumns = async ({ id, attribute, db, inverseRelIds, transaction
     return;
   }
 
+  // Handle databases that don't support window function ROW_NUMBER (here it's MySQL 5)
+  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);
+  }
+
   switch (strapi.db.dialect.client) {
     case 'mysql':
-      await cleanOrderColumnsForInnoDB({ id, attribute, db, inverseRelIds, transaction: trx });
+      // Here it's MariaDB and MySQL 8
+      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;
+    /*
+      UPDATE
+        :joinTable: as a,
+        (
+          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
+      SET :orderColumn: = b.src_order, :inverseOrderColumn: = b.inv_order
+      WHERE b.id = a.id;
+    */
     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
@@ -249,17 +284,17 @@ const cleanOrderColumns = async ({ id, attribute, db, inverseRelIds, transaction
         .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;
       */
     }
   }
@@ -267,9 +302,9 @@ const cleanOrderColumns = async ({ id, attribute, db, inverseRelIds, transaction
 
 /*
  * 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
+ * The use of a session variable instead of a window function makes the query compatible with MySQL 5
  */
-const cleanOrderColumnsForInnoDB = async ({
+const cleanOrderColumnsForOldDatabases = async ({
   id,
   attribute,
   db,
@@ -279,96 +314,68 @@ const cleanOrderColumnsForInnoDB = async ({
   const { joinTable } = attribute;
   const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } = joinTable;
 
-  const now = new Date().valueOf();
-  const randomHex = randomBytes(16).toString('hex');
+  const randomSuffix = `${new Date().valueOf()}_${randomBytes(16).toString('hex')}`;
 
   if (hasOrderColumn(attribute) && id) {
-    const tempOrderTableName = `orderTable_${now}_${randomHex}`;
-    try {
-      await db.connection
-        .raw(
-          `
-          CREATE 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
-            WHERE a.:joinColumnName: = :id
-            `,
-          {
-            tempOrderTableName,
-            joinTableName: joinTable.name,
-            orderColumnName,
-            joinColumnName: joinColumn.name,
-            id,
-          }
-        )
-        .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
-          SET ?? = b.src_order
-          WHERE a.id = b.id`,
-          [joinTable.name, tempOrderTableName, orderColumnName]
-        )
-        .transacting(trx);
-    } finally {
-      await db.connection.raw(`DROP TABLE IF EXISTS ??`, [tempOrderTableName]).transacting(trx);
-    }
+    // raw query as knex doesn't allow updating from a subquery
+    // https://github.com/knex/knex/issues/2504
+    const orderVar = `order_${randomSuffix}`;
+    await db.connection.raw(`SET @${orderVar} = 0;`).transacting(trx);
+    await db.connection
+      .raw(
+        `UPDATE :joinTableName: as a, (
+          SELECT id, (@${orderVar}:=@${orderVar} + 1) AS src_order
+          FROM :joinTableName:
+	        WHERE :joinColumnName: = :id
+	        ORDER BY :orderColumnName:
+        ) AS b
+        SET :orderColumnName: = b.src_order
+        WHERE a.id = b.id
+        AND a.:joinColumnName: = :id`,
+        {
+          joinTableName: joinTable.name,
+          orderColumnName,
+          joinColumnName: joinColumn.name,
+          id,
+        }
+      )
+      .transacting(trx);
   }
 
   if (hasInverseOrderColumn(attribute) && !isEmpty(inverseRelIds)) {
-    const tempInvOrderTableName = `invOrderTable_${now}_${randomHex}`;
-    try {
-      await db.connection
-        .raw(
-          `
-          CREATE TABLE ??
-            SELECT
-              id,
-              (
-                SELECT count(*)
-                FROM ?? b
-                WHERE a.?? >= b.?? AND a.?? = b.?? AND a.?? IN (${inverseRelIds
-                  .map(() => '?')
-                  .join(', ')})
-              ) AS inv_order
-            FROM ?? a
-            WHERE a.?? IN (${inverseRelIds.map(() => '?').join(', ')})
-            `,
-          [
-            tempInvOrderTableName,
-            joinTable.name,
-            inverseOrderColumnName,
-            inverseOrderColumnName,
-            inverseJoinColumn.name,
-            inverseJoinColumn.name,
-            inverseJoinColumn.name,
-            ...inverseRelIds,
-            joinTable.name,
-            inverseJoinColumn.name,
-            ...inverseRelIds,
-          ]
-        )
-        .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 TABLE IF EXISTS ??`, [tempInvOrderTableName]).transacting(trx);
-    }
+    const orderVar = `order_${randomSuffix}`;
+    const columnVar = `col_${randomSuffix}`;
+    await db.connection.raw(`SET @${orderVar} = 0;`).transacting(trx);
+    await db.connection
+      .raw(
+        `UPDATE ?? as a, (
+          SELECT
+          	id,
+            @${orderVar}:=CASE WHEN @${columnVar} = ?? THEN @${orderVar} + 1 ELSE 1 END AS inv_order,
+        	  @${columnVar}:=?? ??
+        	FROM ?? a
+        	WHERE ?? IN(${inverseRelIds.map(() => '?').join(', ')})
+        	ORDER BY ??, ??
+        ) AS b
+        SET ?? = b.inv_order
+        WHERE a.id = b.id
+        AND a.?? IN(${inverseRelIds.map(() => '?').join(', ')})`,
+        [
+          joinTable.name,
+          inverseJoinColumn.name,
+          inverseJoinColumn.name,
+          inverseJoinColumn.name,
+          joinTable.name,
+          inverseJoinColumn.name,
+          ...inverseRelIds,
+          inverseJoinColumn.name,
+          joinColumn.name,
+          inverseOrderColumnName,
+          inverseJoinColumn.name,
+          ...inverseRelIds,
+        ]
+      )
+      .transacting(trx);
   }
 };
 

package/lib/index.d.ts

@@ -163,6 +163,15 @@ export interface Database {
   connection: Knex;
 
   query<T extends keyof AllTypes>(uid: T): QueryFromContentType<T>;
+  transaction(
+    cb?: (params: {
+      trx: Knex.Transaction;
+      rollback: () => Promise<void>;
+      commit: () => Promise<void>;
+    }) => Promise<unknown>
+  ):
+    | Promise<unknown>
+    | { get: () => Knex.Transaction; rollback: () => Promise<void>; commit: () => Promise<void> };
 }
 export class Database implements Database {
   static transformContentTypes(contentTypes: any[]): ModelConfig[];

package/lib/index.js

@@ -8,9 +8,11 @@ const { createMigrationsProvider } = require('./migrations');
 const { createLifecyclesProvider } = require('./lifecycles');
 const createConnection = require('./connection');
 const errors = require('./errors');
+const transactionCtx = require('./transaction-context');
 
 // TODO: move back into strapi
 const { transformContentTypes } = require('./utils/content-types');
+const { validateDatabase } = require('./validations');
 
 class Database {
   constructor(config) {
@@ -49,6 +51,44 @@ class Database {
     return this.entityManager.getRepository(uid);
   }
 
+  async transaction(cb) {
+    const notNestedTransaction = !transactionCtx.get();
+    const trx = notNestedTransaction ? await this.connection.transaction() : transactionCtx.get();
+
+    async function commit() {
+      if (notNestedTransaction) {
+        await trx.commit();
+      }
+    }
+
+    async function rollback() {
+      if (notNestedTransaction) {
+        await trx.rollback();
+      }
+    }
+    if (!cb) {
+      return {
+        commit,
+        rollback,
+        get() {
+          return trx;
+        },
+      };
+    }
+
+    return transactionCtx.run(trx, async () => {
+      try {
+        const callbackParams = { trx, commit, rollback };
+        const res = await cb(callbackParams);
+        await commit();
+        return res;
+      } catch (error) {
+        await rollback();
+        throw error;
+      }
+    });
+  }
+
   getConnection(tableName) {
     const schema = this.connection.getSchemaName();
     const connection = tableName ? this.connection(tableName) : this.connection;
@@ -60,10 +100,6 @@ class Database {
     return schema ? trx.schema.withSchema(schema) : trx.schema;
   }
 
-  transaction() {
-    return this.connection.transaction();
-  }
-
   queryBuilder(uid) {
     return this.entityManager.createQueryBuilder(uid);
   }
@@ -76,7 +112,11 @@ class Database {
 
 // TODO: move into strapi
 Database.transformContentTypes = transformContentTypes;
-Database.init = async (config) => new Database(config);
+Database.init = async (config) => {
+  const db = new Database(config);
+  await validateDatabase(db);
+  return db;
+};
 
 module.exports = {
   Database,

package/lib/metadata/relations.js

@@ -16,6 +16,8 @@ const isAnyToMany = (attribute) => ['oneToMany', 'manyToMany'].includes(attribut
 const isBidirectional = (attribute) => hasInversedBy(attribute) || hasMappedBy(attribute);
 const isOwner = (attribute) => !isBidirectional(attribute) || hasInversedBy(attribute);
 const shouldUseJoinTable = (attribute) => attribute.useJoinTable !== false;
+const getJoinTableName = (tableName, attributeName) =>
+  _.snakeCase(`${tableName}_${attributeName}_links`);
 
 /**
  * Creates a oneToOne relation metadata
@@ -397,7 +399,7 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
     throw new Error(`Unknown target ${attribute.target}`);
   }
 
-  const joinTableName = _.snakeCase(`${meta.tableName}_${attributeName}_links`);
+  const joinTableName = getJoinTableName(meta.tableName, attributeName);
 
   const joinColumnName = _.snakeCase(`${meta.singularName}_id`);
   let inverseJoinColumnName = _.snakeCase(`${targetMeta.singularName}_id`);
@@ -560,4 +562,5 @@ module.exports = {
   isAnyToMany,
   hasOrderColumn,
   hasInverseOrderColumn,
+  getJoinTableName,
 };

package/lib/query/helpers/where.js

@@ -25,6 +25,8 @@ const OPERATORS = [
   '$between',
   '$startsWith',
   '$endsWith',
+  '$startsWithi',
+  '$endsWithi',
   '$contains',
   '$notContains',
   '$containsi',
@@ -283,10 +285,18 @@ const applyOperator = (qb, column, operator, value) => {
       qb.where(column, 'like', `${value}%`);
       break;
     }
+    case '$startsWithi': {
+      qb.whereRaw(`${fieldLowerFn(qb)} LIKE LOWER(?)`, [column, `${value}%`]);
+      break;
+    }
     case '$endsWith': {
       qb.where(column, 'like', `%${value}`);
       break;
     }
+    case '$endsWithi': {
+      qb.whereRaw(`${fieldLowerFn(qb)} LIKE LOWER(?)`, [column, `%${value}`]);
+      break;
+    }
     case '$contains': {
       qb.where(column, 'like', `%${value}%`);
       break;

package/lib/query/query-builder.js

@@ -4,6 +4,7 @@ const _ = require('lodash/fp');
 
 const { DatabaseError } = require('../errors');
 const helpers = require('./helpers');
+const transactionCtx = require('../transaction-context');
 
 const createQueryBuilder = (uid, db, initialState = {}) => {
   const meta = db.metadata.get(uid);
@@ -473,10 +474,18 @@ const createQueryBuilder = (uid, db, initialState = {}) => {
       try {
         const qb = this.getKnexQuery();
 
+        if (transactionCtx.get()) {
+          qb.transacting(transactionCtx.get());
+        }
+
         const rows = await qb;
 
         if (state.populate && !_.isNil(rows)) {
-          await helpers.applyPopulate(_.castArray(rows), state.populate, { qb: this, uid, db });
+          await helpers.applyPopulate(_.castArray(rows), state.populate, {
+            qb: this,
+            uid,
+            db,
+          });
         }
 
         let results = rows;

package/lib/tests/transactions.test.api.js

@@ -0,0 +1,308 @@
+'use strict';
+
+const { createStrapiInstance } = require('../../../../../test/helpers/strapi');
+
+let strapi;
+
+describe('transactions', () => {
+  let original;
+  beforeAll(async () => {
+    strapi = await createStrapiInstance();
+    original = await strapi.db
+      .queryBuilder('strapi::core-store')
+      .select(['*'])
+      .where({ id: 1 })
+      .execute();
+  });
+
+  afterAll(async () => {
+    await strapi.destroy();
+  });
+
+  afterEach(async () => {
+    await strapi.db
+      .queryBuilder('strapi::core-store')
+      .update({
+        key: original[0].key,
+      })
+      .where({ id: 1 })
+      .execute();
+  });
+
+  describe('using a transaction method', () => {
+    test('commits successfully', async () => {
+      await strapi.db.transaction(async () => {
+        await strapi.db
+          .queryBuilder('strapi::core-store')
+          .update({
+            key: 'wrong key',
+          })
+          .where({ id: 1 })
+          .execute();
+
+        await strapi.db
+          .queryBuilder('strapi::core-store')
+          .update({
+            key: 'new key',
+          })
+          .where({ id: 1 })
+          .execute();
+      });
+
+      const end = await strapi.db
+        .queryBuilder('strapi::core-store')
+        .select(['*'])
+        .where({ id: 1 })
+        .execute();
+
+      expect(end[0].key).toEqual('new key');
+    });
+
+    test('rollback successfully', async () => {
+      try {
+        await strapi.db.transaction(async () => {
+          // this is valid
+          await strapi.db
+            .queryBuilder('strapi::core-store')
+            .update({
+              key: 'wrong key',
+            })
+            .where({ id: 1 })
+            .execute();
+
+          // this throws
+          await strapi.db
+            .queryBuilder('invalid_uid')
+            .update({
+              key: 'bad key',
+              invalid_key: 'error',
+            })
+            .where({ id: 1 })
+            .execute();
+        });
+
+        expect('this should not be reached').toBe(false);
+      } catch (e) {
+        // do nothing
+      }
+
+      const end = await strapi.db
+        .queryBuilder('strapi::core-store')
+        .select(['*'])
+        .where({ id: 1 })
+        .execute();
+
+      expect(end[0].key).toEqual(original[0].key);
+    });
+
+    test('nested rollback -> rollback works', async () => {
+      try {
+        await strapi.db.transaction(async () => {
+          // this is valid
+          await strapi.db
+            .queryBuilder('strapi::core-store')
+            .update({
+              key: 'changed key',
+            })
+            .where({ id: 1 })
+            .execute();
+
+          // here we'll make a nested transaction that throws and then confirm we still have "changed key" from above
+          try {
+            await strapi.db.transaction(async () => {
+              await strapi.db
+                .queryBuilder('strapi::core-store')
+                .update({
+                  key: 'changed key - nested',
+                })
+                .where({ id: 1 })
+                .execute();
+
+              // this should throw and roll back
+              await strapi.db
+                .queryBuilder('invalid_uid')
+                .update({
+                  invalid_key: 'error',
+                })
+                .where({ id: 1 })
+                .execute();
+            });
+          } catch (e) {
+            // do nothing
+          }
+
+          // should equal the result from above
+          const result = await strapi.db
+            .queryBuilder('strapi::core-store')
+            .select(['*'])
+            .where({ id: 1 })
+            .execute();
+
+          expect(result[0].key).toEqual('changed key');
+
+          // this throws
+          await strapi.db
+            .queryBuilder('invalid_uid')
+            .update({
+              key: original[0].key,
+              invalid_key: 'error',
+            })
+            .where({ id: 1 })
+            .execute();
+        });
+
+        expect('this should not be reached').toBe(false);
+      } catch (e) {
+        // do nothing
+      }
+
+      const end = await strapi.db
+        .queryBuilder('strapi::core-store')
+        .select(['*'])
+        .where({ id: 1 })
+        .execute();
+
+      expect(end[0].key).toEqual(original[0].key);
+    });
+
+    test('nested commit -> rollback works', async () => {
+      try {
+        await strapi.db.transaction(async () => {
+          // this is valid
+          await strapi.db
+            .queryBuilder('strapi::core-store')
+            .update({
+              key: 'changed key',
+            })
+            .where({ id: 1 })
+            .execute();
+
+          // here we'll make a nested transaction that works, and then later we'll rollback the outer transaction
+          try {
+            await strapi.db.transaction(async () => {
+              await strapi.db
+                .queryBuilder('strapi::core-store')
+                .update({
+                  key: 'changed key - nested',
+                })
+                .where({ id: 1 })
+                .execute();
+            });
+          } catch (e) {
+            // do nothing
+          }
+
+          // should equal the result from above
+          const result = await strapi.db
+            .queryBuilder('strapi::core-store')
+            .select(['*'])
+            .where({ id: 1 })
+            .execute();
+
+          expect(result[0].key).toEqual('changed key - nested');
+
+          // this throws
+          await strapi.db
+            .queryBuilder('invalid_uid')
+            .update({
+              key: original[0].key,
+              invalid_key: 'error',
+            })
+            .where({ id: 1 })
+            .execute();
+        });
+
+        expect('this should not be reached').toBe(false);
+      } catch (e) {
+        // do nothing
+      }
+
+      const end = await strapi.db
+        .queryBuilder('strapi::core-store')
+        .select(['*'])
+        .where({ id: 1 })
+        .execute();
+
+      expect(end[0].key).toEqual(original[0].key);
+    });
+  });
+
+  describe('using a transaction object', () => {
+    test('commits successfully', async () => {
+      const trx = await strapi.db.transaction();
+
+      try {
+        await strapi.db
+          .queryBuilder('strapi::core-store')
+          .update({
+            key: 'wrong key',
+          })
+          .where({ id: 1 })
+          .transacting(trx.get())
+          .execute();
+
+        await strapi.db
+          .queryBuilder('strapi::core-store')
+          .update({
+            key: original[0].key,
+          })
+          .where({ id: 1 })
+          .transacting(trx.get())
+          .execute();
+
+        await trx.commit();
+      } catch (e) {
+        await trx.rollback();
+        console.log(e.message);
+        expect('this should not be reached').toBe(false);
+      }
+
+      const end = await strapi.db
+        .queryBuilder('strapi::core-store')
+        .select(['*'])
+        .where({ id: 1 })
+        .execute();
+
+      expect(end[0].key).toEqual('strapi_content_types_schema');
+    });
+
+    test('rollback successfully', async () => {
+      const trx = await strapi.db.transaction();
+
+      try {
+        await strapi.db
+          .queryBuilder('strapi::core-store')
+          .update({
+            key: 'wrong key',
+          })
+          .where({ id: 1 })
+          .transacting(trx.get())
+          .execute();
+
+        // this query should throw because it has errors
+        await strapi.db
+          .queryBuilder('invalid_uid')
+          .update({
+            key: 123,
+            key_not_here: 'this should error',
+          })
+          .where({ id: 'this should error' })
+          .transacting(trx.get())
+          .execute();
+
+        await trx.commit();
+        expect('this should not be reached').toBe(false);
+      } catch (e) {
+        await trx.rollback();
+      }
+
+      const end = await strapi.db
+        .queryBuilder('strapi::core-store')
+        .select(['*'])
+        .where({ id: 1 })
+        .execute();
+
+      expect(end[0].key).toEqual('strapi_content_types_schema');
+    });
+  });
+});

package/lib/transaction-context.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { AsyncLocalStorage } = require('async_hooks');
+
+const storage = new AsyncLocalStorage();
+
+const transactionCtx = {
+  async run(store, cb) {
+    return storage.run(store, cb);
+  },
+
+  get() {
+    return storage.getStore();
+  },
+};
+
+module.exports = transactionCtx;

package/lib/validations/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { validateRelations } = require('./relations');
+
+/**
+ * Validate if the database is in a valid state before starting the server.
+ *
+ * @param {*} db - Database instance
+ */
+async function validateDatabase(db) {
+  const relationErrors = await validateRelations(db);
+  const errorList = [...relationErrors];
+
+  if (errorList.length > 0) {
+    errorList.forEach((error) => strapi.log.error(error));
+    throw new Error('There are errors in some of your models. Please check the logs above.');
+  }
+}
+
+module.exports = { validateDatabase };

package/lib/validations/relations/bidirectional.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const types = require('../../types');
+const { getJoinTableName } = require('../../metadata/relations');
+
+const getLinksWithoutMappedBy = (db) => {
+  const relationsToUpdate = {};
+
+  db.metadata.forEach((contentType) => {
+    const attributes = contentType.attributes;
+
+    // For each relation attribute, add the joinTable name to tablesToUpdate
+    Object.values(attributes).forEach((attribute) => {
+      if (!types.isRelation(attribute.type)) return;
+
+      if (attribute.inversedBy) {
+        const invRelation = db.metadata.get(attribute.target).attributes[attribute.inversedBy];
+
+        // Both relations use inversedBy.
+        if (invRelation.inversedBy) {
+          relationsToUpdate[attribute.joinTable.name] = {
+            relation: attribute,
+            invRelation,
+          };
+        }
+      }
+    });
+  });
+
+  return Object.values(relationsToUpdate);
+};
+
+const isLinkTableEmpty = async (db, linkTableName) => {
+  // If the table doesn't exist, it's empty
+  const exists = await db.getSchemaConnection().hasTable(linkTableName);
+  if (!exists) return true;
+
+  const result = await db.getConnection().count('* as count').from(linkTableName);
+  return Number(result[0].count) === 0;
+};
+
+/**
+ * Validates bidirectional relations before starting the server.
+ * - If both sides use inversedBy, one of the sides must switch to mappedBy.
+ *    When this happens, two join tables exist in the database.
+ *    This makes sure you switch the side which does not delete any data.
+ *
+ * @param {*} db
+ * @return {*}
+ */
+const validateBidirectionalRelations = async (db) => {
+  const invalidLinks = getLinksWithoutMappedBy(db);
+  const errorList = [];
+
+  for (const { relation, invRelation } of invalidLinks) {
+    const contentType = db.metadata.get(invRelation.target);
+    const invContentType = db.metadata.get(relation.target);
+
+    // Generate the join table name based on the relation target table and attribute name.
+    const joinTableName = getJoinTableName(contentType.tableName, invRelation.inversedBy);
+    const inverseJoinTableName = getJoinTableName(invContentType.tableName, relation.inversedBy);
+
+    const joinTableEmpty = await isLinkTableEmpty(db, joinTableName);
+    const inverseJoinTableEmpty = await isLinkTableEmpty(db, inverseJoinTableName);
+
+    if (joinTableEmpty) {
+      process.emitWarning(
+        `Error on attribute "${invRelation.inversedBy}" in model "${contentType.singularName}" (${contentType.uid}).` +
+          ` Please modify your ${contentType.singularName} schema by renaming the key "inversedBy" to "mappedBy".` +
+          ` Ex: { "inversedBy": "${relation.inversedBy}" } -> { "mappedBy": "${relation.inversedBy}" }`
+      );
+    } else if (inverseJoinTableEmpty) {
+      // Its safe to delete the inverse join table
+      process.emitWarning(
+        `Error on attribute "${relation.inversedBy}" in model "${invContentType.singularName}" (${invContentType.uid}).` +
+          ` Please modify your ${invContentType.singularName} schema by renaming the key "inversedBy" to "mappedBy".` +
+          ` Ex: { "inversedBy": "${invRelation.inversedBy}" } -> { "mappedBy": "${invRelation.inversedBy}" }`
+      );
+    } else {
+      // Both sides have data in the join table
+    }
+  }
+
+  return errorList;
+};
+
+module.exports = {
+  validateBidirectionalRelations,
+};

package/lib/validations/relations/index.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const { validateBidirectionalRelations } = require('./bidirectional');
+
+/**
+ * Validates if relations data and tables are in a valid state before
+ * starting the server.
+ */
+const validateRelations = async (db) => {
+  const bidirectionalRelationsErrors = await validateBidirectionalRelations(db);
+  return [...bidirectionalRelationsErrors];
+};
+
+module.exports = { validateRelations };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.6.0-beta.2",
+  "version": "4.6.1",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -34,7 +34,7 @@
     "date-fns": "2.29.3",
     "debug": "4.3.4",
     "fs-extra": "10.0.0",
-    "knex": "1.0.7",
+    "knex": "2.4.0",
     "lodash": "4.17.21",
     "semver": "7.3.8",
     "umzug": "3.1.1"
@@ -43,5 +43,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "b852090f931cd21868c4016f24db2f9fdfc7a7ab"
+  "gitHead": "17a7845e3d453ea2e7911bda6ec25ed196dd5f16"
 }