@thegetty/quire-cli 1.0.0-rc.33 → 1.0.0-rc.34

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@thegetty/quire-cli",
   "description": "Quire command-line interface",
-  "version": "1.0.0-rc.33",
+  "version": "1.0.0-rc.34",
   "author": "Getty Digital",
   "license": "SEE LICENSE IN https://github.com/thegetty/quire/blob/main/LICENSE",
   "bugs": {

package/src/commands/validate.js

@@ -0,0 +1,64 @@
+import Command from '#src/Command.js'
+import { YAMLException } from 'js-yaml'
+import YamlValidationError from '../errors/validation/yaml-validation-error.js'
+import fs from 'fs-extra'
+import path from 'node:path'
+import { projectRoot  } from '#lib/11ty/index.js'
+import testcwd from '../helpers/test-cwd.js'
+import yamlValidation from '../validators/validate-yaml.js'
+
+
+/**
+ * Quire CLI `validate` Command
+ *  
+ * @class     ValidateCommand
+ * @extends   {Command}
+ */
+export default class ValidateCommand extends Command {
+  static definition = {
+    name: 'validate',
+    description: 'Validate configuration files',
+    summary: 'run validation',
+    version: '1.0.0',
+    options: [
+      [ '--debug', 'run validate with debug output to console' ],
+    ],
+  }
+
+  constructor() {
+    super(ValidateCommand.definition)
+  }
+
+  action(options, command){
+    if(options.debug) {
+      console.debug('[CLI] Command \'%s\' called with options %o', this.name(), options)
+    }
+    
+    const dataPath = path.join(projectRoot, 'content', '_data')
+    const files = fs.readdirSync(dataPath)
+      .filter(file => file.endsWith('.yaml') || file.endsWith('.yml'))
+      .map(file => path.join(dataPath, file)
+      )
+
+    let errorList = []
+    console.log('Validating YAML files..')
+
+    for (const file of files) {
+      try {
+        yamlValidation(file)
+      } catch (error){
+        errorList.push(error)
+      }
+    }
+
+    if(errorList.length > 0) {
+      errorList.forEach(err => { console.error(`${err.reason}`) })
+    } else {
+      console.log('Validation complete.')
+    }
+  }
+
+  preAction(options, command) {
+    testcwd(command)
+  }
+}

package/src/errors/validation/validation-error.js

@@ -0,0 +1,13 @@
+export default class ValidationError extends Error {
+  constructor(message, {filePath, reason, code} = {}) {
+    super(message)
+    this.name = this.constructor.name
+    this.filePath = filePath
+    this.reason = reason
+    this.code = code
+
+    if ('captureStackTrace' in Error) {
+      Error.captureStackTrace(this, this.constructor)
+    }
+  }
+}

package/src/errors/validation/yaml-duplicate-error.js

@@ -0,0 +1,11 @@
+import ValidationError from './validation-error.js'
+
+export default class YamlDuplicateIdError extends ValidationError {
+  constructor(filePath, reason) {
+    super('Duplicate ID found in YAML file', {
+      filePath,
+      reason: reason,
+      code: 'YAML_DUPLICATE_ID_ERROR',
+    })
+  }
+}

package/src/errors/validation/yaml-parse-error.js

@@ -0,0 +1,11 @@
+import ValidationError from './validation-error.js'
+
+export default class YamlParseError extends ValidationError {
+  constructor(filePath, reason) {
+    super('Error parsing YAML file', {
+      filePath,
+      reason: reason,
+      code: 'YAML_PARSE_ERROR',
+    })
+  }
+}

package/src/errors/validation/yaml-validation-error.js

@@ -0,0 +1,11 @@
+import ValidationError from './validation-error.js'
+
+export default class YamlValidationError extends ValidationError {
+  constructor(filePath, reason) {
+    super('Error validating YAML file', {
+      filePath,
+      reason: reason,
+      code: 'YAML_VALIDATION_ERROR',
+    })
+  }
+}

package/src/validators/utils.js

@@ -0,0 +1,98 @@
+import YamlDuplicateIdError from '../errors/validation/yaml-duplicate-error.js'
+import { fileURLToPath } from 'url'
+import fs from 'node:fs'
+import path from 'path'
+import { projectRoot  } from '#lib/11ty/index.js'
+
+const IMAGE_KEYS = new Set(['src', 'image', 'logo'])
+
+export function getSchemaForDocument(file) {
+  const schemaName = path.basename(file, path.extname(file))
+  const __dirname = path.dirname(fileURLToPath(import.meta.url))
+  const schemaPath = path.join(__dirname,'..','..','schemas', `${schemaName}.schema.json`)
+
+  try {
+    return JSON.parse(fs.readFileSync(schemaPath, 'utf8'))
+  } catch (error) {
+    console.warn(`Warning: No schema found for document ${schemaName} at path: ${schemaPath}.`)
+    return null
+  }
+}
+
+// Recursive helper to check image paths in nested figure list structures
+function collectImagePaths(node, paths=[]) {
+  if(!node || typeof node !== 'object') return
+
+  for (const key in node) {
+    const value = node[key]
+    if (IMAGE_KEYS.has(key) && typeof value === 'string') {
+      paths.push(value)
+    }
+    collectImagePaths(value, paths)
+  }
+
+  return paths
+}
+
+function validateImage(label, src) {
+  if(!src) return
+
+  let assetPath = ''
+  if(src.endsWith('.html')) {
+    assetPath = path.join(projectRoot, 'content', '_assets', src)
+  } else {
+    assetPath = path.join(projectRoot, 'content', '_assets', 'images', src)
+  }
+
+  if(!fs.existsSync(assetPath)) {
+    console.warn(`Warning: ${label} source not found at path: ${assetPath}`)
+  }
+}
+
+export function validateImagePaths(doc) {
+  validateImage('Cover image', doc?.epub?.defaultCoverImage)
+  validateImage('Promo image', doc?.promo_image)
+
+  for (const figure of doc?.figure_list || []) {
+    let paths = []
+    const imagePaths = collectImagePaths(figure, paths)
+    for (const imgPath of imagePaths) {
+      validateImage(`Figure id ${figure.id}`, imgPath)
+    }
+  }
+
+  for (const publisher of doc?.publisher || []) {
+    validateImage('Logo', publisher.logo)
+  }
+
+  for (const contributor of doc?.contributor || []) {
+    validateImage('Contributor', contributor.image)
+  }
+}
+
+/**
+ * Lifted from packages/11ty/_plugins/globalData
+ * Throws an error if data contains duplicate ids
+ * @param  {Object|Array} data
+ */
+export const checkForDuplicateIds = function (data, file) {
+  if (!data) return
+
+  if (Array.isArray(data)) {
+    if (data.every((item) => Object.hasOwn(item, 'id'))) {
+      const duplicates = data.filter((a, index) => {
+        return index !== data.findIndex((b) => b.id === a.id)
+      })
+      if (duplicates.length) {
+        const ids = duplicates.map(({ id }) => id)
+        throw new YamlDuplicateIdError(file, `Error in ${file}: Duplicate IDs found: ${ids.join(', ')}`)
+      }
+    }
+  }
+
+  if (typeof data === 'object') {
+    Object.keys(data).forEach((key) => {
+      checkForDuplicateIds(data[key], file)
+    })
+  }
+}

package/src/validators/validate-yaml.js

@@ -0,0 +1,38 @@
+import Ajv from 'ajv'
+import addFormats from 'ajv-formats'
+import { validateImagePaths ,getSchemaForDocument, checkForDuplicateIds } from './utils.js'
+import YamlValidationError from '../errors/validation/yaml-validation-error.js'
+import fs from 'fs'
+import yaml from 'js-yaml'
+
+export default function yamlValidation(file) {
+
+  const fileContent = fs.readFileSync(file, 'utf8')
+
+  let doc
+  try {
+    doc = yaml.load(fileContent)
+  } catch (error) {
+    const message = `Error in ${file}: ${error.reason} at line ${error.mark.line} column ${error.mark.column}`
+    throw new YamlValidationError(file, `${message}`)
+  }
+
+  const schema = getSchemaForDocument(file)
+  if(!schema){ return } 
+
+  const ajv = new Ajv({allErrors:true})
+  addFormats(ajv)
+  const validate = ajv.compile(schema)
+  const valid = validate(doc)
+  if(!valid) {
+    const messages = validate.errors
+      .map(err => `${err.instancePath || '(root)'} ${err.message}`)
+      .join('\n')
+
+    const fullMessage = `Error in ${file}:\n${messages}`
+    throw new YamlValidationError(file, fullMessage)
+  }
+
+  validateImagePaths(doc)
+  checkForDuplicateIds(doc, file)
+}