Filesystem and Path

import { readFile, writeFile, mkdtemp } from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";
const dir = await mkdtemp(path.join(tmpdir(), "n-"));
const f = path.join(dir, "notes.txt");
await writeFile(f, "hi", "utf8");
await readFile(f, "utf8")  // "hi"

import { createReadStream } from "node:fs";
import { Readable } from "node:stream";
// createReadStream("big.log") for real files
const parts: string[] = [];
for await (const c of Readable.from(["a", "b"])) parts.push(String(c));
parts  // ["a", "b"]

import { mkdir, mkdtemp } from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";
const base = await mkdtemp(path.join(tmpdir(), "m-"));
const nested = path.join(base, "data", "cache");
await mkdir(nested, { recursive: true });
// nested now exists

import path from "node:path";
path.join("data", "a.json")     // "data/a.json"
path.isAbsolute(path.resolve("data", "a.json"))  // true

import { fileURLToPath } from "node:url";
const file = fileURLToPath(import.meta.url);
file.endsWith(".ts") || file.endsWith(".js")  // true

import { readdir, mkdtemp, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";
const dir = await mkdtemp(path.join(tmpdir(), "r-"));
await writeFile(path.join(dir, "a.txt"), "x");
const entries = await readdir(dir, { withFileTypes: true });
entries.map((e) => e.name)  // ["a.txt"]
entries[0].isFile()         // true

import { stat } from "node:fs/promises";
try {
  await stat("/no/such/file-xyz");
} catch (e: any) {
  e.code  // "ENOENT"
}

import { rm, mkdir, mkdtemp } from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";
const dir = await mkdtemp(path.join(tmpdir(), "rm-"));
await mkdir(path.join(dir, "sub"));
await rm(dir, { recursive: true, force: true });
// dir removed; no throw

import { copyFile, rename, writeFile, readFile, mkdtemp } from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";
const dir = await mkdtemp(path.join(tmpdir(), "c-"));
const a = path.join(dir, "a.txt");
const b = path.join(dir, "b.txt");
await writeFile(a, "1");
await copyFile(a, b);
await readFile(b, "utf8")  // "1"

import { mkdtemp } from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";
const dir = await mkdtemp(path.join(tmpdir(), "job-"));
dir.includes("job-")  // true

import { appendFile, readFile, mkdtemp } from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";
const f = path.join(await mkdtemp(path.join(tmpdir(), "l-")), "app.log");
await appendFile(f, "ok\n");
await readFile(f, "utf8")  // "ok\n"

import path from "node:path";
const p = path.parse("/tmp/a/b.txt");
p.base  // "b.txt"
p.name  // "b"
p.ext   // ".txt"
path.format({ dir: p.dir, name: p.name, ext: ".md" })
// "/tmp/a/b.md"

import { open, writeFile, mkdtemp } from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";
const f = path.join(await mkdtemp(path.join(tmpdir(), "h-")), "d.bin");
await writeFile(f, Buffer.from("abcd"));
const fh = await open(f, "r");
const { buffer, bytesRead } = await fh.read(Buffer.alloc(2), 0, 2, 0);
await fh.close();
bytesRead          // 2
buffer.toString()  // "ab"

import { watch } from "node:fs";
// const w = watch("config.json", () => reload());
// w.close() on shutdown
typeof watch  // "function"

import { access, constants, writeFile, mkdtemp } from "node:fs/promises";
import { tmpdir } from "node:os";
import path from "node:path";
const f = path.join(await mkdtemp(path.join(tmpdir(), "a-")), "p.txt");
await writeFile(f, "x");
await access(f, constants.R_OK);
// resolves if readable; throws if not