ti2-ventrata 1.0.40 → 1.0.42

package/index.js

@@ -29,6 +29,30 @@ const getHeaders = ({
   // 'Octo-Capabilities': 'octo/pricing',
 });
 
+const extractVentrataErrorMessage = err => {
+  const responseData = err && err.response && err.response.data;
+  if (!responseData) return err && err.message;
+  if (typeof responseData === 'string') return responseData;
+  if (responseData.errorMessage) return responseData.errorMessage;
+  if (responseData.message) return responseData.message;
+  if (Array.isArray(responseData.errors) && responseData.errors.length > 0) {
+    const firstError = responseData.errors[0];
+    if (typeof firstError === 'string') return firstError;
+    if (firstError && firstError.message) return firstError.message;
+  }
+  return err && err.message;
+};
+
+const throwWithVentrataErrorMessage = (error, fallbackMessage) => {
+  const normalizedMessage = extractVentrataErrorMessage(error) || fallbackMessage;
+  if (error && typeof error === 'object') {
+    const wrappedError = Object.assign(new Error(normalizedMessage), error);
+    wrappedError.message = normalizedMessage;
+    throw wrappedError;
+  }
+  throw new Error(normalizedMessage);
+};
+
 class Plugin {
   constructor(params) { // we get the env variables from here
     Object.entries(params).forEach(([attr, value]) => {
@@ -390,7 +414,9 @@ class Plugin {
       notes,
       reference,
       pickupPoint,
+      pickupPointId,
       customFieldValues,
+      participants,
     },
     typeDefsAndQueries: {
       bookingTypeDefs,
@@ -407,33 +433,110 @@ class Plugin {
       acceptLanguage,
     });
     const dataForCreateBooking = await jwt.verify(availabilityKey, this.jwtKey);
-    // if customFieldValues contains perUnitItem fields
-    // we need to overwrite unitItems from the availabilityKey
-    if (customFieldValues && customFieldValues.length) {
-      const productCFV = customFieldValues.filter(o => !R.isNil(o.value) && !o.field.isPerUnitItem);
-      const unitItemCFV = customFieldValues.filter(o => !R.isNil(o.value) && o.field.isPerUnitItem);
-      if (productCFV.length) {
-        dataForCreateBooking.questionAnswers = productCFV.map(o => ({
-          questionId: o.field.id,
-          value: o.value,
-        }));
+    const safeCustomFieldValues = Array.isArray(customFieldValues) ? customFieldValues : [];
+    const safeParticipants = Array.isArray(participants) ? participants : [];
+    const normalizeAnswerValue = rawValue => {
+      // Some TI2 inputs (e.g. option/select fields) can reach us as
+      // { label, value, userInput }. Ventrata questionAnswers.value must be scalar.
+      if (rawValue && typeof rawValue === 'object' && !Array.isArray(rawValue)) {
+        if (Object.prototype.hasOwnProperty.call(rawValue, 'value')) {
+          return rawValue.value;
+        }
       }
-      if (unitItemCFV.length) {
-        dataForCreateBooking.unitItems = R.call(R.compose(
-          R.map(arr => ({
-            unitId: arr[0].field.unitId,
-            questionAnswers: arr.map(o => ({
-              questionId: o.field.id.split('|')[0],
-              value: o.value,
-            })),
-          })),
-          R.values,
-          R.groupBy(o => {
-            const [, unitItemIndex] = o.field.id.split('|');
-            return unitItemIndex;
-          }),
-        ), unitItemCFV);
+      return rawValue;
+    };
+    const parsedInt = value => {
+      const num = Number(value);
+      return Number.isInteger(num) ? num : null;
+    };
+    const upsertQuestionAnswer = (answers, nextAnswer) => {
+      const ix = answers.findIndex(existing => existing.questionId === nextAnswer.questionId);
+      if (ix > -1) answers[ix] = nextAnswer;
+      else answers.push(nextAnswer);
+    };
+    const normalizeQuestionId = value => `${value || ''}`.split('|')[0];
+    const bookingQuestionAnswers = [];
+    const unitItemAnswerCandidates = [];
+    const addAnswerEntry = (entry, participantIndex = null) => {
+      if (!entry || R.isNil(entry.value)) return;
+      const field = entry.field || {};
+      const rawFieldId = `${field.id || ''}`;
+      const questionId = normalizeQuestionId(rawFieldId);
+      if (!questionId) return;
+      const normalizedValue = normalizeAnswerValue(entry.value);
+      if (R.isNil(normalizedValue)) return;
+      const [, unitItemIndexRaw] = rawFieldId.split('|');
+      const unitItemIndexFromId = parsedInt(unitItemIndexRaw);
+      const shouldRouteToUnitItem = Boolean(field.isPerUnitItem)
+        || unitItemIndexFromId !== null
+        || (!R.isNil(participantIndex) && Boolean(field.unitId));
+      if (!shouldRouteToUnitItem) {
+        if (R.isNil(participantIndex)) {
+          bookingQuestionAnswers.push({ questionId, value: normalizedValue });
+        }
+        return;
       }
+      unitItemAnswerCandidates.push({
+        questionId,
+        value: normalizedValue,
+        unitId: field.unitId,
+        unitItemIndex: unitItemIndexFromId,
+        participantIndex,
+      });
+    };
+    safeCustomFieldValues.forEach(entry => addAnswerEntry(entry));
+    safeParticipants.forEach((participant, participantIndex) => {
+      const allParticipantEntries = [
+        ...R.pathOr([], ['fields'], participant),
+        ...R.pathOr([], ['customFieldValues'], participant),
+      ];
+      allParticipantEntries.forEach(entry => addAnswerEntry(entry, participantIndex));
+    });
+    if (bookingQuestionAnswers.length) {
+      const existingQuestionAnswers = Array.isArray(dataForCreateBooking.questionAnswers)
+        ? [...dataForCreateBooking.questionAnswers]
+        : [];
+      bookingQuestionAnswers.forEach(answer => {
+        upsertQuestionAnswer(existingQuestionAnswers, answer);
+      });
+      dataForCreateBooking.questionAnswers = existingQuestionAnswers;
+    }
+    if (unitItemAnswerCandidates.length) {
+      const nextUnitItems = Array.isArray(dataForCreateBooking.unitItems)
+        ? dataForCreateBooking.unitItems.map(unitItem => ({
+          ...unitItem,
+          questionAnswers: Array.isArray(unitItem.questionAnswers) ? [...unitItem.questionAnswers] : [],
+        }))
+        : [];
+      unitItemAnswerCandidates.forEach(candidate => {
+        const candidateIndex = (
+          candidate.unitItemIndex !== null
+            ? candidate.unitItemIndex
+            : (
+              !R.isNil(candidate.participantIndex)
+                ? candidate.participantIndex
+                : nextUnitItems.findIndex(item => item.unitId === candidate.unitId)
+            )
+        );
+        let targetIndex = candidateIndex;
+        if (!(targetIndex >= 0 && targetIndex < nextUnitItems.length)) {
+          if (candidate.unitId) {
+            nextUnitItems.push({
+              unitId: candidate.unitId,
+              questionAnswers: [],
+            });
+            targetIndex = nextUnitItems.length - 1;
+          } else {
+            return;
+          }
+        }
+        const targetItem = nextUnitItems[targetIndex];
+        upsertQuestionAnswer(targetItem.questionAnswers, {
+          questionId: candidate.questionId,
+          value: candidate.value,
+        });
+      });
+      dataForCreateBooking.unitItems = nextUnitItems;
     }
     const { settlementMethods } = dataForCreateBooking;
     const settlementMethod = Plugin.getSettlementMethod(
@@ -441,18 +544,26 @@ class Plugin {
       settlementMethods,
     );
 
-    let booking = R.path(['data'], await axios({
-      method: rebookingId ? 'patch' : 'post',
-      url: `${endpoint || this.endpoint}/bookings${rebookingId ? `/${rebookingId}` : ''}`,
-      data: {
-        orderId,
-        settlementMethod,
-        ...R.omit(['settlementMethods'], dataForCreateBooking),
-        notes,
-        ...(pickupPoint ? { pickupRequested: true, pickupPointId: pickupPoint } : {}),
-      },
-      headers,
-    }));
+    let booking;
+    try {
+      booking = R.path(['data'], await axios({
+        method: rebookingId ? 'patch' : 'post',
+        url: `${endpoint || this.endpoint}/bookings${rebookingId ? `/${rebookingId}` : ''}`,
+        data: {
+          orderId,
+          settlementMethod,
+          ...R.omit(['settlementMethods'], dataForCreateBooking),
+          notes,
+          ...((pickupPoint || pickupPointId) ? {
+            pickupRequested: true,
+            pickupPointId: pickupPoint || pickupPointId,
+          } : {}),
+        },
+        headers,
+      }));
+    } catch (error) {
+      throwWithVentrataErrorMessage(error, 'Failed to create booking');
+    }
     // for booking update, we may not need to confirm again
     if (!booking.utcConfirmedAt && !partialOrder) {
       const validatedCountry = validateCountry(R.pathOr('', ['country'], holder));
@@ -500,7 +611,7 @@ class Plugin {
         }));
       } catch (error) {
         console.error('Booking confirmation failed:', (error.response && error.response.data) ? error.response.data : error.message);
-        throw error;
+        throwWithVentrataErrorMessage(error, 'Failed to confirm booking');
       }
     }
     return ({
@@ -715,8 +826,14 @@ class Plugin {
     });
     const convertQToField = o => ({
       id: o.id,
+      ...(o.unitId ? { unitId: o.unitId } : {}),
       subtitle: o.description === o.label ? '' : o.description,
       title: o.label,
+      required: Boolean(o.required),
+      requiredPerBooking: Boolean(o.required),
+      requiredPerParticipant: Boolean(o.isPerUnitItem && o.required),
+      visiblePerBooking: true,
+      visiblePerParticipant: Boolean(o.isPerUnitItem),
       type: (() => {
         if (o.inputType === 'radio') return 'radio';
         if (Array.isArray(o.selectOptions) && o.selectOptions.length) return 'extended-option';
@@ -728,6 +845,19 @@ class Plugin {
       options: o.selectOptions,
       isPerUnitItem: o.isPerUnitItem,
     });
+    const normalizeQuestion = ({ question, context }) => ({
+      ...question,
+      isPerUnitItem: Boolean(context.isPerUnitItem),
+      ...(context.unitId ? { unitId: context.unitId } : {}),
+    });
+    const collectQuestions = roots => R.call(R.compose(
+      R.uniqBy(q => `${q.id}|${q.unitId || ''}|${Boolean(q.isPerUnitItem)}`),
+      R.chain(obj => (obj.questions || []).map(question => normalizeQuestion({
+        question,
+        context: obj,
+      }))),
+      R.filter(o => o.questions && o.questions.length),
+    ), roots);
     if (!productId) {
       const allProducts = R.pathOr([], ['data'], await axios({
         method: 'get',
@@ -735,15 +865,12 @@ class Plugin {
         headers,
       }));
       const allOptions = R.chain(R.propOr([], 'options'), allProducts);
-      const allUnits = R.chain(R.propOr([], 'units'), allOptions).map(o => ({ ...o, isPerUnitItem: true }));
-      const allQuestions = R.call(R.compose(
-        R.uniqBy(R.prop('id')),
-        R.chain(obj => (obj.questions || []).map(q => ({
-          ...q,
-          isPerUnitItem: Boolean(obj.isPerUnitItem),
-        }))),
-        R.filter(o => o.questions && o.questions.length),
-      ), [...allOptions, ...allUnits]);
+      const allUnits = R.chain(R.propOr([], 'units'), allOptions).map(u => ({
+        ...u,
+        isPerUnitItem: true,
+        unitId: u.id,
+      }));
+      const allQuestions = collectQuestions([...allOptions, ...allUnits]);
       return {
         fields: [],
         customFields: allQuestions.map(convertQToField),
@@ -757,16 +884,13 @@ class Plugin {
     }));
 
     const allOptions = R.propOr([], 'options', product);
-    const allQuestions = R.call(R.compose(
-      R.uniqBy(R.prop('id')),
-      R.chain(obj => (obj.questions || []).map(q => ({
-        ...q,
-        isPerUnitItem: Boolean(obj.isPerUnitItem),
-      }))),
-      R.filter(o => o.questions && o.questions.length),
-    ), [
+    const allQuestions = collectQuestions([
       ...allOptions,
-      ...R.chain(R.propOr([], 'units'), allOptions).map(o => ({ ...o, isPerUnitItem: true })),
+      ...R.chain(R.propOr([], 'units'), allOptions).map(u => ({
+        ...u,
+        isPerUnitItem: true,
+        unitId: u.id,
+      })),
     ]);
     if (!product) return { fields: [] };
     return {

package/index.test.js

@@ -3,6 +3,7 @@ const R = require('ramda');
 const moment = require('moment');
 const faker = require('faker');
 const axios = require('axios');
+const jwt = require('jsonwebtoken');
 
 const Plugin = require('./index');
 
@@ -29,8 +30,9 @@ const app = new Plugin({
   jwtKey: process.env.ti2_ventrata_jwtKey,
   endpoint: process.env.ti2_ventrata_endpoint,
 });
+const describeLive = process.env.RUN_VENTRATA_LIVE_TESTS === 'true' ? describe : describe.skip;
 
-describe('search tests', () => {
+describeLive('search tests', () => {
   let products;
   let testProduct = {
     productName: 'Edinburgh 3 Day Pass',
@@ -336,3 +338,49 @@ describe('search tests', () => {
     });
   });
 });
+
+describe('createBooking error handling', () => {
+  it('surfaces provider error message and preserves status details', async () => {
+    const plugin = new Plugin({
+      jwtKey: 'ventrata-test-jwt-key',
+      endpoint: 'https://api.ventrata.com/octo',
+    });
+    const providerError = {
+      response: {
+        status: 400,
+        data: {
+          errorMessage: 'The phone number Collect is invalid.',
+        },
+      },
+      message: 'Request failed with status code 400',
+    };
+    const mockedAxios = jest.fn().mockRejectedValueOnce(providerError);
+
+    const availabilityKey = jwt.sign({
+      settlementMethods: ['DEFERRED'],
+      unitItems: [],
+    }, 'ventrata-test-jwt-key');
+
+    try {
+      await plugin.createBooking({
+        axios: mockedAxios,
+        token: {
+          apiKey: 'test-api-key',
+          endpoint: 'https://api.ventrata.com/octo',
+        },
+        payload: {
+          availabilityKey,
+          holder: {
+            name: 'Test',
+            surname: 'User',
+          },
+        },
+        typeDefsAndQueries,
+      });
+      throw new Error('Expected createBooking to throw');
+    } catch (error) {
+      expect(error.message).toBe('The phone number Collect is invalid.');
+      expect(error.response.status).toBe(400);
+    }
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ti2-ventrata",
-  "version": "1.0.40",
+  "version": "1.0.42",
   "description": "Ventrata's TI2 Plugin",
   "main": "index.js",
   "scripts": {

package/resolvers/availability.js

@@ -49,7 +49,10 @@ const resolvers = {
     pickupPoints: root => R.pathOr([], ['pickupPoints'], root)
       .map(o => ({
         ...o,
-        postal: o.postal_code,
+        postal: o.postal || o.postalCode || o.postal_code || null,
+        city: o.city || o.locality || null,
+        state: o.state || o.region || null,
+        localDateTime: o.localDateTime || o.localDateTimeStart || null,
       })),
   },
 };

package/resolvers/booking.js

@@ -2,6 +2,30 @@ const { makeExecutableSchema } = require('@graphql-tools/schema');
 const R = require('ramda');
 const { graphql } = require('graphql');
 
+const isHttpUrl = value => typeof value === 'string' && /^https?:\/\//i.test(value);
+
+const getFirstHttpDeliveryUrl = root => {
+  const voucherDeliveryOptions = R.pathOr([], ['voucher', 'deliveryOptions'], root);
+  const ticketDeliveryOptions = R.chain(
+    item => R.pathOr([], ['ticket', 'deliveryOptions'], item),
+    R.pathOr([], ['unitItems'], root),
+  );
+  return R.call(
+    R.compose(
+      R.find(isHttpUrl),
+      R.map(R.prop('deliveryValue')),
+      R.flatten,
+    ),
+    [voucherDeliveryOptions, ticketDeliveryOptions],
+  ) || null;
+};
+
+const getBookingUrl = root => (
+  R.path(['checkinUrl'], root)
+  || getFirstHttpDeliveryUrl(root)
+  || null
+);
+
 const capitalize = sParam => {
   if (typeof sParam !== 'string') return '';
   const s = sParam.replace(/_/g, ' ');
@@ -49,8 +73,8 @@ const resolvers = {
     },
     optionId: R.path(['option', 'id']),
     optionName: root => R.path(['option', 'title'], root) || R.path(['option', 'internalName'], root),
-    publicUrl: () => null,
-    privateUrl: () => null,
+    publicUrl: getBookingUrl,
+    privateUrl: getBookingUrl,
     pickupRequested: R.prop('pickupRequested'),
     pickupPointId: R.prop('pickupPointId'),
     pickupPoint: root => {
@@ -58,7 +82,10 @@ const resolvers = {
       if (!pickupPoint) return null;
       return {
         ...pickupPoint,
-        postal: pickupPoint.postal_code,
+        postal: pickupPoint.postal || pickupPoint.postalCode || pickupPoint.postal_code || null,
+        city: pickupPoint.city || pickupPoint.locality || null,
+        state: pickupPoint.state || pickupPoint.region || null,
+        localDateTime: pickupPoint.localDateTime || pickupPoint.localDateTimeStart || null,
       };
     },
   },

package/resolvers/mapping.test.js

@@ -0,0 +1,428 @@
+const jwt = require('jsonwebtoken');
+
+const Plugin = require('../index');
+const { translateAvailability } = require('./availability');
+const { translateBooking } = require('./booking');
+const { typeDefs: ti2BookingTypeDefs, query: ti2BookingQuery } = require('../node_modules/ti2/controllers/graphql-schemas/booking');
+const { typeDefs: ti2AvailabilityTypeDefs, query: ti2AvailabilityQuery } = require('../node_modules/ti2/controllers/graphql-schemas/availability');
+
+describe('ventrata mappings', () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('keeps unit-scoped duplicate question ids in create booking fields', async () => {
+    const plugin = new Plugin({
+      jwtKey: 'test-jwt-key',
+      endpoint: 'https://example.test/octo',
+    });
+    const axios = jest.fn().mockResolvedValue({
+      data: {
+        options: [
+          {
+            id: 'DEFAULT',
+            questions: [],
+            units: [
+              {
+                id: 'adult-unit',
+                questions: [{ id: 'meal-choice', label: 'Meal', inputType: 'select', selectOptions: [] }],
+              },
+              {
+                id: 'child-unit',
+                questions: [{ id: 'meal-choice', label: 'Meal', inputType: 'select', selectOptions: [] }],
+              },
+            ],
+          },
+        ],
+      },
+    });
+
+    const result = await plugin.getCreateBookingFields({
+      axios,
+      token: { apiKey: 'api-key' },
+      query: { productId: 'product-1' },
+    });
+
+    expect(result.customFields).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'meal-choice',
+          isPerUnitItem: true,
+          unitId: 'adult-unit',
+          required: false,
+          requiredPerParticipant: false,
+          requiredPerBooking: false,
+          visiblePerParticipant: true,
+          visiblePerBooking: true,
+        }),
+        expect.objectContaining({
+          id: 'meal-choice',
+          isPerUnitItem: true,
+          unitId: 'child-unit',
+          required: false,
+          requiredPerParticipant: false,
+          requiredPerBooking: false,
+          visiblePerParticipant: true,
+          visiblePerBooking: true,
+        }),
+      ]),
+    );
+  });
+
+  it('maps mandatory flags for booking-level and per-participant questions', async () => {
+    const plugin = new Plugin({
+      jwtKey: 'test-jwt-key',
+      endpoint: 'https://example.test/octo',
+    });
+    const axios = jest.fn().mockResolvedValue({
+      data: {
+        options: [
+          {
+            id: 'DEFAULT',
+            questions: [{ id: 'hotel', label: 'Hotel', inputType: 'text', required: true }],
+            units: [
+              {
+                id: 'adult-unit',
+                questions: [{ id: 'meal-choice', label: 'Meal', inputType: 'select', required: true, selectOptions: [] }],
+              },
+            ],
+          },
+        ],
+      },
+    });
+
+    const result = await plugin.getCreateBookingFields({
+      axios,
+      token: { apiKey: 'api-key' },
+      query: { productId: 'product-1' },
+    });
+
+    expect(result.customFields).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'hotel',
+          required: true,
+          requiredPerBooking: true,
+          requiredPerParticipant: false,
+          visiblePerBooking: true,
+          visiblePerParticipant: false,
+        }),
+        expect.objectContaining({
+          id: 'meal-choice',
+          unitId: 'adult-unit',
+          required: true,
+          requiredPerBooking: true,
+          requiredPerParticipant: true,
+          visiblePerBooking: true,
+          visiblePerParticipant: true,
+        }),
+      ]),
+    );
+  });
+
+  it('accepts pickupPointId alias when creating booking', async () => {
+    const plugin = new Plugin({
+      jwtKey: 'test-jwt-key',
+      endpoint: 'https://example.test/octo',
+    });
+
+    const verifySpy = jest.spyOn(jwt, 'verify').mockReturnValue({
+      productId: 'product-1',
+      optionId: 'DEFAULT',
+      availabilityId: 'avail-1',
+      unitItems: [{ unitId: 'adult-unit' }],
+      settlementMethods: ['DEFERRED'],
+    });
+
+    const axios = jest.fn().mockResolvedValue({
+      data: {
+        id: 'booking-id',
+        orderId: 'order-id',
+        orderReference: 'order-ref',
+        supplierReference: 'supplier-ref',
+        status: 'CONFIRMED',
+        product: { id: 'product-1', internalName: 'Product' },
+        option: { id: 'DEFAULT', internalName: 'DEFAULT' },
+        availability: { localDateTimeStart: '2026-05-02T08:00:00', localDateTimeEnd: '2026-05-02T10:00:00' },
+        contact: { fullName: 'Test User' },
+        cancellable: true,
+        utcCreatedAt: '2026-05-01T00:00:00Z',
+        pricing: { retail: 1000 },
+        unitItems: [{ uuid: 'unit-item-1', unitId: 'adult-unit', internalName: 'Adult' }],
+        pickupRequested: true,
+        pickupPointId: 'pickup-123',
+        utcConfirmedAt: '2026-05-01T00:00:01Z',
+      },
+    });
+
+    await plugin.createBooking({
+      axios,
+      token: { apiKey: 'api-key' },
+      payload: {
+        availabilityKey: 'signed-key',
+        holder: { name: 'Test', surname: 'User', country: 'US' },
+        pickupPointId: 'pickup-123',
+      },
+      typeDefsAndQueries: {
+        bookingTypeDefs: ti2BookingTypeDefs,
+        bookingQuery: ti2BookingQuery,
+      },
+    });
+
+    expect(verifySpy).toHaveBeenCalledWith('signed-key', 'test-jwt-key');
+    const createBookingCall = axios.mock.calls.find(call => call[0].url === 'https://example.test/octo/bookings');
+    expect(createBookingCall).toBeTruthy();
+    expect(createBookingCall[0].data).toEqual(
+      expect.objectContaining({
+        pickupRequested: true,
+        pickupPointId: 'pickup-123',
+      }),
+    );
+  });
+
+  it('maps participant-scoped custom fields from standard ti2 payload into unitItems questionAnswers', async () => {
+    const plugin = new Plugin({
+      jwtKey: 'test-jwt-key',
+      endpoint: 'https://example.test/octo',
+    });
+
+    jest.spyOn(jwt, 'verify').mockReturnValue({
+      productId: 'product-1',
+      optionId: 'DEFAULT',
+      availabilityId: 'avail-1',
+      unitItems: [
+        { unitId: 'adult-unit' },
+        { unitId: 'adult-unit' },
+      ],
+      settlementMethods: ['DEFERRED'],
+    });
+
+    const axios = jest.fn().mockResolvedValue({
+      data: {
+        id: 'booking-id',
+        orderId: 'order-id',
+        orderReference: 'order-ref',
+        supplierReference: 'supplier-ref',
+        status: 'CONFIRMED',
+        product: { id: 'product-1', internalName: 'Product' },
+        option: { id: 'DEFAULT', internalName: 'DEFAULT' },
+        availability: { localDateTimeStart: '2026-05-02T08:00:00', localDateTimeEnd: '2026-05-02T10:00:00' },
+        contact: { fullName: 'Test User' },
+        cancellable: true,
+        utcCreatedAt: '2026-05-01T00:00:00Z',
+        pricing: { retail: 1000 },
+        unitItems: [{ uuid: 'unit-item-1', unitId: 'adult-unit', internalName: 'Adult' }],
+        utcConfirmedAt: '2026-05-01T00:00:01Z',
+      },
+    });
+
+    await plugin.createBooking({
+      axios,
+      token: { apiKey: 'api-key' },
+      payload: {
+        availabilityKey: 'signed-key',
+        holder: { name: 'Test', surname: 'User', country: 'US' },
+        customFieldValues: [
+          {
+            field: { id: 'specialReq', isPerUnitItem: false },
+            value: 'Window seat',
+          },
+        ],
+        participants: [
+          {
+            fields: [
+              {
+                field: { id: 'dietary', isPerUnitItem: true, unitId: 'adult-unit' },
+                value: 'Vegan',
+              },
+            ],
+          },
+          {
+            fields: [
+              {
+                field: { id: 'dietary', isPerUnitItem: true, unitId: 'adult-unit' },
+                value: 'Gluten-free',
+              },
+            ],
+          },
+        ],
+      },
+      typeDefsAndQueries: {
+        bookingTypeDefs: ti2BookingTypeDefs,
+        bookingQuery: ti2BookingQuery,
+      },
+    });
+
+    const createBookingCall = axios.mock.calls.find(call => call[0].url === 'https://example.test/octo/bookings');
+    expect(createBookingCall).toBeTruthy();
+    expect(createBookingCall[0].data.questionAnswers).toEqual(
+      expect.arrayContaining([
+        {
+          questionId: 'specialReq',
+          value: 'Window seat',
+        },
+      ]),
+    );
+    expect(createBookingCall[0].data.unitItems).toEqual([
+      {
+        unitId: 'adult-unit',
+        questionAnswers: [
+          {
+            questionId: 'dietary',
+            value: 'Vegan',
+          },
+        ],
+      },
+      {
+        unitId: 'adult-unit',
+        questionAnswers: [
+          {
+            questionId: 'dietary',
+            value: 'Gluten-free',
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('normalizes object-like custom-field values to scalar questionAnswers values', async () => {
+    const plugin = new Plugin({
+      jwtKey: 'test-jwt-key',
+      endpoint: 'https://example.test/octo',
+    });
+
+    jest.spyOn(jwt, 'verify').mockReturnValue({
+      productId: 'product-1',
+      optionId: 'DEFAULT',
+      availabilityId: 'avail-1',
+      unitItems: [{ unitId: 'adult-unit' }],
+      settlementMethods: ['DEFERRED'],
+    });
+
+    const axios = jest.fn().mockResolvedValue({
+      data: {
+        id: 'booking-id',
+        orderId: 'order-id',
+        orderReference: 'order-ref',
+        supplierReference: 'supplier-ref',
+        status: 'CONFIRMED',
+        product: { id: 'product-1', internalName: 'Product' },
+        option: { id: 'DEFAULT', internalName: 'DEFAULT' },
+        availability: { localDateTimeStart: '2026-05-02T08:00:00', localDateTimeEnd: '2026-05-02T10:00:00' },
+        contact: { fullName: 'Test User' },
+        cancellable: true,
+        utcCreatedAt: '2026-05-01T00:00:00Z',
+        pricing: { retail: 1000 },
+        unitItems: [{ uuid: 'unit-item-1', unitId: 'adult-unit', internalName: 'Adult' }],
+        utcConfirmedAt: '2026-05-01T00:00:01Z',
+      },
+    });
+
+    const lunchSelection = 'Green Salad (Gluten Free) - romaine lettuce diced tomato green onion cucumber diced chicken & french dressing';
+
+    await plugin.createBooking({
+      axios,
+      token: { apiKey: 'api-key' },
+      payload: {
+        availabilityKey: 'signed-key',
+        holder: { name: 'Test', surname: 'User', country: 'US' },
+        customFieldValues: [
+          {
+            field: { id: '8959d9a0-cb46-4f29-97fa-e07ce7f961da', isPerUnitItem: false },
+            value: {
+              label: lunchSelection,
+              value: lunchSelection,
+              userInput: true,
+            },
+          },
+        ],
+      },
+      typeDefsAndQueries: {
+        bookingTypeDefs: ti2BookingTypeDefs,
+        bookingQuery: ti2BookingQuery,
+      },
+    });
+
+    const createBookingCall = axios.mock.calls.find(call => call[0].url === 'https://example.test/octo/bookings');
+    expect(createBookingCall).toBeTruthy();
+    expect(createBookingCall[0].data.questionAnswers).toEqual(
+      expect.arrayContaining([
+        {
+          questionId: '8959d9a0-cb46-4f29-97fa-e07ce7f961da',
+          value: lunchSelection,
+        },
+      ]),
+    );
+  });
+
+  it('normalizes pickup point fields for availability and booking translations', async () => {
+    const availability = await translateAvailability({
+      rootValue: {
+        pickupPoints: [
+          {
+            id: 'pickup-1',
+            postalCode: 'T1L',
+            locality: 'Banff',
+            region: 'Alberta',
+            localDateTimeStart: '2026-05-02T08:00:00',
+          },
+        ],
+      },
+      variableValues: {
+        productId: 'product-1',
+        optionId: 'DEFAULT',
+        unitsWithQuantity: [],
+        currency: 'CAD',
+        jwtKey: '',
+      },
+      typeDefs: ti2AvailabilityTypeDefs,
+      query: ti2AvailabilityQuery,
+    });
+    expect(availability.pickupPoints[0]).toEqual(expect.objectContaining({
+      postal: 'T1L',
+      city: 'Banff',
+      state: 'Alberta',
+      localDateTime: '2026-05-02T08:00:00',
+    }));
+
+    const booking = await translateBooking({
+      rootValue: {
+        id: 'booking-2',
+        status: 'CONFIRMED',
+        unitItems: [],
+        option: {
+          id: 'DEFAULT',
+          internalName: 'DEFAULT',
+          cancellationCutoff: '',
+        },
+        product: { id: 'product-1', internalName: 'Product' },
+        availability: {},
+        contact: {},
+        pricing: {},
+        voucher: {
+          deliveryOptions: [
+            {
+              deliveryFormat: 'PDF_URL',
+              deliveryValue: 'https://api.ventrata.com/octo/pdf?booking=booking-2',
+            },
+          ],
+        },
+        pickupPoint: {
+          id: 'pickup-2',
+          postalCode: 'T2E 7Y5',
+          locality: 'Calgary',
+          region: 'Alberta',
+        },
+      },
+      typeDefs: ti2BookingTypeDefs,
+      query: ti2BookingQuery,
+    });
+    expect(booking.pickupPoint).toEqual(expect.objectContaining({
+      postal: 'T2E 7Y5',
+      city: 'Calgary',
+      state: 'Alberta',
+    }));
+    expect(booking.publicUrl).toBe('https://api.ventrata.com/octo/pdf?booking=booking-2');
+    expect(booking.privateUrl).toBe('https://api.ventrata.com/octo/pdf?booking=booking-2');
+  });
+});