ti2 1.0.0

package/controllers/__tests__/user.js

@@ -0,0 +1,136 @@
+/* globals describe it expect beforeAll, afterAll, jest */
+
+const faker = require('faker');
+const request = require('supertest');
+const { getRequireMocks } = require('../../../test/utils');
+const app = require('../../../app');
+const sqldb = require('../../../models');
+
+const { env: { adminKey } } = process;
+
+describe('user', () => {
+  const appName = faker.helpers.slugify(
+    faker.company.companyName(),
+  ).toLowerCase();
+  const newApp = {
+    name: appName,
+    packageName: `ti2-${appName}`,
+    adminEmail: faker.internet.email(),
+  };
+  let appKey;
+  const userId = faker.random.uuid();
+  let apiKey = faker.random.uuid();
+  // this token can be as rare as needed
+  const token = {
+    endpoint: faker.internet.url(),
+    apiKey,
+  };
+  beforeAll(async () => {
+    // create an App
+    const resp = await request(app)
+      .post('/app')
+      .set('Authorization', `Bearer ${adminKey}`)
+      .send(newApp);
+    expect(resp.statusCode).toBe(200);
+    expect(resp.body.value).toBeTruthy();
+    appKey = resp.body.value;
+    // create an App+User Mapping
+    await request(app)
+      .post(`/${appName}/${userId}`)
+      .set('Authorization', `Bearer ${appKey}`)
+      .send({
+        tokenHint: apiKey.split('-')[0],
+        token,
+      });
+  });
+  let userKey;
+  afterAll(async () => {
+    await sqldb.sequelize.connectionManager.close();
+  });
+  afterEach(() => jest.clearAllMocks());
+  it('a user should be able to get a user token via an admin key', async () => {
+    const resp = await request(app)
+      .post('/user')
+      .set('Authorization', `Bearer ${adminKey}`)
+      .send({
+        value: userId,
+      });
+    expect(resp.body.value).toBeTruthy();
+    userKey = resp.body.value;
+  });
+  it('a user should be able to get a list of it\'s mapped apps', async () => {
+    const resp = await request(app)
+      .get(`/user/${userId}/apps`)
+      .set('Authorization', `Bearer ${userKey}`);
+    expect(resp.statusCode).toBe(200);
+    expect(resp.body.userAppKeys).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          hint: apiKey.split('-')[0],
+          userId,
+          integrationId: appName,
+        }),
+      ]),
+    );
+  });
+  it('should be able to delete a user/app key', async () => {
+    const resp = await request(app)
+      .delete(`/${appName}/${userId}`)
+      .set('Authorization', `Bearer ${userKey}`)
+      .send({ tokenHint: apiKey.split('-')[0] });
+    expect(resp.statusCode).toBe(200);
+    // make sure the app token is NOT there
+    const respList = await request(app)
+      .get(`/user/${userId}/apps`)
+      .set('Authorization', `Bearer ${userKey}`);
+    expect(respList.statusCode).toBe(200);
+    expect(respList.body.userAppKeys).toEqual(
+      expect.not.arrayContaining([
+        expect.objectContaining({
+          hint: apiKey.split('-')[0],
+          userId,
+          integrationId: appName,
+        }),
+      ]),
+    );
+  });
+  it('should be able to create a user/app integration', async () => {
+    // set up new token
+    apiKey = faker.random.uuid();
+    token.apiKey = apiKey;
+    const resp = await request(app)
+      .post(`/${appName}/${userId}`)
+      .set('Authorization', `Bearer ${userKey}`)
+      .send({
+        tokenHint: apiKey.split('-')[0],
+        token,
+      });
+    expect(resp.statusCode).toBe(200);
+    // make sure the app token is there
+    const respList = await request(app)
+      .get(`/user/${userId}/apps`)
+      .set('Authorization', `Bearer ${userKey}`);
+    expect(respList.statusCode).toBe(200);
+    expect(respList.body.userAppKeys).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          hint: apiKey.split('-')[0],
+          userId,
+          integrationId: appName,
+        }),
+      ]),
+    );
+  });
+  it('should be able to get all the methods for an app', async () => {
+    getRequireMocks({ jest, app: newApp });
+    const methods = await request(app)
+      .get(`/app/${appName}/methods`)
+      .set('Authorization', `Bearer ${userKey}`);
+    expect(methods.statusCode).toBe(200);
+    expect(methods.body.methods).toEqual(
+      expect.arrayContaining([
+        'validateToken', 'getProduct',
+      ]),
+    );
+  });
+});

