ti2-tourplan 1.0.11 → 1.0.13

package/index.js

@@ -1,65 +1,46 @@
+// const axios = require('axios');
+const Promise = require('bluebird');
 const R = require('ramda');
 const assert = require('assert');
 const moment = require('moment');
 const js2xmlparser = require('js2xmlparser');
 const xml2js = require('xml2js');
-const axiosRaw = require('axios');
+const { translateTPOption } = require('./resolvers/product');
 
 const Normalizer = require('./normalizer');
 
 const xmlParser = new xml2js.Parser();
 
-const xmlOptions = {
-  prettyPrinting: {
-    enabled: false,
-  },
+const defaultXmlOptions = {
+  prettyPrinting: { enabled: false },
   dtd: {
     include: true,
     name: 'tourConnect_4_00_000.dtd',
   },
 };
+const hostConnectXmlOptions = {
+  prettyPrinting: { enabled: false },
+  dtd: {
+    include: true,
+    name: 'hostConnect_4_06_009.dtd',
+  },
+};
 
-const getHeaders = ({ length, requestId }) => ({
+const getHeaders = ({ length }) => ({
   Accept: 'application/xml',
   'Content-Type': 'application/xml; charset=utf-8',
   'Content-Length': length,
-  ...requestId ? { requestId } : {},
 });
-
-const axiosSafeRequest = R.pick(['headers', 'method', 'url', 'data']);
-const axiosSafeResponse = response => {
-  const retVal = R.pick(['data', 'status', 'statusText', 'headers', 'request'], response);
-  retVal.request = axiosSafeRequest(retVal.request);
-  return retVal;
+const wildcardMatch = (wildcard, str) => {
+  const w = wildcard.replace(/[.+^${}()|[\]\\]/g, '\\$&'); // regexp escape
+  const re = new RegExp(`^${w.replace(/\*/g, '.*').replace(/\?/g, '.')}$`, 'i');
+  return re.test(str); // remove last 'i' above to have case sensitive
 };
-
 class Plugin {
   constructor(params = {}) { // we get the env variables from here
     Object.entries(params).forEach(([attr, value]) => {
       this[attr] = value;
     });
-    if (this.events) {
-      axiosRaw.interceptors.request.use(request => {
-        this.events.emit(`${this.name}.axios.request`, axiosSafeRequest(request));
-        return request;
-      });
-      axiosRaw.interceptors.response.use(response => {
-        this.events.emit(`${this.name}.axios.response`, axiosSafeResponse(response));
-        return response;
-      });
-    }
-    const pluginObj = this;
-    this.axios = async (...args) => axiosRaw(...args).catch(err => {
-      const errMsg = R.omit(['config'], err.toJSON());
-      console.log(`error in ${this.name}`, args[0], errMsg);
-      if (pluginObj.events) {
-        pluginObj.events.emit(`${this.name}.axios.error`, {
-          request: args[0],
-          err: errMsg,
-        });
-      }
-      throw err;
-    });
     this.tokenTemplate = () => ({
       endpoint: {
         type: 'text',
@@ -78,37 +59,82 @@ class Plugin {
         description: 'The tourplan provided password',
         default: 'en',
       },
+      hostConnectEndpoint: {
+        type: 'text',
+        regExp: /.+/,
+      },
+      hostConnectAgentID: {
+        type: 'text',
+        regExp: /.+/,
+      },
+      hostConnectAgentPassword: {
+        type: 'text',
+        regExp: /.+/,
+      },
     });
+    this.callTourplan = async ({
+      model,
+      endpoint,
+      axios,
+      xmlOptions,
+    }) => {
+      let data = Normalizer.stripEnclosingQuotes(
+        js2xmlparser.parse('Request', model, xmlOptions),
+      );
+      data = data.replace(xmlOptions.dtd.name, `Request SYSTEM "${xmlOptions.dtd.name}"`);
+      const reply = R.path(['data'], await axios({
+        method: 'post',
+        url: endpoint,
+        data,
+        headers: getHeaders({ length: data.length }),
+      }));
+      const replyObj = await xmlParser.parseStringPromise(reply);
+      if (R.path(['Reply', 'ErrorReply', 0, 'Error', 0], replyObj)) {
+        throw new Error(R.path(['Reply', 'ErrorReply', 0, 'Error', 0], replyObj));
+      }
+      return R.path(['Reply'], replyObj);
+    };
   }
 
   async validateToken({
+    axios,
     token: {
       endpoint,
       username,
       password,
+      hostConnectEndpoint,
+      hostConnectAgentID,
+      hostConnectAgentPassword,
     },
-    requestId,
   }) {
     try {
+      if (hostConnectEndpoint) {
+        assert(hostConnectAgentID && hostConnectAgentPassword);
+        const model = {
+          AgentInfoRequest: {
+            AgentID: hostConnectAgentID,
+            Password: hostConnectAgentPassword,
+          },
+        };
+        const replyObj = await this.callTourplan({
+          model,
+          endpoint: hostConnectEndpoint,
+          axios,
+          xmlOptions: hostConnectXmlOptions,
+        });
+        assert(R.path(['AgentInfoReply', 0, 'Currency'], replyObj));
+        return true;
+      }
       const model = {
         AuthenticationRequest: {
           Login: username,
           Password: password,
         },
       };
-      let data = Normalizer.stripEnclosingQuotes(
-        js2xmlparser.parse('Request', model, xmlOptions),
-      );
-      data = data.replace(xmlOptions.dtd.name, `Request SYSTEM "${xmlOptions.dtd.name}"`);
-      const reply = R.path(['data'], await this.axios({
-        metod: 'post',
-        url: endpoint,
-        data,
-        headers: getHeaders({ length: data.length }),
-        requestId,
-      }));
-      const replyObj = await xmlParser.parseStringPromise(reply);
-      assert(R.path(['Reply', 'AuthenticationReply', 0], replyObj) === '');
+      const replyObj = await this.callTourplan({
+        model, endpoint, axios, xmlOptions: defaultXmlOptions,
+      });
+      assert(R.path(['AuthenticationReply', 0], replyObj) === '');
       return true;
     } catch (err) {
       return false;
@@ -116,6 +142,7 @@ class Plugin {
   }
 
   async queryAllotment({
+    axios,
     token: {
       endpoint = this.endpoint,
       username = this.username,
@@ -128,7 +155,6 @@ class Plugin {
       keyPath,
       appliesTo: appliesToFilter,
     },
-    requestId,
   }) {
     const verbose = R.path(['verbose'], this);
     const cleanLog = inputString =>
@@ -157,15 +183,15 @@ class Plugin {
       },
     };
     let data = Normalizer.stripEnclosingQuotes(
-      js2xmlparser.parse('Request', model, xmlOptions),
+      js2xmlparser.parse('Request', model, defaultXmlOptions),
     );
-    data = data.replace(xmlOptions.dtd.name, `Request SYSTEM "${xmlOptions.dtd.name}"`);
+    data = data.replace(defaultXmlOptions.dtd.name, `Request SYSTEM "${defaultXmlOptions.dtd.name}"`);
     if (verbose) console.log('request', cleanLog(data));
-    const reply = R.path(['data'], await this.axios({
+    const reply = R.path(['data'], await axios({
       metod: 'post',
       url: endpoint,
       data,
-      headers: getHeaders({ length: data.length, requestId }),
+      headers: getHeaders({ length: data.length }),
     }));
     if (verbose) console.log('reply', cleanLog(reply));
     const returnObj = await xmlParser.parseStringPromise(reply);
@@ -225,6 +251,459 @@ class Plugin {
       })(),
     };
   }
+
+  async searchProducts({
+    axios,
+    typeDefsAndQueries: {
+      productTypeDefs,
+      productQuery,
+    },
+    token: {
+      hostConnectEndpoint,
+      hostConnectAgentID,
+      hostConnectAgentPassword,
+    },
+    payload: { optionId, productName },
+  }) {
+    const model = {
+      OptionInfoRequest: {
+        Opt: optionId || '?????????????????',
+        Info: 'G',
+        AgentID: hostConnectAgentID,
+        Password: hostConnectAgentPassword,
+      },
+    };
+    const payload = {
+      model,
+      endpoint: hostConnectEndpoint,
+      axios,
+      xmlOptions: hostConnectXmlOptions,
+    };
+    // use cache if we are getting the full list
+    const replyObj = optionId
+      ? await this.callTourplan(payload)
+      : await this.cache.getOrExec({
+        fnParams: [model],
+        fn: () => this.callTourplan(payload),
+        ttl: 60 * 60 * 12, // 12 hours
+        forceRefresh: false,
+      });
+    const productFields = [{
+      id: 'productId',
+      title: 'Supplier',
+      type: 'extended-option',
+    }, {
+      id: 'optionId',
+      title: 'Service',
+      type: 'extended-option',
+    }, {
+      id: 'startDate',
+      title: 'Date',
+      type: 'date',
+    }, {
+      id: 'paxConfigs',
+      title: 'Pax',
+      type: 'list_of_fields',
+      fields: [{
+        id: 'adults',
+        title: 'Adults',
+        type: 'count',
+      }, {
+        id: 'children',
+        title: 'Children',
+        type: 'count',
+      }, {
+        id: 'infants',
+        title: 'Infants',
+        type: 'count',
+      }, {
+        id: 'roomType',
+        title: 'Room Type',
+        type: 'extended-option',
+        options: [{ value: 'SG', label: 'Single' }, { value: 'DB', label: 'Double' }, { value: 'TW', label: 'Twin' }, { value: 'QD', label: 'Quad' }],
+      }],
+      requiredForAvailability: true,
+      requiredForCalendar: true,
+      requiredForBooking: true,
+    }, {
+      id: 'chargeUnitQuanity', // secondary charge unit (SCU) quantity
+      description: 'number of nights or days or hours depending on charge unit',
+      title: 'Quantity',
+      type: 'count',
+    }];
+    const products = R.call(R.compose(
+      R.map(optionsGroupedBySupplierId => {
+        const supplierData = {
+          supplierId: R.path([0, 'OptGeneral', 0, 'SupplierId', 0], optionsGroupedBySupplierId),
+          supplierName: R.path([0, 'OptGeneral', 0, 'SupplierName', 0], optionsGroupedBySupplierId),
+        };
+        return translateTPOption({
+          supplierData,
+          optionsGroupedBySupplierId,
+          typeDefs: productTypeDefs,
+          query: productQuery,
+        });
+      }),
+      R.values,
+      R.groupBy(R.path(['OptGeneral', 0, 'SupplierId', 0])),
+      productName ? R.filter(o => {
+        const str = `${
+          R.path(['OptGeneral', 0, 'Description', 0], o)
+        } ${
+          R.path(['Opt', 0], o)
+        } ${
+          R.path(['OptGeneral', 0, 'SupplierId', 0], o)
+        } ${
+          R.path(['OptGeneral', 0, 'SupplierName', 0], o)
+        }`;
+        return wildcardMatch(productName, str);
+      }) : R.identity,
+      R.pathOr([], ['OptionInfoReply', 0, 'Option']),
+    ), replyObj);
+    return {
+      products,
+      productFields,
+    };
+  }
+
+  async getProductPackages() {
+    return [
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8fea-0242ac120002',
+        packageName: "Afternoon at St Paul's Cathedral and Kensington Palace (half day)",
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8feb-0242ac120002',
+        packageName: 'Beefeater Day Out',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8fec-0242ac120002',
+        packageName: 'Brighton and Hove tour',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8fed-0242ac120002',
+        packageName: 'Buckingham Palace & Kensington Palace (full day)',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8fee-0242ac120002',
+        packageName: 'Buckingham Palace and Hampton Court Palace (full day)',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8fef-0242ac120002',
+        packageName: 'Buckingham Palace and Windsor Castle (full day)',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8ff0-0242ac120002',
+        packageName: 'Canterbury & Dover day trip',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8ff1-0242ac120002',
+        packageName: 'Canterbury day trip',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8ff2-0242ac120002',
+        packageName: 'Churchill War Rooms and the Imperial War Museum',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8ff3-0242ac120002',
+        packageName: 'Churchill War Rooms, the Changing of the Guards & the Tower of London',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8ff4-0242ac120002',
+        packageName: "City walking tour, St Paul's Cathedral and theatre performance at the Globe",
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8ff5-0242ac120002',
+        packageName: 'Downton Abbey day trip',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8ff6-0242ac120002',
+        packageName: "Guided tour of St Paul's Cathedral",
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8ff7-0242ac120002',
+        packageName: 'Hampton Court Palace (half day)',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8ff8-0242ac120002',
+        packageName: 'Hampton Court Palace and Windsor Castle (full day)',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8ff9-0242ac120002',
+        packageName: 'Kensington Palace and the Tower of London (full day)',
+        items: [
+          {
+            itemId: 'LONGUACLUXELONFDG',
+            itemType: 'option',
+          },
+          {
+            itemId: 'LONEFKENPALFIKENI',
+            itemType: 'option',
+          },
+          {
+            itemId: 'LONEFTOWLONFITOWL',
+            itemType: 'option',
+          },
+        ],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8ffa-0242ac120002',
+        packageName: 'Kensington Palace and Westminster Abbey (half day)',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8ffb-0242ac120002',
+        packageName: "Late afternoon visit to St Paul's Cathedral",
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8ffc-0242ac120002',
+        packageName: "St Paul's Cathedral & Kensington Palace (half day)",
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8ffd-0242ac120002',
+        packageName: "St Paul's Cathedral and the Churchill War Rooms (half day)",
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8ffe-0242ac120002',
+        packageName: "St Paul's Cathedral and Westminster Abbey (half day)",
+        items: [
+          {
+            itemId: 'LONGUACLUXELONHDG',
+            itemType: 'option',
+          },
+          {
+            itemId: 'LONEFSTPCATFITSPC',
+            itemType: 'option',
+          },
+          {
+            itemId: 'LONSSGOLTOUGTWAP',
+            itemType: 'option',
+          },
+        ],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-8fff-0242ac120002',
+        packageName: "St Paul's Cathedral, Changing of the Guard and Tower of London (full day)",
+        items: [
+          {
+            itemId: 'LONGUACLUXELONFDG',
+            itemType: 'option',
+          },
+          {
+            itemId: 'LONEFTOWLONFITOWL',
+            itemType: 'option',
+          },
+          {
+            itemId: 'LONEFGOLTOUGT105N',
+            itemType: 'option',
+          },
+        ],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-9000-0242ac120002',
+        packageName: "St Paul's Cathedral, Kensington Palace and Westminster Abbey (full day)",
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-9001-0242ac120002',
+        packageName: 'St Pauls and Tower of London',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-9002-0242ac120002',
+        packageName: 'Stonehenge (Full Day from London)',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-9003-0242ac120002',
+        packageName: 'Stonehenge, Lacock and Avebury (full day)',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-9004-0242ac120002',
+        packageName: 'The White Cliffs of Dover, Dover Castle, & military tunnels (full day)',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-9005-0242ac120002',
+        packageName: 'Tower of London by boat',
+        items: [
+          {
+            itemId: 'LONGUACLUXELONHDG',
+            itemType: 'option',
+          },
+          {
+            itemId: 'LONSSTHACLISINLON',
+            itemType: 'option',
+          },
+          {
+            itemId: 'LONEFTOWLONFITOWL',
+            itemType: 'option',
+          },
+        ],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-9006-0242ac120002',
+        packageName: 'Warner Bros.- The Making of Harry Potter (non refundable)',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-9007-0242ac120002',
+        packageName: 'Westminster Abbey and Buckingham Palace (half day)',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-9008-0242ac120002',
+        packageName: 'Westminster Abbey and Changing of the Guard',
+        items: [
+          {
+            itemId: 'LONGUACLUXELONHDG',
+            itemType: 'option',
+          },
+          {
+            itemId: 'LONEFWESABBWESABB',
+            itemType: 'option',
+          },
+        ],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-9009-0242ac120002',
+        packageName: 'Westminster Abbey and the Tower by boat (full day)',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-900a-0242ac120002',
+        packageName: 'Westminster Abbey, Changing of the Guard & Kensington Palace (full day)',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-900b-0242ac120002',
+        packageName: 'Westminster Abbey, Changing of the Guard and Buckingham Palace',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-900c-0242ac120002',
+        packageName: 'Westminster and the Tower of London (half day)',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-900d-0242ac120002',
+        packageName: 'Westminster, Changing of the Guard and the Tower of London (full day)',
+        items: [],
+      },
+      {
+        packageId: 'a1b2c3d4-e8e8-11ec-900e-0242ac120002',
+        packageName: 'Windsor Castle (half day)',
+        items: [],
+      },
+    ];
+  }
+
+  async searchQuote({
+    axios,
+    token: {
+      hostConnectEndpoint,
+      hostConnectAgentID,
+      hostConnectAgentPassword,
+    },
+    payload: {
+      quoteName,
+      quoteId,
+      optionId,
+      startDate,
+      reference,
+      /*
+      paxConfigs: [{ roomType: 'DB', adults: 2 }, { roomType: 'TW', children: 2 }]
+      */
+      paxConfigs,
+      /*
+        The number of second charge units required (second charge units are discussed
+        in the OptionInfo section). Should only be specified for options that have SCUs.
+        Defaults to 1.
+      */
+      chargeUnitQuanity,
+    },
+  }) {
+    const model = {
+      AddServiceRequest: {
+        AgentID: hostConnectAgentID,
+        Password: hostConnectAgentPassword,
+        ...(quoteId ? {
+          ExistingBookingInfo: { BookingId: quoteId },
+        } : {
+          NewBookingInfo: { Name: quoteName, QB: 'Q' },
+        }),
+        Opt: optionId,
+        DateFrom: startDate,
+        RateId: 'Default',
+        SCUqty: chargeUnitQuanity || 1,
+        AgentRef: reference,
+        RoomConfigs: paxConfigs.map(obj => ({
+          RoomConfig: {
+            Adults: obj.adults || 0,
+            Children: obj.children || 0,
+            Infants: obj.infants || 0,
+            RoomType: ({
+              Single: 'SG',
+              Double: 'DB',
+              Twin: 'TW',
+              Triple: 'TR',
+              Quad: 'QU',
+            })[obj.roomType],
+          },
+        })),
+      },
+    };
+    const replyObj = await this.callTourplan({
+      model,
+      endpoint: hostConnectEndpoint,
+      axios,
+      xmlOptions: hostConnectXmlOptions,
+    });
+    console.log('replyObj', replyObj);
+    return {
+      message: R.path(['AddServiceReply', 0, 'Status', 0], replyObj)
+        === 'NO' ? 'Service cannot be added to quote' : '',
+      quote: {
+        id: R.path(['AddServiceReply', 0, 'BookingId', 0], replyObj),
+        reference: R.path(['AddServiceReply', 0, 'Ref', 0], replyObj),
+      },
+    };
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async getCreateBookingFields({
+    // token: {
+    //   hostConnectAgentID,
+    //   hostConnectAgentPassword,
+    //   hostConnectEndpoint,
+    // },
+    // axios,
+  }) {
+    const customFields = [];
+    return {
+      fields: [],
+      customFields,
+    };
+  }
 }
 
 module.exports = Plugin;

package/index.test.js

@@ -44,6 +44,7 @@ describe('search tests', () => {
       it('valid token', async () => {
         axios.mockImplementation(getFixture);
         const retVal = await app.validateToken({
+          axios,
           token,
         });
         expect(retVal).toBeTruthy();
@@ -51,6 +52,7 @@ describe('search tests', () => {
       it('invalid token', async () => {
         axios.mockImplementation(getFixture);
         const retVal = await app.validateToken({
+          axios,
           token: { ...token, username: 'somerandom' },
         });
         expect(retVal).toBeFalsy();
@@ -85,6 +87,7 @@ describe('search tests', () => {
   it('read allotment empty', async () => {
     const request = axios.mockImplementation(getFixture);
     const retVal = await app.queryAllotment({
+      axios,
       token,
       payload: {
         dateFormat,
@@ -107,6 +110,7 @@ describe('search tests', () => {
   it('read allotment not empty', async () => {
     const request = axios.mockImplementation(getFixture);
     const retVal = await app.queryAllotment({
+      axios,
       token,
       payload: {
         dateFormat,
@@ -142,6 +146,7 @@ describe('search tests', () => {
   it('read allotment that applies to more products', async () => {
     const request = axios.mockImplementation(getFixture);
     const retVal = await app.queryAllotment({
+      axios,
       token,
       payload: {
         dateFormat,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ti2-tourplan",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "Tourplan's TI2 Plugin",
   "main": "index.js",
   "scripts": {
@@ -27,7 +27,8 @@
     "testTimeout": 10000
   },
   "dependencies": {
-    "axios": "^0.24.0",
+    "@graphql-tools/schema": "^8.5.1",
+    "graphql": "^16.5.0",
     "bluebird": "^3.7.2",
     "js2xmlparser": "^4.0.2",
     "jsonwebtoken": "^8.5.1",
@@ -37,6 +38,7 @@
     "xml2js": "^0.4.23"
   },
   "devDependencies": {
+    "axios": "^0.27.2",
     "eslint": "^8.4.1",
     "eslint-config-airbnb": "^19.0.2",
     "eslint-plugin-import": "^2.25.4",

package/resolvers/product.js

@@ -0,0 +1,123 @@
+/* eslint-disable arrow-body-style */
+const { makeExecutableSchema } = require('@graphql-tools/schema');
+const R = require('ramda');
+const { graphql } = require('graphql');
+
+
+const translateTCMLCollection = async ({ rootValue, typeDefs, query }) => {
+  const schema = makeExecutableSchema({
+    typeDefs,
+    resolvers: {
+      Query: {
+        productId: R.path(['elementId']),
+        productName: R.path(['elementName']),
+        availableCurrencies: () => [],
+        defaultCurrency: () => '',
+        options: R.pathOr([], ['children']),
+      },
+      Option: {
+        optionId: R.path(['elementId']),
+        optionName: R.path(['elementName']),
+        units: R.pathOr([], ['children']),
+      },
+      Unit: {
+        unitId: R.path(['elementId']),
+        unitName: R.path(['elementName']),
+        subtitle: () => '',
+        pricing: () => [],
+        restrictions: () => ({}),
+      },
+    },
+  });
+  const retVal = await graphql({ schema, rootValue, source: query });
+  if (retVal.errors) throw new Error(retVal.errors);
+  return retVal.data;
+};
+
+const translateTPOption = ({ optionsGroupedBySupplierId, supplierData, typeDefs, query }) => {
+  return {
+    productId: supplierData.supplierId,
+    productName: supplierData.supplierName,
+    options: optionsGroupedBySupplierId.map(option => {
+      const keyData = {
+        optionId: R.path(['Opt', 0], option),
+        optionName: R.path(['OptGeneral', 0, 'Description', 0], option),
+      };
+      /*
+      SType: One character that specifies the service type of the
+              option. One of: Y (accommodation), A (apartment), P
+              (package), N (non-accommodation). If the service
+              type is Y or P then the option is room-based (pricing
+              is room based, when a service line is added to a
+              booking for this option then a room type must be
+              supplied). The difference between Y and P is that
+              packages are fixed length (hence a number of
+              nights is not specified).
+      */
+      const units = (() => {
+        if (R.path(['OptGeneral', 0, 'SType', 0], option) === 'N') {
+          return [{
+            unitId: 'Adults',
+            unitName: 'Adults',
+            pricing: [],
+            restrictions: {
+              paxCount: R.path(['OptGeneral', 0, 'MPFCU', 0], option),
+              minAge: R.path(['OptGeneral', 0, 'Adult_From', 0], option),
+              maxAge: R.path(['OptGeneral', 0, 'Adult_To', 0], option),
+            },
+          }, R.path(['OptGeneral', 0, 'ChildrenAllowed', 0], option) === 'Y' ? {
+            unitId: 'Children',
+            unitName: 'Children',
+            pricing: [],
+            restrictions: {
+              minAge: R.path(['OptGeneral', 0, 'Child_From', 0], option),
+              maxAge: R.path(['OptGeneral', 0, 'Child_To', 0], option),
+            },
+          } : null, R.path(['OptGeneral', 0, 'InfantsAllowed', 0], option) === 'Y' ? {
+            unitId: 'Infants',
+            unitName: 'Infants',
+            pricing: [],
+            restrictions: {
+              minAge: R.path(['OptGeneral', 0, 'Infant_From', 0], option),
+              maxAge: R.path(['OptGeneral', 0, 'Infant_To', 0], option),
+            },
+          } : null].filter(Boolean);
+        }
+        if (R.path(['OptGeneral', 0, 'SType', 0], option) === 'Y') {
+          return [['SG', 'Single'], ['TW', 'Twin'], ['DB', 'Double'], ['QD', 'Quad']]
+            .filter(([_, unitName]) => R.path(['OptGeneral', 0, `${unitName}_Avail`, 0], option) === 'Y')
+            .map(([unitId, unitName]) => ({
+              unitId,
+              unitName,
+              pricing: [],
+              restrictions: {
+                paxCount: R.path(['OptGeneral', 0, `${unitName}_Max`, 0], option)
+                || R.path(['OptGeneral', 0, `${unitName}_Ad_Max`, 0], option),
+              },
+            }));
+        }
+        return [{
+          unitId: keyData.optionId, unitName: keyData.optionName, pricing: [], restrictions: {},
+        }];
+      })();
+      return {
+        optionId: keyData.optionId,
+        optionName: keyData.optionName,
+        units,
+      };
+    }),
+  };
+  // const schema = makeExecutableSchema({
+  //   typeDefs,
+  //   resolvers: {},
+  // });
+  // const retVal = await graphql({ schema, rootValue, source: query });
+  // if (retVal.errors) throw new Error(retVal.errors);
+  // console.log(retVal.data, rootValue);
+  // return retVal.data;
+};
+
+module.exports = {
+  translateTCMLCollection,
+  translateTPOption,
+};