ti2 1.0.39 → 1.0.42

package/.github/workflows/tests.yml

@@ -1,6 +1,6 @@
 name: Tests Workflow
 
-on: [workflow_dispatch, push, pull_request]
+on: [workflow_dispatch, push]
 
 jobs:
   test:

package/api.yml

@@ -29,6 +29,11 @@ components:
       properties:
         value:
           type: string
+    Status:
+      type: object
+      properties:
+        success:
+          type: boolean
     JobSpec:
       type: object
       properties:
@@ -334,6 +339,13 @@ components:
         id:
           type: string
           description: a quote Id to make a reservation for
+    settingsBody:
+      type: object
+      required: true
+      properties:
+        settings:
+          type: object
+          description: an object with the app+user seettings
 paths:
   /ping:
     get:
@@ -623,7 +635,75 @@ paths:
           content:
             application/json:
               schema: '#/components/schemas/Message'
-
+  /{app}/{userId}/{hint}/token:
+    get:
+      tags:
+        - app
+        - user
+        - admin
+      summary: Get a user app+Token configuration, the authorization can be either from the app or the user
+      security:
+        - bearerAuth: ['app', 'user', 'admin']
+      operationId: getAppToken
+      parameters:
+        - name: app
+          in: path
+          description: app name to read the userId for (must match app token)
+          example: 'expedia'
+          required: true
+          schema:
+            type: string
+        - name: hint
+          in: path
+          description: a specific token hint to be used
+          required: true
+          example: 'travelgate-australia'
+          schema:
+            type: string
+        - name: userId
+          in: path
+          description: user to read the app token for
+          example: '536830b6ed19afa44a000002'
+          required: true
+          schema:
+            type: string
+      responses:
+        200:
+          description: success
+          content:
+            application/json:
+              schema: '#/components/schemas/UserApp'
+  /{app}/{userId}/token:
+    get:
+      tags:
+        - app
+        - user
+        - admin
+      summary: Get a user app+Token configuration, the authorization can be either from the app or the user, it will return the first token found (since no hint is required)
+      security:
+        - bearerAuth: ['app', 'user', 'admin']
+      operationId: getAppToken
+      parameters:
+        - name: app
+          in: path
+          description: app name to read the userId for (must match app token)
+          example: 'expedia'
+          required: true
+          schema:
+            type: string
+        - name: userId
+          in: path
+          description: user to read the app token for
+          example: '536830b6ed19afa44a000002'
+          required: true
+          schema:
+            type: string
+      responses:
+        200:
+          description: success
+          content:
+            application/json:
+              schema: '#/components/schemas/UserApp'
   /{app}/{userId}/validate:
     post:
       tags:
@@ -828,6 +908,98 @@ paths:
           content:
             appication/json:
               schema: '#/components/schemas/appMethods'
+  /settings/{appKey}/{userId}:
+    post:
+      security:
+        - bearerAuth: ['admin', 'user']
+      tags:
+        - user
+      summary: Creates user settings for an app, shared across tokens per user
+      operationId: createAppSettings
+      parameters:
+        - name: appKey
+          in: path
+          description: name of the app to use for the settings
+          required: true
+          example: 'expedia'
+          schema:
+            type: string
+        - name: userId
+          in: path
+          description: user id for the setting to be created
+          required: true
+          example: '536830b6ed19afa44a000002'
+          schema:
+            type: string
+      requestBody:
+        description: Creation Payload
+        required:  true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/settingsBody'
+      responses:
+        200:
+          description: success
+          content:
+            application/json:
+              schema: '#/components/schemas/Success'
+    get:
+      security:
+        - bearerAuth: ['admin', 'user']
+      tags:
+        - user
+      summary: Retrieves a user settings for an app, shared across tokens per user
+      operationId: getAppSettings
+      parameters:
+        - name: appKey
+          in: path
+          description: name of the app to use for the settings
+          required: true
+          example: 'expedia'
+          schema:
+            type: string
+        - name: userId
+          in: path
+          description: user id for the setting to be created
+          required: true
+          example: '536830b6ed19afa44a000002'
+          schema:
+            type: string
+      responses:
+        200:
+          description: success
+          content:
+            application/json:
+              schema: '#/components/schemas/settingsBody'
+    delete:
+      security:
+        - bearerAuth: ['admin', 'user']
+      tags:
+        - user
+      summary: Deletes a user settings for an app, shared across tokens per user
+      operationId: deleteAppSettings
+      parameters:
+        - name: appKey
+          in: path
+          description: name of the app to use for the settings
+          required: true
+          example: 'expedia'
+          schema:
+            type: string
+        - name: userId
+          in: path
+          description: user id for the setting to be created
+          required: true
+          example: '536830b6ed19afa44a000002'
+          schema:
+            type: string
+      responses:
+        200:
+          description: success
+          content:
+            application/json:
+                $ref: '#/components/schemas/Status'
   /bookings/{appKey}/{userId}/search:
     post:
       security:

