ti2-bokun 1.0.0

package/resolvers/booking.js

@@ -0,0 +1,356 @@
+const { makeExecutableSchema } = require('@graphql-tools/schema');
+const R = require('ramda');
+const moment = require('moment');
+const { graphql } = require('graphql');
+
+/** Normalize date to ISO 8601 so UI's moment().utcOffset().format() works reliably */
+const toIsoString = val => {
+  if (!val) return null;
+  if (typeof val !== 'string' && typeof val !== 'number') return null;
+  const m = moment(val);
+  return m.isValid() ? m.toISOString() : null;
+};
+
+const resolvers = {
+  Query: {
+    id: o => R.path(['id'], o) || R.path(['confirmationCode'], o),
+    bookingId: o => R.path(['id'], o) || R.path(['confirmationCode'], o),
+    supplierReference: o => R.path(['supplierReference'], o) || R.path(['confirmationCode'], o) || R.path(['id'], o),
+    supplierBookingId: o => R.path(['supplierReference'], o) || R.path(['confirmationCode'], o) || R.path(['id'], o),
+    status: o => {
+      const status = R.path(['status'], o);
+      const bookingStatus = R.path(['bookingStatus'], o);
+
+      if (status) return status;
+      if (bookingStatus) {
+        switch (bookingStatus.toUpperCase()) {
+          case 'CONFIRMED': return 'CONFIRMED';
+          case 'CANCELLED': return 'CANCELLED';
+          case 'PENDING': return 'PENDING';
+          case 'EXPIRED': return 'EXPIRED';
+          default: return 'PENDING';
+        }
+      }
+
+      return 'CONFIRMED';
+    },
+    productId: o => {
+      const productId = R.path(['productId'], o);
+      if (productId) return productId;
+
+      const activityBookings = R.path(['activityBookings'], o);
+      if (activityBookings && activityBookings.length > 0) {
+        return activityBookings[0].activityId;
+      }
+
+      return null;
+    },
+    productName: o => {
+      const productName = R.path(['productName'], o);
+      const productTitle = R.path(['productTitle'], o);
+      const product = R.path(['product'], o);
+
+      if (productName) return productName;
+      if (productTitle) return productTitle;
+      if (product && product.internalName) return product.internalName;
+
+      const activityBookings = R.path(['activityBookings'], o);
+      if (activityBookings && activityBookings.length > 0) {
+        return activityBookings[0].activityTitle || activityBookings[0].activityName;
+      }
+
+      return 'Bokun Activity';
+    },
+    cancellable: o => {
+      const cancellable = R.path(['cancellable'], o);
+      const status = R.path(['status'], o) || R.path(['bookingStatus'], o);
+
+      if (cancellable !== undefined) return cancellable;
+
+      return status !== 'CANCELLED' && status !== 'EXPIRED';
+    },
+    editable: o => {
+      const editable = R.path(['editable'], o);
+      const status = R.path(['status'], o) || R.path(['bookingStatus'], o);
+
+      if (editable !== undefined) return editable;
+
+      return status !== 'CANCELLED' && status !== 'EXPIRED';
+    },
+    unitItems: o => {
+      const unitItems = R.path(['unitItems'], o);
+      if (unitItems && unitItems.length > 0) {
+        // OCTO format: aggregate by unitId (each unitItem = 1 unit)
+        const byUnitId = unitItems.reduce((acc, item) => {
+          const unitId = item.unitId || (item.unit && item.unit.id);
+          const unitName = (item.unit && item.unit.internalName) || item.unitName || 'Ticket';
+          if (unitId) {
+            if (!acc[unitId]) acc[unitId] = { unitItemId: unitId, unitId, unitName, quantity: 0 };
+            acc[unitId].quantity += 1;
+          }
+          return acc;
+        }, {});
+        return Object.values(byUnitId);
+      }
+
+      const activityBookings = R.path(['activityBookings'], o);
+      if (activityBookings && activityBookings.length > 0) {
+        const pricingCategoryBookings = activityBookings[0].pricingCategoryBookings || [];
+        return pricingCategoryBookings.map(booking => ({
+          unitItemId: booking.pricingCategoryId,
+          unitId: booking.pricingCategoryId,
+          unitName: booking.pricingCategoryName || booking.pricingCategoryTitle || 'Ticket',
+          quantity: booking.quantity || 1,
+        }));
+      }
+
+      return [];
+    },
+    holder: o => {
+      const holder = R.path(['holder'], o);
+      if (holder) return holder;
+
+      const contact = R.path(['contact'], o);
+      const customerInfo = R.path(['customerInfo'], o);
+      const customer = R.path(['customer'], o);
+      const info = contact || customerInfo || customer;
+
+      if (info) {
+        const firstName = info.firstName || (info.fullName || '').split(' ')[0] || '';
+        const lastName = info.lastName || (info.fullName || '').split(' ').slice(1).join(' ') || '';
+        const fullName = `${info.firstName || ''} ${info.lastName || ''}`.trim()
+          || info.fullName || info.name || null;
+        return {
+          name: firstName || (fullName ? fullName.split(' ')[0] : null) || null,
+          surname: lastName || (fullName ? fullName.split(' ').slice(1).join(' ') : null) || null,
+          fullName: fullName || (firstName || lastName ? `${firstName} ${lastName}`.trim() : null) || null,
+          emailAddress: info.email || info.emailAddress || null,
+          phoneNumber: info.phoneNumber || info.phone || null,
+          locales: info.locales || [],
+          country: info.country || null,
+        };
+      }
+
+      return null;
+    },
+    notes: o => R.path(['notes'], o) || R.path(['specialRequests'], o) || null,
+    price: o => {
+      const price = R.path(['price'], o);
+      const pricing = R.path(['pricing'], o);
+      const totalPrice = R.path(['totalPrice'], o);
+      const total = R.path(['total'], o);
+
+      if (price) return price;
+      if (pricing) {
+        return {
+          original: pricing.original != null ? pricing.original : (pricing.retail != null ? pricing.retail : 0),
+          retail: pricing.retail != null ? pricing.retail : (pricing.original != null ? pricing.original : 0),
+          net: pricing.net != null ? pricing.net : (pricing.retail != null ? pricing.retail : (pricing.original != null ? pricing.original : 0)),
+          currency: pricing.currency || 'USD',
+          currencyPrecision: pricing.currencyPrecision != null ? pricing.currencyPrecision : 2,
+        };
+      }
+      if (totalPrice) {
+        return {
+          original: totalPrice,
+          retail: totalPrice,
+          net: totalPrice,
+          currency: R.path(['currency'], o) || 'USD',
+          currencyPrecision: 2,
+        };
+      }
+      if (total) {
+        return {
+          original: total,
+          retail: total,
+          net: total,
+          currency: R.path(['currency'], o) || 'USD',
+          currencyPrecision: 2,
+        };
+      }
+
+      return {
+        original: 0,
+        retail: 0,
+        net: 0,
+        currency: 'USD',
+        currencyPrecision: 2,
+      };
+    },
+    cancelPolicy: o => R.path(['cancelPolicy'], o) || R.path(['cancellationPolicy'], o) || null,
+    optionId: o => {
+      const optionId = R.path(['optionId'], o);
+      if (optionId) return optionId;
+
+      const activityBookings = R.path(['activityBookings'], o);
+      if (activityBookings && activityBookings.length > 0) {
+        return activityBookings[0].rateId || activityBookings[0].startTimeId;
+      }
+
+      return null;
+    },
+    optionName: o => {
+      const optionName = R.path(['optionName'], o);
+      const option = R.path(['option'], o);
+      if (optionName) return optionName;
+      if (option && option.internalName) return option.internalName;
+
+      const activityBookings = R.path(['activityBookings'], o);
+      if (activityBookings && activityBookings.length > 0) {
+        return activityBookings[0].rateName || activityBookings[0].startTime;
+      }
+
+      return null;
+    },
+    availabilityId: o => {
+      const availabilityId = R.path(['availabilityId'], o);
+      if (availabilityId) return availabilityId;
+
+      const activityBookings = R.path(['activityBookings'], o);
+      if (activityBookings && activityBookings.length > 0) {
+        return activityBookings[0].startTimeId;
+      }
+
+      return null;
+    },
+    utcDateTimeStart: o => {
+      const start = R.path(['utcDateTimeStart'], o)
+        || R.path(['availability', 'localDateTimeStart'], o)
+        || R.path(['startDate'], o);
+      return toIsoString(start);
+    },
+    utcDateTimeEnd: o => {
+      const end = R.path(['utcDateTimeEnd'], o)
+        || R.path(['availability', 'localDateTimeEnd'], o)
+        || R.path(['endDate'], o);
+      return toIsoString(end);
+    },
+    timeZone: o => R.path(['product', 'timeZone'], o) || null,
+    start: o => {
+      const start = R.path(['utcDateTimeStart'], o)
+        || R.path(['availability', 'localDateTimeStart'], o)
+        || R.path(['startDate'], o);
+      return toIsoString(start);
+    },
+    end: o => {
+      const end = R.path(['utcDateTimeEnd'], o)
+        || R.path(['availability', 'localDateTimeEnd'], o)
+        || R.path(['endDate'], o);
+      return toIsoString(end);
+    },
+    bookingDate: o => toIsoString(R.path(['utcCreatedAt'], o) || R.path(['createdDate'], o)),
+    utcCreatedAt: o => toIsoString(R.path(['utcCreatedAt'], o) || R.path(['createdDate'], o)),
+    utcUpdatedAt: o => toIsoString(R.path(['utcUpdatedAt'], o) || R.path(['modifiedDate'], o)),
+    utcExpiresAt: o => toIsoString(R.path(['utcExpiresAt'], o) || R.path(['expiresAt'], o)),
+    utcRedeemedAt: o => toIsoString(R.path(['utcRedeemedAt'], o)),
+    utcConfirmedAt: o => toIsoString(R.path(['utcConfirmedAt'], o) || R.path(['confirmedDate'], o)),
+    resellerReference: o => R.path(['resellerReference'], o) || R.path(['externalSaleId'], o) || null,
+    publicUrl: o => R.path(['publicUrl'], o) || null,
+    privateUrl: o => {
+      const url = R.path(['privateUrl'], o);
+      if (url) return url;
+      const uiBaseUrl = R.path(['uiBaseUrl'], o);
+      const id = R.path(['id'], o);
+      if (uiBaseUrl && id) {
+        const base = uiBaseUrl.replace(/\/$/, '');
+        return `${base}/sales/${id}`;
+      }
+      return null;
+    },
+    pickupRequested: o => R.path(['pickupRequested'], o) || false,
+    pickupPointId: o => R.path(['pickupPointId'], o) || R.path(['pickupPlaceId'], o) || null,
+    pickupPoint: o => R.path(['pickupPoint'], o) || R.path(['pickupPlace'], o) || null,
+    pickupHotel: o => R.path(['pickupHotel'], o) || null,
+    pickupHotelRoom: o => R.path(['pickupHotelRoom'], o) || null,
+    voucher: o => {
+      const voucher = R.path(['voucher'], o);
+      if (!voucher) return null;
+      if (typeof voucher === 'string') return voucher;
+      const options = voucher.deliveryOptions || [];
+      const pdf = options.find(opt => opt.deliveryFormat === 'PDF_URL');
+      return (pdf && pdf.deliveryValue) || null;
+    },
+  },
+};
+
+const getSchemaTypeNames = typeDefs => {
+  const names = new Set();
+  const strings = Array.isArray(typeDefs) ? typeDefs : [typeDefs];
+  const typeRegex = /type\s+([A-Za-z0-9_]+)\s*\{([^}]*)\}/g;
+
+  strings.forEach(def => {
+    if (typeof def !== 'string') return;
+    let match = typeRegex.exec(def);
+    while (match) {
+      names.add(match[1]);
+      match = typeRegex.exec(def);
+    }
+  });
+
+  return names;
+};
+
+const getTypeFields = typeDefs => {
+  const typeFields = {};
+  const strings = Array.isArray(typeDefs) ? typeDefs : [typeDefs];
+  const typeRegex = /type\s+([A-Za-z0-9_]+)\s*\{([^}]*)\}/g;
+  const fieldRegex = /([A-Za-z0-9_]+)\s*[:([]/g;
+
+  strings.forEach(def => {
+    if (typeof def !== 'string') return;
+    let match = typeRegex.exec(def);
+    while (match) {
+      const typeName = match[1];
+      const body = match[2];
+      const fields = new Set();
+      let fieldMatch = fieldRegex.exec(body);
+      while (fieldMatch) {
+        fields.add(fieldMatch[1]);
+        fieldMatch = fieldRegex.exec(body);
+      }
+      typeFields[typeName] = fields;
+      match = typeRegex.exec(def);
+    }
+  });
+
+  return typeFields;
+};
+
+const translateBooking = async ({
+  rootValue,
+  typeDefs,
+  query,
+}) => {
+  const schemaTypeNames = getSchemaTypeNames(typeDefs);
+  const typeFields = getTypeFields(typeDefs);
+
+  const filteredResolvers = {};
+  if (schemaTypeNames.has('Query')) {
+    const queryFields = typeFields.Query || new Set();
+    const queryResolvers = {};
+    Object.keys(resolvers.Query).forEach(fieldName => {
+      if (queryFields.has(fieldName)) {
+        queryResolvers[fieldName] = resolvers.Query[fieldName];
+      }
+    });
+    if (Object.keys(queryResolvers).length > 0) {
+      filteredResolvers.Query = queryResolvers;
+    }
+  }
+
+  const schema = makeExecutableSchema({
+    typeDefs,
+    resolvers: filteredResolvers,
+  });
+  const retVal = await graphql({
+    schema,
+    rootValue,
+    source: query,
+  });
+  if (retVal.errors) throw new Error(retVal.errors);
+  return retVal.data;
+};
+
+module.exports = {
+  translateBooking,
+};

package/resolvers/pickup-point.js

@@ -0,0 +1,158 @@
+const { makeExecutableSchema } = require('@graphql-tools/schema');
+const R = require('ramda');
+const { graphql } = require('graphql');
+
+const buildPickupResolvers = typeDefs => {
+  const resolvers = {};
+
+  const pickupFields = {
+    key: o => {
+      const id = R.path(['id'], o) || R.path(['uuid'], o) || R.path(['code'], o);
+      const lat = R.path(['latitude'], o) || R.path(['lat'], o) || R.path(['geoPoint', 'latitude'], o);
+      const lng = R.path(['longitude'], o) || R.path(['lng'], o)
+        || R.path(['lon'], o) || R.path(['geoPoint', 'longitude'], o);
+      if (id) return id.toString();
+      if (lat !== undefined && lng !== undefined) return `${lat},${lng}`;
+      return null;
+    },
+    id: R.path(['id']),
+    name: o => R.path(['name'], o) || R.path(['title'], o) || R.path(['label'], o),
+    description: o => R.path(['description'], o) || R.path(['notes'], o) || null,
+    address: o => {
+      const address = R.path(['address'], o);
+      if (address) return address;
+      const street = R.path(['street'], o);
+      const city = R.path(['city'], o);
+      const state = R.path(['state'], o);
+      const postalCode = R.path(['postalCode'], o) || R.path(['zipCode'], o);
+      const country = R.path(['country'], o);
+      const parts = [];
+      if (street) parts.push(street);
+      if (city) parts.push(city);
+      if (state) parts.push(state);
+      if (postalCode) parts.push(postalCode);
+      if (country) parts.push(country);
+      return parts.length > 0 ? parts.join(', ') : null;
+    },
+    latitude: o => {
+      const latitude = R.path(['latitude'], o);
+      const lat = R.path(['lat'], o);
+      const geoPoint = R.path(['geoPoint'], o);
+      if (latitude !== undefined) return latitude;
+      if (lat !== undefined) return lat;
+      if (geoPoint && geoPoint.latitude !== undefined) return geoPoint.latitude;
+      return null;
+    },
+    longitude: o => {
+      const longitude = R.path(['longitude'], o);
+      const lng = R.path(['lng'], o);
+      const lon = R.path(['lon'], o);
+      const geoPoint = R.path(['geoPoint'], o);
+      if (longitude !== undefined) return longitude;
+      if (lng !== undefined) return lng;
+      if (lon !== undefined) return lon;
+      if (geoPoint && geoPoint.longitude !== undefined) return geoPoint.longitude;
+      return null;
+    },
+    pickupType: o => {
+      const pickupType = R.path(['pickupType'], o);
+      const type = R.path(['type'], o);
+      if (pickupType) return pickupType;
+      if (type) return type;
+      return 'MEET_ON_LOCATION';
+    },
+    directions: o => R.path(['directions'], o) || R.path(['instructions'], o) || null,
+  };
+
+  const defaultTypeNames = ['PickupPoint', 'PickupPointNode', 'PickupLocation'];
+
+  const strings = (Array.isArray(typeDefs) ? typeDefs : [typeDefs]).filter(Boolean);
+  const typeRegex = /type\s+([A-Za-z0-9_]+)\s*\{([^}]*)\}/g;
+
+  strings.forEach(def => {
+    if (typeof def !== 'string') return;
+    let match = typeRegex.exec(def);
+    while (match) {
+      const [, typeName, body] = match;
+      if (/pickup/i.test(typeName) || /pickup/i.test(body)) {
+        const fieldResolvers = {};
+        const fieldRegex = /([A-Za-z0-9_]+)\s*:/g;
+        let fieldMatch = fieldRegex.exec(body);
+        while (fieldMatch) {
+          const fieldName = fieldMatch[1];
+          if (pickupFields[fieldName]) {
+            fieldResolvers[fieldName] = pickupFields[fieldName];
+          }
+          fieldMatch = fieldRegex.exec(body);
+        }
+
+        if (Object.keys(fieldResolvers).length > 0) {
+          resolvers[typeName] = fieldResolvers;
+        }
+      }
+      match = typeRegex.exec(def);
+    }
+  });
+
+  if (Object.keys(resolvers).length === 0) {
+    defaultTypeNames.forEach(typeName => {
+      resolvers[typeName] = pickupFields;
+    });
+  }
+
+  return resolvers;
+};
+
+const translatePickupPoint = async ({
+  rootValue,
+  typeDefs,
+  query,
+}) => {
+  const resolvers = buildPickupResolvers(typeDefs);
+
+  const typeNames = Object.keys(resolvers);
+  const strings = (Array.isArray(typeDefs) ? typeDefs : [typeDefs]).filter(Boolean).slice();
+
+  const hasTypeDefinition = (defs, typeName) => defs.some(
+    def => typeof def === 'string' && new RegExp(`type\\s+${typeName}\\b`).test(def),
+  );
+
+  const getFieldType = fieldName => {
+    if (fieldName === 'key' || fieldName === 'id') return 'ID';
+    if (fieldName === 'latitude' || fieldName === 'longitude') return 'Float';
+    return 'String';
+  };
+
+  typeNames.forEach(typeName => {
+    if (!hasTypeDefinition(strings, typeName)) {
+      const availableFields = Object.keys(resolvers[typeName]);
+      const typeDef = `type ${typeName} {\n${
+        availableFields.map(field => `  ${field}: ${getFieldType(field)}`).join('\n')
+      }\n}`;
+      strings.push(typeDef);
+    }
+  });
+
+  if (!hasTypeDefinition(strings, 'Query')) {
+    strings.push('type Query { _pickupPointDummy: Boolean }');
+  }
+
+  if (!query) {
+    return {};
+  }
+
+  const retVal = await graphql({
+    schema: makeExecutableSchema({
+      typeDefs: strings,
+      resolvers,
+    }),
+    rootValue: rootValue || {},
+    source: query,
+  });
+  if (retVal.errors) throw new Error(retVal.errors);
+  return retVal.data;
+};
+
+module.exports = {
+  translatePickupPoint,
+};

