mikser-io-render-liquid 5.0.0 → 5.0.2

package/index.js

@@ -73,9 +73,29 @@ export async function render({ entity, runtime, state, track }) {
     // Expose every function on runtime as a Liquid filter, so render-
     // helper plugins (markdown, href, ...) keep working without per-
     // plugin glue.
+    //
+    // The filter body resolves the runtime from the per-render CONTEXT rather
+    // than closing over this render's. `engine` is module-level and
+    // registerFilter is a global mutation, so a closure means the last render
+    // to register owns the binding for every render still in flight — and
+    // renders are concurrent, and any `{% render %}` / `{% include %}` is an
+    // await point that guarantees the overlap.
+    //
+    // What that produced: a page resolved `asset` against a DIFFERENT page's
+    // entity, so the relative url was computed from someone else's depth. It
+    // is well-formed and points at nothing, the build is green, and the value
+    // changes between builds because it follows render order. Every
+    // entity-dependent helper was affected the same way, not just asset —
+    // href and resource compute from entity.destination too.
     for (let key in runtime) {
         if (typeof runtime[key] === 'function') {
-            engine.registerFilter(key, (input, ...args) => runtime[key](input, ...args))
+            engine.registerFilter(key, (input, ...args) => {
+                // Falls back to the captured runtime only for a call with no
+                // context — runtime.liquid is public and can be invoked
+                // outside a render.
+                const active = renderContext.getStore()?.runtime ?? runtime
+                return active[key](input, ...args)
+            })
         }
     }
     const source = entity.layout.content ?? ''
@@ -86,7 +106,7 @@ export async function render({ entity, runtime, state, track }) {
         // the async chain and reports the resolved name to the
         // engine's track via the wrapped methods above.
         return await renderContext.run(
-            { track, layouts },
+            { track, layouts, runtime },
             () => runtime.liquid(source, runtime),
         )
     } catch (err) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mikser-io-render-liquid",
-  "version": "5.0.0",
-  "description": "",
+  "version": "5.0.2",
+  "description": "LiquidJS renderer for Mikser. Renders entities whose layout uses the `.liquid` template engine.",
   "main": "index.js",
   "type": "module",
   "scripts": {

package/test/concurrent-filters.test.js

@@ -0,0 +1,81 @@
+// Filters must resolve against the runtime of the render that is CALLING them,
+// not the one that registered them last.
+//
+// The engine is module-level and registerFilter is a global mutation, so when
+// each render re-registered every runtime function as a filter, the last
+// render to start owned the binding for every render still in flight. Renders
+// are concurrent, and `{% render %}` / `{% include %}` reads a partial from
+// disk — an await point that guarantees the overlap.
+//
+// The symptom in production was an `asset` url computed from a DIFFERENT
+// page's entity: a relative prefix with the wrong number of `..` for the page
+// it was emitted on. Well-formed, pointing at nothing, green build, and
+// unstable between builds because it followed render order. `href` and
+// `resource` compute from entity.destination too, so all of them were exposed.
+
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtemp, writeFile, mkdir, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+
+import { load, render } from '../index.js'
+
+let layoutsFolder
+
+// A runtime whose `mark` filter answers with this render's own identity —
+// standing in for asset()/href(), which answer from this render's entity.
+function makeRuntime(id) {
+    const runtime = { mark: () => id }
+    load({ runtime, options: { layoutsFolder }, config: {} })
+    return runtime
+}
+
+const entityFor = (body) => ({
+    id: `/documents/${body}.yml`,
+    layout: { uri: 'page.liquid', content: body },
+})
+
+const renderWith = (runtime, body) =>
+    render({ entity: entityFor(body), runtime, state: {}, track: {} })
+
+describe('concurrent renders do not steal each other filters', () => {
+    before(async () => {
+        layoutsFolder = await mkdtemp(path.join(tmpdir(), 'liquid-concurrent-'))
+        await mkdir(path.join(layoutsFolder, 'ui'), { recursive: true })
+        // The partial is the point: reading it from disk is the await during
+        // which another render can register over this one's filters.
+        await writeFile(path.join(layoutsFolder, 'ui', 'mark.liquid'), "{{ '' | mark }}")
+    })
+    after(() => rm(layoutsFolder, { recursive: true, force: true }))
+
+    it('each render sees its own runtime through a partial', async () => {
+        const a = makeRuntime('A')
+        const b = makeRuntime('B')
+
+        // Both in flight at once. A registers, hits the partial read, and B
+        // registers while A is suspended — the exact interleaving that was
+        // silently producing another page's answer.
+        const [outA, outB] = await Promise.all([
+            renderWith(a, "{% render 'ui/mark' %}"),
+            renderWith(b, "{% render 'ui/mark' %}"),
+        ])
+
+        assert.equal(outA, 'A', 'render A resolved a filter against another render\'s runtime')
+        assert.equal(outB, 'B', 'render B resolved a filter against another render\'s runtime')
+    })
+
+    it('holds with many overlapping renders', async () => {
+        const ids = Array.from({ length: 12 }, (_, i) => `R${i}`)
+        const outputs = await Promise.all(
+            ids.map(id => renderWith(makeRuntime(id), "{% render 'ui/mark' %}")),
+        )
+        assert.deepEqual(outputs, ids,
+            'every render must answer with its own identity, whatever the interleaving')
+    })
+
+    it('still works with no partial, where nothing suspends', async () => {
+        const a = makeRuntime('A')
+        assert.equal(await renderWith(a, "{{ '' | mark }}"), 'A')
+    })
+})