@effect-app/infra 4.0.0-beta.31 → 4.0.0-beta.310

package/src/Store/service.ts

@@ -1,184 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type { UniqueKey } from "@azure/cosmos"
-import { Effect, type NonEmptyReadonlyArray, type Option, type Redacted, ServiceMap } from "effect-app"
-import type { OptimisticConcurrencyException } from "../errors.js"
-import type { FilterResult } from "../Model/filter/filterApi.js"
-import type { FieldValues } from "../Model/filter/types.js"
-import type { FieldPath } from "../Model/filter/types/path/index.js"
-import { type RawQuery } from "../Model/query.js"
-
-export interface StoreConfig<E> {
-  partitionValue: (e?: E) => string
-  /**
-   * Primarily used for testing, creating namespaces in the database to separate data e.g to run multiple tests in isolation within the same database
-   * currently only supported in disk/memory. CosmosDB is TODO.
-   */
-  allowNamespace?: (namespace: string) => boolean
-  /**
-   * just in time migrations, supported by the database driver, supporting queries, for simple default values
-   */
-  defaultValues?: Partial<E>
-
-  /**
-   * How many items can be processed in one batch at a time.
-   * Defaults to 100 for CosmosDB.
-   */
-  maxBulkSize?: number
-
-  /**
-   * Unique indexes, mainly for CosmosDB
-   */
-  uniqueKeys?: UniqueKey[]
-}
-
-export type SupportedValues = string | boolean | number | null
-export type SupportedValues2 = string | boolean | number
-
-// default is eq
-export type Where =
-  | { key: string; t?: "eq" | "not-eq"; value: SupportedValues }
-  | { key: string; t: "gt" | "lt" | "gte" | "lte"; value: SupportedValues2 }
-  | {
-    key: string
-    t: "contains" | "starts-with" | "ends-with" | "not-contains" | "not-starts-with" | "not-ends-with"
-    value: string
-  }
-  | { key: string; t: "includes" | "not-includes"; value: string }
-  | {
-    key: string
-    t: "in" | "not-in"
-    value: readonly (SupportedValues)[]
-  }
-
-export type Filter = readonly FilterResult[]
-
-export interface O<TFieldValues extends FieldValues> {
-  key: FieldPath<TFieldValues>
-  direction: "ASC" | "DESC"
-}
-
-export interface FilterArgs<Encoded extends FieldValues, U extends keyof Encoded = never> {
-  t: Encoded
-  filter?: Filter | undefined
-  select?: NonEmptyReadonlyArray<U | { key: string; subKeys: readonly string[] }> | undefined
-  order?: NonEmptyReadonlyArray<O<NoInfer<Encoded>>>
-  limit?: number | undefined
-  skip?: number | undefined
-}
-
-export type FilterFunc<Encoded extends FieldValues> = <U extends keyof Encoded = never>(
-  args: FilterArgs<Encoded, U>
-) => Effect.Effect<(U extends undefined ? Encoded : Pick<Encoded, U>)[]>
-
-export interface Store<
-  IdKey extends keyof Encoded,
-  Encoded extends FieldValues,
-  PM extends PersistenceModelType<Encoded> = PersistenceModelType<Encoded>
-> {
-  all: Effect.Effect<PM[]>
-  filter: FilterFunc<Encoded>
-  find: (id: Encoded[IdKey]) => Effect.Effect<Option.Option<PM>>
-  set: (e: PM) => Effect.Effect<PM, OptimisticConcurrencyException>
-  batchSet: (
-    items: NonEmptyReadonlyArray<PM>
-  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException>
-  bulkSet: (
-    items: NonEmptyReadonlyArray<PM>
-  ) => Effect.Effect<NonEmptyReadonlyArray<PM>, OptimisticConcurrencyException>
-  batchRemove: (ids: NonEmptyReadonlyArray<Encoded[IdKey]>, partitionKey?: string) => Effect.Effect<void>
-  queryRaw: <Out>(query: RawQuery<Encoded, Out>) => Effect.Effect<readonly Out[]>
-}
-
-export class StoreMaker extends ServiceMap.Opaque<StoreMaker, {
-  make: <IdKey extends keyof Encoded, Encoded extends FieldValues, R = never, E = never>(
-    name: string,
-    idKey: IdKey,
-    seed?: Effect.Effect<Iterable<Encoded>, E, R>,
-    config?: StoreConfig<Encoded>
-  ) => Effect.Effect<Store<IdKey, Encoded>, E, R>
-}>()("effect-app/StoreMaker") {
-}
-
-export const makeContextMap = () => {
-  const etags = new Map<string, string>()
-  const getEtag = (id: string) => etags.get(id)
-  const setEtag = (id: string, eTag: string | undefined) => {
-    if (eTag === undefined) {
-      etags.delete(id)
-    } else {
-      etags.set(id, eTag)
-    }
-  }
-
-  // const parsedCache = new Map<
-  //   Parser<any, any, any>,
-  //   Map<unknown, These.These<unknown, unknown>>
-  // >()
-
-  // const parserCache = new Map<
-  //   Parser<any, any, any>,
-  //   (i: any) => These.These<any, any>
-  // >()
-
-  // const setAndReturn = <I, E, A>(
-  //   p: Parser<I, E, A>,
-  //   np: (i: I) => These.These<E, A>
-  // ) => {
-  //   parserCache.set(p, np)
-  //   return np
-  // }
-
-  // const parserEnv: ParserEnv = {
-  //   // TODO: lax: true would turn off refinement checks, may help on large payloads
-  //   // but of course removes confirming of validation rules (which may be okay for a database owned by the app, as we write safely)
-  //   lax: false,
-  //   cache: {
-  //     getOrSetParser: (p) => parserCache.get(p) ?? setAndReturn(p, (i) => parserEnv.cache!.getOrSet(i, p)),
-  //     getOrSetParsers: (parsers) => {
-  //       return Object.entries(parsers).reduce((prev, [k, v]) => {
-  //         prev[k] = parserEnv.cache!.getOrSetParser(v)
-  //         return prev
-  //       }, {} as any)
-  //     },
-  //     getOrSet: (i, parse): any => {
-  //       const c = parsedCache.get(parse)
-  //       if (c) {
-  //         const f = c.get(i)
-  //         if (f) {
-  //           // console.log("$$$ cache hit", i)
-  //           return f
-  //         } else {
-  //           const nf = parse(i, parserEnv)
-  //           c.set(i, nf)
-  //           return nf
-  //         }
-  //       } else {
-  //         const nf = parse(i, parserEnv)
-  //         parsedCache.set(parse, new Map([[i, nf]]))
-  //         return nf
-  //       }
-  //     }
-  //   }
-  // }
-
-  return {
-    get: getEtag,
-    set: setEtag
-    // parserEnv
-  }
-}
-
-const makeMap = Effect.sync(() => makeContextMap())
-
-export class ContextMap extends ServiceMap.Opaque<ContextMap>()("effect-app/ContextMap", { make: makeMap }) {
-}
-
-export type PersistenceModelType<Encoded extends object> = Encoded & {
-  _etag?: string | undefined
-}
-
-export interface StorageConfig {
-  url: Redacted.Redacted<string>
-  prefix: string
-  dbName: string
-}

package/src/Store.ts

@@ -1 +0,0 @@
-export * from "./Store/service.js"

package/src/adapters/SQL.ts

@@ -1 +0,0 @@
-export * as SQLModel from "./SQL/Model.js"

package/src/adapters/ServiceBus.ts

@@ -1,209 +0,0 @@
-/* eslint-disable @typescript-eslint/prefer-promise-reject-errors */
-import { type OperationOptionsBase, type ProcessErrorArgs, ServiceBusClient, type ServiceBusMessage, type ServiceBusMessageBatch, type ServiceBusReceivedMessage, type ServiceBusReceiver } from "@azure/service-bus"
-import { Cause, Effect, Exit, FiberSet, Layer, type Scope, ServiceMap } from "effect-app"
-import { InfraLogger } from "../logger.js"
-
-const withSpanAndLog = (name: string) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
-  Effect.logInfo(name).pipe(
-    Effect.andThen(self),
-    Effect.tap(Effect.logInfo(name + " done")),
-    Effect.withLogSpan(name),
-    Effect.withSpan(name)
-  )
-
-function makeClient(url: string) {
-  return Effect.acquireRelease(
-    Effect.sync(() => new ServiceBusClient(url)).pipe(withSpanAndLog("ServiceBus.client.create")),
-    (client) => Effect.promise(() => client.close()).pipe(withSpanAndLog("ServiceBus.client.close"))
-  )
-}
-
-export class ServiceBusClientTag
-  extends ServiceMap.Opaque<ServiceBusClientTag, ServiceBusClient>()("@services/Client", { make: makeClient })
-{
-  static readonly layer = (url: string) => this.toLayer(this.make(url))
-}
-
-function makeSender_(queueName: string) {
-  return Effect.gen(function*() {
-    const serviceBusClient = yield* ServiceBusClientTag
-
-    return yield* Effect.acquireRelease(
-      Effect.sync(() => serviceBusClient.createSender(queueName)).pipe(
-        withSpanAndLog(`ServiceBus.sender.create ${queueName}`)
-      ),
-      (sender) => Effect.promise(() => sender.close()).pipe(withSpanAndLog(`ServiceBus.sender.close ${queueName}`))
-    )
-  })
-}
-
-const makeSender = (name: string) =>
-  Effect.gen(function*() {
-    const sender = yield* makeSender_(name)
-    const sendMessages = Effect.fnUntraced(function*(
-      messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
-      options?: Omit<OperationOptionsBase, "abortSignal">
-    ) {
-      return yield* Effect.promise((abortSignal) => sender.sendMessages(messages, { ...options, abortSignal }))
-    })
-
-    return { name, sendMessages }
-  })
-
-export class Sender extends ServiceMap.Opaque<Sender, {
-  name: string
-  sendMessages: (
-    messages: ServiceBusMessage | ServiceBusMessage[] | ServiceBusMessageBatch,
-    options?: Omit<OperationOptionsBase, "abortSignal">
-  ) => Effect.Effect<void, never, never>
-}>()("Sender", { make: makeSender }) {
-  static readonly layer = (name: string) => this.toLayer(this.make(name))
-}
-
-export const SenderTag = <Id>() => <Key extends string>(queueName: Key) => {
-  const tag = ServiceMap.Service<Id, Sender>(`ServiceBus.Sender.${queueName}`)
-
-  return Object.assign(tag, {
-    layer: Layer.effect(
-      tag,
-      Sender.make(queueName).pipe(Effect.map(Sender.of))
-    )
-  })
-}
-
-const makeReceiver = (name: string) =>
-  Effect.gen(function*() {
-    const serviceBusClient = yield* ServiceBusClientTag
-
-    const makeReceiver = Effect.fnUntraced(
-      function*(queueName: string, waitTillEmpty: Effect.Effect<void>, sessionId?: string) {
-        return yield* Effect.acquireRelease(
-          (sessionId
-            ? Effect.promise(() => serviceBusClient.acceptSession(queueName, sessionId))
-            : Effect.sync(() => serviceBusClient.createReceiver(queueName)))
-            .pipe(withSpanAndLog(`ServiceBus.receiver.create ${queueName}.${sessionId}`)),
-          (r) =>
-            waitTillEmpty.pipe(
-              withSpanAndLog(`ServiceBus.receiver.waitTillEmpty ${queueName}.${sessionId}`),
-              Effect.andThen(
-                Effect.promise(() => r.close()).pipe(
-                  withSpanAndLog(`ServiceBus.receiver.close ${queueName}.${sessionId}`)
-                )
-              ),
-              withSpanAndLog(`ServiceBus.receiver.release ${queueName}.${sessionId}`)
-            )
-        )
-      }
-    )
-
-    const make = (waitTillEmpty: Effect.Effect<void>) => makeReceiver(name, waitTillEmpty)
-
-    const makeSession = (sessionId: string, waitTillEmpty: Effect.Effect<void>) =>
-      makeReceiver(name, waitTillEmpty, sessionId)
-
-    return {
-      name,
-      make,
-      makeSession,
-      subscribe: Effect.fnUntraced(function*<RMsg, RErr>(hndlr: MessageHandlers<RMsg, RErr>, sessionId?: string) {
-        const fs = yield* FiberSet.make()
-        const fr = yield* FiberSet.runtime(fs)<RMsg | RErr>()
-        const wait = Effect
-          .gen(function*() {
-            if ((yield* FiberSet.size(fs)) > 0) {
-              yield* InfraLogger.logDebug("Waiting ServiceBusFiberSet to be empty: " + (yield* FiberSet.size(fs)))
-            }
-            while ((yield* FiberSet.size(fs)) > 0) yield* Effect.sleep("250 millis")
-          })
-        const r = yield* sessionId
-          ? makeSession(
-            sessionId,
-            wait
-          )
-          : make(wait)
-
-        const runEffect = <E>(effect: Effect.Effect<void, E, RMsg | RErr>) =>
-          new Promise<void>((resolve, reject) =>
-            fr(effect)
-              .addObserver((exit) => {
-                if (Exit.isSuccess(exit)) {
-                  resolve(exit.value)
-                } else {
-                  // disable @typescript-eslint/prefer-promise-reject-errors
-                  reject(Cause.pretty(exit.cause))
-                }
-              })
-          )
-
-        yield* Effect.acquireRelease(
-          Effect
-            .sync(() => {
-              const s = r
-                .subscribe({
-                  processError: (err) =>
-                    runEffect(
-                      hndlr
-                        .processError(err)
-                        .pipe(
-                          Effect.catchCause((cause) => Effect.logError(`ServiceBus Error ${sessionId}`, cause))
-                        )
-                    ),
-                  processMessage: (msg) => runEffect(hndlr.processMessage(msg))
-                  // DO NOT CATCH ERRORS here as they should return to the queue!
-                })
-              return { close: Effect.promise(() => s.close()) }
-            })
-            .pipe(withSpanAndLog(`ServiceBus.subscription.create ${sessionId}`)),
-          (subscription) =>
-            subscription.close.pipe(
-              withSpanAndLog(`ServiceBus.subscription.close ${sessionId}`)
-            )
-        ) as Effect.Effect<void, never, Scope.Scope> // wth is going on here
-      })
-    }
-  })
-
-export class Receiver extends ServiceMap.Opaque<Receiver, {
-  name: string
-  make: (waitTillEmpty: Effect.Effect<void>) => Effect.Effect<ServiceBusReceiver, never, Scope.Scope>
-  makeSession: (
-    sessionId: string,
-    waitTillEmpty: Effect.Effect<void>
-  ) => Effect.Effect<ServiceBusReceiver, never, Scope.Scope>
-  subscribe<RMsg, RErr>(
-    hndlr: MessageHandlers<RMsg, RErr>,
-    sessionId?: string
-  ): Effect.Effect<void, never, Scope.Scope | RMsg | RErr>
-}>()("Receiver") {
-  static readonly make = makeReceiver
-  static readonly layer = (name: string) => this.toLayer(makeReceiver(name))
-}
-
-export const ReceiverTag = <Id>() => <Key extends string>(queueName: Key) => {
-  const tag = ServiceMap.Service<Id, Receiver>(`ServiceBus.Receiver.${queueName}`)
-
-  return Object.assign(tag, {
-    layer: Layer.effect(
-      tag,
-      makeReceiver(queueName).pipe(Effect.map(Receiver.of))
-    )
-  })
-}
-
-export const SenderReceiver = (queue: string, queueDrain?: string) =>
-  Layer.mergeAll(Sender.layer(queue), Receiver.layer(queueDrain ?? queue))
-
-export interface MessageHandlers<RMsg, RErr> {
-  /**
-   * Handler that processes messages from service bus.
-   *
-   * @param message - A message received from Service Bus.
-   */
-  processMessage(message: ServiceBusReceivedMessage): Effect.Effect<void, never, RMsg>
-  /**
-   * Handler that processes errors that occur during receiving.
-   * @param args - The error and additional context to indicate where
-   * the error originated.
-   */
-  processError(args: ProcessErrorArgs): Effect.Effect<void, never, RErr>
-}

package/src/adapters/logger.ts

@@ -1,3 +0,0 @@
-import { makeLog } from "effect-app/utils/logger"
-
-export const InfraLogger = makeLog("@effect-app/infra", "info")

package/src/adapters/memQueue.ts

@@ -1,21 +0,0 @@
-import { Effect, type Queue, ServiceMap } from "effect-app"
-import * as Q from "effect/Queue"
-
-const make = Effect
-  .gen(function*() {
-    const store = yield* Effect.sync(() => new Map<string, Queue.Queue<string>>())
-
-    return {
-      getOrCreateQueue: Effect.fnUntraced(function*(k: string) {
-        const q = store.get(k)
-        if (q) return q
-        const newQ = yield* Q.unbounded<string>()
-        store.set(k, newQ)
-        return newQ
-      })
-    }
-  })
-
-export class MemQueue extends ServiceMap.Opaque<MemQueue>()("effect-app/MemQueue", { make }) {
-  static readonly Live = this.toLayer(this.make)
-}

package/src/api/internal/auth.ts

@@ -1,68 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable unused-imports/no-unused-vars */
-import { Data, Effect } from "effect-app"
-import { HttpHeaders, HttpMiddleware, HttpServerRequest, HttpServerResponse } from "effect-app/http"
-import { auth, InsufficientScopeError, InvalidRequestError, InvalidTokenError, UnauthorizedError } from "express-oauth2-jwt-bearer"
-
-// // Authorization middleware. When used, the Access Token must
-// // exist and be verified against the Auth0 JSON Web Key Set.
-
-// type Errors = InsufficientScopeError | InvalidRequestError | InvalidTokenError | UnauthorizedError
-type Config = Parameters<typeof auth>[0]
-export const checkJWTI = (config: Config) => {
-  const mw = auth(config)
-  return Effect.fnUntraced(function*(headers: HttpHeaders.Headers) {
-    return yield* Effect.callback<
-      void,
-      InsufficientScopeError | InvalidRequestError | InvalidTokenError | UnauthorizedError
-    >(
-      (resume) => {
-        const next = (err?: unknown) => {
-          if (!err) return resume(Effect.void)
-          if (
-            err instanceof InsufficientScopeError
-            || err instanceof InvalidRequestError
-            || err instanceof InvalidTokenError
-            || err instanceof UnauthorizedError
-          ) {
-            return resume(Effect.fail(err))
-          }
-          return resume(Effect.die(err))
-        }
-        const r = { headers, query: {}, body: {}, is: () => false, method: "POST" } // is("urlencoded")
-        try {
-          mw(r as any, {} as any, next)
-        } catch (e) {
-          return resume(Effect.die(e))
-        }
-      }
-    )
-  })
-}
-
-export const checkJwt = (config: Config) => {
-  const check = checkJWTI(config)
-  return HttpMiddleware.make((app) =>
-    Effect.gen(function*() {
-      const req = yield* HttpServerRequest.HttpServerRequest
-      const response = yield* check(req.headers).pipe(Effect.catch((e) =>
-        HttpServerResponse.json({ message: e.message }, {
-          status: e.status,
-          headers: HttpHeaders.fromInput(e.headers)
-        })
-      ))
-      if (response) {
-        return response
-      }
-      return yield* app
-    })
-  )
-}
-
-export class JWTError extends Data.TaggedClass("JWTError")<{
-  error:
-    | InsufficientScopeError
-    | InvalidRequestError
-    | InvalidTokenError
-    | UnauthorizedError
-}> {}

package/src/api/middlewares.ts

@@ -1,10 +0,0 @@
-/**
- * Mechanism for extendning behaviour of all handlers on the server.
- *
- * @since 1.0.0
- */
-
-export * from "./internal/auth.js"
-export * from "./internal/events.js"
-export * from "./internal/health.js"
-export * from "./internal/RequestContextMiddleware.js"

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

@@ -1,128 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-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"
-import { InfraLogger } from "../../../logger.js"
-import { determineMethod, isCommand } from "../utils.js"
-
-const logRequestError = logError("Request")
-const reportRequestError = reportError("Request")
-
-// TODO: do we need this as middleware or just as layer?
-export const DevModeLive = Layer.effect(
-  DevMode,
-  Effect.gen(function*() {
-    const env = yield* Config.string("env").pipe(Config.withDefault("local-dev"))
-    return env !== "prod"
-  })
-)
-
-export const RequestCacheMiddlewareLive = Layer.succeed(
-  RequestCacheMiddleware,
-  (effect) => effect
-)
-
-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.Top) => {
-      const existing = cache.get(key)
-      if (existing) return existing
-      const n = determineMethod(key, schema)
-      cache.set(key, n)
-      return n
-    }
-    return (effect, { rpc }) => {
-      const method = getCached(rpc._tag, rpc.payloadSchema)
-
-      effect = isCommand(method)
-        ? Effect.retry(Effect.uninterruptible(effect), { times: 1, while: isOptimisticConcurrencyException })
-        : Effect.interruptible(effect)
-
-      return effect
-    }
-  })
-)
-
-export const LoggerMiddlewareLive = Layer
-  .effect(
-    LoggerMiddleware,
-    Effect.gen(function*() {
-      const devMode = yield* DevMode
-      return (effect, { headers, payload, rpc }) =>
-        Effect
-          .annotateCurrentSpan({
-            "request.name": rpc._tag,
-            "requestInput": typeof payload === "object" && payload !== null
-              ? Object.entries(payload).reduce((prev, [key, value]: [string, unknown]) => {
-                prev[key] = key === "password"
-                  ? "<redacted>"
-                  : typeof value === "string" || typeof value === "number" || typeof value === "boolean"
-                  ? typeof value === "string" && value.length > 256
-                    ? (value.substring(0, 253) + "...")
-                    : value
-                  : Array.isArray(value)
-                  ? `Array[${value.length}]`
-                  : value === null || value === undefined
-                  ? `${value}`
-                  : typeof value === "object" && value
-                  ? `Object[${Object.keys(value).length}]`
-                  : typeof value
-                return prev
-              }, {} as Record<string, string | number | boolean>)
-              : payload
-          })
-          .pipe(
-            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, {
-                    action: rpc._tag
-                  }),
-                  InfraLogger
-                    .logError("Finished request", cause)
-                    .pipe(Effect.annotateLogs({
-                      action: rpc._tag,
-                      req: pretty(payload),
-                      headers: pretty(headers)
-                      // resHeaders: pretty(
-                      //   Object
-                      //     .entries(headers)
-                      //     .reduce((prev, [key, value]) => {
-                      //       prev[key] = value && typeof value === "string" ? snipString(value) : value
-                      //       return prev
-                      //     }, {} as Record<string, any>)
-                      // )
-                    }))
-                ])),
-            devMode ? (_) => _ : Effect.catchDefect(() => Effect.die("Internal Server Error"))
-          )
-    })
-  )
-  .pipe(Layer.provide(DevModeLive))
-
-export const DevModeMiddlewareLive = Layer
-  .effect(
-    DevModeMiddleware,
-    Effect.gen(function*() {
-      const devMode = yield* DevMode
-      return (effect) => Effect.provideService(effect, DevMode, devMode)
-    })
-  )
-  .pipe(Layer.provide(DevModeLive))
-
-export const DefaultGenericMiddlewaresLive = Layer.mergeAll(
-  RequestCacheMiddlewareLive,
-  ConfigureInterruptibilityMiddlewareLive,
-  LoggerMiddlewareLive,
-  DevModeMiddlewareLive
-)

package/src/api/routing/middleware.ts

@@ -1,6 +0,0 @@
-// codegen:start {preset: barrel, include: ./middleware/*.ts, nodir: false }
-export * from "./middleware/middleware.js"
-export * from "./middleware/RouterMiddleware.js"
-// codegen:end
-
-export * as Middleware from "./middleware.js"