@thegetty/quire-cli 1.0.0-rc.44 → 1.0.0-rc.46

package/src/main.spec.js

@@ -1,61 +0,0 @@
-import { Command } from 'commander'
-import program from './main.js'
-import test from 'ava'
-
-/**
- * Main Program Unit Tests
- *
- * Tests the CLI program configuration and setup.
- * Command registration is tested indirectly through command spec files.
- */
-
-test('program exports a Commander.js Command instance', (t) => {
-  t.truthy(program)
-  t.true(program instanceof Command, 'program should be a Commander.js Command')
-})
-
-test('program has correct name and description', (t) => {
-  t.is(program.name(), 'quire')
-  t.truthy(program.description(), 'program should have a description')
-  t.regex(program.description(), /quire/i, 'description should mention Quire')
-})
-
-test('program has version option with correct flags', (t) => {
-  // Commander stores _version and the version option in the options array
-  t.truthy(program._version, 'program should have version set')
-
-  // Find the version option
-  const versionOption = program.options.find((opt) => opt.long === '--version')
-  t.truthy(versionOption, '--version option should exist')
-  t.is(versionOption.short, '-v', 'version option should have -v short flag')
-  t.truthy(versionOption.description, 'version option should have description')
-})
-
-test('program help is configured with correct width', (t) => {
-  // Access the help configuration
-  const helpConfig = program._helpConfiguration
-
-  t.truthy(helpConfig, 'help configuration should exist')
-  t.is(helpConfig.helpWidth, 80, 'help width should be 80')
-})
-
-test('program registers commands from commands/index.js', (t) => {
-  // Verify commands are registered
-  t.true(program.commands.length > 0, 'program should have registered commands')
-
-  // Verify expected commands exist
-  const commandNames = program.commands.map((cmd) => cmd.name())
-  t.true(commandNames.includes('build'), 'build command should be registered')
-  t.true(commandNames.includes('new'), 'new command should be registered')
-  t.true(commandNames.includes('preview'), 'preview command should be registered')
-  t.true(commandNames.includes('info'), 'info command should be registered')
-})
-
-test('program injects config into subcommands', (t) => {
-  // Pick a registered command and verify dependency injection of the config
-  const buildCommand = program.commands.find((cmd) => cmd.name() === 'build')
-
-  t.truthy(buildCommand, 'build command should exist')
-  t.truthy(buildCommand.config, 'subcommand should have config injected')
-  t.is(typeof buildCommand.config.get, 'function', 'config should have get method')
-})

package/src/main.test.js

