@effect/platform 0.69.16 → 0.69.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/platform",
-  "version": "0.69.16",
+  "version": "0.69.18",
   "description": "Unified interfaces for common platform-specific services",
   "license": "MIT",
   "repository": {
@@ -14,7 +14,7 @@
     "multipasta": "^0.2.5"
   },
   "peerDependencies": {
-    "effect": "^3.10.10"
+    "effect": "^3.10.12"
   },
   "publishConfig": {
     "provenance": true

package/src/HttpApi.ts

@@ -9,6 +9,7 @@ import { type Pipeable, pipeArguments } from "effect/Pipeable"
 import * as Predicate from "effect/Predicate"
 import type * as Schema from "effect/Schema"
 import * as AST from "effect/SchemaAST"
+import type { Mutable } from "effect/Types"
 import type * as HttpApiEndpoint from "./HttpApiEndpoint.js"
 import { HttpApiDecodeError } from "./HttpApiError.js"
 import type * as HttpApiGroup from "./HttpApiGroup.js"
@@ -57,9 +58,17 @@ export interface HttpApi<
   readonly middlewares: HashSet.HashSet<HttpApiMiddleware.TagClassAny>
 
   /**
-   * Add an endpoint to the `HttpApi`.
+   * Add a `HttpApiGroup` to the `HttpApi`.
    */
   add<A extends HttpApiGroup.HttpApiGroup.Any>(group: A): HttpApi<Groups | A, E, R>
+  /**
+   * Add another `HttpApi` to the `HttpApi`.
+   */
+  addHttpApi<Groups2 extends HttpApiGroup.HttpApiGroup.Any, E2, R2>(api: HttpApi<Groups2, E2, R2>): HttpApi<
+    Groups | HttpApiGroup.HttpApiGroup.AddContext<Groups2, R2>,
+    E | E2,
+    R
+  >
   /**
    * Add an global error to the `HttpApi`.
    */
@@ -142,6 +151,25 @@ const Proto = {
       middlewares: this.middlewares
     })
   },
+  addHttpApi(
+    this: HttpApi.AnyWithProps,
+    api: HttpApi.AnyWithProps
+  ) {
+    return makeProto({
+      groups: HashMap.union(
+        this.groups,
+        HashMap.map(api.groups, (group) => {
+          const newGroup: Mutable<HttpApiGroup.HttpApiGroup.AnyWithProps> = group.annotateContext(Context.empty())
+          newGroup.annotations = Context.merge(api.annotations, newGroup.annotations)
+          newGroup.middlewares = HashSet.union(newGroup.middlewares, api.middlewares)
+          return newGroup
+        })
+      ),
+      errorSchema: HttpApiSchema.UnionUnify(this.errorSchema, api.errorSchema),
+      annotations: this.annotations,
+      middlewares: this.middlewares
+    })
+  },
   addError(
     this: HttpApi.AnyWithProps,
     schema: Schema.Schema.Any,

package/src/HttpApiBuilder.ts

@@ -438,7 +438,7 @@ export const group = <
     handlers: Handlers.FromGroup<ApiError, ApiR, HttpApiGroup.HttpApiGroup.WithName<Groups, Name>>
   ) => Handlers.ValidateReturn<Return>
 ): Layer.Layer<
-  HttpApiGroup.Group<Name>,
+  HttpApiGroup.ApiGroup<Name>,
   Handlers.Error<Return>,
   | Handlers.Context<Return>
   | HttpApiGroup.HttpApiGroup.ContextWithName<Groups, Name>
@@ -982,6 +982,7 @@ export const middlewareOpenApi = (
   )
 
 const bearerLen = `Bearer `.length
+const basicLen = `Basic `.length
 
 /**
  * @since 1.0.0
@@ -1023,7 +1024,7 @@ export const securityDecode = <Security extends HttpApiSecurity.HttpApiSecurity>
         password: Redacted.make("")
       } as any
       return HttpServerRequest.HttpServerRequest.pipe(
-        Effect.flatMap((request) => Encoding.decodeBase64String(request.headers.authorization ?? "")),
+        Effect.flatMap((request) => Encoding.decodeBase64String((request.headers.authorization ?? "").slice(basicLen))),
         Effect.match({
           onFailure: () => empty,
           onSuccess: (header) => {

package/src/HttpApiGroup.ts

@@ -140,7 +140,7 @@ export interface HttpApiGroup<
  * @since 1.0.0
  * @category models
  */
