@planning-inspectorate/data-model 1.11.0

package/tests/appeals/appeal-event.test.js

@@ -0,0 +1,62 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { loadAllSchemasSync } from '../../src/index.js';
+
+const schema = 'appeal-event.schema.json';
+
+const event = {
+	eventId: 'ipsum ut proident Ut',
+	caseReference: 'irure dolore in exercitation elit',
+	eventType: 'site_visit_accompanied',
+	eventName: 'minim anim',
+	eventStatus: 'confirmed',
+	isUrgent: true,
+	eventPublished: false,
+	eventStartDateTime: '1913-04-07T20:47:33.0Z',
+	eventEndDateTime: '1961-01-01T16:05:12.0Z',
+	notificationOfSiteVisit: '1957-10-24T08:38:08.0Z',
+	addressLine1: 'test line 1',
+	addressLine2: 'test line 2',
+	addressTown: 'test town',
+	addressCounty: 'test county',
+	addressPostcode: 'test postcode'
+};
+
+describe(schema, () => {
+	const schemas = loadAllSchemasSync();
+	const flatSchemas = Object.values(schemas).reduce((a, c) => ({ ...a, ...c }), {});
+	const ajv = new Ajv({ schemas: flatSchemas, allErrors: true });
+	addFormats(ajv);
+
+	it('should allow valid event schema', () => {
+		const test = structuredClone(event);
+
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, true);
+	});
+
+	it('should allow valid event schema with null values', () => {
+		const test = structuredClone(event);
+		test.eventName = null;
+		test.eventPublished = null;
+		test.eventEndDateTime = null;
+		test.notificationOfSiteVisit = null;
+		test.addressLine1 = null;
+		test.addressLine2 = null;
+		test.addressTown = null;
+		test.addressCounty = null;
+		test.addressPostcode = null;
+
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, true);
+	});
+
+	it('should allow additional props', () => {
+		const test = structuredClone(event);
+		test.test = 1; // additional unknown prop allowed
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, true);
+	});
+});

package/tests/appeals/commands/appeal-representation-submission.test.js

@@ -0,0 +1,107 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { loadAllSchemasSync } from '../../../src/index.js';
+
+const schema = 'commands/appeal-representation-submission.schema.json';
+
+const document = {
+	documentId: 'Lorem',
+	filename: 'sunt',
+	originalFilename: 'dolore fugiat',
+	size: 663667,
+	mime: 'consequat veniam ipsum ullamco sint',
+	documentURI: 'reprehenderit',
+	dateCreated: '1904-04-10T14:53:32.0Z',
+	documentType: 'lpaStatement'
+};
+
+const newUser = {
+	salutation: null,
+	firstName: null,
+	lastName: null,
+	emailAddress: null,
+	telephoneNumber: null,
+	organisation: null,
+	serviceUserType: 'InterestedParty'
+};
+
+const representation = {
+	caseReference: '123',
+	representationSubmittedDate: '1990-12-28T22:49:47.0Z',
+	representation: 'This is a text based representation',
+	representationType: 'comment'
+};
+
+describe('appeal-representation-submission.schema', () => {
+	const schemas = loadAllSchemasSync();
+	const flatSchemas = Object.values(schemas).reduce((a, c) => ({ ...a, ...c }), {});
+	const ajv = new Ajv({ schemas: flatSchemas, allErrors: true });
+	addFormats(ajv);
+
+	it('should allow valid representation schema with new user', () => {
+		const test = structuredClone(representation);
+		test.documents = [document];
+		test.newUser = newUser;
+
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, true);
+	});
+
+	it('should allow valid representation schema with serviceUserId', () => {
+		const test = structuredClone(representation);
+		test.documents = [document];
+		test.serviceUserId = 'a';
+
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, true);
+	});
+
+	it('should allow valid representation schema with lpa', () => {
+		const test = structuredClone(representation);
+		test.documents = [document];
+		test.lpaCode = 'a';
+
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, true);
+	});
+
+	it('should reject missing user from one of', () => {
+		const test = structuredClone(representation);
+		test.documents = [document];
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, false);
+		assert.strictEqual(
+			ajv.errors.some((x) => x.message === 'must match exactly one schema in oneOf'),
+			true
+		);
+	});
+
+	it('should reject missing root property', () => {
+		const test = structuredClone(representation);
+		test.documents = [document];
+		test.newUser = newUser;
+		delete test.representation;
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, false);
+		assert.strictEqual(
+			ajv.errors.some((x) => x.message === "must have required property 'representation'"),
+			true
+		);
+	});
+
+	it('should allow additional props', () => {
+		const test = structuredClone(representation);
+		test.test = 1; // additional unknown prop allowed
+
+		test.documents = [document];
+		test.documents[0].test = 1; // additional unknown prop allowed
+
+		test.newUser = newUser;
+		test.newUser.test = 1; // additional unknown prop allowed
+
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, true);
+	});
+});

