@effect/platform 0.84.11 → 0.85.1

package/src/HttpApiBuilder.ts

@@ -7,7 +7,7 @@ import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Encoding from "effect/Encoding"
 import * as Fiber from "effect/Fiber"
-import { identity } from "effect/Function"
+import { constFalse, identity } from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
 import * as ManagedRuntime from "effect/ManagedRuntime"
@@ -242,7 +242,7 @@ export interface Handlers<
    */
   handleRaw<Name extends HttpApiEndpoint.HttpApiEndpoint.Name<Endpoints>, R1>(
     name: Name,
-    handler: HttpApiEndpoint.HttpApiEndpoint.HandlerResponseWithName<Endpoints, Name, E, R1>,
+    handler: HttpApiEndpoint.HttpApiEndpoint.HandlerRawWithName<Endpoints, Name, E, R1>,
     options?: { readonly uninterruptible?: boolean | undefined } | undefined
   ): Handlers<
     E,
@@ -286,7 +286,7 @@ export declare namespace Handlers {
   export type Item<E, R> = {
     readonly endpoint: HttpApiEndpoint.HttpApiEndpoint.Any
     readonly handler: HttpApiEndpoint.HttpApiEndpoint.Handler<any, E, R>
-    readonly withFullResponse: boolean
+    readonly withFullRequest: boolean
     readonly uninterruptible: boolean
   }
 
@@ -390,7 +390,7 @@ const HandlersProto = {
       handlers: Chunk.append(this.handlers, {
         endpoint,
         handler,
-        withFullResponse: false,
+        withFullRequest: false,
         uninterruptible: options?.uninterruptible ?? false
       }) as any
     })
@@ -407,7 +407,7 @@ const HandlersProto = {
       handlers: Chunk.append(this.handlers, {
         endpoint,
         handler,
-        withFullResponse: true,
+        withFullRequest: true,
         uninterruptible: options?.uninterruptible ?? false
       }) as any
     })
@@ -480,7 +480,7 @@ export const group = <
               (input) => Context.merge(context, input)
             )
           },
-          item.withFullResponse,
+          item.withFullRequest,
           item.uninterruptible
         ))
       }
