Node.js API compatibility - Path

/**
 * An example of using the Node.js Path API in an Azion Function.
 * Support:
 * - Partially supported (Extended by library `path-browserify`)
 * @module runtime-apis/nodejs/path/main
 * @example
 * // Execute with Azion Bundler:
 * npx edge-functions build
 * npx edge-functions dev
 */
import path from "node:path";

/**
 * An example of using the Node.js Path API in an Azion Function.
 * @param {*} event
 * @returns {Promise<Response>}
 */
const main = async (event) => {
  const pathName = path.join("/", "images", "image.jpg");
  console.log("Path", pathName);
  return new Response(`Path: ${pathName}`);
};

export default main;

import path from "node:path";

const main = async (event) => {
  const requestUrl = new URL(event.request.url);
  const pathname = requestUrl.pathname;

  // Extract path components
  const dirname = path.dirname(pathname);
  const basename = path.basename(pathname);
  const extname = path.extname(pathname);

  console.log("Directory:", dirname);
  console.log("Filename:", basename);
  console.log("Extension:", extname);

  // Build a new path for routing
  const apiPath = path.join("/api", "v1", "users", basename);
  console.log("API path:", apiPath);

  // Note: path.resolve() works for path string manipulation in edge runtimes,
  // but doesn't interact with an actual filesystem
  const absolutePath = path.resolve("/app", "public", "images", "logo.png");
  console.log("Absolute path:", absolutePath);

  return new Response(JSON.stringify({
    original: pathname,
    dirname,
    basename,
    extname,
    apiPath,
    absolutePath
  }), {
    headers: { "Content-Type": "application/json" }
  });
};

export default main;

import path from "node:path";

const main = async (event) => {
  // Normalize messy paths
  const messyPath = "/users/../public/./images//photo.jpg";
  const normalizedPath = path.normalize(messyPath);
  console.log("Normalized:", normalizedPath);
  // /public/images/photo.jpg

  // Parse path into components (using edge-runtime-neutral paths)
  const filePath = "/assets/css/styles.css";
  const parsed = path.parse(filePath);
  console.log("Parsed:", parsed);
  // { root: '/', dir: '/assets/css', base: 'styles.css', ext: '.css', name: 'styles' }

  // Format path from object
  const formatted = path.format({
    root: "/",
    dir: "/data/documents",
    base: "report.pdf"
  });
  console.log("Formatted:", formatted);

  // Check if path is absolute
  const isAbs1 = path.isAbsolute("/assets/app.js");
  const isAbs2 = path.isAbsolute("../relative/path");
  console.log("Is absolute:", isAbs1, isAbs2);

  return new Response(JSON.stringify({
    normalizedPath,
    parsed,
    formatted,
    isAbsolute: { absolute: isAbs1, relative: isAbs2 }
  }), {
    headers: { "Content-Type": "application/json" }
  });
};

export default main;

import path from "node:path";

const main = async (event) => {
  const request = event.request;
  const url = new URL(request.url);

  // Base directory for static files
  const staticBase = "/static";

  // Get requested file path
  const requestedPath = url.pathname.replace(/^\/static/, "");

  // Build full path
  const fullPath = path.join(staticBase, requestedPath);
  console.log("Full path:", fullPath);

  // Security: Validate that the resolved path stays within staticBase
  // This prevents path traversal attacks (e.g., /static/../sensitive/file)
  const resolvedPath = path.resolve(staticBase, requestedPath);
  if (!resolvedPath.startsWith(staticBase)) {
    return new Response("Forbidden", { status: 403 });
  }

  // Determine content type based on extension
  const ext = path.extname(fullPath).toLowerCase();
  const contentTypes = {
    ".html": "text/html",
    ".css": "text/css",
    ".js": "application/javascript",
    ".json": "application/json",
    ".png": "image/png",
    ".jpg": "image/jpeg",
    ".svg": "image/svg+xml"
  };

  const contentType = contentTypes[ext] || "application/octet-stream";
  console.log("Content-Type:", contentType);

  // Build relative path from current location
  const relativePath = path.relative("/static/images", fullPath);
  console.log("Relative path:", relativePath);

  return new Response(JSON.stringify({
    fullPath,
    resolvedPath,
    extension: ext,
    contentType,
    relativePath
  }), {
    headers: { "Content-Type": "application/json" }
  });
};

export default main;

import path from "node:path";

const main = async (event) => {
  // Default path methods (platform-specific)
  const defaultJoin = path.join("folder", "subfolder", "file.txt");
  const defaultSep = path.sep;

  // Force POSIX-style paths (forward slashes)
  // Note: path.posix and path.win32 are properties of the main module
  const posixJoin = path.posix.join("folder", "subfolder", "file.txt");
  const posixSep = path.posix.sep;

  // Force Windows-style paths (backslashes)
  const win32Join = path.win32.join("folder", "subfolder", "file.txt");
  const win32Sep = path.win32.sep;

  console.log("Default join:", defaultJoin);
  console.log("POSIX join:", posixJoin);
  console.log("Windows join:", win32Join);

  // Get delimiter for PATH environment variable
  const delimiter = path.delimiter;
  console.log("Path delimiter:", delimiter);

  return new Response(JSON.stringify({
    default: { join: defaultJoin, sep: defaultSep },
    posix: { join: posixJoin, sep: posixSep },
    win32: { join: win32Join, sep: win32Sep },
    delimiter
  }), {
    headers: { "Content-Type": "application/json" }
  });
};

export default main;