-export interface Group<Name extends string> {
+export interface ApiGroup<Name extends string> {
   readonly _: unique symbol
   readonly name: Name
 }
@@ -170,7 +170,7 @@ export declare namespace HttpApiGroup {
    * @category models
    */
   export type ToService<A> = A extends
-    HttpApiGroup<infer Name, infer _Endpoints, infer _Error, infer _R, infer _TopLevel> ? Group<Name>
+    HttpApiGroup<infer Name, infer _Endpoints, infer _Error, infer _R, infer _TopLevel> ? ApiGroup<Name>
     : never
 
   /**
@@ -209,6 +209,15 @@ export declare namespace HttpApiGroup {
     HttpApiGroup<infer _Name, infer _Endpoints, infer _Error, infer _R, infer _TopLevel> ? _Error
     : never
 
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type AddContext<Group, R> = [R] extends [never] ? Group :
+    Group extends HttpApiGroup<infer _Name, infer _Endpoints, infer _Error, infer _R, infer _TopLevel> ?
+      HttpApiGroup<_Name, _Endpoints, _Error, _R | R, _TopLevel>
+    : never
+
   /**
    * @since 1.0.0
    * @category models

package/src/HttpApiSchema.ts

@@ -147,12 +147,12 @@ export const UnionUnify = <A extends Schema.Schema.All, B extends Schema.Schema.
   A["Encoded"] | B["Encoded"],
   A["Context"] | B["Context"]
 > => {
-  const selfTypes = self.ast._tag === "Union" ? self.ast.types : [self.ast]
-  const thatTypes = that.ast._tag === "Union" ? that.ast.types : [that.ast]
-  return Schema.make(AST.Union.make([
-    ...selfTypes,
-    ...thatTypes
-  ]))
+  return Schema.make(AST.Union.make(Array.from(
+    new Set<AST.AST>([
+      ...(self.ast._tag === "Union" ? self.ast.types : [self.ast]),
+      ...(that.ast._tag === "Union" ? that.ast.types : [that.ast])
+    ])
+  )))
 }
 
 /**

package/src/Socket.ts

@@ -397,7 +397,7 @@ export const fromWebSocket = <RO>(
 ): Effect.Effect<Socket, never, Exclude<RO, Scope.Scope>> =>
   Effect.gen(function*() {
     const fiber = Option.getOrThrow(Fiber.getCurrentFiber())
-    const sendQueue = yield* Mailbox.make<Uint8Array | string, SocketError>({
+    const sendQueue = yield* Mailbox.make<Uint8Array | string | CloseEvent>({
       capacity: fiber.getFiberRef(currentSendQueueCapacity),
       strategy: "dropping"
     })
@@ -465,22 +465,25 @@ export const fromWebSocket = <RO>(
           )
         }
         open = true
-        yield* sendQueue.takeAll.pipe(
-          Effect.tap(([chunk]) =>
-            Effect.try({
-              try: () => {
-                for (const item of chunk) {
-                  ws.send(item)
-                }
-              },
+        yield* sendQueue.take.pipe(
+          Effect.tap((chunk) => {
+            if (isCloseEvent(chunk)) {
+              ws.close(chunk.code, chunk.reason)
+              return Effect.fail(
+                new SocketCloseError({
+                  reason: "Close",
+                  code: chunk.code,
+                  closeReason: chunk.reason
+                })
+              )
+            }
+            return Effect.try({
+              try: () => ws.send(chunk),
               catch: (cause) => new SocketGenericError({ reason: "Write", cause })
             })
-          ),
-          Effect.forever,
-          Effect.catchIf(SocketCloseError.is, (error) => {
-            ws.close(error.code, error.closeReason)
-            return Effect.fail(error)
           }),
+          Effect.forever,
+          Effect.catchTag("NoSuchElementException", () => Effect.void),
           FiberSet.run(fiberSet)
         )
         return yield* FiberSet.join(fiberSet).pipe(
@@ -503,16 +506,7 @@ export const fromWebSocket = <RO>(
           : handler(data)
       )
 
-    const write = (chunk: Uint8Array | string | CloseEvent) =>
-      isCloseEvent(chunk)
-        ? sendQueue.fail(
-          new SocketCloseError({
-            reason: "Close",
-            code: chunk.code,
-            closeReason: chunk.reason
-          })
-        )
-        : sendQueue.offer(chunk)
+    const write = (chunk: Uint8Array | string | CloseEvent) => sendQueue.offer(chunk)
     const writer = Effect.succeed(write)
 
     return Socket.of({
@@ -584,7 +578,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
 }): Effect.Effect<Socket, never, Exclude<R, Scope.Scope>> =>
   Effect.gen(function*() {
     const fiber = Option.getOrThrow(Fiber.getCurrentFiber())
-    const sendQueue = yield* Mailbox.make<Uint8Array | string, SocketError>({
+    const sendQueue = yield* Mailbox.make<Uint8Array | string | CloseEvent>({
       capacity: fiber.getFiberRef(currentSendQueueCapacity),
       strategy: "dropping"
     })
@@ -608,23 +602,24 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
         )
         const fiberSet = yield* FiberSet.make<any, E | SocketError>()
         const encoder = new TextEncoder()
-        yield* sendQueue.takeAll.pipe(
-          Effect.flatMap(([chunk, done]) => {
-            const write = Effect.try({
-              try: () => {
-                for (const item of chunk) {
-                  if (typeof item === "string") {
-                    writer.write(encoder.encode(item))
-                  } else {
-                    writer.write(item)
-                  }
-                }
-              },
+        yield* sendQueue.take.pipe(
+          Effect.tap((chunk) => {
+            if (isCloseEvent(chunk)) {
+              return Effect.fail(
+                new SocketCloseError({
+                  reason: "Close",
+                  code: chunk.code,
+                  closeReason: chunk.reason
+                })
+              )
+            }
+            return Effect.tryPromise({
+              try: () => writer.write(typeof chunk === "string" ? encoder.encode(chunk) : chunk),
               catch: (cause) => new SocketGenericError({ reason: "Write", cause })
             })
-            return done ? Effect.zipRight(write, Effect.interrupt) : write
           }),
           Effect.forever,
+          Effect.catchTag("NoSuchElementException", () => Effect.void),
           Effect.ensuring(Effect.promise(() => writer.close())),
           FiberSet.run(fiberSet)
         )
@@ -663,16 +658,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
           : handler(data)
       )
 
-    const write = (chunk: Uint8Array | string | CloseEvent) =>
-      isCloseEvent(chunk) ?
-        sendQueue.fail(
-          new SocketCloseError({
-            reason: "Close",
-            code: chunk.code,
-            closeReason: chunk.reason
-          })
-        ) :
-        sendQueue.offer(chunk)
+    const write = (chunk: Uint8Array | string | CloseEvent) => sendQueue.offer(chunk)
     const writer = Effect.acquireRelease(
       Effect.succeed(write),
       () => sendQueue.end

package/src/Worker.ts

@@ -66,7 +66,7 @@ export const makePlatform: <W>() => <
   P extends { readonly postMessage: (message: any, transfers?: any | undefined) => void }
 >(
   options: {
-    readonly setup: (options: { readonly worker: W; readonly scope: Scope.Scope }) => Effect.Effect<P>
+    readonly setup: (options: { readonly worker: W; readonly scope: Scope.Scope }) => Effect.Effect<P, WorkerError>
     readonly listen: (
       options: {
         readonly port: P

package/src/internal/worker.ts

@@ -1,3 +1,4 @@
+import { Runtime } from "effect"
 import * as Channel from "effect/Channel"
 import * as Context from "effect/Context"
 import * as Deferred from "effect/Deferred"
@@ -86,6 +87,7 @@ export const makeManager = Effect.gen(function*() {
                 ? Deferred.failCause(mailbox, cause)
                 : mailbox.failCause(cause))
           ),
+          Effect.tapErrorCause(Effect.logWarning),
           Effect.retry(Schedule.spaced(1000)),
           Effect.annotateLogs({
             package: "@effect/platform",
@@ -401,7 +403,7 @@ export const makePlatform = <W>() =>
   readonly setup: (options: {
     readonly worker: W
     readonly scope: Scope.Scope
-  }) => Effect.Effect<P>
+  }) => Effect.Effect<P, WorkerError>
   readonly listen: (options: {
     readonly port: P
     readonly emit: (data: any) => void
@@ -417,49 +419,41 @@ export const makePlatform = <W>() =>
         let currentPort: P | undefined
         const buffer: Array<[I, ReadonlyArray<unknown> | undefined]> = []
 
-        const run = <A, E, R>(handler: (_: Worker.BackingWorker.Message<O>) => Effect.Effect<A, E, R>) =>
+        const run = <A, E, R>(
+          handler: (_: Worker.BackingWorker.Message<O>) => Effect.Effect<A, E, R>
+        ): Effect.Effect<never, WorkerError | E, R> =>
           Effect.uninterruptibleMask((restore) =>
-            Scope.make().pipe(
-              Effect.bindTo("scope"),
-              Effect.bind("port", ({ scope }) => options.setup({ worker: spawn(id), scope })),
-              Effect.tap(({ port, scope }) => {
-                currentPort = port
-                return Scope.addFinalizer(
-                  scope,
-                  Effect.sync(() => {
-                    currentPort = undefined
-                  })
-                )
-              }),
-              Effect.bind("fiberSet", ({ scope }) =>
-                FiberSet.make<any, WorkerError | E>().pipe(
-                  Scope.extend(scope)
-                )),
-              Effect.bind("runFork", ({ fiberSet }) => FiberSet.runtime(fiberSet)<R>()),
-              Effect.tap(({ fiberSet, port, runFork, scope }) =>
-                options.listen({
-                  port,
-                  scope,
-                  emit(data) {
-                    runFork(handler(data))
-                  },
-                  deferred: fiberSet.deferred as any
+            Effect.gen(function*() {
+              const scope = yield* Effect.scope
+              const port = yield* options.setup({ worker: spawn(id), scope })
+              currentPort = port
+              yield* Scope.addFinalizer(
+                scope,
+                Effect.sync(() => {
+                  currentPort = undefined
                 })
-              ),
-              Effect.tap(({ port }) => {
-                if (buffer.length > 0) {
-                  for (const [message, transfers] of buffer) {
-                    port.postMessage([0, message], transfers as any)
-                  }
-                  buffer.length = 0
-                }
-              }),
-              Effect.flatMap(({ fiberSet, scope }) =>
-                (restore(FiberSet.join(fiberSet)) as Effect.Effect<never, WorkerError | E>).pipe(
-                  Effect.ensuring(Scope.close(scope, Exit.void))
-                )
               )
-            )
+              const runtime = (yield* Effect.runtime<R | Scope.Scope>()).pipe(
+                Runtime.updateContext(Context.omit(Scope.Scope))
+              ) as Runtime.Runtime<R>
+              const fiberSet = yield* FiberSet.make<any, WorkerError | E>()
+              const runFork = Runtime.runFork(runtime)
+              yield* options.listen({
+                port,
+                scope,
+                emit(data) {
+                  FiberSet.unsafeAdd(runFork(handler(data)))
+                },
+                deferred: fiberSet.deferred as any
+              })
+              if (buffer.length > 0) {
+                for (const [message, transfers] of buffer) {
+                  port.postMessage([0, message], transfers as any)
+                }
+                buffer.length = 0
+              }
+              return (yield* restore(FiberSet.join(fiberSet))) as never
+            }).pipe(Effect.scoped)
           )
 
         const send = (message: I, transfers?: ReadonlyArray<unknown>) =>

package/src/internal/workerRunner.ts

@@ -127,7 +127,7 @@ export const make = <I, E, R, O>(
 ): Effect.Effect<void, WorkerError, WorkerRunner.PlatformRunner | R | Scope.Scope> =>
   Effect.withFiberRuntime<void, never, WorkerRunner.PlatformRunner | R | Scope.Scope>((fiber) =>
     run(process, options).pipe(
-      Effect.tapErrorCause(Effect.logDebug),
+      Effect.tapErrorCause((cause) => Cause.isInterruptedOnly(cause) ? Effect.void : Effect.logWarning(cause)),
       Effect.retry(Schedule.spaced(1000)),
       Effect.annotateLogs({
         package: "@effect/platform-node",