@strapi/database 4.9.0 → 4.9.2

package/lib/dialects/index.js

@@ -1,5 +1,8 @@
 'use strict';
 
+/**
+ * Require our dialect-specific code
+ */
 const getDialectClass = (client) => {
   switch (client) {
     case 'postgres':
@@ -13,12 +16,34 @@ const getDialectClass = (client) => {
   }
 };
 
+/**
+ * Get the dialect of a database client
+ *
+ * @param {string} The client value from a project database configuration
+ * @returns {string} The dialect of that client
+ */
+const getDialectName = (client) => {
+  switch (client) {
+    case 'postgres':
+      return 'postgres';
+    case 'mysql':
+    case 'mysql2':
+      return 'mysql';
+    case 'sqlite':
+    case 'sqlite-legacy':
+      return 'sqlite';
+    default:
+      throw new Error(`Unknown dialect ${client}`);
+  }
+};
+
 const getDialect = (db) => {
   const { client } = db.config.connection;
+  const dialectName = getDialectName(client);
 
-  const constructor = getDialectClass(client);
+  const constructor = getDialectClass(dialectName);
   const dialect = new constructor(db);
-  dialect.client = client;
+  dialect.client = dialectName;
 
   return dialect;
 };

package/lib/entity-manager/__tests__/relations-orderer.test.js

@@ -121,6 +121,28 @@ describe('Given I have some relations in the database', () => {
       ]);
     });
   });
+
+  describe('When you connect a relation before one with null order', () => {
+    test('Then it replaces null order values to 1 and properly reorders relations', () => {
+      const orderer = relationsOrderer(
+        [
+          { id: 2, order: null },
+          { id: 3, order: null },
+        ],
+        'id',
+        'order'
+      );
+
+      orderer.connect([{ id: 4, position: { before: 3 } }, { id: 5 }]);
+
+      expect(orderer.get()).toMatchObject([
+        { id: 2, order: 1 },
+        { id: 4, order: 0.5 },
+        { id: 3, order: 1 },
+        { id: 5, order: 1.5 },
+      ]);
+    });
+  });
 });
 
 describe('Given there are no relations in the database', () => {

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

@@ -135,7 +135,7 @@ const relationsOrderer = (initArr, idColumn, orderColumn, strict) => {
   const computedRelations = _.castArray(initArr || []).map((r) => ({
     init: true,
     id: r[idColumn],
-    order: r[orderColumn],
+    order: r[orderColumn] || 1,
   }));
 
   const maxOrder = _.maxBy('order', computedRelations)?.order || 0;

package/lib/index.js

@@ -57,15 +57,18 @@ class Database {
 
     async function commit() {
       if (notNestedTransaction) {
+        transactionCtx.clear();
         await trx.commit();
       }
     }
 
     async function rollback() {
       if (notNestedTransaction) {
+        transactionCtx.clear();
         await trx.rollback();
       }
     }
+
     if (!cb) {
       return {
         commit,

package/lib/transaction-context.js

@@ -6,11 +6,19 @@ const storage = new AsyncLocalStorage();
 
 const transactionCtx = {
   async run(store, cb) {
-    return storage.run(store, cb);
+    return storage.run({ trx: store }, cb);
   },
 
   get() {
-    return storage.getStore();
+    const store = storage.getStore();
+    return store?.trx;
+  },
+
+  clear() {
+    const store = storage.getStore();
+    if (store?.trx) {
+      store.trx = null;
+    }
   },
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.9.0",
+  "version": "4.9.2",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -28,9 +28,9 @@
     "lib": "./lib"
   },
   "scripts": {
-    "test:unit": "jest",
-    "test:unit:watch": "jest --watch",
-    "lint": "eslint ."
+    "test:unit": "run -T jest",
+    "test:unit:watch": "run -T jest --watch",
+    "lint": "run -T eslint ."
   },
   "dependencies": {
     "date-fns": "2.29.3",
@@ -45,5 +45,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "ffe3f4621ccc968ce56fda9a8317ec30d4bad205"
+  "gitHead": "91e0be2708e4d1e8ec731c75e73e54c0dfacb67d"
 }

package/lib/tests/knex-utils.test.api.js

@@ -1,33 +0,0 @@
-'use strict';
-
-const { createStrapiInstance } = require('../../../../../test/helpers/strapi');
-const { isKnexQuery } = require('../utils/knex');
-
-let strapi;
-
-describe('knex', () => {
-  beforeAll(async () => {
-    strapi = await createStrapiInstance();
-  });
-
-  afterAll(async () => {
-    await strapi.destroy();
-  });
-
-  describe('isKnexQuery', () => {
-    test('knex query: true', () => {
-      const res = isKnexQuery(strapi.db.connection('strapi_core_store_settings'));
-      expect(res).toBe(true);
-    });
-
-    test('knex raw: true', () => {
-      const res = isKnexQuery(strapi.db.connection.raw('SELECT * FROM strapi_core_store_settings'));
-      expect(res).toBe(true);
-    });
-
-    test.each([[''], [{}], [[]], [2], [new Date()]])('%s: false', (value) => {
-      const res = isKnexQuery(value);
-      expect(res).toBe(false);
-    });
-  });
-});

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

@@ -1,308 +0,0 @@
-'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/tests/db.test.api.js

@@ -1,55 +0,0 @@
-'use strict';
-
-// Test an API with all the possible filed types and simple filterings (no deep filtering, no relations)
-const { createStrapiInstance } = require('../../../../test/helpers/strapi');
-const { createTestBuilder } = require('../../../../test/helpers/builder');
-
-const builder = createTestBuilder();
-let strapi;
-
-const testCT = {
-  displayName: 'test',
-  singularName: 'test',
-  pluralName: 'tests',
-  kind: 'collectionType',
-  attributes: {
-    name: {
-      type: 'string',
-    },
-  },
-};
-
-const fixtures = {
-  test: [
-    {
-      name: 'Hugo LLORIS',
-    },
-    {
-      name: 'Samuel UMTITI',
-    },
-    {
-      name: 'Lucas HERNANDEZ',
-    },
-  ],
-};
-
-describe('Deep Filtering API', () => {
-  beforeAll(async () => {
-    await builder.addContentType(testCT).build();
-
-    strapi = await createStrapiInstance();
-  });
-
-  afterAll(async () => {
-    await strapi.destroy();
-    await builder.cleanup();
-  });
-
-  test('Return an array of ids on createMany', async () => {
-    const res = await strapi.db.query('api::test.test').createMany({ data: fixtures.test });
-
-    expect(res).toMatchObject({ count: expect.any(Number) });
-    expect(Array.isArray(res.ids)).toBe(true);
-    expect(res.ids.length > 0).toBe(true);
-  });
-});