@effect-app/infra 3.10.0 → 4.0.0-beta.1

package/src/api/middlewares.ts

@@ -3,105 +3,8 @@
  *
  * @since 1.0.0
  */
-import type * as App from "@effect/platform/HttpApp"
-import type { Effect } from "effect-app"
-import type { NotLoggedInError } from "../errors.js"
-import * as internal from "./internal/middlewares.js"
 
 export * from "./internal/auth.js"
 export * from "./internal/events.js"
 export * from "./internal/health.js"
 export * from "./internal/RequestContextMiddleware.js"
-
-/**
- * Add access logs for handled requests. The log runs before each request.
- * Optionally configure log level using the first argument. The default log level
- * is `Debug`.
- *
- * @category logging
- * @since 1.0.0
- */
-export const accessLog: (
-  level?: "Info" | "Warning" | "Debug"
-) => <R, E>(app: App.Default<R, E>) => App.Default<R, E> = internal.accessLog
-
-/**
- * Annotate request logs using generated UUID. The default annotation key is `requestId`.
- * The annotation key is configurable using the first argument.
- *
- * Note that in order to apply the annotation also for access logging, you should
- * make sure the `accessLog` middleware is plugged after the `uuidLogAnnotation`.
- *
- * @category logging
- * @since 1.0.0
- */
-export const uuidLogAnnotation: (
-  logAnnotationKey?: string
-) => <R, E>(app: App.Default<R, E>) => App.Default<R, E> = internal.uuidLogAnnotation
-
-/**
- * Measure how many times each endpoint was called in a
- * `server.endpoint_calls` counter metrics.
- *
- * @category metrics
- * @since 1.0.0
- */
-export const endpointCallsMetric: () => <R, E>(
-  app: App.Default<R, E>
-) => App.Default<R, E> = internal.endpointCallsMetric
-
-/**
- * Logs out a handler failure.
- *
- * @category logging
- * @since 1.0.0
- */
-export const errorLog: <R, E>(app: App.Default<R, E>) => App.Default<R, E> = internal.errorLog
-
-/**
- * @category models
- * @since 1.0.0
- */
-export interface BasicAuthCredentials {
-  user: string
-  password: string
-}
-
-/**
- * Basic auth middleware.
- *
- * @category authorization
- * @since 1.0.0
- */
-export const basicAuth: <R2, _>(
-  checkCredentials: (
-    credentials: BasicAuthCredentials
-  ) => Effect.Effect<_, NotLoggedInError, R2>,
-  options?: Partial<{
-    headerName: string
-    skipPaths: readonly string[]
-  }>
-) => <R1, E>(app: App.Default<E, R1>) => App.Default<E, R1 | R2> = internal.basicAuth
-
-/**
- * @category models
- * @since 1.0.0
- */
-export interface CorsOptions {
-  allowedOrigins: readonly string[]
-  allowedMethods: readonly string[]
-  allowedHeaders: readonly string[]
-  exposedHeaders: readonly string[]
-  maxAge: number
-  credentials: boolean
-}
-
-/**
- * Basic auth middleware.
- *
- * @category authorization
- * @since 1.0.0
- */
-export const cors: (
-  options?: Partial<CorsOptions>
-) => <R, E>(app: App.Default<R, E>) => App.Default<R, E> = internal.cors

package/src/api/reportError.ts

@@ -8,7 +8,7 @@ import { logError, reportError } from "../errorReporter.js"
 //     Effect.onExit(self, (exit) =>
 //       Exit.isFailure(exit)
 //         ? unknownOnly
-//           ? Cause.isInterruptedOnly(exit.cause) || Cause.isDie(exit.cause)
+//           ? Cause.hasInterruptsOnly(exit.cause) || Cause.isDie(exit.cause)
 //             ? report(exit.cause)
 //             : log(exit.cause)
 //           : report(exit.cause)
