Function onEndpoint

packages/effect/src/unstable/httpapi/OpenApi.ts:369–639

({ endpoint, group, mergedAnnotations, middleware })

      spec.tags.push(tag)
    },
    onEndpoint({ endpoint, group, mergedAnnotations, middleware }) {
      if (Context.get(mergedAnnotations, Exclude)) {
        return
      }
      let op: OpenAPISpecOperation = {
        tags: [Context.getOrElse(group.annotations, Title, () => group.identifier)],
        operationId: Context.getOrElse(
          endpoint.annotations,
          Identifier,
          () => group.topLevel ? endpoint.identifier : `${group.identifier}.${endpoint.identifier}`
        ),
        parameters: [],
        security: [],
        responses: {}
      }

      const path = endpoint.path.replace(/:(\w+)\??/g, "{$1}")
      const method = endpoint.method.toLowerCase() as OpenAPISpecMethodName

      function processResponseBodies(bodies: ResponseBodies, defaultDescription: () => string) {
        for (const [status, { content, descriptions, headers, streamContent }] of bodies) {
          const description = descriptions.size > 0 ? Array.from(descriptions).join(" | ") : defaultDescription()
          InternalRecord.assignProperty(op.responses, status, {
            description
          })
          for (const schema of headers) {
            const ast = SchemaAST.getLastEncoding(schema.ast)
            if (SchemaAST.isObjects(ast)) {
              for (const ps of ast.propertySignatures) {
                const name = String(ps.name).toLowerCase()
                if (name === "content-type") continue
                op.responses[status].headers ??= {}
                InternalRecord.assignProperty(op.responses[status].headers, name, {
                  schema: {},
                  required: !SchemaAST.isOptional(ps.type)
                })
                pathOps.push({
                  _tag: "parameter",
                  ast: ps.type,
                  path: ["paths", path, method, "responses", String(status), "headers", name, "schema"]
                })
              }
            }
          }
          if (content !== undefined) {
            content.forEach((map, encoding) => {
              map.forEach((schemas, contentType) => {
                const asts = Array.from(schemas, SchemaAST.getAST)
                const ast = asts.length === 1 ? asts[0] : new SchemaAST.Union(asts, "anyOf")

                pathOps.push({
                  _tag: "schema",
                  ast: toEncodingAST(ast, encoding),
                  path: ["paths", path, method, "responses", String(status), "content", contentType, "schema"]
                })
                op.responses[status].content ??= {}
                InternalRecord.assignProperty(op.responses[status].content, contentType, {
                  schema: {}