package/tests/appeals/commands/has-questionnaire.test.js

@@ -0,0 +1,92 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { loadAllSchemasSync } from '../../../src/index.js';
+
+const schema = 'lpa-questionnaire.schema.json';
+
+const document = {
+	documentId: 'deserunt sint aliqua adipisicing dolore',
+	filename: 'ut dolore',
+	originalFilename: 'Lorem amet fugiat adipisicing Excepteur',
+	size: -90476934,
+	mime: 'magna labore exercitation ut',
+	documentURI: 'ut reprehenderit',
+	dateCreated: '1933-04-03T03:24:38.0Z',
+	documentType: 'plansDrawings'
+};
+
+const exampleHasQuestionnaireSchema = {
+	casedata: {
+		caseType: 'D',
+		caseReference: 'nisi incididunt cillum',
+		lpaQuestionnaireSubmittedDate: null,
+		lpaStatement: 'consequat ex',
+		siteAccessDetails: null,
+		siteSafetyDetails: null,
+		isCorrectAppealType: null,
+		isGreenBelt: null,
+		inConservationArea: null,
+		newConditionDetails: 'anim sint ut aute',
+		notificationMethod: null,
+		nearbyCaseReferences: null,
+		neighbouringSiteAddresses: [
+			{
+				neighbouringSiteAddressLine1: 'commodo dolore incididunt',
+				neighbouringSiteAddressLine2: 'est voluptate irure aliqua elit',
+				neighbouringSiteAddressTown: 'labore aliquip ex incididunt nulla',
+				neighbouringSiteAddressCounty: 'enim ut Duis ut ex',
+				neighbouringSiteAddressPostcode: 'pariatur',
+				neighbouringSiteAccessDetails: 'aliqua irure mollit consequat nisi',
+				neighbouringSiteSafetyDetails: null
+			}
+		],
+		affectedListedBuildingNumbers: [
+			'occaecat id aliquip dolore',
+			'magna',
+			'minim laboris fugiat id aliqua',
+			'ullamco quis',
+			'voluptate quis'
+		],
+		lpaCostsAppliedFor: null
+	},
+	documents: [document]
+};
+
+describe('HAS questionnaire command schema', () => {
+	const schemas = loadAllSchemasSync();
+	const flatSchemas = Object.values(schemas).reduce((a, c) => ({ ...a, ...c }), {});
+	const ajv = new Ajv({ schemas: flatSchemas, allErrors: true });
+	addFormats(ajv);
+
+	it('should allow valid HAS schema', () => {
+		const validationResult = ajv.validate(schema, exampleHasQuestionnaireSchema);
+		assert.strictEqual(validationResult, true);
+	});
+
+	it('should allow HAS case without caseType', () => {
+		const test = structuredClone(exampleHasQuestionnaireSchema);
+		delete test.casedata.caseType;
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, true);
+	});
+
+	it('should reject missing caseReference', () => {
+		const test = structuredClone(exampleHasQuestionnaireSchema);
+		delete test.casedata.caseReference;
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, false);
+		assert.strictEqual(
+			ajv.errors.some((x) => x.message === "must have required property 'caseReference'"),
+			true
+		);
+	});
+
+	it('should allow additional props', () => {
+		const test = structuredClone(exampleHasQuestionnaireSchema);
+		test.test = 1;
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, true);
+	});
+});

package/tests/appeals/commands/has-submission.test.js

