refactor: refactor belongsToUpdater to class (#595)

GuillaumeCisco · web-flow · commit 164d89842bee · 2021-01-18T10:10:35.000+01:00
diff --git a/src/services/belongs-to-updater.js b/src/services/belongs-to-updater.js
@@ -1,40 +1,47 @@
 const _ = require('lodash');
 const orm = require('../utils/orm');
+const associationRecord = require('../utils/association-record');
 
-function BelongsToUpdater(model, assoc, opts, params, data) {
-  this.perform = function perform() {
-    return orm.findRecord(model, params.recordId)
-      .then((record) => {
-        // WORKAROUND: Make the hasOne associations update work while waiting
-        //             for the Sequelize 4 release with the fix of the following
-        //             issue: https://github.com/sequelize/sequelize/issues/6069
-        // TODO: Once Sequelize 4 is mainstream, use the following code instead:
-        //       return record['set' + _.upperFirst(params.associationName)](
-        //         data.data ? data.data.id : null);
-        let isHasOne = false;
-        let modelAssociation;
-
-        _.each(model.associations, (association) => {
-          if (association.associationAccessor === params.associationName) {
-            isHasOne = association.associationType === 'HasOne';
-            modelAssociation = association.target;
-          }
-        });
-
-        const setterName = `set${_.upperFirst(params.associationName)}`;
-
-        // NOTICE: Enable model hooks to change fields values during an association update.
-        const options = { fields: null };
-
-        if (isHasOne && data.data) {
-          return orm.findRecord(modelAssociation, data.data.id)
-            .then((recordAssociated) => {
-              record[setterName](recordAssociated, options);
-            });
-        }
-        return record[setterName](data.data ? data.data.id : null, options);
-      });
-  };
+// WORKAROUND: Make the hasOne associations update work while waiting
+//             for the Sequelize 4 release with the fix of the following
+//             issue: https://github.com/sequelize/sequelize/issues/6069
+const getTargetKey = async (pk, association) => {
+  let targetKey = pk;
+
+  if (association.associationType === 'HasOne') {
+    targetKey = await associationRecord.get(association.target, pk);
+  }
+
+  return targetKey;
+};
+
+class BelongsToUpdater {
+  constructor(model, assoc, opts, params, data) {
+    this.model = model;
+    this.assoc = assoc;
+    this.opts = opts;
+    this.params = params;
+    this.data = data;
+  }
+
+  async perform() {
+    const { associationName, recordId } = this.params;
+    const record = await orm.findRecord(this.model, recordId);
+    const association = Object.values(this.model.associations)
+      .find((a) => a.associationAccessor === associationName);
+
+    if (association && this.data.data) {
+      const pk = this.data.data.id;
+      const targetKey = await getTargetKey(pk, association);
+
+      // NOTICE: Enable model hooks to change fields values during an association update.
+      const options = { fields: null };
+      const setterName = `set${_.upperFirst(associationName)}`;
+      return record[setterName](targetKey, options);
+    }
+
+    return null;
+  }
 }
 
 module.exports = BelongsToUpdater;
diff --git a/src/utils/association-record.js b/src/utils/association-record.js
@@ -0,0 +1,11 @@
+import orm from './orm';
+
+async function get(model, pk) {
+  const record = await orm.findRecord(model, pk);
+  if (!record) {
+    throw new Error(`related ${model.name} with pk ${pk} does not exist.`);
+  }
+  return record;
+}
+
+exports.get = get;
diff --git a/test/databases.test.js b/test/databases.test.js
@@ -9,6 +9,7 @@ const LineStatGetter = require('../src/services/line-stat-getter');
 const ResourcesGetter = require('../src/services/resources-getter');
 const ResourceGetter = require('../src/services/resource-getter');
 const ResourceCreator = require('../src/services/resource-creator');
+const BelongsToUpdater = require('../src/services/belongs-to-updater');
 const ResourceRemover = require('../src/services/resource-remover');
 const HasManyGetter = require('../src/services/has-many-getter');
 const HasManyDissociator = require('../src/services/has-many-dissociator');
@@ -45,6 +46,20 @@ const HasManyDissociator = require('../src/services/has-many-dissociator');
       age: { type: Sequelize.INTEGER },
     });
 
