feat: async operations

Author: learosema

src/builtin-filters.js

@@ -100,3 +100,8 @@ export function htmlentities(str) {
 export function urlencode(str) {
   return encodeURIComponent(str);
 }
+
+export async function async(asyncInput) {
+  const result = await asyncInput;
+  return (typeof result === 'function') ? result() : result;
+}

src/transforms/template-data.js

@@ -3,6 +3,7 @@ import vm from 'node:vm';
 import { frontmatter } from './frontmatter.js';
 import { resolve } from '../resolver.js';
 import { SissiConfig } from "../sissi-config.js";
+import { replaceAsync } from '../utils/replace-async.js';
 
 const TEMPLATE_REGEX = /\{\{\s*(.+?)\s*\}\}/g;
 
@@ -47,16 +48,16 @@ export function parseFilterExpression(expr, ctx) {
  * Poor girl's handlebars
  * 
  * @param {string} str the template content
- * @returns {(data: any, filters: Map<string, function>) => string} a function that takes a data object and returns the processed template
+ * @returns {Promise<(data: any, filters: Map<string, function>) => string>} a function that takes a data object and returns the processed template
  */
 export function template(str) {
   const defaultFilters = new Map();
   let isSafe = false;
   defaultFilters.set('safe', (input) => { isSafe = true; return input; })
-  return (data, providedFilters) => {
+  return async (data, providedFilters) => {
     const context = vm.createContext({...data});
     const filters = mergeMaps(defaultFilters || new Map(), providedFilters || new Map())
-    return str.replace(TEMPLATE_REGEX, (_, templateString) => {
+    return replaceAsync(str, TEMPLATE_REGEX, async (_, templateString) => {
       const expressions = templateString.split('|').map(e => e.trim());
       const mainExpression = expressions[0];
       const filterExpressions = expressions.slice(1);
@@ -76,8 +77,14 @@ export function template(str) {
         }
 
         result = args ? filters.get(filter)(result, ...args) : filters.get(filter)(result);
+        if (result instanceof Promise) {
+          result = await result;
+        }
       }
 
+      if (result instanceof Promise) {
+        result = await result;
+      }
       return isSafe ? result : htmlEscape(result);
     });
   }
@@ -125,16 +132,15 @@ export async function handleTemplateFile(config, data, inputFile) {
 
 
   const { data: matterData, body } = frontmatter(content);
-  const fileData = Object.assign({}, structuredClone(data), matterData);
-  if (fileData.page && typeof fileData.page === 'object') {
-    Object.assign(fileData.page, page); 
-  } else {
+  const fileData = Object.assign({}, data, matterData);
+
+  if (! fileData.page) {
     fileData.page = page;
   }
 
   const processor = await plugin.compile(body, inputFile);
 
-  let fileContent = template(await processor(fileData))(fileData, config.filters);
+  let fileContent = await (template(await processor(fileData))(fileData, config.filters));
 
   if (fileData.layout) {
     const layoutFilePath = path.normalize(path.join(config.dir.layouts, fileData.layout));

src/utils/replace-async.js

@@ -0,0 +1,7 @@
+export async function replaceAsync(string, regexp, replacerFunction) {
+  const replacements = await Promise.all(
+      Array.from(string.matchAll(regexp),
+          match => replacerFunction(...match)));
+  let i = 0;
+  return string.replace(regexp, () => replacements[i++]);
+}

tests/transforms/template-data.test.js

@@ -7,6 +7,7 @@ import { createContext } from 'node:vm';
 import { handleTemplateFile, parseFilterExpression, template } from '../../src/transforms/template-data.js';
 import { SissiConfig } from '../../src/sissi-config.js';
 import md from '../../src/md.js';
+import * as builtinFilters from '../../src/builtin-filters.js';
 
 const TEST_DATA = {
   'title': 'This is a title',
@@ -71,56 +72,65 @@ describe('parseFilterExpression function', () => {
 });
 
 describe('template function', () => {
-  it('should insert data into the placeholders wrapped in double curly brackets', () => {
-    assert.equal(template(TEST_TEMPLATE)(TEST_DATA), TEST_TEMPLATE_EXPECTED);
+  it('should insert data into the placeholders wrapped in double curly brackets', async () => {
+    assert.equal(await template(TEST_TEMPLATE)(TEST_DATA), TEST_TEMPLATE_EXPECTED);
   });
 
-  it('should be able to invoke functions', () => {
-    assert.equal(template(TEST_TEMPLATE_2)(TEST_DATA), TEST_TEMPLATE_EXPECTED_2);
-    assert.equal(template(TEST_TEMPLATE_3)(TEST_DATA), TEST_TEMPLATE_EXPECTED_3);
+  it('should be able to invoke functions', async () => {
+    assert.equal(await template(TEST_TEMPLATE_2)(TEST_DATA), TEST_TEMPLATE_EXPECTED_2);
+    assert.equal(await template(TEST_TEMPLATE_3)(TEST_DATA), TEST_TEMPLATE_EXPECTED_3);
   });
 
-  it('should be able to apply a filter', () => {
+  it('should be able to apply a filter', async () => {
     const filters = new Map();
     filters.set('shout', (str) => (str||'').toUpperCase());
-    const result = template('{{greeting | shout }}')({greeting: "Hello"}, filters);
+    const result = await template('{{greeting | shout }}')({greeting: "Hello"}, filters);
 
     assert.equal(result, "HELLO");
   });
 
-  it('should escape angle brackets and ampersands by default', () => {
-    const result = template('{{ content }}')({content: '<h1>Hello</h1>'});
+  it('should escape angle brackets and ampersands by default', async () => {
+    const result = await template('{{ content }}')({content: '<h1>Hello</h1>'});
 
     assert.equal(result, '&lt;h1&gt;Hello&lt;/h1&gt;')
   });
 
-  it('should not escape angle brackets and ampersands when marked safe', () => {
-    const result = template('{{ content | safe }}')({content: '<h1>Hello</h1>'});
+  it('should not escape angle brackets and ampersands when marked safe', async () => {
+    const result = await template('{{ content | safe }}')({content: '<h1>Hello</h1>'});
 
     assert.equal(result, '<h1>Hello</h1>')
   });
 
-  it('should be able to apply a filter with additional parameters', () => {
+  it('should be able to apply a filter with additional parameters', async () => {
     const data = { greeting: 'Hello Lea' }
     const filters = new Map();
     filters.set('piratify', (str, prefix = 'Yo-ho-ho', suffix = 'yarrr') => `${prefix}! ${str}, ${suffix}!`);
 
-    assert.equal(template('{{ greeting | piratify }}')(data, filters), 'Yo-ho-ho! Hello Lea, yarrr!');
-    assert.equal(template('{{ greeting | piratify: "AYE" }}')(data, filters), 'AYE! Hello Lea, yarrr!');
-    assert.equal(template('{{ greeting | piratify: "Ahoy", "matey" }}')(data, filters), 'Ahoy! Hello Lea, matey!');
+    assert.equal(await template('{{ greeting | piratify }}')(data, filters), 'Yo-ho-ho! Hello Lea, yarrr!');
+    assert.equal(await template('{{ greeting | piratify: "AYE" }}')(data, filters), 'AYE! Hello Lea, yarrr!');
+    assert.equal(await template('{{ greeting | piratify: "Ahoy", "matey" }}')(data, filters), 'Ahoy! Hello Lea, matey!');
   });
 
-  it('should be able to chain filters', () => {
+  it('should be able to chain filters', async () => {
     const filters = new Map();
     filters.set('shout', (str) => (str||'').toUpperCase());
     filters.set('piratify', (str, prefix = 'Yo-ho-ho', suffix = 'yarrr') => `${prefix}! ${str}, ${suffix}!`);
 
     const data = { greeting: 'Hello Lea' };
-    assert.equal(template('{{ greeting | piratify | shout }}')(data, filters), 'YO-HO-HO! HELLO LEA, YARRR!');
+    assert.equal(await template('{{ greeting | piratify | shout }}')(data, filters), 'YO-HO-HO! HELLO LEA, YARRR!');
 
     // order matters
-    assert.equal(template('{{ greeting | shout | piratify }}')(data, filters), 'Yo-ho-ho! HELLO LEA, yarrr!');
+    assert.equal(await template('{{ greeting | shout | piratify }}')(data, filters), 'Yo-ho-ho! HELLO LEA, yarrr!');
   });
+
+  it('should be able to do async operations', async () => {
+    const filters = new Map();
+    filters.set('async', builtinFilters.async);
+    const data = { answer: () => Promise.resolve(42) };
+
+    assert.equal(await (template('{{ answer | async }}')(data, filters)), '42');
+  });
+
 });
 
 describe('handleTemplateFile function', () => {

tests/utils/replace-async.test.js

@@ -0,0 +1,37 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { replaceAsync } from '../../src/utils/replace-async.js';
+
+describe('replaceAsync', () => {
+
+  it('should do nothing when there is no match', async () => {
+    const testString = 'There is no planet B.';
+
+    const result = await replaceAsync(testString, /\{\}/g, () => {
+      return Promise.reject('this should not happen');
+    });
+
+    assert.equal(result, testString);
+  });
+
+  it('should reject when an inner result rejects', async () => {
+    const testString = 'Crash {}';
+    
+    await assert.rejects(async () => {
+      await replaceAsync(testString, /\{\}/g, () => Promise.reject(new Error('boom')));
+    }, {
+      message: 'boom'
+    });
+  });
+
+  it('should be able to process asynchronous replacements', async () => {
+    const replacements = ['life', 'universe', 'rest', '42'];
+    
+    const result = await replaceAsync('The answer to {0}, {1} and the {2} is {3}.', /\{(\d+)\}/g, (_, x) => {
+      const idx = (x|0);
+      return Promise.resolve(replacements[idx]);
+    });
+    assert.equal(result, 'The answer to life, universe and the rest is 42.');
+  });
+
+});