@carlosbajo/micro/README.MD

framework para microservicios con google/pubsub

# Micro
Este modulo de NPM se encarga de ocultar todas la configuración básica para que un microservicio pueda ser implementado con éxito, además brinda algunas características muy optimas para el manejo de los servicios.

### Estructura básica de un microservicio (Minima)

Al llamar el modulo esté exporta 2 cosas uno **start()** y **app**

_<u>app</u>_ : Contiene la comunicación con kafka.
_<u>start</u>_ : Método para inicializar el server de koa 

Para implementar un servicio solo se necesita llamar el método **start** para (port: number, secret: key, googleKey)

### Instalación

```bash
npm install @carlosbajo/micro --save
```
### Continuous Delivery 

Cuidado!, siguiente comando
```bash
npm version <new_version>
```
Ejectura **git push --follow-tags** tener el mente el cambio de versiones

### Ejemplo

```javascript
const fw = require('@carlosbajo/micro');
process.chdir(__dirname);

const port = (process.env.NODE_ENV === 'local') ? 3004 : 3001;
fw.start(port, 'roket', ''); // incia el server de Koa
 ```

### Estructura del projecto

```bash
 api 
   | config
       | communication.js
       | router.js
   consumer
       | consumerName.js
   controllers
       | controllerName.js
   schemas
       | schemaName.js
```

##### Config /
<u> communication.js</u>
```javascript
  module.exports = [];
  /* 
  En caso de que se tenga que se necesite comunicación entre microservicios se tiene que exportar el arreglo con el nombre del servicio por ejemplo
  
  module.exports = ['servicename','servicename2'];
  */
```
<u>routes.js</u>

```javascript
/* 
Exportar el objeto de rutas posibles de la api, en este caso el contralador debe de existir así como la accion en el controlador del mismo.
*/
module.exports = {
  'GET /version': {
    controller: 'index',
    action: 'version'
  }
};
/*
Si no se desea exportar un ruta simplemente exportar
module.exports = {}
*/
```
##### Consumer /

<u>example.js</u>
```javascript
const { app } = require('@carlosbajo/micro');

module.exports = {
  getById: async req => {
    const id = req.arg.id ? req.arg.id : req.parent.id;
    const payload = await app.models.actividadespropuestas.findOne({ _id: new mongo.ObjectId(id), status: 1 });
    return payload;
  },
};
```

En este caso los modelos que son generados en el apartado de **schemas** y son inyectados en el objeto app y podemos usar los métodos de mongoose como _findOne_ o _find_.

Al final es importante retornar el resultado en este caso todos los métodos en los consumer son de retorno.

**El método RPC (Comunicación entre servicios)**
el metodo RPC se puede comunicar con otros métodos definidos en los consumer de otros microservicios, para lograr esto solo necesitamos saber el nombre del microservicio y el consumer de ese microservicio.

el metodo rpc se encuentra en pubsub.
```javascript
 const getFromMicro = await app.Pubsub.rpc('entorno.micro.metodo', args);
```
##### Controllers

Aquí se definen los controladores del projecto en este caso los contraladores responden a las rutas que se definene en **config/routes.js**.

<u>example.js</u>

```javascript
const { app } = require('@carlosbajo/micro');
const packageJson = require('../../package.json');

module.exports = {
  version: async ctx => {
    const payload = {
      microservice: app.name,
      version: packageJson.version,
      time: app.deployTime
    };

    ctx.body = payload;
    return payload;
  }
};
```
##### Schemas/
En está carpeta se definen los schemas de mongo en este caso el nombre del archivo es tomado como nombre del schema
<u>example.js</u>

```javascript
module.exports = {
  datasource: 'mongo',
  properties: {
    materiaId: {
      type: String
    },
    aprendizajes: [
      {
        aprendizajeId: {
          type: String
        },
        nombre: {
          type: String
        }
      }
    ],
    modalidad: {
      type: String
    },
    actividad: {
      type: String
    },
    proposito: {
      type: String
    },
    /**
     * Indica la visibilidad del documento
     *
     * @access private
     * @type {!number}
     *
     * 1 => Documento visible
     * 2 => Histórico
     * 3 => Documento borrado lógicamente
     *
     */
    status: {
      type: Number,
      default: 1
    }
  }
```