@planning-inspectorate/dynamic-forms 3.14.0 → 3.15.0

package/src/validator/cross-question-validator.test.js

@@ -14,6 +14,89 @@ function createMockRequest(answers) {
 	};
 }
 
+/**
+ * Creates a mock question object with a simple getDataToSave that returns the body field value.
+ * @param {string} fieldName
+ * @returns {{fieldName: string, bodyFieldNames: string[], getDataToSave: Function}}
+ */
+function createMockQuestion(fieldName) {
+	return {
+		fieldName,
+		bodyFieldNames: [fieldName],
+		getDataToSave: async (req) => ({
+			answers: {
+				[fieldName]: req.body[fieldName]
+			}
+		})
+	};
+}
+
+/**
+ * Creates a mock date question that extracts date from day/month/year fields.
+ * @param {string} fieldName
+ * @returns {{fieldName: string, bodyFieldNames: string[], getDataToSave: Function}}
+ */
+function createMockDateQuestion(fieldName) {
+	return {
+		fieldName,
+		bodyFieldNames: [`${fieldName}_day`, `${fieldName}_month`, `${fieldName}_year`],
+		getDataToSave: async (req) => {
+			const day = req.body[`${fieldName}_day`];
+			const month = req.body[`${fieldName}_month`];
+			const year = req.body[`${fieldName}_year`];
+			if (!day || !month || !year) {
+				throw new Error(`Incomplete date fields for ${fieldName}`);
+			}
+			return {
+				answers: {
+					[fieldName]: new Date(year, month - 1, day)
+				}
+			};
+		}
+	};
+}
+
+/**
+ * Creates a mock date-period question that extracts start/end dates.
+ * @param {string} fieldName
+ * @returns {{fieldName: string, bodyFieldNames: string[], getDataToSave: Function}}
+ */
+function createMockDatePeriodQuestion(fieldName) {
+	return {
+		fieldName,
+		bodyFieldNames: [
+			`${fieldName}_start_day`,
+			`${fieldName}_start_month`,
+			`${fieldName}_start_year`,
+			`${fieldName}_end_day`,
+			`${fieldName}_end_month`,
+			`${fieldName}_end_year`
+		],
+		getDataToSave: async (req) => {
+			const startDay = req.body[`${fieldName}_start_day`];
+			const startMonth = req.body[`${fieldName}_start_month`];
+			const startYear = req.body[`${fieldName}_start_year`];
+			const endDay = req.body[`${fieldName}_end_day`];
+			const endMonth = req.body[`${fieldName}_end_month`];
+			const endYear = req.body[`${fieldName}_end_year`];
+			if (!startDay || !startMonth || !startYear) {
+				throw new Error(`Incomplete start date fields for ${fieldName}`);
+			}
+			if (!endDay || !endMonth || !endYear) {
+				throw new Error(`Incomplete end date fields for ${fieldName}`);
+			}
+			return {
+				answers: {
+					[fieldName]: {
+						start: new Date(startYear, startMonth - 1, startDay),
+						end: new Date(endYear, endMonth - 1, endDay)
+					}
+				}
+			};
+		}
+	};
+}
+
 describe('CrossQuestionValidator', () => {
 	test('should throw an error if dependencyFieldName is missing', () => {
 		assert.throws(() => {
@@ -39,7 +122,7 @@ describe('CrossQuestionValidator', () => {
 			dependencyFieldName: 'other',
 			validationFunction: validationFn
 		});
-		const questionObj = { fieldName: 'field' };
+		const questionObj = createMockQuestion('field');
 		const req = createMockRequest({ field: 'foo', other: 'bar' });
 		const chain = validator.validate(questionObj, req.res.locals.journeyResponse);
 		await chain[0].run(req);
@@ -51,7 +134,7 @@ describe('CrossQuestionValidator', () => {
 			dependencyFieldName: 'other',
 			validationFunction: () => false
 		});
-		const questionObj = { fieldName: 'field' };
+		const questionObj = createMockQuestion('field');
 		const chain = validator.validate(questionObj);
 		const req = createMockRequest({ field: 'foo', other: 'bar' });
 		req.body = { field: 'foo' };
@@ -66,25 +149,28 @@ describe('CrossQuestionValidator', () => {
 			dependencyFieldName: 'other',
 			validationFunction: validationFn
 		});
-		const questionObj = { fieldName: 'field' };
+		const questionObj = createMockQuestion('field');
 		const chain = validator.validate(questionObj);
 		const req = { res: { locals: {} } };
 		await chain[0].run(req);
 		assert.deepEqual(validationFn.mock.calls[0].arguments, [undefined, undefined]);
 	});
 
-	it('should use session answers instead of request body values when useBodyValues is false', async () => {
+	it('should use JourneyResponse answers instead of request body values when useBodyValues is false', async () => {
 		const validationFn = mock.fn(() => true);
 		const validator = new CrossQuestionValidator({
 			dependencyFieldName: 'other',
 			validationFunction: validationFn
 		});
-		const questionObj = { fieldName: 'field' };
-		const req = createMockRequest({ field: 'from-session', other: 'from-session-dependency' });
+		const questionObj = createMockQuestion('field');
+		const req = createMockRequest({ field: 'from-journey-response', other: 'from-journey-response-dependency' });
 		req.body = { field: 'from-body', other: 'from-body-dependency' };
 		const chain = validator.validate(questionObj, req.res.locals.journeyResponse);
 		await chain[0].run(req);
-		assert.deepEqual(validationFn.mock.calls[0].arguments, ['from-session', 'from-session-dependency']);
+		assert.deepEqual(validationFn.mock.calls[0].arguments, [
+			'from-journey-response',
+			'from-journey-response-dependency'
+		]);
 	});
 
 	it('should use request body values when useBodyValues is true', async () => {
@@ -94,9 +180,9 @@ describe('CrossQuestionValidator', () => {
 			useBodyValues: true,
 			validationFunction: validationFn
 		});
-		const questionObj = { fieldName: 'field' };
+		const questionObj = createMockQuestion('field');
 		const chain = validator.validate(questionObj);
-		const req = createMockRequest({ field: 'from-session', other: 'from-session-dependency' });
+		const req = createMockRequest({ field: 'from-journey-response', other: 'from-journey-response-dependency' });
 		req.body = { field: 'from-body', other: 'from-body-dependency' };
 		await chain[0].run(req);
 		assert.deepEqual(validationFn.mock.calls[0].arguments, ['from-body', 'from-body-dependency']);
@@ -109,7 +195,7 @@ describe('CrossQuestionValidator', () => {
 				throw new Error('boom');
 			}
 		});
-		const questionObj = { fieldName: 'field' };
+		const questionObj = createMockQuestion('field');
 		const chain = validator.validate(questionObj);
 		const req = createMockRequest({ field: 'foo', other: 'bar' });
 		const result = await chain[0].run(req);
@@ -123,10 +209,361 @@ describe('CrossQuestionValidator', () => {
 			dependencyFieldName: 'other',
 			validationFunction: validationFn
 		});
-		const questionObj = { fieldName: 'field' };
+		const questionObj = createMockQuestion('field');
 		const chain = validator.validate(questionObj);
 		const req = { res: { locals: { journeyResponse: {} } } };
 		await chain[0].run(req);
 		assert.deepEqual(validationFn.mock.calls[0].arguments, [undefined, undefined]);
 	});
+
+	describe('date question integration', () => {
+		it('should extract date using getDataToSave when useBodyValues is true', async () => {
+			const validationFn = mock.fn(() => true);
+			const validator = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: validationFn,
+				useBodyValues: true
+			});
+			const questionObj = createMockDateQuestion('dateField');
+			const req = createMockRequest({});
+			req.body = {
+				dateField_day: '15',
+				dateField_month: '6',
+				dateField_year: '2026',
+				other: 'dependency-value'
+			};
+			const chain = validator.validate(questionObj);
+			await chain[0].run(req);
+
+			const [currentAnswer, dependencyAnswer] = validationFn.mock.calls[0].arguments;
+			assert.ok(currentAnswer instanceof Date, 'currentAnswer should be a Date');
+			assert.strictEqual(currentAnswer.getFullYear(), 2026);
+			assert.strictEqual(currentAnswer.getMonth() + 1, 6);
+			assert.strictEqual(currentAnswer.getDate(), 15);
+			assert.strictEqual(dependencyAnswer, 'dependency-value');
+		});
+
+		it('should propagate error when getDataToSave throws (e.g. incomplete date fields)', async () => {
+			const validator = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: () => true,
+				useBodyValues: true
+			});
+			const questionObj = createMockDateQuestion('dateField');
+			const req = createMockRequest({});
+			req.body = {
+				dateField_day: '15',
+				dateField_month: '6',
+				// missing year
+				other: 'dependency-value'
+			};
+			const chain = validator.validate(questionObj);
+			const result = await chain[0].run(req);
+			assert.strictEqual(result.isEmpty(), false);
+			assert.match(result.array()[0].msg, /Incomplete date fields/);
+		});
+
+		it('should use JourneyResponse answer directly when useBodyValues is false', async () => {
+			const storedDate = new Date('2026-06-15T00:00:00.000Z');
+			const validationFn = mock.fn(() => true);
+			const validator = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: validationFn
+			});
+			const questionObj = createMockDateQuestion('dateField');
+			const req = createMockRequest({ dateField: storedDate, other: 'dependency-value' });
+			req.body = { dateField_day: '15' };
+			const chain = validator.validate(questionObj, req.res.locals.journeyResponse);
+			await chain[0].run(req);
+
+			const [currentAnswer, dependencyAnswer] = validationFn.mock.calls[0].arguments;
+			assert.strictEqual(currentAnswer, storedDate);
+			assert.strictEqual(dependencyAnswer, 'dependency-value');
+		});
+	});
+
+	describe('date-period question integration', () => {
+		it('should extract date period using getDataToSave when useBodyValues is true', async () => {
+			const validationFn = mock.fn(() => true);
+			const validator = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: validationFn,
+				useBodyValues: true
+			});
+			const questionObj = createMockDatePeriodQuestion('periodField');
+			const req = createMockRequest({});
+			req.body = {
+				periodField_start_day: '1',
+				periodField_start_month: '6',
+				periodField_start_year: '2026',
+				periodField_end_day: '30',
+				periodField_end_month: '6',
+				periodField_end_year: '2026',
+				other: 'dependency-value'
+			};
+			const chain = validator.validate(questionObj);
+			await chain[0].run(req);
+
+			const [currentAnswer, dependencyAnswer] = validationFn.mock.calls[0].arguments;
+			assert.ok(currentAnswer.start instanceof Date, 'start should be a Date');
+			assert.ok(currentAnswer.end instanceof Date, 'end should be a Date');
+			assert.strictEqual(currentAnswer.start.getDate(), 1);
+			assert.strictEqual(currentAnswer.end.getDate(), 30);
+			assert.strictEqual(dependencyAnswer, 'dependency-value');
+		});
+
+		it('should propagate error when getDataToSave throws for incomplete start date', async () => {
+			const validator = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: () => true,
+				useBodyValues: true
+			});
+			const questionObj = createMockDatePeriodQuestion('periodField');
+			const req = createMockRequest({});
+			req.body = {
+				periodField_start_day: '1',
+				// missing start month and year
+				periodField_end_day: '30',
+				periodField_end_month: '6',
+				periodField_end_year: '2026',
+				other: 'dependency-value'
+			};
+			const chain = validator.validate(questionObj);
+			const result = await chain[0].run(req);
+			assert.strictEqual(result.isEmpty(), false);
+			assert.match(result.array()[0].msg, /Incomplete start date fields/);
+		});
+
+		it('should propagate error when getDataToSave throws for incomplete end date', async () => {
+			const validator = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: () => true,
+				useBodyValues: true
+			});
+			const questionObj = createMockDatePeriodQuestion('periodField');
+			const req = createMockRequest({});
+			req.body = {
+				periodField_start_day: '1',
+				periodField_start_month: '6',
+				periodField_start_year: '2026',
+				periodField_end_day: '30',
+				// missing end month and year
+				other: 'dependency-value'
+			};
+			const chain = validator.validate(questionObj);
+			const result = await chain[0].run(req);
+			assert.strictEqual(result.isEmpty(), false);
+			assert.match(result.array()[0].msg, /Incomplete end date fields/);
+		});
+
+		it('should use JourneyResponse answer directly when useBodyValues is false', async () => {
+			const storedPeriod = {
+				start: new Date('2026-06-01T00:00:00.000Z'),
+				end: new Date('2026-06-30T00:00:00.000Z')
+			};
+			const validationFn = mock.fn(() => true);
+			const validator = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: validationFn
+			});
+			const questionObj = createMockDatePeriodQuestion('periodField');
+			const req = createMockRequest({ periodField: storedPeriod, other: 'dependency-value' });
+			req.body = { periodField_start_day: '1' };
+			const chain = validator.validate(questionObj, req.res.locals.journeyResponse);
+			await chain[0].run(req);
+
+			const [currentAnswer, dependencyAnswer] = validationFn.mock.calls[0].arguments;
+			assert.strictEqual(currentAnswer, storedPeriod);
+			assert.strictEqual(dependencyAnswer, 'dependency-value');
+		});
+	});
+
+	describe('useBodyValuesForCurrent', () => {
+		it('should set useBodyValuesForCurrent property correctly', () => {
+			const validator1 = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: () => true,
+				useBodyValuesForCurrent: true
+			});
+			assert.strictEqual(validator1.useBodyValuesForCurrent, true);
+
+			const validator2 = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: () => true,
+				useBodyValues: true
+			});
+			assert.strictEqual(validator2.useBodyValuesForCurrent, true);
+
+			const validator3 = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: () => true
+			});
+			assert.strictEqual(validator3.useBodyValuesForCurrent, false);
+		});
+
+		it('should use body value for current and JourneyResponse value for dependency when useBodyValuesForCurrent is true', async () => {
+			const validationFn = mock.fn(() => true);
+			const validator = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: validationFn,
+				useBodyValuesForCurrent: true
+			});
+			const questionObj = createMockQuestion('field');
+			const req = createMockRequest({ field: 'from-journey-response', other: 'from-journey-response-dependency' });
+			req.body = { field: 'from-body', other: 'from-body-dependency' };
+			const chain = validator.validate(questionObj, req.res.locals.journeyResponse);
+			await chain[0].run(req);
+
+			const [currentAnswer, dependencyAnswer] = validationFn.mock.calls[0].arguments;
+			assert.strictEqual(currentAnswer, 'from-body');
+			assert.strictEqual(dependencyAnswer, 'from-journey-response-dependency');
+		});
+
+		it('should use body values for both current and dependency when useBodyValues is true', async () => {
+			const validationFn = mock.fn(() => true);
+			const validator = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: validationFn,
+				useBodyValues: true
+			});
+			const questionObj = createMockQuestion('field');
+			const req = createMockRequest({ field: 'from-journey-response', other: 'from-journey-response-dependency' });
+			req.body = { field: 'from-body', other: 'from-body-dependency' };
+			const chain = validator.validate(questionObj, req.res.locals.journeyResponse);
+			await chain[0].run(req);
+
+			const [currentAnswer, dependencyAnswer] = validationFn.mock.calls[0].arguments;
+			assert.strictEqual(currentAnswer, 'from-body');
+			assert.strictEqual(dependencyAnswer, 'from-body-dependency');
+		});
+
+		it('should use JourneyResponse value for current when useBodyValuesForCurrent is false', async () => {
+			const validationFn = mock.fn(() => true);
+			const validator = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: validationFn,
+				useBodyValuesForCurrent: false
+			});
+			const questionObj = createMockQuestion('field');
+			const req = createMockRequest({ field: 'from-journey-response', other: 'from-journey-response-dependency' });
+			req.body = { field: 'from-body', other: 'from-body-dependency' };
+			const chain = validator.validate(questionObj, req.res.locals.journeyResponse);
+			await chain[0].run(req);
+
+			const [currentAnswer, dependencyAnswer] = validationFn.mock.calls[0].arguments;
+			assert.strictEqual(currentAnswer, 'from-journey-response');
+			assert.strictEqual(dependencyAnswer, 'from-journey-response-dependency');
+		});
+
+		it('should fallback to req.body[fieldName] when getDataToSave is not available', async () => {
+			const validationFn = mock.fn(() => true);
+			const validator = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: validationFn,
+				useBodyValuesForCurrent: true
+			});
+			// Question without getDataToSave method
+			const questionObj = {
+				fieldName: 'field'
+			};
+			const req = createMockRequest({ field: 'from-journey-response', other: 'from-journey-response-dependency' });
+			req.body = { field: 'from-body', other: 'from-body-dependency' };
+			const chain = validator.validate(questionObj, req.res.locals.journeyResponse);
+			await chain[0].run(req);
+
+			const [currentAnswer, dependencyAnswer] = validationFn.mock.calls[0].arguments;
+			assert.strictEqual(currentAnswer, 'from-body');
+			assert.strictEqual(dependencyAnswer, 'from-journey-response-dependency');
+		});
+
+		it('should return all formatted answers when fieldName is not in formattedAnswers', async () => {
+			const validationFn = mock.fn(() => true);
+			const validator = new CrossQuestionValidator({
+				dependencyFieldName: 'otherField',
+				validationFunction: validationFn,
+				useBodyValues: true
+			});
+			// Mock a behavior where getDataToSave returns answers keyed by input
+			// field names, not the question's fieldName
+			const questionObj = {
+				fieldName: 'contactDetails', // This won't be in formattedAnswers
+				bodyFieldNames: ['email', 'phone'],
+				getDataToSave: async (req) => ({
+					answers: {
+						// Returns individual input fields, not 'contactDetails'
+						email: req.body.email,
+						phone: req.body.phone
+					}
+				})
+			};
+			const req = createMockRequest({});
+			req.body = {
+				contactDetails: 'ignored',
+				email: 'test@example.com',
+				phone: '123456789',
+				otherField: 'dependency-value'
+			};
+			const chain = validator.validate(questionObj);
+			await chain[0].run(req);
+
+			const [currentAnswer, dependencyAnswer] = validationFn.mock.calls[0].arguments;
+			// Should receive all formatted answers since 'contactDetails' is not in formattedAnswers
+			assert.deepStrictEqual(currentAnswer, {
+				email: 'test@example.com',
+				phone: '123456789'
+			});
+			assert.strictEqual(dependencyAnswer, 'dependency-value');
+		});
+	});
+
+	describe('bodyFieldNames getter support', () => {
+		it('should use bodyFieldNames[0] when question provides it', async () => {
+			const validationFn = mock.fn(() => true);
+			const validator = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: validationFn
+			});
+			// Mock question with custom bodyFieldNames getter
+			const questionObj = {
+				fieldName: 'customField',
+				bodyFieldNames: ['customField_first', 'customField_second'],
+				getDataToSave: async (req) => ({
+					answers: {
+						customField: req.body.customField_first + '-' + req.body.customField_second
+					}
+				})
+			};
+			const req = createMockRequest({ customField: 'stored-value', other: 'dep-value' });
+			req.body = {
+				customField_first: 'a',
+				customField_second: 'b',
+				other: 'body-dep'
+			};
+			const chain = validator.validate(questionObj, req.res.locals.journeyResponse);
+			await chain[0].run(req);
+
+			// Should have called validation function with stored answer since useBodyValuesForCurrent is false
+			assert.deepEqual(validationFn.mock.calls[0].arguments, ['stored-value', 'dep-value']);
+		});
+
+		it('should fallback to fieldName when bodyFieldNames is not available', async () => {
+			const validationFn = mock.fn(() => true);
+			const validator = new CrossQuestionValidator({
+				dependencyFieldName: 'other',
+				validationFunction: validationFn
+			});
+			// Question without bodyFieldNames getter
+			const questionObj = {
+				fieldName: 'simpleField'
+			};
+			const req = createMockRequest({ simpleField: 'stored-value', other: 'dep-value' });
+			req.body = {
+				simpleField: 'body-value'
+			};
+			const chain = validator.validate(questionObj, req.res.locals.journeyResponse);
+			await chain[0].run(req);
+
+			assert.deepEqual(validationFn.mock.calls[0].arguments, ['stored-value', 'dep-value']);
+		});
+	});
 });

