@strapi/database 4.6.0-beta.1 → 4.6.0

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/__tests__/relations-orderer.test.js

@@ -1,85 +1,164 @@
 'use strict';
 
-const relationsOrderer = require('../relations-orderer');
+const { relationsOrderer } = require('../relations-orderer');
 
-describe('relations orderer', () => {
-  test('connect at the end', () => {
-    const orderer = relationsOrderer(
-      [
+describe('Given I have some relations in the database', () => {
+  describe('When I connect a relation at the end', () => {
+    test('Then it is placed at the end with the correct order', () => {
+      const orderer = relationsOrderer(
+        [
+          { id: 2, order: 4 },
+          { id: 3, order: 10 },
+        ],
+        'id',
+        'order'
+      );
+
+      orderer.connect([{ id: 4, position: { end: true } }, { id: 5 }]);
+
+      expect(orderer.get()).toMatchObject([
         { id: 2, order: 4 },
         { id: 3, order: 10 },
-      ],
-      'id',
-      'order'
-    );
-
-    orderer.connect([{ id: 4, position: { end: true } }, { id: 5 }]);
-
-    expect(orderer.get()).toMatchObject([
-      { id: 2, order: 4 },
-      { id: 3, order: 10 },
-      { id: 4, order: 10.5 },
-      { id: 5, order: 10.5 },
-    ]);
+        { id: 4, order: 10.5 },
+        { id: 5, order: 10.5 },
+      ]);
+    });
   });
 
-  test('connect at the start', () => {
-    const orderer = relationsOrderer(
-      [
+  describe('When I connect a relation at the start', () => {
+    test('Then it is placed at the start with the correct order', () => {
+      const orderer = relationsOrderer(
+        [
+          { id: 2, order: 4 },
+          { id: 3, order: 10 },
+        ],
+        'id',
+        'order'
+      );
+
+      orderer.connect([{ id: 4, position: { start: true } }]);
+
+      expect(orderer.get()).toMatchObject([
+        { id: 4, order: 0.5 },
         { id: 2, order: 4 },
         { id: 3, order: 10 },
-      ],
-      'id',
-      'order'
-    );
-
-    orderer.connect([{ id: 4, position: { start: true } }]);
-
-    expect(orderer.get()).toMatchObject([
-      { id: 4, order: 0.5 },
-      { id: 2, order: 4 },
-      { id: 3, order: 10 },
-    ]);
+      ]);
+    });
   });
 
-  test('connect multiple relations', () => {
-    const orderer = relationsOrderer(
-      [
+  describe('When I connect multiple relations using before', () => {
+    test('Then they are correctly ordered', () => {
+      const orderer = relationsOrderer(
+        [
+          { id: 2, order: 4 },
+          { id: 3, order: 10 },
+        ],
+        'id',
+        'order'
+      );
+
+      orderer.connect([
+        { id: 4, position: { before: 3 } },
+        { id: 5, position: { before: 4 } },
+      ]);
+
+      expect(orderer.get()).toMatchObject([
         { id: 2, order: 4 },
+        { id: 5, order: 9.5 },
+        { id: 4, order: 9.5 },
         { id: 3, order: 10 },
-      ],
-      'id',
-      'order'
-    );
-
-    orderer.connect([
-      { id: 4, position: { before: 2 } },
-      { id: 4, position: { before: 3 } },
-      { id: 5, position: { before: 4 } },
-    ]);
-
-    expect(orderer.get()).toMatchObject([
-      { id: 2, order: 4 },
-      { id: 5, order: 9.5 },
-      { id: 4, order: 9.5 },
-      { id: 3, order: 10 },
-    ]);
+      ]);
+    });
   });
 
-  test('connect with no initial relations', () => {
-    const orderer = relationsOrderer([], 'id', 'order');
-
-    orderer.connect([
-      { id: 1, position: { start: true } },
-      { id: 2, position: { start: true } },
-      { id: 3, position: { after: 1 } },
-      { id: 1, position: { after: 2 } },
-    ]);
-
-    expect(orderer.get()).toMatchObject([
-      { id: 2, order: 0.5 },
-      { id: 1, order: 0.5 },
-      { id: 3, order: 0.5 },
-    ]);
+  describe('When you connect multiple disordered relations', () => {
+    test('Then they are correctly ordered', () => {
+      const orderer = relationsOrderer(
+        [
+          { id: 1, order: 1 },
+          { id: 2, order: 2 },
+          { id: 3, order: 3 },
+        ],
+        'id',
+        'order'
+      );
+
+      orderer.connect([
+        { id: 5, position: { before: 1 } },
+        { id: 1, position: { before: 2 } },
+        { id: 2, position: { end: true } },
+      ]);
+
+      expect(orderer.get()).toMatchObject([
+        { id: 5, order: 0.5 },
+        { id: 1, order: 1.5 },
+        { id: 3, order: 3 },
+        { id: 2, order: 3.5 },
+      ]);
+    });
+  });
+
+  describe('When you connect a relation before a non-existing relation in non-strict mode', () => {
+    test('Then it is placed at the end', () => {
+      const orderer = relationsOrderer(
+        [
+          { id: 1, order: 1 },
+          { id: 2, order: 2 },
+          { id: 3, order: 3 },
+        ],
+        'id',
+        'order',
+        false
+      );
+
+      orderer.connect([{ id: 4, position: { before: 5 } }]);
+
+      expect(orderer.get()).toMatchObject([
+        { id: 1, order: 1 },
+        { id: 2, order: 2 },
+        { id: 3, order: 3 },
+        { id: 4, order: 3.5 },
+      ]);
+    });
+  });
+});
+
+describe('Given there are no relations in the database', () => {
+  describe('When you connect multiple new relations', () => {
+    test('Then they are correctly ordered', () => {
+      const orderer = relationsOrderer([], 'id', 'order');
+
+      orderer.connect([
+        { id: 1, position: { start: true } },
+        { id: 2, position: { start: true } },
+        { id: 3, position: { after: 1 } },
+      ]);
+
+      expect(orderer.get()).toMatchObject([
+        { id: 2, order: 0.5 },
+        { id: 1, order: 0.5 },
+        { id: 3, order: 0.5 },
+      ]);
+    });
+  });
+
+  describe('When you connect multiple disordered relations', () => {
+    test('Then they are correctly ordered', () => {
+      const orderer = relationsOrderer([], 'id', 'order');
+
+      orderer.connect([
+        { id: 5, position: { before: 1 } },
+        { id: 1, position: { before: 2 } },
+        { id: 2, position: { end: true } },
+        { id: 3, position: { after: 1 } },
+      ]);
+
+      expect(orderer.get()).toMatchObject([
+        { id: 5, order: 0.5 },
+        { id: 1, order: 0.5 },
+        { id: 3, order: 0.5 },
+        { id: 2, order: 0.5 },
+      ]);
+    });
   });
 });

package/lib/entity-manager/__tests__/sort-connect-array.test.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const { sortConnectArray } = require('../relations-orderer');
+
+describe('sortConnectArray', () => {
+  test('sorts connect array', () => {
+    const sortConnect = sortConnectArray([
+      { id: 5, position: { before: 1 } },
+      { id: 1, position: { before: 2 } },
+      { id: 2, position: { end: true } },
+      { id: 3, position: { after: 1 } },
+    ]);
+
+    expect(sortConnect).toMatchObject([
+      { id: 2, position: { end: true } },
+      { id: 1, position: { before: 2 } },
+      { id: 5, position: { before: 1 } },
+      { id: 3, position: { after: 1 } },
+    ]);
+  });
+
+  test('sorts connect array with initial relations', () => {
+    const sortConnect = sortConnectArray(
+      [
+        { id: 5, position: { before: 1 } },
+        { id: 1, position: { before: 2 } },
+        { id: 2, position: { end: true } },
+        { id: 3, position: { after: 1 } },
+      ],
+      [{ id: 1 }]
+    );
+
+    expect(sortConnect).toMatchObject([
+      { id: 5, position: { before: 1 } },
+      { id: 2, position: { end: true } },
+      { id: 1, position: { before: 2 } },
+      { id: 3, position: { after: 1 } },
+    ]);
+  });
+
+  test("error if position doesn't exist", () => {
+    const sortConnect = () => sortConnectArray([{ id: 1, position: { after: 2 } }]);
+
+    expect(sortConnect).toThrowError(
+      'There was a problem connecting relation with id 1 at position {"after":2}. The relation with id 2 needs to be connected first.'
+    );
+  });
+
+  test('error with circular references', () => {
+    const sortConnect = () =>
+      sortConnectArray(
+        [
+          { id: 2, position: { after: 1 } },
+          { id: 3, position: { after: 1 } },
+          { id: 1, position: { after: 3 } },
+        ],
+        []
+      );
+
+    expect(sortConnect).toThrowError(
+      'A circular reference was found in the connect array. One relation is trying to connect before/after another one that is trying to connect before/after it'
+    );
+  });
+
+  test('error when connecting same relation twice', () => {
+    const sortConnect = () =>
+      sortConnectArray(
+        [
+          { id: 1, position: { after: 2 } },
+          { id: 1, position: { after: 3 } },
+        ],
+        []
+      );
+
+    expect(sortConnect).toThrowError(
+      'The relation with id 1 is already connected. You cannot connect the same relation twice.'
+    );
+  });
+});

package/lib/entity-manager/index.js

@@ -39,7 +39,7 @@ const {
   deleteRelations,
   cleanOrderColumns,
 } = require('./regular-relations');
-const relationsOrderer = require('./relations-orderer');
+const { relationsOrderer } = require('./relations-orderer');
 
 const toId = (value) => value.id || value;
 const toIds = (value) => castArray(value || []).map(toId);
@@ -78,6 +78,9 @@ const toAssocs = (data) => {
   }
 
   return {
+    options: {
+      strict: data?.options?.strict,
+    },
     connect: toIdArray(data?.connect).map((elm) => ({
       id: elm.id,
       position: elm.position ? elm.position : { end: true },
@@ -224,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) {
@@ -308,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();
@@ -379,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) {
@@ -583,7 +586,12 @@ const createEntityManager = (db) => {
             });
           } else if (cleanRelationData.connect && hasOrderColumn(attribute)) {
             // use position attributes to calculate order
-            const orderMap = relationsOrderer([], inverseJoinColumn.name, joinTable.orderColumnName)
+            const orderMap = relationsOrderer(
+              [],
+              inverseJoinColumn.name,
+              joinTable.orderColumnName,
+              true // Always make an strict connect when inserting
+            )
               .connect(relsToAdd)
               .get()
               // set the order based on the order of the ids
@@ -873,7 +881,8 @@ const createEntityManager = (db) => {
                 const orderMap = relationsOrderer(
                   adjacentRelations,
                   inverseJoinColumn.name,
-                  joinTable.orderColumnName
+                  joinTable.orderColumnName,
+                  cleanRelationData.options.strict
                 )
                   .connect(cleanRelationData.connect)
                   .getOrderMap();