@effect/platform 0.70.7 → 0.71.1

package/src/HttpApiSchema.ts

@@ -2,9 +2,12 @@
  * @since 1.0.0
  */
 import type { Brand } from "effect/Brand"
+import * as Effect from "effect/Effect"
+import * as Effectable from "effect/Effectable"
 import type { LazyArg } from "effect/Function"
-import { constVoid, dual } from "effect/Function"
+import { constant, constVoid, dual } from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
+import { hasProperty } from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import * as AST from "effect/SchemaAST"
 import * as Struct from "effect/Struct"
@@ -245,7 +248,7 @@ export const asEmpty: {
     self: S,
     options: {
       readonly status: number
-      readonly decode?: LazyArg<Schema.Schema.Type<S>>
+      readonly decode: LazyArg<Schema.Schema.Type<S>>
     }
   ): asEmpty<S>
 } = dual(
@@ -254,14 +257,14 @@ export const asEmpty: {
     self: S,
     options: {
       readonly status: number
-      readonly decode?: LazyArg<Schema.Schema.Type<S>>
+      readonly decode: LazyArg<Schema.Schema.Type<S>>
     }
   ): asEmpty<S> =>
     Schema.transform(
-      Schema.Void,
+      Schema.Void.annotations(self.ast.annotations),
       Schema.typeSchema(self),
       {
-        decode: options.decode as any,
+        decode: options.decode,
         encode: constVoid
       }
     ).annotations(annotations({
@@ -482,3 +485,58 @@ export const deunionize = (
     schemas.add(schema)
   }
 }
+
+/**
+ * @since 1.0.0
+ * @category empty errors
+ */
+export interface EmptyErrorClass<Self, Tag> extends Schema.Schema<Self, void> {
+  new(_: void): { readonly _tag: Tag } & Effect.Effect<never, Self>
+}
+
+/**
+ * @since 1.0.0
+ * @category empty errors
+ */
+export const EmptyError = <Self>() =>
+<const Tag extends string>(options: {
+  readonly tag: Tag
+  readonly status: number
+}): EmptyErrorClass<Self, Tag> => {
+  const symbol = Symbol.for(`@effect/platform/HttpApiSchema/EmptyError/${options.tag}`)
+  class EmptyError extends Effectable.StructuralClass<never, Self> {
+    readonly _tag: Tag = options.tag
+    commit(): Effect.Effect<never, Self> {
+      return Effect.fail(this) as any
+    }
+  }
+  ;(EmptyError as any).prototype[symbol] = symbol
+  Object.assign(EmptyError, {
+    [Schema.TypeId]: Schema.Void[Schema.TypeId],
+    pipe: Schema.Void.pipe,
+    annotations(this: any, annotations: any) {
+      return Schema.make(this.ast).annotations(annotations)
+    }
+  })
+  let transform: Schema.Schema.Any | undefined
+  Object.defineProperty(EmptyError, "ast", {
+    get() {
+      if (transform) {
+        return transform.ast
+      }
+      const self = this as any
+      transform = asEmpty(
+        Schema.declare((u) => hasProperty(u, symbol), {
+          identifier: options.tag,
+          title: options.tag
+        }),
+        {
+          status: options.status,
+          decode: constant(new self())
+        }
+      )
+      return transform.ast
+    }
+  })
+  return EmptyError as any
+}

package/src/HttpApp.ts

@@ -4,7 +4,7 @@
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Exit from "effect/Exit"
-import type * as FiberRef from "effect/FiberRef"
+import * as FiberRef from "effect/FiberRef"
 import * as Layer from "effect/Layer"
 import type * as Option from "effect/Option"
 import * as Runtime from "effect/Runtime"
@@ -160,11 +160,20 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
       )
       return Effect.void
     }, middleware)
