@effect/platform 0.13.2 → 0.13.4

package/src/Http/Router.ts

@@ -4,6 +4,7 @@
 import type * as Chunk from "@effect/data/Chunk"
 import type * as Context from "@effect/data/Context"
 import type * as Option from "@effect/data/Option"
+import type * as Cause from "@effect/io/Cause"
 import type * as Effect from "@effect/io/Effect"
 import type * as App from "@effect/platform/Http/App"
 import type * as Method from "@effect/platform/Http/Method"
@@ -340,3 +341,150 @@ export const options: {
     handler: Route.Handler<R1, E1>
   ): Router<R | Exclude<R1, RouteContext>, E | E1>
 } = internal.options
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const use = internal.use
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const catchAll: {
+  <E, R2, E2>(f: (e: E) => Route.Handler<R2, E2>): <R>(
+    self: Router<R, E>
+  ) => Router<R2 | R, E2>
+  <R, E, R2, E2>(
+    self: Router<R, E>,
+    f: (e: E) => Route.Handler<R2, E2>
+  ): Router<R | R2, E2>
+} = internal.catchAll
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const catchAllCause: {
+  <E, R2, E2>(f: (e: Cause.Cause<E>) => Route.Handler<R2, E2>): <R>(
+    self: Router<R, E>
+  ) => Router<R2 | R, E2>
+  <R, E, R2, E2>(
+    self: Router<R, E>,
+    f: (e: Cause.Cause<E>) => Route.Handler<R2, E2>
+  ): Router<R | R2, E2>
+} = internal.catchAllCause
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const catchTag: {
+  <K extends E extends { _tag: string } ? E["_tag"] : never, E, R1, E1>(
+    k: K,
+    f: (e: Extract<E, { _tag: K }>) => Route.Handler<R1, E1>
+  ): <R>(self: Router<R, E>) => Router<R1 | R, E1 | Exclude<E, { _tag: K }>>
+  <R, E, K extends E extends { _tag: string } ? E["_tag"] : never, R1, E1>(
+    self: Router<R, E>,
+    k: K,
+    f: (e: Extract<E, { _tag: K }>) => Route.Handler<R1, E1>
+  ): Router<R | R1, E1 | Exclude<E, { _tag: K }>>
+} = internal.catchTag
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const catchTags: {
+  <
+    E,
+    Cases extends E extends { _tag: string } ? {
+        [K in E["_tag"]]+?:
+          | ((error: Extract<E, { _tag: K }>) => Route.Handler<any, any>)
+          | undefined
+      }
+      : {}
+  >(
+    cases: Cases
+  ): <R>(self: Router<R, E>) => Router<
+    | R
+    | {
+      [K in keyof Cases]: Cases[K] extends (
+        ...args: Array<any>
+      ) => Effect.Effect<infer R, any, any> ? R
+        : never
+    }[keyof Cases],
+    | Exclude<E, { _tag: keyof Cases }>
+    | {
+      [K in keyof Cases]: Cases[K] extends (
+        ...args: Array<any>
+      ) => Effect.Effect<any, infer E, any> ? E
+        : never
+    }[keyof Cases]
+  >
+  <
+    R,
+    E,
+    Cases extends E extends { _tag: string } ? {
+        [K in E["_tag"]]+?:
+          | ((error: Extract<E, { _tag: K }>) => Route.Handler<any, any>)
+          | undefined
+      }
+      : {}
+  >(
+    self: Router<R, E>,
+    cases: Cases
+  ): Router<
+    | R
+    | {
+      [K in keyof Cases]: Cases[K] extends (
+        ...args: Array<any>
+      ) => Effect.Effect<infer R, any, any> ? R
+        : never
+    }[keyof Cases],
+    | Exclude<E, { _tag: keyof Cases }>
+    | {
+      [K in keyof Cases]: Cases[K] extends (
+        ...args: Array<any>
+      ) => Effect.Effect<any, infer E, any> ? E
+        : never
+    }[keyof Cases]
+  >
+} = internal.catchTags
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const provideService: {
+  <T extends Context.Tag<any, any>>(tag: T, service: Context.Tag.Service<T>): <
+    R,
+    E
+  >(
+    self: Router<R, E>
+  ) => Router<Exclude<R, Context.Tag.Identifier<T>>, E>
+  <R, E, T extends Context.Tag<any, any>>(
+    self: Router<R, E>,
+    tag: T,
+    service: Context.Tag.Service<T>
+  ): Router<Exclude<R, Context.Tag.Identifier<T>>, E>
+} = internal.provideService
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const provideServiceEffect: {
+  <T extends Context.Tag<any, any>, R1, E1>(
+    tag: T,
+    effect: Effect.Effect<R1, E1, Context.Tag.Service<T>>
+  ): <R, E>(
+    self: Router<R, E>
+  ) => Router<R1 | Exclude<R, Context.Tag.Identifier<T>>, E1 | E>
+  <R, E, T extends Context.Tag<any, any>, R1, E1>(
+    self: Router<R, E>,
+    tag: T,
+    effect: Effect.Effect<R1, E1, Context.Tag.Service<T>>
+  ): Router<R1 | Exclude<R, Context.Tag.Identifier<T>>, E | E1>
+} = internal.provideServiceEffect

