@strapi/database 4.6.0-beta.1 → 4.6.0

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.getConnection().schema.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.1",
+  "version": "4.6.0",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -31,10 +31,10 @@
     "test:unit": "jest --verbose"
   },
   "dependencies": {
-    "date-fns": "2.29.2",
+    "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": "2c0bcabdf0bf2a269fed50c6f23ba777845968a0"
+  "gitHead": "a9e55435c489f3379d88565bf3f729deb29bfb45"
 }