@@ -1,347 +0,0 @@
-import test from 'ava'
-import sinon from 'sinon'
-import esmock from 'esmock'
-import QuireError from '#src/errors/quire-error.js'
-
-/**
- * Main Program Integration Tests
- *
- * Tests the runtime behavior of the CLI program, including
- * error handling in command lifecycle hooks.
- */
-
-test.beforeEach((t) => {
-  t.context.sandbox = sinon.createSandbox()
-})
-
-test.afterEach.always((t) => {
-  t.context.sandbox.restore()
-})
-
-/**
- * Helper to create a mock command with configurable hooks
- */
-function createMockCommand(overrides = {}) {
-  return {
-    name: 'mock-command',
-    description: 'Mock command for integration tests',
-    summary: 'mocked command',
-    action: async () => {},
-    ...overrides
-  }
-}
-
-test('preAction hook errors are passed to handleError', async (t) => {
-  const { sandbox } = t.context
-
-  const testError = new QuireError('Test preAction error', {
-    code: 'TEST_ERROR',
-    exitCode: 42
-  })
-
-  const mockHandleError = sandbox.stub()
-
-  const mockCommand = createMockCommand({
-    preAction: () => {
-      throw testError
-    }
-  })
-
-  // Use esmock to inject our mock command and handleError
-  await esmock('./main.js', {
-    '#src/commands/index.js': {
-      default: [mockCommand]
-    },
-    '#lib/error/handler.js': {
-      handleError: mockHandleError
-    }
-  })
-
-  // The program is created at import time, so we need to trigger the hook
-  // by parsing a command. Import the mocked program.
-  const { default: program } = await esmock('./main.js', {
-    '#src/commands/index.js': {
-      default: [mockCommand]
-    },
-    '#lib/error/handler.js': {
-      handleError: mockHandleError
-    }
-  })
-
-  // Configure Commander to not exit on error during tests
-  program.exitOverride()
-  program.configureOutput({
-    writeErr: () => {},
-    writeOut: () => {}
-  })
-
-  // Parse the test command to trigger preAction
-  try {
-    await program.parseAsync(['node', 'quire', 'mock-command'])
-  } catch {
-    // Commander may throw after our error is handled
-  }
-
-  t.true(mockHandleError.called, 'handleError should be called for preAction errors')
-  t.is(mockHandleError.firstCall.args[0], testError, 'handleError should receive the thrown error')
-})
-
-test('postAction hook errors are passed to handleError', async (t) => {
-  const { sandbox } = t.context
-
-  const testError = new QuireError('Test postAction error', {
-    code: 'TEST_POST_ERROR',
-    exitCode: 43
-  })
-
-  const mockHandleError = sandbox.stub()
-
-  const mockCommand = createMockCommand({
-    action: async () => {
-      // Action succeeds
-    },
-    postAction: () => {
-      throw testError
-    }
-  })
-
-  const { default: program } = await esmock('./main.js', {
-    '#src/commands/index.js': {
-      default: [mockCommand]
-    },
-    '#lib/error/handler.js': {
-      handleError: mockHandleError
-    }
-  })
-
-  program.exitOverride()
-  program.configureOutput({
-    writeErr: () => {},
-    writeOut: () => {}
-  })
-
-  try {
-    await program.parseAsync(['node', 'quire', 'mock-command'])
-  } catch {
-    // Commander may throw after our error is handled
-  }
-
-  t.true(mockHandleError.called, 'handleError should be called for postAction errors')
-  t.is(mockHandleError.firstCall.args[0], testError, 'handleError should receive the thrown error')
-})
-
-test('action errors are passed to handleError', async (t) => {
-  const { sandbox } = t.context
-
-  const testError = new QuireError('Test action error', {
-    code: 'TEST_ACTION_ERROR',
-    exitCode: 44
-  })
-
-  const mockHandleError = sandbox.stub()
-
-  const mockCommand = createMockCommand({
-    action: async () => {
-      throw testError
-    }
-  })
-
-  const { default: program } = await esmock('./main.js', {
-    '#src/commands/index.js': {
-      default: [mockCommand]
-    },
-    '#lib/error/handler.js': {
-      handleError: mockHandleError
-    }
-  })
-
-  program.exitOverride()
-  program.configureOutput({
-    writeErr: () => {},
-    writeOut: () => {}
-  })
-
-  try {
-    await program.parseAsync(['node', 'quire', 'mock-command'])
-  } catch {
-    // Commander may throw after our error is handled
-  }
-
-  t.true(mockHandleError.called, 'handleError should be called for action errors')
-  t.is(mockHandleError.firstCall.args[0], testError, 'handleError should receive the thrown error')
-})
-
-test('preAction hook preserves this context for command methods', async (t) => {
-  const { sandbox } = t.context
-
-  const debugSpy = sandbox.spy()
-  let thisContext = null
-
-  const mockCommand = createMockCommand({
-    debug: debugSpy,
-    preAction: function () {
-      thisContext = this
-      this.debug('preAction called')
-    }
-  })
-
-  const { default: program } = await esmock('./main.js', {
-    '#src/commands/index.js': {
-      default: [mockCommand]
-    },
-    '#lib/error/handler.js': {
-      handleError: sandbox.stub()
-    }
-  })
-
-  program.exitOverride()
-  program.configureOutput({
-    writeErr: () => {},
-    writeOut: () => {}
-  })
-
-  try {
-    await program.parseAsync(['node', 'quire', 'mock-command'])
-  } catch {
-    // Ignore Commander errors
-  }
-
-  t.is(thisContext, mockCommand, 'this should be bound to the command instance')
-  t.true(debugSpy.called, 'this.debug should be callable')
-})
-
-test('postAction hook preserves this context for command methods', async (t) => {
-  const { sandbox } = t.context
-
-  const debugSpy = sandbox.spy()
-  let thisContext = null
-
-  const mockCommand = createMockCommand({
-    debug: debugSpy,
-    action: async () => {},
-    postAction: function () {
-      thisContext = this
-      this.debug('postAction called')
-    }
-  })
-
-  const { default: program } = await esmock('./main.js', {
-    '#src/commands/index.js': {
-      default: [mockCommand]
-    },
-    '#lib/error/handler.js': {
-      handleError: sandbox.stub()
-    }
-  })
-
-  program.exitOverride()
-  program.configureOutput({
-    writeErr: () => {},
-    writeOut: () => {}
-  })
-
-  try {
-    await program.parseAsync(['node', 'quire', 'mock-command'])
-  } catch {
-    // Ignore Commander errors
-  }
-
-  t.is(thisContext, mockCommand, 'this should be bound to the command instance')
-  t.true(debugSpy.called, 'this.debug should be callable')
-})
-
-test('async preAction hooks are awaited before action runs', async (t) => {
-  const { sandbox } = t.context
-
-  const callOrder = []
-
-  const mockCommand = createMockCommand({
-    preAction: async () => {
-      await new Promise((resolve) => setTimeout(resolve, 10))
-      callOrder.push('preAction')
-    },
-    action: async () => {
-      callOrder.push('action')
-    }
-  })
-
-  const { default: program } = await esmock('./main.js', {
-    '#src/commands/index.js': {
-      default: [mockCommand]
-    },
-    '#lib/error/handler.js': {
-      handleError: sandbox.stub()
-    }
-  })
-
-  program.exitOverride()
-  program.configureOutput({
-    writeErr: () => {},
-    writeOut: () => {}
-  })
-
-  try {
-    await program.parseAsync(['node', 'quire', 'mock-command'])
-  } catch {
-    // Ignore Commander errors
-  }
-
-  t.deepEqual(callOrder, ['preAction', 'action'], 'preAction should complete before action starts')
-})
-
-test('async postAction hooks are awaited after action completes', async (t) => {
-  const { sandbox } = t.context
-
-  const callOrder = []
-
-  const mockCommand = createMockCommand({
-    action: async () => {
-      callOrder.push('action')
-    },
-    postAction: async () => {
-      await new Promise((resolve) => setTimeout(resolve, 10))
-      callOrder.push('postAction')
-    }
-  })
-
-  const { default: program } = await esmock('./main.js', {
-    '#src/commands/index.js': {
-      default: [mockCommand]
-    },
-    '#lib/error/handler.js': {
-      handleError: sandbox.stub()
-    }
-  })
-
-  program.exitOverride()
-  program.configureOutput({
-    writeErr: () => {},
-    writeOut: () => {}
-  })
-
-  try {
-    await program.parseAsync(['node', 'quire', 'mock-command'])
-  } catch {
-    // Ignore Commander errors
-  }
-
-  t.deepEqual(callOrder, ['action', 'postAction'], 'postAction should run after action completes')
-})
-
-/**
- * Nota bene: preSubcommand hook tests are skipped because:
- * 1. `main` does not process a `subcommands` array in command definitions
- * 2. No commands in the CLI currently use nested subcommands
- * 3. The wrapped error handler pattern is identical to preAction/postAction
- *
- * @todo When nested subcommands are added, these tests should be implemented.
- */
-test.skip('preSubcommand hook errors are passed to handleError', async (t) => {
-  // Requires main.js to support nested subcommands in command definitions
-  t.pass()
-})
-
-test.skip('preSubcommand hook preserves this context for command methods', async (t) => {
-  // Requires main.js to support nested subcommands in command definitions
-  t.pass()
-})

