Async filters don't work if render callback is not used

[olegsmetanin]

"nunjucks": "^3.2.4",

Async filter

.addFilter('await', async function (value, cb) {
  const res = await new Promise((_resolve, _reject) => {
    _resolve(value)
  })
  cb(null, res)
}, true)

with template

{% asyncEach rec in ["qwe"] | await %}
{{ rec }}
{% endeach %}

doesn't work and renders nothing

[geleto]

This is how I do it:

.addFilter('await', function (promise: Promise<any>, callback: (err: Error | null, result?: any) => void) {
	promise.then(result => {
		callback(null, result);
	}).catch(err => {
		callback(err);
	});
}, true);

[olegsmetanin]

@geleto it doesn't work for any real async case, just try to send setTimeout promise with 0 delay to this filter. I expect the following filter will work and render "result":

.addFilter('await', function (_in: any, callback: (err: Error | null, result?: any) => void) {
	const promise = new Promise((resolve) => {
          setTimeout(() => {
            resolve('result')
          }, 0)
        });
        promise.then(result => {
		callback(null, result);
	}).catch(err => {
		callback(err);
	});
}, true);

[geleto]

Here are some example tests for real async cases:

import { expect } from 'chai';
import * as nunjucks from 'nunjucks';

describe('await filter tests', () => {

	let env: nunjucks.Environment;

	beforeEach(() => {
		env = new nunjucks.Environment();
		// Implement 'await' filter for resolving promises in templates
		env.addFilter('await', function (promise: Promise<any>, callback: (err: Error | null, result?: any) => void) {
			promise.then(result => {
				callback(null, result);
			}).catch(err => {
				callback(err);
			});
		}, true);
	});

	it('should handle custom async filter with global async function', (done) => {
		// Add global async function
		env.addGlobal('fetchUser', async (id: number) => {
			// Simulate async operation
			await new Promise(resolve => setTimeout(resolve, 10));
			return { id, name: `User ${id}` };
		});

		const template = '{% set user = fetchUser(123) | await %}Hello, {{ user.name }}!';

		env.renderString(template, {}, (err, result) => {
			if (err) return done(err);
			expect(result).to.equal('Hello, User 123!');
			done();
		});
	});

	it('should handle asyncEach with array of promises', (done) => {
		// Add global function to fetch records
		env.addGlobal('getRecords', () => {
			// Return an array of promises (each record is a promise)
			return [
				new Promise(resolve => setTimeout(() => resolve('Record 1'), 10)),
				new Promise(resolve => setTimeout(() => resolve('Record 2'), 20)),
				new Promise(resolve => setTimeout(() => resolve('Record 3'), 15))
			];
		});

		const template = `{%- set records = getRecords() -%}
		{%- asyncEach rec in records -%}
		{{ rec | await }}{% if not loop.last %}\n{% endif %}
		{%- endeach %}`;;

		env.renderString(template, {}, (err, result) => {
			if (err) return done(err);
			expect((result as string).trim()).to.equal('Record 1\nRecord 2\nRecord 3');
			done();
		});
	});
});

[olegsmetanin]

@geleto Thank you! It seems that we can't call renderString without callback if we have async filters

import { expect } from 'chai';
import * as nunjucks from 'nunjucks';

describe('await filter tests', () => {

	let env: nunjucks.Environment;

	beforeEach(() => {
		env = new nunjucks.Environment();

		env.addFilter('fetchUser', async (id: string, callback: (err: Error | null, result?: any) => void) => {
			// Simulate async operation
			const promise = new Promise(resolve => setTimeout(() => resolve(`User ${id}`), 10));
			promise.then(result => {
				callback(null, result);
			}).catch(err => {
				callback(err);
			});
		}, true);
	});

	it('should render using renderString without callback', () => {
		const template = '{% set user = "User 123" %}Hello, {{ user }}!';
		const result = env.renderString(template, {});
		expect(result).to.equal('Hello, User 123!');
	});

	it('should handle custom async filter using renderString with callback', (done) => {
		const template = '{% set user = "123" | fetchUser %}Hello, {{ user }}!';
		env.renderString(template, {}, (err, result) => {
			if (err) return done(err);
			expect(result).to.equal('Hello, User 123!');
			done();
		});
	});

	// Failed!
	it('should handle custom async filter using renderString without callback', () => {
		const template = '{% set user = "123" | fetchUser %}Hello, {{ user }}!';
		const result = env.renderString(template, {});
		expect(result).to.equal('Hello, User 123!');
	});

});


  await filter tests
    ✔ should render using renderString without callback
    ✔ should handle custom async filter using renderString with callback
    1) should handle custom async filter using renderString without callback


  2 passing (24ms)
  1 failing

  1) await filter tests
       should handle custom async filter using renderString without callback:
     AssertionError: expected null to equal 'Hello, User 123!'