package/cli.js

@@ -4,6 +4,7 @@ const { Command, Argument } = require('commander');
 
 const { migrateApp } = require('./controllers/app')();
 const { migrate } = require('./controllers/admin');
+const { decrypt, encrypt } = require('./lib/security');
 
 const program = new Command();
 
@@ -35,4 +36,23 @@ program.command('db')
     process.exit(0);
   });
 
+program.command('decrypt')
+  .description('decrypt a string')
+  .addArgument(
+    new Argument('<key>', 'key to decrypt'),
+  )
+.action(async key => {
+    console.log(await decrypt(key));
+    process.exit(0);
+  });
+program.command('encrypt')
+  .description('encrypt a string')
+  .addArgument(
+    new Argument('<key>', 'key to encrypt'),
+  )
+.action(async key => {
+    console.log(await encrypt(key));
+    process.exit(0);
+  });
+
 program.parse();

package/controllers/__tests__/app.js

@@ -76,7 +76,6 @@ describe('app', () => {
       token: appKey,
       payload: {
         tokenHint: apiKey.split('-')[0],
-        token,
       },
     });
     expect(valid).toBe(true);

package/controllers/__tests__/user.js

@@ -26,11 +26,13 @@ describe('user', () => {
     endpoint: chance.url(),
     apiKey,
   };
+  let plugins;
   beforeAll(async () => {
     ({
       doApiDelete,
       doApiGet,
       doApiPost,
+      plugins,
     } = await testUtils({
       plugins: [appName],
     }));
@@ -133,6 +135,71 @@ describe('user', () => {
       ]),
     );
   });
