@effect/platform 0.63.2 → 0.64.0

package/src/Socket.ts

@@ -1,7 +1,6 @@
 /**
  * @since 1.0.0
  */
-import * as Cause from "effect/Cause"
 import * as Channel from "effect/Channel"
 import * as Chunk from "effect/Chunk"
 import * as Context from "effect/Context"
@@ -12,6 +11,7 @@ import * as ExecutionStrategy from "effect/ExecutionStrategy"
 import * as Exit from "effect/Exit"
 import * as FiberRef from "effect/FiberRef"
 import * as FiberSet from "effect/FiberSet"
+import { dual } from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
 import * as Predicate from "effect/Predicate"
@@ -32,6 +32,12 @@ export const TypeId: unique symbol = Symbol.for("@effect/platform/Socket")
  */
 export type TypeId = typeof TypeId
 
+/**
+ * @since 1.0.0
+ * @category guards
+ */
+export const isSocket = (u: unknown): u is Socket => Predicate.hasProperty(u, TypeId)
+
 /**
  * @since 1.0.0
  * @category tags
@@ -171,10 +177,11 @@ export class SocketCloseError extends TypeIdError(SocketErrorTypeId, "SocketErro
  * @since 1.0.0
  * @category combinators
  */
-export const toChannel = <IE>(
-  self: Socket
+export const toChannelMap = <IE, A>(
+  self: Socket,
+  f: (data: Uint8Array | string) => A
 ): Channel.Channel<
-  Chunk.Chunk<Uint8Array>,
+  Chunk.Chunk<A>,
   Chunk.Chunk<Uint8Array | string | CloseEvent>,
   SocketError | IE,
   IE,
@@ -183,25 +190,27 @@ export const toChannel = <IE>(
 > =>
   Effect.scope.pipe(
     Effect.bindTo("scope"),
+    Effect.let("state", () => ({ finished: false, buffer: [] as Array<A> })),
+    Effect.bind("semaphore", () => Effect.makeSemaphore(0)),
     Effect.bind("writeScope", ({ scope }) => Scope.fork(scope, ExecutionStrategy.sequential)),
     Effect.bind("write", ({ writeScope }) => Scope.extend(self.writer, writeScope)),
-    Effect.bind("exitQueue", (_) => Queue.unbounded<Exit.Exit<Chunk.Chunk<Uint8Array>, SocketError | IE>>()),
+    Effect.bind("deferred", () => Deferred.make<void, SocketError | IE>()),
     Effect.let(
       "input",
       (
-        { exitQueue, write, writeScope }
+        { deferred, write, writeScope }
       ): AsyncProducer.AsyncInputProducer<IE, Chunk.Chunk<Uint8Array | string | CloseEvent>, unknown> => ({
         awaitRead: () => Effect.void,
         emit(chunk) {
           return Effect.catchAllCause(
             Effect.forEach(chunk, write, { discard: true }),
-            (cause) => Queue.offer(exitQueue, Exit.failCause(cause))
+            (cause) => Deferred.failCause(deferred, cause)
           )
         },
         error(error) {
           return Effect.zipRight(
             Scope.close(writeScope, Exit.void),
-            Queue.offer(exitQueue, Exit.failCause(error))
+            Deferred.failCause(deferred, error)
           )
         },
         done() {
@@ -209,30 +218,95 @@ export const toChannel = <IE>(
         }
       })
     ),
-    Effect.tap(({ exitQueue }) =>
-      self.run((data) => Queue.offer(exitQueue, Exit.succeed(Chunk.of(data)))).pipe(
-        Effect.zipRight(Effect.failCause(Cause.empty)),
-        Effect.exit,
-        Effect.tap((exit) => Queue.offer(exitQueue, exit)),
-        Effect.fork,
+    Effect.tap(({ deferred, scope, semaphore, state }) =>
+      self.runRaw((data) => {
+        state.buffer.push(f(data))
+        return semaphore.release(1)
+      }).pipe(
+        Effect.intoDeferred(deferred),
+        Effect.raceFirst(Deferred.await(deferred)),
+        Effect.ensuring(Effect.suspend(() => {
+          state.finished = true
+          return semaphore.release(1)
+        })),
+        Effect.forkIn(scope),
         Effect.interruptible
       )
     ),
-    Effect.map(({ exitQueue, input }) => {
-      const loop: Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, SocketError | IE, unknown, void, unknown> = Channel
-        .flatMap(
-          Queue.take(exitQueue),
-          Exit.match({
-            onFailure: (cause) => Cause.isEmptyType(cause) ? Channel.void : Channel.failCause(cause),
-            onSuccess: (chunk) => Channel.zipRight(Channel.write(chunk), loop)
-          })
-        )
-
+    Effect.map(({ deferred, input, semaphore, state }) => {
+      const loop: Channel.Channel<Chunk.Chunk<A>, unknown, SocketError | IE, unknown, void, unknown> = Channel.flatMap(
+        semaphore.take(1),
+        (_) => {
+          if (state.buffer.length === 0) {
+            return state.finished ? Deferred.await(deferred) : loop
+          }
+          const chunk = Chunk.unsafeFromArray(state.buffer)
+          state.buffer = []
+          return Channel.zipRight(Channel.write(chunk), state.finished ? Deferred.await(deferred) : loop)
+        }
+      )
       return Channel.embedInput(loop, input)
     }),
     Channel.unwrapScoped
   )
 
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const toChannel = <IE>(
+  self: Socket
+): Channel.Channel<
+  Chunk.Chunk<Uint8Array>,
+  Chunk.Chunk<Uint8Array | string | CloseEvent>,
+  SocketError | IE,
+  IE,
+  void,
+  unknown
+> => {
+  const encoder = new TextEncoder()
+  return toChannelMap(self, (data) => typeof data === "string" ? encoder.encode(data) : data)
+}
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const toChannelString: {
+  (encoding?: string | undefined): <IE>(self: Socket) => Channel.Channel<
+    Chunk.Chunk<string>,
+    Chunk.Chunk<Uint8Array | string | CloseEvent>,
+    SocketError | IE,
+    IE,
+    void,
+    unknown
+  >
+  <IE>(
+    self: Socket,
+    encoding?: string | undefined
+  ): Channel.Channel<
+    Chunk.Chunk<string>,
+    Chunk.Chunk<Uint8Array | string | CloseEvent>,
+    SocketError | IE,
+    IE,
+    void,
+    unknown
+  >
+} = dual((args) => isSocket(args[0]), <IE>(
+  self: Socket,
+  encoding?: string | undefined
+): Channel.Channel<
+  Chunk.Chunk<string>,
+  Chunk.Chunk<Uint8Array | string | CloseEvent>,
+  SocketError | IE,
+  IE,
+  void,
+  unknown
+> => {
+  const decoder = new TextDecoder(encoding)
+  return toChannelMap(self, (data) => typeof data === "string" ? data : decoder.decode(data))
+})
+
 /**
  * @since 1.0.0
  * @category combinators
@@ -348,16 +422,12 @@ export const fromWebSocket = <R>(
     Effect.map(
       Queue.dropping<Uint8Array | string | CloseEvent>(fiber.getFiberRef(currentSendQueueCapacity)),
       (sendQueue) => {
-        const acquireContext = fiber.getFiberRef(FiberRef.currentContext) as Context.Context<Exclude<R, Scope.Scope>>
+        const acquireContext = fiber.getFiberRef(FiberRef.currentContext) as Context.Context<R>
         const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
         const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R>) =>
-          Effect.scope.pipe(
-            Effect.bindTo("scope"),
-            Effect.bind("ws", ({ scope }) =>
-              acquire.pipe(
-                Effect.provide(Context.add(acquireContext, Scope.Scope, scope))
-              ) as Effect.Effect<globalThis.WebSocket>),
-            Effect.bind("fiberSet", (_) => FiberSet.make<any, E | SocketError>()),
+          acquire.pipe(
+            Effect.bindTo("ws"),
+            Effect.bind("fiberSet", () => FiberSet.make<any, E | SocketError>()),
             Effect.bind("run", ({ fiberSet, ws }) =>
               Effect.provideService(FiberSet.runtime(fiberSet)<R>(), WebSocket, ws)),
             Effect.tap(({ fiberSet, run, ws }) => {
@@ -392,19 +462,12 @@ export const fromWebSocket = <R>(
               }
 
               if (ws.readyState !== 1) {
-                return Effect.async<void, SocketError, never>((resume) => {
-                  function onOpen() {
-                    ws.removeEventListener("open", onOpen)
-                    resume(Effect.void)
-                  }
-                  ws.addEventListener("open", onOpen)
-                  return Effect.sync(() => {
-                    ws.removeEventListener("open", onOpen)
-                  })
-                }).pipe(
-                  Effect.tap((_) => {
-                    open = true
-                  }),
+                const openDeferred = Deferred.unsafeMake<void>(fiber.id())
+                ws.onopen = () => {
+                  open = true
+                  Deferred.unsafeDone(openDeferred, Effect.void)
+                }
+                return Deferred.await(openDeferred).pipe(
                   Effect.timeoutFail({
                     duration: options?.openTimeout ?? 10000,
                     onTimeout: () =>
@@ -445,6 +508,7 @@ export const fromWebSocket = <R>(
                 (_) => Effect.void
               )
             ),
+            Effect.mapInputContext((input: Context.Context<R | Scope.Scope>) => Context.merge(acquireContext, input)),
             Effect.scoped,
             Effect.interruptible
           )
@@ -534,15 +598,11 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
     Effect.map(
       Queue.dropping<Uint8Array | string | CloseEvent | typeof EOF>(fiber.getFiberRef(currentSendQueueCapacity)),
       (sendQueue) => {
-        const acquireContext = fiber.getFiberRef(FiberRef.currentContext) as Context.Context<Exclude<R, Scope.Scope>>
+        const acquireContext = fiber.getFiberRef(FiberRef.currentContext) as Context.Context<R>
         const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
         const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R>) =>
-          Effect.scope.pipe(
-            Effect.bindTo("scope"),
-            Effect.bind("stream", ({ scope }) =>
-              acquire.pipe(
-                Effect.provide(Context.add(acquireContext, Scope.Scope, scope))
-              ) as Effect.Effect<InputTransformStream>),
+          acquire.pipe(
+            Effect.bindTo("stream"),
             Effect.bind("reader", ({ stream }) =>
               Effect.acquireRelease(
                 Effect.sync(() => stream.readable.getReader()),
@@ -615,6 +675,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
                 (_) => Effect.void
               )
             ),
+            Effect.mapInputContext((input: Context.Context<R | Scope.Scope>) => Context.merge(acquireContext, input)),
             Effect.scoped,
             Effect.interruptible
           )

package/src/internal/etag.ts

@@ -1,5 +1,9 @@
 import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
 import type * as Etag from "../Etag.js"
+import type * as FileSystem from "../FileSystem.js"
+import type * as Body from "../HttpBody.js"
 
 /** @internal */
 export const GeneratorTypeId: Etag.GeneratorTypeId = Symbol.for(
@@ -18,3 +22,42 @@ export const toString = (self: Etag.Etag): string => {
       return `"${self.value}"`
   }
 }
+
+const fromFileInfo = (info: FileSystem.File.Info) => {
+  const mtime = info.mtime._tag === "Some"
+    ? info.mtime.value.getTime().toString(16)
+    : "0"
+  return `${info.size.toString(16)}-${mtime}`
+}
+
+const fromFileWeb = (file: Body.HttpBody.FileLike) => {
+  return `${file.size.toString(16)}-${file.lastModified.toString(16)}`
+}
+
+/** @internal */
+export const layer = Layer.succeed(
+  tag,
+  tag.of({
+    [GeneratorTypeId]: GeneratorTypeId,
+    fromFileInfo(info) {
+      return Effect.sync(() => ({ _tag: "Strong", value: fromFileInfo(info) }))
+    },
+    fromFileWeb(file) {
+      return Effect.sync(() => ({ _tag: "Strong", value: fromFileWeb(file) }))
+    }
+  })
+)
+
+/** @internal */
+export const layerWeak = Layer.succeed(
+  tag,
+  tag.of({
+    [GeneratorTypeId]: GeneratorTypeId,
+    fromFileInfo(info) {
+      return Effect.sync(() => ({ _tag: "Weak", value: fromFileInfo(info) }))
+    },
+    fromFileWeb(file) {
+      return Effect.sync(() => ({ _tag: "Weak", value: fromFileWeb(file) }))
+    }
+  })
+)

package/src/internal/httpPlatform.ts

@@ -1,12 +1,15 @@
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
-import { pipe } from "effect/Function"
+import { identity, pipe } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Stream from "effect/Stream"
 import * as Etag from "../Etag.js"
 import * as FileSystem from "../FileSystem.js"
 import * as Headers from "../Headers.js"
 import type * as Body from "../HttpBody.js"
 import type * as Platform from "../HttpPlatform.js"
 import type * as ServerResponse from "../HttpServerResponse.js"
+import * as serverResponse from "./httpServerResponse.js"
 
 /** @internal */
 export const TypeId: Platform.TypeId = Symbol.for("@effect/platform/HttpPlatform") as Platform.TypeId
@@ -33,9 +36,9 @@ export const make = (impl: {
     options?: FileSystem.StreamOptions
   ) => ServerResponse.HttpServerResponse
 }): Effect.Effect<Platform.HttpPlatform, never, FileSystem.FileSystem | Etag.Generator> =>
-  Effect.gen(function*(_) {
-    const fs = yield* _(FileSystem.FileSystem)
-    const etagGen = yield* _(Etag.Generator)
+  Effect.gen(function*() {
+    const fs = yield* FileSystem.FileSystem
+    const etagGen = yield* Etag.Generator
 
     return tag.of({
       [TypeId]: TypeId,
@@ -83,3 +86,28 @@ export const make = (impl: {
       }
     })
   })
+
+/** @internal */
+export const layer = Layer.effect(
+  tag,
+  Effect.flatMap(FileSystem.FileSystem, (fs) =>
+    make({
+      fileResponse(path, status, statusText, headers, start, end, contentLength) {
+        return serverResponse.stream(
+          fs.stream(path, {
+            offset: start,
+            bytesToRead: end !== undefined ? end - start : undefined
+          }),
+          { contentLength, headers, status, statusText }
+        )
+      },
+      fileWebResponse(file, status, statusText, headers, _options) {
+        return serverResponse.stream(
+          Stream.fromReadableStream(() => file.stream() as ReadableStream<Uint8Array>, identity),
+          { headers, status, statusText }
+        )
+      }
+    }))
+).pipe(
+  Layer.provide(Etag.layerWeak)
+)

package/src/internal/httpServerResponse.ts

@@ -1,5 +1,6 @@
 import type { ParseOptions } from "@effect/schema/AST"
 import type * as Schema from "@effect/schema/Schema"
+import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Effectable from "effect/Effectable"
 import { dual } from "effect/Function"
@@ -11,7 +12,7 @@ import type * as PlatformError from "../Error.js"
 import type * as FileSystem from "../FileSystem.js"
 import * as Headers from "../Headers.js"
 import type * as Body from "../HttpBody.js"
-import * as Platform from "../HttpPlatform.js"
+import type * as Platform from "../HttpPlatform.js"
 import type * as Respondable from "../HttpServerRespondable.js"
 import type * as ServerResponse from "../HttpServerResponse.js"
 import * as Template from "../Template.js"
@@ -214,13 +215,15 @@ export const schemaJson = <A, I, R>(
       ))
 }
 
+const httpPlatform = Context.GenericTag<Platform.HttpPlatform>("@effect/platform/HttpPlatform")
+
 /** @internal */
 export const file = (
   path: string,
   options?: (ServerResponse.Options & FileSystem.StreamOptions) | undefined
 ): Effect.Effect<ServerResponse.HttpServerResponse, PlatformError.PlatformError, Platform.HttpPlatform> =>
   Effect.flatMap(
-    Platform.HttpPlatform,
+    httpPlatform,
     (platform) => platform.fileResponse(path, options)
   )
 
@@ -230,7 +233,7 @@ export const fileWeb = (
   options?: (ServerResponse.Options.WithContent & FileSystem.StreamOptions) | undefined
 ): Effect.Effect<ServerResponse.HttpServerResponse, never, Platform.HttpPlatform> =>
   Effect.flatMap(
-    Platform.HttpPlatform,
+    httpPlatform,
     (platform) => platform.fileWebResponse(file, options)
   )
 

package/src/internal/multipart.ts

@@ -287,9 +287,7 @@ const makeFromQueue = <IE>(
           if (chunk === null) {
             parser.end()
           } else {
-            Chunk.forEach(chunk, function(buf) {
-              parser.write(buf)
-            })
+            Chunk.forEach(chunk, parser.write)
           }
         })
     )