node:util

The node:util module in Azion Runtime: helpers to promisify callbacks, inspect objects, format strings, and check types, with examples and the supported APIs.

Last updated

View as Markdown Agent setup

The node:util module groups the Node.js helper functions for common data tasks: formatting strings, inspecting objects for debugging, converting callback-style functions to promises, and checking value types at run time. Azion Runtime supports the module through Node.js compatibility. Inside a function, use util.promisify() to adapt callback-based code to async/await, and util.inspect() to log structured data.

Examples

Each example is a complete function that imports util from node:util. The response below each example is the one a deployed function returns.

Promisify and inspect

This function converts a callback-style function to a promise, awaits it, and logs the result with util.inspect():

JavaScript
01/**
02 * An example of using Node.js Util API in an Azion Function.
03 * Support:
04 * - Partially supported (Extended by library `util`)
05 * @module runtime-apis/nodejs/util/main
06 * @example
07 * // Build and run with the Azion CLI:
08 * azion build
09 * azion dev
10 */
11import util from "node:util";
12
13const myTest = (callback) => {
14 try {
15 callback(null, "Success!");
16 } catch (err) {
17 callback(err);
18 }
19};
20
21/**
22 * An example of using the Node.js Util API in an Azion Function.
23 * @param {*} event
24 * @returns {Promise<Response>}
25 */
26const main = async (event) => {
27 const promisifyTest = util.promisify(myTest);
28 const result = await promisifyTest();
29 console.log(util.inspect(result, { showHidden: false, depth: null }));
30
31 return new Response("Done!", { status: 200 });
32};
33
34export default main;

The function logs "Success!" and responds with:

Done!

Callback to promise conversion

This function wraps a callback-based API with util.promisify() and calls it twice with await:

JavaScript
01import util from "node:util";
02import { setTimeout } from "node:timers";
03
04// Simulate a callback-based API
05const fetchData = (id, callback) => {
06 setTimeout(() => {
07 if (id > 0) {
08 callback(null, { id, data: `Item ${id}`, timestamp: Date.now() });
09 } else {
10 callback(new Error("Invalid ID"));
11 }
12 }, 100);
13};
14
15// Convert to promise-based
16const fetchDataAsync = util.promisify(fetchData);
17
18const main = async (event) => {
19 try {
20 // Now can use with async/await
21 const result1 = await fetchDataAsync(1);
22 const result2 = await fetchDataAsync(2);
23
24 console.log("Result 1:", result1);
25 console.log("Result 2:", result2);
26
27 return new Response(JSON.stringify({ results: [result1, result2] }), {
28 headers: { "Content-Type": "application/json" }
29 });
30 } catch (error) {
31 console.error("Error:", error.message);
32 return new Response(JSON.stringify({ error: error.message }), {
33 status: 400,
34 headers: { "Content-Type": "application/json" }
35 });
36 }
37};
38
39export default main;

The function responds with both results:

{"results":[{"id":1,"data":"Item 1","timestamp":1767268800000},{"id":2,"data":"Item 2","timestamp":1767268800000}]}

The two timestamps are equal because, in a deployed function, Date.now() does not advance during a request.

Deep object inspection

This function inspects request details and a nested object, and builds a string with util.format():

JavaScript
01import util from "node:util";
02
03const main = async (event) => {
04 // Complex object to inspect
05 const requestInfo = {
06 url: event.request.url,
07 method: event.request.method,
08 headers: Object.fromEntries(event.request.headers),
09 timestamp: new Date().toISOString()
10 };
11
12 // Nested object
13 const complexData = {
14 level1: {
15 level2: {
16 level3: {
17 value: "deep",
18 array: [1, 2, { nested: true }]
19 }
20 }
21 }
22 };
23
24 // Inspect with options
25 const inspected = util.inspect(requestInfo, {
26 depth: null, // Unlimited depth
27 colors: false, // Explicitly disabled since output goes into JSON response
28 compact: false, // Multi-line output
29 showHidden: false, // Don't show non-enumerable
30 maxArrayLength: 10 // Limit array display
31 });
32
33 console.log("Request info:", inspected);
34
35 // Format string with placeholders
36 const formatted = util.format(
37 "Request %s to %s at %s",
38 requestInfo.method,
39 requestInfo.url,
40 requestInfo.timestamp
41 );
42 console.log(formatted);
43
44 return new Response(JSON.stringify({
45 requestInfo,
46 formatted,
47 inspectedDepth: util.inspect(complexData, { depth: 2 })
48 }), {
49 headers: { "Content-Type": "application/json" }
50 });
51};
52
53export default main;

For a GET request to https://example.com/, the function responds with the request details, the formatted string, and the inspected object:

{"requestInfo":{"url":"https://example.com/","method":"GET","headers":{"accept":"*/*","cdn-loop":"azion.com; steps=1","host":"example.com","user-agent":"curl/8.7.1","x-forwarded-for":"192.0.2.10","x-forwarded-source-port":"6109"},"timestamp":"2026-01-01T12:00:00.000Z"},"formatted":"Request GET to https://example.com/ at 2026-01-01T12:00:00.000Z","inspectedDepth":"{\n \"level1\": {\n \"level2\": {\n \"level3\": {\n \"value\": \"deep\",\n \"array\": [\n 1,\n 2,\n {\n \"nested\": true\n }\n ]\n }\n }\n }\n}"}

In Azion Runtime, util.inspect() prints complexData as indented JSON text with every level expanded, although the call passes depth: 2.

String formatting and deprecation

This function formats strings with placeholders, marks a function as deprecated with util.deprecate(), and calls it:

JavaScript
01import util from "node:util";
02
03// Mark a function as deprecated
04const oldFunction = util.deprecate(
05 () => "This is the old function",
06 "oldFunction is deprecated. Use newFunction instead."
07);
08
09const newFunction = () => "This is the new function";
10
11const main = async (event) => {
12 const results = [];
13
14 // String formatting with %s, %d, %j, %%
15 results.push(util.format("Hello %s!", "World"));
16 results.push(util.format("Number: %d, String: %s", 42, "test"));
17 results.push(util.format("JSON: %j", { key: "value" }));
18 results.push(util.format("Percent: %%"));
19
20 // Style strings (for console output)
21 // Note: ANSI codes are only meaningful in terminal output
22 // They will appear as escape sequences in HTTP responses
23 const styled = util.format(
24 "%s %s %s",
25 "\x1b[31mRed\x1b[0m",
26 "\x1b[32mGreen\x1b[0m",
27 "\x1b[34mBlue\x1b[0m"
28 );
29 console.log(styled); // Useful in logs only
30
31 // Call the deprecated function and its replacement
32 const oldResult = oldFunction();
33 const newResult = newFunction();
34
35 // Get object's own property names
36 const obj = { a: 1, b: 2, c: 3 };
37 const keys = Object.keys(obj);
38
39 return new Response(JSON.stringify({
40 formattedStrings: results,
41 oldFunctionResult: oldResult,
42 newFunctionResult: newResult,
43 objectKeys: keys
44 // Note: styled string not included - ANSI codes not useful in JSON
45 }), {
46 headers: { "Content-Type": "application/json" }
47 });
48};
49
50export default main;

The function responds with the formatted strings and the result of each function:

{"formattedStrings":["Hello World!","Number: 42, String: test","JSON: {\"key\":\"value\"}","Percent: %"],"oldFunctionResult":"This is the old function","newFunctionResult":"This is the new function","objectKeys":["a","b","c"]}

The %s, %d, %j, and %% placeholders work as the example shows. The %i placeholder is not replaced: util.format() leaves %i in the output as written.

Supported APIs

The table lists the status of each node:util API in Azion Runtime:

APIStatus
util.promisify()🟢 Supported
util.inspect()🟢 Supported
util.format()🟢 Supported
util.deprecate()🟢 Supported
util.isDeepStrictEqual()🟢 Supported
util.inherits()🟡 Deprecated (use ES6 classes)
util.callbackify()🟡 Partially supported
util.formatWithOptions()🟡 Partially supported
util.getSystemErrorMap()🟡 Partially supported
util.getSystemErrorName()🟡 Partially supported
util.log()🟡 Partially supported
util.stripVTControlCharacters()🟡 Partially supported
util.styleText()🟡 Partially supported
util.types.isDate()🟢 Supported
util.types.isRegExp()🟢 Supported
util.types.isPromise()🟢 Supported
util.types.isArrayBuffer()🟢 Supported
util.types.isNativeError()🔴 Not supported
util.types.isTypedArray()🟢 Supported
util.types.isMap()🟢 Supported
util.types.isSet()🟢 Supported
util.types.isCryptoKey()🟢 Supported
util.types.isKeyObject()🟢 Supported

APIs marked 🟡 Partially supported have limited functionality compared to the full Node.js implementation.

util.types checks a value’s type at run time, as an alternative to instanceof. util.types.isDate(), util.types.isPromise(), and util.types.isRegExp() return true for a matching value. util.types.isNativeError() throws Error: [unenv] util.types.isNativeError is not implemented yet! in a deployed function and under azion dev.

Node.js deprecates util.inherits() from v5.0.0; use class syntax with extends instead. In Azion Runtime, EventEmitter from node:events is a class, so a constructor function that calls EventEmitter.call(this) to inherit from it throws TypeError: Class constructor e cannot be invoked without 'new'.

Node.js APIs

The status of every Node.js module in Azion Runtime, util included.

Use Node.js APIs through polyfills

How the build turns node: imports into code that runs in Azion Runtime.

node:events

The EventEmitter class to extend with class syntax instead of util.inherits().

Node.js util documentation

The full Node.js reference for every node:util API in the table.