@@ -0,0 +1,113 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { loadAllSchemasSync } from '../../../src/index.js';
+
+const schema = 'appellant-submission.schema.json';
+
+const user = {
+	salutation: 'nisi aute tempor Ut',
+	firstName: null,
+	lastName: null,
+	emailAddress: null,
+	telephoneNumber: 'irure',
+	organisation: null,
+	serviceUserType: 'Appellant'
+};
+
+const document = {
+	documentId: 'Lorem',
+	filename: 'sunt',
+	originalFilename: 'dolore fugiat',
+	size: 663667,
+	mime: 'consequat veniam ipsum ullamco sint',
+	documentURI: 'reprehenderit',
+	dateCreated: '1904-04-10T14:53:32.0Z',
+	documentType: 'appellantCaseWithdrawalLetter'
+};
+
+const exampleHasSubmissionSchema = {
+	casedata: {
+		submissionId: '072a9b08-0266-a291-ecd0-bb0ded9d7350',
+		caseType: 'D',
+		caseProcedure: 'written',
+		lpaCode: 'in laborum pariatur cupidatat',
+		caseSubmittedDate: '1920-12-06T17:37:12.0Z',
+		enforcementNotice: false,
+		applicationReference: 'voluptate esse Excepteur veniam sunt',
+		applicationDate: '1921-01-26T02:05:56.0Z',
+		applicationDecision: 'not_received',
+		applicationDecisionDate: '1890-12-26T17:09:36.0Z',
+		caseSubmissionDueDate: null,
+		siteAddressLine1: 'exercitation incididunt laborum',
+		siteAddressLine2: 'in Ut voluptate ea',
+		siteAddressTown: 'Lorem amet consectetur',
+		siteAddressCounty: null,
+		siteAddressPostcode: 'sunt nulla aliquip labore',
+		siteAccessDetails: null,
+		siteSafetyDetails: ['Duis laboris ex', 'sint Lorem cupidatat commodo'],
+		isGreenBelt: null,
+		siteAreaSquareMetres: -11383801.18983768,
+		floorSpaceSquareMetres: -69227017.16474937,
+		ownsAllLand: null,
+		ownsSomeLand: null,
+		knowsOtherOwners: null,
+		knowsAllOwners: null,
+		advertisedAppeal: true,
+		ownersInformed: null,
+		originalDevelopmentDescription: null,
+		changedDevelopmentDescription: false,
+		nearbyCaseReferences: [
+			'enim consectetur irure ad',
+			'irure ut',
+			'irure eiusmod minim Excepteur id',
+			'aliqua pariatur consectetur eiusmod'
+		],
+		neighbouringSiteAddresses: null,
+		appellantCostsAppliedFor: true
+	},
+	documents: [document],
+	users: [user]
+};
+
+describe('HAS submission command schema', () => {
+	const schemas = loadAllSchemasSync();
+	const flatSchemas = Object.values(schemas).reduce((a, c) => ({ ...a, ...c }), {});
+	const ajv = new Ajv({ schemas: flatSchemas, allErrors: true });
+	addFormats(ajv);
+
+	it('should allow valid HAS schema', () => {
+		const validationResult = ajv.validate(schema, exampleHasSubmissionSchema);
+		assert.strictEqual(validationResult, true);
+	});
+
+	it('should reject missing root property', () => {
+		const test = structuredClone(exampleHasSubmissionSchema);
+		delete test.casedata.caseType;
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, false);
+		assert.strictEqual(
+			ajv.errors.some((x) => x.message === "must have required property 'caseType'"),
+			true
+		);
+	});
+
+	it('should reject missing nested property', () => {
+		const test = structuredClone(exampleHasSubmissionSchema);
+		delete test.casedata.caseProcedure;
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, false);
+		assert.strictEqual(
+			ajv.errors.some((x) => x.message === "must have required property 'caseProcedure'"),
+			true
+		);
+	});
+
+	it('should allow additional props', () => {
+		const test = structuredClone(exampleHasSubmissionSchema);
+		test.test = 1;
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, true);
+	});
+});

package/tests/appeals/commands/s78-questionnaire.test.js