package/src/Http/ServerResponse.ts

@@ -6,6 +6,7 @@ import type * as Effect from "@effect/io/Effect"
 import type * as PlatformError from "@effect/platform/Error"
 import type * as FileSystem from "@effect/platform/FileSystem"
 import type * as Body from "@effect/platform/Http/Body"
+import type * as Etag from "@effect/platform/Http/Etag"
 import type * as Headers from "@effect/platform/Http/Headers"
 import type * as Error from "@effect/platform/Http/ServerError"
 import type * as ServerRequest from "@effect/platform/Http/ServerRequest"
@@ -172,7 +173,7 @@ export const stream: (body: Stream.Stream<never, unknown, Uint8Array>, options?:
 export const file: (
   path: string,
   options?: Options & FileSystem.StreamOptions
-) => Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, ServerResponse> = internal.file
+) => Effect.Effect<FileSystem.FileSystem | Etag.Generator, PlatformError.PlatformError, ServerResponse> = internal.file
 
 /**
  * @since 1.0.0

package/src/internal/http/body.ts

@@ -4,6 +4,7 @@ import * as FileSystem from "@effect/platform/FileSystem"
 import type * as Body from "@effect/platform/Http/Body"
 import * as Schema from "@effect/schema/Schema"
 import type * as Stream_ from "@effect/stream/Stream"
+import * as Mime from "mime/lite"
 
 /** @internal */
 export const TypeId: Body.TypeId = Symbol.for(
@@ -100,9 +101,27 @@ export const file = (
   Effect.flatMap(
     FileSystem.FileSystem,
     (fs) =>
-      Effect.map(
-        fs.stat(path),
-        (stat) => stream(fs.stream(path, options), options?.contentType, Number(stat.size))
+      Effect.map(fs.stat(path), (info) =>
+        stream(
+          fs.stream(path, options),
+          options?.contentType ?? Mime.getType(path) ?? undefined,
+          Number(info.size)
+        ))
+  )
+
+/** @internal */
+export const fileInfo = (
+  path: string,
+  info: FileSystem.File.Info,
+  options?: FileSystem.StreamOptions & { readonly contentType?: string }
+): Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, Body.Stream> =>
+  Effect.map(
+    FileSystem.FileSystem,
+    (fs) =>
+      stream(
+        fs.stream(path, options),
+        options?.contentType ?? Mime.getType(path) ?? undefined,
+        Number(info.size)
       )
   )
 

package/src/internal/http/client.ts

@@ -21,9 +21,13 @@ import * as Schema from "@effect/schema/Schema"
 import * as Stream from "@effect/stream/Stream"
 
 /** @internal */
-export const tag = Context.Tag<Client.Client.Default>("@effect/platform/Http/Client")
+export const TypeId: Client.TypeId = Symbol.for("@effect/platform/Http/Client") as Client.TypeId
+
+/** @internal */
+export const tag = Context.Tag<Client.Client.Default>(TypeId)
 
 const clientProto = {
+  [TypeId]: TypeId,
   pipe() {
     return pipeArguments(this, arguments)
   }

package/src/internal/http/etag.ts

@@ -0,0 +1,20 @@
+import * as Context from "@effect/data/Context"
+import type * as Etag from "@effect/platform/Http/Etag"
+
+/** @internal */
+export const GeneratorTypeId: Etag.GeneratorTypeId = Symbol.for(
+  "@effect/platform/Http/Etag/Generator"
+) as Etag.GeneratorTypeId
+
+/** @internal */
+export const tag = Context.Tag<Etag.Generator>(GeneratorTypeId)
+
+/** @internal */
+export const toString = (self: Etag.Etag): string => {
+  switch (self._tag) {
+    case "Weak":
+      return `W/"${self.value}"`
+    case "Strong":
+      return `"${self.value}"`
+  }
+}

package/src/internal/http/middleware.ts

@@ -1,6 +1,5 @@
-import { dual } from "@effect/data/Function"
+import { flow } from "@effect/data/Function"
 import * as Effect from "@effect/io/Effect"
-import type * as App from "@effect/platform/Http/App"
 import * as Headers from "@effect/platform/Http/Headers"
 import type * as Middleware from "@effect/platform/Http/Middleware"
 import * as ServerRequest from "@effect/platform/Http/ServerRequest"
@@ -62,17 +61,4 @@ export const xForwardedHeaders = make((httpApp) =>
 )
 
 /** @internal */
-export const compose = dual<
-  <B extends App.Default<any, any>, C extends App.Default<any, any>>(
-    that: (b: B) => C
-  ) => <A extends App.Default<any, any>>(
-    self: (a: A) => B
-  ) => (a: A) => C,
-  <A extends App.Default<any, any>, B extends App.Default<any, any>, C extends App.Default<any, any>>(
-    self: (a: A) => B,
-    that: (b: B) => C
-  ) => (a: A) => C
->(2, (self, that) => (inApp) => that(self(inApp)))
-
-/** @internal */
-export const loggerTracer = compose(tracer, logger)
+export const loggerTracer = flow(tracer, logger)

package/src/internal/http/router.ts

@@ -5,6 +5,7 @@ import { dual } from "@effect/data/Function"
 import * as Hash from "@effect/data/Hash"
 import * as Option from "@effect/data/Option"
 import { pipeArguments } from "@effect/data/Pipeable"
+import type * as Cause from "@effect/io/Cause"
 import * as Effect from "@effect/io/Effect"
 import type * as App from "@effect/platform/Http/App"
 import type * as Method from "@effect/platform/Http/Method"
@@ -98,7 +99,7 @@ const toHttpApp = <R, E>(
   const mounts = Chunk.toReadonlyArray(self.mounts)
   const mountsLen = mounts.length
   Chunk.forEach(self.routes, (route) => {
-    function fn(_: any, __: any) {
+    function fn() {
       return route
     }
     if (route.method === "*") {
@@ -302,3 +303,130 @@ export const head = route("HEAD")
 
 /** @internal */
 export const options = route("OPTIONS")
+
+/** @internal */
+export const use = dual<
+  <R, E, R1, E1>(
+    f: (self: Router.Route.Handler<R, E>) => Router.Route.Handler<R1, E1>
+  ) => (self: Router.Router<R, E>) => Router.Router<R1, E1>,
+  <R, E, R1, E1>(
+    self: Router.Router<R, E>,
+    f: (self: Router.Route.Handler<R, E>) => Router.Route.Handler<R1, E1>
+  ) => Router.Router<R1, E1>
+>(2, (self, f) =>
+  new RouterImpl(
+    Chunk.map(
+      self.routes,
+      (route) => new RouteImpl(route.method, route.path, f(route.handler), route.prefix)
+    ),
+    Chunk.map(
+      self.mounts,
+      ([path, app]) => [path, f(app as any)]
+    )
+  ))
+
+/** @internal */
+export const catchAll = dual<
+  <E, R2, E2>(
+    f: (e: E) => Router.Route.Handler<R2, E2>
+  ) => <R>(self: Router.Router<R, E>) => Router.Router<R2 | R, E2>,
+  <R, E, R2, E2>(
+    self: Router.Router<R, E>,
+    f: (e: E) => Router.Route.Handler<R2, E2>
+  ) => Router.Router<R2 | R, E2>
+>(2, (self, f) => use(self, Effect.catchAll(f)))
+
+/** @internal */
+export const catchAllCause = dual<
+  <E, R2, E2>(
+    f: (e: Cause.Cause<E>) => Router.Route.Handler<R2, E2>
+  ) => <R>(self: Router.Router<R, E>) => Router.Router<R2 | R, E2>,
+  <R, E, R2, E2>(
+    self: Router.Router<R, E>,
+    f: (e: Cause.Cause<E>) => Router.Route.Handler<R2, E2>
+  ) => Router.Router<R2 | R, E2>
+>(2, (self, f) => use(self, Effect.catchAllCause(f)))
+
+/** @internal */
+export const catchTag = dual<
+  <K extends (E extends { _tag: string } ? E["_tag"] : never), E, R1, E1>(
+    k: K,
+    f: (e: Extract<E, { _tag: K }>) => Router.Route.Handler<R1, E1>
+  ) => <R>(self: Router.Router<R, E>) => Router.Router<R | R1, Exclude<E, { _tag: K }> | E1>,
+  <R, E, K extends (E extends { _tag: string } ? E["_tag"] : never), R1, E1>(
+    self: Router.Router<R, E>,
+    k: K,
+    f: (e: Extract<E, { _tag: K }>) => Router.Route.Handler<R1, E1>
+  ) => Router.Router<R | R1, Exclude<E, { _tag: K }> | E1>
+>(3, (self, k, f) => use(self, Effect.catchTag(k, f)))
+
+/** @internal */
+export const catchTags: {
+  <
+    E,
+    Cases extends (E extends { _tag: string } ? {
+        [K in E["_tag"]]+?: (error: Extract<E, { _tag: K }>) => Router.Route.Handler<any, any>
+      } :
+      {})
+  >(
+    cases: Cases
+  ): <R>(self: Router.Router<R, E>) => Router.Router<
+    | R
+    | {
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<infer R, any, any>) ? R : never
+    }[keyof Cases],
+    | Exclude<E, { _tag: keyof Cases }>
+    | {
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, infer E, any>) ? E : never
+    }[keyof Cases]
+  >
+  <
+    R,
+    E,
+    Cases extends (E extends { _tag: string } ? {
+        [K in E["_tag"]]+?: (error: Extract<E, { _tag: K }>) => Router.Route.Handler<any, any>
+      } :
+      {})
+  >(
+    self: Router.Router<R, E>,
+    cases: Cases
+  ): Router.Router<
+    | R
+    | {
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<infer R, any, any>) ? R : never
+    }[keyof Cases],
+    | Exclude<E, { _tag: keyof Cases }>
+    | {
+      [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, infer E, any>) ? E : never
+    }[keyof Cases]
+  >
+} = dual(2, (self: Router.Router<any, any>, cases: {}) => use(self, Effect.catchTags(cases)))
+
+export const provideService = dual<
+  <T extends Context.Tag<any, any>>(
+    tag: T,
+    service: Context.Tag.Service<T>
+  ) => <R, E>(self: Router.Router<R, E>) => Router.Router<Exclude<R, Context.Tag.Identifier<T>>, E>,
+  <R, E, T extends Context.Tag<any, any>>(
+    self: Router.Router<R, E>,
+    tag: T,
+    service: Context.Tag.Service<T>
+  ) => Router.Router<Exclude<R, Context.Tag.Identifier<T>>, E>
+>(3, (self, tag, service) => use(self, Effect.provideService(tag, service)))
+
+/* @internal */
+export const provideServiceEffect = dual<
+  <T extends Context.Tag<any, any>, R1, E1>(
+    tag: T,
+    effect: Effect.Effect<R1, E1, Context.Tag.Service<T>>
+  ) => <R, E>(self: Router.Router<R, E>) => Router.Router<R1 | Exclude<R, Context.Tag.Identifier<T>>, E | E1>,
+  <R, E, T extends Context.Tag<any, any>, R1, E1>(
+    self: Router.Router<R, E>,
+    tag: T,
+    effect: Effect.Effect<R1, E1, Context.Tag.Service<T>>
+  ) => Router.Router<R1 | Exclude<R, Context.Tag.Identifier<T>>, E | E1>
+>(3, <R, E, T extends Context.Tag<any, any>, R1, E1>(
+  self: Router.Router<R, E>,
+  tag: T,
+  effect: Effect.Effect<R1, E1, Context.Tag.Service<T>>
+) => use(self, Effect.provideServiceEffect(tag, effect)))

package/src/internal/http/server.ts

@@ -12,7 +12,7 @@ import type * as ServerRequest from "@effect/platform/Http/ServerRequest"
 export const TypeId: Server.TypeId = Symbol.for("@effect/platform/Http/Server") as Server.TypeId
 
 /** @internal */
-export const serverTag = Context.Tag<Server.Server>("@effect/platform/Http/Server")
+export const serverTag = Context.Tag<Server.Server>(TypeId)
 
 const serverProto = {
   [TypeId]: TypeId

package/src/internal/http/serverResponse.ts

@@ -1,9 +1,10 @@
-import { dual } from "@effect/data/Function"
+import { dual, pipe } from "@effect/data/Function"
 import { pipeArguments } from "@effect/data/Pipeable"
 import * as Effect from "@effect/io/Effect"
 import type * as PlatformError from "@effect/platform/Error"
-import type * as FileSystem from "@effect/platform/FileSystem"
+import * as FileSystem from "@effect/platform/FileSystem"
 import type * as Body from "@effect/platform/Http/Body"
+import * as Etag from "@effect/platform/Http/Etag"
 import * as Headers from "@effect/platform/Http/Headers"
 import type * as Error from "@effect/platform/Http/ServerError"
 import * as ServerRequest from "@effect/platform/Http/ServerRequest"
@@ -141,14 +142,35 @@ export const schemaJson = <I, A>(
 export const file = (
   path: string,
   options?: ServerResponse.Options & FileSystem.StreamOptions
-): Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, ServerResponse.ServerResponse> =>
-  Effect.map(internalBody.file(path, options), (body) =>
-    new ServerResponseImpl(
-      options?.status ?? 200,
-      options?.statusText,
-      options?.headers ?? Headers.empty,
-      body
-    ))
+): Effect.Effect<
+  FileSystem.FileSystem | Etag.Generator,
+  PlatformError.PlatformError,
+  ServerResponse.ServerResponse
+> =>
+  pipe(
+    Effect.bindTo(Effect.flatMap(FileSystem.FileSystem, (fs) => fs.stat(path)), "info"),
+    Effect.bind("etag", ({ info }) =>
+      Effect.flatMap(
+        Etag.Generator,
+        (generator) => generator.fromFileInfo(info)
+      )),
+    Effect.bind("body", ({ info }) => internalBody.fileInfo(path, info, options)),
+    Effect.map(({ body, etag, info }) => {
+      const headers: Record<string, string> = {
+        ...(options?.headers ?? {}),
+        etag: Etag.toString(etag)
+      }
+      if (info.mtime._tag === "Some") {
+        headers["last-modified"] = info.mtime.value.toUTCString()
+      }
+      return new ServerResponseImpl(
+        options?.status ?? 200,
+        options?.statusText,
+        headers,
+        body
+      )
+    })
+  )
 
 /** @internal */
 export const urlParams = (