@planning-inspectorate/data-model 1.11.0

package/src/gen-enums.js

@@ -0,0 +1,119 @@
+import fs from 'fs/promises';
+import path from 'path';
+import url from 'url';
+import { loadAllSchemas } from './index.js';
+import snakeCase from 'lodash.snakecase';
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+
+export const constPath = path.join(__dirname, 'enums.js');
+export const constTsPath = path.join(__dirname, 'enums.d.ts');
+
+const SPACING = '  ';
+const NEW_LINE = '\r\n';
+
+/**
+ * Load all schemas and generate JS constant definitions
+ */
+async function run() {
+	const s = await loadAllSchemas();
+
+	/** @type {Object<string, string[]>} */
+	const enumProps = {};
+
+	for (const schemaName of Object.keys(s.schemas).sort()) {
+		const schema = s.schemas[schemaName];
+		collectEnumProps(enumProps, schema.properties, schemaPrefix(schemaName));
+	}
+
+	let output = '';
+	let tsOutput = '';
+
+	for (const name of Object.keys(enumProps).sort()) {
+		output += generateConstants(name, enumProps[name]) + NEW_LINE.repeat(2);
+		tsOutput += generateConstants(name, enumProps[name], { ts: true }) + NEW_LINE.repeat(2);
+	}
+
+	await fs.writeFile(constPath, output);
+	await fs.writeFile(constTsPath, tsOutput);
+}
+
+/**
+ * Generate JS code to define exported constants for the given enum values
+ *
+ * @param {string} name
+ * @param {string[]} values
+ * @param {Object} opts
+ * @param {boolean} [opts.ts] - whether to generate the TS type or JS code
+ * @returns {string}
+ */
+function generateConstants(name, values, { ts = false } = {}) {
+	const freezeStart = ts ? '' : 'Object.freeze(';
+	const freezeEnd = ts ? '' : ')';
+	const exportPrefix = 'export ';
+	const lines = [`${exportPrefix}const ${formatName(name)} = ${freezeStart}{`];
+	/**
+	 * @param {string} line
+	 * @param {number} spacing
+	 */
+	const addWithSpace = (line, spacing = 0) => lines.push(SPACING.repeat(spacing) + line);
+
+	for (const value of values.sort()) {
+		addWithSpace(`${formatName(value)}: '${value}',`, 1);
+	}
+
+	lines.push(`}${freezeEnd};`);
+
+	return lines.join(NEW_LINE);
+}
+
+/**
+ * Format a name for use as a constant value: UPPER_SNAKE_CASE
+ *
+ * @param {string} name
+ * @returns {string}
+ */
+function formatName(name) {
+	return snakeCase(name).toUpperCase();
+}
+
+/**
+ *
+ * @param {Object<string, string[]>} map
+ * @param {Object<string, {type?: string|string[], enum?: string[]}>} properties
+ * @param {string} [prefix]
+ */
+function collectEnumProps(map, properties = {}, prefix) {
+	for (const [key, prop] of Object.entries(properties)) {
+		const name = prefix ? prefix + '_' + key : key;
+
+		const hasStringEnum = (p) =>
+			p && p.enum && Array.isArray(p.enum) && p.type && (p.type === 'string' || p.type.includes('string'));
+		const getEnumValues = (p) => p.filter((e) => e !== null);
+		const collectEnumFromProp = (p) => {
+			if (hasStringEnum(p)) {
+				map[name] = getEnumValues(p.enum);
+			}
+		};
+
+		collectEnumFromProp(prop);
+		collectEnumFromProp(prop.items);
+	}
+}
+
+/**
+ * Generate a prefix based on the schema name
+ *
+ * @param {string} schemaName
+ * @returns {string|undefined}
+ */
+function schemaPrefix(schemaName) {
+	if (schemaName.toLowerCase().includes('appeal')) {
+		return 'appeal';
+	}
+	if (schemaName.toLowerCase().includes('nsip')) {
+		return 'nsip';
+	}
+}
+
+run().catch(console.error);

package/src/gen-types.js

@@ -0,0 +1,70 @@
+import fs from 'fs/promises';
+import path from 'path';
+import url from 'url';
+import { loadAllSchemas } from './index.js';
+import { compile } from 'json-schema-to-typescript';
+import { schemasPath, commandsPath } from './index.js';
+
+const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
+
+export const typesPath = path.join(__dirname, 'schemas.d.ts');
+
+/**
+ * Load all schemas and generate TypeScript definitions
+ */
+async function run() {
+	const s = await loadAllSchemas();
+
+	let types = '';
+	let first = true;
+
+	for (const schemaName of Object.keys(s.schemas).sort()) {
+		const schema = s.schemas[schemaName];
+		types += await compile(schema, schema['$id'], options(first));
+		types += '\n';
+		first = false;
+	}
+
+	for (const commandName of Object.keys(s.commands).sort()) {
+		const schema = s.commands[commandName];
+
+		if (
+			commandName.startsWith('appeal') ||
+			commandName.startsWith('appellant') ||
+			commandName.startsWith('lpa-questionnaire')
+		) {
+			// hack to allow nested $ref links to function in tests and gen types,
+			// can we leverage a better means to resolve $refs that aligns with how tests/appeals references this
+			types += await compile(schema, schema['$id'], options(first, commandsPath));
+		} else {
+			types += await compile(schema, schema['$id'], options(first));
+		}
+
+		types += '\n';
+		first = false;
+	}
+
+	await fs.writeFile(typesPath, types);
+}
+
+/**
+ *
+ * @param {boolean} first
+ * @returns {Partial<import('json-schema-to-typescript').Options>}
+ */
+function options(first, refPath = schemasPath) {
+	return {
+		// don't allow additional properties if not explicit in the schema
+		additionalProperties: false,
+		// we're joining all the definitions into one, so just put the comment in once
+		bannerComment: first ? undefined : '',
+		// resolve $refs from the schemas folder
+		cwd: refPath,
+		declareExternallyReferenced: true,
+		style: {
+			singleQuote: true
+		}
+	};
+}
+
+run().catch(console.error);