@@ -0,0 +1,96 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { loadAllSchemasSync } from '../../../src/index.js';
+
+const schema = 'lpa-questionnaire.schema.json';
+
+const document = {
+	documentId: 'deserunt sint aliqua adipisicing dolore',
+	filename: 'ut dolore',
+	originalFilename: 'Lorem amet fugiat adipisicing Excepteur',
+	size: -90476934,
+	mime: 'magna labore exercitation ut',
+	documentURI: 'ut reprehenderit',
+	dateCreated: '1933-04-03T03:24:38.0Z',
+	documentType: 'plansDrawings'
+};
+
+const exampleS78QuestionnaireSchema = {
+	casedata: {
+		caseType: 'W',
+		caseReference: 'est ea elit in nulla',
+		lpaQuestionnaireSubmittedDate: null,
+		siteAccessDetails: ['velit adipisicing fugiat dolor ullamco'],
+		siteSafetyDetails: ['ut', 'dolore ut sint Duis', 'magna consequat quis laboris officia'],
+		nearbyCaseReferences: ['nulla', 'incididunt eu nostrud eiusmod', 'exercitation', 'Ut nostrud', 'eiusmod cillum eu'],
+		neighbouringSiteAddresses: null,
+		isCorrectAppealType: true,
+		affectedListedBuildingNumbers: null,
+		isGreenBelt: null,
+		inConservationArea: null,
+		newConditionDetails: null,
+		notificationMethod: ['irure', 'cillum tempor incididunt labore in'],
+		lpaCostsAppliedFor: true,
+		lpaStatement: 'ex laborum cupidatat',
+		changedListedBuildingNumbers: null,
+		affectsScheduledMonument: true,
+		hasProtectedSpecies: false,
+		isAonbNationalLandscape: true,
+		designatedSitesNames: ['quis nulla eu officia exercitation'],
+		hasTreePreservationOrder: null,
+		isGypsyOrTravellerSite: true,
+		isPublicRightOfWay: null,
+		eiaEnvironmentalImpactSchedule: 'schedule-2',
+		eiaDevelopmentDescription: 'production-processing-of-metals',
+		eiaSensitiveAreaDetails: null,
+		eiaColumnTwoThreshold: false,
+		eiaScreeningOpinion: false,
+		eiaRequiresEnvironmentalStatement: null,
+		eiaCompletedEnvironmentalStatement: true,
+		hasStatutoryConsultees: true,
+		consultedBodiesDetails: 'in in labore irure nostrud',
+		hasConsultationResponses: null,
+		hasEmergingPlan: null,
+		hasSupplementaryPlanningDocs: null,
+		hasInfrastructureLevy: true,
+		isInfrastructureLevyFormallyAdopted: false,
+		infrastructureLevyAdoptedDate: '1913-06-14T10:40:33.0Z',
+		infrastructureLevyExpectedDate: '1912-06-14T10:40:33.0Z',
+		lpaProcedurePreference: null,
+		lpaProcedurePreferenceDetails: 'in reprehenderit',
+		lpaProcedurePreferenceDuration: -34480053.16630782
+	},
+	documents: [document]
+};
+
+describe('S78 questionnaire command schema', () => {
+	const schemas = loadAllSchemasSync();
+	const flatSchemas = Object.values(schemas).reduce((a, c) => ({ ...a, ...c }), {});
+	const ajv = new Ajv({ schemas: flatSchemas, allErrors: true });
+	addFormats(ajv);
+
+	it('should allow valid HAS schema', () => {
+		const validationResult = ajv.validate(schema, exampleS78QuestionnaireSchema);
+		assert.strictEqual(validationResult, true);
+	});
+
+	it('should reject missing caseReference', () => {
+		const test = structuredClone(exampleS78QuestionnaireSchema);
+		delete test.casedata.caseReference;
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, false);
+		assert.strictEqual(
+			ajv.errors.some((x) => x.message === "must have required property 'caseReference'"),
+			true
+		);
+	});
+
+	it('should allow additional props', () => {
+		const test = structuredClone(exampleS78QuestionnaireSchema);
+		test.test = 1;
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, true);
+	});
+});

package/tests/appeals/commands/s78-submission.test.js

