@effect/platform 0.70.7 → 0.71.0

package/src/HttpApi.ts

@@ -45,12 +45,14 @@ export const isHttpApi = (u: unknown): u is HttpApi.Any => Predicate.hasProperty
  * @category models
  */
 export interface HttpApi<
+  out Id extends string,
   out Groups extends HttpApiGroup.HttpApiGroup.Any = never,
   in out E = never,
   out R = never
 > extends Pipeable {
   new(_: never): {}
   readonly [TypeId]: TypeId
+  readonly identifier: Id
   readonly groups: Record.ReadonlyRecord<string, Groups>
   readonly annotations: Context.Context<never>
   readonly errorSchema: Schema.Schema<E, unknown, R>
@@ -59,11 +61,14 @@ export interface HttpApi<
   /**
    * Add a `HttpApiGroup` to the `HttpApi`.
    */
-  add<A extends HttpApiGroup.HttpApiGroup.Any>(group: A): HttpApi<Groups | A, E, R>
+  add<A extends HttpApiGroup.HttpApiGroup.Any>(group: A): HttpApi<Id, Groups | A, E, R>
   /**
    * Add another `HttpApi` to the `HttpApi`.
    */
-  addHttpApi<Groups2 extends HttpApiGroup.HttpApiGroup.Any, E2, R2>(api: HttpApi<Groups2, E2, R2>): HttpApi<
+  addHttpApi<Id2 extends string, Groups2 extends HttpApiGroup.HttpApiGroup.Any, E2, R2>(
+    api: HttpApi<Id2, Groups2, E2, R2>
+  ): HttpApi<
+    Id,
     Groups | HttpApiGroup.HttpApiGroup.AddContext<Groups2, R2>,
     E | E2,
     R
@@ -76,11 +81,11 @@ export interface HttpApi<
     annotations?: {
       readonly status?: number | undefined
     }
-  ): HttpApi<Groups, E | A, R | RX>
+  ): HttpApi<Id, Groups, E | A, R | RX>
   /**
    * Prefix all endpoints in the `HttpApi`.
    */
-  prefix(prefix: PathInput): HttpApi<Groups, E, R>
+  prefix(prefix: PathInput): HttpApi<Id, Groups, E, R>
   /**
    * Add a middleware to a `HttpApi`. It will be applied to all endpoints in the
    * `HttpApi`.
@@ -88,6 +93,7 @@ export interface HttpApi<
   middleware<I extends HttpApiMiddleware.HttpApiMiddleware.AnyId, S>(
     middleware: Context.Tag<I, S>
   ): HttpApi<
+    Id,
     Groups,
     E | HttpApiMiddleware.HttpApiMiddleware.Error<I>,
     R | I | HttpApiMiddleware.HttpApiMiddleware.ErrorContext<I>
@@ -95,11 +101,11 @@ export interface HttpApi<
   /**
    * Annotate the `HttpApi`.
    */
-  annotate<I, S>(tag: Context.Tag<I, S>, value: S): HttpApi<Groups, E, R>
+  annotate<I, S>(tag: Context.Tag<I, S>, value: S): HttpApi<Id, Groups, E, R>
   /**
    * Annotate the `HttpApi` with a Context.
    */
-  annotateContext<I>(context: Context.Context<I>): HttpApi<Groups, E, R>
+  annotateContext<I>(context: Context.Context<I>): HttpApi<Id, Groups, E, R>
 }
 
 /**
@@ -109,7 +115,7 @@ export interface HttpApi<
 export class Api extends Context.Tag("@effect/platform/HttpApi/Api")<
   Api,
   {
-    readonly api: HttpApi<HttpApiGroup.HttpApiGroup.AnyWithProps>
+    readonly api: HttpApi<string, HttpApiGroup.HttpApiGroup.AnyWithProps>
     readonly context: Context.Context<never>
   }
 >() {}
@@ -131,7 +137,7 @@ export declare namespace HttpApi {
    * @since 1.0.0
    * @category models
    */
