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

package/src/lib/project/build.js

@@ -0,0 +1,143 @@
+/**
+ * Build detection module
+ *
+ * Detects if build output exists and provides build status information.
+ *
+ * @module lib/project/build
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import paths from './paths.js'
+
+/**
+ * Get build output information
+ *
+ * @param {string} [projectRoot] - Project root directory (defaults to cwd)
+ * @returns {Object} Build status information
+ */
+export function getBuildInfo(projectRoot = paths.getProjectRoot()) {
+  const sitePath = path.join(projectRoot, '_site')
+  const epubPath = path.join(projectRoot, '_epub')
+  const pdfFiles = ['pagedjs.pdf', 'prince.pdf']
+
+  const info = {
+    site: {
+      exists: fs.existsSync(sitePath),
+      path: sitePath,
+      mtime: null,
+    },
+    epub: {
+      exists: fs.existsSync(epubPath),
+      path: epubPath,
+      mtime: null,
+    },
+    pdf: {
+      exists: false,
+      paths: [],
+      mtime: null,
+    },
+  }
+
+  // Get modification times if directories exist
+  if (info.site.exists) {
+    info.site.mtime = fs.statSync(sitePath).mtime
+  }
+  if (info.epub.exists) {
+    info.epub.mtime = fs.statSync(epubPath).mtime
+  }
+
+  // Check for PDF files
+  for (const file of pdfFiles) {
+    const pdfPath = path.join(projectRoot, file)
+    if (fs.existsSync(pdfPath)) {
+      info.pdf.exists = true
+      info.pdf.paths.push(pdfPath)
+      // Use most recent mtime if multiple PDFs exist
+      const mtime = fs.statSync(pdfPath).mtime
+      if (!info.pdf.mtime || mtime > info.pdf.mtime) {
+        info.pdf.mtime = mtime
+      }
+    }
+  }
+
+  return info
+}
+
+/**
+ * Check if site build output exists
+ *
+ * @param {string} [projectRoot] - Project root directory (defaults to cwd)
+ * @returns {boolean} True if _site directory exists
+ */
+export function hasSiteOutput(projectRoot = paths.getProjectRoot()) {
+  const sitePath = path.join(projectRoot, '_site')
+  return fs.existsSync(sitePath)
+}
+
+/**
+ * Check if epub build output exists
+ *
+ * @param {string} [projectRoot] - Project root directory (defaults to cwd)
+ * @returns {boolean} True if _epub directory exists
+ */
+export function hasEpubOutput(projectRoot = paths.getProjectRoot()) {
+  const epubPath = path.join(projectRoot, '_epub')
+  return fs.existsSync(epubPath)
+}
+
+/**
+ * Check if PDF output exists
+ *
+ * Checks for PDF output at common locations:
+ * - Default library outputs: pagedjs.pdf, prince.pdf
+ * - Specific library output when lib option provided
+ *
+ * @param {Object} [options]
+ * @param {string} [options.lib] - Specific library to check ('pagedjs' or 'prince')
+ * @param {string} [options.projectRoot] - Project root directory
+ * @returns {boolean} True if PDF output exists
+ */
+export function hasPdfOutput(options = {}) {
+  const { lib, projectRoot = paths.getProjectRoot() } = options
+
+  if (lib) {
+    const pdfPath = path.join(projectRoot, `${lib}.pdf`)
+    return fs.existsSync(pdfPath)
+  }
+
+  // Check for any common PDF output
+  const pdfFiles = ['pagedjs.pdf', 'prince.pdf']
+  return pdfFiles.some((file) => fs.existsSync(path.join(projectRoot, file)))
+}
+
+/**
+ * Require build output to exist, throwing an error if missing
+ *
+ * @param {Object} options
+ * @param {string} [options.type='site'] - Output type to check ('site' or 'epub')
+ * @param {string} [options.projectRoot] - Project root directory
+ * @throws {Error} If required build output does not exist
+ */
+export function requireBuildOutput(options = {}) {
+  const { type = 'site', projectRoot = paths.getProjectRoot() } = options
+
+  if (type === 'site' && !hasSiteOutput(projectRoot)) {
+    const error = new Error('Build output not found. Run "quire build" first.')
+    error.code = 'ENOBUILD'
+    throw error
+  }
+
+  if (type === 'epub' && !hasEpubOutput(projectRoot)) {
+    const error = new Error('EPUB output not found. Run "quire build" first.')
+    error.code = 'ENOBUILD'
+    throw error
+  }
+}
+
+export default {
+  getBuildInfo,
+  hasEpubOutput,
+  hasPdfOutput,
+  hasSiteOutput,
+  requireBuildOutput,
+}

