effect-start 0.28.0 → 0.29.0

package/src/FileSystem.ts

@@ -12,108 +12,93 @@ import * as Option from "effect/Option"
 import * as Sink from "effect/Sink"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
-import * as PlatformError from "./PlatformError.ts"
+import * as System from "./System.ts"
 
 export interface FileSystem {
   readonly access: (
     path: string,
     options?: AccessFileOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
   readonly copy: (
     fromPath: string,
     toPath: string,
     options?: CopyOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly copyFile: (
-    fromPath: string,
-    toPath: string,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly chmod: (path: string, mode: number) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
+  readonly copyFile: (fromPath: string, toPath: string) => Effect.Effect<void, System.SystemError>
+  readonly chmod: (path: string, mode: number) => Effect.Effect<void, System.SystemError>
   readonly chown: (
     path: string,
     uid: number,
     gid: number,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly exists: (path: string) => Effect.Effect<boolean, PlatformError.PlatformError>
-  readonly link: (
-    fromPath: string,
-    toPath: string,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
+  readonly exists: (path: string) => Effect.Effect<boolean, System.SystemError>
+  readonly link: (fromPath: string, toPath: string) => Effect.Effect<void, System.SystemError>
   readonly makeDirectory: (
     path: string,
     options?: MakeDirectoryOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
   readonly makeTempDirectory: (
     options?: MakeTempDirectoryOptions,
-  ) => Effect.Effect<string, PlatformError.PlatformError>
+  ) => Effect.Effect<string, System.SystemError>
   readonly makeTempDirectoryScoped: (
     options?: MakeTempDirectoryOptions,
-  ) => Effect.Effect<string, PlatformError.PlatformError, Scope.Scope>
+  ) => Effect.Effect<string, System.SystemError, Scope.Scope>
   readonly makeTempFile: (
     options?: MakeTempFileOptions,
-  ) => Effect.Effect<string, PlatformError.PlatformError>
+  ) => Effect.Effect<string, System.SystemError>
   readonly makeTempFileScoped: (
     options?: MakeTempFileOptions,
-  ) => Effect.Effect<string, PlatformError.PlatformError, Scope.Scope>
+  ) => Effect.Effect<string, System.SystemError, Scope.Scope>
   readonly open: (
     path: string,
     options?: OpenFileOptions,
-  ) => Effect.Effect<File, PlatformError.PlatformError, Scope.Scope>
+  ) => Effect.Effect<File, System.SystemError, Scope.Scope>
   readonly readDirectory: (
     path: string,
     options?: ReadDirectoryOptions,
-  ) => Effect.Effect<Array<string>, PlatformError.PlatformError>
-  readonly readFile: (path: string) => Effect.Effect<Uint8Array, PlatformError.PlatformError>
+  ) => Effect.Effect<Array<string>, System.SystemError>
+  readonly readFile: (path: string) => Effect.Effect<Uint8Array, System.SystemError>
   readonly readFileString: (
     path: string,
     encoding?: string,
-  ) => Effect.Effect<string, PlatformError.PlatformError>
-  readonly readLink: (path: string) => Effect.Effect<string, PlatformError.PlatformError>
-  readonly realPath: (path: string) => Effect.Effect<string, PlatformError.PlatformError>
+  ) => Effect.Effect<string, System.SystemError>
+  readonly readLink: (path: string) => Effect.Effect<string, System.SystemError>
+  readonly realPath: (path: string) => Effect.Effect<string, System.SystemError>
   readonly remove: (
     path: string,
     options?: RemoveOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly rename: (
-    oldPath: string,
-    newPath: string,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
+  readonly rename: (oldPath: string, newPath: string) => Effect.Effect<void, System.SystemError>
   readonly sink: (
     path: string,
     options?: SinkOptions,
-  ) => Sink.Sink<void, Uint8Array, never, PlatformError.PlatformError>
-  readonly stat: (path: string) => Effect.Effect<File.Info, PlatformError.PlatformError>
+  ) => Sink.Sink<void, Uint8Array, never, System.SystemError>
+  readonly stat: (path: string) => Effect.Effect<File.Info, System.SystemError>
   readonly stream: (
     path: string,
     options?: StreamOptions,
-  ) => Stream.Stream<Uint8Array, PlatformError.PlatformError>
-  readonly symlink: (
-    fromPath: string,
-    toPath: string,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly truncate: (
-    path: string,
-    length?: SizeInput,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Stream.Stream<Uint8Array, System.SystemError>
+  readonly symlink: (fromPath: string, toPath: string) => Effect.Effect<void, System.SystemError>
+  readonly truncate: (path: string, length?: SizeInput) => Effect.Effect<void, System.SystemError>
   readonly utimes: (
     path: string,
     atime: Date | number,
     mtime: Date | number,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
   readonly watch: (
     path: string,
     options?: WatchOptions,
-  ) => Stream.Stream<WatchEvent, PlatformError.PlatformError>
+  ) => Stream.Stream<WatchEvent, System.SystemError>
   readonly writeFile: (
     path: string,
     data: Uint8Array,
     options?: WriteFileOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
   readonly writeFileString: (
     path: string,
     data: string,
     options?: WriteFileStringOptions,
-  ) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<void, System.SystemError>
 }
 
 export const FileSystem: Context.Tag<FileSystem, FileSystem> = Context.GenericTag<FileSystem>(
@@ -202,16 +187,16 @@ export type FileTypeId = typeof FileTypeId
 export interface File {
   readonly [FileTypeId]: FileTypeId
   readonly fd: File.Descriptor
-  readonly stat: Effect.Effect<File.Info, PlatformError.PlatformError>
+  readonly stat: Effect.Effect<File.Info, System.SystemError>
   readonly seek: (offset: SizeInput, from: SeekMode) => Effect.Effect<void>
-  readonly sync: Effect.Effect<void, PlatformError.PlatformError>
-  readonly read: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError.PlatformError>
+  readonly sync: Effect.Effect<void, System.SystemError>
+  readonly read: (buffer: Uint8Array) => Effect.Effect<Size, System.SystemError>
   readonly readAlloc: (
     size: SizeInput,
-  ) => Effect.Effect<Option.Option<Uint8Array>, PlatformError.PlatformError>
-  readonly truncate: (length?: SizeInput) => Effect.Effect<void, PlatformError.PlatformError>
-  readonly write: (buffer: Uint8Array) => Effect.Effect<Size, PlatformError.PlatformError>
-  readonly writeAll: (buffer: Uint8Array) => Effect.Effect<void, PlatformError.PlatformError>
+  ) => Effect.Effect<Option.Option<Uint8Array>, System.SystemError>
+  readonly truncate: (length?: SizeInput) => Effect.Effect<void, System.SystemError>
+  readonly write: (buffer: Uint8Array) => Effect.Effect<Size, System.SystemError>
+  readonly writeAll: (buffer: Uint8Array) => Effect.Effect<void, System.SystemError>
 }
 
 export declare namespace File {
@@ -282,7 +267,7 @@ export class WatchBackend extends Context.Tag("@effect/platform/FileSystem/Watch
       path: string,
       stat: File.Info,
       options?: WatchOptions,
-    ) => Option.Option<Stream.Stream<WatchEvent, PlatformError.PlatformError>>
+    ) => Option.Option<Stream.Stream<WatchEvent, System.SystemError>>
   }
 >() {}
 
@@ -303,7 +288,8 @@ export const make = (
       Effect.tryMap(impl.readFile(path), {
         try: (_) => new TextDecoder(encoding).decode(_),
         catch: (cause) =>
-          new PlatformError.BadArgument({
+          new System.SystemError({
+            reason: "BadArgument",
             module: "FileSystem",
             method: "readFileString",
             description: "invalid encoding",
@@ -330,7 +316,8 @@ export const make = (
         Effect.try({
           try: () => new TextEncoder().encode(data),
           catch: (cause) =>
-            new PlatformError.BadArgument({
+            new System.SystemError({
+              reason: "BadArgument",
               module: "FileSystem",
               method: "writeFileString",
               description: "could not encode string",
@@ -348,14 +335,7 @@ const fileStream = (file: File, options: StreamOptions = {}) => {
 
   function loop(
     totalBytesRead: bigint,
-  ): Channel.Channel<
-    Chunk.Chunk<Uint8Array>,
-    unknown,
-    PlatformError.PlatformError,
-    unknown,
-    void,
-    unknown
-  > {
+  ): Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, System.SystemError, unknown, void, unknown> {
     if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
       return Channel.void
     }

package/src/GlobalLayer.ts

@@ -9,7 +9,7 @@ import * as MutableRef from "effect/MutableRef"
 import * as Option from "effect/Option"
 import * as Runtime from "effect/Runtime"
 
-import * as ChildProcess from "./ChildProcess.ts"
+import * as ChildProcess from "./_ChildProcess.ts"
 
 interface CacheEntry {
   readonly context: Context.Context<any>

package/src/Route.ts

@@ -6,14 +6,14 @@ import * as Predicate from "effect/Predicate"
 import * as Entity from "./Entity.ts"
 import * as RouteBody from "./RouteBody.ts"
 import * as RouteTree from "./RouteTree.ts"
-import type * as Values from "./Values.ts"
+import type * as Values from "./_Values.ts"
 
 export const RouteItems: unique symbol = Symbol()
 export const RouteDescriptor: unique symbol = Symbol()
 // only for structural type matching
 export const RouteBindings: unique symbol = Symbol()
 
-export const TypeId: unique symbol = Symbol.for("effect-start/RouteSet")
+export const TypeId = "~effect-start/RouteSet" as const
 
 export namespace RouteDescriptor {
   export type Any = {

package/src/RouteBody.ts

@@ -3,7 +3,7 @@ import type * as Stream from "effect/Stream"
 import type * as Utils from "effect/Utils"
 import * as Entity from "./Entity.ts"
 import * as Route from "./Route.ts"
-import type * as Values from "./Values.ts"
+import type * as Values from "./_Values.ts"
 
 export type Format = "text" | "html" | "json" | "bytes" | "*"
 

package/src/RouteHttp.ts

@@ -7,15 +7,15 @@ import * as Option from "effect/Option"
 import type * as ParseResult from "effect/ParseResult"
 import * as Runtime from "effect/Runtime"
 import * as Stream from "effect/Stream"
-import * as ContentNegotiation from "./ContentNegotiation.ts"
+import * as ContentNegotiation from "./_ContentNegotiation.ts"
 import * as Entity from "./Entity.ts"
-import type * as Http from "./Http.ts"
+import type * as Http from "./_Http.ts"
 import * as Route from "./Route.ts"
 import type * as RouteBody from "./RouteBody.ts"
 import * as RouteHttpTracer from "./RouteHttpTracer.ts"
 import type * as RouteMount from "./RouteMount.ts"
 import * as RouteTree from "./RouteTree.ts"
-import * as StreamExtra from "./StreamExtra.ts"
+import * as StreamExtra from "./_StreamExtra.ts"
 
 type UnboundedRouteWithMethod = Route.Route.With<{
   method: RouteMount.RouteMount.Method
@@ -63,10 +63,13 @@ const getStatusFromCause = (cause: Cause.Cause<unknown>): number => {
   return 500
 }
 
-const respondError = (options: { status: number; message: string }): Response =>
+const respondError = (
+  options: { status: number; message: string },
+  headers?: Record<string, string>,
+): Response =>
   new Response(JSON.stringify(options, null, 2), {
     status: options.status,
-    headers: { "content-type": "application/json" },
+    headers: { "content-type": "application/json", ...headers },
   })
 
 function streamResponse(
@@ -188,140 +191,158 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
       }
     }
 
-    return (request) => {
-      const method = request.method.toUpperCase()
-      const accept = request.headers.get("accept")
-      const methodRoutes = methodGroups[method] ?? []
+    const allowedMethods = Object.keys(methodGroups)
+      .filter((m) => methodGroups[m] !== undefined && methodGroups[m]!.length > 0)
+      .join(", ")
+
+    return (request) =>
+      new Promise((resolve) => {
+        const method = request.method.toUpperCase()
+        const accept = request.headers.get("accept")
+        const methodRoutes = methodGroups[method] ?? []
+
+        if (method === "OPTIONS" && methodRoutes.length === 0 && wildcards.length === 0) {
+          return resolve(
+            new Response(null, {
+              status: 204,
+              headers: { allow: allowedMethods },
+            }),
+          )
+        }
 
-      if (methodRoutes.length === 0 && wildcards.length === 0) {
-        return Promise.resolve(respondError({ status: 405, message: "method not allowed" }))
-      }
+        if (methodRoutes.length === 0 && wildcards.length === 0) {
+          return resolve(
+            respondError({ status: 405, message: "method not allowed" }, { allow: allowedMethods }),
+          )
+        }
 
-      const allRoutes = [...wildcards, ...methodRoutes]
-      const selectedFormat = determineSelectedFormat(accept, allRoutes)
+        const allRoutes = [...wildcards, ...methodRoutes]
+        const selectedFormat = determineSelectedFormat(accept, allRoutes)
 
-      const specificFormats = new Set<string>()
-      let hasWildcardFormatRoutes = false
-      for (const r of allRoutes) {
-        const format = Route.descriptor(r).format
-        if (format === "*") hasWildcardFormatRoutes = true
-        else if (format) specificFormats.add(format)
-      }
-      const hasSpecificFormatRoutes = specificFormats.size > 0
-      const varyAccept = specificFormats.size > 1
+        const specificFormats = new Set<string>()
+        let hasWildcardFormatRoutes = false
+        for (const r of allRoutes) {
+          const format = Route.descriptor(r).format
+          if (format === "*") hasWildcardFormatRoutes = true
+          else if (format) specificFormats.add(format)
+        }
+        const hasSpecificFormatRoutes = specificFormats.size > 0
+        const varyAccept = specificFormats.size > 1
 
-      if (selectedFormat === undefined && hasSpecificFormatRoutes && !hasWildcardFormatRoutes) {
-        return Promise.resolve(respondError({ status: 406, message: "not acceptable" }))
-      }
+        if (selectedFormat === undefined && hasSpecificFormatRoutes && !hasWildcardFormatRoutes) {
+          return resolve(respondError({ status: 406, message: "not acceptable" }))
+        }
 
-      const createChain = (initialContext: any): Effect.Effect<Entity.Entity<any>, any, any> => {
-        let index = 0
-        let currentContext = initialContext
-        let routePathSet = false
+        const createChain = (initialContext: any): Effect.Effect<Entity.Entity<any>, any, any> => {
+          let index = 0
+          let currentContext = initialContext
+          let routePathSet = false
 
-        const runNext = (passedContext?: any): Effect.Effect<Entity.Entity<any>, any, any> => {
-          if (passedContext !== undefined) {
-            currentContext = passedContext
-          }
+          const runNext = (passedContext?: any): Effect.Effect<Entity.Entity<any>, any, any> => {
+            if (passedContext !== undefined) {
+              currentContext = passedContext
+            }
 
-          if (index >= allRoutes.length) {
-            return Effect.succeed(
-              Entity.make({ status: 404, message: "route not found" }, { status: 404 }),
-            )
-          }
+            if (index >= allRoutes.length) {
+              return Effect.succeed(
+                Entity.make({ status: 404, message: "route not found" }, { status: 404 }),
+              )
+            }
 
-          const route = allRoutes[index++]
-          const descriptor = Route.descriptor(route)
-          const format = descriptor.format
-          const handler = route.handler as unknown as Handler
+            const route = allRoutes[index++]
+            const descriptor = Route.descriptor(route)
+            const format = descriptor.format
+            const handler = route.handler as unknown as Handler
 
-          if (format && format !== "*" && format !== selectedFormat) {
-            return runNext()
-          }
+            if (format && format !== "*" && format !== selectedFormat) {
+              return runNext()
+            }
 
-          currentContext = { ...currentContext, ...descriptor }
+            currentContext = { ...currentContext, ...descriptor }
 
-          const nextArg = (ctx?: any) => Entity.effect(Effect.suspend(() => runNext(ctx)))
+            const nextArg = (ctx?: any) => Entity.effect(Effect.suspend(() => runNext(ctx)))
 
-          const routePath = descriptor["path"]
-          if (!routePathSet && routePath !== undefined) {
-            routePathSet = true
-            return Effect.flatMap(Effect.currentSpan.pipe(Effect.option), (spanOption) => {
-              if (Option.isSome(spanOption)) {
-                spanOption.value.attribute("http.route", routePath)
-              }
-              return handler(currentContext, nextArg)
-            })
+            const routePath = descriptor["path"]
+            if (!routePathSet && routePath !== undefined) {
+              routePathSet = true
+              return Effect.flatMap(Effect.currentSpan.pipe(Effect.option), (spanOption) => {
+                if (Option.isSome(spanOption)) {
+                  spanOption.value.attribute("http.route", routePath)
+                }
+                return handler(currentContext, nextArg)
+              })
+            }
+
+            return handler(currentContext, nextArg)
           }
 
-          return handler(currentContext, nextArg)
+          return runNext()
         }
 
-        return runNext()
-      }
+        const effect = Effect.withFiberRuntime<Response, unknown, R>((fiber) => {
+          const tracerDisabled =
+            !fiber.getFiberRef(FiberRef.currentTracerEnabled) ||
+            fiber.getFiberRef(RouteHttpTracer.currentTracerDisabledWhen)(request)
 
-      const effect = Effect.withFiberRuntime<Response, unknown, R>((fiber) => {
-        const tracerDisabled =
-          !fiber.getFiberRef(FiberRef.currentTracerEnabled) ||
-          fiber.getFiberRef(RouteHttpTracer.currentTracerDisabledWhen)(request)
+          const url = new URL(request.url)
 
-        const url = new URL(request.url)
+          const innerEffect = Effect.gen(function* () {
+            const result = yield* createChain({ request, selectedFormat })
 
-        const innerEffect = Effect.gen(function* () {
-          const result = yield* createChain({ request, selectedFormat })
+            const entity = Entity.isEntity(result) ? result : Entity.make(result, { status: 200 })
 
-          const entity = Entity.isEntity(result) ? result : Entity.make(result, { status: 200 })
+            if (entity.status === 404 && entity.body === undefined) {
+              return respondError({ status: 406, message: "not acceptable" })
+            }
 
-          if (entity.status === 404 && entity.body === undefined) {
-            return respondError({ status: 406, message: "not acceptable" })
-          }
+            const response = yield* toResponse(entity, selectedFormat, runtime)
+            if (varyAccept) {
+              response.headers.set("vary", "Accept")
+            }
+            return response
+          })
 
-          const response = yield* toResponse(entity, selectedFormat, runtime)
-          if (varyAccept) {
-            response.headers.set("vary", "Accept")
+          if (tracerDisabled) {
+            return innerEffect
           }
-          return response
-        })
-
-        if (tracerDisabled) {
-          return innerEffect
-        }
-
-        const spanNameGenerator = fiber.getFiberRef(RouteHttpTracer.currentSpanNameGenerator)
-
-        return Effect.useSpan(
-          spanNameGenerator(request),
-          {
-            parent: Option.getOrUndefined(RouteHttpTracer.parentSpanFromHeaders(request.headers)),
-            kind: "server",
-            captureStackTrace: false,
-          },
-          (span) => {
-            span.attribute("http.request.method", request.method)
-            span.attribute("url.full", url.toString())
-            span.attribute("url.path", url.pathname)
-            const query = url.search.slice(1)
-            if (query !== "") {
-              span.attribute("url.query", query)
-            }
-            span.attribute("url.scheme", url.protocol.slice(0, -1))
 
-            const userAgent = request.headers.get("user-agent")
-            if (userAgent !== null) {
-              span.attribute("user_agent.original", userAgent)
-            }
+          const spanNameGenerator = fiber.getFiberRef(RouteHttpTracer.currentSpanNameGenerator)
+
+          return Effect.useSpan(
+            spanNameGenerator(request),
+            {
+              parent: Option.getOrUndefined(RouteHttpTracer.parentSpanFromHeaders(request.headers)),
+              kind: "server",
+              captureStackTrace: false,
+            },
+            (span) => {
+              span.attribute("http.request.method", request.method)
+              span.attribute("url.full", url.toString())
+              span.attribute("url.path", url.pathname)
+              const query = url.search.slice(1)
+              if (query !== "") {
+                span.attribute("url.query", query)
+              }
+              span.attribute("url.scheme", url.protocol.slice(0, -1))
 
-            return Effect.flatMap(Effect.exit(Effect.withParentSpan(innerEffect, span)), (exit) => {
-              if (exit._tag === "Success") {
-                span.attribute("http.response.status_code", exit.value.status)
+              const userAgent = request.headers.get("user-agent")
+              if (userAgent !== null) {
+                span.attribute("user_agent.original", userAgent)
               }
-              return exit
-            })
-          },
-        )
-      })
 
-      return new Promise((resolve) => {
+              return Effect.flatMap(
+                Effect.exit(Effect.withParentSpan(innerEffect, span)),
+                (exit) => {
+                  if (exit._tag === "Success") {
+                    span.attribute("http.response.status_code", exit.value.status)
+                  }
+                  return exit
+                },
+              )
+            },
+          )
+        })
+
         const fiber = runFork(
           effect.pipe(
             Effect.scoped,
@@ -356,7 +377,6 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
           }
         })
       })
-    }
   }
 }
 

package/src/RouteMount.ts

@@ -1,11 +1,11 @@
 import * as Function from "effect/Function"
 import type * as Types from "effect/Types"
-import type * as Http from "./Http.ts"
-import type * as PathPattern from "./PathPattern.ts"
+import type * as Http from "./_Http.ts"
+import type * as PathPattern from "./_PathPattern.ts"
 import * as Route from "./Route.ts"
 import type * as RouteBody from "./RouteBody.ts"
 
-const RouteSetTypeId: unique symbol = Symbol.for("effect-start/RouteSet")
+const RouteSetTypeId = "~effect-start/RouteSet" as const
 
 // oxlint-disable-next-line import/first, typescript/consistent-type-imports -- typeof import() is not an import statement
 type Module = typeof import("./RouteMount.ts")

package/src/RouteSchema.ts

@@ -3,8 +3,8 @@ import type * as ParseResult from "effect/ParseResult"
 import * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
 import * as Entity from "./Entity.ts"
-import * as Http from "./Http.ts"
-import * as PathPattern from "./PathPattern.ts"
+import * as Http from "./_Http.ts"
+import * as PathPattern from "./_PathPattern.ts"
 import * as Route from "./Route.ts"
 import * as RouteHook from "./RouteHook.ts"