package/src/validators/validate-data-files.js

@@ -1,154 +0,0 @@
-/**
- * Data files validation for Quire projects
- *
- * Validates YAML files in content/_data/ directory:
- * - Required files exist (publication.yaml)
- * - YAML syntax is correct
- * - Files conform to their JSON schemas (when schema exists)
- * - No duplicate IDs in arrays
- *
- * @module validators/validate-data-files
- */
-import fs from 'node:fs'
-import path from 'node:path'
-import yaml from 'js-yaml'
-import Ajv from 'ajv'
-import addFormats from 'ajv-formats'
-import { DATA_DIR, REQUIRED_DATA_FILES } from '#lib/project/index.js'
-import { getSchemaForDocument, checkForDuplicateIds } from './utils.js'
-
-/**
- * Validation result for a single file
- * @typedef {Object} FileValidationResult
- * @property {string} file - Filename
- * @property {boolean} valid - Whether the file is valid
- * @property {string[]} errors - List of error messages
- */
-
-/**
- * Validation result for all data files
- * @typedef {Object} DataFilesValidationResult
- * @property {boolean} valid - Whether all files are valid
- * @property {string[]} errors - All error messages across all files
- * @property {number} fileCount - Number of YAML files found
- * @property {FileValidationResult[]} files - Per-file validation results
- */
-
-/**
- * Validate a single YAML file
- *
- * @param {string} filePath - Absolute path to the YAML file
- * @returns {FileValidationResult} Validation result
- */
-export function validateYamlFile(filePath) {
-  const errors = []
-  const filename = path.basename(filePath)
-
-  // Check file exists
-  if (!fs.existsSync(filePath)) {
-    return { file: filename, valid: false, errors: [`File not found: ${filename}`] }
-  }
-
-  // Read and parse YAML
-  let doc
-  try {
-    const content = fs.readFileSync(filePath, 'utf8')
-    doc = yaml.load(content)
-  } catch (error) {
-    const loc = error.mark ? ` at line ${error.mark.line + 1}` : ''
-    errors.push(`${filename}: YAML syntax error${loc} - ${error.reason || error.message}`)
-    return { file: filename, valid: false, errors }
-  }
-
-  // Validate against schema if one exists
-  const schema = getSchemaForDocument(filePath)
-  if (schema) {
-    const ajv = new Ajv({ allErrors: true })
-    addFormats(ajv)
-    const validate = ajv.compile(schema)
-    const valid = validate(doc)
-
-    if (!valid) {
-      for (const err of validate.errors) {
-        const errPath = err.instancePath || '(root)'
-        errors.push(`${filename}: ${errPath} ${err.message}`)
-      }
-    }
-  }
-
-  // Check for duplicate IDs using the existing utility
-  // Note: checkForDuplicateIds throws, so we need to catch
-  try {
-    checkForDuplicateIds(doc, filePath)
-  } catch (error) {
-    // Extract the duplicate ID info from the error
-    const match = error.reason?.match(/Duplicate IDs found: (.+)/)
-    if (match) {
-      errors.push(`${filename}: duplicate IDs found: ${match[1]}`)
-    } else {
-      errors.push(`${filename}: ${error.reason || error.message}`)
-    }
-  }
-
-  return { file: filename, valid: errors.length === 0, errors }
-}
-
-/**
- * Validate all data files in content/_data/
- *
- * @returns {DataFilesValidationResult} Validation result
- */
-export function validateDataFiles() {
-  const allErrors = []
-  const fileResults = []
-
-  // Check if data directory exists
-  if (!fs.existsSync(DATA_DIR)) {
-    return {
-      valid: true,
-      errors: [],
-      fileCount: 0,
-      files: [],
-      notInProject: true,
-    }
-  }
-
-  // Check required files exist
-  for (const required of REQUIRED_DATA_FILES) {
-    const filePath = path.join(DATA_DIR, required)
-    if (!fs.existsSync(filePath)) {
-      allErrors.push(`Required file missing: ${required}`)
-    }
-  }
-
-  // Find all YAML files
-  let yamlFiles = []
-  try {
-    yamlFiles = fs.readdirSync(DATA_DIR)
-      .filter((file) => file.endsWith('.yaml') || file.endsWith('.yml'))
-      .map((file) => path.join(DATA_DIR, file))
-  } catch (error) {
-    return {
-      valid: false,
-      errors: [`Cannot read ${DATA_DIR}: ${error.message}`],
-      fileCount: 0,
-      files: [],
-    }
-  }
-
-  // Validate each file
-  for (const filePath of yamlFiles) {
-    const result = validateYamlFile(filePath)
-    fileResults.push(result)
-    allErrors.push(...result.errors)
-  }
-
-  return {
-    valid: allErrors.length === 0,
-    errors: allErrors,
-    fileCount: yamlFiles.length,
-    files: fileResults,
-  }
-}
-
-export default validateDataFiles