node:buffer

The node:buffer module in Azion Runtime: the Buffer class for binary data, examples of encodings, concatenation, and request bodies, and the supported APIs.

Last updated

View as Markdown Agent setup

The node:buffer module provides Buffer, the Node.js class that holds raw binary data as a sequence of bytes. Use it to convert text between encodings such as hex and base64, to combine and slice binary data, and to read a request body or a stream as bytes. In Azion Runtime, Buffer is also a global: the global and the class you import from node:buffer are the same object, and every buffer is a Uint8Array.

Examples

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

Basic buffer operations

This function creates a buffer from a string, prints it in two encodings, and overwrites part of it:

JavaScript
01/**
02 * An example of using the Node.js Buffer API in an Azion Function.
03 * Support:
04 * - Partial support
05 * @module runtime-apis/nodejs/buffer/main
06 * @example
07 * // Build and run with the Azion CLI:
08 * azion build
09 * azion dev
10 */
11import { Buffer } from "node:buffer";
12
13/**
14 * Example of using the Node.js Buffer API
15 * Writes `string` to `buf` at `offset` according to the character encoding in `encoding`. The `length` parameter is the number of bytes to write. If `buf` did
16 * not contain enough space to fit the entire string, only part of `string` will be
17 * written. However, partially encoded characters will not be written.
18 * @param {*} event
19 * @returns {Promise<Response>}
20 */
21const main = async (event) => {
22 const helloBuffer = Buffer.from("Hello Edge!", "utf8");
23 console.log(helloBuffer.toString("hex"));
24 // 48656c6c6f204564676521
25 console.log(helloBuffer.toString("base64"));
26 // SGVsbG8gRWRnZSE=
27
28 helloBuffer.write("World", 6, 5, "utf8");
29 console.log(helloBuffer.toString());
30 // Hello World
31 return new Response(helloBuffer.toString(), { status: 200 });
32};
33export default main;

The function responds with the overwritten text:

Hello World

Buffer encoding conversions

This function converts one string to three encodings for data transmission, then decodes the base64 form back to text:

JavaScript
01import { Buffer } from "node:buffer";
02
03const main = async (event) => {
04 // Create buffer from string
05 const textBuffer = Buffer.from("Azion Runtime", "utf8");
06
07 // Convert to different encodings
08 const hexEncoded = textBuffer.toString("hex");
09 const base64Encoded = textBuffer.toString("base64");
10 const base64urlEncoded = textBuffer.toString("base64url");
11
12 console.log("Hex:", hexEncoded);
13 console.log("Base64:", base64Encoded);
14 console.log("Base64URL:", base64urlEncoded);
15
16 // Decode back from base64
17 const decoded = Buffer.from(base64Encoded, "base64").toString("utf8");
18 console.log("Decoded:", decoded);
19
20 // Create JSON response with all encodings
21 return new Response(JSON.stringify({
22 original: "Azion Runtime",
23 hex: hexEncoded,
24 base64: base64Encoded,
25 base64url: base64urlEncoded,
26 decoded: decoded
27 }), {
28 headers: { "Content-Type": "application/json" }
29 });
30};
31
32export default main;

The function responds with each encoding of the string:

{"original":"Azion Runtime","hex":"417a696f6e2052756e74696d65","base64":"QXppb24gUnVudGltZQ==","base64url":"QXppb24gUnVudGltZQ==","decoded":"Azion Runtime"}

In Azion Runtime, base64url output keeps the = padding, as the base64url value shows, and Buffer.isEncoding("base64url") returns false.

Buffer concatenation and slicing

This function combines three buffers into one, then extracts and copies a portion of the result:

JavaScript
01import { Buffer } from "node:buffer";
02
03const main = async (event) => {
04 // Create multiple buffers
05 const header = Buffer.from("HEADER:", "utf8");
06 const content = Buffer.from("Hello World", "utf8");
07 const footer = Buffer.from(":END", "utf8");
08
09 // Concatenate buffers
10 const combined = Buffer.concat([header, content, footer]);
11 console.log("Combined:", combined.toString());
12 // Combined: HEADER:Hello World:END
13
14 // Use subarray() to extract content (preferred over deprecated slice())
15 const contentOnly = combined.subarray(7, 18);
16 console.log("Extracted:", contentOnly.toString());
17 // Extracted: Hello World
18
19 // Get buffer length
20 console.log("Total length:", combined.length);
21 // Total length: 22
22
23 // Copy portion to another buffer
24 const copy = Buffer.alloc(11);
25 combined.copy(copy, 0, 7, 18);
26 console.log("Copied:", copy.toString());
27 // Copied: Hello World
28
29 return new Response(JSON.stringify({
30 combined: combined.toString(),
31 extracted: contentOnly.toString(),
32 copied: copy.toString()
33 }), {
34 headers: { "Content-Type": "application/json" }
35 });
36};
37
38export default main;

The function responds with the combined buffer and the two extracted portions:

{"combined":"HEADER:Hello World:END","extracted":"Hello World","copied":"Hello World"}

