effect 4.0.0-beta.1 → 4.0.0-beta.10

package/src/unstable/http/HttpClientRequest.ts

@@ -61,12 +61,6 @@ export interface Options {
  * @since 4.0.0
  */
 export declare namespace Options {
-  /**
-   * @since 4.0.0
-   * @category models
-   */
-  export interface NoBody extends Omit<Options, "method" | "url" | "body"> {}
-
   /**
    * @since 4.0.0
    * @category models
@@ -133,7 +127,7 @@ export const make = <M extends HttpMethod>(
 ) =>
 (
   url: string | URL,
-  options?: (M extends "GET" | "HEAD" ? Options.NoBody : Options.NoUrl) | undefined
+  options?: Options.NoUrl | undefined
 ): HttpClientRequest =>
   modify(empty, {
     method,
@@ -145,7 +139,7 @@ export const make = <M extends HttpMethod>(
  * @since 4.0.0
  * @category constructors
  */
-export const get: (url: string | URL, options?: Options.NoBody) => HttpClientRequest = make("GET")
+export const get: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("GET")
 
 /**
  * @since 4.0.0
@@ -165,23 +159,33 @@ export const patch: (url: string | URL, options?: Options.NoUrl) => HttpClientRe
  */
 export const put: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("PUT")
 
+const del: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("DELETE")
+
+export {
+  /**
+   * @since 4.0.0
+   * @category constructors
+   */
+  del as delete
+}
+
 /**
  * @since 4.0.0
  * @category constructors
  */
-export const del: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("DELETE")
+export const head: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("HEAD")
 
 /**
  * @since 4.0.0
  * @category constructors
  */
-export const head: (url: string | URL, options?: Options.NoBody) => HttpClientRequest = make("HEAD")
+export const options: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("OPTIONS")
 
 /**
  * @since 4.0.0
  * @category constructors
  */
-export const options: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("OPTIONS")
+export const trace: (url: string | URL, options?: Options.NoUrl) => HttpClientRequest = make("TRACE")
 
 /**
  * @since 4.0.0
@@ -661,7 +665,7 @@ export const setBody: {
   (self: HttpClientRequest, body: HttpBody.HttpBody): HttpClientRequest
 } = dual(2, (self: HttpClientRequest, body: HttpBody.HttpBody): HttpClientRequest => {
   let headers = self.headers
-  if (body._tag === "Empty") {
+  if (body._tag === "Empty" || body._tag === "FormData") {
     headers = Headers.remove(Headers.remove(headers, "Content-Type"), "Content-length")
   } else {
     if (body.contentType) {
@@ -826,7 +830,28 @@ export const bodyFormData: {
    * @category combinators
    */
   (self: HttpClientRequest, body: FormData): HttpClientRequest
-} = dual(2, (self: HttpClientRequest, body: FormData): HttpClientRequest => setBody(self, HttpBody.makeFormData(body)))
+} = dual(2, (self: HttpClientRequest, body: FormData): HttpClientRequest => setBody(self, HttpBody.formData(body)))
+
+/**
+ * @since 4.0.0
+ * @category combinators
+ */
+export const bodyFormDataRecord: {
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (entries: HttpBody.FormDataInput): (self: HttpClientRequest) => HttpClientRequest
+  /**
+   * @since 4.0.0
+   * @category combinators
+   */
+  (self: HttpClientRequest, entries: HttpBody.FormDataInput): HttpClientRequest
+} = dual(
+  2,
+  (self: HttpClientRequest, entries: HttpBody.FormDataInput): HttpClientRequest =>
+    setBody(self, HttpBody.formDataRecord(entries))
+)
 
 /**
  * @since 4.0.0

package/src/unstable/http/HttpEffect.ts

@@ -6,7 +6,6 @@ import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { dual } from "../../Function.ts"
-import { effectIsExit } from "../../internal/effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
@@ -32,30 +31,6 @@ export const toHandled = <E, R, EH, RH>(
   ) => Effect.Effect<unknown, EH, RH>,
   middleware?: HttpMiddleware | undefined
 ): Effect.Effect<void, never, Exclude<R | RH | HttpServerRequest, Scope.Scope>> => {
-  const responded = Effect.flatMap(self, (response) => {
-    const fiber = Fiber.getCurrent()!
-    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
-    const handler = fiber.getRef(PreResponseHandlers)
-    if (handler === undefined) {
-      ;(request as any)[handledSymbol] = true
-      const eff = handleResponse(request, response)
-      if (effectIsExit(eff)) {
-        return eff._tag === "Success" ? Effect.succeed(response) : handleCause(eff.cause)
-      }
-      return Effect.matchCauseEffect(eff, {
-        onFailure: handleCause,
-        onSuccess: () => Effect.succeed(response)
-      })
-    }
-    return Effect.flatMapEager(handler(request, response), (sentResponse) => {
-      ;(request as any)[handledSymbol] = true
-      return Effect.matchCauseEffectEager(handleResponse(request, sentResponse), {
-        onSuccess: () => Effect.succeed(response),
-        onFailure: handleCause
-      })
-    })
-  })
-
   const handleCause = (cause: Cause<E | EH | HttpServerError>) =>
     Effect.flatMapEager(causeResponse(cause), ([response, cause]) => {
       const fiber = Fiber.getCurrent()!
@@ -79,6 +54,23 @@ export const toHandled = <E, R, EH, RH>(
       )
     })
 
+  const responded = Effect.matchCauseEffect(self, {
+    onSuccess: (response) => {
+      const fiber = Fiber.getCurrent()!
+      const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+      const handler = fiber.getRef(PreResponseHandlers)
+      if (handler === undefined) {
+        ;(request as any)[handledSymbol] = true
+        return Effect.mapEager(handleResponse(request, response), () => response)
+      }
+      return Effect.flatMapEager(handler(request, response), (sentResponse) => {
+        ;(request as any)[handledSymbol] = true
+        return Effect.mapEager(handleResponse(request, sentResponse), () => response)
+      })
+    },
+    onFailure: handleCause
+  })
+
   const withMiddleware: Effect.Effect<
     unknown,
     E | EH | HttpServerError,

package/src/unstable/http/HttpMethod.ts

@@ -14,6 +14,7 @@ export type HttpMethod =
   | "PATCH"
   | "HEAD"
   | "OPTIONS"
+  | "TRACE"
 
 /**
  * @since 4.0.0
@@ -24,7 +25,7 @@ export declare namespace HttpMethod {
    * @since 4.0.0
    * @category models
    */