+    models.member = sequelize.define('member', {
+      name: { type: Sequelize.STRING },
+    });
+
+    models.membership = sequelize.define('membership', {
+      type: { type: Sequelize.STRING },
+      memberId: { type: Sequelize.INTEGER },
+    });
+
+    models.friend = sequelize.define('friend', {
+      name: { type: Sequelize.STRING },
+      memberId: { type: Sequelize.INTEGER },
+    });
+
     models.bike = sequelize.define('bike', {
       id: {
         type: Sequelize.UUID,
@@ -104,6 +119,10 @@ const HasManyDissociator = require('../src/services/has-many-dissociator');
     models.user.hasMany(models.address);
     models.team.belongsToMany(models.user, { through: 'userTeam' });
     models.user.belongsToMany(models.team, { through: 'userTeam' });
+    models.membership.belongsTo(models.member);
+    models.member.hasOne(models.membership);
+    models.member.hasMany(models.friend);
+    models.friend.belongsTo(models.member);
 
     Interface.Schemas = {
       schemas: {
@@ -219,6 +238,38 @@ const HasManyDissociator = require('../src/services/has-many-dissociator');
             { field: 'team', type: 'Number', reference: 'team.id' },
           ],
         },
+        member: {
+          name: 'member',
+          idField: 'id',
+          primaryKeys: ['id'],
+          isCompositePrimary: false,
+          fields: [
+            { field: 'id', type: 'Number' },
+            { field: 'name', type: 'String' },
+          ],
+        },
+        membership: {
+          name: 'membership',
+          idField: 'id',
+          primaryKeys: ['id'],
+          isCompositePrimary: false,
+          fields: [
+            { field: 'id', type: 'Number' },
+            { field: 'type', type: 'String' },
+            { field: 'member', type: 'Number', reference: 'member.id' },
+          ],
+        },
+        friend: {
+          name: 'friend',
+          idField: 'id',
+          primaryKeys: ['id'],
+          isCompositePrimary: false,
+          fields: [
+            { field: 'id', type: 'Number' },
+            { field: 'name', type: 'String' },
+            { field: 'member', type: 'Number', reference: 'member.id' },
+          ],
+        },
       },
     };
 
@@ -504,6 +555,111 @@ const HasManyDissociator = require('../src/services/has-many-dissociator');
       });
     });
 
+    describe('resources > resources updater', () => {
+      describe('update a record on a collection', () => {
+        it('should update a record', async () => {
+          expect.assertions(2);
+          const { models } = initializeSequelize();
+          try {
+            await new ResourceCreator(models.member, {
+              id: 1,
+              name: 'foo',
+            }).perform();
+            await new ResourceCreator(models.member, {
+              id: 2,
+              name: 'bar',
+            }).perform();
+            await new ResourceCreator(models.friend, {
+              id: 1,
+              name: 'foo',
+              memberId: 1,
+            }).perform();
+            const result = await new BelongsToUpdater(models.friend, null, null, {
+              recordId: '1',
+              associationName: 'member',
+            }, {
+              data: {
+                id: '2',
+                type: 'member',
+              },
+            }).perform();
+
+            expect(result.id).toStrictEqual(1);
+            expect(result.memberId).toStrictEqual('2');
+          } finally {
+            connectionManager.closeConnection();
+          }
+        });
+
+        it('should update a record with hasOne association', async () => {
+          expect.assertions(2);
+          const { models } = initializeSequelize();
+          try {
+            await new ResourceCreator(models.membership, {
+              id: 1,
+              type: 'basic',
+              memberId: 1,
+            }).perform();
+            await new ResourceCreator(models.membership, {
+              id: 2,
+              type: 'premium',
+              memberId: 2,
+            }).perform();
+            await new BelongsToUpdater(models.member, null, null, {
+              recordId: '1',
+              associationName: 'membership',
+            }, {
+              data: {
+                id: '2',
+                type: 'membership',
+              },
+            }).perform();
+
+            const member = await models.member.findOne({
+              where: { id: 1 },
+              include: { model: models.membership },
+            });
+            expect(member).not.toBeNull();
+            expect(member.membership.id).toStrictEqual(2);
+          } finally {
+            connectionManager.closeConnection();
+          }
+        });
+
+        it('should not update a record', async () => {
+          expect.assertions(1);
+          const { models } = initializeSequelize();
+          try {
+            await expect(new BelongsToUpdater(models.member, null, null, {
+              recordId: '1',
+              associationName: 'membership',
+            }, {
+              data: {
+                id: '999',
+                type: 'membership',
+              },
+            }).perform()).rejects.toThrow(Error('related membership with pk 999 does not exist.'));
+          } finally {
+            connectionManager.closeConnection();
+          }
+        });
+
+        it('should not update a record if no data', async () => {
+          expect.assertions(1);
+          const { models } = initializeSequelize();
+          try {
+            const result = await new BelongsToUpdater(models.member, null, null, {
+              recordId: '1',
+              associationName: 'membership',
+            }, {}).perform();
+            expect(result).toBeNull();
+          } finally {
+            connectionManager.closeConnection();
+          }
+        });
+      });
+    });
+
     describe('resources > resources getter', () => {
       describe('request on the resources getter without page size', () => {
         it('should generate a valid SQL query', async () => {