@@ -623,12 +623,18 @@ const handlerToRoute = (
   endpoint_: HttpApiEndpoint.HttpApiEndpoint.Any,
   middleware: MiddlewareMap,
   handler: HttpApiEndpoint.HttpApiEndpoint.Handler<any, any, any>,
-  isFullResponse: boolean,
+  isFullRequest: boolean,
   uninterruptible: boolean
 ): HttpRouter.Route<any, any> => {
   const endpoint = endpoint_ as HttpApiEndpoint.HttpApiEndpoint.AnyWithProps
+  const isMultipartStream = endpoint.payloadSchema.pipe(
+    Option.map(({ ast }) => HttpApiSchema.getMultipartStream(ast)),
+    Option.getOrElse(constFalse)
+  )
   const decodePath = Option.map(endpoint.pathSchema, Schema.decodeUnknown)
-  const decodePayload = Option.map(endpoint.payloadSchema, Schema.decodeUnknown)
+  const decodePayload = isFullRequest || isMultipartStream
+    ? Option.none()
+    : Option.map(endpoint.payloadSchema, Schema.decodeUnknown)
   const decodeHeaders = Option.map(endpoint.headersSchema, Schema.decodeUnknown)
   const encodeSuccess = Schema.encode(makeSuccessSchema(endpoint.successSchema))
   return HttpRouter.makeRoute(
@@ -642,7 +648,7 @@ const handlerToRoute = (
         const httpRequest = Context.unsafeGet(context, HttpServerRequest.HttpServerRequest)
         const routeContext = Context.unsafeGet(context, HttpRouter.RouteContext)
         const urlParams = Context.unsafeGet(context, HttpServerRequest.ParsedSearchParams)
-        const request: any = {}
+        const request: any = { request: httpRequest }
         if (decodePath._tag === "Some") {
           request.path = yield* decodePath.value(routeContext.params)
         }
@@ -651,6 +657,8 @@ const handlerToRoute = (
             requestPayload(httpRequest, urlParams),
             decodePayload.value
           )
+        } else if (isMultipartStream) {
+          request.payload = httpRequest.multipartStream
         }
         if (decodeHeaders._tag === "Some") {
           request.headers = yield* decodeHeaders.value(httpRequest.headers)
@@ -659,10 +667,8 @@ const handlerToRoute = (
           const schema = endpoint.urlParamsSchema.value
           request.urlParams = yield* Schema.decodeUnknown(schema)(normalizeUrlParams(urlParams, schema.ast))
         }
-        const response = isFullResponse
-          ? yield* handler(request)
-          : yield* Effect.flatMap(handler(request), encodeSuccess)
-        return response as HttpServerResponse.HttpServerResponse
+        const response = yield* handler(request)
+        return HttpServerResponse.isServerResponse(response) ? response : yield* encodeSuccess(response)
       }).pipe(
         Effect.catchIf(ParseResult.isParseError, HttpApiDecodeError.refailParseError)
       )

package/src/HttpApiEndpoint.ts

@@ -8,12 +8,15 @@ import * as Option from "effect/Option"
 import { type Pipeable, pipeArguments } from "effect/Pipeable"
 import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
+import type * as Stream from "effect/Stream"
 import type * as Types from "effect/Types"
 import type * as HttpApiMiddleware from "./HttpApiMiddleware.js"
 import * as HttpApiSchema from "./HttpApiSchema.js"
 import type { HttpMethod } from "./HttpMethod.js"
 import * as HttpRouter from "./HttpRouter.js"
+import type { HttpServerRequest } from "./HttpServerRequest.js"
 import type { HttpServerResponse } from "./HttpServerResponse.js"
+import type * as Multipart from "./Multipart.js"
 
 /**
  * @since 1.0.0
@@ -402,8 +405,34 @@ export declare namespace HttpApiEndpoint {
   > ?
       & ([_Path] extends [never] ? {} : { readonly path: _Path })
       & ([_UrlParams] extends [never] ? {} : { readonly urlParams: _UrlParams })
-      & ([_Payload] extends [never] ? {} : { readonly payload: _Payload })
+      & ([_Payload] extends [never] ? {}
+        : _Payload extends Brand<HttpApiSchema.MultipartStreamTypeId> ?
+          { readonly payload: Stream.Stream<Multipart.Part, Multipart.MultipartError> }
+        : { readonly payload: _Payload })
       & ([_Headers] extends [never] ? {} : { readonly headers: _Headers })
+      & { readonly request: HttpServerRequest }
+    : {}
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type RequestRaw<Endpoint extends Any> = Endpoint extends HttpApiEndpoint<
+    infer _Name,
+    infer _Method,
+    infer _Path,
+    infer _UrlParams,
+    infer _Payload,
+    infer _Headers,
+    infer _Success,
+    infer _Error,
+    infer _R,
+    infer _RE
+  > ?
+      & ([_Path] extends [never] ? {} : { readonly path: _Path })
+      & ([_UrlParams] extends [never] ? {} : { readonly urlParams: _UrlParams })
+      & ([_Headers] extends [never] ? {} : { readonly headers: _Headers })
+      & { readonly request: HttpServerRequest }
     : {}
 
   /**
@@ -416,7 +445,9 @@ export declare namespace HttpApiEndpoint {
     & ([Headers] extends [never] ? {} : { readonly headers: Headers })
     & ([Payload] extends [never] ? {}
       : Payload extends infer P ?
-        P extends Brand<HttpApiSchema.MultipartTypeId> ? { readonly payload: FormData } : { readonly payload: P }
+        P extends Brand<HttpApiSchema.MultipartTypeId> | Brand<HttpApiSchema.MultipartStreamTypeId>
+          ? { readonly payload: FormData }
+        : { readonly payload: P }
       : { readonly payload: Payload })
   ) extends infer Req ? keyof Req extends never ? (void | { readonly withResponse?: WithResponse }) :
     Req & { readonly withResponse?: WithResponse } :
@@ -464,15 +495,15 @@ export declare namespace HttpApiEndpoint {
    */
   export type Handler<Endpoint extends Any, E, R> = (
     request: Types.Simplify<Request<Endpoint>>
-  ) => Effect<Success<Endpoint>, Error<Endpoint> | E, R>
+  ) => Effect<Success<Endpoint> | HttpServerResponse, Error<Endpoint> | E, R>
 
   /**
    * @since 1.0.0
    * @category models
    */
-  export type HandlerResponse<Endpoint extends Any, E, R> = (
-    request: Types.Simplify<Request<Endpoint>>
-  ) => Effect<HttpServerResponse, Error<Endpoint> | E, R>
+  export type HandlerRaw<Endpoint extends Any, E, R> = (
+    request: Types.Simplify<RequestRaw<Endpoint>>
+  ) => Effect<Success<Endpoint> | HttpServerResponse, Error<Endpoint> | E, R>
 
   /**
    * @since 1.0.0
@@ -500,7 +531,7 @@ export declare namespace HttpApiEndpoint {
    * @since 1.0.0
    * @category models
    */
-  export type HandlerResponseWithName<Endpoints extends Any, Name extends string, E, R> = HandlerResponse<
+  export type HandlerRawWithName<Endpoints extends Any, Name extends string, E, R> = HandlerRaw<
     WithName<Endpoints, Name>,
     E,
     R

package/src/HttpApiSchema.ts

@@ -20,6 +20,14 @@ export const AnnotationMultipart: unique symbol = Symbol.for(
   "@effect/platform/HttpApiSchema/AnnotationMultipart"
 )
 
+/**
+ * @since 1.0.0
+ * @category annotations
+ */
+export const AnnotationMultipartStream: unique symbol = Symbol.for(
+  "@effect/platform/HttpApiSchema/AnnotationMultipartStream"
+)
+
 /**
  * @since 1.0.0
  * @category annotations
@@ -69,6 +77,9 @@ export const extractAnnotations = (ast: AST.Annotations): AST.Annotations => {
   if (AnnotationMultipart in ast) {
     result[AnnotationMultipart] = ast[AnnotationMultipart]
   }
+  if (AnnotationMultipartStream in ast) {
+    result[AnnotationMultipartStream] = ast[AnnotationMultipartStream]
+  }
   return result
 }
 
@@ -102,6 +113,13 @@ export const getEmptyDecodeable = (ast: AST.AST): boolean =>
  */
 export const getMultipart = (ast: AST.AST): boolean => getAnnotation<boolean>(ast, AnnotationMultipart) ?? false
 