-    return (request: Request): Promise<Response> =>
+    return (request: Request, context?: Context.Context<never> | undefined): Promise<Response> =>
       new Promise((resolve) => {
+        const contextMap = new Map<string, any>(
+          context ?
+            [
+              ...runtime.context.unsafeMap,
+              ...context.unsafeMap
+            ] :
+            runtime.context.unsafeMap
+        )
         const httpServerRequest = ServerRequest.fromWeb(request)
+        contextMap.set(ServerRequest.HttpServerRequest.key, httpServerRequest)
         ;(httpServerRequest as any)[resolveSymbol] = resolve
-        const fiber = run(Effect.provideService(httpApp, ServerRequest.HttpServerRequest, httpServerRequest))
+        const fiber = run(Effect.locally(httpApp as any, FiberRef.currentContext, Context.unsafeMake(contextMap)))
         request.signal?.addEventListener("abort", () => {
           fiber.unsafeInterruptAsFork(ServerError.clientAbortFiberId)
         }, { once: true })
@@ -179,7 +188,9 @@ export const toWebHandlerRuntime = <R>(runtime: Runtime.Runtime<R>) => {
 export const toWebHandler: <E>(
   self: Default<E, Scope.Scope>,
   middleware?: HttpMiddleware | undefined
-) => (request: Request) => Promise<Response> = toWebHandlerRuntime(Runtime.defaultRuntime)
+) => (request: Request, context?: Context.Context<never> | undefined) => Promise<Response> = toWebHandlerRuntime(
+  Runtime.defaultRuntime
+)
 
 /**
  * @since 1.0.0
@@ -191,12 +202,13 @@ export const toWebHandlerLayer = <E, R, RE>(
   middleware?: HttpMiddleware | undefined
 ): {
   readonly close: () => Promise<void>
-  readonly handler: (request: Request) => Promise<Response>
+  readonly handler: (request: Request, context?: Context.Context<never> | undefined) => Promise<Response>
 } => {
   const scope = Effect.runSync(Scope.make())
   const close = () => Effect.runPromise(Scope.close(scope, Exit.void))
   const build = Effect.map(Layer.toRuntime(layer), (_) => toWebHandlerRuntime(_)(self, middleware))
   const runner = Effect.runPromise(Scope.extend(build, scope))
-  const handler = (request: Request): Promise<Response> => runner.then((handler) => handler(request))
+  const handler = (request: Request, context?: Context.Context<never> | undefined): Promise<Response> =>
+    runner.then((handler) => handler(request, context))
   return { close, handler } as const
 }

package/src/OpenApi.ts

@@ -2,6 +2,7 @@
  * @since 1.0.0
  */
 import * as Context from "effect/Context"
+import { constFalse } from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
 import * as Option from "effect/Option"
 import type { ReadonlyRecord } from "effect/Record"
@@ -84,6 +85,14 @@ export class Deprecated extends Context.Tag("@effect/platform/OpenApi/Deprecated
  */
 export class Override extends Context.Tag("@effect/platform/OpenApi/Override")<Override, Record<string, unknown>>() {}
 
+/**
+ * @since 1.0.0
+ * @category annotations
+ */
+export class Exclude extends Context.Reference<Exclude>()("@effect/platform/OpenApi/Exclude", {
+  defaultValue: constFalse
+}) {}
+
 /**
  * Transforms the generated OpenAPI specification
  * @since 1.0.0
@@ -127,6 +136,7 @@ export const annotations: (
     readonly servers?: ReadonlyArray<OpenAPISpecServer> | undefined
     readonly format?: string | undefined
     readonly override?: Record<string, unknown> | undefined
+    readonly exclude?: boolean | undefined
     readonly transform?: ((openApiSpec: Record<string, any>) => Record<string, any>) | undefined
   }
 ) => Context.Context<never> = contextPartial({
@@ -140,6 +150,7 @@ export const annotations: (
   servers: Servers,
   format: Format,
   override: Override,
+  exclude: Exclude,
   transform: Transform
 })
 
@@ -213,6 +224,9 @@ export const fromApi = <A extends HttpApi.HttpApi.Any>(self: A): OpenAPISpec =>
   })
   HttpApi.reflect(api as any, {
     onGroup({ group }) {
+      if (Context.get(group.annotations, Exclude)) {
+        return
+      }
       let tag: Mutable<OpenAPISpecTag> = {
         name: Context.getOrElse(group.annotations, Title, () => group.identifier)
       }
@@ -230,7 +244,10 @@ export const fromApi = <A extends HttpApi.HttpApi.Any>(self: A): OpenAPISpec =>
       })
       spec.tags!.push(tag)
     },
-    onEndpoint({ endpoint, errors, group, middleware, payloads, successes }) {
+    onEndpoint({ endpoint, errors, group, mergedAnnotations, middleware, payloads, successes }) {
+      if (Context.get(mergedAnnotations, Exclude)) {
+        return
+      }
       const path = endpoint.path.replace(/:(\w+)[^/]*/g, "{$1}")
       const method = endpoint.method.toLowerCase() as OpenAPISpecMethodName
       let op: DeepMutable<OpenAPISpecOperation> = {