ti2-ventrata 1.0.18 → 1.0.19

package/.github/workflows/nodejs.yml

@@ -9,6 +9,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - run: sed -i 's/"file:.*"/"latest"/' package.json
+      - name: install dependencies
+        run: npm i
       - uses: actions/setup-node@v1
         with:
           node-version: 12
@@ -38,6 +41,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v1
+      - run: sed -i 's/"file:.*"/"latest"/' package.json
+      - name: install dependencies
+        run: npm i
       - uses: JS-DevTools/npm-publish@v1
         with:
           token: ${{ secrets.NPM_TOKEN }}

package/index.js

@@ -1,4 +1,4 @@
-const axios = require('axios');
+const axiosRaw = require('axios');
 const curlirize = require('axios-curlirize');
 const R = require('ramda');
 const Promise = require('bluebird');
@@ -6,189 +6,23 @@ const assert = require('assert');
 const moment = require('moment');
 const jwt = require('jsonwebtoken');
 const wildcardMatch = require('./utils/wildcardMatch');
+const { translateProduct } = require('./resolvers/product');
+const { translateAvailability } = require('./resolvers/availability');
+const { translateBooking } = require('./resolvers/booking');
 
 const CONCURRENCY = 3; // is this ok ?
 if (process.env.debug) {
-  curlirize(axios);
+  curlirize(axiosRaw);
 }
 
