@effect/platform 0.11.4 → 0.12.0

package/src/Http/ServerRequest.ts

@@ -0,0 +1,120 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Context from "@effect/data/Context"
+import type * as Effect from "@effect/io/Effect"
+import type * as Scope from "@effect/io/Scope"
+import type * as FileSystem from "@effect/platform/FileSystem"
+import type * as FormData from "@effect/platform/Http/FormData"
+import type * as Headers from "@effect/platform/Http/Headers"
+import type * as IncomingMessage from "@effect/platform/Http/IncomingMessage"
+import type { Method } from "@effect/platform/Http/Method"
+import type * as Error from "@effect/platform/Http/ServerError"
+import * as internal from "@effect/platform/internal/http/serverRequest"
+import type * as Path from "@effect/platform/Path"
+import type * as ParseResult from "@effect/schema/ParseResult"
+import type * as Schema from "@effect/schema/Schema"
+import type * as Stream from "@effect/stream/Stream"
+
+export {
+  /**
+   * @since 1.0.0
+   * @category fiber refs
+   */
+  maxBodySize
+} from "@effect/platform/Http/IncomingMessage"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const TypeId: unique symbol = internal.TypeId
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface ServerRequest extends IncomingMessage.IncomingMessage<Error.RequestError> {
+  readonly [TypeId]: TypeId
+  readonly url: string
+  readonly originalUrl: string
+  readonly method: Method
+
+  readonly formData: Effect.Effect<Scope.Scope | FileSystem.FileSystem | Path.Path, FormData.FormDataError, FormData>
+  readonly formDataStream: Stream.Stream<never, FormData.FormDataError, FormData.Part>
+
+  readonly setUrl: (url: string) => ServerRequest
+  readonly replaceHeaders: (headers: Headers.Headers) => ServerRequest
+}
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export const ServerRequest: Context.Tag<ServerRequest, ServerRequest> = internal.serverRequestTag
+
+/**
+ * @since 1.0.0
+ * @category accessors
+ */
+export const formDataRecord: Effect.Effect<
+  Scope.Scope | FileSystem.FileSystem | Path.Path | ServerRequest,
+  FormData.FormDataError,
+  Record<string, string | Array<File>>
+> = internal.formDataRecord
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaHeaders: <I extends Readonly<Record<string, string>>, A>(
+  schema: Schema.Schema<I, A>
+) => Effect.Effect<ServerRequest, ParseResult.ParseError, A> = internal.schemaHeaders
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaBodyJson: <I, A>(
+  schema: Schema.Schema<I, A>
+) => Effect.Effect<ServerRequest, Error.RequestError | ParseResult.ParseError, A> = internal.schemaBodyJson
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaBodyUrlParams: <I extends Readonly<Record<string, string>>, A>(
+  schema: Schema.Schema<I, A>
+) => Effect.Effect<ServerRequest, Error.RequestError | ParseResult.ParseError, A> = internal.schemaBodyUrlParams
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaFormData: <I extends Readonly<Record<string, string | ReadonlyArray<File>>>, A>(
+  schema: Schema.Schema<I, A>
+) => Effect.Effect<
+  ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path,
+  FormData.FormDataError | ParseResult.ParseError,
+  A
+> = internal.schemaFormData
+
+/**
+ * @since 1.0.0
+ * @category schema
+ */
+export const schemaFormDataJson: <I, A>(
+  schema: Schema.Schema<I, A>
+) => (
+  field: string
+) => Effect.Effect<
+  ServerRequest | Scope.Scope | FileSystem.FileSystem | Path.Path,
+  Error.RequestError | FormData.FormDataError | ParseResult.ParseError,
+  A
+> = internal.schemaFormDataJson

package/src/Http/ServerResponse.ts