-  export type NoBody = "GET" | "HEAD" | "OPTIONS"
+  export type NoBody = "GET" | "HEAD" | "OPTIONS" | "TRACE"
 
   /**
    * @since 4.0.0
@@ -36,12 +37,22 @@ export declare namespace HttpMethod {
 /**
  * @since 4.0.0
  */
-export const hasBody = (method: HttpMethod): boolean => method !== "GET" && method !== "HEAD" && method !== "OPTIONS"
+export const hasBody = (method: HttpMethod): method is HttpMethod.WithBody =>
+  method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE"
 
 /**
  * @since 4.0.0
  */
-export const all: ReadonlySet<HttpMethod> = new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
+export const all: ReadonlySet<HttpMethod> = new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "HEAD",
+  "OPTIONS",
+  "TRACE"
+])
 
 /**
  * @since 4.0.0
@@ -53,7 +64,8 @@ export const allShort = [
   ["DELETE", "del"],
   ["PATCH", "patch"],
   ["HEAD", "head"],
-  ["OPTIONS", "options"]
+  ["OPTIONS", "options"],
+  ["TRACE", "trace"]
 ] as const
 
 /**

package/src/unstable/http/HttpMiddleware.ts

@@ -46,21 +46,16 @@ export declare namespace HttpMiddleware {
  */
 export const make = <M extends HttpMiddleware>(middleware: M): M => middleware
 
-/**
- * @since 4.0.0
- * @category Logger
- */
-export const LoggerDisabled = ServiceMap.Reference<boolean>("effect/http/HttpMiddleware/LoggerDisabled", {
-  defaultValue: constFalse
-})
+const loggerDisabledRequests = new WeakSet<HttpServerRequest>()
 
 /**
  * @since 4.0.0
  * @category Logger
  */
-export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | HttpServerRequest> =>
   Effect.withFiber((fiber) => {
-    fiber.setServices(ServiceMap.add(fiber.services, LoggerDisabled, true))
+    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+    loggerDisabledRequests.add(request)
     return self
   })
 
