mikser-io 6.0.5 → 6.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mikser-io",
-	"version": "6.0.5",
+	"version": "6.1.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')
                     }

package/src/plugins/layouts.js

@@ -20,6 +20,8 @@ export default ({
     onSync,
     matchEntity,
     changeExtension,
+    findEntity,
+    findEntities,
     constants: { ACTION, OPERATION, TASKS },
 }) => {
     const collection = 'layouts'
@@ -57,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
                     }
                 }
             }
@@ -206,9 +208,10 @@ export default ({
                                 break
                             }
                         }
-                        if (!entity.layout && runtime.config.layouts?.autoLayouts && entity.name) {
-                            const dir = path.dirname(entity.name)
-                            const base = path.basename(entity.name)
+                        if (!entity.layout && runtime.config.layouts?.autoLayouts && entity.id) {
+                            const lookupBase = entity.id.replace(`/${entity.collection}/`,'')
+                            const dir = path.dirname(lookupBase)
+                            const base = path.basename(lookupBase)
                             const chunks = base.split('.')
                             const candidates = []
 
@@ -248,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
             }
@@ -256,6 +264,7 @@ export default ({
     })
 
     onBeforeRender(async (signal) => {
+        const logger = useLogger()
         const tasks = []
         const entities = Array.from(getSitemapEntities())
             .filter(entity => entity.layout)
@@ -274,7 +283,7 @@ export default ({
             try {
                 var { load, plugins = [] } = await import(`${path.join(runtime.options.layoutsFolder, entity.layout.name)}.js?stamp=${Date.now()}`)
                 if (load) {
-                    data = await load(entity, signal)
+                    data = await load({ entity, findEntity, findEntities, runtime, signal })            
                 }
             } catch (err) {
                 if (err.code != 'ERR_MODULE_NOT_FOUND') throw err
@@ -288,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/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}]`
 }