@strapi/database 4.6.0-beta.1 → 4.6.0-beta.2

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 },
@@ -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();

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

@@ -296,7 +296,9 @@ const cleanOrderColumnsForInnoDB = async ({
                 FROM :joinTableName: b
                 WHERE a.:orderColumnName: >= b.:orderColumnName: AND a.:joinColumnName: = b.:joinColumnName: AND a.:joinColumnName: = :id
               ) AS src_order
-            FROM :joinTableName: a`,
+            FROM :joinTableName: a
+            WHERE a.:joinColumnName: = :id
+            `,
           {
             tempOrderTableName,
             joinTableName: joinTable.name,
@@ -338,7 +340,9 @@ const cleanOrderColumnsForInnoDB = async ({
                   .map(() => '?')
                   .join(', ')})
               ) AS inv_order
-            FROM ?? a`,
+            FROM ?? a
+            WHERE a.?? IN (${inverseRelIds.map(() => '?').join(', ')})
+            `,
           [
             tempInvOrderTableName,
             joinTable.name,
@@ -349,6 +353,8 @@ const cleanOrderColumnsForInnoDB = async ({
             inverseJoinColumn.name,
             ...inverseRelIds,
             joinTable.name,
+            inverseJoinColumn.name,
+            ...inverseRelIds,
           ]
         )
         .transacting(trx);

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

@@ -1,6 +1,107 @@
 'use strict';
 
+const { castArray } = require('lodash/fp');
 const _ = require('lodash/fp');
+const { InvalidRelationError } = require('../errors');
+/**
+ * When connecting relations, the order you connect them matters.
+ *
+ * Example, if you connect the following relations:
+ *   { id: 5, position: { before: 1 } }
+ *   { id: 1, position: { before: 2 } }
+ *   { id: 2, position: { end: true } }
+ *
+ * Going through the connect array, id 5 has to be connected before id 1,
+ * so the order of id5 = id1 - 1. But the order value of id 1 is unknown.
+ * The only way to know the order of id 1 is to connect it first.
+ *
+ * This function makes sure the relations are connected in the right order:
+ *   { id: 2, position: { end: true } }
+ *   { id: 1, position: { before: 2 } }
+ *   { id: 5, position: { before: 1 } }
+ *
+ */
+const sortConnectArray = (connectArr, initialArr = [], strictSort = true) => {
+  const sortedConnect = [];
+  // Boolean to know if we have to recalculate the order of the relations
+  let needsSorting = false;
+  // Map to validate if relation is already in sortedConnect or DB.
+  const relationInInitialArray = initialArr.reduce((acc, rel) => ({ ...acc, [rel.id]: true }), {});
+  // Map to store the first index where a relation id is connected
+  const mappedRelations = connectArr.reduce((mapper, relation) => {
+    const adjacentRelId = relation.position?.before || relation.position?.after;
+
+    if (!relationInInitialArray[adjacentRelId] && !mapper[adjacentRelId]) {
+      needsSorting = true;
+    }
+
+    // If the relation is already in the array, throw an error
+    if (mapper[relation.id]) {
+      throw new InvalidRelationError(
+        `The relation with id ${relation.id} is already connected. ` +
+          'You cannot connect the same relation twice.'
+      );
+    }
+
+    return {
+      [relation.id]: { ...relation, computed: false },
+      ...mapper,
+    };
+  }, {});
+
+  // If we don't need to sort the connect array, we can return it as is
+  if (!needsSorting) return connectArr;
+
+  // Recursively compute in which order the relation should be connected
+  const computeRelation = (relation, relationsSeenInBranch) => {
+    const adjacentRelId = relation.position?.before || relation.position?.after;
+    const adjacentRelation = mappedRelations[adjacentRelId];
+
+    // If the relation has already been seen in the current branch,
+    // it means there is a circular reference
+    if (relationsSeenInBranch[adjacentRelId]) {
+      throw new InvalidRelationError(
+        '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'
+      );
+    }
+
+    // This relation has already been computed
+    if (mappedRelations[relation.id]?.computed) return;
+
+    mappedRelations[relation.id].computed = true;
+
+    // Relation does not have a before or after attribute or is in the initial array
+    if (!adjacentRelId || relationInInitialArray[adjacentRelId]) {
+      sortedConnect.push(relation);
+      return;
+    }
+
+    // Look if id is referenced elsewhere in the array
+    if (mappedRelations[adjacentRelId]) {
+      computeRelation(adjacentRelation, { ...relationsSeenInBranch, [relation.id]: true });
+      sortedConnect.push(relation);
+    } else if (strictSort) {
+      // If we reach this point, it means that the adjacent relation is not in the connect array
+      // and it is not in the database.
+      throw new InvalidRelationError(
+        `There was a problem connecting relation with id ${
+          relation.id
+        } at position ${JSON.stringify(
+          relation.position
+        )}. The relation with id ${adjacentRelId} needs to be connected first.`
+      );
+    } else {
+      // We are in non-strict mode so we can push the relation.
+      sortedConnect.push({ id: relation.id, position: { end: true } });
+    }
+  };
+
+  // Iterate over connectArr and populate sortedConnect
+  connectArr.forEach((relation) => computeRelation(relation, {}));
+
+  return sortedConnect;
+};
 
 /**
  * Responsible for calculating the relations order when connecting them.
@@ -23,34 +124,31 @@ const _ = require('lodash/fp');
  * - The final step would be to recalculate fractional order values.
  *      [ { id: 2, order: 4 }, { id: 5, order: 3.33 },  { id: 4, order: 3.66 }, { id: 3, order: 10 } ]
  *
- * Constraints:
- * - Expects you will never connect a relation before / after one that does not exist
- * - Expect initArr to have all relations referenced in the positional attributes
- *
  * @param {Array<*>} initArr - array of relations to initialize the class with
  * @param {string} idColumn - the column name of the id
  * @param {string} orderColumn - the column name of the order
+ * @param {boolean} strict - if true, will throw an error if a relation is connected adjacent to
+ *                               another one that does not exist
  * @return {*}
  */
-const relationsOrderer = (initArr, idColumn, orderColumn) => {
-  const arr = _.castArray(initArr || []).map((r) => ({
+const relationsOrderer = (initArr, idColumn, orderColumn, strict) => {
+  const computedRelations = _.castArray(initArr || []).map((r) => ({
     init: true,
     id: r[idColumn],
     order: r[orderColumn],
   }));
 
-  const maxOrder = _.maxBy('order', arr)?.order || 0;
+  const maxOrder = _.maxBy('order', computedRelations)?.order || 0;
 
-  // TODO: Improve performance by using a map
   const findRelation = (id) => {
-    const idx = arr.findIndex((r) => r.id === id);
-    return { idx, relation: arr[idx] };
+    const idx = computedRelations.findIndex((r) => r.id === id);
+    return { idx, relation: computedRelations[idx] };
   };
 
   const removeRelation = (r) => {
     const { idx } = findRelation(r.id);
     if (idx >= 0) {
-      arr.splice(idx, 1);
+      computedRelations.splice(idx, 1);
     }
   };
 
@@ -72,45 +170,46 @@ const relationsOrderer = (initArr, idColumn, orderColumn) => {
       idx = 0;
     } else {
       r.order = maxOrder + 0.5;
-      idx = arr.length;
+      idx = computedRelations.length;
     }
 
     // Insert the relation in the array
-    arr.splice(idx, 0, r);
+    computedRelations.splice(idx, 0, r);
   };
 
   return {
     disconnect(relations) {
-      _.castArray(relations).forEach((relation) => {
+      castArray(relations).forEach((relation) => {
         removeRelation(relation);
       });
       return this;
     },
     connect(relations) {
-      _.castArray(relations).forEach((relation) => {
+      sortConnectArray(castArray(relations), computedRelations, strict).forEach((relation) => {
         this.disconnect(relation);
 
         try {
           insertRelation(relation);
         } catch (err) {
-          strapi.log.error(err);
           throw new Error(
-            `Could not connect ${relation.id}, position ${JSON.stringify(
+            `There was a problem connecting relation with id ${
+              relation.id
+            } at position ${JSON.stringify(
               relation.position
-            )} is invalid`
+            )}. The list of connect relations is not valid`
           );
         }
       });
       return this;
     },
     get() {
-      return arr;
+      return computedRelations;
     },
     /**
      * Get a map between the relation id and its order
      */
     getOrderMap() {
-      return _(arr)
+      return _(computedRelations)
         .groupBy('order')
         .reduce((acc, relations) => {
           if (relations[0]?.init) return acc;
@@ -123,4 +222,4 @@ const relationsOrderer = (initArr, idColumn, orderColumn) => {
   };
 };
 
-module.exports = relationsOrderer;
+module.exports = { relationsOrderer, sortConnectArray };

package/lib/errors/index.js

@@ -5,6 +5,7 @@ const NotNullError = require('./not-null');
 const InvalidTimeError = require('./invalid-time');
 const InvalidDateError = require('./invalid-date');
 const InvalidDateTimeError = require('./invalid-datetime');
+const InvalidRelationError = require('./invalid-relation');
 
 module.exports = {
   DatabaseError,
@@ -12,4 +13,5 @@ module.exports = {
   InvalidTimeError,
   InvalidDateError,
   InvalidDateTimeError,
+  InvalidRelationError,
 };

package/lib/errors/invalid-relation.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const DatabaseError = require('./database');
+
+class InvalidRelationError extends DatabaseError {
+  constructor(message) {
+    super();
+    this.name = 'InvalidRelationFormat';
+    this.message = message || 'Invalid relation format';
+    this.details = {};
+  }
+}
+
+module.exports = InvalidRelationError;

package/lib/index.js

@@ -20,6 +20,8 @@ class Database {
       connection: {},
       settings: {
         forceMigration: true,
+        runMigrations: true,
+        ...config.settings,
       },
       ...config,
     };

package/lib/migrations/index.js

@@ -61,7 +61,7 @@ const createMigrationsProvider = (db) => {
     async shouldRun() {
       const pending = await migrations.pending();
 
-      return pending.length > 0;
+      return pending.length > 0 && db.config.settings.runMigrations;
     },
     async up() {
       await migrations.up();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "4.6.0-beta.1",
+  "version": "4.6.0-beta.2",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -31,7 +31,7 @@
     "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",
@@ -43,5 +43,5 @@
     "node": ">=14.19.1 <=18.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "2c0bcabdf0bf2a269fed50c6f23ba777845968a0"
+  "gitHead": "b852090f931cd21868c4016f24db2f9fdfc7a7ab"
 }