package/controllers/admin.js

@@ -0,0 +1,77 @@
+const jwt = require('jsonwebtoken');
+const assert = require('assert');
+const { omit } = require('ramda');
+const sqldb = require('../models');
+
+const { env: { jwtSecret } } = process;
+
+const createApp = async (req, res, next) => {
+  const {
+    name,
+    packageName,
+    adminEmail,
+  } = req.body;
+  try {
+    const newApp = await sqldb.Integration.create({
+      name,
+      packageName,
+      adminEmail,
+    });
+    const { apiKey } = newApp;
+    return res.json({ value: apiKey });
+  } catch (err) {
+    return next(err);
+  }
+};
+
+const listApps = async (req, res, next) => {
+  try {
+    const integrations = await sqldb.Integration.findAll().map(int => omit(['apiKey'], int.dataValues));
+    return res.json({ integrations });
+  } catch (err) {
+    return next(err);
+  }
+};
+
+const createUserToken = async (req, res, next) => {
+  const {
+    body: {
+      userId,
+    },
+  } = req;
+  if (!userId) {
+    assert(userId, 'No user provided');
+    // return next({ status: 404 });
+  }
+  try {
+    // check that the user exists or create it
+    if (!(await sqldb.User.findOne(({ where: { userId }, raw: true })))) {
+      await sqldb.User.create({ userId });
+    }
+    const value = jwt.sign({ userId }, jwtSecret);
+    return res.json({ value });
+  } catch (err) {
+    return next(err);
+  }
+};
+
+const resetIntegrationToken = async (req, res, next) => {
+  const { pathParams: { appKey: name } } = req;
+  try {
+    const integration = await sqldb.Integration.findOne({ where: { name } });
+    assert(Boolean(integration) !== false);
+    const value = sqldb.Integration.generateKey();
+    integration.apiKey = value;
+    integration.save();
+    return res.json({ value });
+  } catch (err) {
+    return next(err);
+  }
+};
+
+module.exports = {
+  createApp,
+  createUserToken,
+  listApps,
+  resetIntegrationToken,
+};

package/controllers/app.js

@@ -0,0 +1,91 @@
+const jwt = require('jwt-promise');
+const { omit } = require('ramda');
+const sqldb = require('../models');
+
+const { env: { jwtSecret } } = process;
+
+const jwtEncode = async (req, res, next) => {
+  try {
+    const value = await jwt.sign(req.body, `${req.appRecord.name}.${jwtSecret}`);
+    return res.json({ value });
+  } catch (err) {
+    return next(err);
+  }
+};
+
+const createAppToken = async (req, res, next) => {
+  const {
+    body: {
+      tokenHint: hint,
+      token: appKey,
+    },
+    params: {
+      app: integrationId,
+      userId,
+    },
+  } = req;
+  try {
+    const payload = {
+      integrationId,
+      userId,
+      hint,
+      appKey,
+    };
+    // check if the user exists
+    const userRecord = await sqldb.User.findOne({ where: { userId } });
+    if (!userRecord) { // create the user record
+      await sqldb.User.create({ userId });
+    }
+    // check if the user alrady has the same app with the same hint
+    const userAppKeyDup = await sqldb.UserAppKey.findOne({
+      where: { userId, integrationId, hint },
+    });
+    if (userAppKeyDup) await userAppKeyDup.destroy();
+    const newAppKey = await sqldb.UserAppKey.create(payload);
+    return res.json({ value: newAppKey.get('id').toString() });
+  } catch (err) {
+    return next(err);
+  }
+};
+
+const deleteAppToken = async (req, res, next) => {
+  const {
+    body: {
+      tokenHint: hint,
+    },
+    params: {
+      app: integrationId,
+      userId,
+    },
+  } = req;
+  // check if the user exists
+  const userRecord = await sqldb.User.findOne({ where: { userId } });
+  if (!userRecord) return next({ status: 404, message: 'User does not exists' });
+  const retVal = await sqldb.UserAppKey.destroy({
+    where: {
+      integrationId,
+      userId,
+      hint,
+    },
+  });
+  if (retVal === 0) return next({ status: 404, message: 'Key not found' });
+  return res.json({ message: `${retVal} erased` });
+};
+
+const listAppTokens = async (req, res, next) => {
+  const { params: { app: integrationId } } = req;
+  try {
+    const userAppKeys = (await sqldb.UserAppKey.findAll({ where: { integrationId } }))
+      .map(userAppKey => userAppKey.dataValues);
+    return res.json({ userAppKeys: userAppKeys.map(userAppKey => omit(['appKey', 'id'], userAppKey)) });
+  } catch (err) {
+    return next(err);
+  }
+};
+
+module.exports = {
+  jwtEncode,
+  createAppToken,
+  deleteAppToken,
+  listAppTokens,
+};

