Continue builds on errors and adjust error throwing point

Improve site building errors and reliability

Watch also doesn't crash as often so thats good.

bin.js

@@ -98,10 +98,12 @@ async function run () {
   }
 
   if (!argv.watch) {
+    // TODO: handle warning and error output
     const results = await siteup.build()
     console.log(results)
     console.log('done')
   } else {
+    // TODO: handle watch data event or something... maybe like a async iterator?
     const initialResults = await siteup.watch()
     console.log(initialResults)
   }

index.js

@@ -39,8 +39,18 @@ export class Siteup {
   }
 
   async watch () {
+    // TODO: expose events and stuff to the caller instead.
     if (this.watching) throw new Error('Already watching.')
-    const results = await watchBuild(this._src, this._dest, this.opts)
+
+    let report
+
+    try {
+      report = await watchBuild(this._src, this._dest, this.opts)
+      console.log('Initial JS, CSS and Page Build Complete')
+    } catch (err) {
+      console.error(err)
+      if (err.report) report = err.report
+    }
 
     this._cpxWatcher = cpx.watch(getCopyGlob(this._src), this._dest, { ignore: this.opts.ignore })
 
@@ -60,7 +70,6 @@ export class Siteup {
       console.log(`Copy error: ${err.message}`)
     })
 
-    console.log(this.opts.ignore)
     const ig = ignore().add(this.opts.ignore)
 
     const anymatch = name => ig.ignores(relname(this._src, name))
@@ -70,27 +79,25 @@ export class Siteup {
       persistent: true
     })
 
-    console.log(watcher)
-
     this._watcher = watcher
 
     await once(watcher, 'ready')
 
     watcher.on('add', path => {
       console.log(`File ${path} has been added`)
-      watchBuild(this._src, this._dest, this.opts)
+      watchBuild(this._src, this._dest, this.opts).then(() => console.log('Site Rebuilt')).catch(console.error)
     })
     watcher.on('change', path => {
       console.log(`File ${path} has been changed`)
-      watchBuild(this._src, this._dest, this.opts)
+      watchBuild(this._src, this._dest, this.opts).then(() => console.log('Site Rebuilt')).catch(console.error)
     })
     watcher.on('unlink', path => {
       console.log(`File ${path} has been removed`)
-      // await build(this.src, this.dest)
+      watchBuild(this._src, this._dest, this.opts).then(() => console.log('Site Rebuilt')).catch(console.error)
     })
     watcher.on('error', console.error)
 
