Models

A model module fulfills the M in the Model View Controller (MVC) pattern and represents a persistent entity that is mapped onto an underlying database. In Apogeu a model is a module with a plural name convention and lives in the app/models directory.

A model can be created with the apogeu model model_name command:

$ apogeu create model user

Create the app/models/user.js module

const mongoose = require('mongoose');
const Schema = mongoose.Schema;
const UserModel = new Schema({
});
module.exports = mongoose.model('User', UserModel);

Services

A service contains business logic that can be reused across a Apogeu application. In Apogeu, a service is a module with a plural name that ends in the "Service" convention and lives in the app/services directory.

A service can be created with the apogeu create service model_name command:

$ apogeu create service user

Create the app/services/users.js module

const UsersService = {
};
module.exports = UsersService;

Controllers

A controller fulfills the C in the Model View Controller (MVC) pattern and is responsible for handling web requests. In Apogeu, a service is a module with a plural name that ends in the "Controller" convention and lives in the app/controllers directory.

A controller can be created with the apogeu create controller model_name command:

$ apogeu create controller user

Create the app/controllers/users.js module

const UsersController = {
};
module.exports = UsersController;

Middlewares

Middleware functions are functions that have access to the request object (req), the response object (res), and the next function in the application’s request-response cycle. In Apogeu, a service is a module with a singular name that ends in the "Middleware" convention and lives in the app/middlewares directory.

A middleware can be created with the apogeu create middleware log command:

$ apogeu create middleware log

Create the app/middlewares/log.js module

const LogMiddleware = (req, res, next) => {
  next();
};
module.exports = LogMiddleware;

Routes

Routing refers to the definition of application end points (URIs) and how they respond to client requests.

In Apogeu, a route is a module that lives in the config/routes.js.

// config/routes.js

module.exports = {
  'get /': HomepagesController.index,

  'get /middleware': [LogMiddleware, HomepagesController.index],

  '/users': [
    {
      method: 'get',
      middlewares: [LogMiddleware],
      controller: UsersController.list,
    },
    {
      method: 'post',
      controller: UsersController.create,
    },
  ],

  '/users/:id': [
    {
      method: 'get',
      controller: UsersController.findById,
    },
    {
      method: 'put',
      controller: UsersController.update,
    },
    {
      method: 'delete',
      controller: UsersController.delete,
    },
  ],

};

Views

For the views we use the Pug template engine.

You can learn more about it in: https://pugjs.org

In Apogeu, the views that lives in the app/views.

Scaffold

Scaffolding allows you to generate some basic interfaces. In Apogeu, scaffold lives in the config/scaffold directory.

• config/scaffold/controller

  A controller is used with the apogeu create controller model_name command:

  $ apogeu create controller user

  The scaffold will create the app/controllers/users.js based on the next module:

  const {{model}}Controller = {
  
    index: (req, res) => {
      res.send('{{model}}Controller');
    },
  
  };
  
  module.exports = {{model}}Controller;

• config/scaffold/controllerCrud

  A controllerCrud is used with the apogeu create controller model_name --crud command:

  $ apogeu create controller user --crud

  The scaffold will create the app/controllers/users.js based on the next module:

  const {{model}}Controller = {
  
    list: (req, res, next) => {
      {{model}}Service
        .list(req.query)
        .then(data => res.status(200).json({ success: true, data }))
        .catch(next);
    },
  
    create: (req, res, next) => {
      {{model}}Service
        .create(req.body)
        .then(data => res.status(200).json({ success: true, data }))
        .catch(next);
    },
  
    findById: (req, res, next) => {
      {{model}}Service
        .findById(req.params.id)
        .then(data => res.status(200).json({ success: true, data }))
        .catch(next);
    },
  
    update: (req, res, next) => {
      {{model}}Service
        .update(req.params.id, req.body)
        .then(data => res.status(200).json({ success: true, data }))
        .catch(next);
    },
  
    delete: (req, res, next) => {
      {{model}}Service
        .delete(req.params.id)
        .then(() => res.status(200).json({ success: true }))
        .catch(next);
    },
  
  };
  
  module.exports = {{model}}Controller;

• config/scaffold/middleware

  A middleware is used with the apogeu create middleware model_name command:

  $ apogeu create middleware log

  The scaffold will create the app/middlewares/log.js based on the next module:

  const {{model}}Middleware = (req, res, next) => {
    next();
  };
  
  module.exports = {{model}}Middleware;

• config/scaffold/model

  A model is used with the apogeu create model model_name command:

  $ apogeu create model user

  The scaffold will create the app/models/user.js based on the next module:

  const mongoose = require('mongoose');
  
  const Schema = mongoose.Schema;
  
  const {{model}}Model = new Schema({
  
  });
  
  module.exports = mongoose.model('{{model}}', {{model}}Model);

• config/scaffold/service

  A service is used with the apogeu create service model_name command:

  $ apogeu create service user

  The scaffold will create the app/services/users.js based on the next module:

  const {{model}}Service = {
  
    index: () => new Promise((resolve, reject) => {
    }),
  
  };
  
  module.exports = {{model}}Service;

• config/scaffold/serviceCrud

  A serviceCrud is used with the apogeu create service model_name --crud command:

  $ apogeu create service user --crud

  The scaffold will create the app/services/users.js based on the next module:

  const {{model}}Service = {
  
    list: (query = {}) => {
      const { limit, skip, sort } = query;
      return {{model}}Model
        .find({})
        .limit(limit)
        .skip(skip)
        .sort(sort);
    },
  
    create: (body = {}) => {
      const model = new {{model}}Model(body);
      return model.save();
    },
  
    findById: (_id) => new Promise((resolve, reject) => {
      {{model}}Model
        .findOne({ _id })
        .then((data) => {
          if (!data) return reject({ success: false, message: 'Not found', status: 404 });
          resolve(data);
        })
        .catch(reject);
    }),
  
    update: (_id, body) => new Promise((resolve, reject) => {
      {{model}}Service.findById(_id)
        .then((user) => {
          Object.assign(user, body);
          user.save().then(resolve).catch(reject);
        })
        .catch(reject);
    }),
  
    delete: _id => new Promise((resolve, reject) => {
      {{model}}Service.findById(_id)
        .then((user) => {
          user.remove().then(resolve).catch(reject);
        })
        .catch(reject);
    }),
  
  };
  
  module.exports = {{model}}Service;

Tests

There are distinct structures for unit tests and integration tests.

.js files inside test/unit folder are taken as unit tests, so they only have access to the app's structure.

.js files inside test/integration folder are taken as integration tests, so the app is started before run the tests.

Currently only mocha tests are comprehended by Apogeu.

const assert = require('assert');

it('list users', (done) => {
  UsersService.list({ limit: 1 })
    .then((results) => {
      assert.equal(results.length, 1);
      done();
    });
});