effect-start 0.17.2 → 0.19.0

package/src/node/FileSystem.ts

@@ -1,36 +1,29 @@
 /*
  * Adapted from @effect/platform
  */
-import { effectify } from "@effect/platform/Effectify"
-import * as Error from "@effect/platform/Error"
-import type {
-  PlatformError,
-  SystemErrorReason,
-} from "@effect/platform/Error"
-import { SystemError } from "@effect/platform/Error"
 import * as FileSystem from "@effect/platform/FileSystem"
 import type * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
-import { pipe } from "effect/Function"
+import * as Function from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as Stream from "effect/Stream"
-import * as Crypto from "node:crypto"
+import * as NCrypto from "node:crypto"
 import * as NFS from "node:fs"
 import * as NOS from "node:os"
 import * as NPath from "node:path"
+import * as Effectify from "./Effectify.ts"
+import * as PlatformError from "./PlatformError.ts"
 
 const handleBadArgument = (method: string) => (cause: unknown) =>
-  new Error.BadArgument({
+  new PlatformError.BadArgument({
     module: "FileSystem",
     method,
     cause,
   })
 
-// == access
-
 const access = (() => {
-  const nodeAccess = effectify(
+  const nodeAccess = Effectify.effectify(
     NFS.access,
     handleErrnoException("FileSystem", "access"),
     handleBadArgument("access"),
@@ -47,10 +40,8 @@ const access = (() => {
   }
 })()
 
-// == copy
-
 const copy = (() => {
-  const nodeCp = effectify(
+  const nodeCp = Effectify.effectify(
     NFS.cp,
     handleErrnoException("FileSystem", "copy"),
     handleBadArgument("copy"),
@@ -63,10 +54,8 @@ const copy = (() => {
     })
 })()
 
-// == copyFile
-
 const copyFile = (() => {
-  const nodeCopyFile = effectify(
+  const nodeCopyFile = Effectify.effectify(
     NFS.copyFile,
     handleErrnoException("FileSystem", "copyFile"),
     handleBadArgument("copyFile"),
@@ -74,10 +63,8 @@ const copyFile = (() => {
   return (fromPath: string, toPath: string) => nodeCopyFile(fromPath, toPath)
 })()
 
-// == chmod
-
 const chmod = (() => {
-  const nodeChmod = effectify(
+  const nodeChmod = Effectify.effectify(
     NFS.chmod,
     handleErrnoException("FileSystem", "chmod"),
     handleBadArgument("chmod"),
@@ -85,10 +72,8 @@ const chmod = (() => {
   return (path: string, mode: number) => nodeChmod(path, mode)
 })()
 
-// == chown
-
 const chown = (() => {
-  const nodeChown = effectify(
+  const nodeChown = Effectify.effectify(
     NFS.chown,
     handleErrnoException("FileSystem", "chown"),
     handleBadArgument("chown"),
@@ -96,10 +81,8 @@ const chown = (() => {
   return (path: string, uid: number, gid: number) => nodeChown(path, uid, gid)
 })()
 
-// == link
-
 const link = (() => {
-  const nodeLink = effectify(
+  const nodeLink = Effectify.effectify(
     NFS.link,
     handleErrnoException("FileSystem", "link"),
     handleBadArgument("link"),
@@ -108,10 +91,8 @@ const link = (() => {
     nodeLink(existingPath, newPath)
 })()
 
-// == makeDirectory
-
 const makeDirectory = (() => {
-  const nodeMkdir = effectify(
+  const nodeMkdir = Effectify.effectify(
     NFS.mkdir,
     handleErrnoException("FileSystem", "makeDirectory"),
     handleBadArgument("makeDirectory"),
@@ -123,10 +104,8 @@ const makeDirectory = (() => {
     })
 })()
 
-// == makeTempDirectory
-
 const makeTempDirectoryFactory = (method: string) => {
-  const nodeMkdtemp = effectify(
+  const nodeMkdtemp = Effectify.effectify(
     NFS.mkdtemp,
     handleErrnoException("FileSystem", method),
     handleBadArgument(method),
@@ -145,10 +124,8 @@ const makeTempDirectoryFactory = (method: string) => {
 }
 const makeTempDirectory = makeTempDirectoryFactory("makeTempDirectory")
 
-// == remove
-
 const removeFactory = (method: string) => {
-  const nodeRm = effectify(
+  const nodeRm = Effectify.effectify(
     NFS.rm,
     handleErrnoException("FileSystem", method),
     handleBadArgument(method),
@@ -164,8 +141,6 @@ const removeFactory = (method: string) => {
 }
 const remove = removeFactory("remove")
 
-// == makeTempDirectoryScoped
-
 const makeTempDirectoryScoped = (() => {
   const makeDirectory = makeTempDirectoryFactory("makeTempDirectoryScoped")
   const removeDirectory = removeFactory("makeTempDirectoryScoped")
@@ -179,22 +154,20 @@ const makeTempDirectoryScoped = (() => {
     )
 })()
 
-// == open
-
 const openFactory = (method: string) => {
-  const nodeOpen = effectify(
+  const nodeOpen = Effectify.effectify(
     NFS.open,
     handleErrnoException("FileSystem", method),
     handleBadArgument(method),
   )
-  const nodeClose = effectify(
+  const nodeClose = Effectify.effectify(
     NFS.close,
     handleErrnoException("FileSystem", method),
     handleBadArgument(method),
   )
 
   return (path: string, options?: FileSystem.OpenFileOptions) =>
-    pipe(
+    Function.pipe(
       Effect.acquireRelease(
         nodeOpen(path, options?.flag ?? "r", options?.mode),
         (fd) => Effect.orDie(nodeClose(fd)),
@@ -211,32 +184,32 @@ const open = openFactory("open")
 
 const makeFile = (() => {
   const nodeReadFactory = (method: string) =>
-    effectify(
+    Effectify.effectify(
       NFS.read,
       handleErrnoException("FileSystem", method),
       handleBadArgument(method),
     )
   const nodeRead = nodeReadFactory("read")
   const nodeReadAlloc = nodeReadFactory("readAlloc")
-  const nodeStat = effectify(
+  const nodeStat = Effectify.effectify(
     NFS.fstat,
     handleErrnoException("FileSystem", "stat"),
     handleBadArgument("stat"),
   )
-  const nodeTruncate = effectify(
+  const nodeTruncate = Effectify.effectify(
     NFS.ftruncate,
     handleErrnoException("FileSystem", "truncate"),
     handleBadArgument("truncate"),
   )
 
-  const nodeSync = effectify(
+  const nodeSync = Effectify.effectify(
     NFS.fsync,
     handleErrnoException("FileSystem", "sync"),
     handleBadArgument("sync"),
   )
 
   const nodeWriteFactory = (method: string) =>
-    effectify(
+    Effectify.effectify(
       NFS.write,
       handleErrnoException("FileSystem", method),
       handleBadArgument(method),
@@ -372,7 +345,7 @@ const makeFile = (() => {
 
     private writeAllChunk(
       buffer: Uint8Array,
-    ): Effect.Effect<void, Error.PlatformError> {
+    ): Effect.Effect<void, PlatformError.PlatformError> {
       return Effect.flatMap(
         Effect.suspend(() =>
           nodeWriteAll(
@@ -386,7 +359,7 @@ const makeFile = (() => {
         (bytesWritten) => {
           if (bytesWritten === 0) {
             return Effect.fail(
-              new Error.SystemError({
+              new PlatformError.SystemError({
                 module: "FileSystem",
                 method: "writeAll",
                 reason: "WriteZero",
@@ -416,15 +389,13 @@ const makeFile = (() => {
     new FileImpl(fd, append)
 })()
 
-// == makeTempFile
-
 const makeTempFileFactory = (method: string) => {
   const makeDirectory = makeTempDirectoryFactory(method)
   const open = openFactory(method)
   const randomHexString = (bytes: number) =>
-    Effect.sync(() => Crypto.randomBytes(bytes).toString("hex"))
+    Effect.sync(() => NCrypto.randomBytes(bytes).toString("hex"))
   return (options?: FileSystem.MakeTempFileOptions) =>
-    pipe(
+    Function.pipe(
       Effect.zip(makeDirectory(options), randomHexString(6)),
       Effect.map(([directory, random]) =>
         NPath.join(directory, random + (options?.suffix ?? ""))
@@ -434,8 +405,6 @@ const makeTempFileFactory = (method: string) => {
 }
 const makeTempFile = makeTempFileFactory("makeTempFile")
 
-// == makeTempFileScoped
-
 const makeTempFileScoped = (() => {
   const makeFile = makeTempFileFactory("makeTempFileScoped")
   const removeDirectory = removeFactory("makeTempFileScoped")
@@ -447,8 +416,6 @@ const makeTempFileScoped = (() => {
     )
 })()
 
-// == readDirectory
-
 const readDirectory = (
   path: string,
   options?: FileSystem.ReadDirectoryOptions,
@@ -459,10 +426,8 @@ const readDirectory = (
       handleErrnoException("FileSystem", "readDirectory")(err as any, [path]),
   })
 
-// == readFile
-
 const readFile = (path: string) =>
-  Effect.async<Uint8Array, Error.PlatformError>((resume, signal) => {
+  Effect.async<Uint8Array, PlatformError.PlatformError>((resume, signal) => {
     try {
       NFS.readFile(path, { signal }, (err, data) => {
         if (err) {
@@ -480,10 +445,8 @@ const readFile = (path: string) =>
     }
   })
 
-// == readLink
-
 const readLink = (() => {
-  const nodeReadLink = effectify(
+  const nodeReadLink = Effectify.effectify(
     NFS.readlink,
     handleErrnoException("FileSystem", "readLink"),
     handleBadArgument("readLink"),
@@ -491,10 +454,8 @@ const readLink = (() => {
   return (path: string) => nodeReadLink(path)
 })()
 
-// == realPath
-
 const realPath = (() => {
-  const nodeRealPath = effectify(
+  const nodeRealPath = Effectify.effectify(
     NFS.realpath,
     handleErrnoException("FileSystem", "realPath"),
     handleBadArgument("realPath"),
@@ -502,10 +463,8 @@ const realPath = (() => {
   return (path: string) => nodeRealPath(path)
 })()
 
-// == rename
-
 const rename = (() => {
-  const nodeRename = effectify(
+  const nodeRename = Effectify.effectify(
     NFS.rename,
     handleErrnoException("FileSystem", "rename"),
     handleBadArgument("rename"),
@@ -513,8 +472,6 @@ const rename = (() => {
   return (oldPath: string, newPath: string) => nodeRename(oldPath, newPath)
 })()
 
-// == stat
-
 const makeFileInfo = (stat: NFS.Stats): FileSystem.File.Info => ({
   type: stat.isFile()
     ? "File"
@@ -546,7 +503,7 @@ const makeFileInfo = (stat: NFS.Stats): FileSystem.File.Info => ({
   blocks: Option.fromNullable(stat.blocks),
 })
 const stat = (() => {
-  const nodeStat = effectify(
+  const nodeStat = Effectify.effectify(
     NFS.stat,
     handleErrnoException("FileSystem", "stat"),
     handleBadArgument("stat"),
@@ -554,10 +511,8 @@ const stat = (() => {
   return (path: string) => Effect.map(nodeStat(path), makeFileInfo)
 })()
 
-// == symlink
-
 const symlink = (() => {
-  const nodeSymlink = effectify(
+  const nodeSymlink = Effectify.effectify(
     NFS.symlink,
     handleErrnoException("FileSystem", "symlink"),
     handleBadArgument("symlink"),
@@ -565,10 +520,8 @@ const symlink = (() => {
   return (target: string, path: string) => nodeSymlink(target, path)
 })()
 
-// == truncate
-
 const truncate = (() => {
-  const nodeTruncate = effectify(
+  const nodeTruncate = Effectify.effectify(
     NFS.truncate,
     handleErrnoException("FileSystem", "truncate"),
     handleBadArgument("truncate"),
@@ -577,10 +530,8 @@ const truncate = (() => {
     nodeTruncate(path, length !== undefined ? Number(length) : undefined)
 })()
 
-// == utimes
-
 const utimes = (() => {
-  const nodeUtimes = effectify(
+  const nodeUtimes = Effectify.effectify(
     NFS.utimes,
     handleErrnoException("FileSystem", "utime"),
     handleBadArgument("utime"),
@@ -589,10 +540,10 @@ const utimes = (() => {
     nodeUtimes(path, atime, mtime)
 })()
 
-// == watch
-
 const watchNode = (path: string, options?: FileSystem.WatchOptions) =>
-  Stream.asyncScoped<FileSystem.WatchEvent, Error.PlatformError>((emit) =>
+  Stream.asyncScoped<FileSystem.WatchEvent, PlatformError.PlatformError>((
+    emit,
+  ) =>
     Effect.acquireRelease(
       Effect.sync(() => {
         const watcher = NFS.watch(
@@ -621,7 +572,7 @@ const watchNode = (path: string, options?: FileSystem.WatchOptions) =>
         )
         watcher.on("error", (error) => {
           emit.fail(
-            new Error.SystemError({
+            new PlatformError.SystemError({
               module: "FileSystem",
               reason: "Unknown",
               method: "watch",
@@ -654,14 +605,12 @@ const watch = (
     Stream.unwrap,
   )
 
-// == writeFile
-
 const writeFile = (
   path: string,
   data: Uint8Array,
   options?: FileSystem.WriteFileOptions,
 ) =>
-  Effect.async<void, Error.PlatformError>((resume, signal) => {
+  Effect.async<void, PlatformError.PlatformError>((resume, signal) => {
     try {
       NFS.writeFile(path, data, {
         signal,
@@ -683,7 +632,7 @@ const writeFile = (
     }
   })
 
-const makeFileSystem = Effect.map(
+const make = Effect.map(
   Effect.serviceOption(FileSystem.WatchBackend),
   (backend) =>
     FileSystem.make({
@@ -716,22 +665,35 @@ const makeFileSystem = Effect.map(
     }),
 )
 
-export const layer = Layer.effect(FileSystem.FileSystem, makeFileSystem)
+export const layer = Layer.unwrapEffect(
+  Effect
+    .gen(function*() {
+      const mod = yield* Effect.tryPromise(() =>
+        import("@effect/platform/FileSystem")
+      )
+      return Layer.effect(mod.FileSystem, make)
+    })
+    .pipe(
+      Effect.catchAll(() =>
+        Effect.die(new globalThis.Error("@effect/platform is not installed"))
+      ),
+    ),
+)
 
 export {
-  Error,
   FileSystem,
+  PlatformError as Error,
 }
 
 export function handleErrnoException(
-  module: SystemError["module"],
+  module: PlatformError.SystemError["module"],
   method: string,
 ) {
   return function(
     err: NodeJS.ErrnoException,
     [path]: [path: NFS.PathLike | number, ...args: Array<any>],
-  ): PlatformError {
-    let reason: SystemErrorReason = "Unknown"
+  ): PlatformError.PlatformError {
+    let reason: PlatformError.SystemErrorReason = "Unknown"
 
     switch (err.code) {
       case "ENOENT":
@@ -763,7 +725,7 @@ export function handleErrnoException(
         break
     }
 
-    return new SystemError({
+    return new PlatformError.SystemError({
       reason,
       module,
       method,

package/src/node/PlatformError.ts

@@ -0,0 +1,102 @@
+/*
+ * Adapted from @effect/platform
+ */
+import type * as Cause from "effect/Cause"
+import * as Data from "effect/Data"
+import * as Predicate from "effect/Predicate"
+import * as Schema from "effect/Schema"
+import type * as Types from "effect/Types"
+
+import { TypeId as TypeId_ } from "@effect/platform/Error"
+
+export const TypeId: typeof TypeId_ = TypeId_
+
+export type TypeId = typeof TypeId
+
+export const isPlatformError = (u: unknown): u is PlatformError => Predicate.hasProperty(u, TypeId)
+
+export const TypeIdError = <const TypeId extends symbol, const Tag extends string>(
+  typeId: TypeId,
+  tag: Tag,
+): new<A extends Record<string, any>>(
+  args: Types.Simplify<A>,
+) =>
+  & Cause.YieldableError
+  & Record<TypeId, TypeId>
+  & { readonly _tag: Tag }
+  & Readonly<A> => {
+  class Base extends Data.Error<{}> {
+    readonly _tag = tag
+  }
+  ;(Base.prototype as any)[typeId] = typeId
+  ;(Base.prototype as any).name = tag
+  return Base as any
+}
+
+export const Module = Schema.Literal(
+  "Clipboard",
+  "Command",
+  "FileSystem",
+  "KeyValueStore",
+  "Path",
+  "Stream",
+  "Terminal",
+)
+
+export class BadArgument
+  extends Schema.TaggedError<BadArgument>("@effect/platform/Error/BadArgument")("BadArgument", {
+    module: Module,
+    method: Schema.String,
+    description: Schema.optional(Schema.String),
+    cause: Schema.optional(Schema.Defect),
+  })
+{
+  readonly [TypeId]: typeof TypeId = TypeId
+
+  get message(): string {
+    return `${this.module}.${this.method}${this.description ? `: ${this.description}` : ""}`
+  }
+}
+
+export const SystemErrorReason = Schema.Literal(
+  "AlreadyExists",
+  "BadResource",
+  "Busy",
+  "InvalidData",
+  "NotFound",
+  "PermissionDenied",
+  "TimedOut",
+  "UnexpectedEof",
+  "Unknown",
+  "WouldBlock",
+  "WriteZero",
+)
+
+export type SystemErrorReason = typeof SystemErrorReason.Type
+
+export class SystemError
+  extends Schema.TaggedError<SystemError>("@effect/platform/Error/SystemError")("SystemError", {
+    reason: SystemErrorReason,
+    module: Module,
+    method: Schema.String,
+    description: Schema.optional(Schema.String),
+    syscall: Schema.optional(Schema.String),
+    pathOrDescriptor: Schema.optional(Schema.Union(Schema.String, Schema.Number)),
+    cause: Schema.optional(Schema.Defect),
+  })
+{
+  readonly [TypeId]: typeof TypeId = TypeId
+
+  get message(): string {
+    return `${this.reason}: ${this.module}.${this.method}${
+      this.pathOrDescriptor !== undefined ? ` (${this.pathOrDescriptor})` : ""
+    }${this.description ? `: ${this.description}` : ""}`
+  }
+}
+
+export type PlatformError = BadArgument | SystemError
+
+export const PlatformError: Schema.Union<[
+  typeof BadArgument,
+  typeof SystemError,
+]> = Schema.Union(BadArgument, SystemError)

package/src/testing/TestLogger.ts

@@ -28,7 +28,7 @@ export function layer(): Layer.Layer<TestLogger> {
 
       const customLogger = Logger.make(({ message, logLevel, cause }) => {
         const causeStr = !Cause.isEmpty(cause)
-          ? ` ${Cause.pretty(cause)}`
+          ? ` ${Cause.pretty(cause, { renderErrorCause: true })}`
           : ""
         MutableRef.update(
           mutableRef,

package/dist/Random.d.ts

@@ -1,5 +0,0 @@
-export declare function uuid(): string;
-export declare function uuidSorted(): string;
-export declare function token(length: number): string;
-export declare function bytes(length: number): Uint8Array;
-export declare function uuid4bytes(): Uint8Array;

package/dist/Random.js

@@ -1,49 +0,0 @@
-export function uuid() {
-    return base36(uuid4bytes());
-}
-export function uuidSorted() {
-    return base36(uuid7bytes());
-}
-export function token(length) {
-    return base36(bytes(length));
-}
-function base36(bytes) {
-    if (bytes.length === 0)
-        return "";
-    let zeros = 0;
-    while (zeros < bytes.length && bytes[zeros] === 0)
-        zeros++;
-    let n = 0n;
-    for (let i = zeros; i < bytes.length; i++)
-        n = (n << 8n) + BigInt(bytes[i]);
-    return "0".repeat(zeros) + (n === 0n ? "" : n.toString(36));
-}
-export function bytes(length) {
-    const buf = new Uint8Array(length);
-    crypto.getRandomValues(buf);
-    return buf;
-}
-export function uuid4bytes() {
-    const buf = bytes(16);
-    buf[6] = (buf[6] & 0x0f) | 0x40; // version 4
-    buf[8] = (buf[8] & 0x3f) | 0x80; // variant
-    return buf;
-}
-function uuid7bytes() {
-    const buf = new Uint8Array(16);
-    const timestamp = BigInt(Date.now());
-    // 48-bit timestamp (6 bytes)
-    buf[0] = Number((timestamp >> 40n) & 0xffn);
-    buf[1] = Number((timestamp >> 32n) & 0xffn);
-    buf[2] = Number((timestamp >> 24n) & 0xffn);
-    buf[3] = Number((timestamp >> 16n) & 0xffn);
-    buf[4] = Number((timestamp >> 8n) & 0xffn);
-    buf[5] = Number(timestamp & 0xffn);
-    // 12-bit random A (1.5 bytes)
-    crypto.getRandomValues(buf.subarray(6, 8));
-    buf[6] = (buf[6] & 0x0f) | 0x70; // version 7
-    // 2-bit variant + 62-bit random B (8 bytes)
-    crypto.getRandomValues(buf.subarray(8, 16));
-    buf[8] = (buf[8] & 0x3f) | 0x80; // variant
-    return buf;
-}