@defra/forms-model 3.0.431 → 3.0.432

package/schemas/sorting-options-schema.json

@@ -0,0 +1,28 @@
+{
+  "type": "object",
+  "properties": {
+    "sortBy": {
+      "type": "string",
+      "description": "Field to sort results by",
+      "enum": [
+        "updatedAt",
+        "title"
+      ],
+      "title": "Sort By"
+    },
+    "order": {
+      "type": "string",
+      "description": "Sort order (ascending or descending)",
+      "enum": [
+        "asc",
+        "desc"
+      ],
+      "title": "Order"
+    }
+  },
+  "additionalProperties": false,
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Sorting Options Schema",
+  "description": "JSON Schema for validating Sorting Options Schema in Defra forms",
+  "$id": "@defra/forms-model/schemas/sorting-options-schema.json"
+}

package/schemas/written-answer-sub-schema.json

@@ -0,0 +1,12 @@
+{
+  "type": "string",
+  "description": "Subtype for written answer questions",
+  "enum": [
+    "TextField",
+    "MultilineTextField",
+    "NumberField"
+  ],
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Written Answer Sub Schema",
+  "$id": "@defra/forms-model/schemas/written-answer-sub-schema.json"
+}

package/scripts/generate-schemas.js

@@ -1,238 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import parse from 'joi-to-json'
-
-import { schemasDir } from './schema-modules/constants.js'
-import { ensureDirectoryExists, toTitleCase } from './schema-modules/utils.js'
-import { addTitles } from './schema-modules/title-processors.js'
-import { simplifyForDocs } from './schema-modules/schema-simplifiers.js'
-
-/**
- * Cleans the schemas directory by removing all existing JSON files
- * @returns {number} Number of files cleaned
- */
-export function cleanSchemaDirectory() {
-  console.log('Cleaning existing schema files...')
-  const existingFiles = fs
-    .readdirSync(schemasDir)
-    .filter((file) => file.endsWith('.json'))
-
-  for (const file of existingFiles) {
-    fs.unlinkSync(path.join(schemasDir, file))
-  }
-
-  console.log(`Cleaned ${existingFiles.length} existing schema files`)
-  return existingFiles.length
-}
-
-/**
- * Gets the schema map that defines which files should be generated
- * @returns {Record<string, string>} Schema map with filename-to-schema-export mapping
- */
-export function getSchemaMap() {
-  return {
-    // Form definition schemas
-    'form-definition-schema': 'formDefinitionSchema',
-    'form-definition-v2-payload-schema': 'formDefinitionV2PayloadSchema',
-
-    // Component schemas
-    'component-schema': 'componentSchema',
-    'component-schema-v2': 'componentSchemaV2',
-
-    // Page schemas
-    'page-schema': 'pageSchema',
-    'page-schema-v2': 'pageSchemaV2',
-    'page-schema-payload-v2': 'pageSchemaPayloadV2',
-
-    // List schemas
-    'list-schema': 'listSchema',
-    'list-schema-v2': 'listSchemaV2',
-
-    // Form metadata schemas
-    'form-metadata-schema': 'formMetadataSchema',
-    'form-metadata-author-schema': 'formMetadataAuthorSchema',
-    'form-metadata-input-schema': 'formMetadataInputSchema',
-    'form-metadata-state-schema': 'formMetadataStateSchema',
-
-    // Form metadata field schemas
-    'form-metadata-contact-schema': 'contactSchema',
-    'form-metadata-email-schema': 'emailSchema',
-    'form-metadata-online-schema': 'onlineSchema',
-
-    // Form editor schemas
-    'form-editor-input-page-schema': 'formEditorInputPageSchema',
-    'form-editor-input-check-answers-setting-schema':
-      'formEditorInputCheckAnswersSettingSchema',
-    'form-editor-input-question-schema': 'formEditorInputQuestionSchema',
-    'form-editor-input-page-settings-schema':
-      'formEditorInputPageSettingsSchema',
-
-    // Form editor field schemas
-    'page-type-schema': 'pageTypeSchema',
-    'question-type-schema': 'questionTypeSchema',
-    'question-type-full-schema': 'questionTypeFullSchema',
-    'written-answer-sub-schema': 'writtenAnswerSubSchema',
-    'date-sub-schema': 'dateSubSchema',
-
-    // Form submission schemas
-    'form-submit-payload-schema': 'formSubmitPayloadSchema',
-    'form-submit-record-schema': 'formSubmitRecordSchema',
-    'form-submit-recordset-schema': 'formSubmitRecordsetSchema',
-
-    // Form manager schemas
-    'patch-page-schema': 'patchPageSchema',
-
-    // Section schemas
-    'question-schema': 'questionSchema',
-
-    // Validation schemas
-    'min-schema': 'minSchema',
-    'max-schema': 'maxSchema',
-    'min-length-schema': 'minLengthSchema',
-    'max-length-schema': 'maxLengthSchema',
-    'max-future-schema': 'maxFutureSchema',
-    'max-past-schema': 'maxPastSchema',
-
-    // Common schemas
-    'search-options-schema': 'searchOptionsSchema',
-    'query-options-schema': 'queryOptionsSchema',
-    'pagination-options-schema': 'paginationOptionsSchema',
-    'sorting-options-schema': 'sortingOptionsSchema'
-  }
-}
-
-/**
- * Process a single schema and create its JSON Schema file
- * @param {string} fileName - Output file name
- * @param {string} schemaName - Schema export name in the model
- * @param {Record<string, unknown>} model - The loaded model containing schemas
- * @returns {boolean} Whether processing was successful
- */
-export function processSchema(fileName, schemaName, model) {
-  try {
-    /** @type {unknown} */
-    const joiSchema = model[schemaName]
-
-    if (!joiSchema) {
-      return false
-    }
-
-    /** @type {import('./schema-modules/types.js').SchemaObject} */
-    let jsonSchema = parse(
-      /** @type {Schema} */ (joiSchema),
-      'json',
-      {},
-      {
-        includeSchemaDialect: true,
-        includeDescriptions: true
-      }
-    )
-
-    const title = toTitleCase(fileName)
-    if (!jsonSchema.title) {
-      jsonSchema.title = title
-    }
-    if (!jsonSchema.description) {
-      jsonSchema.description = `JSON Schema for validating ${title} in Defra forms`
-    }
-
-    if (!jsonSchema.$id) {
-      jsonSchema.$id = `@defra/forms-model/schemas/${fileName}.json`
-    }
-
-    addTitles(jsonSchema, '')
-
-    jsonSchema = simplifyForDocs(jsonSchema, '')
-
-    const outputPath = path.join(schemasDir, `${fileName}.json`)
-    fs.writeFileSync(outputPath, JSON.stringify(jsonSchema, null, 2))
-    return true
-  } catch (/** @type {unknown} */ err) {
-    const error = err instanceof Error ? err : new Error(String(err))
-    console.error(`✗ Failed to process ${fileName}: ${error.message}`)
-    return false
-  }
-}
-
-/**
- * Loads the model with all schemas
- * @returns {Promise<Record<string, unknown>>} Loaded model
- */
-async function loadModelSchemas() {
-  console.log('Loading model schemas...')
-  return import('../dist/module/index.js')
-}
-
-/**
- * Processes all schemas and generates JSON Schema files
- * @param {Record<string, unknown>} model - The loaded model containing schemas
- * @returns {{ successCount: number, errorCount: number }} Object containing success and error counts
- */
-export function processAllSchemas(model) {
-  const schemaMap = getSchemaMap()
-  let successCount = 0
-  let errorCount = 0
-
-  for (const [fileName, schemaName] of Object.entries(schemaMap)) {
-    const success = processSchema(fileName, schemaName, model)
-
-    if (success) {
-      successCount++
-    } else {
-      errorCount++
-    }
-  }
-
-  return { successCount, errorCount }
-}
-
-/**
- * Generates schema files from Joi schemas
- */
-export async function generateSchemas() {
-  try {
-    const model = await loadModelSchemas()
-
-    ensureDirectoryExists(schemasDir)
-
-    cleanSchemaDirectory()
-
-    const { successCount, errorCount } = processAllSchemas(model)
-
-    console.log('\nSchema generation complete!')
-    console.log(`✓ Successfully generated ${successCount} schemas`)
-    if (errorCount > 0) {
-      console.log(`✗ Failed to generate ${errorCount} schemas`)
-    }
-
-    return { successCount, errorCount }
-  } catch (err) {
-    const error = err instanceof Error ? err : new Error(String(err))
-    console.error(`\n✗ Schema generation failed: ${error.message}`)
-    throw error
-  }
-}
-
-// Only run when executed directly, not when imported as a module
-if (import.meta.url === `file://${process.argv[1]}`) {
-  ;(async () => {
-    try {
-      await generateSchemas()
-    } catch (err) {
-      console.error('Schema generation failed:', err)
-      throw err
-    }
-  })().catch((err) => {
-    console.error('Unhandled error:', err)
-    // eslint-disable-next-line no-process-exit
-    process.exit(1)
-  })
-}
-
-/**
- * @import { Schema } from 'joi'
- */
-
-/**
- * @import { SchemaObject } from './schema-modules/types.js'
- */

