import * as NodeFileSystem from "@effect/platform-node-shared/NodeFileSystem"
import { assert, describe, it } from "@effect/vitest"
import * as ByteSize from "effect/ByteSize"
import * as Deferred from "effect/Deferred"
import * as Effect from "effect/Effect"
import * as Fiber from "effect/Fiber"
import * as FileSystem from "effect/FileSystem"
import * as Layer from "effect/Layer"
import * as Option from "effect/Option"
import * as Stream from "effect/Stream"
import * as TestClock from "effect/testing/TestClock"
import * as NFS from "node:fs"
import * as Path from "node:path"
import { afterEach, beforeEach, vi } from "vitest"
import { testGlob, testLayer } from "../../../effect/test/FileSystem.test-utils.ts"
const startWatch = Effect.fnUntraced(function*<E, R>(
fs: FileSystem.FileSystem,
root: string,
watch: () => Stream.Stream<FileSystem.WatchEvent, E, R>
) {
const ready = yield* Deferred.make<void>()
const readyName = ".watch-ready"
const fiber = yield* watch().pipe(
Stream.tap((event) =>
event.path === readyName
? Deferred.succeed(ready, undefined)
: Effect.void
),
Stream.dropUntil((event) => event.path === readyName),
Stream.filter((event) => event.path !== readyName),
Stream.runHead,
Effect.flatMap(Effect.fromOption),
Effect.forkChild
)
const signalFiber = yield* Effect.sleep("10 millis").pipe(
TestClock.withLive,
Effect.andThen(fs.writeFileString(`${root}/${readyName}`, "")),
Effect.forever,
Effect.forkChild
)
yield* Deferred.await(ready).pipe(
Effect.raceFirst(Fiber.join(fiber).pipe(Effect.asVoid)),
Effect.ensuring(Fiber.interrupt(signalFiber))
)
return fiber
})
// A file system whose listings report every entry as `"Unknown"`, so `glob`
// learns entry types from `stat` and `readLink` alone.
const untypedLayer = Layer.effect(
FileSystem.FileSystem,
Effect.gen(function*() {
const fs = yield* FileSystem.FileSystem
return FileSystem.make({
...fs,
readDirectoryEntries: (path) =>
Effect.map(fs.readDirectory(path), (names) => names.map((name) => ({ name, type: "Unknown" as const })))
})
})
).pipe(Layer.provide(NodeFileSystem.layer))
describe("FileSystem without typed directory listings", { concurrent: false }, () => {
testGlob(untypedLayer)
})
describe("FileSystem", { concurrent: false }, () => {
testLayer(NodeFileSystem.layer, { noFollow: process.platform !== "win32" })
it.effect("realPath resolves a directory alias to its physical target", () =>
Effect.gen(function*() {
const fs = yield* FileSystem.FileSystem
const root = yield* fs.realPath(yield* fs.makeTempDirectoryScoped())
const target = Path.join(root, "target")
const alias = Path.join(root, "alias")
yield* fs.makeDirectory(target)
NFS.symlinkSync(target, alias, process.platform === "win32" ? "junction" : "dir")
assert.strictEqual(yield* fs.realPath(alias), target)
}).pipe(
Effect.provide(NodeFileSystem.layer)
))
it.effect("writeAll accepts an empty buffer", () =>
Effect.gen(function*() {
const fs = yield* FileSystem.FileSystem
const path = yield* fs.makeTempFileScoped()
const file = yield* fs.open(path, { flag: "r+" })
yield* file.writeAll(new Uint8Array(0))
}).pipe(
Effect.provide(NodeFileSystem.layer)
))
it.effect("watch reports Create for a new file outside the current directory", () =>
Effect.gen(function*() {
const fs = yield* FileSystem.FileSystem
const root = yield* fs.makeTempDirectoryScoped()
const name = "created.txt"
const path = `${root}/${name}`
assert.strictEqual(yield* fs.exists(name), false)
const fiber = yield* startWatch(fs, root, () => fs.watch(root))
yield* fs.writeFileString(path, "")
const event = yield* Fiber.join(fiber)
assert.strictEqual(yield* fs.exists(path), true)
assert.deepStrictEqual(event, { _tag: "Create", path: name })
}).pipe(
Effect.provide(NodeFileSystem.layer)
))
it.effect("watch does not report nested changes when recursive is false", () =>
Effect.gen(function*() {
const fs = yield* FileSystem.FileSystem
const root = yield* fs.makeTempDirectoryScoped()
const nested = `${root}/nested`
yield* fs.makeDirectory(nested)
const fiber = yield* startWatch(fs, root, () => fs.watch(root, { recursive: false }))
yield* fs.writeFileString(`${nested}/nested.txt`, "")
yield* fs.writeFileString(`${root}/direct.txt`, "")
const event = yield* Fiber.join(fiber)
assert.strictEqual(event.path, "direct.txt")
}).pipe(
Effect.provide(NodeFileSystem.layer)
))
it.effect("watch is non-recursive when options are omitted", () =>
Effect.gen(function*() {
const fs = yield* FileSystem.FileSystem
const root = yield* fs.makeTempDirectoryScoped()
const nested = `${root}/nested`
yield* fs.makeDirectory(nested)
const fiber = yield* startWatch(fs, root, () => fs.watch(root))
yield* fs.writeFileString(`${nested}/nested.txt`, "")
yield* fs.writeFileString(`${root}/direct.txt`, "")
const event = yield* Fiber.join(fiber)
assert.strictEqual(event.path, "direct.txt")
}).pipe(
Effect.provide(NodeFileSystem.layer)
))
it.live("watch uses a WatchBackend provided after the layer is built", () =>
Effect.gen(function*() {
const fs = yield* FileSystem.FileSystem
const root = yield* fs.makeTempDirectoryScoped()
const backendEvent: FileSystem.WatchEvent = { _tag: "Create", path: "from-backend" }
const event = yield* fs.watch(root).pipe(
Stream.runHead,
Effect.provideService(FileSystem.WatchBackend, {
register: () => Option.some(Stream.make(backendEvent))
}),
Effect.timeout("1 second")
)
assert.deepStrictEqual(event, Option.some(backendEvent))
}).pipe(
Effect.provide(NodeFileSystem.layer)
))
it.effect("watch prefers the caller WatchBackend over the construction backend", () =>
Effect.gen(function*() {
const fs = yield* FileSystem.FileSystem
const root = yield* fs.makeTempDirectoryScoped()
const callerEvent: FileSystem.WatchEvent = { _tag: "Create", path: "from-caller" }
const event = yield* fs.watch(root).pipe(
Stream.runHead,
Effect.provideService(FileSystem.WatchBackend, {
register: () => Option.some(Stream.make(callerEvent))
})
)
assert.deepStrictEqual(event, Option.some(callerEvent))
}).pipe(
Effect.provide(NodeFileSystem.layer),
Effect.provideService(FileSystem.WatchBackend, {
register: () => Option.some(Stream.make({ _tag: "Create" as const, path: "from-construction" }))
})
))
it.effect("watch reports nested changes when recursive is true", () =>
Effect.gen(function*() {
const fs = yield* FileSystem.FileSystem
const root = yield* fs.makeTempDirectoryScoped()
const nested = `${root}/nested`
yield* fs.makeDirectory(nested)
const fiber = yield* startWatch(fs, root, () => fs.watch(root, { recursive: true }))
yield* fs.writeFileString(`${nested}/nested.txt`, "")
const event = yield* Fiber.join(fiber)
assert(event.path.endsWith("nested.txt"))
}).pipe(
Effect.provide(NodeFileSystem.layer)
))
})
const state = vi.hoisted(() => ({
enabled: false,
values: {} as Record<string, bigint>,
positions: [] as Array<number | bigint | undefined>
}))
vi.mock("node:fs", async (importOriginal) => {
const original = await importOriginal<typeof NFS>()
// Match Node's number and bigint stat modes.
const stat = (
_pathOrFd: string | number,
optionsOrCallback: { bigint?: boolean } | ((error: null, stats: object) => void),
callback?: (error: null, stats: object) => void
) => {
const bigint = typeof optionsOrCallback === "object" && optionsOrCallback.bigint
const done = typeof optionsOrCallback === "function" ? optionsOrCallback : callback!
done(null, {
...Object.fromEntries(Object.entries(state.values).map(([key, value]) => [key, bigint ? value : Number(value)])),
mtime: new Date(0),
atime: new Date(0),
birthtime: new Date(0),
isFile: () => true
})
}
const doubles = {
open: (_path: string, _flags: string, _mode: unknown, callback: (error: null, fd: number) => void) =>
callback(null, 42),
close: (_fd: number, callback: (error: null) => void) => callback(null),
stat,
fstat: stat,
write: (
_fd: number,
_buffer: Uint8Array,
_offset: unknown,
_length: unknown,
position: number | bigint | undefined,
callback: (error: null, bytesWritten: number) => void
) => {
state.positions.push(position)
callback(null, 1)
}
}
return {
...original,
...Object.fromEntries(
Object.entries(doubles).map(([name, implementation]) => [
name,
(...args: Array<unknown>) =>
Reflect.apply(state.enabled ? implementation : original[name as keyof typeof doubles], original, args)
])
)
}
})
const maxSafe = BigInt(Number.MAX_SAFE_INTEGER)
const oversized = maxSafe + 2n
describe("NodeFileSystem precision", { concurrent: false }, () => {
afterEach(() => {
state.enabled = false
})
beforeEach(() => {
state.enabled = true
state.positions = []
state.values = {
size: 4n,
blksize: 4096n,
dev: 1n,
ino: 2n,
mode: 33188n,
nlink: 1n,
uid: 1000n,
gid: 1000n,
rdev: 0n,
blocks: 8n
}
})
for (const method of ["write", "writeAll"] as const) {
it.effect(`${method} rejects an unsafe position before writing`, () =>
Effect.gen(function*() {
const fs = yield* FileSystem.FileSystem
const file = yield* fs.open("precision.bin", { flag: "r+" })
yield* file.seek(oversized, "start")
const error = yield* Effect.flip(file[method](new Uint8Array([1])))
assert.strictEqual(error.reason._tag, "BadArgument")
assert.deepStrictEqual(state.positions, [])
}).pipe(Effect.provide(NodeFileSystem.layer)))
}
it.effect("writeAll stops when a partial write advances beyond the safe integer limit", () =>
Effect.gen(function*() {
const fs = yield* FileSystem.FileSystem
const file = yield* fs.open("precision.bin", { flag: "r+" })
yield* file.seek(maxSafe, "start")
const error = yield* Effect.flip(file.writeAll(new Uint8Array([1, 2])))
assert.strictEqual(error.reason._tag, "BadArgument")
assert.deepStrictEqual(state.positions, [Number.MAX_SAFE_INTEGER])
assert.strictEqual(yield* file.seek(0n, "current"), maxSafe + 1n)
}).pipe(Effect.provide(NodeFileSystem.layer)))
for (const method of ["stat", "fstat"] as const) {
const getInfo = Effect.gen(function*() {
const fs = yield* FileSystem.FileSystem
return yield* method === "stat" ? fs.stat("precision.bin") : (yield* fs.open("precision.bin")).stat
})
it.effect(`${method} preserves oversized byte counts`, () =>
Effect.gen(function*() {
state.values.size = oversized
state.values.blksize = oversized
const info = yield* getInfo
assert.strictEqual(info.size, ByteSize.bytes(oversized))
assert.strictEqual(Option.getOrThrow(info.blksize), ByteSize.bytes(oversized))
}).pipe(Effect.provide(NodeFileSystem.layer)))
it.effect(`${method} rejects unsafe mode metadata`, () =>
Effect.gen(function*() {
state.values.mode = maxSafe + 1n
const error = yield* Effect.flip(getInfo)
assert.strictEqual(error.reason._tag, "BadArgument")
}).pipe(Effect.provide(NodeFileSystem.layer)))
for (
const { expected, name, value } of [
{ name: "preserves metadata above MAX_SAFE_INTEGER", value: maxSafe + 1n, expected: 9007199254740992n },
{ name: "interprets signed identifiers as unsigned 64-bit", value: -2n, expected: 18446744073709551614n }
]
) {
it.effect(`${method} ${name}`, () =>
Effect.gen(function*() {
Object.assign(state.values, { dev: value, ino: value, rdev: value, nlink: value, blocks: value })
const info = yield* getInfo
assert.strictEqual(info.dev, expected)
for (const field of ["ino", "rdev", "nlink"] as const) {
assert.deepStrictEqual(info[field], Option.some(expected), field)
}
assert.deepStrictEqual(info.blocks, Option.some(value))
}).pipe(Effect.provide(NodeFileSystem.layer)))
}
it.effect(`${method} preserves numeric ownership metadata`, () =>
Effect.gen(function*() {
Object.assign(state.values, { uid: 1000n, gid: 1001n })
const info = yield* getInfo
assert.deepStrictEqual(info.uid, Option.some(1000))
assert.deepStrictEqual(info.gid, Option.some(1001))
}).pipe(Effect.provide(NodeFileSystem.layer)))
it.effect(`${method} omits missing optional metadata`, () =>
Effect.gen(function*() {
const fields = ["ino", "nlink", "uid", "gid", "rdev", "blocks"] as const
for (const field of fields) {
delete state.values[field]
}
const info = yield* getInfo
for (const field of fields) {
assert.deepStrictEqual(info[field], Option.none(), field)
}
assert.strictEqual(info.type, "File")
assert.strictEqual(info.size, ByteSize.bytes(4n))
assert.deepStrictEqual(info.mtime, Option.some(new Date(0)))
}).pipe(Effect.provide(NodeFileSystem.layer)))
}
})