+  const apiKey2 = chance.guid();
+  const token2 = { ...token };
+  it('create a second token', async () => {
+    // set up new token
+    await doApiPost({
+      url: `/${appName}/${userId}`,
+      token: userKey,
+      payload: {
+        tokenHint: apiKey2.split('-')[1],
+        token: token2,
+      },
+    });
+  });
+  it('should be able to read a user/app token', async () => {
+    const returnValue = await doApiGet({
+      url: `/${appName}/${userId}/token`,
+      token: userKey,
+    });
+    expect(returnValue.token).toEqual(token);
+  });
+  it('should be able to read the second user/app token by hint', async () => {
+    const returnValue = await doApiGet({
+      url: `/${appName}/${userId}/${apiKey2.split('-')[1]}/token`,
+      token: userKey,
+    });
+    expect(returnValue.token).toEqual(token2);
+  });
+  it('should be able to create an app setting', async () => {
+    const returnValue = await doApiPost({
+      url: `/settings/${appName}/${userId}`,
+      token: userKey,
+      payload: {
+        settings: {
+          custom: true,
+        },
+      },
+    });
+    expect(returnValue.success).toBe(true);
+  });
+  it('should be able to get an app settings', async () => {
+    const returnValue = await doApiGet({
+      url: `/settings/${appName}/${userId}`,
+      token: userKey,
+    });
+    expect(returnValue.settings.custom).toBe(true);
+  });
+  it('testing the user token should include the user app setting', async () => {
+    const { valid } = await doApiPost({
+      url: `/${appName}/${userId}/validate`,
+      token: userKey,
+      payload: {
+        tokenHint: apiKey.split('-')[0],
+      },
+    });
+    expect(plugins[0].validateToken).toHaveBeenCalled();
+    expect(valid).toBe(true);
+    expect(plugins[0].validateToken.mock.calls[0][0].token).toEqual({ custom: true, ...token });
+  });
+  it('should be able to delete an app settings', async () => {
+    const returnValue = await doApiDelete({
+      url: `/settings/${appName}/${userId}`,
+      token: userKey,
+    });
+    expect(returnValue.success).toBe(true);
+  });
   it('should be able to get all the methods for an app', async () => {
     const { methods } = await doApiGet({
       url: `/app/${appName}/methods`,

package/controllers/allotment.js

@@ -22,7 +22,7 @@ const queryAllotment = plugins => async (req, res, next) => {
       },
     });
     assert(userAppKeys, 'could not find the app key');
-    const token = userAppKeys.appKey;
+    const token = await userAppKeys.token;
     assert(app.queryAllotment, 'could not find the allotment method');
     const results = await app.queryAllotment({
       token,

package/controllers/app.js

@@ -73,7 +73,7 @@ const createAppToken = async (req, res, next) => {
     if (!userRecord) { // create the user record
       await sqldb.User.create({ userId });
     }
-    // check if the user alrady has the same app with the same hint
+    // check if the user already has the same app with the same hint
     const userAppKeyDup = await sqldb.UserAppKey.findOne({
       where: { userId, integrationId, hint },
     });
@@ -186,7 +186,7 @@ const validateAppToken = plugins => async (req, res, next) => {
       },
     });
     assert(userAppKeys, 'could not find the app key');
-    const token = userAppKeys.appKey;
+    const token = await userAppKeys.token;
     assert(app.validateToken, `could not find the validateToken method for ${appKey}`);
     const valid = await app.validateToken({
       token,
@@ -197,13 +197,12 @@ const validateAppToken = plugins => async (req, res, next) => {
   }
 };
 
-
 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)) });
+    return res.json({ userAppKeys: userAppKeys.map(userAppKey => omit(['appKey', 'id', 'token'], userAppKey)) });
   } catch (err) {
     return next(err);
   }
@@ -310,9 +309,114 @@ const getJobStatus = async (req, res, next) => {
   }
 };
 
