@saeeol/core 7.3.2 → 7.3.5

package/test/filesystem/filesystem.test.ts

@@ -1,338 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { Effect, Layer, FileSystem } from "effect"
-import { NodeFileSystem } from "@effect/platform-node"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { testEffect } from "../lib/effect"
-import path from "path"
-
-const live = AppFileSystem.layer.pipe(Layer.provideMerge(NodeFileSystem.layer))
-const { effect: it } = testEffect(live)
-
-describe("AppFileSystem", () => {
-  describe("isDir", () => {
-    it(
-      "returns true for directories",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        expect(yield* fs.isDir(tmp)).toBe(true)
-      }),
-    )
-
-    it(
-      "returns false for files",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        const file = path.join(tmp, "test.txt")
-        yield* filesys.writeFileString(file, "hello")
-        expect(yield* fs.isDir(file)).toBe(false)
-      }),
-    )
-
-    it(
-      "returns false for non-existent paths",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        expect(yield* fs.isDir("/tmp/nonexistent-" + Math.random())).toBe(false)
-      }),
-    )
-  })
-
-  describe("isFile", () => {
-    it(
-      "returns true for files",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        const file = path.join(tmp, "test.txt")
-        yield* filesys.writeFileString(file, "hello")
-        expect(yield* fs.isFile(file)).toBe(true)
-      }),
-    )
-
-    it(
-      "returns false for directories",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        expect(yield* fs.isFile(tmp)).toBe(false)
-      }),
-    )
-  })
-
-  describe("readJson / writeJson", () => {
-    it(
-      "round-trips JSON data",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        const file = path.join(tmp, "data.json")
-        const data = { name: "test", count: 42, nested: { ok: true } }
-
-        yield* fs.writeJson(file, data)
-        const result = yield* fs.readJson(file)
-
-        expect(result).toEqual(data)
-      }),
-    )
-  })
-
-  describe("ensureDir", () => {
-    it(
-      "creates nested directories",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        const nested = path.join(tmp, "a", "b", "c")
-
-        yield* fs.ensureDir(nested)
-
-        const info = yield* filesys.stat(nested)
-        expect(info.type).toBe("Directory")
-      }),
-    )
-
-    it(
-      "is idempotent",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        const dir = path.join(tmp, "existing")
-        yield* filesys.makeDirectory(dir)
-
-        yield* fs.ensureDir(dir)
-
-        const info = yield* filesys.stat(dir)
-        expect(info.type).toBe("Directory")
-      }),
-    )
-  })
-
-  describe("writeWithDirs", () => {
-    it(
-      "creates parent directories if missing",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        const file = path.join(tmp, "deep", "nested", "file.txt")
-
-        yield* fs.writeWithDirs(file, "hello")
-
-        expect(yield* filesys.readFileString(file)).toBe("hello")
-      }),
-    )
-
-    it(
-      "writes directly when parent exists",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        const file = path.join(tmp, "direct.txt")
-
-        yield* fs.writeWithDirs(file, "world")
-
-        expect(yield* filesys.readFileString(file)).toBe("world")
-      }),
-    )
-
-    it(
-      "writes Uint8Array content",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        const file = path.join(tmp, "binary.bin")
-        const content = new Uint8Array([0x00, 0x01, 0x02, 0x03])
-
-        yield* fs.writeWithDirs(file, content)
-
-        const result = yield* filesys.readFile(file)
-        expect(new Uint8Array(result)).toEqual(content)
-      }),
-    )
-  })
-
-  describe("findUp", () => {
-    it(
-      "finds target in start directory",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        yield* filesys.writeFileString(path.join(tmp, "target.txt"), "found")
-
-        const result = yield* fs.findUp("target.txt", tmp)
-        expect(result).toEqual([path.join(tmp, "target.txt")])
-      }),
-    )
-
-    it(
-      "finds target in parent directories",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        yield* filesys.writeFileString(path.join(tmp, "marker"), "root")
-        const child = path.join(tmp, "a", "b")
-        yield* filesys.makeDirectory(child, { recursive: true })
-
-        const result = yield* fs.findUp("marker", child, tmp)
-        expect(result).toEqual([path.join(tmp, "marker")])
-      }),
-    )
-
-    it(
-      "returns empty array when not found",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        const result = yield* fs.findUp("nonexistent", tmp, tmp)
-        expect(result).toEqual([])
-      }),
-    )
-  })
-
-  describe("up", () => {
-    it(
-      "finds multiple targets walking up",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        yield* filesys.writeFileString(path.join(tmp, "a.txt"), "a")
-        yield* filesys.writeFileString(path.join(tmp, "b.txt"), "b")
-        const child = path.join(tmp, "sub")
-        yield* filesys.makeDirectory(child)
-        yield* filesys.writeFileString(path.join(child, "a.txt"), "a-child")
-
-        const result = yield* fs.up({ targets: ["a.txt", "b.txt"], start: child, stop: tmp })
-
-        expect(result).toContain(path.join(child, "a.txt"))
-        expect(result).toContain(path.join(tmp, "a.txt"))
-        expect(result).toContain(path.join(tmp, "b.txt"))
-      }),
-    )
-  })
-
-  describe("glob", () => {
-    it(
-      "finds files matching pattern",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        yield* filesys.writeFileString(path.join(tmp, "a.ts"), "a")
-        yield* filesys.writeFileString(path.join(tmp, "b.ts"), "b")
-        yield* filesys.writeFileString(path.join(tmp, "c.json"), "c")
-
-        const result = yield* fs.glob("*.ts", { cwd: tmp })
-        expect(result.sort()).toEqual(["a.ts", "b.ts"])
-      }),
-    )
-
-    it(
-      "supports absolute paths",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        yield* filesys.writeFileString(path.join(tmp, "file.txt"), "hello")
-
-        const result = yield* fs.glob("*.txt", { cwd: tmp, absolute: true })
-        expect(result).toEqual([path.join(tmp, "file.txt")])
-      }),
-    )
-  })
-
-  describe("globMatch", () => {
-    it(
-      "matches patterns",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        expect(fs.globMatch("*.ts", "foo.ts")).toBe(true)
-        expect(fs.globMatch("*.ts", "foo.json")).toBe(false)
-        expect(fs.globMatch("src/**", "src/a/b.ts")).toBe(true)
-      }),
-    )
-  })
-
-  describe("globUp", () => {
-    it(
-      "finds files walking up directories",
-      Effect.gen(function* () {
-        const fs = yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        yield* filesys.writeFileString(path.join(tmp, "root.md"), "root")
-        const child = path.join(tmp, "a", "b")
-        yield* filesys.makeDirectory(child, { recursive: true })
-        yield* filesys.writeFileString(path.join(child, "leaf.md"), "leaf")
-
-        const result = yield* fs.globUp("*.md", child, tmp)
-        expect(result).toContain(path.join(child, "leaf.md"))
-        expect(result).toContain(path.join(tmp, "root.md"))
-      }),
-    )
-  })
-
-  describe("built-in passthrough", () => {
-    it(
-      "exists works",
-      Effect.gen(function* () {
-        yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        const file = path.join(tmp, "exists.txt")
-        yield* filesys.writeFileString(file, "yes")
-
-        expect(yield* filesys.exists(file)).toBe(true)
-        expect(yield* filesys.exists(file + ".nope")).toBe(false)
-      }),
-    )
-
-    it(
-      "remove works",
-      Effect.gen(function* () {
-        yield* AppFileSystem.Service
-        const filesys = yield* FileSystem.FileSystem
-        const tmp = yield* filesys.makeTempDirectoryScoped()
-        const file = path.join(tmp, "delete-me.txt")
-        yield* filesys.writeFileString(file, "bye")
-
-        yield* filesys.remove(file)
-
-        expect(yield* filesys.exists(file)).toBe(false)
-      }),
-    )
-  })
-
-  describe("pure helpers", () => {
-    test("mimeType returns correct types", () => {
-      expect(AppFileSystem.mimeType("file.json")).toBe("application/json")
-      expect(AppFileSystem.mimeType("image.png")).toBe("image/png")
-      expect(AppFileSystem.mimeType("unknown.qzx")).toBe("application/octet-stream")
-    })
-
-    test("contains checks path containment", () => {
-      expect(AppFileSystem.contains("/a/b", "/a/b/c")).toBe(true)
-      expect(AppFileSystem.contains("/a/b", "/a/c")).toBe(false)
-    })
-
-    test("overlaps detects overlapping paths", () => {
-      expect(AppFileSystem.overlaps("/a/b", "/a/b/c")).toBe(true)
-      expect(AppFileSystem.overlaps("/a/b/c", "/a/b")).toBe(true)
-      expect(AppFileSystem.overlaps("/a", "/b")).toBe(false)
-    })
-  })
-})

