@effect/platform 0.68.6 → 0.69.1

package/src/HttpApiMiddleware.ts

@@ -0,0 +1,317 @@
+/**
+ * @since 1.0.0
+ */
+import * as Context from "effect/Context"
+import type * as Effect from "effect/Effect"
+import { hasProperty } from "effect/Predicate"
+import * as Schema from "effect/Schema"
+import type { Mutable, Simplify } from "effect/Types"
+import type * as HttpApiSecurity from "./HttpApiSecurity.js"
+import type * as HttpRouter from "./HttpRouter.js"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const TypeId: unique symbol = Symbol.for("@effect/platform/HttpApiMiddleware")
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const SecurityTypeId: unique symbol = Symbol.for("@effect/platform/HttpApiMiddleware/Security")
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type SecurityTypeId = typeof SecurityTypeId
+
+/**
+ * @since 1.0.0
+ * @category guards
+ */
+export const isSecurity = (u: TagClassAny): u is TagClassSecurityAny => hasProperty(u, SecurityTypeId)
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface HttpApiMiddleware<Provides, E> extends Effect.Effect<Provides, E, HttpRouter.HttpRouter.Provided> {}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type HttpApiMiddlewareSecurity<Security extends Record<string, HttpApiSecurity.HttpApiSecurity>, Provides, E> = {
+  readonly [K in keyof Security]: (
+    _: HttpApiSecurity.HttpApiSecurity.Type<Security[K]>
+  ) => Effect.Effect<Provides, E, HttpRouter.HttpRouter.Provided>
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace HttpApiMiddleware {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface Any {
+    readonly [TypeId]: TypeId
+  }
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface AnyId {
+    readonly [TypeId]: {
+      readonly provides: any
+    }
+  }
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Provides<A> = A extends { readonly [TypeId]: { readonly provides: infer P } } ? P : never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type ExtractProvides<A> = Provides<Only<A>>
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Error<A> = A extends { readonly [TypeId]: { readonly failure: infer E } } ? E : never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type ErrorContext<A> = A extends { readonly [TypeId]: { readonly failureContext: infer R } } ? R : never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Only<R> = Extract<R, AnyId>
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Without<R> = Exclude<R, AnyId>
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type TagClass<
+  Self,
+  Name extends string,
+  Options
+> = Options extends { readonly security: Record<string, HttpApiSecurity.HttpApiSecurity> } ? TagClass.BaseSecurity<
+    Self,
+    Name,
+    Options,
+    Simplify<
+      HttpApiMiddlewareSecurity<
+        Options["security"],
+        TagClass.Service<Options>,
+        TagClass.FailureService<Options>
+      >
+    >,
+    Options["security"]
+  >
+  : TagClass.Base<
+    Self,
+    Name,
+    Options,
+    HttpApiMiddleware<
+      TagClass.Service<Options>,
+      TagClass.FailureService<Options>
+    >
+  >
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export declare namespace TagClass {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Provides<Options> = Options extends {
+    readonly provides: Context.Tag<any, any>
+    readonly optional?: false
+  } ? Context.Tag.Identifier<Options["provides"]>
+    : never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Service<Options> = Options extends { readonly provides: Context.Tag<any, any> }
+    ? Context.Tag.Service<Options["provides"]>
+    : void
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type FailureSchema<Options> = Options extends
+    { readonly failure: Schema.Schema.All; readonly optional?: false } ? Options["failure"]
+    : typeof Schema.Never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Failure<Options> = Options extends
+    { readonly failure: Schema.Schema<infer _A, infer _I, infer _R>; readonly optional?: false } ? _A
+    : never
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type FailureContext<Options> = Schema.Schema.Context<FailureSchema<Options>>
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type FailureService<Options> = Optional<Options> extends true ? unknown : Failure<Options>
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Optional<Options> = Options extends { readonly optional: true } ? true : false
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface Base<Self, Name extends string, Options, Service> extends Context.Tag<Self, Service> {
+    new(_: never):
+      & Context.TagClassShape<Name, Service>
+      & {
+        readonly [TypeId]: {
+          readonly provides: Provides<Options>
+          readonly failure: Failure<Options>
+          readonly failureContext: FailureContext<Options>
+        }
+      }
+    readonly [TypeId]: TypeId
+    readonly optional: Optional<Options>
+    readonly failure: FailureSchema<Options>
+    readonly provides: Options extends { readonly provides: Context.Tag<any, any> } ? Options["provides"]
+      : undefined
+  }
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface BaseSecurity<
+    Self,
+    Name extends string,
+    Options,
+    Service,
+    Security extends Record<string, HttpApiSecurity.HttpApiSecurity>
+  > extends Base<Self, Name, Options, Service> {
+    readonly [SecurityTypeId]: SecurityTypeId
+    readonly security: Security
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface TagClassAny extends Context.Tag<any, HttpApiMiddleware.Any> {
+  readonly [TypeId]: TypeId
+  readonly optional: boolean
+  readonly provides?: Context.Tag<any, any>
+  readonly failure: Schema.Schema.All
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface TagClassSecurityAny extends TagClassAny {
+  readonly [SecurityTypeId]: SecurityTypeId
+  readonly security: Record<string, HttpApiSecurity.HttpApiSecurity>
+}
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export const Tag = <Self>(): <
+  const Name extends string,
+  const Options extends {
+    readonly optional?: boolean
+    readonly failure?: Schema.Schema.All
+    readonly provides?: Context.Tag<any, any>
+    readonly security?: Record<string, HttpApiSecurity.HttpApiSecurity>
+  }
+>(
+  id: Name,
+  options?: Options | undefined
+) => TagClass<Self, Name, Options> =>
+(
+  id: string,
+  options?: {
+    readonly optional?: boolean
+    readonly security?: Record<string, HttpApiSecurity.HttpApiSecurity>
+    readonly failure?: Schema.Schema.All
+    readonly provides?: Context.Tag<any, any>
+  }
+) => {
+  const Err = globalThis.Error as any
+  const limit = Err.stackTraceLimit
+  Err.stackTraceLimit = 2
+  const creationError = new Err()
+  Err.stackTraceLimit = limit
+
+  function TagClass() {}
+  const TagClass_ = TagClass as any as Mutable<TagClassSecurityAny>
+  Object.setPrototypeOf(TagClass, Object.getPrototypeOf(Context.GenericTag<Self, any>(id)))
+  TagClass.key = id
+  Object.defineProperty(TagClass, "stack", {
+    get() {
+      return creationError.stack
+    }
+  })
+  TagClass_[TypeId] = TypeId
+  TagClass_.failure = options?.optional === true || options?.failure === undefined ? Schema.Never : options.failure
+  if (options?.provides) {
+    TagClass_.provides = options.provides
+  }
+  TagClass_.optional = options?.optional ?? false
+  if (options?.security) {
+    if (Object.keys(options.security).length === 0) {
+      throw new Error("HttpApiMiddleware.Tag: security object must not be empty")
+    }
+    TagClass_[SecurityTypeId] = SecurityTypeId
+    TagClass_.security = options.security
+  }
+  return TagClass as any
+}

package/src/HttpApiSchema.ts

@@ -1,11 +1,12 @@
 /**
  * @since 1.0.0
  */
-import * as AST from "@effect/schema/AST"
-import * as Schema from "@effect/schema/Schema"
 import type { Brand } from "effect/Brand"
 import type { LazyArg } from "effect/Function"
 import { constVoid, dual } from "effect/Function"
+import { globalValue } from "effect/GlobalValue"
+import * as Schema from "effect/Schema"
+import * as AST from "effect/SchemaAST"
 import * as Struct from "effect/Struct"
 
 /**
@@ -400,3 +401,39 @@ export const Text = (options?: {
 export const Uint8Array = (options?: {
   readonly contentType?: string
 }): typeof Schema.Uint8ArrayFromSelf => withEncoding(Schema.Uint8ArrayFromSelf, { kind: "Uint8Array", ...options })
+
+const astCache = globalValue(
+  "@effect/platform/HttpApiSchema/astCache",
+  () => new WeakMap<AST.AST, Schema.Schema.Any>()
+)
+
+/**
+ * @since 1.0.0
+ */
+export const deunionize = (
+  schemas: Set<Schema.Schema.Any>,
+  schema: Schema.Schema.Any
+): void => {
+  if (astCache.has(schema.ast)) {
+    schemas.add(astCache.get(schema.ast)!)
+    return
+  }
+  const ast = schema.ast
+  if (ast._tag === "Union") {
+    for (const astType of ast.types) {
+      if (astCache.has(astType)) {
+        schemas.add(astCache.get(astType)!)
+        continue
+      }
+      const memberSchema = Schema.make(AST.annotations(astType, {
+        ...ast.annotations,
+        ...astType.annotations
+      }))
+      astCache.set(astType, memberSchema)
+      schemas.add(memberSchema)
+    }
+  } else {
+    astCache.set(ast, schema)
+    schemas.add(schema)
+  }
+}

package/src/HttpApiSecurity.ts

@@ -140,7 +140,7 @@ export const basic: Basic = Object.assign(Object.create(Proto), {
  * @since 1.0.0
  * @category annotations
  */
-export const annotateMerge: {
+export const annotateContext: {
   /**
    * @since 1.0.0
    * @category annotations

package/src/HttpApiSwagger.ts

@@ -3,7 +3,7 @@
  */
 import * as Effect from "effect/Effect"
 import type { Layer } from "effect/Layer"
-import { HttpApi } from "./HttpApi.js"
+import { Api } from "./HttpApi.js"
 import { Router } from "./HttpApiBuilder.js"
 import * as HttpServerResponse from "./HttpServerResponse.js"
 import * as internal from "./internal/apiSwagger.js"
@@ -15,10 +15,10 @@ import * as OpenApi from "./OpenApi.js"
  */
 export const layer = (options?: {
   readonly path?: `/${string}` | undefined
-}): Layer<never, never, HttpApi.Service> =>
+}): Layer<never, never, Api> =>
   Router.use((router) =>
     Effect.gen(function*() {
-      const api = yield* HttpApi
+      const { api } = yield* Api
       const spec = OpenApi.fromApi(api)
       const response = HttpServerResponse.html(`<!DOCTYPE html>
 <html lang="en">

package/src/HttpBody.ts

@@ -1,11 +1,11 @@
 /**
  * @since 1.0.0
  */
-import type * as ParseResult from "@effect/schema/ParseResult"
-import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
 import type { Inspectable } from "effect/Inspectable"
+import type * as ParseResult from "effect/ParseResult"
 import * as Predicate from "effect/Predicate"
+import type * as Schema from "effect/Schema"
 import type * as Stream_ from "effect/Stream"
 import type * as PlatformError from "./Error.js"
 import type * as FileSystem from "./FileSystem.js"

package/src/HttpClientRequest.ts

@@ -1,13 +1,13 @@
 /**
  * @since 1.0.0
  */
-import type { ParseOptions } from "@effect/schema/AST"
-import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
 import type { Inspectable } from "effect/Inspectable"
 import type * as Option from "effect/Option"
 import type { Pipeable } from "effect/Pipeable"
 import type { Redacted } from "effect/Redacted"
+import type * as Schema from "effect/Schema"
+import type { ParseOptions } from "effect/SchemaAST"
 import type * as Stream from "effect/Stream"
 import type * as PlatformError from "./Error.js"
 import type * as FileSystem from "./FileSystem.js"

package/src/HttpClientResponse.ts

@@ -1,10 +1,10 @@
 /**
  * @since 1.0.0
  */
-import type { ParseOptions } from "@effect/schema/AST"
-import type * as ParseResult from "@effect/schema/ParseResult"
-import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
+import type * as ParseResult from "effect/ParseResult"
+import type * as Schema from "effect/Schema"
+import type { ParseOptions } from "effect/SchemaAST"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import type { Unify } from "effect/Unify"

package/src/HttpIncomingMessage.ts

@@ -1,15 +1,15 @@
 /**
  * @since 1.0.0
  */
-import type { ParseOptions } from "@effect/schema/AST"
-import type * as ParseResult from "@effect/schema/ParseResult"
-import * as Schema from "@effect/schema/Schema"
 import * as Effect from "effect/Effect"
 import * as FiberRef from "effect/FiberRef"
 import { dual } from "effect/Function"
 import * as Global from "effect/GlobalValue"
 import type { Inspectable } from "effect/Inspectable"
 import * as Option from "effect/Option"
+import type * as ParseResult from "effect/ParseResult"
+import * as Schema from "effect/Schema"
+import type { ParseOptions } from "effect/SchemaAST"
 import type * as Stream from "effect/Stream"
 import * as FileSystem from "./FileSystem.js"
 import type * as Headers from "./Headers.js"

package/src/HttpRouter.ts

@@ -1,9 +1,6 @@
 /**
  * @since 1.0.0
  */
-import type { ParseOptions } from "@effect/schema/AST"
-import type * as ParseResult from "@effect/schema/ParseResult"
-import type * as Schema from "@effect/schema/Schema"
 import type * as Cause from "effect/Cause"
 import type * as Chunk from "effect/Chunk"
 import type * as Context from "effect/Context"
@@ -12,6 +9,9 @@ import type { FiberRef } from "effect/FiberRef"
 import type { Inspectable } from "effect/Inspectable"
 import type * as Layer from "effect/Layer"
 import type * as Option from "effect/Option"
+import type * as ParseResult from "effect/ParseResult"
+import type * as Schema from "effect/Schema"
+import type { ParseOptions } from "effect/SchemaAST"
 import type * as Scope from "effect/Scope"
 import type { RouterConfig } from "find-my-way-ts"
 import type * as Etag from "./Etag.js"

package/src/HttpServer.ts

@@ -5,11 +5,15 @@ import type * as Context from "effect/Context"
 import type * as Effect from "effect/Effect"
 import type * as Layer from "effect/Layer"
 import type * as Scope from "effect/Scope"
+import type { Generator } from "./Etag.js"
+import type { FileSystem } from "./FileSystem.js"
 import type * as App from "./HttpApp.js"
 import type * as Client from "./HttpClient.js"
 import type * as Middleware from "./HttpMiddleware.js"
+import type { HttpPlatform } from "./HttpPlatform.js"
 import type * as ServerRequest from "./HttpServerRequest.js"
 import * as internal from "./internal/httpServer.js"
+import type { Path } from "./Path.js"
 
 /**
  * @since 1.0.0
@@ -231,3 +235,20 @@ export const withLogAddress: <A, E, R>(layer: Layer.Layer<A, E, R>) => Layer.Lay
  */
 export const layerTestClient: Layer.Layer<Client.HttpClient, never, Client.HttpClient | HttpServer> =
   internal.layerTestClient
+
+/**
+ * A Layer providing the `HttpPlatform`, `FileSystem`, `Etag.Generator`, and `Path`
+ * services.
+ *
+ * The `FileSystem` service is a no-op implementation, so this layer is only
+ * useful for platforms that have no file system.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerContext: Layer.Layer<
+  | HttpPlatform
+  | FileSystem
+  | Generator
+  | Path
+> = internal.layerContext

package/src/HttpServerRequest.ts

@@ -1,15 +1,15 @@
 /**
  * @since 1.0.0
  */
-import type { ParseOptions } from "@effect/schema/AST"
-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 { Option } from "effect/Option"
+import type * as ParseResult from "effect/ParseResult"
 import type { ReadonlyRecord } from "effect/Record"
+import type * as Schema from "effect/Schema"
+import type { ParseOptions } from "effect/SchemaAST"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import type * as FileSystem from "./FileSystem.js"

package/src/HttpServerRespondable.ts

@@ -1,9 +1,9 @@
 /**
  * @since 1.0.0
  */
-import * as ParseResult from "@effect/schema/ParseResult"
 import * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
+import * as ParseResult from "effect/ParseResult"
 import { hasProperty } from "effect/Predicate"
 import type { HttpServerResponse } from "./HttpServerResponse.js"
 import * as ServerResponse from "./HttpServerResponse.js"

package/src/HttpServerResponse.ts

@@ -1,11 +1,11 @@
 /**
  * @since 1.0.0
  */
-import type { ParseOptions } from "@effect/schema/AST"
-import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
 import type { Inspectable } from "effect/Inspectable"
 import type * as Runtime from "effect/Runtime"
+import type * as Schema from "effect/Schema"
+import type { ParseOptions } from "effect/SchemaAST"
 import type * as Stream from "effect/Stream"
 import type { Cookie, Cookies, CookiesError } from "./Cookies.js"
 import type * as PlatformError from "./Error.js"

package/src/KeyValueStore.ts

@@ -1,13 +1,13 @@
 /**
  * @since 1.0.0
  */
-import type * as ParseResult from "@effect/schema/ParseResult"
-import type * as Schema from "@effect/schema/Schema"
 import type * as Context from "effect/Context"
 import type * as Effect from "effect/Effect"
 import type { LazyArg } from "effect/Function"
 import type * as Layer from "effect/Layer"
 import type * as Option from "effect/Option"
+import type * as ParseResult from "effect/ParseResult"
+import type * as Schema from "effect/Schema"
 import type * as PlatformError from "./Error.js"
 import type * as FileSystem from "./FileSystem.js"
 import * as internal from "./internal/keyValueStore.js"

package/src/Multipart.ts

@@ -1,9 +1,6 @@
 /**
  * @since 1.0.0
  */
-import type { ParseOptions } from "@effect/schema/AST"
-import type * as ParseResult from "@effect/schema/ParseResult"
-import type * as Schema from "@effect/schema/Schema"
 import type { YieldableError } from "effect/Cause"
 import type * as Channel from "effect/Channel"
 import type * as Chunk from "effect/Chunk"
@@ -11,6 +8,9 @@ import type * as Effect from "effect/Effect"
 import type * as FiberRef from "effect/FiberRef"
 import type { Inspectable } from "effect/Inspectable"
 import type * as Option from "effect/Option"
+import type * as ParseResult from "effect/ParseResult"
+import type * as Schema from "effect/Schema"
+import type { ParseOptions } from "effect/SchemaAST"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import type * as Multipasta from "multipasta"