package/controllers/bookings.js

@@ -0,0 +1,63 @@
+const assert = require('assert');
+
+const { UserAppKey } = require('../models/index');
+
+const bookingsSearch = plugins => async (req, res, next) => {
+  const {
+    params: { appKey, userId, hint },
+    body,
+  } = req;
+  try {
+    const app = plugins.find(({ name }) => name === appKey);
+    const userAppKeys = await UserAppKey.findOne({
+      where: {
+        userId,
+        integrationId: appKey,
+        ...(hint ? { hint } : {}),
+      },
+    });
+    assert(userAppKeys, 'could not find the app key');
+    const token = userAppKeys.appKey;
+    const search = app.searchHotelBooking || app.searchBooking;
+    const results = await search({
+      token,
+      payload: body,
+    });
+    return res.json(results);
+  } catch (err) {
+    console.log({ err });
+    return next(err);
+  }
+};
+
+const bookingsCancel = plugins => async (req, res, next) => {
+  const {
+    params: { appKey, userId, hint },
+    body,
+  } = req;
+  try {
+    const app = plugins.find(({ name }) => name === appKey);
+    // const app = load(appKey);
+    const userAppKeys = (await UserAppKey.findOne({
+      where: {
+        userId,
+        integrationId: appKey,
+        ...(hint ? { hint } : {}),
+      },
+    }));
+    assert(userAppKeys, 'could not find the app key');
+    const token = userAppKeys.appKey;
+    const results = await app.cancelBooking({
+      token,
+      payload: body,
+    });
+    return res.json(results);
+  } catch (err) {
+    return next(err);
+  }
+};
+
+module.exports = plugins => ({
+  bookingsSearch: bookingsSearch(plugins),
+  bookingsCancel: bookingsCancel(plugins),
+});

package/controllers/ping.js

@@ -0,0 +1,27 @@
+/*
+  Functions in a127 controllers used for operations should take two parameters:
+
+  Param 1: a handle to the request object
+  Param 2: a handle to the response object
+  */
+const {
+  name,
+  version,
+  description,
+} = require('../package.json');
+
+const ping = (_req, res, next) => {
+  try {
+    return res.json({
+      name,
+      description,
+      version,
+      uptime: process.uptime(),
+    });
+  } catch (err) {
+    return next(err);
+  } };
+
+module.exports = {
+  ping,
+};

package/controllers/user.js

@@ -0,0 +1,37 @@
+// controllers/user.js
+const { omit, flatten } = require('ramda');
+const assert = require('assert');
+const Promise = require('bluebird');
+const moment = require('moment');
+
+const { UserAppKey, Sequelize: { Op } } = require('../models');
+// const { load } = require('../../plugins/index.js');
+
+const userAppList = async (req, res, next) => {
+  const { params: { userId } } = req;
+  try {
+    const userAppKeys = (await UserAppKey.findAll({ where: { userId } }))
+      .map(userAppKey => userAppKey.dataValues);
+    return res.json({ userAppKeys: userAppKeys.map(userAppKey => omit(['appKey', 'id'], userAppKey)) });
+  } catch (err) {
+    return next(err);
+  }
+};
+
+const getAppMethods = plugins => async (req, res, next) => {
+  const { params: { appKey } } = req;
+  try {
+    const app = plugins.filter(({ name }) => name === appKey)[0];
+    // load(appKey);
+    return res.json({
+      methods: Object.getOwnPropertyNames(Object.getPrototypeOf(app)),
+    });
+  } catch (err) {
+    return next(err);
+  }
+};
+
+module.exports = plugins => ({
+  userAppList,
+  getAppMethods: getAppMethods(plugins),
+});