package/test/fixture/effect-flock-worker.ts

@@ -1,60 +0,0 @@
-import fs from "fs/promises"
-import os from "os"
-import { Effect, Layer } from "effect"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { EffectFlock } from "@saeeol/core/util/effect-flock"
-import { Global } from "@saeeol/core/global"
-
-type Msg = {
-  key: string
-  dir: string
-  holdMs?: number
-  ready?: string
-  active?: string
-  done?: string
-}
-
-function sleep(ms: number) {
-  return new Promise<void>((resolve) => setTimeout(resolve, ms))
-}
-
-const msg: Msg = JSON.parse(process.argv[2])
-
-const testGlobal = Global.layerWith({
-  home: os.homedir(),
-  data: os.tmpdir(),
-  cache: os.tmpdir(),
-  config: os.tmpdir(),
-  state: os.tmpdir(),
-  bin: os.tmpdir(),
-  log: os.tmpdir(),
-})
-
-const testLayer = EffectFlock.layer.pipe(Layer.provide(testGlobal), Layer.provide(AppFileSystem.defaultLayer))
-
-async function job() {
-  if (msg.ready) await fs.writeFile(msg.ready, String(process.pid))
-  if (msg.active) await fs.writeFile(msg.active, String(process.pid), { flag: "wx" })
-
-  try {
-    if (msg.holdMs && msg.holdMs > 0) await sleep(msg.holdMs)
-    if (msg.done) await fs.appendFile(msg.done, "1\n")
-  } finally {
-    if (msg.active) await fs.rm(msg.active, { force: true })
-  }
-}
-
-await Effect.runPromise(
-  Effect.gen(function* () {
-    const flock = yield* EffectFlock.Service
-    yield* flock.withLock(
-      Effect.promise(() => job()),
-      msg.key,
-      msg.dir,
-    )
-  }).pipe(Effect.provide(testLayer)),
-).catch((err) => {
-  const text = err instanceof Error ? (err.stack ?? err.message) : String(err)
-  process.stderr.write(text)
-  process.exit(1)
-})

