@effect-app/infra 3.0.3 → 3.0.5

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

@@ -3,13 +3,12 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { type RpcMiddleware } from "@effect/rpc"
 import { type Context, type Layer } from "effect-app"
-import type { GetContextConfig, RPCContextMap } from "effect-app/client/req"
-import { type MiddlewareMakerId } from "effect-app/rpc"
+import { type GetContextConfig, type MiddlewareMakerId, type RpcContextMap } from "effect-app/rpc"
 // module:
 //
 
 export type RouterMiddleware<
-  RequestContextMap extends Record<string, RPCContextMap.Any>, // what services will the middlware provide dynamically to the next, or raise errors.
+  RequestContextMap extends Record<string, RpcContextMap.Any>, // what services will the middlware provide dynamically to the next, or raise errors.
   MakeMiddlewareE, // what the middleware construction can fail with
   MakeMiddlewareR, // what the middlware requires to be constructed
   ContextProviderA, // what the context provider provides

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

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Cause, Duration, Effect, Layer, ParseResult, Request, Schedule, type Schema } from "effect"
-import * as MiddlewareNative from "effect-app/rpc/middleware-native"
+import { ConfigureInterruptibilityMiddleware, DevMode, LoggerMiddleware, RequestCacheMiddleware } from "effect-app/middleware"
 import { pretty } from "effect-app/utils"
 import { logError, reportError } from "../../../errorReporter.js"
 import { InfraLogger } from "../../../logger.js"
@@ -18,7 +18,7 @@ export const RequestCacheLayers = Layer.mergeAll(
 )
 
 export const RequestCacheMiddlewareLive = Layer.succeed(
-  MiddlewareNative.RequestCacheMiddleware,
+  RequestCacheMiddleware,
   (effect) => effect.pipe(Effect.provide(RequestCacheLayers))
 )
 
