@effect-app/infra 2.85.0 → 2.86.0

package/test/dist/requires.d.ts

@@ -0,0 +1,21 @@
+import { type RPCContextMap } from "effect-app/client";
+import { type DynamicMiddlewareMaker, type GenericMiddlewareMaker, type makeMiddlewareBasic, type RequestContextMapProvider } from "../src/api/routing.js";
+export interface MiddlewareM<RequestContext extends Record<string, RPCContextMap.Any>, Provided extends keyof RequestContext, Middlewares extends ReadonlyArray<GenericMiddlewareMaker>, DynamicMiddlewareProviders, MiddlewareR = never> {
+    middleware: <MW extends GenericMiddlewareMaker>(mw: MW) => DynamicMiddlewareMakerrsss<RequestContext, Provided, [
+        ...Middlewares,
+        MW
+    ], DynamicMiddlewareProviders, GenericMiddlewareMaker.ApplyServices<MW, MiddlewareR>>;
+}
+export interface Dynamic<RequestContext extends Record<string, RPCContextMap.Any>, Provided extends keyof RequestContext, Middlewares extends ReadonlyArray<GenericMiddlewareMaker>, DynamicMiddlewareProviders, out MiddlewareR> extends MiddlewareM<RequestContext, Provided, Middlewares, DynamicMiddlewareProviders, MiddlewareR> {
+    middleware: <MW extends DynamicMiddlewareMaker<RequestContext> | GenericMiddlewareMaker>(mw: MW) => MW extends DynamicMiddlewareMaker<RequestContext> ? DynamicMiddlewareMakerrsss<RequestContext, Provided | MW["dynamic"]["key"], Middlewares, DynamicMiddlewareProviders & {
+        [K in MW["dynamic"]["key"]]: MW;
+    }, GenericMiddlewareMaker.ApplyServices<MW, MiddlewareR>> : DynamicMiddlewareMakerrsss<RequestContext, Provided, [
+        ...Middlewares,
+        MW
+    ], DynamicMiddlewareProviders, GenericMiddlewareMaker.ApplyServices<MW, MiddlewareR>>;
+}
+type GetDynamicMiddleware<T, RequestContext extends Record<string, RPCContextMap.Any>> = T extends RequestContextMapProvider<RequestContext> ? T : never;
+type DynamicMiddlewareMakerrsss<RequestContext extends Record<string, RPCContextMap.Any>, Provided extends keyof RequestContext = never, Middlewares extends ReadonlyArray<GenericMiddlewareMaker> = [], DynamicMiddlewareProviders = unknown, MiddlewareR = never> = keyof Omit<RequestContext, Provided> extends never ? [MiddlewareR] extends [never] ? ReturnType<typeof makeMiddlewareBasic<RequestContext, GetDynamicMiddleware<DynamicMiddlewareProviders, RequestContext>, Middlewares>> & MiddlewareM<RequestContext, Provided, Middlewares, DynamicMiddlewareProviders, MiddlewareR> : MiddlewareM<RequestContext, Provided, Middlewares, DynamicMiddlewareProviders, MiddlewareR> : Dynamic<RequestContext, Provided, Middlewares, DynamicMiddlewareProviders, MiddlewareR>;
+export declare const makeNewMiddleware: <RequestContextMap extends Record<string, RPCContextMap.Any>>() => DynamicMiddlewareMakerrsss<RequestContextMap>;
+export {};
+//# sourceMappingURL=requires.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"requires.d.ts","sourceRoot":"","sources":["../requires.ts"],"names":[],"mappings":"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"}

package/test/dist/requires.js