+const createAppSettings = async (req, res, next) => {
+  const {
+    body: {
+      settings,
+    },
+    params: {
+      appKey: integrationId,
+      userId,
+    },
+  } = req;
+  try {
+    const payload = {
+      integrationId,
+      userId,
+      settings,
+    };
+    // 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 already has the same app settings
+    const userSettings = await sqldb.UserIntegrationSettings.findOne({
+      where: { userId, integrationId },
+    });
+    if (userSettings) {
+      userSettings.settings = settings;
+      await userSettings.save();
+    } else {
+      await sqldb.UserIntegrationSettings.create(payload);
+    }
+    return res.json({ success: true });
+  } catch (err) {
+    console.log(err.stack);
+    return next(err);
+  }
+};
+
+const deleteAppSettings = async (req, res, next) => {
+  const {
+    params: {
+      appKey: 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.UserIntegrationSettings.destroy({
+    where: {
+      integrationId,
+      userId,
+    },
+  });
+  if (retVal === 0) return next({ status: 404, message: 'Settings not found' });
+  return res.json({ success: true });
+};
+
+const getAppSettings = async (req, res, next) => {
+  const {
+    params: {
+      appKey: 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 userIntegrationSettings = await sqldb.UserIntegrationSettings.findOne({
+    where: { userId, integrationId },
+  });
+  if (!userIntegrationSettings) {
+    return res.json({ settings: {} });
+  }
+  return res.json({ settings: userIntegrationSettings.settings });
+};
+
+const getAppToken = async (req, res, next) => {
+  const {
+    params: {
+      app: integrationId,
+      userId,
+      hint,
+    },
+  } = 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 userAppKey = await sqldb.UserAppKey.findOne({
+    where: {
+      userId,
+      integrationId,
+      ...(hint ? { hint } : {}),
+    },
+  });
+  if (!userAppKey) {
+    return next({ status: 404, message: 'User integratio is not found' });
+  }
+  return res.json({ token: await userAppKey.token });
+};
+
 module.exports = plugins => ({
   createAppToken,
+  getAppToken,
+  createAppSettings,
+  getAppSettings,
   deleteAppToken,
+  deleteAppSettings,
   getAppScheduledJobs,
   getJobStatus,
   jwtEncode,

package/controllers/bookings.js

@@ -32,7 +32,7 @@ const bookingsSearch = plugins => async (req, res, next) => {
       },
     });
     assert(userAppKeys, 'could not find the app key');
-    const token = userAppKeys.appKey;
+    const token = await userAppKeys.token;
     const search = app.searchHotelBooking || app.searchBooking;
     const results = await search({
       token,
@@ -61,7 +61,7 @@ const bookingsCancel = plugins => async (req, res, next) => {
       },
     }));
     assert(userAppKeys, 'could not find the app key');
-    const token = userAppKeys.appKey;
+    const token = await userAppKeys.token;
     const results = await app.cancelBooking({
       token,
       payload: body,
@@ -89,7 +89,7 @@ const $bookingsProductSearch = plugins => async ({
     },
   }));
   assert(userAppKeys, 'could not find the app key');
-  const token = userAppKeys.appKey;
+  const token = await userAppKeys.token;
   const results = await app.searchProducts({
     token,
     payload,
@@ -126,7 +126,7 @@ const bookingsAvailabilitySearch = plugins => async (req, res, next) => {
       },
     }));
     assert(userAppKeys, 'could not find the app key');
-    const token = userAppKeys.appKey;
+    const token = await userAppKeys.token;
     const results = await app.searchAvailability({
       token,
       payload,
@@ -154,7 +154,7 @@ const $bookingsAvailabilityCalendar = plugins => async ({
     },
   }));
   assert(userAppKeys, 'could not find the app key');
-  const token = userAppKeys.appKey;
+  const token = await userAppKeys.token;
   return app.availabilityCalendar({
     token,
     payload,
@@ -190,7 +190,7 @@ const searchQuote = plugins => async (req, res, next) => {
       },
     }));
     assert(userAppKeys, 'could not find the app key');
-    const token = userAppKeys.appKey;
+    const token = await userAppKeys.token;
     assert(payload.id, 'the availability id is required');
     const results = await app.searchQuote({
       token,
@@ -219,7 +219,7 @@ const createBooking = plugins => async (req, res, next) => {
       },
     }));
     assert(userAppKeys, 'could not find the app key');
-    const token = userAppKeys.appKey;
+    const token = await userAppKeys.token;
     assert(payload.id, 'the quote id is required');
     const results = await app.createBooking({
       token,

package/lib/security.js

@@ -0,0 +1,31 @@
+const crypto = require('crypto');
+
+const { env: { dbCryptoKey } } = process;
+
+const generateKey = () => {
+  const newKey = `${crypto.randomBytes(5).toString('base64').replace(/\W/g, '')}.${crypto.randomBytes(32).toString('base64').replace(/\W/g, '')}`;
+  return newKey;
+};
+
+const encrypt = text => {
+  const iv = crypto.randomBytes(16);
+  const cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(dbCryptoKey, 'base64'), iv);
+  let encrypted = cipher.update(text);
+  encrypted = Buffer.concat([encrypted, cipher.final()]);
+  return `${iv.toString('hex')}%${encrypted.toString('hex')}`;
+};
+
+const decrypt = text => {
+  const iv = Buffer.from(text.split('%')[0], 'hex');
+  const encryptedText = Buffer.from(text.split('%')[1], 'hex');
+  const decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(dbCryptoKey, 'base64'), iv);
+  let decrypted = decipher.update(encryptedText);
+  decrypted = Buffer.concat([decrypted, decipher.final()]);
+  return decrypted.toString();
+};
+
+module.exports = {
+  generateKey,
+  encrypt,
+  decrypt,
+};

