@effect/platform 0.46.3 → 0.47.1

package/src/Error.ts

@@ -1,6 +1,10 @@
 /**
  * @since 1.0.0
  */
+import type * as Cause from "effect/Cause"
+import * as Data from "effect/Data"
+import * as Predicate from "effect/Predicate"
+import type { Simplify } from "../../effect/src/Types.js"
 import * as internal from "./internal/error.js"
 
 /**
@@ -21,6 +25,63 @@ export type PlatformErrorTypeId = typeof PlatformErrorTypeId
  */
 export type PlatformError = BadArgument | SystemError
 
+/**
+ * @since 1.0.0
+ * @category error
+ */
+export const TypeIdError = <const TypeId extends symbol, const Tag extends string>(
+  typeId: TypeId,
+  tag: Tag
+): new<A extends Record<string, any>>(
+  args: Simplify<A>
+) =>
+  & Cause.YieldableError
+  & Record<TypeId, TypeId>
+  & { readonly _tag: Tag }
+  & Readonly<A> =>
+{
+  class Base extends Data.Error<{}> {
+    readonly _tag = tag
+  }
+  ;(Base.prototype as any)[typeId] = typeId
+  ;(Base.prototype as any).name = tag
+  return Base as any
+}
+
+/**
+ * @since 1.0.0
+ * @category error
+ */
+export const RefailError = <const TypeId extends symbol, const Tag extends string>(
+  typeId: TypeId,
+  tag: Tag
+): new<A extends Record<string, any>>(
+  args: Simplify<A & { readonly error: unknown }>
+) =>
+  & Cause.YieldableError
+  & Record<TypeId, TypeId>
+  & { readonly _tag: Tag; readonly error: unknown }
+  & Readonly<A> =>
+{
+  class Base extends Data.Error<{
+    readonly error: unknown
+  }> {
+    readonly _tag = tag
+    constructor(props: any) {
+      super(props)
+      if (Predicate.hasProperty(this.error, "stack")) {
+        ;(this as any).stack = this.error.stack
+      }
+    }
+    get message() {
+      return String(Predicate.hasProperty(this.error, "message") ? this.error.message : this.error)
+    }
+  }
+  ;(Base.prototype as any)[typeId] = typeId
+  ;(Base.prototype as any).name = tag
+  return Base as any
+}
+
 /**
  * @since 1.0.0
  */

package/src/Http/Body.ts

@@ -4,6 +4,7 @@
 import type * as ParseResult from "@effect/schema/ParseResult"
 import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
+import * as Predicate from "effect/Predicate"
 import type * as Stream_ from "effect/Stream"
 import type * as PlatformError from "../Error.js"
 import type * as FileSystem from "../FileSystem.js"
@@ -22,6 +23,12 @@ export const TypeId: unique symbol = internal.TypeId
  */
 export type TypeId = typeof TypeId
 
+/**
+ * @since 1.0.0
+ * @category refinements
+ */
+export const isBody = (u: unknown): u is Body => Predicate.hasProperty(u, TypeId)
+
 /**
  * @since 1.0.0
  * @category models
@@ -122,7 +129,13 @@ export interface Raw extends Body.Proto {
  * @since 1.0.0
  * @category constructors
  */
-export const raw: (body: unknown) => Raw = internal.raw
+export const raw: (
+  body: unknown,
+  options?: {
+    readonly contentType?: string | undefined
+    readonly contentLength?: number | undefined
+  } | undefined
+) => Raw = internal.raw
 
 /**
  * @since 1.0.0

package/src/Http/ClientError.ts

@@ -1,6 +1,7 @@
 /**
  * @since 1.0.0
  */
+import * as Error from "@effect/platform/Error"
 import * as internal from "../internal/http/clientError.js"
 import type * as ClientRequest from "./ClientRequest.js"
 import type * as ClientResponse from "./ClientResponse.js"
@@ -23,57 +24,39 @@ export type TypeId = typeof TypeId
  */
 export type HttpClientError = RequestError | ResponseError
 
