effect 4.0.0-beta.4 → 4.0.0-beta.40

package/src/unstable/http/UrlParams.ts

@@ -19,7 +19,6 @@ import * as Schema from "../../Schema.ts"
 import * as Issue from "../../SchemaIssue.ts"
 import * as Transformation from "../../SchemaTransformation.ts"
 import * as Tuple from "../../Tuple.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 
 const TypeId = "~effect/http/UrlParams"
 
@@ -43,10 +42,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 +60,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 +122,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)) {
@@ -219,18 +233,17 @@ export const getFirst: {
    * @since 4.0.0
    * @category combinators
    */
-  (key: string): (self: UrlParams) => string | undefined
+  (key: string): (self: UrlParams) => Option.Option<string>
   /**
    * @since 4.0.0
    * @category combinators
    */
-  (self: UrlParams, key: string): string | undefined
+  (self: UrlParams, key: string): Option.Option<string>
 } = dual(
   2,
-  (self: UrlParams, key: string): string | undefined =>
+  (self: UrlParams, key: string): Option.Option<string> =>
     Arr.findFirst(self.params, ([k]) => k === key).pipe(
-      Option.map(([, value]) => value),
-      Option.getOrUndefined
+      Option.map(([, value]) => value)
     )
 )
 
@@ -243,16 +256,15 @@ export const getLast: {
    * @since 4.0.0
    * @category combinators
    */
-  (key: string): (self: UrlParams) => string | undefined
+  (key: string): (self: UrlParams) => Option.Option<string>
   /**
    * @since 4.0.0
    * @category combinators
    */
-  (self: UrlParams, key: string): string | undefined
-} = dual(2, (self: UrlParams, key: string): string | undefined =>
+  (self: UrlParams, key: string): Option.Option<string>
+} = dual(2, (self: UrlParams, key: string): Option.Option<string> =>
   Arr.findLast(self.params, ([k]) => k === key).pipe(
-    Option.map(([, value]) => value),
-    Option.getOrUndefined
+    Option.map(([, value]) => value)
   ))
 
 /**
@@ -522,9 +534,9 @@ export const schemaJsonField = (field: string): schemaJsonField =>
       Schema.UnknownFromJsonString,
       Transformation.transformOrFail({
         decode: (params) =>
-          UndefinedOr.match(getFirst(params, field), {
-            onUndefined: () => Effect.fail(new Issue.Pointer([field], new Issue.MissingKey(undefined))),
-            onDefined: Effect.succeed
+          Option.match(getFirst(params, field), {
+            onNone: () => Effect.fail(new Issue.Pointer([field], new Issue.MissingKey(undefined))),
+            onSome: Effect.succeed
           }),
         encode: (value) => Effect.succeed(make([[field, value]]))
       })
@@ -539,7 +551,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/http/index.ts

@@ -109,6 +109,11 @@ export * as HttpServerRespondable from "./HttpServerRespondable.ts"
  */
 export * as HttpServerResponse from "./HttpServerResponse.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as HttpStaticServer from "./HttpStaticServer.ts"
+
 /**
  * @since 4.0.0
  */
@@ -133,3 +138,8 @@ export * as Template from "./Template.ts"
  * @since 4.0.0
  */
 export * as UrlParams from "./UrlParams.ts"
+
+/**
+ * @since 4.0.0
+ */
+export * as Url from "./Url.ts"

package/src/unstable/http/internal/preResponseHandler.ts

@@ -0,0 +1,15 @@
+import * as Effect from "../../../Effect.ts"
+import type { PreResponseHandler } from "../HttpEffect.ts"
+import type { HttpServerRequest } from "../HttpServerRequest.ts"
+
+/** @internal */
+export const requestPreResponseHandlers = new WeakMap<object, PreResponseHandler>()
+
+/** @internal */
+export const appendPreResponseHandlerUnsafe = (request: HttpServerRequest, handler: PreResponseHandler): void => {
+  const prev = requestPreResponseHandlers.get(request.source)
+  const next: PreResponseHandler = prev ?
+    (request, response) => Effect.flatMap(prev(request, response), (response) => handler(request, response))
+    : handler
+  requestPreResponseHandlers.set(request.source, next)
+}

package/src/unstable/httpapi/HttpApi.ts

@@ -57,7 +57,7 @@ export interface HttpApi<
   /**
    * Prefix all endpoints in the `HttpApi`.
    */
-  prefix<const Prefix extends PathInput>(prefix: Prefix): HttpApi<Id, Groups>
+  prefix<const Prefix extends PathInput>(prefix: Prefix): HttpApi<Id, HttpApiGroup.AddPrefix<Groups, Prefix>>
 
   /**
    * Add a middleware to a `HttpApi`. It will be applied to all endpoints in the
@@ -67,13 +67,13 @@ export interface HttpApi<
    * api is called.
    */
   middleware<I extends HttpApiMiddleware.AnyId, S>(
-    middleware: ServiceMap.Service<I, S>
+    middleware: ServiceMap.Key<I, S>
   ): HttpApi<Id, HttpApiGroup.AddMiddleware<Groups, I>>
 
   /**
    * Annotate the `HttpApi`.
    */
-  annotate<I, S>(tag: ServiceMap.Service<I, S>, value: S): HttpApi<Id, Groups>
+  annotate<I, S>(tag: ServiceMap.Key<I, S>, value: S): HttpApi<Id, Groups>
 
   /**
    * Annotate the `HttpApi` with a ServiceMap.
@@ -137,14 +137,14 @@ const Proto = {
       annotations: this.annotations
     })
   },
-  middleware(this: AnyWithProps, tag: HttpApiMiddleware.AnyKey) {
+  middleware(this: AnyWithProps, tag: HttpApiMiddleware.AnyService) {
     return makeProto({
       identifier: this.identifier,
       groups: Record.map(this.groups, (group) => group.middleware(tag as any)),
       annotations: this.annotations
     })
   },
-  annotate(this: AnyWithProps, key: ServiceMap.Service<any, any>, value: any) {
+  annotate(this: AnyWithProps, key: ServiceMap.Key<any, any>, value: any) {
     return makeProto({
       identifier: this.identifier,
       groups: this.groups,
@@ -212,7 +212,7 @@ export const reflect = <Id extends string, Groups extends HttpApiGroup.Any>(
       readonly group: HttpApiGroup.AnyWithProps
       readonly endpoint: HttpApiEndpoint.AnyWithProps
       readonly mergedAnnotations: ServiceMap.ServiceMap<never>
-      readonly middleware: ReadonlySet<HttpApiMiddleware.AnyKey>
+      readonly middleware: ReadonlySet<HttpApiMiddleware.AnyService>
       readonly successes: ReadonlyMap<number, readonly [Schema.Top, ...Array<Schema.Top>]>
       readonly errors: ReadonlyMap<number, readonly [Schema.Top, ...Array<Schema.Top>]>
     }) => void

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"
@@ -20,7 +20,7 @@ import * as Transformation from "../../SchemaTransformation.ts"
 import type * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
-import type { Covariant } from "../../Types.ts"
+import type { Covariant, NoInfer } from "../../Types.ts"
 import * as UndefinedOr from "../../UndefinedOr.ts"
 import type { Cookie } from "../http/Cookies.ts"
 import type * as Etag from "../http/Etag.ts"
@@ -36,7 +36,6 @@ import * as Multipart from "../http/Multipart.ts"
 import * as UrlParams from "../http/UrlParams.ts"
 import type * as HttpApi from "./HttpApi.ts"
 import * as HttpApiEndpoint from "./HttpApiEndpoint.ts"
-import { HttpApiSchemaError } from "./HttpApiError.ts"
 import type * as HttpApiGroup from "./HttpApiGroup.ts"
 import * as HttpApiMiddleware from "./HttpApiMiddleware.ts"
 import * as HttpApiSchema from "./HttpApiSchema.ts"
@@ -63,7 +62,6 @@ export const layer = <Id extends string, Groups extends HttpApiGroup.Any>(
   | HttpPlatform
   | Path
   | HttpApiGroup.ToService<Id, Groups>
-  | HttpApiGroup.ErrorServicesEncode<Groups>
 > =>
   HttpRouter.use(Effect.fnUntraced(function*(router) {
     const services = yield* Effect.services<
@@ -74,10 +72,16 @@ export const layer = <Id extends string, Groups extends HttpApiGroup.Any>(
       | Path
     >()
     const routes: Array<HttpRouter.Route<any, any>> = []
+    const availableGroups = Array.from(services.mapUnsafe.keys()).filter((key) =>
+      key.startsWith("effect/httpapi/HttpApiGroup/")
+    )
     for (const group of Object.values(api.groups)) {
       const groupRoutes = services.mapUnsafe.get(group.key) as Array<HttpRouter.Route<any, any>>
       if (groupRoutes === undefined) {
-        return yield* Effect.die(`HttpApiGroup "${group.key}" not found`)
+        const available = availableGroups.length === 0 ? "none" : availableGroups.join(", ")
+        return yield* Effect.die(
+          `HttpApiGroup "${group.identifier}" not found (key: "${group.key}"). Did you forget to provide HttpApiBuilder.group(api, "${group.identifier}", ...)? Available groups: ${available}`
+        )
       }
       routes.push(...groupRoutes)
     }
@@ -168,11 +172,11 @@ export interface Handlers<
     | R
     | HttpApiEndpoint.MiddlewareWithName<Endpoints, Name>
     | HttpApiEndpoint.MiddlewareServicesWithName<Endpoints, Name>
-    | HttpApiEndpoint.ExcludeProvided<
+    | (HttpApiEndpoint.ExcludeProvidedWithName<
       Endpoints,
       Name,
       R1 | HttpApiEndpoint.ServerServicesWithName<Endpoints, Name>
-    >,
+    > extends infer _R ? _R extends never ? never : HttpRouter.Request<"Requires", _R> : never),
     HttpApiEndpoint.ExcludeName<Endpoints, Name>
   >
 
@@ -188,11 +192,11 @@ export interface Handlers<
     | R
     | HttpApiEndpoint.MiddlewareWithName<Endpoints, Name>
     | HttpApiEndpoint.MiddlewareServicesWithName<Endpoints, Name>
-    | HttpApiEndpoint.ExcludeProvided<
+    | (HttpApiEndpoint.ExcludeProvidedWithName<
       Endpoints,
       Name,
       R1 | HttpApiEndpoint.ServerServicesWithName<Endpoints, Name>
-    >,
+    > extends infer _R ? _R extends never ? never : HttpRouter.Request<"Requires", _R> : never),
     HttpApiEndpoint.ExcludeName<Endpoints, Name>
   >
 }
@@ -284,6 +288,54 @@ export declare namespace Handlers {
     never
 }
 
+/**
+ * @since 4.0.0
+ * @category handlers
+ */
+export const endpoint = <
+  ApiId extends string,
+  Groups extends HttpApiGroup.Any,
+  const GroupName extends HttpApiGroup.Name<Groups>,
+  const EndpointName extends HttpApiEndpoint.Name<HttpApiGroup.Endpoints<HttpApiGroup.WithName<Groups, GroupName>>>,
+  R,
+  Group extends HttpApiGroup.Any = HttpApiGroup.WithName<Groups, GroupName>,
+  Endpoint extends HttpApiEndpoint.Any = HttpApiEndpoint.WithName<HttpApiGroup.Endpoints<Group>, EndpointName>
+>(
+  api: HttpApi.HttpApi<ApiId, Groups>,
+  groupName: GroupName,
+  endpointName: EndpointName,
+  handler: NoInfer<
+    HttpApiEndpoint.HandlerWithName<
+      HttpApiGroup.Endpoints<HttpApiGroup.WithName<Groups, GroupName>>,
+      EndpointName,
+      never,
+      R
+    >
+  >
+): Effect.Effect<
+  Effect.Effect<
+    HttpServerResponse,
+    never,
+    | HttpServerRequest
+    | HttpRouter.RouteContext
+    | Request.ParsedSearchParams
+    | Exclude<R, HttpApiEndpoint.MiddlewareProvides<Endpoint>>
+  >,
+  never,
+  | HttpApiEndpoint.ServerServices<Endpoint>
+  | HttpApiEndpoint.Middleware<Endpoint>
+  | HttpApiEndpoint.MiddlewareServices<Endpoint>
+  | Etag.Generator
+  | FileSystem
+  | HttpPlatform
+  | Path
+> =>
+  Effect.servicesWith((services: ServiceMap.ServiceMap<any>) => {
+    const group = api.groups[groupName] as unknown as HttpApiGroup.AnyWithProps
+    const endpoint = group.endpoints[endpointName] as unknown as HttpApiEndpoint.AnyWithProps
+    return Effect.succeed(handlerToHttpEffect(group, endpoint, services, handler as any, false))
+  })
+
 /**
  * @since 4.0.0
  * @category security
@@ -328,7 +380,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,
@@ -356,7 +408,7 @@ export const securitySetCookie = (
   self: HttpApiSecurity.ApiKey,
   value: string | Redacted.Redacted,
   options?: Cookie["options"]
-): Effect.Effect<void> =>
+): Effect.Effect<void, never, HttpServerRequest> =>
   HttpEffect.appendPreResponseHandler((_req, response) =>
     Effect.orDie(
       Response.setCookie(response, self.key, stringOrRedacted(value), {
@@ -497,22 +549,23 @@ function decodePayload(
   }
 }
 
-function handlerToRoute(
+function handlerToHttpEffect(
   group: HttpApiGroup.AnyWithProps,
-  handler: Handlers.Item<any>,
-  services: ServiceMap.ServiceMap<any>
-): HttpRouter.Route<any, any> {
-  const endpoint = handler.endpoint
+  endpoint: HttpApiEndpoint.AnyWithProps,
+  services: ServiceMap.ServiceMap<any>,
+  handler: HttpApiEndpoint.Handler<any, any, any>,
+  isRaw: boolean
+) {
   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 shouldParsePayload = endpoint.payload.size > 0 && !isRaw
   const payloadBy = shouldParsePayload ? buildPayloadDecoders(endpoint.payload) : undefined
 
-  const effect = applyMiddleware(
+  return applyMiddleware(
     group,
     endpoint,
     services,
@@ -545,23 +598,26 @@ function handlerToRoute(
           request.payload = yield* result
         }
       }
-      const response = yield* handler.handler(request)
+      const response = yield* handler(request)
       return Response.isHttpServerResponse(response) ? response : yield* encodeSuccess(response)
     })
   ).pipe(
-    Effect.catch((error) => {
-      if (Schema.isSchemaError(error)) {
-        error = HttpApiSchemaError.fromSchemaError(error)
-      }
-      return Effect.orDie(encodeError(error))
-    }),
+    Effect.withErrorReporting,
+    Effect.catch((error) => Effect.orDie(encodeError(error))),
     Effect.provideServices(services)
   )
+}
 
+function handlerToRoute(
+  group: HttpApiGroup.AnyWithProps,
+  handler: Handlers.Item<any>,
+  services: ServiceMap.ServiceMap<any>
+): HttpRouter.Route<any, any> {
+  const endpoint = handler.endpoint
   return HttpRouter.route(
     endpoint.method,
     endpoint.path as HttpRouter.PathInput,
-    effect,
+    handlerToHttpEffect(group, endpoint, services, handler.handler, handler.isRaw),
     { uninterruptible: handler.uninterruptible }
   )
 }
@@ -580,13 +636,13 @@ const getRequestMediaType = (request: HttpServerRequest): string => {
 const applyMiddleware = <A extends Effect.Effect<any, any, any>>(
   group: HttpApiGroup.AnyWithProps,
   endpoint: HttpApiEndpoint.AnyWithProps,
-  services: ServiceMap.ServiceMap<never>,
+  services: ServiceMap.ServiceMap<any>,
   handler: A
 ) => {
   const options = { group, endpoint }
   for (const key_ of endpoint.middlewares) {
-    const key = key_ as any as HttpApiMiddleware.AnyKey
-    const service = services.mapUnsafe.get(key_.key) as HttpApiMiddleware.HttpApiMiddleware<any, any, any>
+    const key = key_ as any as HttpApiMiddleware.AnyService
+    const service = ServiceMap.getUnsafe(services, key as any) as HttpApiMiddleware.HttpApiMiddleware<any, any, any>
     const apply = HttpApiMiddleware.isSecurity(key)
       ? makeSecurityMiddleware(key, service as any)
       : service
@@ -596,21 +652,22 @@ const applyMiddleware = <A extends Effect.Effect<any, any, any>>(
 }
 
 const securityMiddlewareCache = new WeakMap<
-  any,
+  object,
   (effect: Effect.Effect<any, any, any>, options: any) => Effect.Effect<any, any, any>
 >()
 
 const makeSecurityMiddleware = (
-  key: HttpApiMiddleware.AnyKeySecurity,
+  key: HttpApiMiddleware.AnyServiceSecurity,
   service: HttpApiMiddleware.HttpApiMiddlewareSecurity<any, any, any, any>
 ): (effect: Effect.Effect<any, any, any>, options: any) => Effect.Effect<any, any, any> => {
-  if (securityMiddlewareCache.has(key)) {
-    return securityMiddlewareCache.get(key)!
+  const cached = securityMiddlewareCache.get(service)
+  if (cached !== undefined) {
+    return cached
   }
 
-  const entries = Object.entries(key.security).map(([key, security]) => ({
+  const entries = Object.entries(key.security).map(([securityKey, security]) => ({
     decode: securityDecode(security),
-    middleware: service[key]
+    middleware: service[securityKey]
   }))
   if (entries.length === 0) {
     return identity
@@ -638,7 +695,7 @@ const makeSecurityMiddleware = (
     return yield* lastResult!.asEffect()
   })
 
-  securityMiddlewareCache.set(key, middleware)
+  securityMiddlewareCache.set(service, middleware)
   return middleware
 }
 
@@ -678,7 +735,11 @@ function getResponseTransformation(
   schema: Schema.Top
 ): Transformation.Transformation<unknown, Response.HttpServerResponse> {
   const ast = schema.ast
-  const encode = getResponseEncode(getStatus(ast), HttpApiSchema.getResponseEncoding(ast))
+  const encode = getResponseEncode(
+    getStatus(ast),
+    HttpApiSchema.getResponseEncoding(ast),
+    HttpApiSchema.isNoContent(ast)
+  )
 
   return Transformation.transformOrFail({
     decode: (res) => Effect.fail(new Issue.Forbidden(Option.some(res), { message: "Encode only schema" })),
@@ -688,11 +749,15 @@ function getResponseTransformation(
 
 function getResponseEncode<E>(
   status: number,
-  encoding: HttpApiSchema.ResponseEncoding
+  encoding: HttpApiSchema.ResponseEncoding,
+  isNoContent: boolean
 ): (e: E) => Effect.Effect<Response.HttpServerResponse, Issue.InvalidValue, never> {
   switch (encoding._tag) {
     case "Json": {
       return ((e) => {
+        if (e === undefined || isNoContent) {
+          return Effect.succeed(Response.empty({ status }))
+        }
         try {
           const s = JSON.stringify(e)
           return Effect.succeed(Response.text(s, { status, contentType: encoding.contentType }))