Break sequelize models in separate folders

Question

My real question is: Is it possible to work with sequelize having the Models in separate folders?

I'm asking this because i'm trying to work with a modular structure in my application, to accomplish that i need to have the model, the controller and the routes in the same folder, here's what i mean:

├── node_modules
├── src
│   ├── client
│   │   └── ... //Frontend things managed by angular (like views, etc...)
│   └── server
|       ├── components
|       |   ├── db
|       |   |   ├── migrations
|       |   |   |   ├── users.js
|       |   |   |   └── ...
|       |   |   ├── seeders
|       |   |   ├── config.json
|       |   |   ├── options.json
|       |   |   └── index.js 
|       |   ├── env
|       |   └── ...
│       ├── modules //By module i mean an entity
|       |   ├── users
|       |   |   ├── users.model.js
|       |   |   ├── users.controller.js
|       |   |   └── index.js //Here i define the routes
|       |   └── ...
|       └── ...
|
├── package.json
└── server.js

How could i do that? how could i split the models into separate folders?

Maybe what i'm asking for is: How could i configure the models/index.js script to read the models from each directory?

models/index.js

'use strict';

var fs        = require('fs');
var path      = require('path');
var Sequelize = require('sequelize');
var basename  = path.basename(module.filename);
var env       = process.env.NODE_ENV || 'development';
var config    = require(__dirname + '/../config.json')[env];
var db        = {};

if (config.use_env_variable) {
  var sequelize = new Sequelize(process.env[config.use_env_variable]);
} else {
  var sequelize = new Sequelize(config.database, config.username, config.password, config);
}

fs
  .readdirSync(__dirname)
  .filter(function(file) {
    return (file.indexOf('.') !== 0) && (file !== basename);
  })
  .forEach(function(file) {
    if (file.slice(-3) !== '.js') return;
    var model = sequelize['import'](path.join(__dirname, file));
    db[model.name] = model;
  });

Object.keys(db).forEach(function(modelName) {
  if (db[modelName].associate) {
    db[modelName].associate(db);
  }
});

db.sequelize = sequelize;
db.Sequelize = Sequelize;

module.exports = db;

Something i was thinking is to look for the xxx.model.js under each folder of the modules directory having a structure like this:

modules
├── index.js //The above script configured to read the x.model.js in each folder
├── users
|   ├── users.model.js
|   ├── users.controller.js
|   └── ...
├── questions
|   ├── questions.model.js
|   ├── questions.controller.js
|   └── ...
└── ...

NOTE: I come from a Laravel background, i'm guessing how are migrations and models different in sequelize since when you define a model you tell the type, etc.. of the column, the same as the migration...