-/**
- * @since 1.0.0
- */
-export declare namespace HttpError {
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export interface Proto {
-    readonly [TypeId]: TypeId
-    readonly _tag: string
-  }
-
-  /**
-   * @since 1.0.0
-   */
-  export type ProvidedFields = TypeId | "_tag"
-}
-
 /**
  * @since 1.0.0
  * @category error
  */
-export interface RequestError extends HttpError.Proto {
-  readonly _tag: "RequestError"
+export class RequestError extends Error.RefailError(TypeId, "RequestError")<{
   readonly request: ClientRequest.ClientRequest
   readonly reason: "Transport" | "Encode" | "InvalidUrl"
-  readonly error: unknown
-}
+}> {
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`
+  }
 
-/**
- * @since 1.0.0
- * @category error
- */
-export const RequestError: (props: Omit<RequestError, HttpError.ProvidedFields>) => RequestError = internal.requestError
+  get message() {
+    const errorString = super.message
+    return `${this.reason} error (${this.methodAndUrl}): ${errorString}`
+  }
+}
 
 /**
  * @since 1.0.0
  * @category error
  */
-export interface ResponseError extends HttpError.Proto {
-  readonly _tag: "ResponseError"
+export class ResponseError extends Error.RefailError(TypeId, "ResponseError")<{
   readonly request: ClientRequest.ClientRequest
   readonly response: ClientResponse.ClientResponse
   readonly reason: "StatusCode" | "Decode" | "EmptyBody"
-  readonly error: unknown
-}
+}> {
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`
+  }
 
-/**
- * @since 1.0.0
- * @category error
- */
-export const ResponseError: (props: Omit<ResponseError, HttpError.ProvidedFields>) => ResponseError =
-  internal.responseError
+  get message() {
+    const errorString = super.message
+    return `${this.reason} error (${this.response.status} ${this.methodAndUrl}): ${errorString}`
+  }
+}

package/src/Http/Headers.ts

@@ -1,12 +1,14 @@
 /**
  * @since 1.0.0
  */
-import { dual } from "effect/Function"
+import * as Schema from "@effect/schema/Schema"
+import { dual, identity } from "effect/Function"
 import type * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
 import * as ReadonlyArray from "effect/ReadonlyArray"
 import * as ReadonlyRecord from "effect/ReadonlyRecord"
 import * as Secret from "effect/Secret"
+import * as String from "effect/String"
 
 /**
  * @since 1.0.0
@@ -20,6 +22,12 @@ export const HeadersTypeId = Symbol.for("@effect/platform/Http/Headers")
  */
 export type HeadersTypeId = typeof HeadersTypeId
 
+/**
+ * @since 1.0.0
+ * @category refinements
+ */
+export const isHeaders = (u: unknown): u is Headers => Predicate.hasProperty(u, HeadersTypeId)
+
 /**
  * @since 1.0.0
  * @category models
@@ -29,6 +37,26 @@ export interface Headers {
   readonly [key: string]: string
 }
 
+/**
+ * @since 1.0.0
+ * @category schemas
+ */
+export const schemaFromSelf: Schema.Schema<Headers> = Schema.declare(isHeaders, {
+  identifier: "Headers",
+  equivalence: () => ReadonlyRecord.getEquivalence(String.Equivalence)
+})
+
+/**
+ * @since 1.0.0
+ * @category schemas
+ */
+export const schema: Schema.Schema<Headers, ReadonlyRecord.ReadonlyRecord<string, string>> = Schema.transform(
+  Schema.record(Schema.string, Schema.string),
+  schemaFromSelf,
+  (record) => fromInput(record),
+  identity
+)
+
 /**
  * @since 1.0.0
  * @category models

package/src/Http/ServerError.ts

@@ -3,6 +3,7 @@
  */
 import type * as Cause from "effect/Cause"
 import type * as FiberId from "effect/FiberId"
+import { RefailError, TypeIdError } from "../Error.js"
 import * as internal from "../internal/http/serverError.js"
 import type * as ServerRequest from "./ServerRequest.js"
 import type * as ServerResponse from "./ServerResponse.js"