package/src/lib/project/build.test.js

@@ -0,0 +1,253 @@
+import test from 'ava'
+import path from 'node:path'
+import { Volume, createFsFromVolume } from 'memfs'
+import esmock from 'esmock'
+
+/**
+ * Helper to create cross-platform paths for memfs
+ * memfs uses forward slashes internally, but we need to pass
+ * platform-native paths to the functions under test
+ */
+const testRoot = '/test-project'
+const nativePath = (...segments) => path.join(testRoot, ...segments)
+const memfsPath = (...segments) => [testRoot, ...segments].join('/')
+
+test.beforeEach((t) => {
+  // Create in-memory file system
+  t.context.vol = new Volume()
+  t.context.fs = createFsFromVolume(t.context.vol)
+})
+
+test.afterEach.always((t) => {
+  t.context.vol.reset()
+})
+
+test('hasSiteOutput returns true when _site exists', async (t) => {
+  const { vol } = t.context
+
+  vol.fromJSON({
+    [memfsPath('_site', 'index.html')]: '<html></html>',
+  })
+
+  const { hasSiteOutput } = await esmock('./build.js', {
+    'node:fs': createFsFromVolume(vol),
+  })
+
+  t.true(hasSiteOutput(testRoot))
+})
+
+test('hasSiteOutput returns false when _site does not exist', async (t) => {
+  const { vol } = t.context
+
+  vol.fromJSON({
+    [memfsPath('.quire')]: '',
+  })
+
+  const { hasSiteOutput } = await esmock('./build.js', {
+    'node:fs': createFsFromVolume(vol),
+  })
+
+  t.false(hasSiteOutput(testRoot))
+})
+
+test('hasEpubOutput returns true when _epub exists', async (t) => {
+  const { vol } = t.context
+
+  vol.fromJSON({
+    [memfsPath('_epub', 'content.opf')]: '<package></package>',
+  })
+
+  const { hasEpubOutput } = await esmock('./build.js', {
+    'node:fs': createFsFromVolume(vol),
+  })
+
+  t.true(hasEpubOutput(testRoot))
+})
+
+test('hasEpubOutput returns false when _epub does not exist', async (t) => {
+  const { vol } = t.context
+
+  vol.fromJSON({
+    [memfsPath('.quire')]: '',
+  })
+
+  const { hasEpubOutput } = await esmock('./build.js', {
+    'node:fs': createFsFromVolume(vol),
+  })
+
+  t.false(hasEpubOutput(testRoot))
+})
+
+test('getBuildInfo returns correct status for existing builds', async (t) => {
+  const { vol } = t.context
+
+  vol.fromJSON({
+    [memfsPath('_site', 'index.html')]: '<html></html>',
+    [memfsPath('_epub', 'content.opf')]: '<package></package>',
+    [memfsPath('pagedjs.pdf')]: '%PDF-1.4',
+  })
+
+  const { getBuildInfo } = await esmock('./build.js', {
+    'node:fs': createFsFromVolume(vol),
+  })
+
+  const info = getBuildInfo(testRoot)
+
+  t.true(info.site.exists)
+  t.is(info.site.path, nativePath('_site'))
+  t.truthy(info.site.mtime)
+
+  t.true(info.epub.exists)
+  t.is(info.epub.path, nativePath('_epub'))
+  t.truthy(info.epub.mtime)
+
+  t.true(info.pdf.exists)
+  t.deepEqual(info.pdf.paths, [nativePath('pagedjs.pdf')])
+  t.truthy(info.pdf.mtime)
+})
+
+test('getBuildInfo returns correct status for missing builds', async (t) => {
+  const { vol } = t.context
+
+  vol.fromJSON({
+    [memfsPath('.quire')]: '',
+  })
+
+  const { getBuildInfo } = await esmock('./build.js', {
+    'node:fs': createFsFromVolume(vol),
+  })
+
+  const info = getBuildInfo(testRoot)
+
+  t.false(info.site.exists)
+  t.is(info.site.mtime, null)
+
+  t.false(info.epub.exists)
+  t.is(info.epub.mtime, null)
+
+  t.false(info.pdf.exists)
+  t.deepEqual(info.pdf.paths, [])
+  t.is(info.pdf.mtime, null)
+})
+
+test('getBuildInfo returns multiple PDF paths when both exist', async (t) => {
+  const { vol } = t.context
+
+  vol.fromJSON({
+    [memfsPath('pagedjs.pdf')]: '%PDF-1.4',
+    [memfsPath('prince.pdf')]: '%PDF-1.4',
+  })
+
+  const { getBuildInfo } = await esmock('./build.js', {
+    'node:fs': createFsFromVolume(vol),
+  })
+
+  const info = getBuildInfo(testRoot)
+
+  t.true(info.pdf.exists)
+  t.is(info.pdf.paths.length, 2)
+  t.true(info.pdf.paths.includes(nativePath('pagedjs.pdf')))
+  t.true(info.pdf.paths.includes(nativePath('prince.pdf')))
+  t.truthy(info.pdf.mtime)
+})
+
+test('requireBuildOutput throws when site output missing', async (t) => {
+  const { vol } = t.context
+
+  vol.fromJSON({
+    [memfsPath('.quire')]: '',
+  })
+
+  const { requireBuildOutput } = await esmock('./build.js', {
+    'node:fs': createFsFromVolume(vol),
+  })
+
+  const error = t.throws(() => {
+    requireBuildOutput({ type: 'site', projectRoot: testRoot })
+  })
+
+  t.is(error.code, 'ENOBUILD')
+  t.regex(error.message, /quire build/)
+})
+
+test('requireBuildOutput throws when epub output missing', async (t) => {
+  const { vol } = t.context
+
+  vol.fromJSON({
+    [memfsPath('.quire')]: '',
+  })
+
+  const { requireBuildOutput } = await esmock('./build.js', {
+    'node:fs': createFsFromVolume(vol),
+  })
+
+  const error = t.throws(() => {
+    requireBuildOutput({ type: 'epub', projectRoot: testRoot })
+  })
+
+  t.is(error.code, 'ENOBUILD')
+})
+
+test('requireBuildOutput does not throw when output exists', async (t) => {
+  const { vol } = t.context
+
+  vol.fromJSON({
+    [memfsPath('_site', 'index.html')]: '<html></html>',
+    [memfsPath('_epub', 'content.opf')]: '<package></package>',
+  })
+
+  const { requireBuildOutput } = await esmock('./build.js', {
+    'node:fs': createFsFromVolume(vol),
+  })
+
+  t.notThrows(() => {
+    requireBuildOutput({ type: 'site', projectRoot: testRoot })
+  })
+
+  t.notThrows(() => {
+    requireBuildOutput({ type: 'epub', projectRoot: testRoot })
+  })
+})
+
+test('hasPdfOutput returns true when specific lib PDF exists', async (t) => {
+  const { vol } = t.context
+
+  vol.fromJSON({
+    [memfsPath('pagedjs.pdf')]: '%PDF-1.4',
+  })
+
+  const { hasPdfOutput } = await esmock('./build.js', {
+    'node:fs': createFsFromVolume(vol),
+  })
+
+  t.true(hasPdfOutput({ lib: 'pagedjs', projectRoot: testRoot }))
+  t.false(hasPdfOutput({ lib: 'prince', projectRoot: testRoot }))
+})
+
+test('hasPdfOutput returns false when no PDF exists', async (t) => {
+  const { vol } = t.context
+
+  vol.fromJSON({
+    [memfsPath('.quire')]: '',
+  })
+
+  const { hasPdfOutput } = await esmock('./build.js', {
+    'node:fs': createFsFromVolume(vol),
+  })
+
+  t.false(hasPdfOutput({ projectRoot: testRoot }))
+})
+
+test('hasPdfOutput returns true when any common PDF exists', async (t) => {
+  const { vol } = t.context
+
+  vol.fromJSON({
+    [memfsPath('prince.pdf')]: '%PDF-1.4',
+  })
+
+  const { hasPdfOutput } = await esmock('./build.js', {
+    'node:fs': createFsFromVolume(vol),
+  })
+
+  t.true(hasPdfOutput({ projectRoot: testRoot }))
+})