@@ -0,0 +1,202 @@
+/**
+ * @since 1.0.0
+ */
+import type { Pipeable } from "@effect/data/Pipeable"
+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 Headers from "@effect/platform/Http/Headers"
+import type * as Error from "@effect/platform/Http/ServerError"
+import type * as ServerRequest from "@effect/platform/Http/ServerRequest"
+import type * as UrlParams from "@effect/platform/Http/UrlParams"
+import * as internal from "@effect/platform/internal/http/serverResponse"
+import type * as Schema from "@effect/schema/Schema"
+import type * as Stream from "@effect/stream/Stream"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const TypeId = Symbol.for("@effect/platform/Http/ServerResponse")
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface ServerResponse extends Pipeable {
+  readonly [TypeId]: TypeId
+  readonly status: number
+  readonly statusText?: string
+  readonly headers: Headers.Headers
+  readonly body: Body.Body
+}
+
+/**
+ * @since 1.0.0
+ */
+export namespace ServerResponse {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface NonEffectBody extends ServerResponse {
+    readonly body: Body.NonEffect
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Options {
+  readonly status?: number
+  readonly statusText?: string
+  readonly headers?: Headers.Headers
+  readonly contentType?: string
+  readonly contentLength?: number
+}
+
+/**
+ * @since 1.0.0
+ */
+export namespace Options {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface WithContent extends Omit<Options, "contentType" | "contentLength"> {}
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface WithContentType extends Omit<Options, "contentLength"> {}
+}
+
+/**
+ * @since 1.0.0
+ */
+export const isServerResponse: (u: unknown) => u is ServerResponse = internal.isServerResponse
+
+/**
+ * @since 1.0.0
+ */
+export const toNonEffectBody: (
+  self: ServerResponse
+) => Effect.Effect<ServerRequest.ServerRequest, Error.ResponseError, ServerResponse.NonEffectBody> =
+  internal.toNonEffectBody
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const empty: (options?: Options.WithContent) => ServerResponse = internal.empty
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const uint8Array: (body: Uint8Array, options?: Options.WithContentType) => ServerResponse = internal.uint8Array
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const text: (body: string, options?: Options.WithContentType) => ServerResponse = internal.text
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const json: (body: unknown, options?: Options.WithContent) => ServerResponse = internal.json
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const schemaJson: <I, A>(
+  schema: Schema.Schema<I, A>
+) => (body: A, options?: Options.WithContent) => ServerResponse = internal.schemaJson
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const unsafeJson: (body: unknown, options?: Options.WithContent) => ServerResponse = internal.unsafeJson
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const urlParams: (body: UrlParams.Input, options?: Options.WithContent) => ServerResponse = internal.urlParams
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const effect: (
+  body: Effect.Effect<never, unknown, Body.NonEffect>,
+  options?: Options.WithContent
+) => ServerResponse = internal.effect
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const raw: (body: unknown, options?: Options) => ServerResponse = internal.raw
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const formData: (body: FormData, options?: Options.WithContent) => ServerResponse = internal.formData
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const stream: (body: Stream.Stream<never, unknown, Uint8Array>, options?: Options) => ServerResponse =
+  internal.stream
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const file: (
+  path: string,
+  options?: Options & FileSystem.StreamOptions
+) => Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, ServerResponse> = internal.file
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setHeader: {
+  (key: string, value: string): (self: ServerResponse) => ServerResponse
+  (self: ServerResponse, key: string, value: string): ServerResponse
+} = internal.setHeader
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setHeaders: {
+  (input: Headers.Input): (self: ServerResponse) => ServerResponse
+  (self: ServerResponse, input: Headers.Input): ServerResponse
+} = internal.setHeaders
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const setBody: {
+  (body: Body.Body): (self: ServerResponse) => ServerResponse
+  (self: ServerResponse, body: Body.Body): ServerResponse
+} = internal.setBody

package/src/Http/UrlParams.ts

@@ -40,7 +40,10 @@ export const empty: UrlParams = Chunk.empty()
  * @since 1.0.0
  * @category combinators
  */
-export const set = dual<
+export const set: {
+  (key: string, value: string): (self: UrlParams) => UrlParams
+  (self: UrlParams, key: string, value: string): UrlParams
+} = dual<
   (key: string, value: string) => (self: UrlParams) => UrlParams,
   (self: UrlParams, key: string, value: string) => UrlParams
 >(3, (self, key, value) =>
@@ -53,7 +56,10 @@ export const set = dual<
  * @since 1.0.0
  * @category combinators
  */
-export const setAll = dual<
+export const setAll: {
+  (input: Input): (self: UrlParams) => UrlParams
+  (self: UrlParams, input: Input): UrlParams
+} = dual<
   (input: Input) => (self: UrlParams) => UrlParams,
   (self: UrlParams, input: Input) => UrlParams
 >(2, (self, input) => {
@@ -69,7 +75,10 @@ export const setAll = dual<
  * @since 1.0.0
  * @category combinators
  */
-export const append = dual<
+export const append: {
+  (key: string, value: string): (self: UrlParams) => UrlParams
+  (self: UrlParams, key: string, value: string): UrlParams
+} = dual<
   (key: string, value: string) => (self: UrlParams) => UrlParams,
   (self: UrlParams, key: string, value: string) => UrlParams
 >(3, (self, key, value) =>
@@ -82,7 +91,10 @@ export const append = dual<
  * @since 1.0.0
  * @category combinators
  */
-export const appendAll = dual<
+export const appendAll: {
+  (input: Input): (self: UrlParams) => UrlParams
+  (self: UrlParams, input: Input): UrlParams
+} = dual<
   (input: Input) => (self: UrlParams) => UrlParams,
   (self: UrlParams, input: Input) => UrlParams
 >(2, (self, input) =>
@@ -95,7 +107,10 @@ export const appendAll = dual<
  * @since 1.0.0
  * @category combinators
  */
-export const remove = dual<
+export const remove: {
+  (key: string): (self: UrlParams) => UrlParams
+  (self: UrlParams, key: string): UrlParams
+} = dual<
   (key: string) => (self: UrlParams) => UrlParams,
   (self: UrlParams, key: string) => UrlParams
 >(2, (self, key) => Chunk.filter(self, ([k]) => k !== key))

package/src/HttpServer.ts

@@ -0,0 +1,44 @@
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ */
+export * as app from "@effect/platform/Http/App"
+/**
+ * @since 1.0.0
+ */
+export * as middleware from "@effect/platform/Http/Middleware"
+/**
+ * @since 1.0.0
+ */
+export * as request from "@effect/platform/Http/ServerRequest"
+/**
+ * @since 1.0.0
+ */
+export * as response from "@effect/platform/Http/ServerResponse"
+/**
+ * @since 1.0.0
+ */
+export * as error from "@effect/platform/Http/ServerError"
+/**
+ * @since 1.0.0
+ */
+export * as body from "@effect/platform/Http/Body"
+/**
+ * @since 1.0.0
+ */
+export * as formData from "@effect/platform/Http/FormData"
+/**
+ * @since 1.0.0
+ */
+export * as headers from "@effect/platform/Http/Headers"
+/**
+ * @since 1.0.0
+ */
+export * as router from "@effect/platform/Http/Router"
+/**
+ * @since 1.0.0
+ */
+export * as urlParams from "@effect/platform/Http/UrlParams"

package/src/internal/command.ts

@@ -2,6 +2,7 @@ import * as Chunk from "@effect/data/Chunk"
 import { dual } from "@effect/data/Function"
 import * as HashMap from "@effect/data/HashMap"
 import * as Option from "@effect/data/Option"
+import { pipeArguments } from "@effect/data/Pipeable"
 import type ReadonlyArray from "@effect/data/ReadonlyArray"
 import * as Effect from "@effect/io/Effect"
 import type * as Command from "@effect/platform/Command"
@@ -88,7 +89,10 @@ export const make = (command: string, ...args: Array<string>): Command.Command =
   stdout: "pipe",
   stderr: "pipe",
   gid: Option.none(),
-  uid: Option.none()
+  uid: Option.none(),
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 })
 
 /** @internal */
@@ -99,7 +103,10 @@ export const pipeTo = dual<
   [CommandTypeId]: CommandTypeId,
   _tag: "PipedCommand",
   left: self,
-  right: into
+  right: into,
+  pipe() {
+    return pipeArguments(this, arguments)
+  }
 }))
 
 /** @internal */

package/src/internal/fileSystem.ts

@@ -3,7 +3,7 @@ import { identity, pipe } from "@effect/data/Function"
 import * as Option from "@effect/data/Option"
 import * as Effect from "@effect/io/Effect"
 import * as Error from "@effect/platform/Error"
-import type { File, FileSystem, Size as Size_, StreamOptions } from "@effect/platform/FileSystem"
+import type { File, FileSystem, Size as Size_, SizeInput, StreamOptions } from "@effect/platform/FileSystem"
 import * as Sink from "@effect/stream/Sink"
 import * as Stream from "@effect/stream/Stream"
 
@@ -11,7 +11,7 @@ import * as Stream from "@effect/stream/Stream"
 export const tag = Tag<FileSystem>("@effect/platform/FileSystem")
 
 /** @internal */
-export const Size = (bytes: number | bigint) => typeof bytes === "bigint" ? bytes as Size_ : BigInt(bytes) as Size_
+export const Size = (bytes: SizeInput) => typeof bytes === "bigint" ? bytes as Size_ : BigInt(bytes) as Size_
 
 /** @internal */
 export const make = (
@@ -69,10 +69,12 @@ export const make = (
 /** @internal */
 const stream = (file: File, {
   bufferSize = 4,
-  bytesToRead,
-  chunkSize = Size(64 * 1024)
-}: StreamOptions = {}) =>
-  Stream.bufferChunks(
+  bytesToRead: bytesToRead_,
+  chunkSize: chunkSize_ = Size(64 * 1024)
+}: StreamOptions = {}) => {
+  const bytesToRead = bytesToRead_ !== undefined ? Size(bytesToRead_) : undefined
+  const chunkSize = Size(chunkSize_)
+  return Stream.bufferChunks(
     Stream.unfoldEffect(BigInt(0), (totalBytesRead) => {
       if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
         return Effect.succeed(Option.none())
@@ -83,9 +85,10 @@ const stream = (file: File, {
         : chunkSize
 
       return Effect.map(
-        file.readAlloc(toRead as Size_),
+        file.readAlloc(toRead),
         Option.map((buf) => [buf, Size(totalBytesRead + BigInt(buf.length))] as const)
       )
     }),
     { capacity: bufferSize }
   )
+}

package/src/internal/http/body.ts

@@ -1,4 +1,6 @@
 import * as Effect from "@effect/io/Effect"
+import type * as PlatformError from "@effect/platform/Error"
+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"
@@ -9,100 +11,124 @@ export const TypeId: Body.TypeId = Symbol.for(
 ) as Body.TypeId
 
 class EmptyImpl implements Body.Empty {
-  readonly [TypeId]: Body.TypeId = TypeId
+  readonly [TypeId]: Body.TypeId
   readonly _tag = "Empty"
+  constructor() {
+    this[TypeId] = TypeId
+  }
 }
 
 /** @internal */
 export const empty: Body.Empty = new EmptyImpl()
 
 class RawImpl implements Body.Raw {
-  readonly [TypeId]: Body.TypeId = TypeId
+  readonly [TypeId]: Body.TypeId
   readonly _tag = "Raw"
   constructor(
     readonly body: unknown,
     readonly contentType?: string,
     readonly contentLength?: number
-  ) {}
+  ) {
+    this[TypeId] = TypeId
+  }
 }
 
 /** @internal */
 export const raw = (body: unknown, contentType?: string, contentLength?: number): Body.Raw =>
   new RawImpl(body, contentType, contentLength)
 
-class BytesImpl implements Body.Bytes {
-  readonly [TypeId]: Body.TypeId = TypeId
-  readonly _tag = "Bytes"
+class Uint8ArrayImpl implements Body.Uint8Array {
+  readonly [TypeId]: Body.TypeId
+  readonly _tag = "Uint8Array"
   constructor(
     readonly body: Uint8Array,
-    readonly contentType?: string
-  ) {}
+    readonly contentType: string
+  ) {
+    this[TypeId] = TypeId
+  }
   get contentLength(): number {
     return this.body.length
   }
 }
 
 /** @internal */
-export const bytes = (body: Uint8Array, contentType?: string): Body.Bytes => new BytesImpl(body, contentType)
+export const uint8Array = (body: Uint8Array, contentType?: string): Body.Uint8Array =>
+  new Uint8ArrayImpl(body, contentType ?? "application/octet-stream")
 
 /** @internal */
-export const text = (body: string, contentType?: string): Body.Bytes =>
-  bytes(new TextEncoder().encode(body), contentType)
+export const text = (body: string, contentType?: string): Body.Uint8Array =>
+  uint8Array(new TextEncoder().encode(body), contentType ?? "text/plain")
 
-class BytesEffectImpl implements Body.BytesEffect {
-  readonly [TypeId]: Body.TypeId = TypeId
-  readonly _tag = "BytesEffect"
+class EffectBodyImpl implements Body.EffectBody {
+  readonly [TypeId]: Body.TypeId
+  readonly _tag = "Effect"
   constructor(
-    readonly body: Effect.Effect<never, unknown, Uint8Array>,
+    readonly effect: Effect.Effect<never, unknown, Body.NonEffect>,
     readonly contentType?: string
-  ) {}
+  ) {
+    this[TypeId] = TypeId
+  }
 }
 
 /** @internal */
-export const bytesEffect = (
-  body: Effect.Effect<never, unknown, Uint8Array>,
-  contentType?: string
-): Body.BytesEffect => new BytesEffectImpl(body, contentType)
+export const effect = (
+  body: Effect.Effect<never, unknown, Body.NonEffect>
+): Body.EffectBody => new EffectBodyImpl(body)
 
 /** @internal */
-export const json = (body: unknown): Body.BytesEffect =>
-  bytesEffect(
-    Effect.try(() => new TextEncoder().encode(JSON.stringify(body))),
-    "application/json"
-  )
+export const unsafeJson = (body: unknown): Body.Uint8Array =>
+  uint8Array(new TextEncoder().encode(JSON.stringify(body)), "application/json")
+
+/** @internal */
+export const json = (body: unknown): Body.EffectBody => effect(Effect.try(() => unsafeJson(body)))
 
 /** @internal */
 export const jsonSchema = <I, A>(schema: Schema.Schema<I, A>) => {
   const encode = Schema.encode(schema)
-  return (body: A): Body.BytesEffect =>
-    bytesEffect(
-      Effect.flatMap(
-        encode(body),
-        (json) => Effect.try(() => new TextEncoder().encode(JSON.stringify(json)))
-      ),
-      "application/json"
-    )
+  return (body: A): Body.EffectBody =>
+    effect(Effect.flatMap(
+      encode(body),
+      (json) => Effect.try(() => unsafeJson(json))
+    ))
 }
 
+/** @internal */
+export const file = (
+  path: string,
+  options?: FileSystem.StreamOptions & { readonly contentType?: string }
+): Effect.Effect<FileSystem.FileSystem, PlatformError.PlatformError, Body.Stream> =>
+  Effect.flatMap(
+    FileSystem.FileSystem,
+    (fs) =>
+      Effect.map(
+        fs.stat(path),
+        (stat) => stream(fs.stream(path, options), options?.contentType, Number(stat.size))
+      )
+  )
+
 class FormDataImpl implements Body.FormData {
-  readonly [TypeId]: Body.TypeId = TypeId
+  readonly [TypeId]: Body.TypeId
   readonly _tag = "FormData"
   constructor(
     readonly formData: FormData
-  ) {}
+  ) {
+    this[TypeId] = TypeId
+  }
 }
 
 /** @internal */
 export const formData = (body: FormData): Body.FormData => new FormDataImpl(body)
 
 class StreamImpl implements Body.Stream {
-  readonly [TypeId]: Body.TypeId = TypeId
+  readonly [TypeId]: Body.TypeId
   readonly _tag = "Stream"
   constructor(
     readonly stream: Stream_.Stream<never, unknown, Uint8Array>,
-    readonly contentType?: string,
+    readonly contentType: string,
     readonly contentLength?: number
-  ) {}
+  ) {
+    this[TypeId] = TypeId
+  }
 }
 
 /** @internal */
@@ -110,4 +136,4 @@ export const stream = (
   body: Stream_.Stream<never, unknown, Uint8Array>,
   contentType?: string,
   contentLength?: number
-): Body.Stream => new StreamImpl(body, contentType, contentLength)
+): Body.Stream => new StreamImpl(body, contentType ?? "application/octet-stream", contentLength)