mikser-io 6.9.3 → 6.12.0

package/package.json

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

package/src/api.js

@@ -5,7 +5,7 @@
 import { randomUUID } from 'node:crypto'
 import { writeFile, unlink, mkdir } from 'node:fs/promises'
 import path from 'node:path'
-import { updateEntity as defaultUpdateEntity } from './lifecycle.js'
+import './lifecycle.js' // side-effect: attaches runtime.create / update / delete
 
 /**
  * Bind to the runtime and return an on-demand renderer that pipelines
@@ -20,14 +20,10 @@ import { updateEntity as defaultUpdateEntity } from './lifecycle.js'
  *
  * @param {object} runtime                  - the mikser runtime singleton
  * @param {object} [opts]
- * @param {Function} [opts.updateEntity]    - override lifecycle.updateEntity (mostly for testing)
- * @param {number}   [opts.defaultTimeout]  - per-render timeout in ms (default 30_000)
+ * @param {number} [opts.defaultTimeout]    - per-render timeout in ms (default 30_000)
  * @returns {{ render: (entity, { timeout? }?) => Promise<{ output, entity }> }}
  */
-export function useRenderer(runtime, {
-    updateEntity = defaultUpdateEntity,
-    defaultTimeout = 30_000,
-} = {}) {
+export function useRenderer(runtime, { defaultTimeout = 30_000 } = {}) {
     let pending = []
     let cycleRunning = false
 
@@ -61,7 +57,7 @@ export function useRenderer(runtime, {
 
         try {
             for (const item of batch) {
-                await updateEntity(item.entity).catch(item.reject)
+                await runtime.update(item.entity).catch(item.reject)
             }
             await runtime.process()
         } catch (err) {
@@ -91,13 +87,21 @@ export function useRenderer(runtime, {
      * `runtime.process()` cycle — within that cycle, mikser's worker pool
      * renders the batch in parallel.
      *
+     * By default the entity is **not** kept in the catalog: after the
+     * render resolves, the catalog row is pruned so it doesn't accumulate.
+     * The rendered output file is always kept on disk — the bytes are the
+     * work product. Pass `catalog: true` to also keep the catalog row,
+     * useful if you'll re-render the same entity later or query it via
+     * `findEntities`.
+     *
      * @param {object} entity                - any entity-shaped object
      * @param {object} [opts]
-     * @param {number} [opts.timeout]        - override the default timeout
+     * @param {number}  [opts.timeout]       - override the default timeout
+     * @param {boolean} [opts.catalog=false] - keep the catalog row after render
      * @returns {Promise<{output, entity}>}
      */
-    function render(entity, { timeout = defaultTimeout } = {}) {
-        return new Promise((resolve, reject) => {
+    async function render(entity, { timeout = defaultTimeout, catalog = false } = {}) {
+        const result = await new Promise((resolve, reject) => {
             const correlationId = randomUUID()
             pending.push({
                 entity: { ...entity, _correlationId: correlationId },
@@ -109,6 +113,22 @@ export function useRenderer(runtime, {
             })
             if (!cycleRunning) setImmediate(runBatch)
         })
+
+        if (!catalog) {
+            // Prune the catalog row so it doesn't accumulate, but LEAVE
+            // the rendered output file on disk — the bytes are the work
+            // product. We deliberately bypass the journal/DELETE path
+            // here (which would also unlink the file via engine.js's
+            // manifest cleanup) and splice the entity out of the
+            // in-memory catalog directly.
+            const entities = runtime.catalog?.data?.entities
+            if (entities) {
+                const idx = entities.findIndex(e => e.id === result.entity.id)
+                if (idx >= 0) entities.splice(idx, 1)
+            }
+        }
+
+        return result
     }
 
     return { render }

package/src/journal.js

@@ -69,7 +69,13 @@ export async function* useJournal(name, operations, signal) {
 export async function clearJournal(aborted) {
     await journal('operations').del()
     if (!aborted) {
-        if (runtime.options.watch !== true) {
+        // Tear down the sqlite connection only when this is genuinely a
+        // one-shot run that's about to exit. Watch mode and any plugin
+        // that keeps the process alive (e.g. the API plugin's HTTP server)
+        // sets `persistent` so subsequent cycles can still write to the
+        // journal — without this, the second /render request would crash
+        // with "Unable to acquire a connection".
+        if (runtime.options.watch !== true && runtime.options.persistent !== true) {
             journal.destroy()
         }
     }

package/src/lifecycle.js

@@ -34,6 +34,15 @@ export async function updateEntity(entity) {
     }
 }
 
+// Expose the three entity operations as methods on the runtime so library
+// code (useRenderer, custom plugins) can call `runtime.update(entity)`
+// instead of importing and threading the standalone functions. The
+// imports above already pulled the runtime singleton into scope; this is
+// just a single assignment per name.
+runtime.create = createEntity
+runtime.update = updateEntity
+runtime.delete = deleteEntity
+
 export async function postprocessEntity(entity, options = {}, context = {}) {
     const logger = useLogger()
     const entry = { operation: OPERATION.POSTPROCESS, entity, options, context }

package/src/plugins/api.js

@@ -68,7 +68,6 @@ export default ({
     runtime,
     onLoaded,
     useLogger,
-    updateEntity,
     findEntities,
 }) => {
     onLoaded(async () => {
@@ -95,7 +94,6 @@ export default ({
         // library entry point and the Api endpoints share the exact same
         // batching/timeouts/error semantics.
         const { render } = useRenderer(runtime, {
-            updateEntity,
             defaultTimeout: runtime.config.api?.renderTimeout ?? 30_000,
         })
 
@@ -150,7 +148,13 @@ export default ({
 
         router.post('/render', auth, async (req, res) => {
             try {
-                const { output, entity } = await render(req.body)
+                // Pull `catalog` out as a control flag; everything else
+                // is treated as the entity. Default is NOT to keep the
+                // catalog row (the rendered output stays on disk either
+                // way). Send `catalog: true` to keep the row, e.g. if
+                // you'll re-render or query the entity later.
+                const { catalog, ...entityShape } = req.body
+                const { output, entity } = await render(entityShape, { catalog })
                 await sendRenderOutput(res, output, entity)
             } catch (err) {
                 logger.error('Api render error: %s', err.message)
@@ -160,6 +164,11 @@ export default ({
             }
         })
 
+        // The HTTP server keeps the process alive across many process()
+        // cycles. Tell the journal layer not to tear down the sqlite
+        // connection at the end of each cycle.
+        runtime.options.persistent = true
+
         const base = runtime.config.api?.base ?? '/api'
         app.use(base, router)
 

package/src/tracking.js

@@ -27,6 +27,7 @@ onInitialized(() => {
 })
 
 export function trackProgress(name, total) {
+    if (!name || !total) return
     const logger = useLogger()
     logger.debug('%s started: %d', name, total)
     progress.bar?.stop()
@@ -54,7 +55,7 @@ export function stopProgress() {
         logger.warn('%s unfinished: %d', name, total - value)
     } else {
         const time = Math.round((Date.now() - progress.stamp) / 1000)
-        logger.info('%s: %s', name, formatTime(time, { autopaddingChar: '' }))
+        logger.info('%s finished: %d %s', name, total, formatTime(time, { autopaddingChar: '' }))
     }
     progress = {}
 }