package/resolvers/product.js

@@ -0,0 +1,155 @@
+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.path(['name'], o) || R.prop('internalName', o),
+    availableCurrencies: o => {
+      const currencies = R.path(['currencies'], o);
+      return currencies || ['USD'];
+    },
+    defaultCurrency: o => R.path(['defaultCurrency'], o) || 'USD',
+    options: root => {
+      const products = R.propOr([], 'products', root);
+      const options = R.propOr([], 'options', root);
+      const rates = R.propOr([], 'rates', root);
+
+      if (products.length > 0) {
+        return products.map(product => ({
+          ...product,
+          id: product.id,
+          title: product.title || product.name,
+          units: product.pricingCategories || [],
+        }));
+      }
+
+      if (options.length > 0) {
+        return options;
+      }
+
+      if (rates.length > 0) {
+        return [{
+          id: root.id,
+          title: root.title || root.name,
+          units: rates,
+        }];
+      }
+
+      return [{
+        id: root.id,
+        title: root.title || root.name,
+        units: R.propOr([], 'pricingCategories', root),
+      }];
+    },
+  },
+  Option: {
+    optionId: R.prop('id'),
+    optionName: o => R.path(['title'], o) || R.path(['name'], o) || R.prop('internalName', o),
+    units: root => {
+      const units = R.propOr([], 'units', root);
+      const pricingCategories = R.propOr([], 'pricingCategories', root);
+      const rates = R.propOr([], 'rates', root);
+
+      if (units.length > 0) return units;
+      if (pricingCategories.length > 0) return pricingCategories;
+      if (rates.length > 0) return rates;
+
+      return [];
+    },
+  },
+  Unit: {
+    unitId: o => R.path(['id'], o) || R.path(['pricingCategoryId'], o),
+    unitName: o => R.path(['title'], o) || R.path(['name'], o) || R.path(['label'], o) || R.prop('internalName', o),
+    subtitle: R.path(['subtitle']),
+    type: o => {
+      const ageFrom = R.path(['minAge'], o);
+      const ageTo = R.path(['maxAge'], o);
+
+      if (ageFrom !== undefined && ageTo !== undefined) {
+        if (ageFrom >= 18) return 'ADULT';
+        if (ageTo <= 17) return 'CHILD';
+        if (ageTo <= 3) return 'INFANT';
+      }
+
+      return R.prop('type', o) || 'ADULT';
+    },
+    pricing: root => {
+      const pricing = R.path(['pricing'], root);
+      const price = R.path(['price'], root);
+      const defaultPrice = R.path(['defaultPrice'], root);
+      const priceFrom = R.path(['priceFrom'], root);
+
+      if (pricing) return pricing;
+
+      if (price !== undefined) {
+        return [{
+          currency: R.path(['currency'], root) || 'USD',
+          currencyPrecision: 2,
+          price,
+        }];
+      }
+
+      if (defaultPrice !== undefined) {
+        return [{
+          currency: R.path(['currency'], root) || 'USD',
+          currencyPrecision: 2,
+          price: defaultPrice,
+        }];
+      }
+
+      if (priceFrom !== undefined) {
+        return [{
+          currency: R.path(['currency'], root) || 'USD',
+          currencyPrecision: 2,
+          price: priceFrom,
+        }];
+      }
+
+      return [{
+        currency: 'USD',
+        currencyPrecision: 2,
+        price: 0,
+      }];
+    },
+    restrictions: root => {
+      const restrictions = R.prop('restrictions', root);
+      if (restrictions) return restrictions;
+
+      const minAge = R.path(['minAge'], root);
+      const maxAge = R.path(['maxAge'], root);
+      const minQuantity = R.path(['minQuantity'], root);
+      const maxQuantity = R.path(['maxQuantity'], root);
+
+      return {
+        ...(minAge !== undefined && { minAge }),
+        ...(maxAge !== undefined && { maxAge }),
+        ...(minQuantity !== undefined && { minUnits: minQuantity }),
+        ...(maxQuantity !== undefined && { maxUnits: maxQuantity }),
+      };
+    },
+  },
+};
+
+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,33 @@
+const { makeExecutableSchema } = require('@graphql-tools/schema');
+const R = require('ramda');
+const { graphql } = require('graphql');
+
+const resolvers = {
+  Query: {
+    rateId: R.path(['id']),
+    rateName: o => R.path(['name'], o) || R.path(['title'], o) || R.path(['label'], o),
+    rateDescription: o => R.path(['description'], o) || null,
+  },
+};
+
+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,
+};