package/src/lib/project/config.js

@@ -0,0 +1,48 @@
+/**
+ * Project configuration module
+ *
+ * Loads and validates Quire project configuration files.
+ *
+ * @module lib/project/config
+ */
+import fs from 'fs-extra'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import yaml from 'js-yaml'
+import paths from './paths.js'
+import { ConfigFileNotFoundError } from '#src/errors/index.js'
+
+/**
+ * Load and validate Quire project configuration
+ *
+ * @param {string} [projectRoot] - project root directory (defaults to cwd)
+ * @returns {Promise<Object>} validated configuration object
+ *
+ * @todo consider hardcoding a version check against .quire / project's package.json ver
+ */
+export async function loadProjectConfig(projectRoot) {
+  const root = projectRoot || paths.getProjectRoot()
+  const configPath = path.join(root, 'content', '_data', 'config.yaml')
+
+  if (!fs.existsSync(configPath)) {
+    throw new ConfigFileNotFoundError(configPath)
+  }
+
+  const data = fs.readFileSync(configPath)
+  let config = yaml.load(data)
+
+  // NB: Schemas and validators are specific to the 11ty version of the project being built
+  const schemaPath = path.join(root, '_plugins', 'schemas', 'config.json')
+  const validatorPath = path.join(root, '_plugins', 'globalData', 'validator.js')
+
+  if (fs.existsSync(schemaPath) && fs.existsSync(validatorPath)) {
+    const { validateUserConfig } = await import(pathToFileURL(validatorPath))
+
+    const schemaJSON = fs.readFileSync(schemaPath)
+    const schema = JSON.parse(schemaJSON)
+
+    config = validateUserConfig('config', config, { config: schema })
+  }
+
+  return config
+}

