Fixing #11 (enum name harmony) and #12 (pass down transaction)

src/index.js

@@ -20,46 +20,62 @@ export default (args) => {
     defaultValue,
     newValues,
     queryInterface,
+    sequelizeOptions = {},
     enumName = `enum_${tableName}_${columnName}`
   } = args;
 
   const newEnumName = `${enumName}_new`;
 
-  return queryInterface.sequelize.transaction((t) => {
-    const sequelizeOptions = { transaction: t };
+  return queryInterface.sequelize.transaction(sequelizeOptions, (t) => {
+    const newSequelizeOptions = {
+      ...(sequelizeOptions || {}),
+      transaction: t
+    };
 
     // Create a copy of the type
-    return createEnum(
-      { queryInterface, name: newEnumName, values: newValues, sequelizeOptions }
-    )
+    return createEnum({
+      queryInterface,
+      name: newEnumName,
+      values: newValues,
+      sequelizeOptions: newSequelizeOptions
+    })
       // Drop default value (ALTER COLUMN cannot cast default values)
-      .then(() => defaultValue && unsetDefaultValueFromEnum(
-        { queryInterface, tableName, columnName, sequelizeOptions }
-      ))
+      .then(() => defaultValue && unsetDefaultValueFromEnum({
+        queryInterface,
+        tableName,
+        columnName,
+        sequelizeOptions: newSequelizeOptions
+      }))
       // Change column type to the new ENUM TYPE
       .then(() => setColumnTypeToEnum({
         tableName,
         columnName,
         enumName: newEnumName,
         queryInterface,
-        sequelizeOptions
+        sequelizeOptions: newSequelizeOptions
       }))
       // Drop old ENUM
-      .then(() => dropEnum({ enumName, sequelizeOptions, queryInterface }))
+      .then(() => dropEnum(
+        {
+          name: enumName,
+          sequelizeOptions: newSequelizeOptions,
+          queryInterface
+        }
+      ))
       // Rename new ENUM name
       .then(() => renameEnum({
         oldEnumName: newEnumName,
         newEnumName: enumName,
         queryInterface,
-        sequelizeOptions
+        sequelizeOptions: newSequelizeOptions
       }))
       .then(() => defaultValue && setColumnDefault({
         tableName,
         columnName,
         defaultValue,
         defaultValueType: enumName,
         queryInterface,
-        sequelizeOptions
+        sequelizeOptions: newSequelizeOptions
       }));
   });
 };
@@ -165,27 +181,27 @@ export function getQueryToSetEnumType(tableName, columnName, enumName) {
  *
  * @param {Object} args
  * @param {Object} args.queryInterface
- * @param {String} args.enumName
+ * @param {String} args.name
  * @param {Object} args.sequelizeOptions
  *
  * @return {Promise}
  */
 export function dropEnum(args) {
   return args.queryInterface.sequelize.query(
-    getQueryToDropEnum(args.enumName),
+    getQueryToDropEnum(args.name),
     args.sequelizeOptions
   );
 }
 
 /**
  * Get the query to drop an Enum.
  *
- * @param {String} enumName
+ * @param {String} name
  *
  * @return {String}
  */
-export function getQueryToDropEnum(enumName) {
-  return `DROP TYPE "${enumName}"`;
+export function getQueryToDropEnum(name) {
+  return `DROP TYPE "${name}"`;
 }
 
 /**

test/index.js

@@ -22,6 +22,27 @@ describe('replaceEnum() - enum replacement:', () => {
     expect(transactionSpy.calledOnce).to.be.true;
   });
 
+  it('should run all queries within a sub-transaction', async () => {
+    const queryInterface = queryInterfaceMock();
+
+    const transactionSpy = sinon.spy(queryInterface.sequelize, 'transaction');
+
+    await replaceEnum({
+      queryInterface,
+      tableName: 'table1',
+      columnName: 'column1',
+      defaultValue: 'A',
+      newValues: ['A', 'B', 'C'],
+      enumName: 'enum1',
+      sequelizeOptions: { transaction: { mockParentTransaction: true } }
+    });
+
+    expect(transactionSpy.calledOnceWith(
+      sinon.match({ transaction: { mockParentTransaction: true } }),
+      sinon.match.func
+    )).to.be.true;
+  });
+
   it('should pass correct queries to queryInterface', async () => {
     const queryInterface = queryInterfaceMock();
 
@@ -84,11 +105,40 @@ describe('replaceEnum() - enum replacement:', () => {
 
     expect(queries).to.have.length(6, 'should create 6 queries');
 
-    queries.forEach((query) =>
+    queries.forEach((query) => {
       expect(query.options).to.deep.equal({
-        transaction: { mockTransaction: true }
-      })
-    );
+        transaction: {
+          mockTransaction: true,
+          sequelizeOptions: {}
+        }
+      });
+    });
+  });
+
+  it('should pass correct options - transaction and subtransaction', async () => {
+    const queryInterface = queryInterfaceMock();
+    await replaceEnum({
+      queryInterface,
+      tableName: 'table1',
+      columnName: 'column1',
+      defaultValue: 'A',
+      newValues: ['A', 'B', 'C'],
+      enumName: 'enum1',
+      sequelizeOptions: { transaction: { mockParentTransaction: true } }
+    });
+
+    const queries = queryInterface.getQueries();
+
+    expect(queries).to.have.length(6, 'should create 6 queries');
+
+    queries.forEach((query) => {
+      expect(query.options).to.deep.equal({
+        transaction: {
+          mockTransaction: true,
+          sequelizeOptions: { transaction: { mockParentTransaction: true } }
+        }
+      });
+    });
   });
 });
 
@@ -101,8 +151,11 @@ function queryInterfaceMock() {
         queries.push({ sql, options });
         return Promise.resolve();
       },
-      async transaction(callback) {
-        await callback({ mockTransaction: true });
+      async transaction(...args) {
+        const sequelizeOptions = (args.length > 1) ? args[0] : null;
+        const callback = args.length ? args[args.length - 1] : null;
+
+        await callback({ mockTransaction: true, sequelizeOptions });
         return Promise.resolve();
       }
     },