-    return results
+    return report
   }
 
   async stopWatching () {

lib/build-css/index.js

@@ -13,7 +13,7 @@ import postcssNesting from 'postcss-nesting'
  * @param  {[type]} siteData [description]
  * @return {[type]}          [description]
  */
-export async function buildCss (src, dest, siteData) {
+export async function buildCss (src, dest, siteData, opts) {
   const styles = []
 
   if (siteData.globalStyle) styles.push(siteData.globalStyle)
@@ -22,23 +22,40 @@ export async function buildCss (src, dest, siteData) {
     if (page.pageStyle) styles.push(page.pageStyle)
   }
 
-  const results = []
+  const results = {
+    type: 'css',
+    success: [],
+    errors: [],
+    warnings: []
+  }
+
   for (const style of styles) {
-    const css = await readFile(style.filepath)
-    const targetPath = join(dest, style.relname)
-    const result = await postcss([
-      postcssImport,
-      postcssUrl({
-        url: 'copy',
-        useHash: true,
-        assetsPath: 'assets'
-      }),
-      postcssNesting,
-      autoprefixer
-    ]).process(css, { from: style.filepath, to: targetPath })
-    await writeFile(targetPath, result.css)
-    if (result.map) await writeFile(targetPath + '.map', result.map.toString())
-    results.push(result)
+    try {
+      const css = await readFile(style.filepath)
+      const targetPath = join(dest, style.relname)
+      const result = await postcss([
+        postcssImport,
+        postcssUrl({
+          url: 'copy',
+          useHash: true,
+          assetsPath: 'assets'
+        }),
+        postcssNesting,
+        autoprefixer
+      ]).process(css, { from: style.filepath, to: targetPath })
+      await writeFile(targetPath, result.css)
+      if (result.map) {
+        await writeFile(targetPath + '.map', result.map.toString())
+        delete result.map
+      }
+      delete result.css
+      results.success.push(result)
+    } catch (err) {
+      const buildError = new Error('Error building css', { cause: err })
+      buildError.style = style
+      results.errors.push(buildError)
+    }
   }
+
   return results
 }

lib/build-js/index.js

@@ -8,16 +8,17 @@ import esbuild from 'esbuild'
  * @param  {[type]} siteData [description]
  * @return {[type]}          [description]
  */
-export async function buildJs (src, dest, siteData) {
+export async function buildJs (src, dest, siteData, opts) {
   const entryPoints = []
   if (siteData.globalClient) entryPoints.push(join(src, siteData.globalClient.relname))
 
   for (const page of siteData.pages) {
     if (page.clientBundle) entryPoints.push(join(src, page.clientBundle.relname))
   }
 
-  const results = await esbuild.build({
+  const buildOpts = {
     entryPoints: entryPoints,
+    logLevel: 'silent',
     bundle: true,
     write: true,
     format: 'esm',
@@ -27,7 +28,22 @@ export async function buildJs (src, dest, siteData) {
     target: [
       'es2020'
     ]
-  })
+  }
 
-  return results
+  try {
+    // esbuild returns { errors:[], warnings: [] } already
+    const report = await esbuild.build(buildOpts)
+    return { ...report, buildOpts, type: 'js' }
+  } catch (err) {
+    const results = {
+      type: 'js',
+      errors: [],
+      warnings: [],
+      buildOpts
+    }
+    const buildError = new Error('Error building JS clients', { cause: err })
+    buildError.buildOpts = buildOpts
+    results.errors.push(buildError)
+    return results
+  }
 }

lib/build-pages/index.js

@@ -12,47 +12,98 @@ const __dirname = desm(import.meta.url)
 export { pageBuilders }
 
 /**
- * Page builder glue. Most of the magic happens in the builders
+ * Page builder glue. Most of the magic happens in the builders.
  * @param  {[type]} src      [description]
  * @param  {[type]} dest     [description]
  * @param  {[type]} siteData [description]
  * @return {[type]}          [description]
  */
-export async function buildPages (src, dest, siteData) {
+export function buildPages (src, dest, siteData, opts) {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(join(__dirname, 'worker.js'), {
+      workerData: { src, dest, siteData }
+    })
+
+    worker.once('message', results => {
+      if (results.errors.length > 0) {
+        // Put the errorData on the error to be consistent with the rest of the builders.
+        results.errors = results.errors.map(({ error, errorData }) => {
+          for (const [key, val] of Object.entries(errorData)) {
+            error[key] = val
+          }
+          return error
+        })
+      }
+      resolve(results)
+    })
+    worker.once('error', reject)
+    worker.once('exit', (code) => {
+      if (code !== 0) { reject(new Error(`Worker stopped with exit code ${code}`)) }
+    })
+  })
+}
+
+/**
+ * Directly build pages. Normally you run this in a worker.
+ * @param  {[type]} src      [description]
+ * @param  {[type]} dest     [description]
+ * @param  {[type]} siteData [description]
+ * @return {[type]}          [description]
+ */
+export async function buildPagesDirect (src, dest, siteData) {
+  const results = {
+    type: 'page',
+    success: [],
+    errors: [],
+    warnings: []
+  }
+
   const [
     globalVars,
     rootLayout
-  ] = await Promise.all([
+  ] = await Promise.allSettled([
     resolveVars(siteData?.globalVars?.filepath),
     resolveLayout(siteData?.rootLayout?.filepath)
   ])
 
-  const results = []
+  if (globalVars.status === 'rejected') {
+    results.errors.push(new Error('Encountered an error when resolving globalVars', {
+      cause: globalVars.reason
+    }))
+  }
+
+  if (rootLayout.status === 'rejected') {
+    results.errors.push(new Error('Encountered an error when resolving rootLayout', {
+      cause: rootLayout.reason
+    }))
+  }
+
+  if (results.errors.length > 0) return results // Return early, these will all fail.
+
   for (const page of siteData.pages) {
-    const builder = pageBuilders[page.type]
-    // This should never happen
-    if (!builder) throw new Error(`Can't build ${page.path}. unimplemented type ${page.type}`)
+    try {
+      const builder = pageBuilders[page.type]
+      // This should never happen
+      if (!builder) throw new Error(`Can't build ${page.path}. unimplemented type ${page.type}`)
 
-    globalVars.styles = siteData.globalStyle ? ['/global.css'] : []
-    globalVars.scripts = siteData.globalClient ? ['/global.client.js'] : []
+      // Supplement global vars with some global styles and clients
+      globalVars.value.styles = siteData.globalStyle ? ['/global.css'] : []
+      globalVars.value.scripts = siteData.globalClient ? ['/global.client.js'] : []
 
-    const result = await builder({ src, dest, page, globalVars, rootLayout })
-    results.push(result)
+      const result = await builder({
+        src,
+        dest,
+        page,
+        globalVars: globalVars.value,
+        rootLayout: rootLayout.value
+      })
+      results.success.push(result)
+    } catch (err) {
+      const buildError = new Error('Error building page', { cause: err })
+      // I can't put stuff on the error, the worker swallows it for some reason.
+      results.errors.push({ error: buildError, errorData: { page } })
+    }
   }
 
   return results
 }
-
-export function buildPagesInWorker (src, dest, siteData) {
-  return new Promise((resolve, reject) => {
-    const worker = new Worker(join(__dirname, 'worker.js'), {
-      workerData: { src, dest, siteData }
-    })
-
-    worker.once('message', resolve)
-    worker.once('error', reject)
-    worker.once('exit', (code) => {
-      if (code !== 0) { reject(new Error(`Worker stopped with exit code ${code}`)) }
-    })
-  })
-}

lib/build-pages/worker.js

@@ -1,9 +1,9 @@
 import { parentPort, workerData } from 'worker_threads'
-import { buildPages } from './index.js'
+import { buildPagesDirect } from './index.js'
 
 async function run () {
   const { src, dest, siteData } = workerData
-  const results = await buildPages(src, dest, siteData)
+  const results = await buildPagesDirect(src, dest, siteData)
   parentPort.postMessage(results)
 }
 

lib/build-static/index.js

@@ -9,6 +9,24 @@ export function getCopyGlob (src) {
 /**
  * run CPX2 on src folder
  */
-export async function buildStatic (src, dest, opts = {}) {
-  return await copy(getCopyGlob(src), dest, { ignore: opts.ignore })
+export async function buildStatic (src, dest, siteData, opts = {}) {
+  const results = {
+    type: 'static',
+    report: null,
+    errors: [],
+    warnings: []
+  }
+
+  const args = [getCopyGlob(src), dest, { ignore: opts.ignore }]
+
+  try {
+    const report = await copy(...args)
+    results.report = report
+  } catch (err) {
+    const buildError = new Error('Error copying static files', { cause: err })
+    buildError.staticArgs = args
+    results.errors.push(buildError)
+  }
+
+  return results
 }