package/test/fixture/flock-worker.ts

@@ -1,72 +0,0 @@
-import fs from "fs/promises"
-import { Flock } from "@saeeol/core/util/flock"
-
-type Msg = {
-  key: string
-  dir: string
-  staleMs?: number
-  timeoutMs?: number
-  baseDelayMs?: number
-  maxDelayMs?: number
-  holdMs?: number
-  ready?: string
-  active?: string
-  done?: string
-}
-
-function sleep(ms: number) {
-  return new Promise<void>((resolve) => {
-    setTimeout(resolve, ms)
-  })
-}
-
-function input() {
-  const raw = process.argv[2]
-  if (!raw) {
-    throw new Error("Missing flock worker input")
-  }
-
-  return JSON.parse(raw) as Msg
-}
-
-async function job(input: Msg) {
-  if (input.ready) {
-    await fs.writeFile(input.ready, String(process.pid))
-  }
-
-  if (input.active) {
-    await fs.writeFile(input.active, String(process.pid), { flag: "wx" })
-  }
-
-  try {
-    if (input.holdMs && input.holdMs > 0) {
-      await sleep(input.holdMs)
-    }
-
-    if (input.done) {
-      await fs.appendFile(input.done, "1\n")
-    }
-  } finally {
-    if (input.active) {
-      await fs.rm(input.active, { force: true })
-    }
-  }
-}
-
-async function main() {
-  const msg = input()
-
-  await Flock.withLock(msg.key, () => job(msg), {
-    dir: msg.dir,
-    staleMs: msg.staleMs,
-    timeoutMs: msg.timeoutMs,
-    baseDelayMs: msg.baseDelayMs,
-    maxDelayMs: msg.maxDelayMs,
-  })
-}
-
-await main().catch((err) => {
-  const text = err instanceof Error ? (err.stack ?? err.message) : String(err)
-  process.stderr.write(text)
-  process.exit(1)
-})

package/test/fixture/tmpdir.ts

@@ -1,13 +0,0 @@
-import fs from "fs/promises"
-import { tmpdir as osTmpdir } from "os"
-import path from "path"
-
-export const tmpdir = async () => {
-  const dir = await fs.mkdtemp(path.join(osTmpdir(), "saeeol-core-test-"))
-  return {
-    path: dir,
-    async [Symbol.asyncDispose]() {
-      await fs.rm(dir, { recursive: true, force: true })
-    },
-  }
-}

package/test/global.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import fs from "fs/promises"
-import os from "os"
-import path from "path"
-import { Global } from "@saeeol/core/global"
-
-describe("global paths", () => {
-  test("tmp path is under the system temp directory", () => {
-    expect(Global.Path.tmp).toBe(path.join(os.tmpdir(), "saeeol"))
-    expect(Global.make().tmp).toBe(Global.Path.tmp)
-  })
-
-  test("tmp path is created on module load", async () => {
-    expect((await fs.stat(Global.Path.tmp)).isDirectory()).toBe(true)
-  })
-})

package/test/lib/effect.ts