@@ -0,0 +1,27 @@
+import { Array, Either } from "effect-app";
+import { makeMiddleware } from "../src/api/routing.js";
+export const makeNewMiddleware = () => {
+    const make = makeMiddleware();
+    let capturedMiddlewares = [];
+    const it = {
+        middleware: (...middlewares) => {
+            for (const mw of middlewares) {
+                capturedMiddlewares = [mw, ...capturedMiddlewares];
+                if (mw.dynamic) {
+                    console.log("Adding dynamic middleware", mw.key, mw.dynamic.key);
+                }
+                else {
+                    console.log("Adding generic middleware", mw.key);
+                }
+            }
+            const [genericMiddlewares, dyn] = Array.partitionMap(capturedMiddlewares, (mw) => "dynamic" in mw && mw.dynamic
+                ? Either.right(mw)
+                : Either.left(mw));
+            const dynamicMiddlewares = dyn.reduce((prev, cur) => ({ ...prev, [cur.dynamic.key]: cur }), {});
+            // TODO: support dynamic and generic intertwined. treat them as one
+            return Object.assign(make({ genericMiddlewares, dynamicMiddlewares }), it);
+        }
+    };
+    return it;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWlyZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9yZXF1aXJlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLFlBQVksQ0FBQTtBQUUxQyxPQUFPLEVBQTRELGNBQWMsRUFBNEQsTUFBTSx1QkFBdUIsQ0FBQTtBQWtIMUssTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBRXlCLEdBQUcsRUFBRTtJQUMxRCxNQUFNLElBQUksR0FBRyxjQUFjLEVBQU8sQ0FBQTtJQUNsQyxJQUFJLG1CQUFtQixHQUE2RCxFQUFFLENBQUE7SUFDdEYsTUFBTSxFQUFFLEdBQUc7UUFDVCxVQUFVLEVBQUUsQ0FBQyxHQUFHLFdBQWtCLEVBQUUsRUFBRTtZQUNwQyxLQUFLLE1BQU0sRUFBRSxJQUFJLFdBQVcsRUFBRSxDQUFDO2dCQUM3QixtQkFBbUIsR0FBRyxDQUFDLEVBQUUsRUFBRSxHQUFHLG1CQUFtQixDQUFDLENBQUE7Z0JBQ2xELElBQUksRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFDO29CQUNmLE9BQU8sQ0FBQyxHQUFHLENBQUMsMkJBQTJCLEVBQUUsRUFBRSxDQUFDLEdBQUcsRUFBRSxFQUFFLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFBO2dCQUNsRSxDQUFDO3FCQUFNLENBQUM7b0JBQ04sT0FBTyxDQUFDLEdBQUcsQ0FBQywyQkFBMkIsRUFBRSxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUE7Z0JBQ2xELENBQUM7WUFDSCxDQUFDO1lBQ0QsTUFBTSxDQUFDLGtCQUFrQixFQUFFLEdBQUcsQ0FBQyxHQUFHLEtBQUssQ0FBQyxZQUFZLENBQ2xELG1CQUFtQixFQUNuQixDQUFDLEVBQUUsRUFBRSxFQUFFLENBQ0wsU0FBUyxJQUFJLEVBQUUsSUFBSSxFQUFFLENBQUMsT0FBTztnQkFDM0IsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsRUFBaUMsQ0FBQztnQkFDakQsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsRUFBNEIsQ0FBQyxDQUNoRCxDQUFBO1lBQ0QsTUFBTSxrQkFBa0IsR0FBRyxHQUFHLENBQUMsTUFBTSxDQUNuQyxDQUFDLElBQUksRUFBRSxHQUFHLEVBQUUsRUFBRSxDQUFDLENBQUMsRUFBRSxHQUFHLElBQUksRUFBRSxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUMsRUFDcEQsRUFBeUIsQ0FDMUIsQ0FBQTtZQUNELG1FQUFtRTtZQUNuRSxPQUFPLE1BQU0sQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsa0JBQWtCLEVBQUUsa0JBQWtCLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFBO1FBQzVFLENBQUM7S0FDRixDQUFBO0lBQ0QsT0FBTyxFQUFTLENBQUE7QUFDbEIsQ0FBQyxDQUFBIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"requires.test.d.ts","sourceRoot":"","sources":["../requires.test.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,KAAK,EAAK,MAAM,YAAY,CAAA;AAC7C,OAAO,EAAqB,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACrE,OAAO,EAAwD,IAAI,EAAE,QAAQ,EAAQ,MAAM,eAAe,CAAA;;;;;;;AAE1G,qBAAa,cAAe,SAAQ,mBAYlC;CACD;;;;;;;AAED,qBAAa,kBAAmB,SAAQ,uBAYtC;CACD;;;;;;;AAED,qBAAa,sBAAuB,SAAQ,2BAa1C;CACD"}

package/test/fixtures.ts

@@ -0,0 +1,85 @@
+import { Context, Effect, Option, S, Scope } from "effect-app"
+import { NotLoggedInError, type RPCContextMap, UnauthorizedError } from "effect-app/client"
+import { TaggedError } from "effect-app/Schema"
+import { contextMap, Middleware } from "../src/api/routing.js"
+
+export class UserProfile extends Context.assignTag<UserProfile, UserProfile>("UserProfile")(
+  S.Class<UserProfile>("UserProfile")({
+    id: S.String,
+    roles: S.Array(S.String)
+  })
+) {
+}
+
+export class Some extends Context.TagMakeId("Some", Effect.succeed({ a: 1 }))<Some>() {}
+export class SomeElse extends Context.TagMakeId("SomeElse", Effect.succeed({ b: 2 }))<SomeElse>() {}
+
+export type RequestContextMap = {
+  allowAnonymous: RPCContextMap.Inverted<UserProfile, typeof NotLoggedInError>
+  requireRoles: RPCContextMap.Custom<never, typeof UnauthorizedError, Array<string>>
+  test: RPCContextMap<never, typeof S.Never>
+}
+
+export class AllowAnonymous extends Middleware.Tag<AllowAnonymous>()("AllowAnonymous", {
+  dynamic: contextMap<RequestContextMap>()("allowAnonymous"),
+  requires: SomeElse
+})({
+  effect: Effect.gen(function*() {
+    return Effect.fnUntraced(
+      function*({ config, headers }) {
+        yield* SomeElse
+        yield* Scope.Scope // provided by HttpRouter.HttpRouter.Provided
+        const isLoggedIn = !!headers["x-user"]
+        if (!isLoggedIn) {
+          if (!config.allowAnonymous) {
+            return yield* new NotLoggedInError({ message: "Not logged in" })
+          }
+          return Option.none()
+        }
+        return Option.some(Context.make(
+          UserProfile,
+          { id: "whatever", roles: ["user", "manager"] }
+        ))
+      }
+    )
+  })
+}) {
+}
+
+// @effect-diagnostics-next-line missingEffectServiceDependency:off
+export class RequireRoles extends Middleware.Tag<RequireRoles>()("RequireRoles", {
+  dynamic: contextMap<RequestContextMap>()("requireRoles"),
+  // had to move this in here, because once you put it manually as a readonly static property on the class,
+  // there's a weird issue where the fluent api stops behaving properly after adding this middleware via `addDynamicMiddleware`
+  dependsOn: [AllowAnonymous]
+})({
+  effect: Effect.gen(function*() {
+    yield* Some
+    return Effect.fnUntraced(
+      function*({ config }) {
+        // we don't know if the service will be provided or not, so we use option..
+        const userProfile = yield* Effect.serviceOption(UserProfile)
+        const { requireRoles } = config
+        if (requireRoles && !userProfile.value?.roles?.some((role) => requireRoles.includes(role))) {
+          return yield* new UnauthorizedError({ message: "don't have the right roles" })
+        }
+        return Option.none<Context<never>>()
+      }
+    )
+  })
+}) {
+}
+
+export class Test extends Middleware.Tag<Test>()("Test", { dynamic: contextMap<RequestContextMap>()("test") })({
+  effect: Effect.gen(function*() {
+    return Effect.fn(function*() {
+      return Option.none<Context<never>>()
+    })
+  })
+}) {}
+
+export class CustomError1 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}
+export class CustomError2 extends TaggedError<NotLoggedInError>()("CustomError1", {}) {}
+
+const MakeSomeService = Effect.succeed({ a: 1 })
+export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)<SomeService>() {}