+/**
+ * @since 1.0.0
+ * @category annotations
+ */
+export const getMultipartStream = (ast: AST.AST): boolean =>
+  getAnnotation<boolean>(ast, AnnotationMultipartStream) ?? false
+
 const encodingJson: Encoding = {
   kind: "Json",
   contentType: "application/json"
@@ -411,6 +429,39 @@ export const Multipart = <S extends Schema.Schema.Any>(self: S): Multipart<S> =>
     [AnnotationMultipart]: true
   }) as any
 
+/**
+ * @since 1.0.0
+ * @category multipart
+ */
+export const MultipartStreamTypeId: unique symbol = Symbol.for("@effect/platform/HttpApiSchema/MultipartStream")
+
+/**
+ * @since 1.0.0
+ * @category multipart
+ */
+export type MultipartStreamTypeId = typeof MultipartStreamTypeId
+
+/**
+ * @since 1.0.0
+ * @category multipart
+ */
+export interface MultipartStream<S extends Schema.Schema.Any> extends
+  Schema.Schema<
+    Schema.Schema.Type<S> & Brand<MultipartStreamTypeId>,
+    Schema.Schema.Encoded<S>,
+    Schema.Schema.Context<S>
+  >
+{}
+
+/**
+ * @since 1.0.0
+ * @category multipart
+ */
+export const MultipartStream = <S extends Schema.Schema.Any>(self: S): MultipartStream<S> =>
+  self.annotations({
+    [AnnotationMultipartStream]: true
+  }) as any
+
 const defaultContentType = (encoding: Encoding["kind"]) => {
   switch (encoding) {
     case "Json": {

package/src/Multipart.ts

@@ -83,6 +83,7 @@ export interface File extends Part.Proto {
   readonly name: string
   readonly contentType: string
   readonly content: Stream.Stream<Uint8Array, MultipartError>
+  readonly contentEffect: Effect.Effect<Uint8Array, MultipartError>
 }
 
 /**
@@ -310,3 +311,14 @@ export const toPersisted: (
   stream: Stream.Stream<Part, MultipartError>,
   writeFile?: (path: string, file: File) => Effect.Effect<void, MultipartError, FileSystem.FileSystem>
 ) => Effect.Effect<Persisted, MultipartError, FileSystem.FileSystem | Path.Path | Scope.Scope> = internal.toPersisted
+
+/**
+ * @since 1.0.0
+ */
+export const collectUint8Array: Channel.Channel<
+  never,
+  Chunk.Chunk<Uint8Array>,
+  unknown,
+  unknown,
+  Uint8Array
+> = internal.collectUint8Array

package/src/internal/multipart.ts

@@ -1,3 +1,4 @@
+import type { Cause } from "effect/Cause"
 import * as Channel from "effect/Channel"
 import * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
@@ -355,6 +356,7 @@ class FileImpl extends PartBase implements Multipart.File {
   readonly name: string
   readonly contentType: string
   readonly content: Stream.Stream<Uint8Array, Multipart.MultipartError>
+  readonly contentEffect: Effect.Effect<Uint8Array, Multipart.MultipartError>
 
   constructor(
     info: MP.PartInfo,
@@ -365,6 +367,11 @@ class FileImpl extends PartBase implements Multipart.File {
     this.name = info.filename ?? info.name
     this.contentType = info.contentType
     this.content = Stream.fromChannel(channel)
+    this.contentEffect = channel.pipe(
+      Channel.pipeTo(collectUint8Array),
+      Channel.run,
+      Effect.mapError((cause) => new MultipartError({ reason: "InternalError", cause }))
+    )
   }
 
   toJSON(): unknown {
@@ -388,6 +395,31 @@ const defaultWriteFile = (path: string, file: Multipart.File) =>
       )
   )
 
+/** @internal */
+export const collectUint8Array = Channel.suspend(() => {
+  let accumulator = new Uint8Array(0)
+  const loop: Channel.Channel<
+    never,
+    Chunk.Chunk<Uint8Array>,
+    unknown,
+    unknown,
+    Uint8Array
+  > = Channel.readWithCause({
+    onInput(chunk: Chunk.Chunk<Uint8Array>) {
+      for (const element of chunk) {
+        const newAccumulator = new Uint8Array(accumulator.length + element.length)
+        newAccumulator.set(accumulator, 0)
+        newAccumulator.set(element, accumulator.length)
+        accumulator = newAccumulator
+      }
+      return loop
+    },
+    onFailure: (cause: Cause<unknown>) => Channel.failCause(cause),
+    onDone: () => Channel.succeed(accumulator)
+  })
+  return loop
+})
+
 /** @internal */
 export const toPersisted = (
   stream: Stream.Stream<Multipart.Part, Multipart.MultipartError>,