Binary data processing

This function reads the request body as a buffer, searches it for a byte sequence, and compares and allocates buffers:

JavaScript
01import { Buffer } from "node:buffer";
02
03const main = async (event) => {
04 // Get request body
05 const request = event.request;
06 const arrayBuffer = await request.arrayBuffer();
07
08 // Handle empty request body
09 if (!arrayBuffer.byteLength) {
10 return new Response(JSON.stringify({
11 error: "Empty request body",
12 length: 0
13 }), {
14 status: 400,
15 headers: { "Content-Type": "application/json" }
16 });
17 }
18
19 const dataBuffer = Buffer.from(arrayBuffer);
20
21 // Check buffer properties
22 console.log("Buffer length:", dataBuffer.length);
23 console.log("First byte:", dataBuffer[0]);
24
25 // Find byte sequence
26 const searchBuffer = Buffer.from("Azion", "utf8");
27 const index = dataBuffer.indexOf(searchBuffer);
28 console.log("Found 'Azion' at index:", index);
29
30 // Compare buffers
31 const buf1 = Buffer.from("test");
32 const buf2 = Buffer.from("test");
33 console.log("Buffers equal:", buf1.equals(buf2));
34
35 // Create buffer with specific size
36 const allocated = Buffer.alloc(256);
37 allocated.write("Allocated buffer example", 0, "utf8");
38 console.log("Allocated:", allocated.toString("utf8", 0, 24));
39
40 return new Response(JSON.stringify({
41 length: dataBuffer.length,
42 firstByte: dataBuffer[0],
43 foundAtIndex: index
44 }), {
45 headers: { "Content-Type": "application/json" }
46 });
47};
48
49export default main;

For a POST request whose body is Hello Azion Runtime, the function responds with the body length, its first byte, and the position of Azion:

{"length":19,"firstByte":72,"foundAtIndex":6}

JSON serialization with buffers

This function converts an object to a JSON buffer, uses the buffer size in the response, and sets Content-Length from it:

JavaScript
01import { Buffer } from "node:buffer";
02
03const main = async (event) => {
04 // Create object with data
05 const data = {
06 id: 12345,
07 name: "Azion Function",
08 timestamp: Date.now()
09 };
10
11 // Convert to JSON string and then to buffer
12 const jsonString = JSON.stringify(data);
13 const jsonBuffer = Buffer.from(jsonString, "utf8");
14
15 // Calculate size for headers
16 const contentLength = jsonBuffer.length;
17
18 // Convert back to object
19 const parsed = JSON.parse(jsonBuffer.toString("utf8"));
20
21 console.log("JSON buffer size:", contentLength, "bytes");
22 console.log("Parsed object:", parsed);
23
24 // Create response buffer with metadata
25 const responseData = {
26 ...parsed,
27 bufferSize: contentLength
28 };
29 const responseBuffer = Buffer.from(JSON.stringify(responseData), "utf8");
30
31 return new Response(responseBuffer, {
32 headers: {
33 "Content-Type": "application/json",
34 "Content-Length": responseBuffer.length.toString()
35 }
36 });
37};
38
39export default main;

The function responds with the object and its buffer size, with Content-Length set to 78:

{"id":12345,"name":"Azion Function","timestamp":1767268800000,"bufferSize":62}

Supported APIs

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

APIStatus
Buffer.alloc()🟢 Supported
Buffer.allocUnsafe()🟢 Supported
Buffer.byteLength()🟢 Supported
Buffer.compare()🟢 Supported
Buffer.concat()🟢 Supported
Buffer.from()🟢 Supported
Buffer.isBuffer()🟢 Supported
Buffer.isEncoding()🟢 Supported
buf.compare()🟢 Supported
buf.copy()🟢 Supported
buf.equals()🟢 Supported
buf.fill()🟢 Supported
buf.indexOf()🟢 Supported
buf.includes()🟢 Supported
buf.lastIndexOf()🟢 Supported
buf.length🟢 Supported
buf.readInt*()🟡 Partially supported
buf.subarray()🟢 Supported
buf.slice()🟡 Supported (deprecated, use subarray())
buf.toString()🟢 Supported
buf.write()🟢 Supported
buf.writeInt*()🟡 Partially supported
buffer.isAscii()🔴 Not supported
buffer.isUtf8()🔴 Not supported
buffer.resolveObjectURL()🔴 Not supported
buffer.transcode()🔴 Not supported

APIs marked 🟡 Partially supported have limited functionality compared to the full Node.js implementation. Among them, writeUInt32BE(), readUInt32BE(), writeInt16LE(), and readInt16LE() return the values written, and readBigUInt64BE() is available. The module-level functions buffer.isAscii(), buffer.isUtf8(), buffer.resolveObjectURL(), and buffer.transcode() are not supported. Node.js deprecates buf.slice() from v17.5.0; use buf.subarray() instead.

Node.js APIs

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

Use Node.js APIs through polyfills

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

Encoding

The Web API alternative for converting between text and bytes.

Node.js buffer documentation

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