mikser-io 6.2.0 → 6.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mikser-io",
-	"version": "6.2.0",
+	"version": "6.3.0",
 	"description": "<p align=\"center\">   <img src=\"mikser-lockup-stacked.svg\" alt=\"mikser\" width=\"198\" /> </p>",
 	"main": "index.js",
 	"scripts": {

package/src/engine.js

@@ -226,14 +226,33 @@ export async function setup(options) {
     })
 
     onBeforePostprocess(async (signal) => {
+        // Resolve the output extension for each postprocessor exactly once
+        // per cycle. A plugin can declare `export const output = '...'` to
+        // separate its name from the produced file extension (e.g. post-mjml
+        // names itself "mjml" but emits ".html"). Falls back to the
+        // postprocessor name for plugins that don't declare it — preserves
+        // the current behavior for post-pdf and any other existing plugin.
+        const outputExtCache = new Map()
+        const resolveOutputExt = async (postprocessor) => {
+            if (outputExtCache.has(postprocessor)) return outputExtCache.get(postprocessor)
+            let ext = postprocessor
+            try {
+                const plugin = await loadPostPlugin(`post-${postprocessor}`, runtime.options.workingFolder)
+                if (plugin?.output) ext = plugin.output
+            } catch { /* loadPostPlugin already logged */ }
+            outputExtCache.set(postprocessor, ext)
+            return ext
+        }
+
         const tasks = []
         for await (const { entity, options, context, output } of useJournal('Queuing postprocess', [OPERATION.RENDER], signal)) {
             if (output?.success && options.postprocessor) {
+                const ext = await resolveOutputExt(options.postprocessor)
                 tasks.push({
                     entity: {
                         ...entity,
                         origin: entity.destination,
-                        destination: changeExtension(entity.destination, options.postprocessor)
+                        destination: changeExtension(entity.destination, ext)
                     },
                     options: { postprocessor: options.postprocessor, tasks: options.tasks },
                     context

package/src/plugins/layouts.js

@@ -1,5 +1,6 @@
 import path from 'node:path'
 import { mkdir, writeFile, unlink } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
 import { globby } from 'globby'
 import _ from 'lodash'
 
@@ -280,13 +281,27 @@ export default ({
             const entity = _.cloneDeep(original)
             entity.destination = '/' + entity.name
             let data
-            try {
-                var { load, plugins = [] } = await import(`${path.join(runtime.options.layoutsFolder, entity.layout.name)}.js?stamp=${Date.now()}`)
+            let load
+            let plugins = []
+            const sidecarPath = `${path.join(runtime.options.layoutsFolder, entity.layout.name)}.js`
+            // Existence-check first so a real ERR_MODULE_NOT_FOUND inside the
+            // sidecar (e.g. it imports a missing package) doesn't get swallowed
+            // as "sidecar doesn't exist".
+            if (existsSync(sidecarPath)) {
+                try {
+                    ({ load, plugins = [] } = await import(`${sidecarPath}?stamp=${Date.now()}`))
+                } catch (err) {
+                    logger.error('Layout sidecar %s failed to load: %s', sidecarPath.replace(runtime.options.workingFolder + '/', ''), err.message)
+                    throw err
+                }
                 if (load) {
-                    data = await load({ entity, findEntity, findEntities, runtime, signal })            
+                    try {
+                        data = await load({ entity, findEntity, findEntities, runtime, signal })
+                    } catch (err) {
+                        logger.error('Layout sidecar %s load() threw: %s', sidecarPath.replace(runtime.options.workingFolder + '/', ''), err.message)
+                        throw err
+                    }
                 }
-            } catch (err) {
-                if (err.code != 'ERR_MODULE_NOT_FOUND') throw err
             }
 
             if (data?.pages) {
@@ -370,7 +385,11 @@ export default ({
             } catch { }
             await writeFile(destinationFile, output.result)
             logger.debug('Layout render finished: %s', entity.destination.replace(runtime.options.workingFolder, ''))
-            if (entity.origin) {
+            if (entity.origin && entity.origin !== entity.destination) {
+                // Don't unlink the origin if it was the same path we just
+                // wrote to (post plugins that produce the same extension as
+                // the renderer's output — e.g. MJML→HTML on `*.html-mjml.*`
+                // layouts). Otherwise we'd delete our own final file.
                 const originFile = path.join(runtime.options.outputFolder, entity.origin)
                 try {
                     await unlink(originFile)

package/src/plugins.js

@@ -27,6 +27,10 @@ export async function loadPlugin(pluginName) {
         if (fs.existsSync(resolveLocation.replace('file:', ''))) {
             try {
                 const plugin = await import(resolveLocation)
+                if (typeof plugin.default !== 'function') {
+                    logger.error('Plugin %s loaded from %s but does not export a default factory function', pluginName, resolveLocation)
+                    return
+                }
                 const pluginRuntime = plugin.default(core)
                 runtime.engine[pluginName] = pluginRuntime
                 if (pluginRuntime) {
@@ -36,12 +40,18 @@ export async function loadPlugin(pluginName) {
                 }
                 return
             } catch (err) {
-                logger.error('Plugin load error: [%s] %s', pluginName, err.message)
+                // ERR_MODULE_NOT_FOUND here means the plugin file resolved
+                // but one of its imports didn't — a real bug worth surfacing.
+                if (err.code === 'ERR_MODULE_NOT_FOUND') {
+                    logger.error('Plugin %s found at %s but its dependencies are missing: %s', pluginName, resolveLocation, err.message)
+                } else {
+                    logger.error('Plugin %s failed to load (%s): %s', pluginName, resolveLocation, err.message)
+                }
                 return
             }
         }
     }
-    logger.error('Plugin not loaded: %s', pluginName)
+    logger.error('Plugin %s not found. Searched: %s', pluginName, resolveLocations.join(', '))
 }
 
 onLoad(async () => {

package/src/postprocess.js

@@ -1,13 +1,16 @@
 import path from 'node:path'
 import { createRequire } from 'node:module'
+import { existsSync } from 'node:fs'
 import _ from 'lodash'
+import { useLogger } from './engine.js'
 
 export async function loadPlugin(pluginName, workingFolder) {
+    const logger = useLogger()
     const require = createRequire(path.join(workingFolder, 'package.json'))
     let nodeModulesResolved
     try {
         nodeModulesResolved = require.resolve(`mikser-io-${pluginName}`)
-    } catch { }
+    } catch { /* package not installed at this level — fine, try next */ }
 
     const resolveLocations = [
         path.join(workingFolder, 'node_modules', `mikser-io-${pluginName}/index.js`),
@@ -15,13 +18,25 @@ export async function loadPlugin(pluginName, workingFolder) {
         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) {
+        // See render.js loadPlugin — existence-check first so we can
+        // distinguish "plugin not at this path" from "plugin found but its
+        // transitive deps are missing".
+        if (!existsSync(resolveLocation.replace(/^file:/, ''))) continue
         try {
             return await import(resolveLocation)
         } catch (err) {
-            if (err.code != 'ERR_MODULE_NOT_FOUND') throw err
+            if (err.code === 'ERR_MODULE_NOT_FOUND') {
+                logger?.error('Postprocess plugin %s found at %s but its dependencies are missing: %s', pluginName, resolveLocation, err.message)
+            } else {
+                logger?.error('Postprocess plugin %s failed to load (%s): %s', pluginName, resolveLocation, err.message)
+            }
+            throw err
         }
     }
+
+    logger?.error('Postprocess plugin %s not found. Searched: %s', pluginName, resolveLocations.join(', '))
 }
 
 export default async ({ entity, options, config, context, state, logger }) => {
@@ -46,10 +61,24 @@ export default async ({ entity, options, config, context, state, logger }) => {
 
     for (let pluginName of pluginsToLoad) {
         const plugin = await loadPlugin(pluginName, options.workingFolder)
+        if (!plugin) continue // loadPlugin already logged the "not found" path
         plugins[pluginName] = plugin
-        if (plugin?.load) await plugin.load({ entity, options, config: config[pluginName], context, runtime, state, logger })
+        if (plugin.load) {
+            try {
+                await plugin.load({ entity, options, config: config[pluginName], context, runtime, state, logger })
+            } catch (err) {
+                logger.error('Postprocess plugin %s load() failed: %s', pluginName, err.message)
+                throw err
+            }
+        }
     }
 
     const postprocessorPlugin = plugins[`post-${postprocessor}`]
-    return await postprocessorPlugin?.postprocess({ entity, options, config, context, plugins, runtime, state, logger })
+    if (!postprocessorPlugin) {
+        throw new Error(`Postprocessor "${postprocessor}" was requested but plugin "post-${postprocessor}" is not loaded`)
+    }
+    if (typeof postprocessorPlugin.postprocess !== 'function') {
+        throw new Error(`Plugin "post-${postprocessor}" does not export a postprocess() function`)
+    }
+    return await postprocessorPlugin.postprocess({ entity, options, config, context, plugins, runtime, state, logger })
 }

package/src/render.js

@@ -1,4 +1,4 @@
-import { readFileSync } from 'node:fs'
+import { readFileSync, existsSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import path from 'node:path'
 import _ from 'lodash'
@@ -46,7 +46,7 @@ export default async ({ entity, options, config, context, state, logger, port })
         let nodeModulesResolved
         try {
             nodeModulesResolved = require.resolve(`mikser-io-${pluginName}`)
-        } catch { }
+        } catch { /* package not installed at this level — fine, try next */ }
 
         const resolveLocations = [
             path.join(options.workingFolder, 'node_modules', `mikser-io-${pluginName}/index.js`),
@@ -54,16 +54,26 @@ export default async ({ entity, options, config, context, state, logger, port })
             path.join(options.workingFolder, 'plugins', `${pluginName}.js`),
             path.join(path.dirname(import.meta.url), 'plugins', 'render', `${pluginName.replace('render-', '')}.js`)
         ].filter(Boolean)
+
         for (let resolveLocation of resolveLocations) {
+            // Existence-check first: once we know the plugin file is there,
+            // any subsequent ERR_MODULE_NOT_FOUND is a *transitive* dep
+            // missing (e.g. plugin imports a package that isn't installed),
+            // not a "this plugin isn't here, try the next path" signal.
+            if (!existsSync(resolveLocation.replace(/^file:/, ''))) continue
             try {
                 return await import(resolveLocation)
             } catch (err) {
-                if (err.code != 'ERR_MODULE_NOT_FOUND') {
-                    logger.error('Redner plugin error:', resolveLocation, err)
-                    throw err
+                if (err.code === 'ERR_MODULE_NOT_FOUND') {
+                    logger.error('Render plugin %s found at %s but its dependencies are missing: %s', pluginName, resolveLocation, err.message)
+                } else {
+                    logger.error('Render plugin %s failed to load (%s): %s', pluginName, resolveLocation, err.message)
                 }
+                throw err
             }
         }
+
+        logger.error('Render plugin %s not found. Searched: %s', pluginName, resolveLocations.join(', '))
     }
 
     const { renderer } = options