package/index.js

@@ -0,0 +1,173 @@
+const express = require('express');
+const createMiddleware = require('swagger-express-middleware');
+const { connector } = require('swagger-routes-express');
+const swaggerUi = require('swagger-ui-express');
+const yaml = require('js-yaml');
+const fs = require('fs');
+const { pickBy } = require('ramda');
+
+const schema = yaml.load(fs.readFileSync(`${__dirname}/api.yml`));
+
+const auth = require('./auth/authHandler');
+const pingController = require('./controllers/ping');
+const adminController = require('./controllers/admin');
+const appController = require('./controllers/app');
+const userController = require('./controllers/user');
+const bookingsController = require('./controllers/bookings');
+
+module.exports = ({
+  apiDocs = true,
+  elasticLogIndex = 'apilog_ti2',
+  elasticLogsClient,
+  plugins: pluginsParam = {},
+  port: portParam,
+  startServer = true,
+}) => {
+  const port = portParam || process.env.PORT || 10010;
+  const app = express();
+  const plugins = Object.entries(pluginsParam).map(([pluginName, Plugin]) => {
+    // pass all env variables
+    const pluginEnv = pickBy(
+      (_val, key) => key.substring(0, `ti2_${pluginName}`.length)
+        .replace('-', '_') === `ti2_${pluginName}`,
+      process.env,
+    );
+    const params = {};
+    Object.entries(pluginEnv).forEach(([attr, value]) => {
+      const nuName = attr.replace(/_/g, '-').replace(`ti2-${pluginName}-`, '');
+      params[nuName] = value;
+    });
+    return new Plugin({ name: pluginName, ...params });
+  });
+  const api = {
+    ...pingController,
+    ...adminController,
+    ...appController,
+    ...userController(plugins),
+    ...bookingsController(plugins),
+  }; // mehthods that should map to the yaml api spec
+  createMiddleware(schema, app, (_err, middleware) => {
+    if (apiDocs) {
+      app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(schema));
+    }
+    app.use(
+      middleware.metadata(),
+      middleware.CORS(),
+      middleware.parseRequest(),
+      // middleware.validateRequest(),
+    );
+    const connect = connector(api, schema, {
+      security: auth,
+    });
+    if (elasticLogsClient) { // API request logs are saved on elastic
+      // setup the index
+      elasticLogsClient.indices.existsTemplate({
+        name: 'apilog',
+      }).then(async ({ body }) => {
+        if (!body) {
+          // the template has to be created
+          console.log('=- creating index template -=');
+          await elasticLogsClient.indices.putTemplate({
+            name: 'apilog',
+            body: {
+              index_patterns: [`${elasticLogIndex}*`],
+              settings: {
+                number_of_shards: 1,
+              },
+              mappings: {
+                dynamic: true,
+                properties: {
+                  body: { type: 'object' },
+                  client: { type: 'keyword' },
+                  date: { type: 'long' },
+                  method: { type: 'keyword' },
+                  params: { type: 'object' },
+                  query: { type: 'object' },
+                  url: { type: 'text' },
+                  responseStatusCode: { type: 'long' },
+                  responseTimeInMs: { type: 'long' },
+                },
+              },
+            },
+          });
+        }
+        const exists = await elasticLogsClient.indices.exists({
+          index: elasticLogIndex,
+        });
+        if (!exists || !exists.body) {
+          console.log('=- creating index =-');
+          await elasticLogsClient.indices.create({
+            index: elasticLogIndex,
+          });
+        }
+      }).catch(console.log);
+      app.use((req, res, next) => {
+        const startHrTime = process.hrtime();
+        const body = {
+          date: Math.floor(Date.now() / 1e3),
+          url: req.url,
+          // body: req.body,
+          params: req.pathParams,
+          query: req.query,
+          appRecord: req.appRecord,
+          method: req.method,
+          client: req.headers['x-forwarded-for'] || req.connection.remoteAddress,
+        };
+        elasticLogsClient.index({
+          index: elasticLogIndex,
+          body,
+        }).then(({ body: { _id } }) => {
+          res.on('finish', () => {
+            const elapsedHrTime = process.hrtime(startHrTime);
+            const responseTimeInMs = parseInt(elapsedHrTime[0] * 1e3 + elapsedHrTime[1] / 1e6, 10);
+            elasticLogsClient.index({
+              index: elasticLogIndex,
+              id: _id,
+              body: {
+                ...body,
+                ...{
+                  responseTimeInMs,
+                  responseStatusCode: res.statusCode,
+                },
+              },
+            }).catch((err, response) => console.log(err, response));
+          });
+        }).catch((err, response) => console.log(err, response));
+        next();
+      });
+    }
+    connect(app);
+    app.use(middleware.mock());
+    // global error Handling
+    app.use((err, req, res, next) => {
+      // console.log(req.headers.['X-Request-Id'], err);
+      res.status(err.status || 500);
+      return res.json({
+        message: err.message || 'Internal Error',
+      });
+    });
+  });
+
+  if (startServer) {
+    app.listen(port, () => console.log(`ti2 waiting on port ${port}`));
+  }
+  // first create a generic "terminator"
+  const terminator = sig => {
+    if (typeof sig === 'string') {
+      console.log('%s: Received %s - terminating ti2 ...',
+        Date(Date.now()), sig);
+      process.exit(1);
+    }
+    console.log('%s: Node server stopped.', Date(Date.now()));
+  };
+
+  // then implement it for every process signal related to exit/quit
+  [
+    'SIGHUP', 'SIGINT', 'SIGQUIT', 'SIGILL', 'SIGTRAP', 'SIGABRT',
+    'SIGBUS', 'SIGFPE', 'SIGUSR1', 'SIGSEGV', 'SIGUSR2', 'SIGTERM',
+  ].forEach(element => {
+    process.on(element, () => { terminator(element); });
+  });
+
+  return app;
+}