-const isNilOrEmpty = R.either(R.isNil, R.isEmpty);
-const isNilOrEmptyArray = el => {
-  if (!Array.isArray(el)) return true;
-  return R.isNil(el) || R.isEmpty(el);
-};
-
-const doMap = (obj, map, omitParam = []) => {
-  const retVal = {};
-  const omit = [
-    ...omitParam,
-    ...Object.keys(map),
-  ];
-  Object.entries(map).forEach(([attribute, fn]) => {
-    const newVal = fn(obj);
-    if (newVal !== undefined) {
-      retVal[attribute] = newVal;
-    }
+const axios = async (...args) => axiosRaw(...args)
+  .catch(err => {
+    const errMsg = R.path(['response', 'data', 'errorMessage'], err);
+    console.log('error in ti2-ventrata', args[0], errMsg);
+    if (errMsg) throw new Error(errMsg);
+    throw err;
   });
-  return {
-    ...retVal,
-    ...R.omit(omit, obj),
-  };
-};
-
-const doMapCurry = mapObj => item => doMap(item, mapObj);
-
-const productMapIn = {
-  productId: R.path(['id']),
-  productName: o => R.path(['title'], o) || R.prop('internalName', o),
-  availableCurrencies: R.path(['availableCurrencies']),
-  defaultCurrency: R.path(['defaultCurrency']),
-  options: e => R.pathOr(undefined, ['options'], e).map(option => doMap(option, optionMapIn, ['id', 'title'])),
-};
-
-const optionMapIn = {
-  optionId: R.path(['id']),
-  optionName: o => R.path(['title'], o) || R.prop('internalName', o),
-  units: option => R.pathOr(undefined, ['units'], option).map(unit => doMap(unit, unitMap)),
-};
-
-const rateMap = {
-  rateId: R.path(['id']),
-  rateName: rateName => R.toLower(R.path(['internalName'], rateName)),
-  pricing: R.path(['pricingFrom']),
-};
-
-const unitPricingMap = {
-  unitId: R.prop('unitId'),
-  original: R.prop('original'),
-  retail: R.prop('retail'),
-  net: R.prop('net'),
-  currencyPrecision: R.prop('currencyPrecision'),
-};
-
-const availabilityMap = {
-  dateTimeStart: root => R.path(['localDateTimeStart'], root) || R.path(['localDate'], root),
-  dateTimeEnd: root => R.path(['localDateTimeEnd'], root) || R.path(['localDate'], root),
-  allDay: R.path(['allDay']),
-  pricing: root => R.path(['pricing'], root) || R.path(['pricingFrom'], root),
-  unitPricing: root => {
-    let before = [];
-    if (R.path(['unitPricing'], root)) before = R.path(['unitPricing'], root);
-    else before = R.path(['unitPricingFrom'], root) || [];
-    return before.map(item => doMap(item, unitPricingMap));
-  },
-  vacancies: R.prop('vacancies'),
-  offer: avail => (avail.offerCode ? doMap(avail, {
-    offerId: R.path(['offerCode']),
-    title: R.pathOr(undefined, ['offerTitle']),
-    description: R.pathOr(undefined, ['offer', 'description']),
-  }) : undefined),
-  meetingPoint: avail => (avail.meetingPoint ? doMap(avail, {
-    description: R.pathOr(undefined, ['meetingPoint']),
-    dateTime: R.pathOr(undefined, ['meetingLocalDateTime']),
-    coordinates: () => ((avail.meetingPointLatitude
-      && avail.meetingPointLongitude) ? doMap(avail, {
-        lat: R.path(['meetingPointLatitude']),
-        long: R.path(['meetingPointLongitude']),
-      }) : undefined),
-  }) : undefined),
-};
-const capitalize = sParam => {
-  if (typeof sParam !== 'string') return '';
-  const s = sParam.replace(/_/g, ' ');
-  return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
-};
-
-const unitMap = {
-  unitId: R.path(['id']),
-  unitName: o => R.path(['title'], o) || R.prop('internalName', o),
-  type: R.path(['type']),
-  subtitle: R.path(['subtitle']),
-  restrictions: R.path(['restrictions']),
-  pricing: root => R.path(['pricing'], root) || R.path(['pricingFrom'], root),
-};
-
-const itineraryMap = {
-  name: R.path(['name']),
-  type: R.path(['type']),
-  address: R.path(['address']),
-  coordinates: itinerary => ((itinerary.latitude
-    && Boolean(itinerary.longitude)) ? doMap(itinerary, {
-      lat: R.path(['latitude']),
-      long: R.path(['longitude']),
-    }) : undefined),
-  duration: ({ duration }) => (isNilOrEmpty(duration) ? undefined : doMapCurry({
-    durationName: R.path(['duration']),
-    amount: R.path(['durationAmount']),
-    unit: R.path(['durationUnit']),
-  })),
-};
-
-const unitItemMap = {
-  unitItemId: R.path(['uuid']),
-  unitId: R.path(['unitId']),
-  unitName: R.path(['unit', 'title']),
-  supplierBookingId: R.path(['supplierReference']),
-  status: e => capitalize(R.path(['status'], e)),
-  contact: R.path(['contact']),
-  pricing: R.path(['pricing']),
-  unit: root => doMap(root.unit, unitMap),
-};
-
-const contactMapOut = {
-  country: R.path(['country']),
-  emailAddress: R.path(['emailAddress']),
-  name: R.path(['firstName']),
-  surname: R.path(['lastName']),
-  fullName: R.path(['fullName']),
-  locales: R.path(['locales']),
-  notes: R.path(['notes']),
-  phoneNumber: R.path(['phoneNumber']),
-};
-
-const bookingMap = {
-  id: R.path(['id']),
-  orderId: R.path(['orderReference']),
-  bookingId: R.path(['supplierReference']),
-  supplierBookingId: R.path(['supplierReference']),
-  status: e => capitalize(R.path(['status'], e)),
-  productId: R.path(['product', 'id']),
-  productName: R.path(['product', 'title']),
-  optionId: R.path(['option', 'id']),
-  optionName: R.path(['option', 'title']),
-  itinerary: ({ option: { itinerary } = {} }) =>
-    (isNilOrEmptyArray(itinerary) ? undefined : itinerary.map(doMapCurry(itineraryMap))),
-  duration: booking => doMap(booking, {
-    durationName: R.path(['duration']),
-    amount: R.path(['durationAmount']),
-    unit: R.path(['durationUnit']),
-  }),
-  cancellable: R.path(['cancellable']),
-  unitItems: ({ unitItems }) =>
-    (isNilOrEmptyArray(unitItems) ? undefined : unitItems.map(doMapCurry(unitItemMap))),
-  start: R.path(['availability', 'localDateTimeStart']),
-  end: R.path(['availability', 'localDateTimeEnd']),
-  allDay: R.path(['availability', 'allDay']),
-  bookingDate: R.path(['utcCreatedAt']),
-  holder: booking => doMap(R.path(['contact'], booking), contactMapOut),
-  telephone: R.pathOr(undefined, ['contact', 'phoneNumber']),
-  notes: R.pathOr(undefined, ['notes']),
-  price: R.path(['pricing']),
-  offer: booking => (booking.offerCode ? doMap(booking, {
-    offerId: R.path(['offerCode']),
-    title: R.pathOr(undefined, ['offerTitle']),
-    description: R.pathOr(undefined, ['offer', 'description']),
-  }) : undefined),
-  cancelPolicy: R.pathOr(undefined, ['product', 'cancellationPolicy']), // TODO: Looks like cancellation text on appers on the shortDescription of the product entity .. an NLP extractor would be usefull ?
-};
-
-const contactMap = {
-  fullName: holder => `${holder.name} ${holder.surname}`,
-  emailAddress: R.path(['emailAddress']),
-  phoneNumber: R.path(['phoneNumber']),
-  locales: R.path(['locales']),
-  country: R.path(['country']),
-};
+const isNilOrEmpty = R.either(R.isNil, R.isEmpty);
 
 const getHeaders = ({
   apiKey,
@@ -201,6 +35,7 @@ const getHeaders = ({
   ...acceptLanguage ? { 'Accept-Language': acceptLanguage } : {},
   'Content-Type': 'application/json',
   ...resellerId ? { Referer: resellerId } : {},
+  // 'Octo-Capabilities': 'octo/pricing,octo/pickups',
   'Octo-Capabilities': 'octo/pricing',
 });
 
@@ -280,6 +115,10 @@ class Plugin {
       resellerId,
     },
     payload,
+    typeDefsAndQueries: {
+      productTypeDefs,
+      productQuery,
+    },
   }) {
     let url = `${endpoint || this.endpoint}/products`;
     if (!isNilOrEmpty(payload)) {
@@ -300,7 +139,14 @@ class Plugin {
       headers,
     }));
     if (!Array.isArray(results)) results = [results];
-    let products = results.map(e => doMap(e, productMapIn, ['id', 'title']));
+    let products = await Promise.map(
+      results,
+      product => translateProduct({
+        rootValue: product,
+        typeDefs: productTypeDefs,
+        query: productQuery,
+      }),
+    );
     // dynamic extra filtering
     if (!isNilOrEmpty(payload)) {
       const extraFilters = R.omit(['productId'], payload);
@@ -319,50 +165,20 @@ class Plugin {
   }
 
   async searchQuote({
-    token: {
-      apiKey,
-      endpoint,
-      octoEnv,
-      acceptLanguage,
-      resellerId,
-    },
-    payload: {
-      productIds,
-      optionIds,
-      occupancies,
-    },
+    // token: {
+    //   apiKey,
+    //   endpoint,
+    //   octoEnv,
+    //   acceptLanguage,
+    //   resellerId,
+    // },
+    // payload: {
+    //   productIds,
+    //   optionIds,
+    //   occupancies,
+    // },
   }) {
-    assert(occupancies.length > 0, 'there should be at least one occupancy');
-    assert(productIds.length === optionIds.length, 'mismatched product/option combinations');
-    assert(productIds.length === occupancies.length, 'mismatched product/occupancies combinations');
-    assert(productIds.every(Boolean), 'some invalid productId(s)');
-    assert(optionIds.every(Boolean), 'some invalid optionId(s)');
-    assert(occupancies.every(Boolean), 'some invalid occupacies(s)');
-    const quote = occupancies.map(() => productIds.map(productId => ({ productId })));
-    let productsDetail = await Promise.map(R.uniq(productIds), productId => {
-      const headers = getHeaders({
-        apiKey,
-        endpoint,
-        octoEnv,
-        acceptLanguage,
-        resellerId,
-      });
-      const url = `${endpoint || this.endpoint}/products/${productId}`;
-      return axios({
-        method: 'get',
-        url,
-        headers,
-      });
-    }, { concurrency: CONCURRENCY }).map(({ data }) => data);
-    productsDetail = R.indexBy(R.prop('id'), productsDetail);
-    // console.log({ optionIds });
-    productIds.forEach((productId, productIdIx) => {
-      const optionDetail = productsDetail[productId]
-        .options.filter(({ id }) => id === optionIds[productIdIx])[0];
-      quote[productIdIx] =
-        pickUnit(optionDetail.units, occupancies[productIdIx]).map(e => doMap(e, rateMap));
-    });
-    return { quote };
+    return { quote: [] };
   }
 
   async searchAvailability({
@@ -373,42 +189,33 @@ class Plugin {
       acceptLanguage,
       resellerId,
     },
-    token,
     payload: {
       productIds,
       optionIds,
-      occupancies,
+      units,
       startDate,
       endDate,
       dateFormat,
       currency,
     },
+    typeDefsAndQueries: {
+      availTypeDefs,
+      availQuery,
+    },
   }) {
     assert(this.jwtKey, 'JWT secret should be set');
-    assert(occupancies.length > 0, 'there should be at least one occupancy');
     assert(
       productIds.length === optionIds.length,
       'mismatched productIds/options length',
     );
     assert(
-      optionIds.length === occupancies.length,
-      'mismatched options/occupancies length',
+      optionIds.length === units.length,
+      'mismatched options/units length',
     );
     assert(productIds.every(Boolean), 'some invalid productId(s)');
     assert(optionIds.every(Boolean), 'some invalid optionId(s)');
-    assert(occupancies.every(Boolean), 'some invalid occupacies(s)');
     const localDateStart = moment(startDate, dateFormat).format('YYYY-MM-DD');
     const localDateEnd = moment(endDate, dateFormat).format('YYYY-MM-DD');
-    // obtain the rates
-    const { quote } = await this.searchQuote({
-      token,
-      payload: {
-        productIds,
-        optionIds,
-        occupancies,
-      },
-    });
-    const rates = quote.map(q => q.map(({ rateId }) => rateId));
     const headers = getHeaders({
       apiKey,
       endpoint,
@@ -417,43 +224,35 @@ class Plugin {
       resellerId,
     });
     const url = `${endpoint || this.endpoint}/availability`;
-    let availability = (
-      await Promise.map(rates, async (rate, rateIx) => {
-        const qtys = R.countBy(x => x)(rate);
+    const availability = (
+      await Promise.map(productIds, async (productId, ix) => {
         const data = {
-          productId: productIds[rateIx],
-          optionId: optionIds[rateIx],
+          productId,
+          optionId: optionIds[ix],
           localDateStart,
           localDateEnd,
-          currency,
-          units: Object.entries(qtys).map(([id, quantity]) => ({
-            id, quantity,
-          })),
+          units: units[ix].map(u => ({ id: u.unitId, quantity: u.quantity })),
         };
-        return axios({
+        if (currency) data.currency = currency;
+        const result = R.path(['data'], await axios({
           method: 'post',
           url,
           data,
           headers,
-        });
-      }, { concurrency: CONCURRENCY })
-    ).map(({ data }) => data);
-    availability = availability.map(
-      (avails, availsIx) => (avails.map(
-        avail => (avail.available ? ({
-          key: jwt.sign(({
-            productId: productIds[availsIx],
-            optionId: optionIds[availsIx],
-            availabilityId: avail.id,
+        }));
+        return Promise.map(result, avail => translateAvailability({
+          typeDefs: availTypeDefs,
+          query: availQuery,
+          rootValue: avail,
+          variableValues: {
+            productId,
+            optionId: optionIds[ix],
             currency,
-            unitItems: rates[availsIx].map(rate => ({ unitId: rate })),
-          }), this.jwtKey),
-          ...doMap(avail, availabilityMap),
-          available: true,
-        }) : ({
-          available: false,
-        })),
-      )),
+            unitsWithQuantity: units[ix],
+            jwtKey: this.jwtKey,
+          },
+        }));
+      }, { concurrency: CONCURRENCY })
     );
     return { availability };
   }
@@ -466,42 +265,33 @@ class Plugin {
       acceptLanguage,
       resellerId,
     },
-    token,
     payload: {
       productIds,
       optionIds,
-      occupancies,
+      units,
       startDate,
       endDate,
       currency,
       dateFormat,
     },
+    typeDefsAndQueries: {
+      availTypeDefs,
+      availQuery,
+    },
   }) {
     assert(this.jwtKey, 'JWT secret should be set');
-    assert(occupancies.length > 0, 'there should be at least one occupancy');
     assert(
       productIds.length === optionIds.length,
       'mismatched productIds/options length',
     );
     assert(
-      optionIds.length === occupancies.length,
-      'mismatched options/occupancies length',
+      optionIds.length === units.length,
+      'mismatched options/units length',
     );
     assert(productIds.every(Boolean), 'some invalid productId(s)');
     assert(optionIds.every(Boolean), 'some invalid optionId(s)');
-    assert(occupancies.every(Boolean), 'some invalid occupacies(s)');
     const localDateStart = moment(startDate, dateFormat).format('YYYY-MM-DD');
     const localDateEnd = moment(endDate, dateFormat).format('YYYY-MM-DD');
-    // obtain the rates
-    const { quote } = await this.searchQuote({
-      token,
-      payload: {
-        productIds,
-        optionIds,
-        occupancies,
-      },
-    });
-    const rates = quote.map(q => q.map(({ rateId }) => rateId));
     const headers = getHeaders({
       apiKey,
       endpoint,
@@ -510,31 +300,29 @@ class Plugin {
       resellerId,
     });
     const url = `${endpoint || this.endpoint}/availability/calendar`;
-    let availability = (
-      await Promise.map(rates, async (rate, rateIx) => {
-        const qtys = R.countBy(x => x)(rate);
+    const availability = (
+      await Promise.map(productIds, async (productId, ix) => {
         const data = {
-          productId: productIds[rateIx],
-          optionId: optionIds[rateIx],
+          productId,
+          optionId: optionIds[ix],
           localDateStart,
           localDateEnd,
-          currency,
-          units: Object.entries(qtys).map(([id, quantity]) => ({
-            id, quantity,
-          })),
+          // units is required here to get the total pricing for the calendar
+          units: units[ix].map(u => ({ id: u.unitId, quantity: u.quantity })),
         };
-        return axios({
+        if (currency) data.currency = currency;
+        const result = await axios({
           method: 'post',
           url,
           data,
           headers,
         });
+        return Promise.map(result.data, avail => translateAvailability({
+          rootValue: avail,
+          typeDefs: availTypeDefs,
+          query: availQuery,
+        }));
       }, { concurrency: CONCURRENCY })
-    ).map(({ data }) => data);
-    availability = availability.map(
-      (avails, availsIx) => (avails.map(
-        avail => doMap(avail, availabilityMap),
-      )),
     );
     return { availability };
   }
@@ -548,12 +336,17 @@ class Plugin {
       resellerId,
     },
     payload: {
+      rebookingId,
       availabilityKey,
       holder,
       notes,
       reference,
       settlementMethod,
     },
+    typeDefsAndQueries: {
+      bookingTypeDefs,
+      bookingQuery,
+    },
   }) {
     assert(availabilityKey, 'an availability code is required !');
     assert(R.path(['name'], holder), 'first name is required');
@@ -565,33 +358,45 @@ class Plugin {
       acceptLanguage,
       resellerId,
     });
-    let url = `${endpoint || this.endpoint}/bookings`;
-    let data = await jwt.verify(availabilityKey, this.jwtKey);
+    const dataForCreateBooking = await jwt.verify(availabilityKey, this.jwtKey);
     let booking = R.path(['data'], await axios({
-      method: 'post',
-      url,
+      method: rebookingId ? 'patch' : 'post',
+      url: `${endpoint || this.endpoint}/bookings${rebookingId ? `/${rebookingId}` : ''}`,
       data: {
         settlementMethod,
-        ...data,
+        ...dataForCreateBooking,
         notes,
       },
       headers,
     }));
-    url = `${endpoint || this.endpoint}/bookings/${booking.uuid}/confirm`;
-    const contact = doMap(holder, contactMap);
-    data = {
-      contact,
-      notes,
-      resellerReference: reference,
-      settlementMethod,
-    };
-    booking = R.path(['data'], await axios({
-      method: 'post',
-      url,
-      data,
-      headers,
-    }));
-    return ({ booking: doMap(booking, bookingMap) });
+    // for booking update, we may not need to confirm again
+    if (!booking.utcConfirmedAt) {
+      const dataForConfirmBooking = {
+        contact: {
+          fullName: `${holder.name} ${holder.surname}`,
+          emailAddress: R.path(['emailAddress'], holder),
+          phoneNumber: R.path(['phoneNumber'], holder),
+          locales: R.path(['locales'], holder),
+          country: R.path(['country'], holder),
+        },
+        notes,
+        resellerReference: reference,
+        settlementMethod,
+      };
+      booking = R.path(['data'], await axios({
+        method: 'post',
+        url: `${endpoint || this.endpoint}/bookings/${booking.uuid}/confirm`,
+        data: dataForConfirmBooking,
+        headers,
+      }));
+    }
+    return ({
+      booking: await translateBooking({
+        rootValue: booking,
+        typeDefs: bookingTypeDefs,
+        query: bookingQuery,
+      }),
+    });
   }
 
   async cancelBooking({
@@ -607,6 +412,10 @@ class Plugin {
       id,
       reason,
     },
+    typeDefsAndQueries: {
+      bookingTypeDefs,
+      bookingQuery,
+    },
   }) {
     assert(!isNilOrEmpty(bookingId) || !isNilOrEmpty(id), 'Invalid booking id');
     const headers = getHeaders({
@@ -623,7 +432,13 @@ class Plugin {
       data: { reason },
       headers,
     }));
-    return ({ cancellation: doMap(booking, bookingMap) });
+    return ({
+      cancellation: await translateBooking({
+        rootValue: booking,
+        typeDefs: bookingTypeDefs,
+        query: bookingQuery,
+      }),
+    });
   }
 
   async searchBooking({
@@ -642,6 +457,10 @@ class Plugin {
       travelDateEnd,
       dateFormat,
     },
+    typeDefsAndQueries: {
+      bookingTypeDefs,
+      bookingQuery,
+    },
   }) {
     assert(
       !isNilOrEmpty(bookingId)
@@ -707,7 +526,13 @@ class Plugin {
       }
       return [];
     })();
-    return ({ bookings: R.unnest(bookings).map(doMapCurry(bookingMap)) });
+    return ({
+      bookings: await Promise.map(R.unnest(bookings), booking => translateBooking({
+        rootValue: booking,
+        typeDefs: bookingTypeDefs,
+        query: bookingQuery,
+      })),
+    });
   }
 }
 

package/index.test.js

@@ -6,12 +6,27 @@ const faker = require('faker');
 const Plugin = require('./index');
 const fixtureUnits = require('./__fixtures__/units.js');
 
+const { typeDefs: productTypeDefs, query: productQuery } = require('./node_modules/ti2/controllers/graphql-schemas/product');
+const { typeDefs: availTypeDefs, query: availQuery } = require('./node_modules/ti2/controllers/graphql-schemas/availability');
+const { typeDefs: bookingTypeDefs, query: bookingQuery } = require('./node_modules/ti2/controllers/graphql-schemas/booking');
+const { typeDefs: rateTypeDefs, query: rateQuery } = require('./node_modules/ti2/controllers/graphql-schemas/rate');
+
+const typeDefsAndQueries = {
+  productTypeDefs,
+  productQuery,
+  availTypeDefs,
+  availQuery,
+  bookingTypeDefs,
+  bookingQuery,
+  rateTypeDefs,
+  rateQuery,
+};
+
 const app = new Plugin({
   jwtKey: process.env.ti2_ventrata_jwtKey,
+  endpoint: process.env.ti2_ventrata_endpoint,
 });
 
-const rnd = arr => arr[Math.floor(Math.random() * arr.length)];
-
 describe('search tests', () => {
   let products;
   let testProduct = {
@@ -103,6 +118,7 @@ describe('search tests', () => {
     it('get for all products, a test product should exist', async () => {
       const retVal = await app.searchProducts({
         token,
+        typeDefsAndQueries,
       });
       expect(Array.isArray(retVal.products)).toBeTruthy();
       // console.log(retVal.products.filter(({ productName }) => productName === testProduct.productName));
@@ -121,6 +137,7 @@ describe('search tests', () => {
         payload: {
           productId: testProduct.productId,
         },
+        typeDefsAndQueries,
       });
       expect(Array.isArray(retVal.products)).toBeTruthy();
       expect(retVal.products).toHaveLength(1);
@@ -132,6 +149,7 @@ describe('search tests', () => {
         payload: {
           productName: '*bus*',
         },
+        typeDefsAndQueries,
       });
       expect(Array.isArray(retVal.products)).toBeTruthy();
       expect(retVal.products.length).toBeGreaterThan(0);
@@ -146,62 +164,39 @@ describe('search tests', () => {
           dateFormat,
           productIds: [
             '28ca088b-bc7b-4746-ab06-5971f1ed5a5e',
-            '5d981651-e204-4549-bfbe-691043dd2515',
+            '3465143f-4902-447a-9c1e-8e5598666663',
           ],
-          optionIds: ['DEFAULT', 'DEFAULT'],
-          occupancies: [
-            [{ age: 30 }, { age: 40 }],
-            [{ age: 30 }, { age: 40 }],
+          optionIds: ['DEFAULT', 'dbe73645-2dd9-4cde-ade0-4faa95668d01'],
+          units: [
+            [{ unitId: 'unit_c1709f42-297e-4f7e-bd6b-3e77d4622d8a', quantity: 2 }],
+            [{ unitId: 'unit_d49f8d25-5b37-4365-b67d-daa0594d021e', quantity: 2 }],
           ],
         },
+        typeDefsAndQueries,
       });
       expect(retVal).toBeTruthy();
       const { availability } = retVal;
       expect(availability).toHaveLength(2);
       expect(availability[0].length).toBeGreaterThan(0);
     });
-    it('should be able to get quotes', async () => {
-      const retVal = await app.searchQuote({
-        token,
-        payload: {
-          startDate: moment().add(6, 'M').format(dateFormat),
-          endDate: moment().add(6, 'M').add(2, 'd').format(dateFormat),
-          dateFormat,
-          productIds: busProducts.map(({ productId }) => productId),
-          optionIds: busProducts.map(({ options }) =>
-            faker.random.arrayElement(options).optionId),
-          occupancies: [
-            [{ age: 30 }, { age: 40 }],
-            [{ age: 30 }, { age: 40 }],
-          ],
-        },
-      });
-      expect(retVal).toBeTruthy();
-      const { quote } = retVal;
-      expect(quote.length).toBeGreaterThan(0);
-      expect(quote[0]).toContainObject([{
-        rateName: 'adult',
-        pricing: expect.toContainObject([{
-          currency: 'USD',
-        }]),
-      }]);
-    });
+
     let availabilityKey;
     it('should be able to get availability', async () => {
       const retVal = await app.searchAvailability({
         token,
+        typeDefsAndQueries,
         payload: {
           startDate: moment().add(6, 'M').format(dateFormat),
           endDate: moment().add(6, 'M').add(2, 'd').format(dateFormat),
           dateFormat,
           productIds: [
             '28ca088b-bc7b-4746-ab06-5971f1ed5a5e',
-            '5d981651-e204-4549-bfbe-691043dd2515',
+            '3465143f-4902-447a-9c1e-8e5598666663',
           ],
-          optionIds: ['DEFAULT', 'DEFAULT'],
-          occupancies: [
-            [{ age: 30 }, { age: 40 }],
-            [{ age: 30 }, { age: 40 }],
+          optionIds: ['DEFAULT', 'dbe73645-2dd9-4cde-ade0-4faa95668d01'],
+          units: [
+            [{ unitId: 'unit_c1709f42-297e-4f7e-bd6b-3e77d4622d8a', quantity: 2 }],
+            [{ unitId: 'unit_d49f8d25-5b37-4365-b67d-daa0594d021e', quantity: 2 }],
           ],
         },
       });
@@ -218,6 +213,7 @@ describe('search tests', () => {
       const fullName = faker.name.findName().split(' ');
       const retVal = await app.createBooking({
         token,
+        typeDefsAndQueries,
         payload: {
           availabilityKey,
           notes: faker.lorem.paragraph(),
@@ -244,6 +240,7 @@ describe('search tests', () => {
     it('should be able to cancel the booking', async () => {
       const retVal = await app.cancelBooking({
         token,
+        typeDefsAndQueries,
         payload: {
           bookingId: booking.id,
           reason: faker.lorem.paragraph(),
@@ -259,6 +256,7 @@ describe('search tests', () => {
     it('it should be able to search bookings by id', async () => {
       const retVal = await app.searchBooking({
         token,
+        typeDefsAndQueries,
         payload: {
           bookingId: booking.id,
         },
@@ -270,6 +268,7 @@ describe('search tests', () => {
     it('it should be able to search bookings by reference', async () => {
       const retVal = await app.searchBooking({
         token,
+        typeDefsAndQueries,
         payload: {
           bookingId: reference,
         },
@@ -281,6 +280,7 @@ describe('search tests', () => {
     it('it should be able to search bookings by supplierBookingId', async () => {
       const retVal = await app.searchBooking({
         token,
+        typeDefsAndQueries,
         payload: {
           bookingId: booking.supplierBookingId,
         },
@@ -292,6 +292,7 @@ describe('search tests', () => {
     it('it should be able to search bookings by travelDate', async () => {
       const retVal = await app.searchBooking({
         token,
+        typeDefsAndQueries,
         payload: {
           travelDateStart: moment().add(6, 'M').format(dateFormat),
           travelDateEnd: moment().add(6, 'M').add(2, 'd').format(dateFormat),
@@ -306,6 +307,7 @@ describe('search tests', () => {
       const fullName = faker.name.findName().split(' ');
       const retVal = await app.createBooking({
         token,
+        typeDefsAndQueries,
         payload: {
           availabilityKey,
           notes: faker.lorem.paragraph(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ti2-ventrata",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "description": "Ventrata's TI2 Plugin",
   "main": "index.js",
   "scripts": {
@@ -27,9 +27,11 @@
     "testTimeout": 10000
   },
   "dependencies": {
+    "@graphql-tools/schema": "^9.0.12",
     "axios": "^0.24.0",
     "axios-curlirize": "^1.3.7",
     "bluebird": "^3.7.2",
+    "graphql": "^16.6.0",
     "jsonwebtoken": "^8.5.1",
     "moment": "^2.29.4",
     "ramda": "^0.27.1"
@@ -44,6 +46,7 @@
     "jest-cli": "^27.4.7",
     "jest-diff": "^27.4.2",
     "jest-environment-node": "27.4",
-    "jest-util": "27.4"
+    "jest-util": "27.4",
+    "ti2": "latest"
   }
 }

package/resolvers/availability.js

@@ -0,0 +1,61 @@
+const { makeExecutableSchema } = require('@graphql-tools/schema');
+const { graphql } = require('graphql');
+const R = require('ramda');
+const jwt = require('jsonwebtoken');
+
+const resolvers = {
+  Query: {
+    key: (root, args) => {
+      const {
+        productId,
+        optionId,
+        currency,
+        unitsWithQuantity,
+        jwtKey,
+      } = args;
+      if (!jwtKey) return null;
+      return jwt.sign({
+        productId,
+        optionId,
+        availabilityId: root.id,
+        currency,
+        unitItems: R.chain(u => new Array(u.quantity).fill(1).map(() => ({
+          unitId: u.unitId,
+        })), unitsWithQuantity),
+      }, jwtKey);
+    },
+    dateTimeStart: root => R.path(['localDateTimeStart'], root) || R.path(['localDate'], root),
+    dateTimeEnd: root => R.path(['localDateTimeEnd'], root) || R.path(['localDate'], root),
+    allDay: R.path(['allDay']),
+    vacancies: R.prop('vacancies'),
+    available: root => root.status !== 'SOLD_OUT',
+    // get the starting price
+    pricing: R.prop('pricingFrom'),
+    unitPricing: R.prop('unitPricingFrom'),
+    pickupAvailable: R.prop('pickupAvailable'),
+    pickupRequired: R.prop('pickupRequired'),
+    pickupPoints: root => R.pathOr([], ['pickupPoints'], root)
+      .map(o => ({
+        ...o,
+        postal: o.postal_code,
+      })),
+  },
+};
+
+const translateAvailability = async ({ rootValue, variableValues, typeDefs, query }) => {
+  const schema = makeExecutableSchema({
+    typeDefs,
+    resolvers,
+  });
+  const retVal = await graphql({
+    schema,
+    rootValue,
+    source: query,
+    variableValues,
+  });
+  if (retVal.errors) throw new Error(retVal.errors);
+  return retVal.data;
+};
+module.exports = {
+  translateAvailability,
+};

package/resolvers/booking.js

@@ -0,0 +1,79 @@
+const { makeExecutableSchema } = require('@graphql-tools/schema');
+const R = require('ramda');
+const { graphql } = require('graphql');
+
+const capitalize = sParam => {
+  if (typeof sParam !== 'string') return '';
+  const s = sParam.replace(/_/g, ' ');
+  return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
+};
+const resolvers = {
+  Query: {
+    id: R.path(['id']),
+    orderId: R.path(['orderReference']),
+    bookingId: R.path(['supplierReference']),
+    supplierBookingId: R.path(['supplierReference']),
+    status: e => capitalize(R.path(['status'], e)),
+    productId: R.path(['product', 'id']),
+    productName: root => R.path(['product', 'title'], root) || R.path(['product', 'internalName'], root),
+    cancellable: R.path(['cancellable']),
+    editable: R.path(['cancellable']),
+    unitItems: ({ unitItems }) => unitItems.map(unitItem => ({
+      unitItemId: unitItem.uuid,
+      unitId: unitItem.unitId,
+      unitName: unitItem.title || unitItem.internalName,
+    })),
+    start: R.path(['availability', 'localDateTimeStart']),
+    end: R.path(['availability', 'localDateTimeEnd']),
+    allDay: R.path(['availability', 'allDay']),
+    bookingDate: R.path(['utcCreatedAt']),
+    holder: root => ({
+      name: R.path(['contact', 'fullName'], root).split(' ')[0],
+      surname: R.last(R.path(['contact', 'fullName'], root).split(' ')),
+      fullName: R.path(['contact', 'fullName'], root),
+      phoneNumber: R.path(['contact', 'phoneNumber'], root),
+      emailAddress: R.path(['contact', 'emailAddress'], root),
+    }),
+    notes: root => root.notes || '',
+    price: root => root.pricing,
+    cancelPolicy: ({ option }) => {
+      if (option.cancellationCutoff) {
+        return `Cancel up to ${option.cancellationCutoff} before activity starts`;
+      }
+      return '';
+    },
+    optionId: R.path(['option', 'id']),
+    optionName: root => R.path(['option', 'title'], root) || R.path(['option', 'internalName'], root),
+    resellerReference: R.propOr('', 'resellerReference'),
+    publicUrl: () => null,
+    privateUrl: () => null,
+    pickupRequested: R.prop('pickupRequested'),
+    pickupPointId: R.prop('pickupPointId'),
+    pickupPoint: root => {
+      const pickupPoint = R.path(['pickupPoint'], root);
+      if (!pickupPoint) return null;
+      return {
+        ...pickupPoint,
+        postal: pickupPoint.postal_code,
+      };
+    },
+  },
+};
+
+const translateBooking = async ({ rootValue, typeDefs, query }) => {
+  const schema = makeExecutableSchema({
+    typeDefs,
+    resolvers,
+  });
+  const retVal = await graphql({
+    schema,
+    rootValue,
+    source: query,
+  });
+  if (retVal.errors) throw new Error(retVal.errors);
+  return retVal.data;
+};
+
+module.exports = {
+  translateBooking,
+};

package/resolvers/product.js

@@ -0,0 +1,48 @@
+const { makeExecutableSchema } = require('@graphql-tools/schema');
+const R = require('ramda');
+const { graphql } = require('graphql');
+
+const resolvers = {
+  Query: {
+    productId: R.path(['id']),
+    productName: o => R.path(['title'], o) || R.prop('internalName', o),
+    availableCurrencies: R.path(['availableCurrencies']),
+    defaultCurrency: R.path(['defaultCurrency']),
+    options: R.propOr([], 'options'),
+  },
+  Option: {
+    optionId: R.prop('id'),
+    optionName: o => R.path(['title'], o) || R.prop('internalName', o),
+    units: R.propOr([], 'units'),
+  },
+  Unit: {
+    unitId: R.path(['id']),
+    unitName: o => R.path(['title'], o) || R.prop('internalName', o),
+    subtitle: R.path(['subtitle']),
+    type: R.prop('type'),
+    pricing: root => R.path(['pricing'], root) || R.path(['pricingFrom'], root),
+    restrictions: R.prop('restrictions'),
+  },
+};
+
+const translateProduct = async ({
+  rootValue,
+  typeDefs,
+  query,
+}) => {
+  const schema = makeExecutableSchema({
+    typeDefs,
+    resolvers,
+  });
+  const retVal = await graphql({
+    schema,
+    rootValue,
+    source: query,
+  });
+  if (retVal.errors) throw new Error(retVal.errors);
+  return retVal.data;
+};
+
+module.exports = {
+  translateProduct,
+};

package/resolvers/rate.js

@@ -0,0 +1,34 @@
+const { makeExecutableSchema } = require('@graphql-tools/schema');
+const R = require('ramda');
+const { graphql } = require('graphql');
+
+const resolvers = {
+  Query: {
+    rateId: R.path(['unitId']),
+    rateName: root => R.toLower(R.path(['unitName'], root)),
+    pricing: root => [{
+      original: R.path(['total_including_tax'], root),
+      retail: R.path(['total_including_tax'], root),
+      currencyPrecision: 2,
+      currency: R.path(['company', 'currency'], root),
+    }],
+  },
+};
+
+const translateRate = async ({ rootValue, typeDefs, query }) => {
+  const schema = makeExecutableSchema({
+    typeDefs,
+    resolvers,
+  });
+  const retVal = await graphql({
+    schema,
+    rootValue,
+    source: query,
+  });
+  if (retVal.errors) throw new Error(retVal.errors);
+  return retVal.data;
+};
+
+module.exports = {
+  translateRate,
+};