package/migrations/20221108160527-userIntegrationSettings.js

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

package/migrations/20221114141152-encryptUserToken.js

@@ -0,0 +1,45 @@
+const jwt = require('jsonwebtoken');
+const R = require('ramda');
+const assert = require('assert');
+const sqldb = require('../models/index');
+
+const { encrypt, decrypt } = require('../lib/security');
+
+const { env: { dbCryptoKey } } = process;
+
+module.exports = {
+  up: async () => {
+    // encrypt all data
+    const existingTokens = await sqldb.UserAppKey.findAll();
+    const valuesToUpdate = [];
+    for (const currentToken of existingTokens) {
+      const decodedToken = JSON.stringify(R.omit(
+        ['iat'],
+        jwt.verify(currentToken.dataValues.appKey, dbCryptoKey),
+      ));
+      const encryptedToken = encrypt(decodedToken);
+      // make sure we can decrypt it
+      const decodedValue = decrypt(encryptedToken);
+      assert(R.equals(decodedToken, decodedValue));
+      currentToken.appKey = encryptedToken;
+      valuesToUpdate.push({
+        id: currentToken.id,
+        appToken: encryptedToken,
+      });
+    }
+    for (const { id, appToken } of valuesToUpdate) {
+      const currentToken = await sqldb.UserAppKey.findOne({ where: { id } });
+      currentToken.appKey = appToken;
+      await currentToken.save();
+    }
+  },
+  down: async () => {
+    const existingTokens = await sqldb.UserAppKey.findAll();
+    for (const currentToken of existingTokens) {
+      const decodedToken = decrypt(currentToken.dataValues.appKey);
+      const jwtToken = jwt.sign(decodedToken, dbCryptoKey);
+      currentToken.appKey = jwtToken;
+      await currentToken.save();
+    }
+  },
+};

package/models/integration.js

@@ -1,29 +1,6 @@
-const crypto = require('crypto');
 const Sequelize = require('sequelize');
 const db = require('./db');
