@effect-app/infra 4.0.0-beta.13 → 4.0.0-beta.131

package/src/api/setupRequest.ts

@@ -1,9 +1,18 @@
-import { Effect, Layer, Tracer } from "effect-app"
+import { Effect, Layer, Option, Tracer } from "effect-app"
 import { NonEmptyString255 } from "effect-app/Schema"
+import { SqlClient } from "effect/unstable/sql"
 import { LocaleRef, RequestContext, spanAttributes } from "../RequestContext.js"
 import { ContextMapContainer } from "../Store/ContextMapContainer.js"
 import { storeId } from "../Store/Memory.js"
 
+const withSqlTransaction = <R, E, A>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+  Effect.serviceOption(SqlClient.SqlClient).pipe(
+    Effect.flatMap(Option.match({
+      onNone: () => self,
+      onSome: (sql) => sql.withTransaction(self).pipe(Effect.orDie)
+    }))
+  )
+
 export const getRequestContext = Effect
   .all({
     span: Effect.currentSpan.pipe(Effect.orDie),
@@ -43,16 +52,25 @@ const withRequestSpan = (name = "request", options?: Tracer.SpanOptions) => <R,
       )
   )
 
+export interface SetupRequestOptions {
+  readonly withTransaction?: boolean
+}
+
 export const setupRequestContextFromCurrent =
-  (name = "request", options?: Tracer.SpanOptions) => <R, E, A>(self: Effect.Effect<A, E, R>) =>
+  (name = "request", options?: Tracer.SpanOptions & SetupRequestOptions) => <R, E, A>(self: Effect.Effect<A, E, R>) =>
     self
       .pipe(
+        options?.withTransaction === true ? withSqlTransaction : (_) => _,
         withRequestSpan(name, options),
-        Effect.provide(ContextMapContainer.layer)
+        Effect.provide(ContextMapContainer.layer, { local: true })
       )
 
 // TODO: consider integrating Effect.withParentSpan