@@ -18,9 +18,9 @@ const tapErrorCause = (name: string, unknownOnly?: boolean) => {
   const report = reportError(name)
   const log = logError(name)
   return <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    Effect.tapErrorCause(self, (cause) =>
+    Effect.tapCause(self, (cause) =>
       unknownOnly
-        ? Cause.isFailure(cause)
+        ? Cause.hasFails(cause)
           ? log(cause)
           : report(cause)
         : report(cause))

package/src/api/routing/middleware/RouterMiddleware.ts

@@ -1,12 +1,13 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { type RpcMiddlewareWrap } from "@effect/rpc/RpcMiddleware"
-import { type Context, type Effect, type Layer } from "effect-app"
+import { type Layer, type ServiceMap } from "effect-app"
 import { type GetContextConfig, type RpcContextMap } from "effect-app/rpc/RpcContextMap"
+import { type RpcMiddlewareV4 } from "effect-app/rpc/RpcMiddleware"
 // module:
 //
 
+// v4: middleware tags are ServiceMap.Service (not Effect) — they carry the RpcMiddlewareV4 as their service Shape
 export type RouterMiddleware<
   Self,
   RequestContextMap extends Record<string, RpcContextMap.Any>, // what services will the middlware provide dynamically to the next, or raise errors.
@@ -17,11 +18,9 @@ export type RouterMiddleware<
   _ContextProviderR, // what the context provider requires
   RequestContextId
 > =
-  & Effect.Effect<RpcMiddlewareWrap<ContextProviderA, ContextProviderE>, never, Self>
-  // makes error because of TagUnify :/
-  // Context.Tag<Self, RpcMiddlewareWrap<ContextProviderA, ContextProviderE>>
+  & ServiceMap.Service<Self, RpcMiddlewareV4<ContextProviderA, ContextProviderE, never>>
   & {
     readonly Default: Layer.Layer<Self, MakeMiddlewareE, MakeMiddlewareR>
-    readonly requestContext: Context.Tag<RequestContextId, GetContextConfig<RequestContextMap>>
+    readonly requestContext: ServiceMap.Service<RequestContextId, GetContextConfig<RequestContextMap>>
     readonly requestContextMap: RequestContextMap
   }

package/src/api/routing/middleware/middleware.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Cause, Config, Duration, Effect, Layer, ParseResult, Request, Schedule, type Schema } from "effect"
+import { Cause, Config, Effect, Layer, Schema } from "effect"
 import { ConfigureInterruptibilityMiddleware, DevMode, DevModeMiddleware, LoggerMiddleware, RequestCacheMiddleware } from "effect-app/middleware"
 import { pretty } from "effect-app/utils"
 import { logError, reportError } from "../../../errorReporter.js"
@@ -18,29 +18,19 @@ export const DevModeLive = Layer.effect(
   })
 )
 
-export const RequestCacheLayers = Layer.mergeAll(
-  Layer.setRequestCache(
-    Request.makeCache({ capacity: 500, timeToLive: Duration.hours(8) })
-  ),
-  Layer.setRequestCaching(true),
-  Layer.setRequestBatching(true)
-)
-
 export const RequestCacheMiddlewareLive = Layer.succeed(
   RequestCacheMiddleware,
-  (effect) => effect.pipe(Effect.provide(RequestCacheLayers))
+  (effect) => effect
 )
 
-// retry just once on optimistic concurrency exceptions
-const optimisticConcurrencySchedule = Schedule.once.pipe(
-  Schedule.intersect(Schedule.recurWhile<any>((a) => a?._tag === "OptimisticConcurrencyException"))
-)
+const isOptimisticConcurrencyException = (input: unknown) =>
+  typeof input === "object" && input !== null && "_tag" in input && input._tag === "OptimisticConcurrencyException"
 
 export const ConfigureInterruptibilityMiddlewareLive = Layer.effect(
   ConfigureInterruptibilityMiddleware,
   Effect.gen(function*() {
     const cache = new Map()
-    const getCached = (key: string, schema: Schema.Schema.Any) => {
+    const getCached = (key: string, schema: Schema.Top) => {
       const existing = cache.get(key)
       if (existing) return existing
       const n = determineMethod(key, schema)
@@ -51,7 +41,7 @@ export const ConfigureInterruptibilityMiddlewareLive = Layer.effect(
       const method = getCached(rpc._tag, rpc.payloadSchema)
 
       effect = isCommand(method)
-        ? Effect.retry(Effect.uninterruptible(effect), optimisticConcurrencySchedule)
+        ? Effect.retry(Effect.uninterruptible(effect), { times: 1, while: isOptimisticConcurrencyException })
         : Effect.interruptible(effect)
 
       return effect
@@ -88,12 +78,11 @@ export const LoggerMiddlewareLive = Layer
               : payload
           })
           .pipe(
-            // can't use andThen due to some being a function and effect
-            Effect.zipRight(effect),
-            // TODO: support ParseResult if the error channel of the request allows it.. but who would want that?
-            Effect.catchAll((_) => ParseResult.isParseError(_) ? Effect.die(_) : Effect.fail(_)),
-            Effect.tapErrorCause((cause) => Cause.isFailure(cause) ? logRequestError(cause) : Effect.void),
-            Effect.tapDefect((cause) =>
+            Effect.andThen(effect),
+            // TODO: support SchemaError if the error channel of the request allows it.. but who would want that?
+            Effect.catch((_) => Schema.isSchemaError(_) ? Effect.die(_) : Effect.fail(_)),
+            Effect.tapCause((cause) => Cause.hasFails(cause) ? logRequestError(cause) : Effect.void),
+            Effect.tapCauseIf(Cause.hasDies, (cause) =>
               Effect
                 .all([
                   reportRequestError(cause, {
@@ -114,9 +103,8 @@ export const LoggerMiddlewareLive = Layer
                       //     }, {} as Record<string, any>)
                       // )
                     }))
-                ])
-            ),
-            devMode ? (_) => _ : Effect.catchAllDefect(() => Effect.die("Internal Server Error"))
+                ])),
+            devMode ? (_) => _ : Effect.catchDefect(() => Effect.die("Internal Server Error"))
           )
     })
   )

