Loopback Models In Es6

I'm new to loopback.js. I want to use the ES6 syntax for classes. How to achieve this using the way that the models are defined by loopback? module.exports = function(MyModel) {

Solution 1:

Some ideas by https://github.com/NextFaze/Loopback-Style-Guide#custom-model-methods I create a bootstraping class in ES6 for managment models. I create 2 examples in ES5 and ES6.

ES5 Model example

module.exports = function(Sbif) {

  var request = require('request-promise'),
      token    = process.env.SBIF_TOKEN_URL,
      api_url  =  process.env.SBIF_API_URL;

  // UTM ---------------------------------------------Sbif.utm = function(params, cb) {
    makeRequest('utm',{}).then(function(res) {
      cb(null, JSON.parse(res).UTMs[0]);
    });
  };

  Sbif.remoteMethod('utm',{
    accepts: {arg: 'params', type: 'string'},
    returns: {arg: 'utm', type: 'string'},
    http: {path: '/utm', verb: 'get' }
  });

  // IPC ---------------------------------------------Sbif.ipc = function(params, cb) {
    makeRequest('ipc', {}).then(function(res) {
      cb(null, JSON.parse(res).IPCs[0]);
    });
  };

  Sbif.remoteMethod('ipc', {
    accepts: {arg: 'params', type: 'string'},
    returns: {arg: 'ipc', type: 'string'},
    http: {path: '/ipc'}
  });

  // EURO --------------------------------------------Sbif.euro = function(params, cb) {
    makeRequest('euro', {}).then(function(res) {
      cb(null, JSON.parse(res).Euros[0]);
    });
  };

  Sbif.remoteMethod('euro', {
    accepts: {arg: 'params', type: 'string'},
    returns: {arg: 'euro', type: 'string'},
    http: {path: '/euro'}
  });

  // Dolár -------------------------------------------Sbif.dolar = function(params, cb) {
    makeRequest('dolar',{}).then(function(res) {
      cb(null,JSON.parse(res).Dolares[0]);
    });
  };

  Sbif.remoteMethod('dolar', {
    accepts: {arg: 'params', type: 'string'},
    returns: {arg: 'dolar', type: 'string'},
    http: {path: '/dolar'}
  });


  // UF ----------------------------------------------Sbif.uf = function(params, cb) {
    makeRequest('uf',{}).then(function(res) {
      cb(null, JSON.parse(res).UFs[0]);
    });
  };

  Sbif.remoteMethod( 'uf',{
    accepts: {arg: 'params', type: 'string'},
    returns: {arg: 'uf', type: 'string'},
    http: {path: '/uf', verb: 'get' }
  });


  // SBIF Token and URLfunctionmakeRequest(indicador, parametros){
    returnrequest(buildUrl(indicador, parametros));
  }

  functionbuildUrl(indicador, parametros){
    var url = api_url + indicador;
    if(parametros.length > 0){
      parametros.forEach((parametros) {
        url += '/' + parametros; 
      });
    }
    return url + "?apikey=" + token + "&formato=json";
  }


};

ES6 Model example

import request from'request-promise';

var token    = process.env.SBIF_TOKEN_URL,
    api_url  =  process.env.SBIF_API_URL;

classSbifApi{
  constructor(SbifModel){
    //map remote methods to class methods. Set an extra this using the .bind functionSbifModel.uf = this.getData.bind(SbifModel, 'uf');
    SbifModel.utm = this.getData.bind(SbifModel, 'utm');
    SbifModel.ipc = this.getData.bind(SbifModel, 'ipc');
    SbifModel.dolar = this.getData.bind(SbifModel, 'dolar');
    SbifModel.euro = this.getData.bind(SbifModel, 'euro');

    //Set remotesthis.setRemotes(SbifModel, {name: 'uf', path: '/uf', root: 'uf'});
    this.setRemotes(SbifModel, {name: 'utm', path: '/utm', root: 'utm'});
    this.setRemotes(SbifModel, {name: 'ipc', path: '/ipc', root: 'ipc'});
    this.setRemotes(SbifModel, {name: 'dolar', path: '/dolar', root: 'dolar'});
    this.setRemotes(SbifModel, {name: 'euro', path: '/euro', root: 'euro'});

    returnSbifModel;
  }
  setRemotes(model, remoteMethod){
    let remoteOpts = {
      accepts: {
        arg: 'params', 
        type: 'string'
      },
      returns: {
        arg: remoteMethod.root || remoteMethod.name,
        type: 'string'
      },
      http: {
        path: remoteMethod.path || '/' + remoteMethod.name, 
        verb: 'get' 
      }
    };
    //Set the model remote methodnpm
    model.remoteMethod(remoteMethod.name, remoteOpts);
  }
  getData(type, params, callback){
    request(`${api_url}/${type}?apikey=${token}&formato=json`).then((res) => {

      let data = JSON.parse(res);

      switch(type){
        case'uf': 
          data = data.UFs[0]; 
          break;
        case'utm': 
          data = data.UTMs[0]; 
          break;
        case'ipc': 
          data = data.IPCs[0]; 
          break;
        case'dolar': 
          data = data.Dolares[0]; 
          break;
        case'euro': 
          data = data.Euros[0]; 
          break;
      }
      callback(null, data);
    });
  }
}
exportdefaultfunction(Model) { newSbifApi(Model); }