Most of my questions were resolved with [the docs](https://github.com/sequelize/cli#options) but not the breaking of the models folder — Jonathan Solorzano, Sep 13 '15 at 04:18
Could you tell me how you resolved your issue? I'm not getting much from the docs. — Sunil Kumar, Jul 22 '17 at 13:45
@JonathanSolorzano, did you find a solution for your problem? — Vijay Dev, Aug 16 '17 at 12:31

score 9 · Answer 1 · edited May 01 '21 at 02:52

You have to read all the models from different folders exist in your given directory.

Let's add sortDir function into models/index.js

sortDir will sort all the js files exist in each folder we have in our directory into an array called files. After calling the function we can easily read our models from files array.

const files = [];
const sortDir = (maniDir) => {
  const folders = [];
  const CheckFile = filePath => (fs.statSync(filePath).isFile());
  const sortPath = (dir) => {
    fs
      .readdirSync(dir)
      .filter(file => (file.indexOf(".") !== 0) && (file !== "index.js"))
      .forEach((res) => {
        const filePath = path.join(dir, res);
        if (CheckFile(filePath)) {
          files.push(filePath);
        } else {
          folders.push(filePath);
        }
      });
  };
  folders.push(maniDir);
  let i = 0;
  do {
    sortPath(folders[i]);
    i += 1;
  } while (i < folders.length);
};
sortDir(__dirname);

Now, you can read each model after sorting them from array files.

files
  .forEach((file) => {
    const model = require(file)(sequelize, Sequelize.DataTypes);
    db[model.name] = model;
  });

Hope it helps!

score 1 · Answer 2 · answered Oct 09 '18 at 09:01

I hope, this will save your time.

import fs from "fs";
import path from "path";
import Sequelize from "sequelize";
import { getConfig } from "../../lib/config";
const db = {};
// Load config file based on the enviroment
const config = getConfig();

let sequelize = null;
const { Op } = Sequelize;
const operatorsAliases = {
  $gt: Op.gt,
  $gte: Op.gte,
  $ne: Op.ne,
  $in: Op.in,
  $or: Op.or,
  $and: Op.and,
  $like: Op.like,
};

if (config.useEnvVariable) {
  sequelize = new Sequelize(process.env[config.useEnvVariable], config);
} else {
  const databaseConf = config[process.env.NODE_ENV];
  sequelize = new Sequelize(
    databaseConf.database,
    databaseConf.username,
    databaseConf.password,
    {
      host: databaseConf.host,
      dialect: databaseConf.dialect,
      operatorsAliases,
    },
  );
}

const files = [];
const sortDir = maniDir => {
  const folders = [];
  const CheckFile = filePath => fs.statSync(filePath).isFile();
  const sortPath = dir => {
    fs
      .readdirSync(dir)
      .filter(file => file.indexOf(".") !== 0 && file !== "index.js")
      .forEach(res => {
        const filePath = path.join(dir, res);
        if (filePath.indexOf("Schema") === -1) {
          if (CheckFile(filePath)) {
            files.push(filePath);
          } else {
            folders.push(filePath);
          }
        }
      });
  };
  folders.push(maniDir);
  let i = 0;
  do {
    sortPath(folders[i]);
    i += 1;
  } while (i < folders.length);
};
sortDir(__dirname);

files.forEach(file => {
  const model = sequelize.import(file);
  db[model.name] = model;
});

Object.keys(db).forEach(modelName => {
  console.log(modelName);
  if (db[modelName].associate) {
    db[modelName].associate(db);
  }
});

db.sequelize = sequelize;
db.Sequelize = Sequelize;
db.sequelize.sync({
   logging: false,
 });

export default db;

score 0 · Answer 3 · answered Dec 10 '20 at 19:12

    'use strict';
    const fs = require('fs');
    const path = require('path');
    const Sequelize = require('sequelize');
    const basename = path.basename(__filename);
    const env = process.env.NODE_ENV || 'development';
    const config = require(__dirname + '/../config/database.js')[env];
    const db = {};
    let sequelize = null;
    const { Op } = Sequelize;
    const operatorsAliases = {
    $gt: Op.gt,
    $gte: Op.gte,
    $ne: Op.ne,
    $in: Op.in,
    $or: Op.or,
    $and: Op.and,
    $like: Op.like,
    };

    if (config.use_env_variable) {
    sequelize = new Sequelize(process.env[config.use_env_variable], config);
    } else {
    sequelize = new Sequelize(config.database, config.username, config.password, config);
    }

const files = [];
const sortDir = maniDir => {
  const folders = [];
  const CheckFile = filePath => fs.statSync(filePath).isFile();
  const sortPath = dir => {
    fs
      .readdirSync(dir)
      .filter(file => file.indexOf(".") !== 0 && file !== "index.js")
      .forEach(res => {
        const filePath = path.join(dir, res);
        if (filePath.indexOf("Schema") === -1) {
          if (CheckFile(filePath)) {
            files.push(filePath);
          } else {
            folders.push(filePath);
          }
        }
      });
  };
  folders.push(maniDir);
  let i = 0;
  do {
    sortPath(folders[i]);
    i += 1;
  } while (i < folders.length);
};
sortDir(__dirname);

files.forEach(file => {

    console.log(file)
    const model = require(path.join( file))(sequelize, Sequelize.DataTypes);
  db[model.name] = model;
  console.log(model)
});
Object.keys(db).forEach(modelName => {
    if (db[modelName].associate) {
      db[modelName].associate(db);
    }
  });

db.sequelize = sequelize;
db.Sequelize = Sequelize;
db.sequelize.sync({
   logging: false,
 });

 module.exports = db;

score -1 · Answer 4 · answered Sep 13 '15 at 04:50

-1

You can use node module glob custom folder whatever you like

answered Sep 13 '15 at 04:50

trquoccuong

2,857
2
20
26

This module help you analyze folder and get file by prefix or postfix and you cant get models file easily – trquoccuong Sep 13 '15 at 04:53
Oh i see, could you make an example of how could i work with it using the structure? – Jonathan Solorzano Sep 13 '15 at 05:14
https://www.npmjs.com/package/jerryjs my mini project use glob to structure folder – trquoccuong Sep 13 '15 at 06:24
3

i want to use the structure i posted, i see what you mean by using `glob`, but could you make an example of the `index.js` script using `glob`? and also answer the other questions in the post ? – Jonathan Solorzano Sep 13 '15 at 15:55

Break sequelize models in separate folders

4 Answers4

Linked