package/src/lib/project/config.test.js

@@ -0,0 +1,134 @@
+import test from 'ava'
+import { Volume, createFsFromVolume } from 'memfs'
+import sinon from 'sinon'
+import esmock from 'esmock'
+
+test.beforeEach((t) => {
+  // Create sinon sandbox for mocking
+  t.context.sandbox = sinon.createSandbox()
+
+  // Create in-memory file system
+  t.context.vol = new Volume()
+  t.context.fs = createFsFromVolume(t.context.vol)
+})
+
+test.afterEach.always((t) => {
+  // Restore all mocks
+  if (t.context.sandbox) {
+    t.context.sandbox.restore()
+  }
+
+  // Clear in-memory file system
+  t.context.vol.reset()
+})
+
+test('loadProjectConfig should throw ConfigFileNotFoundError when config file does not exist', async (t) => {
+  const { fs, vol } = t.context
+
+  // Setup empty directory
+  vol.fromJSON({
+    '/project/content/_data/.gitkeep': ''
+  })
+
+  const { loadProjectConfig } = await esmock('./config.js', {
+    'fs-extra': {
+      existsSync: (p) => fs.existsSync(p),
+      readFileSync: (p) => fs.readFileSync(p)
+    },
+    './paths.js': {
+      default: {
+        getProjectRoot: () => '/project'
+      }
+    }
+  })
+
+  const error = await t.throwsAsync(() => loadProjectConfig('/project'))
+
+  t.is(error.code, 'CONFIG_FILE_NOT_FOUND')
+  t.true(error.message.includes('config.yaml'), 'error should include config path')
+})
+
+test('loadProjectConfig should load and parse YAML config file', async (t) => {
+  const { fs, vol } = t.context
+
+  // Setup config file
+  vol.fromJSON({
+    '/project/content/_data/config.yaml': 'title: Test Project\nauthor: Test Author'
+  })
+
+  // Mock fs-extra to use memfs
+  const { loadProjectConfig } = await esmock('./config.js', {
+    'fs-extra': {
+      existsSync: (p) => fs.existsSync(p),
+      readFileSync: (p) => fs.readFileSync(p)
+    },
+    './paths.js': {
+      default: {
+        getProjectRoot: () => '/project'
+      }
+    }
+  })
+
+  const result = await loadProjectConfig('/project')
+
+  t.truthy(result, 'should return config object')
+  t.is(result.title, 'Test Project', 'should parse title')
+  t.is(result.author, 'Test Author', 'should parse author')
+})
+
+test('loadProjectConfig should load PDF configuration', async (t) => {
+  const { fs, vol } = t.context
+
+  // Setup config file with PDF settings
+  vol.fromJSON({
+    '/project/content/_data/config.yaml': `title: Test Project
+pdf:
+  filename: test-book
+  outputDir: _pdf`
+  })
+
+  // Mock fs-extra to use memfs
+  const { loadProjectConfig } = await esmock('./config.js', {
+    'fs-extra': {
+      existsSync: (p) => fs.existsSync(p),
+      readFileSync: (p) => fs.readFileSync(p)
+    },
+    './paths.js': {
+      default: {
+        getProjectRoot: () => '/project'
+      }
+    }
+  })
+
+  const result = await loadProjectConfig('/project')
+
+  t.truthy(result.pdf, 'should have pdf config')
+  t.is(result.pdf.filename, 'test-book', 'should parse pdf filename')
+  t.is(result.pdf.outputDir, '_pdf', 'should parse pdf outputDir')
+})
+
+test('loadProjectConfig should use default project root when not provided', async (t) => {
+  const { fs, vol } = t.context
+
+  // Setup config file
+  vol.fromJSON({
+    '/default/project/content/_data/config.yaml': 'title: Default Project'
+  })
+
+  // Mock fs-extra to use memfs
+  const { loadProjectConfig } = await esmock('./config.js', {
+    'fs-extra': {
+      existsSync: (p) => fs.existsSync(p),
+      readFileSync: (p) => fs.readFileSync(p)
+    },
+    './paths.js': {
+      default: {
+        getProjectRoot: () => '/default/project'
+      }
+    }
+  })
+
+  const result = await loadProjectConfig()
+
+  t.is(result.title, 'Default Project', 'should use default project root')
+})

package/src/{helpers/is-quire.js → lib/project/detect.js}

@@ -1,6 +1,9 @@
 /**
- * A helper module to test if a directory is a Quire project root
- * @module is-quire
+ * Project detection module
+ *
+ * Detects if a directory is a Quire project root by checking for marker files.
+ *
+ * @module lib/project/detect
  */
 import fs from 'node:fs'
 
@@ -28,4 +31,3 @@ export default function (dirpath) {
   return fs.readdirSync(dirpath)
     .find((entry) => QUIRE_DOT_FILES.includes(entry))
 }
-