@effect-app/infra 3.9.0 → 4.0.0-beta.0

package/src/rateLimit.ts

@@ -21,7 +21,7 @@
 // }
 
 import { Array, type Duration, Effect, type NonEmptyArray } from "effect-app"
-import type { Semaphore } from "effect-app/Effect"
+import type { Semaphore } from "effect/Semaphore"
 
 /**
  * Executes the specified effect, acquiring the specified number of permits
@@ -30,8 +30,8 @@ import type { Semaphore } from "effect-app/Effect"
  * failure, or interruption.
  */
 export function SEM_withPermitsDuration(permits: number, duration: Duration.Duration) {
-  return (self: Semaphore): <R, E, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> => {
-    return (effect) =>
+  return (self: Semaphore): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> => {
+    return <A, E, R>(effect: Effect.Effect<A, E, R>) =>
       Effect.uninterruptibleMask(
         (restore) =>
           restore(self.take(permits))
@@ -52,7 +52,7 @@ export function batchPar<R, E, A, R2, E2, A2, T>(
 ) {
   return (items: Iterable<T>) =>
     Effect.forEach(
-      Array.chunk_(items, n),
+      Array.chunksOf(items, n),
       (_, i) =>
         Effect
           .forEach(_, (_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
@@ -68,7 +68,7 @@ export function batch<R, E, A, R2, E2, A2, T>(
 ) {
   return (items: Iterable<T>) =>
     Effect.forEach(
-      Array.chunk_(items, n),
+      Array.chunksOf(items, n),
       (_, i) =>
         Effect
           .forEach(_, (_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
@@ -101,12 +101,12 @@ export function naiveRateLimit(
     forEachBatch: (a: A[]) => Effect.Effect<A2, E2, R2>
   ) =>
     Effect.forEach(
-      Array.chunk_(items, n),
+      Array.chunksOf(items, n),
       (batch, i) =>
         ((i === 0)
           ? Effect.void
           : Effect.sleep(d))
-          .pipe(Effect.zipRight(
+          .pipe(Effect.andThen(
             Effect
               .forEach(batch, forEachItem, { concurrency: n })
               .pipe(Effect.flatMap(forEachBatch))

package/src/test.ts

@@ -1,36 +1,14 @@
-import { Arbitrary } from "effect"
-import { Predicate, S } from "effect-app"
+import { S } from "effect-app"
 import { copy } from "effect-app/utils"
-import type { PropertySignature } from "effect/Schema"
 import { generate } from "./arbs.js"
 
-const isPropertySignature = (u: unknown): u is PropertySignature.All =>
-  Predicate.hasProperty(u, S.PropertySignatureTypeId)
-
-const defaults = (fields: S.Struct.Fields) => {
-  const keys = Object.keys(fields)
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const out: Record<string, any> = {}
-  for (const key of keys) {
-    const field = fields[key]
-    if (isPropertySignature(field)) {
-      const ast = field.ast
-      const defaultValue = ast._tag === "PropertySignatureDeclaration" ? ast.defaultValue : ast.to.defaultValue
-      if (defaultValue !== undefined) {
-        out[key] = defaultValue()
-      }
-    }
-  }
-  return out
-}
-
 /**
  * Given the schema for an object-like structure, creates a function that generates random instances of that object with some values provided.
  */
-export const createRandomInstance = <A extends object, I, R>(s: S.Schema<A, I, R> & { fields: S.Struct.Fields }) => {
-  const gen = generate(Arbitrary.make(s))
+export const createRandomInstance = <A extends object, I, R>(s: S.Codec<A, I, R> & { fields: S.Struct.Fields }) => {
+  const gen = generate(S.toArbitrary(s))
   return (overrides?: Partial<A>) => {
-    const v = { ...gen.value, ...defaults(s.fields) }
+    const v = gen.value
     return overrides ? copy(v, overrides) : v
   }
 }
@@ -38,12 +16,12 @@ export const createRandomInstance = <A extends object, I, R>(s: S.Schema<A, I, R
 /**
  * Like `createRandomInstance`, but takes encoded values rather than decoded ones.
  */
-export const createRandomInstanceI = <A extends object, I>(s: S.Schema<A, I, never> & { fields: S.Struct.Fields }) => {
-  const gen = generate(Arbitrary.make(s))
+export const createRandomInstanceI = <A extends object, I>(s: S.Codec<A, I, never> & { fields: S.Struct.Fields }) => {
+  const gen = generate(S.toArbitrary(s))
   const encode = S.encodeSync(s)
   const decode = S.decodeSync(s)
   return (overrides?: Partial<I>) => {
-    const v = { ...gen.value, ...defaults(s.fields) }
+    const v = gen.value
     if (!overrides) return v
     return decode({ ...encode(v), ...overrides })
   }

package/test/contextProvider.test.ts

@@ -1,82 +1,89 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { expectTypeOf, it } from "@effect/vitest"
-import { Context, Effect, Scope } from "effect-app"
+import { Effect, Layer, Scope, ServiceMap } from "effect-app"
 import { ContextProvider, mergeContextProviders, MergedContextProvider } from "../src/api/ContextProvider.js"
 import { CustomError1, Some, SomeElse, SomeService } from "./fixtures.js"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class MyContextProvider extends Effect.Service<MyContextProvider>()("MyContextProvider", {
-  effect: Effect.gen(function*() {
-    yield* SomeService
-    if (Math.random() > 0.5) return yield* new CustomError1()
-
-    return Effect.gen(function*() {
-      // the only requirements you can have are the one provided by HttpLayerRouter.Provided
-      yield* Scope.Scope
-
-      yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
-      yield* Effect.succeed("this is a generator")
-
-      // this is allowed here but mergeContextProviders/MergedContextProvider will trigger an error
-      // yield* SomeElse
-
-      // currently the effectful context provider cannot trigger an error when building the per request context
-      // this is allowed here but mergeContextProviders/MergedContextProvider will trigger an error
-      // if (Math.random() > 0.5) return yield* new CustomError2()
-
-      return Context.make(Some, new Some({ a: 1 }))
+class MyContextProvider extends ServiceMap.Service<MyContextProvider>()(
+  "MyContextProvider",
+  {
+    make: Effect.gen(function*() {
+      yield* SomeService
+      if (Math.random() > 0.5) return yield* new CustomError1()
+
+      return Effect.gen(function*() {
+        // the only requirements you can have are the one provided by HttpLayerRouter.Provided
+        yield* Scope.Scope
+
+        yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
+        yield* Effect.succeed("this is a generator")
+
+        return Some.serviceMap({ a: 1 }) 
+      })
     })
-  })
-}) {}
-
-class MyContextProvider2 extends Effect.Service<MyContextProvider2>()("MyContextProvider2", {
-  effect: Effect.gen(function*() {
-    if (Math.random() > 0.5) return yield* new CustomError1()
-
-    return Effect.gen(function*() {
-      // we test without dependencies, so that we end up with an R of never.
-
-      return Context.make(SomeElse, new SomeElse({ b: 2 }))
+  }
+) {
+  static readonly Default = Layer.effect(this, this.make)
+}
+
+class MyContextProvider2 extends ServiceMap.Service<MyContextProvider2>()(
+  "MyContextProvider2",
+  {
+    make: Effect.gen(function*() {
+      if (Math.random() > 0.5) return yield* new CustomError1()
+
+      return Effect.gen(function*() {
+        // we test without dependencies, so that we end up with an R of never.
+
+        return SomeElse.serviceMap({ b: 2 })
+      })
     })
-  })
-}) {}
-
-class MyContextProvider2Gen extends Effect.Service<MyContextProvider2Gen>()("MyContextProvider2Gen", {
-  effect: Effect.gen(function*() {
-    if (Math.random() > 0.5) return yield* new CustomError1()
-
-    return function*() {
-      // we test without dependencies, so that we end up with an R of never
-
-      return Context.make(SomeElse, new SomeElse({ b: 2 }))
-    }
-  })
-}) {}
+  }
+) {
+  static readonly Default = Layer.effect(this, this.make)
+}
+
+class MyContextProvider2Gen extends ServiceMap.Service<MyContextProvider2Gen>()(
+  "MyContextProvider2Gen",
+  {
+    make: Effect.gen(function*() {
+      if (Math.random() > 0.5) return yield* new CustomError1()
+
+      return function*() {
+        // we test without dependencies, so that we end up with an R of never
+
+        return SomeElse.serviceMap({ b: 2 })
+      }
+    })
+  }
+) {
+  static readonly Default = Layer.effect(this, this.make)
+}
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class MyContextProviderGen extends Effect.Service<MyContextProviderGen>()("MyContextProviderGen", {
-  effect: Effect.gen(function*() {
-    yield* SomeService
-    if (Math.random() > 0.5) return yield* new CustomError1()
-
-    return function*() {
-      // the only requirements you can have are the one provided by HttpLayerRouter.Provided
-      yield* Scope.Scope
-
-      yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
-      yield* Effect.succeed("this is a generator")
-
-      // this is allowed here but mergeContextProviders/MergedContextProvider will trigger an error
-      // yield* SomeElse
-
-      // currently the effectful context provider cannot trigger an error when building the per request context
-      // this is allowed here but mergeContextProviders/MergedContextProvider will trigger an error
-      // if (Math.random() > 0.5) return yield* new CustomError2()
-      return Context.make(Some, new Some({ a: 1 }))
-    }
-  })
-}) {}
+class MyContextProviderGen extends ServiceMap.Service<MyContextProviderGen>()(
+  "MyContextProviderGen",
+  {
+    make: Effect.gen(function*() {
+      yield* SomeService
+      if (Math.random() > 0.5) return yield* new CustomError1()
+
+      return function*() {
+        // the only requirements you can have are the one provided by HttpLayerRouter.Provided
+        yield* Scope.Scope
+
+        yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
+        yield* Effect.succeed("this is a generator")
+
+        return Some.serviceMap({ a: 1 })
+      }
+    })
+  }
+) {
+  static readonly Default = Layer.effect(this, this.make)
+}
 
 export const someContextProvider = ContextProvider({
   effect: Effect.gen(function*() {
@@ -93,7 +100,7 @@ export const someContextProvider = ContextProvider({
       // currently the effectful context provider cannot trigger an error when building the per request context
       // if (Math.random() > 0.5) return yield* new CustomError2()
 
-      return Context.make(Some, new Some({ a: 1 }))
+      return Some.serviceMap({ a: 1 })
     })
   })
 })
@@ -112,7 +119,7 @@ export const someContextProviderGen = ContextProvider({
       // currently the effectful context provider cannot trigger an error when building the per request context
       // if (Math.random() > 0.5) return yield* new CustomError2()
 
-      return Context.make(Some, new Some({ a: 1 }))
+      return Some.serviceMap({ a: 1 })
     }
   })
 })

package/test/controller.test.ts

@@ -1,14 +1,14 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/api/routing"
-import { type RpcSerialization } from "@effect/rpc"
 import { expect, expectTypeOf, it } from "@effect/vitest"
-import { Context, Effect, Layer, S, Scope } from "effect-app"
+import { Effect, Layer, S, Scope, ServiceMap } from "effect-app"
 import { InvalidStateError, makeRpcClient, UnauthorizedError } from "effect-app/client"
 import { DefaultGenericMiddlewares } from "effect-app/middleware"
 import * as RpcX from "effect-app/rpc"
 import { MiddlewareMaker } from "effect-app/rpc"
 import { TypeTestId } from "effect-app/TypeTest"
+import { type RpcSerialization } from "effect/unstable/rpc"
 import { DefaultGenericMiddlewaresLive, DevModeMiddlewareLive } from "../src/api/routing/middleware.js"
 import { sort } from "../src/api/routing/tsort.js"
 import { AllowAnonymous, AllowAnonymousLive, CustomError1, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElse, SomeService, Test, TestLive } from "./fixtures.js"
@@ -37,7 +37,7 @@ class MyContextProvider extends RpcX.RpcMiddleware.Tag<MyContextProvider, {
         // this is allowed here but mergeContextProviders/MergedContextProvider will trigger an error
         // if (Math.random() > 0.5) return yield* new CustomError2()
 
-        return yield* Effect.provideService(effect, Some, new Some({ a: 1 }))
+        return yield* Effect.provideService(effect, Some, Some.of({ a: 1 }))
       })
     }
   })
@@ -49,7 +49,7 @@ class MyContextProvider3 extends RpcX.RpcMiddleware.Tag<MyContextProvider3, {
   requires: SomeElse
 }>()("MyContextProvider3") {
   static Default = Layer.make(this, {
-    dependencies: [Layer.effect(SomeService, SomeService.make)],
+    dependencies: [SomeService.Default],
     *make() {
       yield* SomeService
       if (Math.random() > 0.5) return yield* new CustomError1()
@@ -69,7 +69,7 @@ class MyContextProvider3 extends RpcX.RpcMiddleware.Tag<MyContextProvider3, {
         // this is allowed here but mergeContextProviders/MergedContextProvider will trigger an error
         // if (Math.random() > 0.5) return yield* new CustomError2()
 
-        return yield* Effect.provideService(effect, Some, new Some({ a: 1 }))
+        return yield* Effect.provideService(effect, Some, Some.of({ a: 1 }))
       })
     }
   })
@@ -91,7 +91,7 @@ class MyContextProvider2
       return Effect.fnUntraced(function*(effect) {
         // we test without dependencies, so that we end up with an R of never.
 
-        return yield* Effect.provideService(effect, SomeElse, new SomeElse({ b: 2 }))
+        return yield* Effect.provideService(effect, SomeElse, SomeElse.of({ b: 2 }))
       })
     }
   })
@@ -99,7 +99,7 @@ class MyContextProvider2
 
 //
 
-const Str = Context.GenericTag<"str", "str">("str")
+class Str extends ServiceMap.Service<Str, "str">()("str") {}
 
 export class BogusMiddleware extends RpcX.RpcMiddleware.Tag<BogusMiddleware>()("BogusMiddleware") {
   static Default = Layer.make(this, {
@@ -147,7 +147,7 @@ class middleware extends MiddlewareMaker
   .middleware(MyContextProvider)
   .middleware(...genericMiddlewares)
 {
-  static Default = this.layer.pipe(Layer.provide(MiddlewaresLive))
+  static Default = this.layer.pipe(Layer.provide([...MiddlewaresLive]))
   // static override [Unify.unifySymbol]?: TagUnify<typeof middleware> // why we need this?
 }
 
@@ -238,12 +238,16 @@ const Something = { Eff, Gen, DoSomething, GetSomething, GetSomething2, meta: {
 // const client = ApiClientFactory.makeFor(Layer.empty)(Something)
 // client.pipe(Effect.map(c => c.DoSomething.name))
 
-export class SomethingService extends Effect.Service<SomethingService>()("SomethingService", {
-  dependencies: [],
-  effect: Effect.gen(function*() {
-    return {}
-  })
-}) {}
+export class SomethingService extends ServiceMap.Service<SomethingService>()(
+  "SomethingService",
+  {
+    make: Effect.gen(function*() {
+      return {}
+    })
+  }
+) {
+  static Default = Layer.effect(this, this.make)
+}
 
 declare const a: {
   (opt: { a: 1 }): void
@@ -252,28 +256,36 @@ declare const a: {
   (opt: { b: 3 }): void
 }
 
-export class SomethingRepo extends Effect.Service<SomethingRepo>()("SomethingRepo", {
-  dependencies: [SomethingService.Default],
-  effect: Effect.gen(function*() {
-    const smth = yield* SomethingService
-    console.log({ smth })
-    return {}
-  })
-}) {}
+export class SomethingRepo extends ServiceMap.Service<SomethingRepo>()(
+  "SomethingRepo",
+  {
+    make: Effect.gen(function*() {
+      const smth = yield* SomethingService
+      console.log({ smth })
+      return {}
+    })
+  }
+) {
+  static Default = Layer.effect(this, this.make).pipe(Layer.provide(SomethingService.Default))
+}
 
-export class SomethingService2 extends Effect.Service<SomethingService2>()("SomethingService2", {
-  dependencies: [],
-  effect: Effect.gen(function*() {
-    return {}
-  })
-}) {}
+export class SomethingService2 extends ServiceMap.Service<SomethingService2>()(
+  "SomethingService2",
+  {
+    make: Effect.gen(function*() {
+      return {}
+    })
+  }
+) {
+  static Default = Layer.effect(this, this.make)
+}
 
 export const { Router, matchAll } = makeRouter(
   middleware
 )
 
 export const r2 = makeRouter(
-  Object.assign(middleware2, { Default: middleware2.layer.pipe(Layer.provide(MiddlewaresLive)) })
+  Object.assign(middleware2, { Default: middleware2.layer.pipe(Layer.provide([...MiddlewaresLive])) })
 )
 
 const router = Router(Something)({
@@ -306,8 +318,8 @@ const router = Router(Something)({
         const some = yield* Some
         return yield* Effect.logInfo("Some", some)
       },
-      *GetSomething(req) {
-        console.log(req.id)
+      *GetSomething(req: GetSomething) {
+        console.log(req["id"])
 
         const _b = yield* Effect.succeed(false)
         if (_b) {
@@ -319,7 +331,7 @@ const router = Router(Something)({
           return yield* Effect.succeed("12")
         }
         if (!_b) {
-          return yield* new UnauthorizedError()
+          return yield* Effect.fail(new UnauthorizedError())
         } else {
           // expected an error here because a boolean is not a string
           // return _b
@@ -347,8 +359,8 @@ it("sorts based on requirements", () => {
 
 // eslint-disable-next-line unused-imports/no-unused-vars
 const matched = matchAll({ router })
-expectTypeOf({} as Layer.Layer.Context<typeof matched>).toEqualTypeOf<
-  RpcSerialization.RpcSerialization | SomeService | "str"
+expectTypeOf({} as Layer.Services<typeof matched>).toEqualTypeOf<
+  RpcSerialization.RpcSerialization | SomeService | Str
 >()
 
 type makeContext = MakeContext<typeof router[TypeTestId]>
@@ -371,8 +383,8 @@ const router2 = r2.Router(Something)({
         const some = yield* Some
         return yield* Effect.logInfo("Some", some)
       },
-      *GetSomething(req) {
-        console.log(req.id)
+      *GetSomething(req: GetSomething) {
+        console.log(req["id"])
 
         const _b = yield* Effect.succeed(false)
         if (_b) {
@@ -384,7 +396,7 @@ const router2 = r2.Router(Something)({
           return yield* Effect.succeed("12")
         }
         if (!_b) {
-          return yield* new UnauthorizedError()
+          return yield* Effect.fail(new UnauthorizedError())
         } else {
           // expected an error here because a boolean is not a string
           // return _b
@@ -405,8 +417,8 @@ const router2 = r2.Router(Something)({
 
 // eslint-disable-next-line unused-imports/no-unused-vars
 const matched2 = matchAll({ router: router2 })
-expectTypeOf({} as Layer.Layer.Context<typeof matched2>).toEqualTypeOf<
-  RpcSerialization.RpcSerialization | SomeService | "str"
+expectTypeOf({} as Layer.Services<typeof matched2>).toEqualTypeOf<
+  RpcSerialization.RpcSerialization | SomeService | Str
 >()
 
 type makeContext2 = MakeContext<typeof router2[TypeTestId]>

package/test/dist/contextProvider.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contextProvider.test.d.ts","sourceRoot":"","sources":["../contextProvider.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEnD,OAAO,EAAE,YAAY,EAAE,IAAI,EAAY,WAAW,EAAE,MAAM,eAAe,CAAA;AA2EzE,eAAO,MAAM,mBAAmB;;CAkB9B,CAAA;AACF,eAAO,MAAM,sBAAsB;;CAkBjC,CAAA"}
+{"version":3,"file":"contextProvider.test.d.ts","sourceRoot":"","sources":["../contextProvider.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE7D,OAAO,EAAE,YAAY,EAAE,IAAI,EAAY,WAAW,EAAE,MAAM,eAAe,CAAA;AAkFzE,eAAO,MAAM,mBAAmB;;CAkB9B,CAAA;AACF,eAAO,MAAM,sBAAsB;;CAkBjC,CAAA"}

package/test/dist/controller.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAc,MAAM,+BAA+B,CAAA;AAC7F,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,OAAO,EAAW,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAC7D,OAAO,EAAoC,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAEvF,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAKtC,OAAO,EAAE,cAAc,EAAsB,YAAY,EAAqB,YAAY,EAAoB,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAY,MAAM,eAAe,CAAA;;cAuE/G,QAAQ;;AADzE,cAAM,kBACJ,SAAQ,uBAA0F;IAElG,MAAM,CAAC,OAAO,uDAUZ;CACH;;;;;AAMD,qBAAa,eAAgB,SAAQ,oBAA4D;IAC/F,MAAM,CAAC,OAAO,6CAUZ;CACH;AAkFD,eAAO,MAAM,WAAW;;;;;;;;;;YAKM,CAAA;AAE9B,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;;;;;;;;;;;;;;AAEtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;;;;;AAEtE,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;;;;;AAgB1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;AAOtC,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;AAEL,eAAO,MAAQ,MAAM;;;;;SAvJnB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuJoB,QAAQ;;qGAE9B,CAAA;AAED,eAAO,MAAM,EAAE;;;;;;;;;aA3Jb,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6JF,CAAA"}
+{"version":3,"file":"controller.test.d.ts","sourceRoot":"","sources":["../controller.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAc,MAAM,+BAA+B,CAAA;AAE7F,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAChE,OAAO,EAAoC,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAEvF,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAA;AAGtC,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AAG3D,OAAO,EAAE,cAAc,EAAsB,YAAY,EAAqB,YAAY,EAAoB,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAY,MAAM,eAAe,CAAA;;cAuE/G,QAAQ;;AADzE,cAAM,kBACJ,SAAQ,uBAA0F;IAElG,MAAM,CAAC,OAAO,uDAUZ;CACH;;AAID,cAAM,GAAI,SAAQ,QAAuC;CAAG;;;;;AAE5D,qBAAa,eAAgB,SAAQ,oBAA4D;IAC/F,MAAM,CAAC,OAAO,2CAUZ;CACH;AAkFD,eAAO,MAAM,WAAW;;;;;;;;;;YAKM,CAAA;AAE9B,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;;;;;;;;;;;;;;AAEtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;;;AACtE,qBAAa,GAAI,SAAQ,QAA0C;CAAG;;;;;;;;;;;;;;;;;;AAEtE,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;;;;;;;AAgB1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;AAOtC,qBAAa,gBAAiB,SAAQ,qBAOrC;IACC,MAAM,CAAC,OAAO,8CAAgC;CAC/C;;;;AASD,qBAAa,aAAc,SAAQ,kBASlC;IACC,MAAM,CAAC,OAAO,2CAA8E;CAC7F;;;;AAED,qBAAa,iBAAkB,SAAQ,sBAOtC;IACC,MAAM,CAAC,OAAO,+CAAgC;CAC/C;AAED,eAAO,MAAQ,MAAM;;;;;SA3KX,CADF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4Ke,QAAQ;;0FAE9B,CAAA;AAED,eAAO,MAAM,EAAE;;;;;;;;;aA/KL,CADF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkLP,CAAA"}