-export function setupRequestContext<R, E, A>(self: Effect.Effect<A, E, R>, requestContext: RequestContext) {
+export function setupRequestContext<R, E, A>(
+  self: Effect.Effect<A, E, R>,
+  requestContext: RequestContext,
+  options?: SetupRequestOptions
+) {
   const layer = Layer.mergeAll(
     ContextMapContainer.layer,
     Layer.succeed(LocaleRef, requestContext.locale),
@@ -60,8 +78,9 @@ export function setupRequestContext<R, E, A>(self: Effect.Effect<A, E, R>, reque
   )
   return self
     .pipe(
+      options?.withTransaction === true ? withSqlTransaction : (_) => _,
       withRequestSpan(requestContext.name),
-      Effect.provide(layer)
+      Effect.provide(layer, { local: true })
     )
 }
 
@@ -69,7 +88,7 @@ export function setupRequestContextWithCustomSpan<R, E, A>(
   self: Effect.Effect<A, E, R>,
   requestContext: RequestContext,
   name: string,
-  options?: Tracer.SpanOptions
+  options?: Tracer.SpanOptions & SetupRequestOptions
 ) {
   const layer = Layer.mergeAll(
     ContextMapContainer.layer,
@@ -78,7 +97,8 @@ export function setupRequestContextWithCustomSpan<R, E, A>(
   )
   return self
     .pipe(
+      options?.withTransaction === true ? withSqlTransaction : (_) => _,
       withRequestSpan(name, options),
-      Effect.provide(layer)
+      Effect.provide(layer, { local: true })
     )
 }

package/src/errorReporter.ts

@@ -13,47 +13,41 @@ const tryCauseException = <E>(cause: Cause.Cause<E>, name: string): CauseExcepti
   }
 }
 
-export function reportError(
-  name: string
-) {
-  return (
-    cause: Cause.Cause<unknown>,
-    extras?: Record<string, unknown>,
-    level: LogLevel.Severity = "Error"
-  ) =>
-    Effect
-      .gen(function*() {
-        if (Cause.hasInterruptsOnly(cause)) {
-          yield* InfraLogger.logDebug("Interrupted").pipe(Effect.annotateLogs("extras", JSON.stringify(extras ?? {})))
-          return
-        }
-        const error = tryCauseException(cause, name)
-
-        yield* reportSentry(error, extras, LogLevelToSentry(level))
-        yield* InfraLogger
-          .logWithLevel(level, "Reporting error", cause)
-          .pipe(
-            Effect.annotateLogs(dropUndefined({
-              extras,
-              error: tryToReport(error),
-              cause: tryToJson(cause),
-              __error_name__: name
-            }))
-          )
-          .pipe(
-            Effect.catchCause((cause) => InfraLogger.logWarning("Failed to log error", cause)),
-            Effect.catchCause(() => InfraLogger.logFatal("Failed to log error cause"))
-          )
+export function reportError(name: string) {
+  return Effect.fnUntraced(
+    function*(
+      cause: Cause.Cause<unknown>,
+      extras?: Record<string, unknown>,
+      level: LogLevel.Severity = "Error"
+    ) {
+      if (Cause.hasInterruptsOnly(cause)) {
+        yield* InfraLogger.logDebug("Interrupted").pipe(Effect.annotateLogs("extras", JSON.stringify(extras ?? {})))
+        return
+      }
+      const error = tryCauseException(cause, name)
 
-        return error
-      })
-      .pipe(
-        Effect.tapCause((cause) =>
-          InfraLogger.logError("Failed to report error", cause).pipe(
-            Effect.tapCause(() => InfraLogger.logFatal("Failed to log error cause"))
-          )
+      yield* reportSentry(error, extras, LogLevelToSentry(level))
+      yield* InfraLogger
+        .logWithLevel(level, "Reporting error", cause)
+        .pipe(
+          Effect.annotateLogs(dropUndefined({
+            extras,
+            error: tryToReport(error),
+            cause: tryToJson(cause),
+            __error_name__: name
+          })),
+          Effect.catchCause((cause) => InfraLogger.logWarning("Failed to log error", cause)),
+          Effect.catchCause(() => InfraLogger.logFatal("Failed to log error cause"))
         )
-      )
+
+      return error
+    },
+    (effect) =>
+      Effect.tapCause(effect, (cause) =>
+        InfraLogger.logError("Failed to report error", cause).pipe(
+          Effect.tapCause(() => InfraLogger.logFatal("Failed to log error cause"))
+        ))
+  )
 }
 
 function reportSentry(
@@ -72,39 +66,31 @@ function reportSentry(
   }))
 }
 
-export function logError<E>(
-  name: string
-) {
-  return (cause: Cause.Cause<E>, extras?: Record<string, unknown>) =>
-    Effect
-      .gen(function*() {
-        if (Cause.hasInterruptsOnly(cause)) {
-          yield* InfraLogger.logDebug("Interrupted").pipe(Effect.annotateLogs(dropUndefined({ extras })))
-          return
-        }
-        yield* InfraLogger
-          .logWarning("Logging error", cause)
-          .pipe(
-            Effect.annotateLogs(dropUndefined({
-              extras,
-              cause: tryToJson(cause),
-              __error_name__: name
-            }))
-          )
-      })
-      .pipe(
-        Effect.tapCause(() => InfraLogger.logFatal("Failed to log error cause"))
-      )
+export function logError<E>(name: string) {
+  return Effect.fnUntraced(
+    function*(cause: Cause.Cause<E>, extras?: Record<string, unknown>) {
+      if (Cause.hasInterruptsOnly(cause)) {
+        yield* InfraLogger.logDebug("Interrupted").pipe(Effect.annotateLogs(dropUndefined({ extras })))
+        return
+      }
+      yield* InfraLogger
+        .logWarning("Logging error", cause)
+        .pipe(Effect.annotateLogs(dropUndefined({
+          extras,
+          cause: tryToJson(cause),
+          __error_name__: name
+        })))
+    },
+    (effect) => Effect.tapCause(effect, () => InfraLogger.logFatal("Failed to log error cause"))
+  )
 }
 
-export function reportMessage(message: string, extras?: Record<string, unknown>) {
-  return Effect.gen(function*() {
-    const context = yield* getRC
-    const scope = new Sentry.Scope()
-    if (context) scope.setContext("context", { ...context })
-    if (extras) scope.setContext("extras", extras)
-    Sentry.captureMessage(message, scope)
+export const reportMessage = Effect.fnUntraced(function*(message: string, extras?: Record<string, unknown>) {
+  const context = yield* getRC
+  const scope = new Sentry.Scope()
+  if (context) scope.setContext("context", { ...context })
+  if (extras) scope.setContext("extras", extras)
+  Sentry.captureMessage(message, scope)
 
-    console.warn(message, extras)
-  })
-}
+  console.warn(message, extras)
+})

package/src/rateLimit.ts

@@ -21,7 +21,9 @@
 // }
 
 import { Array, type Duration, Effect, type NonEmptyArray } from "effect-app"
+import { dual } from "effect-app/Function"
 import type { Semaphore } from "effect/Semaphore"
+import type { Concurrency } from "effect/Types"
 
 /**
  * Executes the specified effect, acquiring the specified number of permits
@@ -45,36 +47,42 @@ export function SEM_withPermitsDuration(permits: number, duration: Duration.Dura
   }
 }
 
-export function batchPar<R, E, A, R2, E2, A2, T>(
-  n: number,
-  forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect.Effect<A, E, R>,
-  forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect.Effect<A2, E2, R2>
-) {
-  return (items: Iterable<T>) =>
-    Effect.forEach(
-      Array.chunksOf(items, n),
-      (_, i) =>
-        Effect
-          .forEach(_, (_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
-          .pipe(Effect.flatMap((_) => forEachBatch(_, i))),
-      { concurrency: "inherit" }
-    )
+export interface BatchOptions {
+  readonly concurrency?: Concurrency | undefined
 }
 
-export function batch<R, E, A, R2, E2, A2, T>(
-  n: number,
-  forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect.Effect<A, E, R>,
-  forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect.Effect<A2, E2, R2>
-) {
-  return (items: Iterable<T>) =>
+export const batch: {
+  <T, A, E, R, A2, E2, R2>(
+    n: number,
+    forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect.Effect<A, E, R>,
+    forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect.Effect<A2, E2, R2>,
+    options?: BatchOptions
+  ): (items: Iterable<T>) => Effect.Effect<Array<A2>, E | E2, R | R2>
+  <T, A, E, R, A2, E2, R2>(
+    items: Iterable<T>,
+    n: number,
+    forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect.Effect<A, E, R>,
+    forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect.Effect<A2, E2, R2>,
+    options?: BatchOptions
+  ): Effect.Effect<Array<A2>, E | E2, R | R2>
+} = dual(
+  (args) => typeof args[0] !== "number",
+  <T, A, E, R, A2, E2, R2>(
+    items: Iterable<T>,
+    n: number,
+    forEachItem: (item: T, iWithinBatch: number, batchI: number) => Effect.Effect<A, E, R>,
+    forEachBatch: (a: NonEmptyArray<A>, i: number) => Effect.Effect<A2, E2, R2>,
+    options?: BatchOptions
+  ) =>
     Effect.forEach(
       Array.chunksOf(items, n),
       (_, i) =>
         Effect
           .forEach(_, (_, j) => forEachItem(_, j, i), { concurrency: "inherit" })
-          .pipe(Effect.flatMap((_) => forEachBatch(_, i)))
+          .pipe(Effect.flatMap((_) => forEachBatch(_, i))),
+      { concurrency: options?.concurrency }
     )
-}
+)
 
 // export function rateLimit(
 //   n: number,

package/test/auth.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "@effect/vitest"
+import { Effect } from "effect-app"
+import { HttpHeaders } from "effect-app/http"
+import { SignJWT } from "jose"
+import { checkJWTI, InvalidRequestError, InvalidTokenError, UnauthorizedError } from "../src/api/internal/auth.js"
+
+const issuer = "https://issuer.example.com/"
+const audience = "effect-app"
+const secret = "test-secret-test-secret-test-secret"
+
+const makeToken = () =>
+  new SignJWT({ scope: "read:all" })
+    .setProtectedHeader({ alg: "HS256", typ: "at+jwt" })
+    .setIssuer(issuer)
+    .setAudience(audience)
+    .setIssuedAt()
+    .setExpirationTime("10m")
+    .sign(new TextEncoder().encode(secret))
+
+describe("checkJWTI", () => {
+  it.effect(
+    "validates a bearer token from headers",
+    Effect.fnUntraced(function*() {
+      const token = yield* Effect.promise(() => makeToken())
+
+      yield* checkJWTI({
+        audience,
+        issuer,
+        secret,
+        strict: true,
+        tokenSigningAlg: "HS256"
+      })(HttpHeaders.fromRecordUnsafe({ authorization: `Bearer ${token}` }))
+    })
+  )
+
+  it.effect(
+    "fails on malformed authorization headers",
+    Effect.fnUntraced(function*() {
+      const error = yield* Effect.flip(
+        checkJWTI({
+          audience,
+          issuer,
+          secret,
+          tokenSigningAlg: "HS256"
+        })(HttpHeaders.fromRecordUnsafe({ authorization: "Basic abc" }))
+      )
+
+      expect(error).toBeInstanceOf(InvalidRequestError)
+      expect(error.status).toBe(400)
+    })
+  )
+
+  it.effect(
+    "fails when the token is missing",
+    Effect.fnUntraced(function*() {
+      const error = yield* Effect.flip(
+        checkJWTI({
+          audience,
+          issuer,
+          secret,
+          tokenSigningAlg: "HS256"
+        })(HttpHeaders.empty)
+      )
+
+      expect(error).toBeInstanceOf(UnauthorizedError)
+      expect(error.status).toBe(401)
+    })
+  )
+
+  it.effect(
+    "allows missing tokens when auth is optional",
+    Effect.fnUntraced(function*() {
+      yield* checkJWTI({
+        audience,
+        authRequired: false,
+        issuer,
+        secret,
+        tokenSigningAlg: "HS256"
+      })(HttpHeaders.empty)
+    })
+  )
+
+  it.effect(
+    "fails when the token signature is invalid",
+    Effect.fnUntraced(function*() {
+      const token = yield* Effect.promise(() => makeToken())
+
+      const error = yield* Effect.flip(
+        checkJWTI({
+          audience,
+          issuer,
+          secret: "wrong-secret-wrong-secret-wrong-secret",
+          tokenSigningAlg: "HS256"
+        })(HttpHeaders.fromRecordUnsafe({ authorization: `Bearer ${token}` }))
+      )
+
+      expect(error).toBeInstanceOf(InvalidTokenError)
+      expect(error.status).toBe(401)
+    })
+  )
+})

package/test/contextProvider.test.ts

@@ -1,12 +1,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { expectTypeOf, it } from "@effect/vitest"
-import { Effect, Layer, Scope, ServiceMap } from "effect-app"
+import { Context, Effect, Layer, Scope } 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 ServiceMap.Service<MyContextProvider>()(
+class MyContextProvider extends Context.Service<MyContextProvider>()(
   "MyContextProvider",
   {
     make: Effect.gen(function*() {
@@ -20,7 +20,7 @@ class MyContextProvider extends ServiceMap.Service<MyContextProvider>()(
         yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
         yield* Effect.succeed("this is a generator")
 
-        return Some.serviceMap({ a: 1 }) 
+        return Some.context({ a: 1 })
       })
     })
   }
@@ -28,7 +28,7 @@ class MyContextProvider extends ServiceMap.Service<MyContextProvider>()(
   static readonly Default = Layer.effect(this, this.make)
 }
 
-class MyContextProvider2 extends ServiceMap.Service<MyContextProvider2>()(
+class MyContextProvider2 extends Context.Service<MyContextProvider2>()(
   "MyContextProvider2",
   {
     make: Effect.gen(function*() {
@@ -37,7 +37,7 @@ class MyContextProvider2 extends ServiceMap.Service<MyContextProvider2>()(
       return Effect.gen(function*() {
         // we test without dependencies, so that we end up with an R of never.
 
-        return SomeElse.serviceMap({ b: 2 })
+        return SomeElse.context({ b: 2 })
       })
     })
   }
@@ -45,7 +45,7 @@ class MyContextProvider2 extends ServiceMap.Service<MyContextProvider2>()(
   static readonly Default = Layer.effect(this, this.make)
 }
 
-class MyContextProvider2Gen extends ServiceMap.Service<MyContextProvider2Gen>()(
+class MyContextProvider2Gen extends Context.Service<MyContextProvider2Gen>()(
   "MyContextProvider2Gen",
   {
     make: Effect.gen(function*() {
@@ -54,7 +54,7 @@ class MyContextProvider2Gen extends ServiceMap.Service<MyContextProvider2Gen>()(
       return function*() {
         // we test without dependencies, so that we end up with an R of never
 
-        return SomeElse.serviceMap({ b: 2 })
+        return SomeElse.context({ b: 2 })
       }
     })
   }
@@ -63,7 +63,7 @@ class MyContextProvider2Gen extends ServiceMap.Service<MyContextProvider2Gen>()(
 }
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class MyContextProviderGen extends ServiceMap.Service<MyContextProviderGen>()(
+class MyContextProviderGen extends Context.Service<MyContextProviderGen>()(
   "MyContextProviderGen",
   {
     make: Effect.gen(function*() {
@@ -77,7 +77,7 @@ class MyContextProviderGen extends ServiceMap.Service<MyContextProviderGen>()(
         yield* Effect.logInfo("MyContextProviderGen", "this is a generator")
         yield* Effect.succeed("this is a generator")
 
-        return Some.serviceMap({ a: 1 })
+        return Some.context({ a: 1 })
       }
     })
   }
@@ -100,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 Some.serviceMap({ a: 1 })
+      return Some.context({ a: 1 })
     })
   })
 })
@@ -119,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 Some.serviceMap({ a: 1 })
+      return Some.context({ a: 1 })
     }
   })
 })

package/test/controller.test.ts

@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 import { type MakeContext, type MakeErrors, makeRouter } from "@effect-app/infra/api/routing"
 import { expect, expectTypeOf, it } from "@effect/vitest"
-import { Effect, Layer, S, Scope, ServiceMap } from "effect-app"
+import { Context, Effect, Layer, S, Scope } from "effect-app"
 import { InvalidStateError, makeRpcClient, UnauthorizedError } from "effect-app/client"
 import { DefaultGenericMiddlewares } from "effect-app/middleware"
 import * as RpcX from "effect-app/rpc"
@@ -99,7 +99,7 @@ class MyContextProvider2
 
 //
 
-class Str extends ServiceMap.Service<Str, "str">()("str") {}
+class Str extends Context.Service<Str, "str">()("str") {}
 
 export class BogusMiddleware extends RpcX.RpcMiddleware.Tag<BogusMiddleware>()("BogusMiddleware") {
   static Default = Layer.make(this, {
@@ -202,12 +202,17 @@ export const middleware3 = MiddlewareMaker
   .middleware(Test)
   .middleware(BogusMiddleware)
 
-export const { TaggedRequest: Req } = makeRpcClient(RequestContextMap)
+export const { TaggedRequestFor } = makeRpcClient(RequestContextMap)
+const Req = TaggedRequestFor("Something")
+const Command = Req.Command
+const Query = Req.Query
 
-export class Eff extends Req<Eff>()("Eff", {}, { success: S.Void }) {}
-export class Gen extends Req<Gen>()("Gen", {}, { success: S.Void }) {}
+export class Eff extends Command<Eff>()("Eff", {}, { success: S.Void }) {}
+export class Gen extends Command<Gen>()("Gen", {}) {}
 
-export class DoSomething extends Req<DoSomething>()("DoSomething", {
+expectTypeOf(Eff.error).toEqualTypeOf<typeof Gen.error>()
+
+export class DoSomething extends Command<DoSomething>()("DoSomething", {
   id: S.String
 }, { success: S.Void }) {}
 
@@ -225,20 +230,20 @@ export class DoSomething extends Req<DoSomething>()("DoSomething", {
 //   )
 // )
 
-export class GetSomething extends Req<GetSomething>()("GetSomething", {
+export class GetSomething extends Query<GetSomething>()("GetSomething", {
   id: S.String
 }, { success: S.String }) {}
 
-export class GetSomething2 extends Req<GetSomething2>()("GetSomething2", {
+export class GetSomething2 extends Query<GetSomething2>()("GetSomething2", {
   id: S.String
-}, { success: S.NumberFromString }) {}
+}, { success: S.FiniteFromString }) {}
 
-const Something = { Eff, Gen, DoSomething, GetSomething, GetSomething2, meta: { moduleName: "Something" as const } }
+const Something = { Eff, Gen, DoSomething, GetSomething, GetSomething2 }
 
 // const client = ApiClientFactory.makeFor(Layer.empty)(Something)
 // client.pipe(Effect.map(c => c.DoSomething.name))
 
-export class SomethingService extends ServiceMap.Service<SomethingService>()(
+export class SomethingService extends Context.Service<SomethingService>()(
   "SomethingService",
   {
     make: Effect.gen(function*() {
@@ -258,7 +263,7 @@ declare const a: {
   (opt: { b: 3 }): void
 }
 
-export class SomethingRepo extends ServiceMap.Service<SomethingRepo>()(
+export class SomethingRepo extends Context.Service<SomethingRepo>()(
   "SomethingRepo",
   {
     make: Effect.gen(function*() {
@@ -271,7 +276,7 @@ export class SomethingRepo extends ServiceMap.Service<SomethingRepo>()(
   static Default = Layer.effect(this, this.make).pipe(Layer.provide(SomethingService.Default))
 }
 
-export class SomethingService2 extends ServiceMap.Service<SomethingService2>()(
+export class SomethingService2 extends Context.Service<SomethingService2>()(
   "SomethingService2",
   {
     make: Effect.gen(function*() {

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

@@ -0,0 +1 @@
+{"version":3,"file":"auth.test.d.ts","sourceRoot":"","sources":["../auth.test.ts"],"names":[],"mappings":""}

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,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"}
+{"version":3,"file":"contextProvider.test.d.ts","sourceRoot":"","sources":["../contextProvider.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAE1D,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;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,qBASrC;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;;;;;SA7KX,CADL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8KkB,QAAQ;;0FAE9B,CAAA;AAED,eAAO,MAAM,EAAE;;;;;;;;;aAjLL,CADL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoLJ,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,OAAO,EAAE,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;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,QAAoC;CAAG;;;;;AAEzD,qBAAa,eAAgB,SAAQ,oBAA4D;IAC/F,MAAM,CAAC,OAAO,2CAUZ;CACH;AAkFD,eAAO,MAAM,WAAW;;;;;;;;;;YAKM,CAAA;AAE9B,eAAO,MAAQ,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAqC,CAAA;;;;;;;;;;;;;;;;;;;;AAKpE,qBAAa,GAAI,SAAQ,QAA8C;CAAG;;;;;;;;;;;;;;;;AAC1E,qBAAa,GAAI,SAAQ,QAAyB;CAAG;;;;;;;;;;;;;;;;;;;;;;AAIrD,qBAAa,WAAY,SAAQ,gBAEV;CAAG;;;;;;;;;;;;;;;;;;;;;;AAgB1B,qBAAa,YAAa,SAAQ,iBAET;CAAG;;;;;;;;;;;;;;;;;;;;;;AAE5B,qBAAa,aAAc,SAAQ,kBAEA;CAAG;;;;;;;;AAOtC,qBAAa,gBAAiB,SAAQ,qBASrC;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;SA3KnB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2KqB,QAAQ;;0FAE9B,CAAA;AAED,eAAO,MAAM,EAAE;;;;;aA/Kb,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiLD,CAAA"}

package/test/dist/date-query.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-query.test.d.ts","sourceRoot":"","sources":["../date-query.test.ts"],"names":[],"mappings":""}

package/test/dist/fixtures.d.ts

@@ -1,15 +1,16 @@
-import { Effect, Layer, S, ServiceMap } from "effect-app";
+import { Context, Effect, Layer, S } from "effect-app";
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client";
 import { RpcContextMap, RpcX } from "effect-app/rpc";
-declare const UserProfile_base: S.EnhancedClass<UserProfile, S.Struct<{
+declare const UserProfile_base: S.EnhancedClass<UserProfile, import("effect/Schema").Struct<{
     id: S.String;
     roles: S.$Array<S.String> & {
-        withDefault: S.withConstructorDefault<S.$Array<S.String> & S.WithoutConstructorDefault>;
+        withDefault: S.withConstructorDefault<S.$Array<S.String>>;
+        withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.String>>;
     };
-}>, {}> & ServiceMap.Opaque<UserProfile, UserProfile>;
+}>, {}> & Context.Opaque<UserProfile, UserProfile>;
 export declare class UserProfile extends UserProfile_base {
 }
-declare const Some_base: ServiceMap.OpaqueClass<Some, "Some", {
+declare const Some_base: Context.OpaqueClass<Some, "Some", {
     a: number;
 }> & {
     readonly make: Effect.Effect<{
@@ -18,7 +19,7 @@ declare const Some_base: ServiceMap.OpaqueClass<Some, "Some", {
 };
 export declare class Some extends Some_base {
 }
-declare const SomeElse_base: ServiceMap.OpaqueClass<SomeElse, "SomeElse", {
+declare const SomeElse_base: Context.OpaqueClass<SomeElse, "SomeElse", {
     b: number;
 }> & {
     readonly make: Effect.Effect<{
@@ -27,7 +28,7 @@ declare const SomeElse_base: ServiceMap.OpaqueClass<SomeElse, "SomeElse", {
 };
 export declare class SomeElse extends SomeElse_base {
 }
-declare const SomeService_base: ServiceMap.OpaqueClass<SomeService, "SomeService", {
+declare const SomeService_base: Context.OpaqueClass<SomeService, "SomeService", {
     a: number;
 }> & {
     readonly make: Effect.Effect<{
@@ -101,10 +102,19 @@ declare const Test_base: RpcX.RpcMiddleware.TagClass<Test, "Test", {
 export declare class Test extends Test_base {
 }
 export declare const TestLive: Layer.Layer<Test, never, never>;
-declare const CustomError1_base: S.ErrorClass<CustomError1, S.TaggedStruct<"CustomError1", {}>, import("effect/Cause").YieldableError>;
+declare const Counter_base: Context.OpaqueClass<Counter, "Counter", {
+    a: number;
+}> & {
+    readonly make: Effect.Effect<{
+        a: number;
+    }, never, never>;
+};
+export declare class Counter extends Counter_base {
+}
+declare const CustomError1_base: import("effect/Schema").Class<CustomError1, import("effect/Schema").TaggedStruct<"CustomError1", {}>, import("effect/Cause").YieldableError>;
 export declare class CustomError1 extends CustomError1_base {
 }
-declare const CustomError2_base: S.ErrorClass<CustomError2, S.TaggedStruct<"CustomError2", {}>, import("effect/Cause").YieldableError>;
+declare const CustomError2_base: import("effect/Schema").Class<CustomError2, import("effect/Schema").TaggedStruct<"CustomError2", {}>, import("effect/Cause").YieldableError>;
 export declare class CustomError2 extends CustomError2_base {
 }
 export {};