-  export type AnyWithProps = HttpApi<HttpApiGroup.HttpApiGroup.AnyWithProps, any, any>
+  export type AnyWithProps = HttpApi<string, HttpApiGroup.HttpApiGroup.AnyWithProps, any, any>
 }
 
 const Proto = {
@@ -144,6 +150,7 @@ const Proto = {
     group: HttpApiGroup.HttpApiGroup.AnyWithProps
   ) {
     return makeProto({
+      identifier: this.identifier,
       groups: Record.set(this.groups, group.identifier, group),
       errorSchema: this.errorSchema,
       annotations: this.annotations,
@@ -158,10 +165,11 @@ const Proto = {
     for (const key in api.groups) {
       const newGroup: Mutable<HttpApiGroup.HttpApiGroup.AnyWithProps> = api.groups[key].annotateContext(Context.empty())
       newGroup.annotations = Context.merge(api.annotations, newGroup.annotations)
-      newGroup.middlewares = new Set([...this.middlewares, ...newGroup.middlewares])
+      newGroup.middlewares = new Set([...api.middlewares, ...newGroup.middlewares])
       newGroups[key] = newGroup as any
     }
     return makeProto({
+      identifier: this.identifier,
       groups: newGroups,
       errorSchema: HttpApiSchema.UnionUnify(this.errorSchema, api.errorSchema),
       annotations: this.annotations,
@@ -174,6 +182,7 @@ const Proto = {
     annotations?: { readonly status?: number }
   ) {
     return makeProto({
+      identifier: this.identifier,
       groups: this.groups,
       errorSchema: HttpApiSchema.UnionUnify(
         this.errorSchema,
@@ -187,6 +196,7 @@ const Proto = {
   },
   prefix(this: HttpApi.AnyWithProps, prefix: PathInput) {
     return makeProto({
+      identifier: this.identifier,
       groups: Record.map(this.groups, (group) => group.prefix(prefix)),
       errorSchema: this.errorSchema,
       annotations: this.annotations,
@@ -195,6 +205,7 @@ const Proto = {
   },
   middleware(this: HttpApi.AnyWithProps, tag: HttpApiMiddleware.TagClassAny) {
     return makeProto({
+      identifier: this.identifier,
       groups: this.groups,
       errorSchema: HttpApiSchema.UnionUnify(
         this.errorSchema,
@@ -208,6 +219,7 @@ const Proto = {
   },
   annotate(this: HttpApi.AnyWithProps, tag: Context.Tag<any, any>, value: any) {
     return makeProto({
+      identifier: this.identifier,
       groups: this.groups,
       errorSchema: this.errorSchema,
       annotations: Context.add(this.annotations, tag, value),
@@ -216,6 +228,7 @@ const Proto = {
   },
   annotateContext(this: HttpApi.AnyWithProps, context: Context.Context<any>) {
     return makeProto({
+      identifier: this.identifier,
       groups: this.groups,
       errorSchema: this.errorSchema,
       annotations: Context.merge(this.annotations, context),
@@ -224,14 +237,15 @@ const Proto = {
   }
 }
 
-const makeProto = <Groups extends HttpApiGroup.HttpApiGroup.Any, E, I, R>(
+const makeProto = <Id extends string, Groups extends HttpApiGroup.HttpApiGroup.Any, E, I, R>(
   options: {
+    readonly identifier: Id
     readonly groups: Record.ReadonlyRecord<string, Groups>
     readonly errorSchema: Schema.Schema<E, I, R>
     readonly annotations: Context.Context<never>
     readonly middlewares: ReadonlySet<HttpApiMiddleware.TagClassAny>
   }
-): HttpApi<Groups, E, R> => {
+): HttpApi<Id, Groups, E, R> => {
   function HttpApi() {}
   Object.setPrototypeOf(HttpApi, Proto)
   HttpApi.groups = options.groups
@@ -250,12 +264,14 @@ const makeProto = <Groups extends HttpApiGroup.HttpApiGroup.Any, E, I, R>(
  * @since 1.0.0
  * @category constructors
  */
-export const empty: HttpApi<never, HttpApiDecodeError> = makeProto({
-  groups: new Map() as any,
-  errorSchema: HttpApiDecodeError,
-  annotations: Context.empty(),
-  middlewares: new Set()
-})
+export const make = <const Id extends string>(identifier: Id): HttpApi<Id, never, HttpApiDecodeError> =>
+  makeProto({
+    identifier,
+    groups: new Map() as any,
+    errorSchema: HttpApiDecodeError,
+    annotations: Context.empty(),
+    middlewares: new Set()
+  })
 
 /**
  * Extract metadata from an `HttpApi`, which can be used to generate documentation
@@ -266,8 +282,8 @@ export const empty: HttpApi<never, HttpApiDecodeError> = makeProto({
  * @since 1.0.0
  * @category reflection
  */
-export const reflect = <Groups extends HttpApiGroup.HttpApiGroup.Any, Error, R>(
-  self: HttpApi<Groups, Error, R>,
+export const reflect = <Id extends string, Groups extends HttpApiGroup.HttpApiGroup.Any, Error, R>(
+  self: HttpApi<Id, Groups, Error, R>,
   options: {
     readonly predicate?: Predicate.Predicate<{
       readonly endpoint: HttpApiEndpoint.HttpApiEndpoint.AnyWithProps

package/src/HttpApiBuilder.ts

@@ -55,12 +55,12 @@ export class Router extends HttpRouter.Tag("@effect/platform/HttpApiBuilder/Rout
  * @since 1.0.0
  * @category constructors
  */
-export const api = <Groups extends HttpApiGroup.HttpApiGroup.Any, E, R>(
-  api: HttpApi.HttpApi<Groups, E, R>
+export const api = <Id extends string, Groups extends HttpApiGroup.HttpApiGroup.Any, E, R>(
+  api: HttpApi.HttpApi<Id, Groups, E, R>
 ): Layer.Layer<
   HttpApi.Api,
   never,
-  HttpApiGroup.HttpApiGroup.ToService<Groups> | R | HttpApiGroup.HttpApiGroup.ErrorContext<Groups>
+  HttpApiGroup.HttpApiGroup.ToService<Id, Groups> | R | HttpApiGroup.HttpApiGroup.ErrorContext<Groups>
 > =>
   Layer.effect(
     HttpApi.Api,
@@ -132,7 +132,7 @@ export const httpApp: Effect.Effect<
  * import { HttpApi, HttpApiBuilder, HttpServer } from "@effect/platform"
  * import { Layer } from "effect"
  *
- * class MyApi extends HttpApi.empty {}
+ * class MyApi extends HttpApi.make("api") {}
  *
  * const MyApiLive = HttpApiBuilder.api(MyApi)
  *
@@ -429,19 +429,20 @@ const makeHandlers = <E, Provides, R, Endpoints extends HttpApiEndpoint.HttpApiE
  * @category handlers
  */
 export const group = <
+  ApiId extends string,
   Groups extends HttpApiGroup.HttpApiGroup.Any,
   ApiError,
   ApiR,
   const Name extends HttpApiGroup.HttpApiGroup.Name<Groups>,
   Return
 >(
-  api: HttpApi.HttpApi<Groups, ApiError, ApiR>,
+  api: HttpApi.HttpApi<ApiId, Groups, ApiError, ApiR>,
   groupName: Name,
   build: (
     handlers: Handlers.FromGroup<ApiError, ApiR, HttpApiGroup.HttpApiGroup.WithName<Groups, Name>>
   ) => Handlers.ValidateReturn<Return>
 ): Layer.Layer<
-  HttpApiGroup.ApiGroup<Name>,
+  HttpApiGroup.ApiGroup<ApiId, Name>,
   Handlers.Error<Return>,
   | Handlers.Context<Return>
   | HttpApiGroup.HttpApiGroup.MiddlewareWithName<Groups, Name>
@@ -481,6 +482,7 @@ export const group = <
  * @category handlers
  */
 export const handler = <
+  ApiId extends string,
   Groups extends HttpApiGroup.HttpApiGroup.Any,
   ApiError,
   ApiR,
@@ -488,7 +490,7 @@ export const handler = <
   const Name extends HttpApiGroup.HttpApiGroup.EndpointsWithName<Groups, GroupName>["name"],
   R
 >(
-  _api: HttpApi.HttpApi<Groups, ApiError, ApiR>,
+  _api: HttpApi.HttpApi<ApiId, Groups, ApiError, ApiR>,
   _groupName: GroupName,
   _name: Name,
   f: HttpApiEndpoint.HttpApiEndpoint.HandlerWithName<
@@ -842,8 +844,8 @@ export const middleware: {
    * @since 1.0.0
    * @category middleware
    */
-  <Groups extends HttpApiGroup.HttpApiGroup.Any, Error, ErrorR, EX = never, RX = never>(
-    api: HttpApi.HttpApi<Groups, Error, ErrorR>,
+  <ApiId extends string, Groups extends HttpApiGroup.HttpApiGroup.Any, Error, ErrorR, EX = never, RX = never>(
+    api: HttpApi.HttpApi<ApiId, Groups, Error, ErrorR>,
     middleware: MiddlewareFn<NoInfer<Error>> | Effect.Effect<MiddlewareFn<NoInfer<Error>>, EX, RX>,
     options?: {
       readonly withContext?: false | undefined
@@ -855,8 +857,8 @@ export const middleware: {
    * @since 1.0.0
    * @category middleware
    */
-  <Groups extends HttpApiGroup.HttpApiGroup.Any, Error, ErrorR, R, EX = never, RX = never>(
-    api: HttpApi.HttpApi<Groups, Error, ErrorR>,
+  <ApiId extends string, Groups extends HttpApiGroup.HttpApiGroup.Any, Error, ErrorR, R, EX = never, RX = never>(
+    api: HttpApi.HttpApi<ApiId, Groups, Error, ErrorR>,
     middleware: MiddlewareFn<NoInfer<Error>, R> | Effect.Effect<MiddlewareFn<NoInfer<Error>, R>, EX, RX>,
     options: {
       readonly withContext: true
@@ -926,8 +928,8 @@ export const middlewareScoped: {
    * @since 1.0.0
    * @category middleware
    */
-  <Groups extends HttpApiGroup.HttpApiGroup.Any, Error, ErrorR, EX, RX>(
-    api: HttpApi.HttpApi<Groups, Error, ErrorR>,
+  <ApiId extends string, Groups extends HttpApiGroup.HttpApiGroup.Any, Error, ErrorR, EX, RX>(
+    api: HttpApi.HttpApi<ApiId, Groups, Error, ErrorR>,
     middleware: Effect.Effect<MiddlewareFn<NoInfer<Error>>, EX, RX>,
     options?: {
       readonly withContext?: false | undefined
@@ -940,8 +942,8 @@ export const middlewareScoped: {
    * @since 1.0.0
    * @category middleware
    */
-  <Groups extends HttpApiGroup.HttpApiGroup.Any, Error, ErrorR, R, EX, RX>(
-    api: HttpApi.HttpApi<Groups, Error, ErrorR>,
+  <ApiId extends string, Groups extends HttpApiGroup.HttpApiGroup.Any, Error, ErrorR, R, EX, RX>(
+    api: HttpApi.HttpApi<ApiId, Groups, Error, ErrorR>,
     middleware: Effect.Effect<MiddlewareFn<NoInfer<Error>, R>, EX, RX>,
     options: {
       readonly withContext: true

package/src/HttpApiClient.ts

@@ -102,8 +102,8 @@ export declare namespace Client {
 /**
  * @internal
  */
-const makeClient = <Groups extends HttpApiGroup.Any, ApiError, ApiR>(
-  api: HttpApi.HttpApi<Groups, ApiError, ApiR>,
+const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, ApiError, ApiR>(
+  api: HttpApi.HttpApi<ApiId, Groups, ApiError, ApiR>,
   options: {
     readonly predicate?: Predicate.Predicate<{
       readonly endpoint: HttpApiEndpoint.AnyWithProps
@@ -240,8 +240,8 @@ const makeClient = <Groups extends HttpApiGroup.Any, ApiError, ApiR>(
  * @since 1.0.0
  * @category constructors
  */
-export const make = <Groups extends HttpApiGroup.Any, ApiError, ApiR>(
-  api: HttpApi.HttpApi<Groups, ApiError, ApiR>,
+export const make = <ApiId extends string, Groups extends HttpApiGroup.Any, ApiError, ApiR>(
+  api: HttpApi.HttpApi<ApiId, Groups, ApiError, ApiR>,
   options?: {
     readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined
     readonly transformResponse?:
@@ -272,12 +272,13 @@ export const make = <Groups extends HttpApiGroup.Any, ApiError, ApiR>(
  * @category constructors
  */
 export const group = <
+  ApiId extends string,
   Groups extends HttpApiGroup.Any,
   ApiError,
   ApiR,
   const GroupName extends Groups["identifier"]
 >(
-  api: HttpApi.HttpApi<Groups, ApiError, ApiR>,
+  api: HttpApi.HttpApi<ApiId, Groups, ApiError, ApiR>,
   groupId: GroupName,
   options?: {
     readonly transformClient?: ((client: HttpClient.HttpClient) => HttpClient.HttpClient) | undefined
@@ -311,13 +312,14 @@ export const group = <
  * @category constructors
  */
 export const endpoint = <
+  ApiId extends string,
   Groups extends HttpApiGroup.Any,
   ApiError,
   ApiR,
   const GroupName extends HttpApiGroup.Name<Groups>,
   const EndpointName extends HttpApiEndpoint.Name<HttpApiGroup.EndpointsWithName<Groups, GroupName>>
 >(
-  api: HttpApi.HttpApi<Groups, ApiError, ApiR>,
+  api: HttpApi.HttpApi<ApiId, Groups, ApiError, ApiR>,
   groupName: GroupName,
   endpointName: EndpointName,
   options?: {

package/src/HttpApiError.ts

@@ -109,3 +109,111 @@ export class HttpApiDecodeError extends Schema.TaggedError<HttpApiDecodeError>()
     return Effect.flatMap(HttpApiDecodeError.fromParseError(error), Effect.fail)
   }
 }
+
+/**
+ * @since 1.0.0
+ * @category empty errors
+ */
+export class BadRequest extends HttpApiSchema.EmptyError<BadRequest>()({
+  tag: "BadRequest",
+  status: 400
+}) {}
+
+/**
+ * @since 1.0.0
+ * @category empty errors
+ */
+export class Unauthorized extends HttpApiSchema.EmptyError<Unauthorized>()({
+  tag: "Unauthorized",
+  status: 401
+}) {}
+
+/**
+ * @since 1.0.0
+ * @category empty errors
+ */
+export class Forbidden extends HttpApiSchema.EmptyError<Forbidden>()({
+  tag: "Forbidden",
+  status: 403
+}) {}
+
+/**
+ * @since 1.0.0
+ * @category empty errors
+ */
+export class NotFound extends HttpApiSchema.EmptyError<NotFound>()({
+  tag: "NotFound",
+  status: 404
+}) {}
+
+/**
+ * @since 1.0.0
+ * @category empty errors
+ */
+export class MethodNotAllowed extends HttpApiSchema.EmptyError<MethodNotAllowed>()({
+  tag: "MethodNotAllowed",
+  status: 405
+}) {}
+
+/**
+ * @since 1.0.0
+ * @category empty errors
+ */
+export class NotAcceptable extends HttpApiSchema.EmptyError<NotAcceptable>()({
+  tag: "NotAcceptable",
+  status: 406
+}) {}
+
+/**
+ * @since 1.0.0
+ * @category empty errors
+ */
+export class RequestTimeout extends HttpApiSchema.EmptyError<RequestTimeout>()({
+  tag: "RequestTimeout",
+  status: 408
+}) {}
+
+/**
+ * @since 1.0.0
+ * @category empty errors
+ */
+export class Conflict extends HttpApiSchema.EmptyError<Conflict>()({
+  tag: "Conflict",
+  status: 409
+}) {}
+
+/**
+ * @since 1.0.0
+ * @category empty errors
+ */
+export class Gone extends HttpApiSchema.EmptyError<Gone>()({
+  tag: "Gone",
+  status: 410
+}) {}
+
+/**
+ * @since 1.0.0
+ * @category empty errors
+ */
+export class InternalServerError extends HttpApiSchema.EmptyError<InternalServerError>()({
+  tag: "InternalServerError",
+  status: 500
+}) {}
+
+/**
+ * @since 1.0.0
+ * @category empty errors
+ */
+export class NotImplemented extends HttpApiSchema.EmptyError<NotImplemented>()({
+  tag: "NotImplemented",
+  status: 501
+}) {}
+
+/**
+ * @since 1.0.0
+ * @category empty errors
+ */
+export class ServiceUnavailable extends HttpApiSchema.EmptyError<ServiceUnavailable>()({
+  tag: "ServiceUnavailable",
+  status: 503
+}) {}

package/src/HttpApiGroup.ts

@@ -139,8 +139,9 @@ export interface HttpApiGroup<
  * @since 1.0.0
  * @category models
  */
-export interface ApiGroup<Name extends string> {
+export interface ApiGroup<ApiId extends string, Name extends string> {
   readonly _: unique symbol
+  readonly apiId: ApiId
   readonly name: Name
 }
 
@@ -168,8 +169,8 @@ export declare namespace HttpApiGroup {
    * @since 1.0.0
    * @category models
    */
-  export type ToService<A> = A extends
-    HttpApiGroup<infer Name, infer _Endpoints, infer _Error, infer _R, infer _TopLevel> ? ApiGroup<Name>
+  export type ToService<ApiId extends string, A> = A extends
+    HttpApiGroup<infer Name, infer _Endpoints, infer _Error, infer _R, infer _TopLevel> ? ApiGroup<ApiId, Name>
     : never
 
   /**

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/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> = {