package/migrations/20191212214934-create-integration.js

@@ -0,0 +1,31 @@
+module.exports = {
+  up: (queryInterface, Sequelize) => queryInterface
+    .createTable('Integrations', {
+      name: {
+        type: Sequelize.STRING,
+        allowNull: false,
+        primaryKey: true,
+      },
+      packageName: {
+        type: Sequelize.STRING,
+      },
+      adminEmail: {
+        type: Sequelize.STRING,
+      },
+      apiKey: {
+        type: Sequelize.STRING,
+      },
+      lastSeen: {
+        type: Sequelize.INTEGER,
+      },
+      createdAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+      updatedAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+    }),
+  down: queryInterface => queryInterface.dropTable('Integrations'),
+};

package/migrations/20191216174955-create-user.js

@@ -0,0 +1,19 @@
+module.exports = {
+  up: (queryInterface, Sequelize) => queryInterface
+    .createTable('Users', {
+      userId: {
+        allowNull: false,
+        primaryKey: true,
+        type: Sequelize.STRING,
+      },
+      createdAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+      updatedAt: {
+        allowNull: false,
+        type: Sequelize.DATE,
+      },
+    }),
+  down: queryInterface => queryInterface.dropTable('Users'),
+};

package/migrations/20191217004250-create-user-app-keys.js

@@ -0,0 +1,43 @@
+module.exports = {
+  up: (queryInterface, Sequelize) => queryInterface.createTable('UserAppKeys', {
+    id: {
+      allowNull: false,
+      autoIncrement: true,
+      primaryKey: true,
+      type: Sequelize.INTEGER,
+    },
+    integrationId: {
+      type: Sequelize.STRING,
+      allowNull: false,
+      references: {
+        model: 'Integrations',
+        key: 'name',
+      },
+    },
+    userId: {
+      type: Sequelize.STRING,
+      allowNull: false,
+      references: {
+        model: 'Users',
+        key: 'userId',
+      },
+    },
+    appKey: {
+      type: Sequelize.STRING,
+      allowNull: false,
+    },
+    hint: {
+      type: Sequelize.STRING,
+      allowNull: false,
+    },
+    createdAt: {
+      allowNull: false,
+      type: Sequelize.DATE,
+    },
+    updatedAt: {
+      allowNull: false,
+      type: Sequelize.DATE,
+    },
+  }),
+  down: queryInterface => queryInterface.dropTable('UserAppKeys'),
+};