@@ -28,7 +28,7 @@ const optimisticConcurrencySchedule = Schedule.once.pipe(
 )
 
 export const ConfigureInterruptibilityMiddlewareLive = Layer.effect(
-  MiddlewareNative.ConfigureInterruptibilityMiddleware,
+  ConfigureInterruptibilityMiddleware,
   Effect.gen(function*() {
     const cache = new Map()
     const getCached = (key: string, schema: Schema.Schema.Any) => {
@@ -51,9 +51,9 @@ export const ConfigureInterruptibilityMiddlewareLive = Layer.effect(
 )
 
 export const LoggerMiddlewareLive = Layer.effect(
-  MiddlewareNative.LoggerMiddleware,
+  LoggerMiddleware,
   Effect.gen(function*() {
-    const devMode = yield* MiddlewareNative.DevMode
+    const devMode = yield* DevMode
     return (effect, { headers, payload, rpc }) =>
       Effect
         .annotateCurrentSpan({

package/src/api/routing.ts

@@ -4,9 +4,9 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Rpc, RpcGroup, type RpcSerialization, RpcServer } from "@effect/rpc"
 import { type Array, Effect, Layer, type NonEmptyReadonlyArray, Predicate, S, Schema, type Scope } from "effect-app"
-import type { GetEffectContext, GetEffectError, RPCContextMap } from "effect-app/client/req"
 import { type HttpHeaders } from "effect-app/http"
-import { DevMode } from "effect-app/rpc"
+import { DevMode } from "effect-app/middleware"
+import { type GetEffectContext, type GetEffectError, type RpcContextMap } from "effect-app/rpc"
 import { type TypeTestId } from "effect-app/TypeTest"
 import { typedKeysOf, typedValuesOf } from "effect-app/utils"
 import { type Service } from "effect/Effect"
@@ -93,7 +93,7 @@ type FilterRequestModules<T> = {
   [K in keyof T as T[K] extends AnyRequestModule ? K : never]: T[K]
 }
 
-type RPCRouteR<
+type RpcRouteR<
   T extends [any, (req: any, headers: HttpHeaders.Headers) => Effect<any, any, any>]
 > = T extends [
   any,
@@ -153,7 +153,7 @@ export type RouteMatcher<
 }
 
 export const makeRouter = <
-  RequestContextMap extends Record<string, RPCContextMap.Any>,
+  RequestContextMap extends Record<string, RpcContextMap.Any>,
   MakeMiddlewareE,
   MakeMiddlewareR,
   ContextProviderA,
@@ -347,7 +347,6 @@ export const makeRouter = <
         match: any
       ) => Effect<THandlers, MakeE, MakeR> | Generator<YieldWrap<Effect<any, MakeE, MakeR>>, THandlers, any>
     ) => {
-      console.log({ dependencies, make })
       const dependenciesL = (dependencies ? Layer.mergeAll(...dependencies as any) : Layer.empty) as Layer.Layer<
         LayerUtils.GetLayersSuccess<MakeDependencies>,
         LayerUtils.GetLayersError<MakeDependencies>,
@@ -428,7 +427,7 @@ export const makeRouter = <
             })) as unknown as Layer<
               { [K in keyof RequestModules]: Rpc.Handler<K> },
               MakeE,
-              RPCRouteR<typeof mapped[keyof typeof mapped]>
+              RpcRouteR<typeof mapped[keyof typeof mapped]>
             >
 
           return RpcServer

package/test/controller.test.ts

@@ -5,91 +5,101 @@ import { type RpcSerialization } from "@effect/rpc"
 import { expect, expectTypeOf, it } from "@effect/vitest"
 import { Context, Effect, Layer, S, Scope } from "effect-app"
 import { InvalidStateError, makeRpcClient, NotLoggedInError, UnauthorizedError } from "effect-app/client"
-import { DefaultGenericMiddlewares, makeMiddleware, TagService } from "effect-app/rpc"
+import { DefaultGenericMiddlewares } from "effect-app/middleware"
+import { makeMiddleware, Tag } from "effect-app/rpc"
 import { TypeTestId } from "effect-app/TypeTest"
 import { DefaultGenericMiddlewaresLive } 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"
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class MyContextProvider extends TagService<MyContextProvider, {
-  provides: Some
-  requires: SomeElse
-}>()("MyContextProvider", {})({
-  effect: Effect.gen(function*() {
-    yield* SomeService
-    if (Math.random() > 0.5) return yield* new CustomError1()
-
-    return Effect.fnUntraced(function*(effect) {
-      yield* SomeElse
-      // 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 yield* Effect.provideService(effect, Some, new Some({ a: 1 }))
+class MyContextProvider extends Context.DefineService(
+  Tag<MyContextProvider, {
+    provides: Some
+    requires: SomeElse
+  }>()("MyContextProvider", {}),
+  {
+    effect: Effect.gen(function*() {
+      yield* SomeService
+      if (Math.random() > 0.5) return yield* new CustomError1()
+
+      return Effect.fnUntraced(function*(effect) {
+        yield* SomeElse
+        // 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 yield* Effect.provideService(effect, Some, new Some({ a: 1 }))
+      })
     })
-  })
-}) {}
+  }
+) {}
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class MyContextProvider3 extends TagService<MyContextProvider3, {
-  provides: Some
-  requires: SomeElse
-}>()("MyContextProvider3", {})({
-  dependencies: [Layer.effect(SomeService, SomeService.make)],
-  effect: Effect.gen(function*() {
-    yield* SomeService
-    if (Math.random() > 0.5) return yield* new CustomError1()
-
-    return Effect.fnUntraced(function*(effect) {
-      yield* SomeElse
-      // 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 yield* Effect.provideService(effect, Some, new Some({ a: 1 }))
+class MyContextProvider3 extends Context.DefineService(
+  Tag<MyContextProvider3, {
+    provides: Some
+    requires: SomeElse
+  }>()("MyContextProvider3", {}),
+  {
+    dependencies: [Layer.effect(SomeService, SomeService.make)],
+    effect: Effect.gen(function*() {
+      yield* SomeService
+      if (Math.random() > 0.5) return yield* new CustomError1()
+
+      return Effect.fnUntraced(function*(effect) {
+        yield* SomeElse
+        // 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 yield* Effect.provideService(effect, Some, new Some({ a: 1 }))
+      })
     })
-  })
-}) {}
+  }
+) {}
 
 expectTypeOf(MyContextProvider3.Default).toEqualTypeOf<Layer.Layer<MyContextProvider3, CustomError1, never>>()
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class MyContextProvider2 extends TagService<MyContextProvider2, { provides: SomeElse }>()("MyContextProvider2", {})({
-  effect: Effect.gen(function*() {
-    if (Math.random() > 0.5) return yield* new CustomError1()
+class MyContextProvider2 extends Context.DefineService(
+  Tag<MyContextProvider2, { provides: SomeElse }>()("MyContextProvider2", {}),
+  {
+    effect: Effect.gen(function*() {
+      if (Math.random() > 0.5) return yield* new CustomError1()
 
-    return Effect.fnUntraced(function*(effect) {
-      // we test without dependencies, so that we end up with an R of never.
+      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, new SomeElse({ b: 2 }))
+      })
     })
-  })
-}) {}
+  }
+) {}
 
 //
 
 const Str = Context.GenericTag<"str", "str">("str")
 
-export class BogusMiddleware extends TagService<BogusMiddleware>()("BogusMiddleware", {})({
+export class BogusMiddleware extends Context.DefineService(Tag<BogusMiddleware>()("BogusMiddleware", {}), {
   effect: Effect.gen(function*() {
     yield* Str
     // yield* Effect.context<"test-dep">()

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;AAM7D,OAAO,EAAE,cAAc,EAAsB,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAoB,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAY,MAAM,eAAe,CAAA;;cAgEpG,QAAQ;;;;AAApF,cAAM,kBAAmB,SAAQ,uBAU/B;CAAG;;;;;;;AAML,qBAAa,eAAgB,SAAQ,oBAUnC;CACD;AAgED,eAAO,MAAM,WAAW;;;;;;YAIM,CAAA;AAE9B,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AACD,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/B,CAAA;;;;;;;;;;AAEF,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;;;;;AAItC,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;AAUL,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,QAAQ;;qGAK9B,CAAA;AAED,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGd,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;AAC7F,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAEnD,OAAO,EAAW,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAO7D,OAAO,EAAE,cAAc,EAAsB,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAoB,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAY,MAAM,eAAe,CAAA;;cAuE1I,QAAQ;;;;AAD9C,cAAM,kBAAmB,SAAQ,uBAahC;CAAG;;;;;;;AAMJ,qBAAa,eAAgB,SAAQ,oBAUnC;CACD;AAgED,eAAO,MAAM,WAAW;;;;;;YAIM,CAAA;AAE9B,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,cAAc,CAAC,EAAE,IAAI,CAAA;IACrB,iEAAiE;IACjE,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC/B,CAAA;AACD,eAAO,MAAuB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/B,CAAA;;;;;;;;;;AAEF,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;;;;;AAItC,qBAAa,gBAAiB,SAAQ,qBAKpC;CAAG;;;;;AASL,qBAAa,aAAc,SAAQ,kBAOjC;CAAG;;;;;AAEL,qBAAa,iBAAkB,SAAQ,sBAKrC;CAAG;AAUL,eAAO,MAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAE,QAAQ;;qGAK9B,CAAA;AAED,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGd,CAAA"}

package/test/dist/fixtures.d.ts

@@ -1,5 +1,6 @@
 import { Context, Effect, Layer, S, Scope } from "effect-app";
-import { NotLoggedInError, RPCContextMap, UnauthorizedError } from "effect-app/client";
+import { NotLoggedInError, UnauthorizedError } from "effect-app/client";
+import { RpcContextMap } from "effect-app/rpc";
 declare const UserProfile_base: S.EnhancedClass<UserProfile, {
     id: typeof S.String;
     roles: S.Array$<typeof S.String> & {
@@ -36,7 +37,7 @@ declare const Some_base: (abstract new (service: {
 } & {
     use: <X>(body: (_: {
         a: number;
-    }) => X) => X extends Effect.Effect<infer A_1, infer E_2, infer R_4> ? Effect.Effect<A_1, E_2, Some | R_4> : Effect.Effect<X, never, Some>;
+    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, Some | R_3> : Effect.Effect<X, never, Some>;
 };
 export declare class Some extends Some_base {
 }
@@ -62,7 +63,7 @@ declare const SomeElse_base: (abstract new (service: {
 } & {
     use: <X>(body: (_: {
         b: number;
-    }) => X) => X extends Effect.Effect<infer A_1, infer E_2, infer R_4> ? Effect.Effect<A_1, E_2, R_4 | SomeElse> : Effect.Effect<X, never, SomeElse>;
+    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, R_3 | SomeElse> : Effect.Effect<X, never, SomeElse>;
 };
 export declare class SomeElse extends SomeElse_base {
 }
@@ -88,7 +89,7 @@ declare const SomeService_base: (abstract new (service: {
 } & {
     use: <X>(body: (_: {
         a: number;
-    }) => X) => X extends Effect.Effect<infer A_1, infer E_2, infer R_4> ? Effect.Effect<A_1, E_2, R_4 | SomeService> : Effect.Effect<X, never, SomeService>;
+    }) => X) => X extends Effect.Effect<infer A, infer E_1, infer R_3> ? Effect.Effect<A, E_1, R_3 | SomeService> : Effect.Effect<X, never, SomeService>;
 };
 export declare class SomeService extends SomeService_base {
 }
@@ -105,15 +106,15 @@ export declare class SomeElseMiddleware extends SomeElseMiddleware_base {
 }
 export declare const SomeElseMiddlewareLive: Layer.Layer<SomeElseMiddleware, never, never>;
 export declare const RequestContextMap: {
-    readonly allowAnonymous: RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>;
-    readonly requireRoles: RPCContextMap.Custom<never, typeof UnauthorizedError, string[]>;
-    readonly test: RPCContextMap.RPCContextMap<never, typeof S.Never>;
+    readonly allowAnonymous: RpcContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>;
+    readonly requireRoles: RpcContextMap.Custom<never, typeof UnauthorizedError, string[]>;
+    readonly test: RpcContextMap.RpcContextMap<never, typeof S.Never>;
 };
 type _RequestContextMap = typeof RequestContextMap;
 export interface RequestContextMap extends _RequestContextMap {
 }
 declare const AllowAnonymous_base: import("effect-app/rpc").TagClass<AllowAnonymous, "AllowAnonymous", {
-    readonly dynamic: import("effect-app/rpc").RpcDynamic<"allowAnonymous", RPCContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>>;
+    readonly dynamic: import("effect-app/rpc").RpcDynamic<"allowAnonymous", RpcContextMap.Inverted<[typeof UserProfile], typeof NotLoggedInError>>;
 }, {
     requires: SomeElse;
 }>;
@@ -121,7 +122,7 @@ export declare class AllowAnonymous extends AllowAnonymous_base {
 }
 export declare const AllowAnonymousLive: Layer.Layer<AllowAnonymous, never, never>;
 declare const RequireRoles_base: import("effect-app/rpc").TagClass<RequireRoles, "RequireRoles", {
-    readonly dynamic: import("effect-app/rpc").RpcDynamic<"requireRoles", RPCContextMap.Custom<never, typeof UnauthorizedError, string[]>>;
+    readonly dynamic: import("effect-app/rpc").RpcDynamic<"requireRoles", RpcContextMap.Custom<never, typeof UnauthorizedError, string[]>>;
     readonly dependsOn: readonly [typeof AllowAnonymous];
 }, {
     requires: never;
@@ -131,7 +132,7 @@ export declare class RequireRoles extends RequireRoles_base {
 }
 export declare const RequireRolesLive: Layer.Layer<RequireRoles, never, SomeService>;
 declare const Test_base: import("effect-app/rpc").TagClass<Test, "Test", {
-    readonly dynamic: import("effect-app/rpc").RpcDynamic<"test", RPCContextMap.RPCContextMap<never, typeof S.Never>>;
+    readonly dynamic: import("effect-app/rpc").RpcDynamic<"test", RpcContextMap.RpcContextMap<never, typeof S.Never>>;
 }, {
     requires: never;
     provides: never;

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

@@ -1 +1 @@
-{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAC7D,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;;;;;;;;;;;;;AAItF,qBAAa,WAAY,SAAQ,gBAKhC;CACA;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AACxF,qBAAa,QAAS,SAAQ,aAAmE;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,WAAY,SAAQ,gBAAgE;CAAG;;cAGhC,IAAI;;AAAxE,qBAAa,cAAe,SAAQ,mBAA+D;CAClG;AAED,eAAO,MAAM,kBAAkB,2CAM9B,CAAA;;cAE2E,QAAQ;;AAApF,qBAAa,kBAAmB,SAAQ,uBAA2E;CAAG;AAEtH,eAAO,MAAM,sBAAsB,+CAUlC,CAAA;AASD,eAAO,MAAM,iBAAiB;;;;CAIpB,CAAA;AAEV,KAAK,kBAAkB,GAAG,OAAO,iBAAiB,CAAA;AAClD,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;CAAG;;;;cAEI,QAAQ;;AAA5E,qBAAa,cAAe,SAAQ,mBAElC;CAAG;AAEL,eAAO,MAAM,kBAAkB,2CAyB9B,CAAA;;;;;;;;AAID,qBAAa,YAAa,SAAQ,iBAKhC;CAAG;AAEL,eAAO,MAAM,gBAAgB,+CAuB5B,CAAA;;;;;;;AAGD,qBAAa,IAAK,SAAQ,SAExB;CAAG;AAEL,eAAO,MAAM,QAAQ,iCAOpB,CAAA;;;;AAED,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;;;;AACxF,qBAAa,YAAa,SAAQ,iBAAmD;CAAG"}
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAC7D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AACvE,OAAO,EAAyB,aAAa,EAAO,MAAM,gBAAgB,CAAA;;;;;;;;;;;;;AAG1E,qBAAa,WAAY,SAAQ,gBAKhC;CACA;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAAa,IAAK,SAAQ,SAA2D;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AACxF,qBAAa,QAAS,SAAQ,aAAmE;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;AAEpG,qBAAa,WAAY,SAAQ,gBAAgE;CAAG;;cAGhC,IAAI;;AAAxE,qBAAa,cAAe,SAAQ,mBAA+D;CAClG;AAED,eAAO,MAAM,kBAAkB,2CAM9B,CAAA;;cAE2E,QAAQ;;AAApF,qBAAa,kBAAmB,SAAQ,uBAA2E;CAAG;AAEtH,eAAO,MAAM,sBAAsB,+CAUlC,CAAA;AASD,eAAO,MAAM,iBAAiB;;;;CAIpB,CAAA;AAEV,KAAK,kBAAkB,GAAG,OAAO,iBAAiB,CAAA;AAClD,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;CAAG;;;;cAEI,QAAQ;;AAA5E,qBAAa,cAAe,SAAQ,mBAElC;CAAG;AAEL,eAAO,MAAM,kBAAkB,2CAyB9B,CAAA;;;;;;;;AAID,qBAAa,YAAa,SAAQ,iBAKhC;CAAG;AAEL,eAAO,MAAM,gBAAgB,+CAuB5B,CAAA;;;;;;;AAGD,qBAAa,IAAK,SAAQ,SAExB;CAAG;AAEL,eAAO,MAAM,QAAQ,iCAOpB,CAAA;;;;AAED,qBAAa,YAAa,SAAQ,iBAAmD;CAAG;;;;AACxF,qBAAa,YAAa,SAAQ,iBAAmD;CAAG"}

package/test/dist/fixtures.js

@@ -1,6 +1,6 @@
 import { Context, Effect, Layer, S, Scope } from "effect-app";
-import { NotLoggedInError, RPCContextMap, UnauthorizedError } from "effect-app/client";
-import { contextMap, getConfig, Tag } from "effect-app/rpc";
+import { NotLoggedInError, UnauthorizedError } from "effect-app/client";
+import { contextMap, getConfig, RpcContextMap, Tag } from "effect-app/rpc";
 import { TaggedError } from "effect-app/Schema";
 export class UserProfile extends Context.assignTag("UserProfile")(S.Class("UserProfile")({
     id: S.String,
@@ -37,9 +37,9 @@ const requestConfig = getConfig();
 //
 // consider if we want to support Context of one Service
 export const RequestContextMap = {
-    allowAnonymous: RPCContextMap.makeInverted([UserProfile], NotLoggedInError),
-    requireRoles: RPCContextMap.makeCustom(null, UnauthorizedError, Array()),
-    test: RPCContextMap.make(null, S.Never)
+    allowAnonymous: RpcContextMap.makeInverted([UserProfile], NotLoggedInError),
+    requireRoles: RpcContextMap.makeCustom(null, UnauthorizedError, Array()),
+    test: RpcContextMap.make(null, S.Never)
 };
 export class AllowAnonymous extends Tag()("AllowAnonymous", {
     dynamic: contextMap(RequestContextMap, "allowAnonymous")
@@ -101,4 +101,4 @@ export class CustomError1 extends TaggedError()("CustomError1", {}) {
 }
 export class CustomError2 extends TaggedError()("CustomError1", {}) {
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"requires.test.d.ts","sourceRoot":"","sources":["../requires.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAA2B,KAAK,EAAE,CAAC,EAAE,MAAM,YAAY,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAGvE,OAAO,EAAE,cAAc,EAAyC,YAAY,EAAoB,IAAI,EAAE,kBAAkB,EAA0B,cAAc,EAAmC,IAAI,EAAY,MAAM,eAAe,CAAA;;cAG/K,IAAI;;;;AAD7D,qBAAa,sBACX,SAAQ,2BASN;CAEH;AAkBD,eAAO,MAAM,eAAe;;;;;;;;;;SAKK,CAAA"}
+{"version":3,"file":"requires.test.d.ts","sourceRoot":"","sources":["../requires.test.ts"],"names":[],"mappings":"AAGA,OAAO,EAA2B,KAAK,EAAE,CAAC,EAAE,MAAM,YAAY,CAAA;AAC9D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAA;AAGvE,OAAO,EAAE,cAAc,EAAyC,YAAY,EAAoB,IAAI,EAAE,kBAAkB,EAA0B,cAAc,EAAmC,IAAI,EAAY,MAAM,eAAe,CAAA;;cAG9L,IAAI;;;;AAD9C,qBAAa,sBAAuB,SAAQ,2BAY3C;CACA;AAkBD,eAAO,MAAM,eAAe;;;;;;;;;;SAKK,CAAA"}

package/test/dist/rpc-multi-middleware.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rpc-multi-middleware.test.d.ts","sourceRoot":"","sources":["../rpc-multi-middleware.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAkD,MAAM,aAAa,CAAA;AAEvF,OAAO,EAA2B,KAAK,EAAE,MAAM,QAAQ,CAAA;AAOvD,OAAO,EAA4M,WAAW,EAAE,MAAM,eAAe,CAAA;AA8CrP,eAAO,MAAM,OAAO,uFAWO,CAAA;AAiB3B,eAAO,MAAM,YAAY,yKAItB,CAAA;AAEH,eAAO,MAAM,YAAY,+FAgByB,CAAA"}
+{"version":3,"file":"rpc-multi-middleware.test.d.ts","sourceRoot":"","sources":["../rpc-multi-middleware.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAkD,MAAM,aAAa,CAAA;AAEvF,OAAO,EAA2B,KAAK,EAAE,MAAM,QAAQ,CAAA;AAQvD,OAAO,EAA4M,WAAW,EAAE,MAAM,eAAe,CAAA;AA4CrP,eAAO,MAAM,OAAO,uFAMhB,CAAA;AAiBJ,eAAO,MAAM,YAAY,yKAItB,CAAA;AAEH,eAAO,MAAM,YAAY,+FAgByB,CAAA"}

package/test/fixtures.ts

@@ -1,6 +1,6 @@
 import { Context, Effect, Layer, S, Scope } from "effect-app"
-import { NotLoggedInError, RPCContextMap, UnauthorizedError } from "effect-app/client"
-import { contextMap, getConfig, Tag } from "effect-app/rpc"
+import { NotLoggedInError, UnauthorizedError } from "effect-app/client"
+import { contextMap, getConfig, RpcContextMap, Tag } from "effect-app/rpc"
 import { TaggedError } from "effect-app/Schema"
 
 export class UserProfile extends Context.assignTag<UserProfile, UserProfile>("UserProfile")(
@@ -50,9 +50,9 @@ const requestConfig = getConfig<RequestContextMap>()
 //
 // consider if we want to support Context of one Service
 export const RequestContextMap = {
-  allowAnonymous: RPCContextMap.makeInverted([UserProfile], NotLoggedInError),
-  requireRoles: RPCContextMap.makeCustom(null as never, UnauthorizedError, Array<string>()),
-  test: RPCContextMap.make(null as never, S.Never)
+  allowAnonymous: RpcContextMap.makeInverted([UserProfile], NotLoggedInError),
+  requireRoles: RpcContextMap.makeCustom(null as never, UnauthorizedError, Array<string>()),
+  test: RpcContextMap.make(null as never, S.Never)
 } as const
 
 type _RequestContextMap = typeof RequestContextMap

package/test/rawQuery.test.ts

@@ -137,7 +137,7 @@ describe("select first-level array fields", () => {
     })
     .pipe(setupRequestContextFromCurrent())
 
-  it("works well in CosmosDB", () =>
+  it.skipIf(!process.env["STORAGE_URL"])("works well in CosmosDB", () =>
     test
       .pipe(Effect.provide(SomethingRepo.TestCosmos), rt.runPromise))
 
@@ -232,7 +232,7 @@ describe("filter first-level array fields as groups", () => {
     })
     .pipe(setupRequestContextFromCurrent())
 
-  it("works well in CosmosDB", () =>
+  it.skipIf(!process.env["STORAGE_URL"])("works well in CosmosDB", () =>
     test
       .pipe(Effect.provide(SomethingRepo.TestCosmos), rt.runPromise))
 
@@ -302,7 +302,7 @@ describe("1", () => {
     })
     .pipe(setupRequestContextFromCurrent())
 
-  it("works well in CosmosDB", () =>
+  it.skipIf(!process.env["STORAGE_URL"])("works well in CosmosDB", () =>
     test
       .pipe(Effect.provide(SomethingRepo.TestCosmos), rt.runPromise))
 
@@ -330,7 +330,7 @@ describe("multi-level", () => {
     })
     .pipe(setupRequestContextFromCurrent())
 
-  it("works well in CosmosDB", () =>
+  it.skipIf(!process.env["STORAGE_URL"])("works well in CosmosDB", () =>
     test
       .pipe(Effect.provide(SomethingRepo.TestCosmos), rt.runPromise))
 

package/test/requires.test.ts

@@ -4,11 +4,12 @@ import { describe, expect, expectTypeOf, it } from "@effect/vitest"
 import { Context, Effect, Either, Layer, S } from "effect-app"
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client"
 import { HttpHeaders } from "effect-app/http"
-import { makeMiddleware, TagService } from "effect-app/rpc"
+import { makeMiddleware, Tag } from "effect-app/rpc"
 import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElseMiddleware, SomeElseMiddlewareLive, SomeMiddleware, SomeMiddlewareLive, SomeService, Test, TestLive } from "./fixtures.js"
 
-export class RequiresSomeMiddleware
-  extends TagService<RequiresSomeMiddleware, { requires: Some }>()("RequiresSomeMiddleware", {})({
+export class RequiresSomeMiddleware extends Context.DefineService(
+  Tag<RequiresSomeMiddleware, { requires: Some }>()("RequiresSomeMiddleware", {}),
+  {
     effect: Effect.gen(function*() {
       // yield* Effect.context<"test-dep">()
       return Effect.fnUntraced(function*(effect) {
@@ -17,8 +18,8 @@ export class RequiresSomeMiddleware
         return yield* effect
       })
     })
-  })
-{
+  }
+) {
 }
 
 const middleware3 = makeMiddleware(RequestContextMap)

package/test/rpc-multi-middleware.test.ts

@@ -6,7 +6,8 @@ import { Console, Effect, Either, Layer } from "effect"
 import { S } from "effect-app"
 import { NotLoggedInError } from "effect-app/client"
 import { HttpLayerRouter } from "effect-app/http"
-import { DefaultGenericMiddlewares, makeMiddleware, middlewareGroup } from "effect-app/rpc"
+import { DefaultGenericMiddlewares } from "effect-app/middleware"
+import { makeMiddleware, middlewareGroup } from "effect-app/rpc"
 import { createServer } from "http"
 import { DefaultGenericMiddlewaresLive } from "../src/api/routing.js"
 import { AllowAnonymous, AllowAnonymousLive, RequestContextMap, RequireRoles, RequireRolesLive, Some, SomeElseMiddleware, SomeElseMiddlewareLive, SomeMiddleware, SomeMiddlewareLive, SomeService, Test, TestLive, UserProfile } from "./fixtures.js"
@@ -17,56 +18,49 @@ const middleware = makeMiddleware(RequestContextMap)
   .middleware(SomeElseMiddleware, SomeMiddleware)
   .middleware(...DefaultGenericMiddlewares)
 
-const UserRpcs = middlewareGroup(middleware)(RpcGroup
-  .make(
+const UserRpcs = middlewareGroup(middleware)(
+  RpcGroup.make(
     middleware.rpc("getUser", {
       success: S.Literal("awesome")
     }),
     middleware.rpc("doSomething", {
       success: S.Literal("also-awesome"),
-      config: { allowAnonymous: true }
+      config: { allowAnonymous: true } // type safe config based on `RequestContextMap`
     })
-  ))
+  )
+)
 
-const impl = Effect
-  .gen(function*() {
-    const impl = UserRpcs
-      .toLayerDynamic({
-        getUser: Effect.fn(function*(_payload, _headers) {
-          yield* Some
-          yield* UserProfile // we only access it while protected by allowAnonymous: false
-          return "awesome" as const
-        }),
-        doSomething: Effect.fn(function*() {
-          console.log(yield* Effect.serviceOption(UserProfile)) // we access it optionally, while allowAnonymous: true
-          return "also-awesome" as const
-        })
-      })
-    return impl
+const impl = UserRpcs
+  .toLayerDynamic({
+    getUser: Effect.fn(function*(_payload, _headers) {
+      yield* Some
+      yield* UserProfile // we only access it while protected by allowAnonymous: false
+      return "awesome" as const
+    }),
+    doSomething: Effect.fn(function*() {
+      console.log(yield* Effect.serviceOption(UserProfile)) // we access it optionally, while allowAnonymous: true
+      return "also-awesome" as const
+    })
   })
-  .pipe(Layer.unwrapEffect)
 
 expectTypeOf<Layer.Layer.Context<typeof impl>>().toEqualTypeOf<never>()
 
-const UserRpcsBad = middlewareGroup(middleware)(RpcGroup
-  .make(
+const UserRpcsBad = middlewareGroup(middleware)(
+  RpcGroup.make(
     middleware.rpc("doSomethingElse", {
       success: S.Literal("also-awesome2"),
       config: { allowAnonymous: true }
     })
-  ))
-export const badImpl = Effect
-  .gen(function*() {
-    const impl = UserRpcsBad
-      .toLayerDynamic({
-        doSomethingElse: Effect.fn(function*() {
-          console.log(yield* UserProfile) // bad boy! allowAnonymous: false, so `UserProfile` must fall through to the Layer R.
-          return "also-awesome2" as const
-        })
-      })
-    return impl
+  )
+)
+
+export const badImpl = UserRpcsBad
+  .toLayerDynamic({
+    doSomethingElse: Effect.fn(function*() {
+      console.log(yield* UserProfile) // bad boy! allowAnonymous: false, so `UserProfile` must fall through to the Layer R.
+      return "also-awesome2" as const
+    })
   })
-  .pipe(Layer.unwrapEffect)
 
 expectTypeOf<Layer.Layer.Context<typeof badImpl>>().toEqualTypeOf<UserProfile>()
 

package/wallaby.cjs

@@ -1 +0,0 @@
-module.exports = require("../../wallaby.base.cjs")