Allow the Postgres schema for the migration table to be specified through migrationStorageTableSchema (#265)

docs/README.md

@@ -150,7 +150,10 @@ database, using `sequelize`, but want to use a different table, you can change t
     "migrationStoragePath": "sequelizeMeta.json",
 
     // Use a different table name. Default: SequelizeMeta
-    "migrationStorageTableName": "sequelize_meta"
+    "migrationStorageTableName": "sequelize_meta",
+
+    // Use a different schema (Postgres-only). Default: undefined
+    "migrationStorageTableSchema": "sequelize_schema"
   }
 }
 ```

src/core/migrator.js

@@ -61,6 +61,24 @@ export function getMigrator (type, args) {
 
     return sequelize
       .authenticate()
+      .then(() => {
+        // Check if this is a PostgreSQL run and if there is a custom schema specified, and if there is, check if it's
+        // been created. If not, attempt to create it.
+        if (helpers.version.getDialectName() === 'pg') {
+          const customSchemaName = helpers.umzug.getSchema('migration');
+          if (customSchemaName && customSchemaName !== 'public') {
+            return sequelize.showAllSchemas().then(schemas => {
+              if (!_.includes(schemas, customSchemaName)) {
+                return sequelize.createSchema(customSchemaName);
+              } else {
+                return Bluebird.resolve();
+              }
+            });
+          }
+        }
+
+        return Bluebird.resolve();
+      })
       .then(() => migrator)
       .catch(e => helpers.view.error(e));
   });
@@ -127,7 +145,8 @@ export function addTimestampsToSchema (migrator) {
             }
           }, {
             tableName,
-            timestamps: true
+            timestamps: true,
+            schema: helpers.umzug.getSchema()
           });
 
           return SequelizeMeta.sync()
@@ -136,4 +155,4 @@ export function addTimestampsToSchema (migrator) {
             });
         });
     });
-}
+}

src/helpers/umzug-helper.js

@@ -34,13 +34,18 @@ module.exports = {
     return this.getStorageOption(type + 'StorageTableName', storageTableName[type]);
   },
 
+  getSchema (type) {
+    return this.getStorageOption(type + 'StorageTableSchema', undefined);
+  },
+
   getStorageOptions (type, extraOptions) {
     const options = {};
 
     if (this.getStorage(type) === 'json') {
       options.path = this.getStoragePath(type);
     } else if (this.getStorage(type) === 'sequelize') {
       options.tableName = this.getTableName(type);
+      options.schema = this.getSchema(type);
     }
 
     _.assign(options, extraOptions);

test/db/migrate.test.js

@@ -143,6 +143,35 @@ const _         = require('lodash');
         });
       });
     });
+
+    describe('custom meta schema', () => {
+      it('correctly uses the defined schema', function (done) {
+        const self = this;
+
+        prepare(() => {
+          if (Support.dialectIsPostgres()) {
+            helpers.readSchemas(self.sequelize, schemas => {
+              expect(schemas.sort()).to.eql(['sequelize_schema']);
+
+              // Tables from public should still be the same.
+              helpers.readTables(self.sequelize, tables => {
+                expect(tables.sort()).to.eql(['Person', 'Task']);
+                done();
+              });
+            });
+          } else {
+            // If not Postgres, the schema option gets prepended to the table name.
+            helpers.readTables(self.sequelize, tables => {
+              expect(tables.sort()).to.eql(['Person', 'Task', 'sequelize_schema.SequelizeMeta']);
+              done();
+            });
+          }
+        }, {
+          migrationFile: 'new/*createPerson',
+          config:        { migrationStorageTableSchema: 'sequelize_schema' }
+        });
+      });
+    });
   });
 });
 

test/support/helpers.js

@@ -182,6 +182,14 @@ module.exports = {
       });
   },
 
+  readSchemas: function (sequelize, callback) {
+    return sequelize
+      .showAllSchemas()
+      .then(function (schemas) {
+        return callback(schemas.sort());
+      });
+  },
+
   countTable: function (sequelize, table, callback) {
     var QueryGenerator =  sequelize.getQueryInterface().QueryGenerator;
 

test/support/index.js

@@ -4,6 +4,7 @@ var fs        = require('fs');
 var path      = require('path');
 var Sequelize = require('sequelize');
 var _         = require('lodash');
+var Bluebird  = require('bluebird');
 var DataTypes = Sequelize;
 var Config    = require(__dirname + '/config/config');
 var expect    = require('expect.js');
@@ -90,27 +91,55 @@ var Support = {
   },
 
   clearDatabase: function (sequelize, callback) {
-    sequelize
-      .getQueryInterface()
-      .dropAllTables()
-      .then(function () {
-        if (sequelize.daoFactoryManager) {
-          sequelize.daoFactoryManager.daos = [];
-        } else {
-          sequelize.modelManager.models = [];
-        }
-
-        return sequelize
-          .getQueryInterface()
-          .dropAllEnums()
-            .then(callback)
-            .catch(function (err) {
-              console.log('Error in support.clearDatabase() dropAllEnums() :: ', err);
+    function dropAllTables() {
+      return sequelize
+        .getQueryInterface()
+        .dropAllTables()
+        .then(function () {
+          if (sequelize.daoFactoryManager) {
+            sequelize.daoFactoryManager.daos = [];
+          } else {
+            sequelize.modelManager.models = [];
+          }
+
+          return sequelize
+            .getQueryInterface()
+            .dropAllEnums()
+              .then(callback)
+              .catch(function (err) {
+                console.log('Error in support.clearDatabase() dropAllEnums() :: ', err);
+              });
+        })
+        .catch(function (err) {
+          console.log('Error in support.clearDatabase() dropAllTables() :: ', err);
+        });
+    };
+
+    // If Postgres, loop through each of the non-public schemas and DROP/re-CREATE them.
+    if (this.dialectIsPostgres()) {
+      sequelize
+        .showAllSchemas()
+        .then(function (schemas) {
+          // showAllSchemas() leaves off the public schema.
+          let searchPathSchemas = schemas.join(', ');
+          let promise = Bluebird.resolve();
+
+          _.forEach(schemas, function (schema) {
+            promise = promise.then(function () {
+              return sequelize
+                .dropSchema(schema)
+                .then(function() {
+                  return sequelize.createSchema(schema)
+                });
             });
-      })
-      .catch(function (err) {
-        console.log('Error in support.clearDatabase() dropAllTables() :: ', err);
-      });
+          });
+
+          // Drop the public schema tables.
+          promise.then(dropAllTables);
+        });
+    } else {
+      return dropAllTables();
+    }
   },
 
   getSupportedDialects: function () {