@@ -25,34 +26,21 @@ export type TypeId = typeof TypeId
  */
 export type HttpServerError = RequestError | ResponseError | RouteNotFound | ServeError
 
-/**
- * @since 1.0.0
- */
-export declare namespace HttpError {
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export interface Proto {
-    readonly [TypeId]: TypeId
-    readonly _tag: string
-  }
-
-  /**
-   * @since 1.0.0
-   */
-  export type ProvidedFields = TypeId | "_tag"
-}
-
 /**
  * @since 1.0.0
  * @category error
  */
-export interface RequestError extends HttpError.Proto {
-  readonly _tag: "RequestError"
+export class RequestError extends RefailError(TypeId, "RequestError")<{
   readonly request: ServerRequest.ServerRequest
   readonly reason: "Transport" | "Decode"
-  readonly error: unknown
+}> {
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`
+  }
+
+  get message() {
+    return `${this.reason} error (${this.methodAndUrl}): ${super.message}`
+  }
 }
 
 /**
@@ -65,57 +53,38 @@ export const isServerError: (u: unknown) => u is HttpServerError = internal.isSe
  * @since 1.0.0
  * @category error
  */
-export const RequestError: (props: Omit<RequestError, HttpError.ProvidedFields>) => RequestError = internal.requestError
-
-/**
- * @since 1.0.0
- * @category error
- */
-export interface RouteNotFound extends HttpError.Proto {
-  readonly _tag: "RouteNotFound"
+export class RouteNotFound extends TypeIdError(TypeId, "RouteNotFound")<{
   readonly request: ServerRequest.ServerRequest
+}> {
+  get message() {
+    return `${this.request.method} ${this.request.url} not found`
+  }
 }
 
 /**
  * @since 1.0.0
  * @category error
  */
-export const RouteNotFound: (props: Omit<RouteNotFound, HttpError.ProvidedFields>) => RouteNotFound =
-  internal.routeNotFound
-
-/**
- * @since 1.0.0
- * @category error
- */
-export interface ResponseError extends HttpError.Proto {
-  readonly _tag: "ResponseError"
+export class ResponseError extends RefailError(TypeId, "ResponseError")<{
   readonly request: ServerRequest.ServerRequest
   readonly response: ServerResponse.ServerResponse
   readonly reason: "Decode"
-  readonly error: unknown
-}
-
-/**
- * @since 1.0.0
- * @category error
- */
-export const ResponseError: (props: Omit<ResponseError, HttpError.ProvidedFields>) => ResponseError =
-  internal.responseError
+}> {
+  get methodAndUrl() {
+    return `${this.request.method} ${this.request.url}`
+  }
 
-/**
- * @since 1.0.0
- * @category error
- */
-export interface ServeError extends HttpError.Proto {
-  readonly _tag: "ServeError"
-  readonly error: unknown
+  get message() {
+    return `${this.reason} error (${this.response.status} ${this.methodAndUrl}): ${super.message}`
+  }
 }
 
 /**
  * @since 1.0.0
  * @category error
  */
-export const ServeError: (props: Omit<ServeError, HttpError.ProvidedFields>) => ServeError = internal.serveError
+export class ServeError extends RefailError(TypeId, "ServeError")<{}> {
+}
 
 /**
  * @since 1.0.0

package/src/Http/ServerRequest.ts

@@ -3,6 +3,8 @@
  */
 import type * as ParseResult from "@effect/schema/ParseResult"
 import type * as Schema from "@effect/schema/Schema"
+import type { Channel } from "effect/Channel"
+import type { Chunk } from "effect/Chunk"
 import type * as Context from "effect/Context"
 import type * as Effect from "effect/Effect"
 import type * as Scope from "effect/Scope"
@@ -10,6 +12,7 @@ import type * as Stream from "effect/Stream"
 import type * as FileSystem from "../FileSystem.js"
 import * as internal from "../internal/http/serverRequest.js"
 import type * as Path from "../Path.js"
+import type * as Socket from "../Socket.js"
 import type * as Headers from "./Headers.js"
 import type * as IncomingMessage from "./IncomingMessage.js"
 import type { Method } from "./Method.js"
@@ -54,6 +57,8 @@ export interface ServerRequest extends IncomingMessage.IncomingMessage<Error.Req
   >
   readonly multipartStream: Stream.Stream<Multipart.Part, Multipart.MultipartError>
 
+  readonly upgrade: Effect.Effect<Socket.Socket, Error.RequestError>
+
   readonly modify: (
     options: {
       readonly url?: string
@@ -79,6 +84,26 @@ export const persistedMultipart: Effect.Effect<
   Scope.Scope | FileSystem.FileSystem | Path.Path | ServerRequest
 > = internal.multipartPersisted
 
+/**
+ * @since 1.0.0
+ * @category accessors
+ */
+export const upgrade: Effect.Effect<Socket.Socket, Error.RequestError, ServerRequest> = internal.upgrade
+
+/**
+ * @since 1.0.0
+ * @category accessors
+ */
+export const upgradeChannel: <IE = never>() => Channel<
+  Chunk<Uint8Array>,
+  Chunk<Uint8Array>,
+  Error.RequestError | IE | Socket.SocketError,
+  IE,
+  void,
+  unknown,
+  ServerRequest
+> = internal.upgradeChannel
+
 /**
  * @since 1.0.0
  * @category schema

package/src/Http/UrlParams.ts

@@ -31,6 +31,16 @@ export const fromInput = (input: Input): UrlParams => {
   return ReadonlyArray.fromIterable(Object.entries(input))
 }
 
+/**
+ * @since 1.0.0
+ * @category schemas
+ */
+export const schema: Schema.Schema<UrlParams, ReadonlyArray<readonly [string, string]>> = Schema.array(
+  Schema.tuple(Schema.string, Schema.string)
+).pipe(
+  Schema.identifier("UrlParams")
+)
+
 /**
  * @since 1.0.0
  * @category constructors

package/src/PlatformLogger.ts

@@ -0,0 +1,59 @@
+/**
+ * @since 1.0.0
+ */
+import type { DurationInput } from "effect/Duration"
+import type { Effect } from "effect/Effect"
+import type * as Logger from "effect/Logger"
+import type { Scope } from "effect/Scope"
+import type { PlatformError } from "./Error.js"
+import type { FileSystem, OpenFileOptions } from "./FileSystem.js"
+import * as internal from "./internal/platformLogger.js"
+
+/**
+ * Create a Logger from another string Logger that writes to the specified file.
+ *
+ * @since 1.0.0
+ * @example
+ * import { PlatformLogger } from "@effect/platform"
+ * import { NodeFileSystem, NodeRuntime } from "@effect/platform-node"
+ * import { Effect, Layer, Logger } from "effect"
+ *
+ * const fileLogger = Logger.logfmtLogger.pipe(
+ *   PlatformLogger.toFile("/tmp/log.txt")
+ * )
+ * const LoggerLive = Logger.replaceScoped(Logger.defaultLogger, fileLogger).pipe(
+ *   Layer.provide(NodeFileSystem.layer)
+ * )
+ *
+ * Effect.log("a").pipe(
+ *   Effect.zipRight(Effect.log("b")),
+ *   Effect.zipRight(Effect.log("c")),
+ *   Effect.provide(LoggerLive),
+ *   NodeRuntime.runMain
+ * )
+ */
+export const toFile: {
+  (
+    path: string,
+    options?:
+      | (OpenFileOptions & {
+        readonly batchWindow?:
+          | DurationInput
+          | undefined
+      })
+      | undefined
+  ): <Message>(
+    self: Logger.Logger<Message, string>
+  ) => Effect<Logger.Logger<Message, void>, PlatformError, Scope | FileSystem>
+  <Message>(
+    self: Logger.Logger<Message, string>,
+    path: string,
+    options?:
+      | (OpenFileOptions & {
+        readonly batchWindow?:
+          | DurationInput
+          | undefined
+      })
+      | undefined
+  ): Effect<Logger.Logger<Message, void>, PlatformError, Scope | FileSystem>
+} = internal.toFile