@@ -102,7 +97,7 @@ export const logger: <E, R>(
     const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
     return Effect.withLogSpan(
       Effect.flatMap(Effect.exit(httpApp), (exit) => {
-        if (fiber.getRef(LoggerDisabled)) {
+        if (loggerDisabledRequests.has(request)) {
           return exit
         } else if (exit._tag === "Failure") {
           const [response, cause] = causeResponseStripped(exit.cause)

package/src/unstable/http/HttpServerResponse.ts

@@ -327,7 +327,7 @@ export const formData = (
     statusText: options?.statusText,
     headers: options?.headers && Headers.fromInput(options.headers),
     cookies: options?.cookies,
-    body: Body.makeFormData(body)
+    body: Body.formData(body)
   })
 
 /**

package/src/unstable/http/Multipart.ts

@@ -203,13 +203,13 @@ export const PersistedFileSchema: PersistedFileSchema = Schema.declare(
  * @since 4.0.0
  * @category Schemas
  */
-export const FilesSchema: Schema.Array$<PersistedFileSchema> = Schema.Array(PersistedFileSchema)
+export const FilesSchema: Schema.$Array<PersistedFileSchema> = Schema.Array(PersistedFileSchema)
 
 /**
  * @since 4.0.0
  * @category Schemas
  */
-export const SingleFileSchema: Schema.decodeTo<PersistedFileSchema, Schema.Array$<PersistedFileSchema>> = FilesSchema
+export const SingleFileSchema: Schema.decodeTo<PersistedFileSchema, Schema.$Array<PersistedFileSchema>> = FilesSchema
   .check(
     Schema.isLengthBetween(1, 1)
   ).pipe(

package/src/unstable/http/UrlParams.ts

@@ -43,10 +43,14 @@ export const isUrlParams = (u: unknown): u is UrlParams => hasProperty(u, TypeId
  * @category models
  */
 export type Input =
-  | CoercibleRecord
+  | CoercibleRecordInput
   | Iterable<readonly [string, Coercible]>
   | URLSearchParams
 
+type CoercibleRecordInput = CoercibleRecord & {
+  readonly [Symbol.iterator]?: never
+}
+
 /**
  * @since 4.0.0
  * @category models
@@ -57,8 +61,17 @@ export type Coercible = string | number | bigint | boolean | null | undefined
  * @since 4.0.0
  * @category models
  */
-export interface CoercibleRecord {
-  readonly [key: string]: Coercible | ReadonlyArray<Coercible> | CoercibleRecord
+type CoercibleRecordField<A> = A extends Coercible ? A
+  : A extends ReadonlyArray<infer Item> ? ReadonlyArray<Item extends Coercible ? Item : never>
+  : A extends object ? CoercibleRecord<A>
+  : never
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export type CoercibleRecord<A extends object = any> = {
+  readonly [K in keyof A]: CoercibleRecordField<A[K]>
 }
 
 const Proto = {
@@ -110,7 +123,9 @@ export const fromInput = (input: Input): UrlParams => {
 }
 
 const fromInputNested = (input: Input): Array<[string | Array<string>, any]> => {
-  const entries = Symbol.iterator in input ? Arr.fromIterable(input) : Object.entries(input)
+  const entries = typeof (input as any)[Symbol.iterator] === "function"
+    ? Arr.fromIterable(input as Iterable<readonly [string, Coercible]>)
+    : Object.entries(input)
   const out: Array<[string | Array<string>, string]> = []
   for (const [key, value] of entries) {
     if (Array.isArray(value)) {
@@ -539,7 +554,7 @@ export const schemaJsonField = (field: string): schemaJsonField =>
  */
 export interface schemaRecord extends
   Schema.decodeTo<
-    Schema.Record$<Schema.String, Schema.Union<readonly [Schema.String, Schema.NonEmptyArray<Schema.String>]>>,
+    Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.NonEmptyArray<Schema.String>]>>,
     UrlParamsSchema,
     never,
     never

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -2,7 +2,7 @@
  * @since 4.0.0
  */
 import * as Effect from "../../Effect.ts"
-import * as Base64 from "../../encoding/Base64.ts"
+import * as Encoding from "../../Encoding.ts"
 import * as Fiber from "../../Fiber.ts"
 import type { FileSystem } from "../../FileSystem.ts"
 import { identity } from "../../Function.ts"
@@ -328,7 +328,7 @@ export const securityDecode = <Security extends HttpApiSecurity.HttpApiSecurity>
       } as any
       return HttpServerRequest.asEffect().pipe(
         Effect.flatMap((request) =>
-          Base64.decodeString((request.headers.authorization ?? "").slice(basicLen)).asEffect()
+          Encoding.decodeBase64String((request.headers.authorization ?? "").slice(basicLen)).asEffect()
         ),
         Effect.match({
           onFailure: () => empty,
@@ -505,9 +505,9 @@ function handlerToRoute(
   const endpoint = handler.endpoint
   const encodeSuccess = Schema.encodeUnknownEffect(makeSuccessSchema(endpoint))
   const encodeError = Schema.encodeUnknownEffect(makeErrorSchema(endpoint))
-  const decodeParams = UndefinedOr.map(HttpApiEndpoint.getParamsSchema(endpoint), Schema.decodeUnknownEffect)
-  const decodeHeaders = UndefinedOr.map(HttpApiEndpoint.getHeadersSchema(endpoint), Schema.decodeUnknownEffect)
-  const decodeQuery = UndefinedOr.map(HttpApiEndpoint.getQuerySchema(endpoint), Schema.decodeUnknownEffect)
+  const decodeParams = UndefinedOr.map(endpoint.params, Schema.decodeUnknownEffect)
+  const decodeHeaders = UndefinedOr.map(endpoint.headers, Schema.decodeUnknownEffect)
+  const decodeQuery = UndefinedOr.map(endpoint.query, Schema.decodeUnknownEffect)
 
   const shouldParsePayload = endpoint.payload.size > 0 && !handler.isRaw
   const payloadBy = shouldParsePayload ? buildPayloadDecoders(endpoint.payload) : undefined

package/src/unstable/httpapi/HttpApiClient.ts

@@ -217,7 +217,7 @@ const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>
         })
 
         // encoders
-        const encodeParams = UndefinedOr.map(HttpApiEndpoint.getParamsSchema(endpoint), Schema.encodeUnknownEffect)
+        const encodeParams = UndefinedOr.map(endpoint.params, Schema.encodeUnknownEffect)
 
         const payloadSchemas = HttpApiEndpoint.getPayloadSchemas(endpoint)
         const encodePayload = Arr.isArrayNonEmpty(payloadSchemas) ?
@@ -226,8 +226,8 @@ const makeClient = <ApiId extends string, Groups extends HttpApiGroup.Any, E, R>
             : Schema.encodeUnknownEffect(Schema.Union(payloadSchemas)) :
           undefined
 
-        const encodeHeaders = UndefinedOr.map(HttpApiEndpoint.getHeadersSchema(endpoint), Schema.encodeUnknownEffect)
-        const encodeQuery = UndefinedOr.map(HttpApiEndpoint.getQuerySchema(endpoint), Schema.encodeUnknownEffect)
+        const encodeHeaders = UndefinedOr.map(endpoint.headers, Schema.encodeUnknownEffect)
+        const encodeQuery = UndefinedOr.map(endpoint.query, Schema.encodeUnknownEffect)
 
         const middlewareKeys = Array.from(onEndpointOptions.middleware, (tag) => `${tag.key}/Client`)
 

package/src/unstable/httpapi/HttpApiEndpoint.ts

@@ -4,7 +4,6 @@
 import * as Arr from "../../Array.ts"
 import type { Brand } from "../../Brand.ts"
 import type { Effect } from "../../Effect.ts"
-import { format } from "../../Formatter.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
@@ -71,9 +70,9 @@ export interface HttpApiEndpoint<
   readonly name: Name
   readonly path: Path
   readonly method: Method
-  readonly params: Schema.Struct.Fields | undefined
-  readonly query: Schema.Struct.Fields | undefined
-  readonly headers: Schema.Struct.Fields | undefined
+  readonly params: Schema.Top | undefined
+  readonly query: Schema.Top | undefined
+  readonly headers: Schema.Top | undefined
   readonly payload: PayloadMap
   readonly success: ReadonlySet<Schema.Top>
   readonly error: ReadonlySet<Schema.Top>
@@ -156,21 +155,6 @@ export interface HttpApiEndpoint<
   >
 }
 
-/** @internal */
-export function getParamsSchema(endpoint: AnyWithProps): Schema.Top | undefined {
-  return endpoint.params ? Schema.Struct(endpoint.params) : undefined
-}
-
-/** @internal */
-export function getQuerySchema(endpoint: AnyWithProps): Schema.Top | undefined {
-  return endpoint.query ? Schema.Struct(endpoint.query) : undefined
-}
-
-/** @internal */
-export function getHeadersSchema(endpoint: AnyWithProps): Schema.Top | undefined {
-  return endpoint.headers ? Schema.Struct(endpoint.headers) : undefined
-}
-
 /** @internal */
 export function getPayloadSchemas(endpoint: AnyWithProps): Array<Schema.Top> {
   const result: Array<Schema.Top> = []
@@ -830,9 +814,9 @@ function makeProto<
   readonly name: Name
   readonly path: Path
   readonly method: Method
-  readonly params: Schema.Struct.Fields | undefined
-  readonly query: Schema.Struct.Fields | undefined
-  readonly headers: Schema.Struct.Fields | undefined
+  readonly params: Schema.Top | undefined
+  readonly query: Schema.Top | undefined
+  readonly headers: Schema.Top | undefined
   readonly payload: PayloadMap
   readonly success: ReadonlySet<Schema.Top>
   readonly error: ReadonlySet<Schema.Top>
@@ -855,32 +839,28 @@ function makeProto<
 }
 
 /**
- * Params come from the router as `string` (optional params as `undefined`) and
- * must be encodable back into the URL path.
- *
- * We accept "struct fields" (`Record<string, Codec<...>>`) so we can both enforce
- * `Encoded` = `string | undefined` per field and reliably generate OpenAPI
- * `in: path` parameters by iterating object properties.
- *
  * @since 4.0.0
  * @category constraints
  */
-export type ParamsConstraint = Record<string, Schema.Encoder<string | undefined, unknown>>
+export type ParamsConstraint =
+  | Record<string, Schema.Encoder<string | undefined, unknown>>
+  | Schema.Encoder<Record<string, string | undefined>, unknown>
 
 /**
- * URL search params can be repeated, so fields may encode to `string` or
- * `ReadonlyArray<string>` (or be missing).
- *
- * Kept as "struct fields" so OpenAPI can safely expand properties into
- * `in: query` parameters.
- *
  * @since 4.0.0
  * @category constraints
  */
-export type QuerySchemaConstraint = Record<
-  string,
-  Schema.Encoder<string | ReadonlyArray<string> | undefined, unknown>
->
+export type HeadersConstraint =
+  | Record<string, Schema.Encoder<string | undefined, unknown>>
+  | Schema.Encoder<Record<string, string | undefined>, unknown>
+
+/**
+ * @since 4.0.0
+ * @category constraints
+ */
+export type QueryConstraint =
+  | Record<string, Schema.Encoder<string | ReadonlyArray<string> | undefined, unknown>>
+  | Schema.Encoder<Record<string, string | ReadonlyArray<string> | undefined>, unknown>
 
 /**
  * Payload schema depends on the HTTP method:
@@ -893,34 +873,23 @@ export type QuerySchemaConstraint = Record<
  * @since 4.0.0
  * @category constraints
  */
-export type PayloadSchemaConstraint<Method extends HttpMethod> = Method extends HttpMethod.NoBody ? Record<
+export type PayloadConstraint<Method extends HttpMethod> = Method extends HttpMethod.NoBody ? Record<
     string,
     Schema.Encoder<string | ReadonlyArray<string> | undefined, unknown>
   > :
-  SuccessSchemaConstraint
-
-/**
- * HTTP headers are string-valued (or missing).
- *
- * Kept as "struct fields" so OpenAPI can safely expand properties into
- * `in: header` parameters.
- *
- * @since 4.0.0
- * @category constraints
- */
-export type HeadersSchemaConstraint = Record<string, Schema.Encoder<string | undefined, unknown>>
+  SuccessConstraint
 
 /**
  * @since 4.0.0
  * @category constraints
  */
-export type SuccessSchemaConstraint = Schema.Top | ReadonlyArray<Schema.Top>
+export type SuccessConstraint = Schema.Top | ReadonlyArray<Schema.Top>
 
 /**
  * @since 4.0.0
  * @category constraints
  */
-export type ErrorSchemaConstraint = Schema.Top | ReadonlyArray<Schema.Top>
+export type ErrorConstraint = Schema.Top | ReadonlyArray<Schema.Top>
 
 /**
  * @since 4.0.0
@@ -931,11 +900,11 @@ export const make = <Method extends HttpMethod>(method: Method) =>
   const Name extends string,
   const Path extends HttpRouter.PathInput,
   Params extends ParamsConstraint = never,
-  Query extends QuerySchemaConstraint = never,
-  Payload extends PayloadSchemaConstraint<Method> = never,
-  Headers extends HeadersSchemaConstraint = never,
-  const Success extends SuccessSchemaConstraint = HttpApiSchema.NoContent,
-  const Error extends ErrorSchemaConstraint = never
+  Query extends QueryConstraint = never,
+  Payload extends PayloadConstraint<Method> = never,
+  Headers extends HeadersConstraint = never,
+  const Success extends SuccessConstraint = HttpApiSchema.NoContent,
+  const Error extends ErrorConstraint = never
 >(
   name: Name,
   path: Path,
@@ -964,8 +933,8 @@ export const make = <Method extends HttpMethod>(method: Method) =>
     name,
     path,
     method,
-    params: options?.params,
-    query: options?.query,
+    params: getParams(options?.params),
+    query: getQuery(options?.query),
     headers: getHeaders(options?.headers),
     payload: getPayload(options?.payload),
     success: getSuccess(options?.success),
@@ -975,17 +944,23 @@ export const make = <Method extends HttpMethod>(method: Method) =>
   })
 }
 
+function getParams(params: ParamsConstraint | undefined): Schema.Top | undefined {
+  if (params === undefined) return undefined
+  if (Schema.isSchema(params)) return params
+  return Schema.Struct(params)
+}
+
+function getQuery(query: QueryConstraint | undefined): Schema.Top | undefined {
+  if (query === undefined) return undefined
+  if (Schema.isSchema(query)) return query
+  return Schema.Struct(query)
+}
+
 // all keys should be lowercase
-function getHeaders(headers: Schema.Struct.Fields | undefined): Schema.Struct.Fields | undefined {
-  if (headers !== undefined) {
-    for (const key of Object.keys(headers)) {
-      const lowerKey = key.toLowerCase()
-      if (key !== lowerKey) {
-        throw new Error(`Header keys must be lowercase, got ${format(key)} (use ${format(lowerKey)})`)
-      }
-    }
-    return headers
-  }
+function getHeaders(headers: HeadersConstraint | undefined): Schema.Top | undefined {
+  if (headers === undefined) return undefined
+  if (Schema.isSchema(headers)) return headers
+  return Schema.Struct(headers)
 }
 
 function getPayload(

package/src/unstable/httpapi/HttpApiScalar.ts

@@ -98,6 +98,12 @@ export type ScalarConfig = {
    * Default: `false`
    */
   defaultOpenAllTags?: boolean
+  /**
+   * Whether to display the operation ID in the operation reference.
+   *
+   * Default: `false`
+   */
+  showOperationId?: boolean
 }
 
 type ScalarSource =

package/src/unstable/httpapi/OpenApi.ts

@@ -362,20 +362,23 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
         }
       }
 
-      function processParameters(fields: Schema.Struct.Fields | undefined, i: OpenAPISpecParameter["in"]) {
-        if (fields) {
-          for (const [name, field] of Object.entries(fields)) {
-            op.parameters.push({
-              name: String(name),
-              in: i,
-              schema: {},
-              required: i === "path" || !AST.isOptional(field.ast)
-            })
-            pathOps.push({
-              _tag: "parameter",
-              ast: AST.toEncoded(field.ast),
-              path: ["paths", path, method, "parameters", String(op.parameters.length - 1), "schema"]
-            })
+      function processParameters(schema: Schema.Top | undefined, i: OpenAPISpecParameter["in"]) {
+        if (schema) {
+          const ast = AST.toEncoded(schema.ast)
+          if (AST.isObjects(ast)) {
+            for (const ps of ast.propertySignatures) {
+              op.parameters.push({
+                name: String(ps.name),
+                in: i,
+                schema: {},
+                required: i === "path" || !AST.isOptional(ps.type)
+              })
+              pathOps.push({
+                _tag: "parameter",
+                ast: ps.type,
+                path: ["paths", path, method, "parameters", String(op.parameters.length - 1), "schema"]
+              })
+            }
           }
         }
       }
@@ -421,8 +424,7 @@ export function fromApi<Id extends string, Groups extends HttpApiGroup.Any>(
       processParameters(endpoint.params, "path")
       if (!hasBody && endpoint.payload.size === 1) {
         const entry = endpoint.payload.values().next().value!
-        const schema = entry.schemas[0] as Schema.Struct<Schema.Struct.Fields>
-        processParameters(schema.fields, "query")
+        processParameters(entry.schemas[0], "query")
       }
       processParameters(endpoint.headers, "header")
       processParameters(endpoint.query, "query")