@@ -0,0 +1,119 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { loadAllSchemasSync } from '../../../src/index.js';
+
+const schema = 'appellant-submission.schema.json';
+
+const user = {
+	salutation: 'nisi aute tempor Ut',
+	firstName: null,
+	lastName: null,
+	emailAddress: null,
+	telephoneNumber: 'irure',
+	organisation: null,
+	serviceUserType: 'Appellant'
+};
+
+const document = {
+	documentId: 'Lorem',
+	filename: 'sunt',
+	originalFilename: 'dolore fugiat',
+	size: 663667,
+	mime: 'consequat veniam ipsum ullamco sint',
+	documentURI: 'reprehenderit',
+	dateCreated: '1904-04-10T14:53:32.0Z',
+	documentType: 'appellantCaseWithdrawalLetter'
+};
+
+const exampleS78SubmissionSchema = {
+	casedata: {
+		caseType: 'W',
+		submissionId: '4b78fc58-fcb0-70d6-5dea-b9b774f802d6',
+		caseProcedure: 'written',
+		lpaCode: 'cupidatat',
+		caseSubmittedDate: '1890-12-28T22:49:47.0Z',
+		enforcementNotice: null,
+		applicationReference: 'consectetur enim et',
+		applicationDate: '1920-04-07T20:23:53.0Z',
+		applicationDecision: 'granted',
+		applicationDecisionDate: null,
+		caseSubmissionDueDate: null,
+		siteAddressLine1: 'occaecat aliquip non pariatur consequat',
+		siteAddressLine2: null,
+		siteAddressTown: 'et',
+		siteAddressCounty: 'velit',
+		siteAddressPostcode: 'nisi minim laboris sed',
+		siteAccessDetails: ['laborum', 'aute velit quis', 'dolor'],
+		siteSafetyDetails: ['velit aliqua', 'qui', 'tempor Duis ut dolore', 'anim Ut in ea', 'eiusmod laborum'],
+		neighbouringSiteAddresses: null,
+		nearbyCaseReferences: ['incididunt'],
+		isGreenBelt: false,
+		siteAreaSquareMetres: null,
+		floorSpaceSquareMetres: -6341893.2219680995,
+		ownsAllLand: null,
+		ownsSomeLand: true,
+		knowsOtherOwners: 'Some',
+		knowsAllOwners: 'Some',
+		advertisedAppeal: null,
+		ownersInformed: null,
+		originalDevelopmentDescription: 'in amet',
+		changedDevelopmentDescription: true,
+		appellantCostsAppliedFor: false,
+		agriculturalHolding: true,
+		tenantAgriculturalHolding: true,
+		otherTenantsAgriculturalHolding: null,
+		informedTenantsAgriculturalHolding: null,
+		appellantProcedurePreference: null,
+		appellantProcedurePreferenceDetails: 'eiusmod ex exercitation',
+		appellantProcedurePreferenceDuration: 10816414.941069126,
+		appellantProcedurePreferenceWitnessCount: -91300569.36444478,
+		planningObligation: false,
+		statusPlanningObligation: 'proident aute',
+		developmentType: 'change-of-use'
+	},
+	documents: [document],
+	users: [user]
+};
+
+describe('S78 submission command schema', () => {
+	const schemas = loadAllSchemasSync();
+	const flatSchemas = Object.values(schemas).reduce((a, c) => ({ ...a, ...c }), {});
+	const ajv = new Ajv({ schemas: flatSchemas, allErrors: true });
+	addFormats(ajv);
+
+	it('should allow valid S78 schema', () => {
+		const validationResult = ajv.validate(schema, exampleS78SubmissionSchema);
+		assert.strictEqual(validationResult, true);
+	});
+
+	it('should reject missing root property', () => {
+		const test = structuredClone(exampleS78SubmissionSchema);
+		delete test.casedata.caseType;
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, false);
+		assert.strictEqual(
+			ajv.errors.some((x) => x.message === "must have required property 'caseType'"),
+			true
+		);
+	});
+
+	it('should reject missing nested property', () => {
+		const test = structuredClone(exampleS78SubmissionSchema);
+		delete test.casedata.caseProcedure;
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, false);
+		assert.strictEqual(
+			ajv.errors.some((x) => x.message === "must have required property 'caseProcedure'"),
+			true
+		);
+	});
+
+	it('should allow additional props', () => {
+		const test = structuredClone(exampleS78SubmissionSchema);
+		test.test = 1;
+		const validationResult = ajv.validate(schema, test);
+		assert.strictEqual(validationResult, true);
+	});
+});