package/src/validator/date-period-validator.js

@@ -6,10 +6,6 @@ import { enGB } from 'date-fns/locale';
 import BaseValidator from './base-validator.js';
 import { parseDateInput, startOfDay } from '../lib/date-utils.js';
 
-/**
- * @typedef {import('../components/date/question.js')} DateQuestion
- */
-
 /**
  * @typedef {Object} DateValidationSettings
  * @property {Boolean} ensureFuture
@@ -64,7 +60,7 @@ export class DatePeriodValidator extends BaseValidator {
 
 	/**
 	 * validates the response body, checking the values sent for the date are valid
-	 * @param {DateQuestion} questionObj
+	 * @param {import('../components/date/question.js').DateQuestion} questionObj
 	 */
 	validate(questionObj) {
 		const fieldName = questionObj.fieldName;

package/src/validator/date-time-validator.js

@@ -1,10 +1,6 @@
 import { body } from 'express-validator';
 import DateValidator from './date-validator.js';
 
-/**
- * @typedef {import('./question.js')} DateTimeQuestion
- */
-
 /**
  * enforces a user has entered a valid date
  * @class
@@ -32,7 +28,7 @@ export class DateTimeValidator extends DateValidator {
 
 	/**
 	 * validates the response body, checking the values sent for the date are valid
-	 * @param {DateTimeQuestion} questionObj
+	 * @param {import('../components/date-time/question.js').DateTimeQuestion} questionObj
 	 */
 	validate(questionObj) {
 		const fieldName = questionObj.fieldName;

package/src/validator/date-validator.js

@@ -5,10 +5,6 @@ import { enGB } from 'date-fns/locale';
 import BaseValidator from './base-validator.js';
 import { endOfDay, parseDateInput, startOfDay } from '../lib/date-utils.js';
 
-/**
- * @typedef {import('../components/date/question.js')} DateQuestion
- */
-
 /**
  * @typedef {Object} DateValidationSettings
  * @property {Boolean} [ensureFuture]
@@ -69,7 +65,7 @@ export class DateValidator extends BaseValidator {
 
 	/**
 	 * validates the response body, checking the values sent for the date are valid
-	 * @param {DateQuestion} questionObj
+	 * @param {import('../components/date/question.js').DateQuestion} questionObj
 	 */
 	validate(questionObj) {
 		const fieldName = questionObj.fieldName;

package/src/validator/required-validator.js

@@ -2,10 +2,6 @@ import { body } from 'express-validator';
 
 import BaseValidator from './base-validator.js';
 
-/**
- * @typedef {import('../questions/question.js')} Question
- */
-
 /**
  * enforces a field is not empty
  * @class
@@ -30,7 +26,7 @@ export class RequiredValidator extends BaseValidator {
 
 	/**
 	 * validates the response body, checking the questionObj's fieldname
-	 * @param {Question} questionObj
+	 * @param {import('../questions/question.js').Question} questionObj
 	 */
 	validate(questionObj) {
 		return body(questionObj.fieldName).notEmpty().withMessage(this.errorMessage);

package/src/validator/unit-option-entry-validator.js

@@ -3,10 +3,6 @@ import { body } from 'express-validator';
 import BaseValidator from './base-validator.js';
 import { toArray } from '#src/lib/utils.js';
 
-/**
- * @typedef {import('../questions/question.js')} Question
- */
-
 /**
  * enforces a field is not empty when condition is satisfied
  * @class
@@ -34,7 +30,7 @@ export class UnitOptionEntryValidator extends BaseValidator {
 
 	/**
 	 * validates the response body, checking the questionObj's fieldname
-	 * @param {Question} questionObj
+	 * @param {import('../components/unit-option-entry/question.js').UnitOptionEntryQuestion} questionObj
 	 */
 	validate(questionObj) {
 		return questionObj.options.reduce((schema, option) => {

package/types/src/components/address/question.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"question.d.ts","sourceRoot":"","sources":["../../../../src/components/address/question.js"],"names":[],"mappings":"AAOA;IACC;;OAEG;IACH,oBAFW,OAAO,iBAAiB,EAAE,kBAAkB,EAqBtD;IAXE;;;;;;kBAA8C;IAIhD;;;;;;MAMC;IAGF;;;OAGG;IACH,4BAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,GAAC,GAAC,MAAM,CAqBpB;IAqCD;;;OAGG;IACH;;eAUC;IAuBD,kEAMC;CACD;;yBAxIwB,WAAW"}
+{"version":3,"file":"question.d.ts","sourceRoot":"","sources":["../../../../src/components/address/question.js"],"names":[],"mappings":"AAOA;IACC;;OAEG;IACH,oBAFW,OAAO,iBAAiB,EAAE,kBAAkB,EAqBtD;IAXE;;;;;;kBAA8C;IAIhD;;;;;;MAMC;IAiBF;;;OAGG;IACH,4BAHW,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACjB,GAAC,GAAC,MAAM,CAqBpB;IAqCD;;;OAGG;IACH;;eAUC;IAuBD,kEAMC;CACD;;yBAtJwB,WAAW"}

package/types/src/components/date/question.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"question.d.ts","sourceRoot":"","sources":["../../../../src/components/date/question.js"],"names":[],"mappings":"AAKA;;GAEG;AACH;IACC;;;OAGG;IACH,uCAHW,OAAO,iBAAiB,EAAE,kBAAkB,EAStD;IADA,gBAA4B;IAG7B;;;;;OAKG,CACH,mBAJW,OAAO,SAAS,EAAE,OAAO,mBACzB,OAAO,mBAAmB,EAAE,eAAe,GACzC,OAAO,CAAE,MAAM,CAAC,CAY5B;IAED;;MAwBC;CAoBD;;yBAlFwB,6BAA6B"}
+{"version":3,"file":"question.d.ts","sourceRoot":"","sources":["../../../../src/components/date/question.js"],"names":[],"mappings":"AAKA;;GAEG;AACH;IACC;;;OAGG;IACH,uCAHW,OAAO,iBAAiB,EAAE,kBAAkB,EAStD;IADA,gBAA4B;IAW7B;;;;;OAKG,CACH,mBAJW,OAAO,SAAS,EAAE,OAAO,mBACzB,OAAO,mBAAmB,EAAE,eAAe,GACzC,OAAO,CAAE,MAAM,CAAC,CAY5B;IAED;;MAwBC;CAoBD;;yBA1FwB,6BAA6B"}

package/types/src/components/date-period/question.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"question.d.ts","sourceRoot":"","sources":["../../../../src/components/date-period/question.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH;IACC;;;;;;;;;OASG;IACH,6FATW,OAAO,iBAAiB,EAAE,kBAAkB,EAqBtD;IAPA,gBAA4B;IAC5B,YAAsD;IAEtD,eAA0B;IAC1B,aAAsB;IACtB,eAA+D;IAC/D,aAA2D;IAG5D;;;;;OAKG,CACH,mBAJW,OAAO,SAAS,EAAE,OAAO,mBACzB,OAAO,mBAAmB,EAAE,eAAe,GACzC,OAAO,CAAE,MAAM,CAAC,CAgC5B;IAED;;MAuCC;CAyCD;;yBAzJwB,WAAW"}
+{"version":3,"file":"question.d.ts","sourceRoot":"","sources":["../../../../src/components/date-period/question.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH;IACC;;;;;;;;;OASG;IACH,6FATW,OAAO,iBAAiB,EAAE,kBAAkB,EAqBtD;IAPA,gBAA4B;IAC5B,YAAsD;IAEtD,eAA0B;IAC1B,aAAsB;IACtB,eAA+D;IAC/D,aAA2D;IAkB5D;;;;;OAKG,CACH,mBAJW,OAAO,SAAS,EAAE,OAAO,mBACzB,OAAO,mBAAmB,EAAE,eAAe,GACzC,OAAO,CAAE,MAAM,CAAC,CAgC5B;IAED;;MAuCC;CAyCD;;yBAxKwB,WAAW"}

package/types/src/components/date-time/question.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"question.d.ts","sourceRoot":"","sources":["../../../../src/components/date-time/question.js"],"names":[],"mappings":"AAMA;IACC,kBAAiB;IACjB,kBAAiB;IAEjB;;;;OAIG;IACH,mDAJW,OAAO,iBAAiB,EAAE,kBAAkB,EAWtD;IAFA,gBAA4B;IAC5B,gBAA4B;IAG7B;;;;;OAKG,CACH,mBAJW,OAAO,SAAS,EAAE,OAAO,mBACzB,eAAe,GACb,OAAO,CAAE,MAAM,CAAC,CAqB5B;IAED;;MAqCC;;CAoCD;;yBA5HwB,6BAA6B"}
+{"version":3,"file":"question.d.ts","sourceRoot":"","sources":["../../../../src/components/date-time/question.js"],"names":[],"mappings":"AAMA;IACC,kBAAiB;IACjB,kBAAiB;IAEjB;;;;OAIG;IACH,mDAJW,OAAO,iBAAiB,EAAE,kBAAkB,EAWtD;IAFA,gBAA4B;IAC5B,gBAA4B;IAkB7B;;;;;OAKG,CACH,mBAJW,OAAO,SAAS,EAAE,OAAO,mBACzB,eAAe,GACb,OAAO,CAAE,MAAM,CAAC,CAqB5B;IAED;;MAqCC;;CAoCD;;yBA3IwB,6BAA6B"}

package/types/src/components/multi-field-input/question.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"question.d.ts","sourceRoot":"","sources":["../../../../src/components/multi-field-input/question.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AAEH;;GAEG;AACH;IACC;;OAEG;IACH,wCAFW,OAAO,oCAAoC,EAAE,4BAA4B,EAanF;IAJC,uEAA8B;IAMhC;;;;;;;;;;;QAOC;IAsBD;;;;;;;;;;;;;OAaG;IACH,wDAZW,OAAO,GAEL,KAAK,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QACvB,MAAM,EAAE;YACN,IAAI,EAAE,MAAM,CAAC;YACb,IAAI,EAAE,MAAM,CAAC;YACb,kBAAkB,EAAE,MAAM,CAAC;SAC5B,CAAC;KACH,CAAC,CAkBJ;;CAyBD;;gCA/GY,OAAO,WAAW,EAAE,iBAAiB;sBACrC,OAAO,UAAU,EAAE,OAAO;8BAC1B,OAAO,mBAAmB,EAAE,eAAe;;;yBAP/B,WAAW"}
+{"version":3,"file":"question.d.ts","sourceRoot":"","sources":["../../../../src/components/multi-field-input/question.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AAEH;;GAEG;AACH;IACC;;OAEG;IACH,wCAFW,OAAO,oCAAoC,EAAE,4BAA4B,EAanF;IAJC,uEAA8B;IAchC;;;;;;;;;;;QAOC;IAsBD;;;;;;;;;;;;;OAaG;IACH,wDAZW,OAAO,GAEL,KAAK,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;QACvB,MAAM,EAAE;YACN,IAAI,EAAE,MAAM,CAAC;YACb,IAAI,EAAE,MAAM,CAAC;YACb,kBAAkB,EAAE,MAAM,CAAC;SAC5B,CAAC;KACH,CAAC,CAkBJ;;CAyBD;;gCAvHY,OAAO,WAAW,EAAE,iBAAiB;sBACrC,OAAO,UAAU,EAAE,OAAO;8BAC1B,OAAO,mBAAmB,EAAE,eAAe;;;yBAP/B,WAAW"}

package/types/src/questions/question.d.ts

@@ -111,6 +111,14 @@ export class Question {
      * @returns {boolean}
      */
     get isInManageListSection(): boolean;
+    /**
+     * Gets the body field names used by this question in form submissions.
+     * Returns the field names that should be present in req.body when this question is submitted.
+     * Subclasses should override this for questions with multiple or differently-named body fields.
+     *
+     * @returns {string[]}
+     */
+    get bodyFieldNames(): string[];
     /**
      * gets the view model for this question
      *