@@ -1,53 +0,0 @@
-import { test, type TestOptions } from "bun:test"
-import { Cause, Effect, Exit, Layer } from "effect"
-import type * as Scope from "effect/Scope"
-import * as TestClock from "effect/testing/TestClock"
-import * as TestConsole from "effect/testing/TestConsole"
-
-type Body<A, E, R> = Effect.Effect<A, E, R> | (() => Effect.Effect<A, E, R>)
-
-const body = <A, E, R>(value: Body<A, E, R>) => Effect.suspend(() => (typeof value === "function" ? value() : value))
-
-const run = <A, E, R, E2>(value: Body<A, E, R | Scope.Scope>, layer: Layer.Layer<R, E2>) =>
-  Effect.gen(function* () {
-    const exit = yield* body(value).pipe(Effect.scoped, Effect.provide(layer), Effect.exit)
-    if (Exit.isFailure(exit)) {
-      for (const err of Cause.prettyErrors(exit.cause)) {
-        yield* Effect.logError(err)
-      }
-    }
-    return yield* exit
-  }).pipe(Effect.runPromise)
-
-const make = <R, E>(testLayer: Layer.Layer<R, E>, liveLayer: Layer.Layer<R, E>) => {
-  const effect = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
-    test(name, () => run(value, testLayer), opts)
-
-  effect.only = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
-    test.only(name, () => run(value, testLayer), opts)
-
-  effect.skip = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
-    test.skip(name, () => run(value, testLayer), opts)
-
-  const live = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
-    test(name, () => run(value, liveLayer), opts)
-
-  live.only = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
-    test.only(name, () => run(value, liveLayer), opts)
-
-  live.skip = <A, E2>(name: string, value: Body<A, E2, R | Scope.Scope>, opts?: number | TestOptions) =>
-    test.skip(name, () => run(value, liveLayer), opts)
-
-  return { effect, live }
-}
-
-// Test environment with TestClock and TestConsole
-const testEnv = Layer.mergeAll(TestConsole.layer, TestClock.layer())
-
-// Live environment - uses real clock, but keeps TestConsole for output capture
-const liveEnv = TestConsole.layer
-
-export const it = make(testEnv, liveEnv)
-
-export const testEffect = <R, E>(layer: Layer.Layer<R, E>) =>
-  make(Layer.provideMerge(layer, testEnv), Layer.provideMerge(layer, liveEnv))

package/test/npm-config.test.ts

@@ -1,51 +0,0 @@
-import path from "path"
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { NpmConfig } from "@saeeol/core/npm-config"
-import { tmpdir } from "./fixture/tmpdir"
-
-describe("NpmConfig.load", () => {
-  test("reads registry from project .npmrc", async () => {
-    await using tmp = await tmpdir()
-    await Bun.write(path.join(tmp.path, ".npmrc"), "registry=https://registry.example.test/\n")
-
-    const config = await Effect.runPromise(NpmConfig.load(tmp.path))
-
-    expect(config.registry).toBe("https://registry.example.test/")
-  })
-
-  test("reads scoped registries from project .npmrc", async () => {
-    await using tmp = await tmpdir()
-    await Bun.write(path.join(tmp.path, ".npmrc"), "@acme:registry=https://npm.acme.test/\n")
-
-    const config = await Effect.runPromise(NpmConfig.load(tmp.path))
-
-    expect(config["@acme:registry"]).toBe("https://npm.acme.test/")
-  })
-
-  test("flattens boolean and list options", async () => {
-    await using tmp = await tmpdir()
-    await Bun.write(path.join(tmp.path, ".npmrc"), "ignore-scripts=true\nomit[]=dev\nomit[]=optional\n")
-
-    const config = await Effect.runPromise(NpmConfig.load(tmp.path))
-
-    expect(config.ignoreScripts).toBe(true)
-    expect(config.omit).toEqual(["dev", "optional"])
-  })
-})
-
-describe("NpmConfig.registry", () => {
-  test("normalizes configured registry without trailing slash", async () => {
-    await using tmp = await tmpdir()
-    await Bun.write(path.join(tmp.path, ".npmrc"), "registry=https://registry.example.test/\n")
-
-    await expect(Effect.runPromise(NpmConfig.registry(tmp.path))).resolves.toBe("https://registry.example.test")
-  })
-
-  test("leaves configured registry without trailing slash unchanged", async () => {
-    await using tmp = await tmpdir()
-    await Bun.write(path.join(tmp.path, ".npmrc"), "registry=https://registry.example.test\n")
-
-    await expect(Effect.runPromise(NpmConfig.registry(tmp.path))).resolves.toBe("https://registry.example.test")
-  })
-})