package/scripts/schema-modules/constants.js

@@ -1,39 +0,0 @@
-import path from 'path'
-import { fileURLToPath } from 'url'
-
-export const currentDirname = path.dirname(fileURLToPath(import.meta.url))
-export const schemasDir = path.resolve(currentDirname, '../../schemas')
-
-/**
- * Condition type constants
- */
-export const CONDITION_TYPES = {
-  DEFINITION: 'Condition Definition',
-  REFERENCE: 'Condition Reference',
-  NESTED_GROUP: 'Nested Condition Group'
-}
-
-/**
- * Value type constants
- */
-export const VALUE_TYPES = {
-  STATIC: 'Static Value',
-  RELATIVE_DATE: 'Relative Date Value'
-}
-
-/**
- * Common description constants
- */
-export const DESCRIPTIONS = {
-  NESTED_CONDITION_GROUP:
-    'A nested group of conditions that allows building complex logical expressions with multiple levels.'
-}
-
-/**
- * Path segment constants
- */
-export const PATH_SEGMENTS = {
-  CONDITIONS: 'conditions',
-  ITEMS: 'items',
-  PROPERTIES: 'properties'
-}

package/scripts/schema-modules/schema-processors.js

@@ -1,109 +0,0 @@
-import { CONDITION_TYPES, DESCRIPTIONS, VALUE_TYPES } from './constants.js'
-
-/**
- * Fixes titles for condition items in anyOfTitles
- * @param {SchemaObject} obj - Schema to process
- * @returns {boolean} True if changes were made
- */
-export function fixConditionItems(obj) {
-  if (!obj.anyOfTitles?.includes('Conditions  Item Variant 3')) {
-    return false
-  }
-
-  const EXPECTED_CONDITION_TYPES_COUNT = 3
-
-  obj.anyOfTitles = [
-    CONDITION_TYPES.DEFINITION,
-    CONDITION_TYPES.REFERENCE,
-    CONDITION_TYPES.NESTED_GROUP
-  ]
-
-  if (obj.anyOf?.length === EXPECTED_CONDITION_TYPES_COUNT) {
-    if (obj.anyOf[0].properties?.field) {
-      obj.anyOf[0].title = CONDITION_TYPES.DEFINITION
-    }
-    if (obj.anyOf[1].properties?.conditionName) {
-      obj.anyOf[1].title = CONDITION_TYPES.REFERENCE
-    }
-    if (obj.anyOf[2].$ref?.includes('conditionGroupSchema')) {
-      obj.anyOf[2].title = CONDITION_TYPES.NESTED_GROUP
-      obj.anyOf[2].description = DESCRIPTIONS.NESTED_CONDITION_GROUP
-    }
-  }
-  return true
-}
-
-/**
- * Fixes titles for value objects in anyOfTitles
- * @param {SchemaObject} obj - Schema to process
- * @returns {boolean} True if changes were made
- */
-export function fixValueObjects(obj) {
-  if (
-    obj.anyOfTitles?.length !== 2 ||
-    obj.anyOfTitles[0] !== 'Value (object)' ||
-    obj.anyOfTitles[1] !== 'Value (object)'
-  ) {
-    return false
-  }
-
-  obj.anyOfTitles = [VALUE_TYPES.STATIC, VALUE_TYPES.RELATIVE_DATE]
-
-  if (obj.anyOf?.length === 2) {
-    if (obj.anyOf[0].properties?.value) {
-      obj.anyOf[0].title = VALUE_TYPES.STATIC
-    }
-    if (obj.anyOf[1].properties?.period) {
-      obj.anyOf[1].title = VALUE_TYPES.RELATIVE_DATE
-    }
-  }
-
-  return true
-}
-
-/**
- * Processes the anyOfTitles array in an object
- * @param {SchemaObject} obj - Schema to process
- */
-export function processAnyOfTitles(obj) {
-  if (!obj || typeof obj !== 'object') {
-    return
-  }
-
-  if (!Array.isArray(obj.anyOfTitles)) {
-    return
-  }
-
-  if (!fixConditionItems(obj)) {
-    fixValueObjects(obj)
-  }
-}
-
-/**
- * Recursively fixes all condition titles and anyOfTitles throughout the schema
- * regardless of their nesting level
- * @param {SchemaObject} obj - The schema or subschema to fix
- */
-export function fixConditionTitles(obj) {
-  if (!obj || typeof obj !== 'object') {
-    return
-  }
-
-  processAnyOfTitles(obj)
-
-  if (obj.title === 'Conditions  Item Variant 3') {
-    obj.title = CONDITION_TYPES.NESTED_GROUP
-    obj.description = DESCRIPTIONS.NESTED_CONDITION_GROUP
-  }
-
-  Object.keys(obj).forEach((key) => {
-    const value = obj[key]
-    if (value && typeof value === 'object') {
-      fixConditionTitles(value)
-    }
-  })
-}
-
-/**
- * @import { SchemaObject } from './types.js'
- */