package/tests/schemas.test.js

@@ -0,0 +1,97 @@
+import { describe, it } from 'node:test';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { loadAllSchemasSync } from '../src/index.js';
+
+describe('schemas', () => {
+	it('should only include valid JSON schemas', () => {
+		// validate that all schemas are valid JSON schema documents
+		// by default AJV uses draft-07 which is the same as the schemas
+		// https://ajv.js.org/json-schema.html#json-schema-versions
+
+		const ajv = new Ajv({ allErrors: true, strict: true });
+		addFormats(ajv);
+
+		const allSchemas = loadAllSchemasSync();
+		const schemas = Object.values(allSchemas).reduce((a, c) => ({ ...a, ...c }), {});
+		const errorsBySchema = {};
+		for (const schema of Object.values(schemas)) {
+			ajv.validateSchema(schema);
+			if (ajv.errors) {
+				errorsBySchema[schema.$id] = ajv.errors.map((e) => {
+					let error = `${e.instancePath} ${e.message}`;
+					if (e.params) {
+						error += ` ${JSON.stringify(e.params)}`;
+					}
+					return error;
+				});
+			}
+		}
+		if (Object.keys(errorsBySchema).length) {
+			console.log('*'.repeat(50));
+			console.log('ERRORS:');
+			for (const [schema, errors] of Object.entries(errorsBySchema)) {
+				console.log(schema);
+				for (const error of errors) {
+					console.log('  ', error);
+				}
+			}
+			throw new Error(
+				`${Object.keys(errorsBySchema).join(', ')} schemas are invalid (count: ${Object.keys(errorsBySchema).length}), see console output`
+			);
+		}
+	});
+	it('should have matching $id and filenames', () => {
+		const allSchemas = loadAllSchemasSync();
+		const errorsBySchema = {};
+		for (let [name, schema] of Object.entries(allSchemas.schemas)) {
+			if (name.includes('/')) {
+				name = name.split('/').pop();
+			}
+			if (name !== schema.$id) {
+				errorsBySchema[schema.$id] = name;
+			}
+		}
+		for (let [name, schema] of Object.entries(allSchemas.commands)) {
+			// ID includes the commands/ prefix
+			if ('commands/' + name !== schema.$id) {
+				errorsBySchema[schema.$id] = name;
+			}
+		}
+		if (Object.keys(errorsBySchema).length) {
+			console.log('*'.repeat(50));
+			console.log('ERRORS:');
+			for (const [schema, filename] of Object.entries(errorsBySchema)) {
+				console.log(schema, filename);
+			}
+			throw new Error(
+				`${Object.keys(errorsBySchema).join(', ')} schemas have mismatched $id and filenames (count: ${Object.keys(errorsBySchema).length}), see console output`
+			);
+		}
+	});
+	it('should use the singular form for $id', () => {
+		// very crude test to ensure schemas don't end in 's'...
+		const suffixExceptions = [
+			'has', // allow has suffix for appeals
+			'listed-buildings' // allow this temporary schema, to remove when this schema copy is removed
+		];
+
+		const allSchemas = loadAllSchemasSync();
+		const schemas = Object.values(allSchemas).reduce((a, c) => ({ ...a, ...c }), {});
+		const errors = [];
+		for (const schema of Object.values(schemas)) {
+			const name = schema.$id.replace('.schema.json', '');
+			if (name.endsWith('s') && !suffixExceptions.some((suffix) => name.endsWith(suffix))) {
+				errors.push(schema.$id);
+			}
+		}
+		if (errors.length > 0) {
+			console.log('*'.repeat(50));
+			console.log('ERRORS:');
+			for (const error of errors) {
+				console.log('  ' + error);
+			}
+			throw new Error(`${errors.join(', ')} schemas use plural names, see console output`);
+		}
+	});
+});