package/test/layerUtils.test.ts

@@ -0,0 +1,19 @@
+import { it } from "@effect/vitest"
+import { type Layer } from "effect"
+import { expectTypeOf } from "vitest/index.cjs"
+import { type LayerUtils } from "../src/api/layerUtils.js"
+
+it("works", () => {
+  type B = (Layer.Layer<void, "error-a", "a"> | Layer.Layer<void, "error-b", "b">)[]
+  type C = LayerUtils.GetLayersContext<B>
+  type CE = LayerUtils.GetLayersError<B>
+
+  expectTypeOf({} as C).toEqualTypeOf<"a" | "b">()
+  expectTypeOf({} as CE).toEqualTypeOf<"error-a" | "error-b">()
+
+  type B2 = [Layer.Layer<void, "error-a", "a">, Layer.Layer<void, "error-b", "b"> | Layer.Layer<void, "error-c", "c">]
+  type C2 = LayerUtils.GetLayersContext<B2>
+  type CE2 = LayerUtils.GetLayersError<B2>
+  expectTypeOf({} as C2).toEqualTypeOf<"a" | "b" | "c">()
+  expectTypeOf({} as CE2).toEqualTypeOf<"error-a" | "error-b" | "error-c">()
+})

package/test/query.test.ts

@@ -1,13 +1,14 @@
 /* eslint-disable unused-imports/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Context, Effect, flow, Layer, Option, pipe, S, Struct } from "effect-app"
+import { Effect, flow, Layer, Option, pipe, S, Struct } from "effect-app"
 import { inspect } from "util"
 import { expect, expectTypeOf, it } from "vitest"
 import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
 import { and, count, make, one, or, order, page, project, type QueryEnd, type QueryProjection, type QueryWhere, toFilter, where } from "../src/Model/query.js"
 import { makeRepo } from "../src/Model/Repository.js"
 import { memFilter, MemoryStoreLive } from "../src/Store/Memory.js"
+import { SomeService } from "./fixtures.js"
 
 const str = S.Struct({ _tag: S.Literal("string"), value: S.String })
 const num = S.Struct({ _tag: S.Literal("number"), value: S.Number })
@@ -25,9 +26,6 @@ export declare namespace Something {
   export interface Encoded extends S.Schema.Encoded<typeof Something> {}
 }
 
-const MakeSomeService = Effect.succeed({ a: 1 })
-export class SomeService extends Context.TagMakeId("SomeService", MakeSomeService)<SomeService>() {}
-
 const q = make<Something.Encoded>()
   .pipe( // provided automatically inside Repo.q2()
     where("displayName", "Verona"),

package/test/requires.test.ts

@@ -0,0 +1,75 @@
+import { expectTypeOf, it } from "@effect/vitest"
+import { Effect, Layer, S } from "effect-app"
+import { makeNewMiddleware, Middleware } from "../src/api/routing.js"
+import { AllowAnonymous, type RequestContextMap, RequireRoles, Some, SomeElse, Test } from "./fixtures.js"
+
+export class SomeMiddleware extends Middleware.Tag<SomeMiddleware>()("SomeMiddleware", {
+  provides: Some,
+  wrap: true
+})({
+  effect: Effect.gen(function*() {
+    // yield* Effect.context<"test-dep">()
+    return ({ next }) =>
+      Effect.gen(function*() {
+        // yield* Effect.context<"test-dep2">()
+        return yield* next.pipe(Effect.provideService(Some, new Some({ a: 1 })))
+      })
+  })
+}) {
+}
+
+export class SomeElseMiddleware extends Middleware.Tag<SomeElseMiddleware>()("SomeElseMiddleware", {
+  provides: SomeElse,
+  wrap: true
+})({
+  effect: Effect.gen(function*() {
+    // yield* Effect.context<"test-dep">()
+    return ({ next }) =>
+      Effect.gen(function*() {
+        // yield* Effect.context<"test-dep2">()
+        return yield* next.pipe(Effect.provideService(SomeElse, new SomeElse({ b: 2 })))
+      })
+  })
+}) {
+}
+
+export class RequiresSomeMiddleware extends Middleware.Tag<RequiresSomeMiddleware>()("RequiresSomeMiddleware", {
+  requires: Some,
+  wrap: true
+})({
+  effect: Effect.gen(function*() {
+    // yield* Effect.context<"test-dep">()
+    return ({ next }) =>
+      Effect.gen(function*() {
+        yield* Some
+        // yield* Effect.context<"test-dep2">()
+        return yield* next
+      })
+  })
+}) {
+}
+
+it("requires gets enforced", async () => {
+  const middleware3 = makeNewMiddleware<RequestContextMap>()
+    .middleware(RequiresSomeMiddleware)
+    .middleware(SomeMiddleware)
+    .middleware(AllowAnonymous, RequireRoles)
+    .middleware(SomeElseMiddleware)
+    .middleware(Test)
+
+  type LayerContext = Layer.Layer.Context<typeof middleware3["Default"]>
+  expectTypeOf({} as LayerContext).toEqualTypeOf<Some>()
+
+  await Effect
+    .gen(function*() {
+      const mw = yield* middleware3
+      const mwM = mw.effect(Object.assign({}, S.Any, { config: {} }), (_req) => Effect.void, "some-module")
+      yield* mwM({}, { "x-user": "test-user" })
+      // console.log({ v })
+    })
+    .pipe(
+      Effect.scoped,
+      Effect.provide(middleware3.Default.pipe(Layer.provide(Layer.succeed(Some, new Some({ a: 1 }))))),
+      Effect.runPromise
+    )
+})