mikser-io 6.0.6 → 6.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mikser-io",
-	"version": "6.0.6",
+	"version": "6.2.0",
 	"description": "<p align=\"center\">   <img src=\"mikser-lockup-stacked.svg\" alt=\"mikser\" width=\"198\" /> </p>",
 	"main": "index.js",
 	"scripts": {
@@ -53,7 +53,9 @@
 	},
 	"devDependencies": {
 		"fluent-ffmpeg": "^2.1.3",
-		"mikser-io-render-markdown": "^2.0.0",
+		"mikser-io-post-mjml": "file:../mikser-io-post-mjml",
+		"mikser-io-render-liquid": "file:../mikser-io-render-liquid",
+		"mikser-io-render-markdown": "file:../mikser-io-render-markdown",
 		"sharp": "^0.34.5"
 	},
 	"directories": {

package/src/engine.js

@@ -1,7 +1,7 @@
 import pino from 'pino'
 import path from 'node:path'
 import { Command } from 'commander'
-import { rm, lstat, realpath, mkdir, writeFile } from 'fs/promises'
+import { rm, lstat, realpath, mkdir, writeFile, readFile, unlink } from 'fs/promises'
 import { existsSync } from 'fs'
 import _ from 'lodash'
 import Piscina from 'piscina'
@@ -10,7 +10,7 @@ import { onInitialize, onInitialized, onRender, onCancel, onCancelled, onFinaliz
 import { useJournal, updateEntry } from './journal.js'
 import { globby } from 'globby'
 import { OPERATION, TASKS } from './constants.js'
-import { changeExtension } from './utils.js'
+import { changeExtension, formatErrorContext } from './utils.js'
 import render from './render.js'
 import postprocess, { loadPlugin as loadPostPlugin } from './postprocess.js'
 import map from 'p-map'
@@ -89,6 +89,27 @@ export async function setup(options) {
     onLoaded(async () => {
         const logger = useLogger()
         logger.debug(runtime.options, 'Mikser options')
+
+        // Cumulative render manifest — survives across watch cycles, used to
+        // unlink stale output files when their source entity is deleted.
+        // Keyed by "<entity.id>:<entity.destination>" so paginated outputs
+        // for the same id stay distinct.
+        runtime.state.manifest = new Map()
+        const manifestPath = path.join(runtime.options.runtimeFolder, 'render-details.json')
+        if (existsSync(manifestPath)) {
+            try {
+                const arr = JSON.parse(await readFile(manifestPath, 'utf8'))
+                if (Array.isArray(arr)) {
+                    for (const entity of arr) {
+                        if (entity?.id && entity?.destination) {
+                            runtime.state.manifest.set(`${entity.id}:${entity.destination}`, entity)
+                        }
+                    }
+                }
+            } catch (err) {
+                logger.warn('Could not load render-details.json: %s', err.message)
+            }
+        }
     })
 
     onRender(async (signal) => {
@@ -156,7 +177,7 @@ export async function setup(options) {
                 } catch (err) {
                     if (!signal.aborted) {
                         await updateEntry({ id, output: { success: false } })
-                        logger.error('Render error: %s %s', entity.id, err.message)
+                        logger.error('Render error: %s%s %s', entity.id, formatErrorContext(entity, err, runtime.options), err.message)
                     }
                     logger.debug('Render canceled')
                 }
@@ -171,15 +192,37 @@ export async function setup(options) {
     })
 
     onAfterRender(async () => {
-        const results = new Map()
+        const logger = useLogger()
+        const manifest = runtime.state.manifest
+
+        // Unlink stale output files for entities deleted in this cycle, and
+        // prune them from the manifest. Matches by `entity.id` for direct hits
+        // and by `entity.parent` so paginated children (whose id was rewritten
+        // via changeExtension) are reclaimed alongside their source.
+        for await (let { entity } of useJournal('Manifest cleanup', [OPERATION.DELETE])) {
+            for (const [key, value] of manifest) {
+                if (value.id === entity.id || value.parent === entity.id) {
+                    const filePath = path.join(runtime.options.outputFolder, value.destination)
+                    try {
+                        await unlink(filePath)
+                        logger.debug('Manifest unlinked stale output: %s', value.destination)
+                    } catch { }
+                    manifest.delete(key)
+                }
+            }
+        }
+
+        // Merge this cycle's successful renders. New ids appear; re-rendered
+        // ids overwrite (same key); ids whose destination changed leave the
+        // old key as a stale entry — handled by the cleanup pass on next DELETE.
         for await (let { output, entity } of useJournal('Output', [OPERATION.RENDER])) {
             if (output?.success) {
-                const jobId = entity.id + ':' + entity.destination
-                results.set(jobId, entity)
+                manifest.set(`${entity.id}:${entity.destination}`, entity)
             }
         }
-        const renderOutput = path.join(runtime.options.runtimeFolder, `render-details.json`)
-        await writeFile(renderOutput, JSON.stringify(Array.from(results.values())), 'utf8')
+
+        const manifestPath = path.join(runtime.options.runtimeFolder, 'render-details.json')
+        await writeFile(manifestPath, JSON.stringify(Array.from(manifest.values())), 'utf8')
     })
 
     onBeforePostprocess(async (signal) => {
@@ -259,7 +302,7 @@ export async function setup(options) {
                     } catch (err) {
                         if (!signal.aborted) {
                             await updateEntry({ id, output: { success: false } })
-                            logger.error('Postprocess error: %s %s', entity.id, err.message)
+                            logger.error('Postprocess error: %s%s %s', entity.id, formatErrorContext(entity, err, runtime.options), err.message)
                         }
                         logger.debug('Postprocess canceled')
                     }
@@ -313,5 +356,5 @@ export async function setup(options) {
 }
 
 export function useLogger() {
-    return runtime.engine.logger
+    return runtime.engine?.logger
 }

package/src/plugins/layouts.js

@@ -59,18 +59,18 @@ export default ({
 
     function removeFromSitemap(entity) {
         const { sitemap } = runtime.state.layouts
+        const matches = (current) =>
+            current.id === entity.id || current.parent === entity.id
         for (let href in sitemap) {
             let entry = sitemap[href]
             if (entry.id) {
-                if (entry.id == entity.id) {
+                if (matches(entry)) {
                     delete sitemap[href]
-                    return
                 }
             } else {
                 for (let lang in entry) {
-                    if (entry[lang].id == entity.id) {
+                    if (matches(entry[lang])) {
                         delete entry[lang]
-                        return
                     }
                 }
             }
@@ -251,6 +251,11 @@ export default ({
                     }
                     break
                 case OPERATION.DELETE:
+                    // DELETE journal entries are sparse (id/collection/type only),
+                    // so the uri-based removePagesFromSitemap can't match. Walk
+                    // the sitemap by id first; keep the uri-based sweep for any
+                    // paginated children that match by uri.
+                    removeFromSitemap(entity)
                     removePagesFromSitemap(entity)
                     break
             }
@@ -292,6 +297,9 @@ export default ({
                         if (page) {
                             pageEntity.page = page + 1
                             pageEntity.id = changeExtension(entity.id, `${pageEntity.page}.${entity.layout.format}`)
+                            // Remember the source entity id so the render manifest
+                            // can reclaim paginated outputs when the parent is deleted.
+                            pageEntity.parent = entity.id
                             if (entity.meta) {
                                 if (entity.meta.href) {
                                     pageEntity.meta.href = `${entity.meta.href}.${pageEntity.page}`

package/src/plugins/render/hbs.js

@@ -53,5 +53,18 @@ export async function render({ entity, runtime }) {
             sandbox[helper] = runtime[helper]
         }
     }
-    return runtime.hbs(source, sandbox)
+    try {
+        return runtime.hbs(source, sandbox)
+    } catch (err) {
+        // Handlebars compile errors expose `.lineNumber`/`.column`; runtime
+        // errors (missing helper, etc.) don't, but we still know the layout.
+        // Parse errors put the line in the message as "Parse error on line N".
+        if (err.lineNumber != null && err.line == null) err.line = err.lineNumber
+        if (err.line == null && typeof err.message === 'string') {
+            const m = err.message.match(/on line (\d+)/i)
+            if (m) err.line = Number(m[1])
+        }
+        err.layoutUri = entity.layout.uri
+        throw err
+    }
 }

package/src/postprocess.js

@@ -1,12 +1,20 @@
 import path from 'node:path'
+import { createRequire } from 'node:module'
 import _ from 'lodash'
 
 export async function loadPlugin(pluginName, workingFolder) {
+    const require = createRequire(path.join(workingFolder, 'package.json'))
+    let nodeModulesResolved
+    try {
+        nodeModulesResolved = require.resolve(`mikser-io-${pluginName}`)
+    } catch { }
+
     const resolveLocations = [
-        path.join(workingFolder, 'node_modules', `mikser-core-${pluginName}/index.js`),
+        path.join(workingFolder, 'node_modules', `mikser-io-${pluginName}/index.js`),
+        nodeModulesResolved,
         path.join(workingFolder, 'plugins', `${pluginName}.js`),
         path.join(path.dirname(import.meta.url), 'plugins', 'post', `${pluginName.replace('post-', '')}.js`)
-    ]
+    ].filter(Boolean)
     for (let resolveLocation of resolveLocations) {
         try {
             return await import(resolveLocation)

package/src/render.js

@@ -2,6 +2,25 @@ import { readFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import path from 'node:path'
 import _ from 'lodash'
+import { useLogger } from './engine.js'
+
+// Flatten template-helper args into a single human-readable message.
+// Handlebars helpers receive a trailing options object (it has a `.hash`
+// property) which we drop.
+function formatLogArgs(args) {
+    if (args.length && typeof args[args.length - 1] === 'object' && args[args.length - 1] !== null && 'hash' in args[args.length - 1]) {
+        args = args.slice(0, -1)
+    }
+    return args
+        .map(arg => {
+            if (arg == null) return String(arg)
+            if (typeof arg === 'object') {
+                try { return JSON.stringify(arg) } catch { return String(arg) }
+            }
+            return String(arg)
+        })
+        .join(' ')
+}
 
 export default async ({ entity, options, config, context, state, logger, port }) => {
     logger = logger || {
@@ -65,7 +84,21 @@ export default async ({ entity, options, config, context, state, logger, port })
         data: context.data,
         content() {
             return readFileSync(entity.source, { encoding: 'utf8' })
-        }
+        },
+        // Logger functions are exposed directly so each renderer's
+        // auto-helper loop picks them up are picked up; falls back to the local `logger` in
+        // worker contexts where the engine singleton isn't initialised.
+        //
+        // Args are flattened into a single space-separated message so
+        // every value the template passed shows up — pino otherwise drops
+        // trailing positional args unless the first contains %s/%d format
+        // specifiers. Handlebars appends an internal options object as
+        // the last arg, which we strip before joining.
+        log: (...args) => (useLogger() ?? logger).info(formatLogArgs(args)),
+        warn: (...args) => (useLogger() ?? logger).warn(formatLogArgs(args)),
+        error: (...args) => (useLogger() ?? logger).error(formatLogArgs(args)),
+        debug: (...args) => (useLogger() ?? logger).debug(formatLogArgs(args)),
+        trace: (...args) => (useLogger() ?? logger).trace(formatLogArgs(args)),
     }
 
     for (let pluginName of pluginsToLoad) {

package/src/utils.js

@@ -62,4 +62,22 @@ export function changeExtension(file, format) {
     let extension = path.extname(file)
     let result = file.substring(0, file.length - extension.length) + '.' + format
     return result
+}
+
+// Build a compact "[layouts/foo.hbs:12:4]" suffix from whatever the
+// underlying template engine attached to its thrown error. Renderer
+// plugins are expected to set `err.layoutUri` (and optionally `err.line` /
+// `err.column`) before rethrowing.
+export function formatErrorContext(entity, err, options) {
+    const layoutUri = err?.layoutUri || entity?.layout?.uri || entity?.layout?.id
+    if (!layoutUri) return ''
+    const workingFolder = options?.workingFolder
+    const rel = workingFolder && layoutUri.startsWith(workingFolder + '/')
+        ? layoutUri.slice(workingFolder.length + 1)
+        : layoutUri
+    const line = err?.line ?? err?.lineNumber
+    const column = err?.column ?? err?.col
+    let pos = ''
+    if (line) pos = `:${line}${column ? ':' + column : ''}`
+    return ` [${rel}${pos}]`
 }