node:path

The node:path module in Azion Runtime: functions that join, parse, and normalize path strings, examples for routing and parsing, and the supported APIs.

Last updated

View as Markdown Agent setup

The node:path module provides the Node.js utilities for working with file and directory paths. Its functions join, split, normalize, and parse paths, and a function uses them to build paths when it routes requests or composes asset references. Azion Runtime does not give a function access to a real filesystem, so every path function operates on path strings only. For example, path.resolve() returns a string without reading a directory.

Examples

The functions below run on their own: each one imports path from node:path, and each output is the one a deployed function returns.

Basic path operations

This function joins three segments into one path, logs it, and returns it in the response body:

JavaScript
01/**
02 * An example of using the Node.js Path API in an Azion Function.
03 * Support:
04 * - Partially supported (Extended by library `path-browserify`)
05 * @module runtime-apis/nodejs/path/main
06 * @example
07 * // Build and run with the Azion CLI:
08 * azion build
09 * azion dev
10 */
11import path from "node:path";
12
13/**
14 * An example of using the Node.js Path API in an Azion Function.
15 * @param {*} event
16 * @returns {Promise<Response>}
17 */
18const main = async (event) => {
19 const pathName = path.join("/", "images", "image.jpg");
20 console.log("Path", pathName);
21 return new Response(`Path: ${pathName}`);
22};
23
24export default main;

The function logs Path /images/image.jpg and responds with this body:

Path: /images/image.jpg

URL routing with path

This function splits the request path into its directory, file name, and extension, then builds an API path and an absolute path from the parts:

JavaScript
01import path from "node:path";
02
03const main = async (event) => {
04 const requestUrl = new URL(event.request.url);
05 const pathname = requestUrl.pathname;
06
07 // Extract path components
08 const dirname = path.dirname(pathname);
09 const basename = path.basename(pathname);
10 const extname = path.extname(pathname);
11
12 console.log("Directory:", dirname);
13 console.log("Filename:", basename);
14 console.log("Extension:", extname);
15
16 // Build a new path for routing
17 const apiPath = path.join("/api", "v1", "users", basename);
18 console.log("API path:", apiPath);
19
20 // In Azion Runtime, path.resolve() manipulates path strings only;
21 // it does not read a filesystem
22 const absolutePath = path.resolve("/app", "public", "images", "logo.png");
23 console.log("Absolute path:", absolutePath);
24
25 return new Response(JSON.stringify({
26 original: pathname,
27 dirname,
28 basename,
29 extname,
30 apiPath,
31 absolutePath
32 }), {
33 headers: { "Content-Type": "application/json" }
34 });
35};
36
37export default main;

For a request to /docs/getting-started, a path with no file extension, the function responds with each part of the path and the two paths it built:

{"original":"/docs/getting-started","dirname":"/docs","basename":"getting-started","extname":"","apiPath":"/api/v1/users/getting-started","absolutePath":"/app/public/images/logo.png"}

Path normalization and parsing

This function normalizes a path that holds .., ., and a double slash. It then parses a path into its parts, builds a path from an object, and checks whether two paths are absolute:

JavaScript
01import path from "node:path";
02
03const main = async (event) => {
04 // Normalize messy paths
05 const messyPath = "/users/../public/./images//photo.jpg";
06 const normalizedPath = path.normalize(messyPath);
07 console.log("Normalized:", normalizedPath);
08 // /public/images/photo.jpg
09
10 // Parse path into components
11 const filePath = "/assets/css/styles.css";
12 const parsed = path.parse(filePath);
13 console.log("Parsed:", parsed);
14 // { root: '/', dir: '/assets/css', base: 'styles.css', ext: '.css', name: 'styles' }
15
16 // Format path from object
17 const formatted = path.format({
18 root: "/",
19 dir: "/data/documents",
20 base: "report.pdf"
21 });
22 console.log("Formatted:", formatted);
23
24 // Check if path is absolute
25 const isAbs1 = path.isAbsolute("/assets/app.js");
26 const isAbs2 = path.isAbsolute("../relative/path");
27 console.log("Is absolute:", isAbs1, isAbs2);
28
29 return new Response(JSON.stringify({
30 normalizedPath,
31 parsed,
32 formatted,
33 isAbsolute: { absolute: isAbs1, relative: isAbs2 }
34 }), {
35 headers: { "Content-Type": "application/json" }
36 });
37};
38
39export default main;

The function responds with the normalized path, the parsed parts, the formatted path, and the two checks:

{"normalizedPath":"/public/images/photo.jpg","parsed":{"root":"/","dir":"/assets/css","base":"styles.css","ext":".css","name":"styles"},"formatted":"/data/documents/report.pdf","isAbsolute":{"absolute":true,"relative":false}}

Path separators and platform variants

This function joins the same segments with the default, POSIX, and Windows variants of the module, and reads each separator and the delimiter:

JavaScript
01import path from "node:path";
02
03const main = async (event) => {
04 // Default path methods (POSIX rules in Azion Runtime)
05 const defaultJoin = path.join("folder", "subfolder", "file.txt");
06 const defaultSep = path.sep;
07
08 // POSIX-style paths (forward slashes)
09 // path.posix and path.win32 are properties of the main module
10 const posixJoin = path.posix.join("folder", "subfolder", "file.txt");
11 const posixSep = path.posix.sep;
12
13 // Windows-style methods: in Azion Runtime, they also use forward slashes
14 const win32Join = path.win32.join("folder", "subfolder", "file.txt");
15 const win32Sep = path.win32.sep;
16
17 console.log("Default join:", defaultJoin);
18 console.log("POSIX join:", posixJoin);
19 console.log("Windows join:", win32Join);
20
21 // Get delimiter for PATH environment variable
22 const delimiter = path.delimiter;
23 console.log("Path delimiter:", delimiter);
24
25 return new Response(JSON.stringify({
26 default: { join: defaultJoin, sep: defaultSep },
27 posix: { join: posixJoin, sep: posixSep },
28 win32: { join: win32Join, sep: win32Sep },
29 delimiter
30 }), {
31 headers: { "Content-Type": "application/json" }
32 });
33};
34
35export default main;

The function responds with the same joined path and the / separator for all three variants, and : as the delimiter:

{"default":{"join":"folder/subfolder/file.txt","sep":"/"},"posix":{"join":"folder/subfolder/file.txt","sep":"/"},"win32":{"join":"folder/subfolder/file.txt","sep":"/"},"delimiter":":"}

Supported APIs

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

APIStatus
path.basename()🟢 Supported
path.dirname()🟢 Supported
path.extname()🟢 Supported
path.format()🟢 Supported
path.isAbsolute()🟢 Supported
path.join()🟢 Supported
path.normalize()🟢 Supported
path.parse()🟢 Supported
path.relative()🟢 Supported
path.resolve()🟢 Supported
path.sep🟢 Supported
path.delimiter🟢 Supported
path.posix🟢 Supported
path.win32🟡 Partially supported

path.win32.join() joins segments with /, so path.win32.join("C:\\a", "b") returns C:/a/b, and path.win32.sep is /.

Every path function operates on path strings, without filesystem access. path.resolve() resolves relative segments against /, so path.resolve("a", "b") returns /a/b. To work with the path of a request, read it with the Web URL API, as in new URL(event.request.url).pathname, and pass it to the node:path functions.

Node.js APIs

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

Use Node.js APIs through polyfills

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

node:url

The Node.js module that parses and formats the URLs whose paths node:path handles.

Node.js path documentation

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