package/src/api/routing/schema/jwt.ts

@@ -1,20 +1,22 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import { Effect, Option } from "effect"
 import * as S from "effect-app/Schema"
 import { jwtDecode, type JwtDecodeOptions } from "jwt-decode"
 
-export const parseJwt = <R, I, A>(
-  schema: S.Schema<A, I, R>,
+export const parseJwt = <Sch extends S.Top>(
+  schema: Sch,
   options?: JwtDecodeOptions
-): S.Schema<A, string, R> =>
+) =>
   S
     .transformToOrFail(
       S.String,
       S.Unknown,
-      (s, __, ast) =>
-        S.ParseResult.try({
+      (s, _options) =>
+        Effect.try({
           try: () => jwtDecode(s, options),
-          catch: (e: any) => new S.ParseResult.Type(ast, s, e?.message)
+          catch: (e: any) =>
+            new S.SchemaIssue.InvalidValue(Option.some(s), { message: e?.message })
         })
     )
-    .pipe(S.compose(schema, { strict: false }))
+    .pipe(S.decodeTo(schema) as any) as any as S.decodeTo<Sch, S.String>

package/src/api/routing/utils.ts

@@ -1,34 +1,36 @@
-import { S } from "effect-app"
-import type { AST, Schema } from "effect-app/Schema"
+import { S, SchemaAST } from "effect-app"
+import type { AST } from "effect-app/Schema"
 
 const get = ["Get", "Index", "List", "All", "Find", "Search"]
 const del = ["Delete", "Remove", "Destroy"]
 const patch = ["Patch", "Update", "Edit"]
 
 const astAssignableToString = (ast: AST.AST): boolean => {
-  if (ast._tag === "StringKeyword") return true
-  if (ast._tag === "Union" && ast.types.every(astAssignableToString)) {
+  // In v4, refined strings (e.g. NonEmptyString) are String nodes with checks — no Refinement wrapper.
+  // Transformations are stored as encoding on nodes — no Transformation wrapper.
+  // So we check the encoded form to see if the wire format is a string.
+  const encoded = SchemaAST.toEncoded(ast)
+  if (encoded._tag === "String") return true
+  if (encoded._tag === "Union" && encoded.types.every(astAssignableToString)) {
     return true
   }
-  if (ast._tag === "Refinement" || ast._tag === "Transformation") {
-    return astAssignableToString(ast.from)
-  }
 
   return false
 }
 
 const onlyStringsAst = (ast: AST.AST): boolean => {
   if (ast._tag === "Union") return ast.types.every(onlyStringsAst)
-  if (ast._tag !== "TypeLiteral") return false
+  // v4: TypeLiteral is now Objects
+  if (ast._tag !== "Objects") return false
   return ast.propertySignatures.every((_) => astAssignableToString(_.type))
 }
 
-const onlyStrings = (schema: Schema.Any & { fields?: S.Struct.Fields }): boolean => {
+const onlyStrings = (schema: S.Top & { fields?: S.Struct.Fields }): boolean => {
   if ("fields" in schema && schema.fields) return onlyStringsAst(S.Struct(schema.fields).ast) // only one level..
   return onlyStringsAst(schema.ast)
 }
 
-export const determineMethod = (fullName: string, schema: Schema.Any) => {
+export const determineMethod = (fullName: string, schema: S.Top) => {
   const bits = fullName.split(".")
   const actionName = bits[bits.length - 1]!