-
-const { env: { dbCryptoKey } } = process;
-const generateKey = () => {
-  const newKey = `${crypto.randomBytes(5).toString('base64').replace(/\W/g, '')}.${crypto.randomBytes(32).toString('base64').replace(/\W/g, '')}`;
-  return newKey;
-};
-
-const encrypt = text => {
-  const iv = crypto.randomBytes(16);
-  const cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(dbCryptoKey, 'base64'), iv);
-  let encrypted = cipher.update(text);
-  encrypted = Buffer.concat([encrypted, cipher.final()]);
-  return `${iv.toString('hex')}%${encrypted.toString('hex')}`;
-};
-
-const decrypt = text => {
-  const iv = Buffer.from(text.split('%')[0], 'hex');
-  const encryptedText = Buffer.from(text.split('%')[1], 'hex');
-  const decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(dbCryptoKey, 'base64'), iv);
-  let decrypted = decipher.update(encryptedText);
-  decrypted = Buffer.concat([decrypted, decipher.final()]);
-  return decrypted.toString();
-};
+const { generateKey, encrypt, decrypt } = require('../lib/security');
 
 const Integration = db.define('Integration', {
   name: {
@@ -65,6 +42,9 @@ Integration.associate = models => {
   Integration.hasMany(models.UserAppKey, {
     foreignKey: 'integrationId',
   });
+  Integration.hasMany(models.UserIntegrationSettings, {
+    foreignKey: 'integrationId',
+  });
 };
 Integration.generateKey = generateKey;
 

package/models/user.js

@@ -11,6 +11,9 @@ User.associate = models => {
   User.hasMany(models.UserAppKey, {
     foreignKey: 'userId',
   });
+  User.hasMany(models.UserIntegrationSettings, {
+    foreignKey: 'userId',
+  });
   // associations can be defined here
 };
 

package/models/userappkey.js

@@ -1,6 +1,7 @@
 const jwt = require('jsonwebtoken');
 const Sequelize = require('sequelize');
-const { omit } = require('ramda');
+const { omit, pathOr } = require('ramda');
+const { encrypt, decrypt } = require('../lib/security');
 const db = require('./db');
 
 const { env: { dbCryptoKey } } = process;
@@ -37,12 +38,26 @@ const UserAppKey = db.define('UserAppKey', {
     type: Sequelize.TEXT,
     allowNull: false,
     set: function setter(value, field) {
-      const newValue = jwt.sign(value, dbCryptoKey);
-      this.setDataValue(field, newValue);
+      if (typeof value === 'object') {
+        const newValue = encrypt(JSON.stringify(value));
+        this.setDataValue(field, newValue);
+      } else {
+        this.setDataValue(field, value);
+      }
     },
-    get: function getter(field) {
-      const retValue = jwt.verify(this.getDataValue(field), dbCryptoKey);
-      return omit(['iat'], retValue);
+  },
+  token: {
+    type: Sequelize.VIRTUAL,
+    async get() {
+      const sqldb = require('./index');
+      const userIntegrationSettings = await sqldb.UserIntegrationSettings.findOne({
+        where: { userId: this.getDataValue('userId'), integrationId: this.getDataValue('integrationId') },
+      });
+      const appKey = JSON.parse(decrypt(this.getDataValue('appKey')));
+      return {
+        ...pathOr({}, ['settings'], userIntegrationSettings),
+        ...appKey,
+      };
     },
   },
 }, {});

package/models/userintegrationsetting.js

@@ -0,0 +1,52 @@
+const Sequelize = require('sequelize');
+const db = require('./db');
+const { encrypt, decrypt } = require('../lib/security');
+
+const UserIntegrationSettings = db.define('UserIntegrationSettings', {
+  userId: {
+    primaryKey: true,
+    type: Sequelize.STRING,
+    allowNull: false,
+    validate: {
+      is: /^((?!true|false|TRUE|FALSE).){1,255}$/,
+    },
+  },
+  integrationId: {
+    primaryKey: true,
+    type: Sequelize.STRING,
+    allowNull: false,
+    validate: {
+      is: /^((?!true|false|TRUE|FALSE).){1,255}$/,
+    },
+  },
+  settings: {
+    type: Sequelize.TEXT,
+    allowNull: false,
+  },
+}, {
+  getterMethods: {
+    settings() {
+      if (!this.getDataValue('settings')) { // there is no setting
+        return {};
+      }
+      return JSON.parse(decrypt(this.getDataValue('settings')));
+    },
+  },
+  setterMethods: {
+    settings(value) {
+      this.setDataValue('settings', encrypt(JSON.stringify(value)));
+    },
+  },
+});
+
+UserIntegrationSettings.associate = models => {
+  UserIntegrationSettings.belongsTo(models.User, {
+    foreignKey: 'userId',
+    as: 'user',
+  });
+  UserIntegrationSettings.belongsTo(models.Integration, {
+    foreignKey: 'integrationId',
+    as: 'integration',
+  });
+};
+module.exports = UserIntegrationSettings;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ti2",
-  "version": "1.0.39",
+  "version": "1.0.42",
   "description": "Tourist Industry Exchange (TI2)",
   "main": "index.js",
   "scripts": {