@effect-app/infra 4.0.0-beta.8 → 4.0.0-beta.81

package/test/fixtures.ts

@@ -1,9 +1,9 @@
-import { Effect, Layer, S, Scope, ServiceMap } from "effect-app"
+import { Context, Effect, Layer, S, Scope } from "effect-app"
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client"
 import { RpcContextMap, RpcX } from "effect-app/rpc"
-import { TaggedError } from "effect-app/Schema"
+import { TaggedErrorClass } from "effect-app/Schema"
 
-export class UserProfile extends ServiceMap.assignTag<UserProfile, UserProfile>("UserProfile")(
+export class UserProfile extends Context.assignTag<UserProfile, UserProfile>("UserProfile")(
   S.Class<UserProfile>("UserProfile")({
     id: S.String,
     roles: S.Array(S.String)
@@ -11,10 +11,10 @@ export class UserProfile extends ServiceMap.assignTag<UserProfile, UserProfile>(
 ) {
 }
 
-export class Some extends ServiceMap.Opaque<Some>()("Some", { make: Effect.succeed({ a: 1 }) }) {}
-export class SomeElse extends ServiceMap.Opaque<SomeElse>()("SomeElse", { make: Effect.succeed({ b: 2 }) }) {}
+export class Some extends Context.Opaque<Some>()("Some", { make: Effect.succeed({ a: 1 }) }) {}
+export class SomeElse extends Context.Opaque<SomeElse>()("SomeElse", { make: Effect.succeed({ b: 2 }) }) {}
 const MakeSomeService = Effect.succeed({ a: 1 })
-export class SomeService extends ServiceMap.Opaque<SomeService>()("SomeService", { make: MakeSomeService }) {
+export class SomeService extends Context.Opaque<SomeService>()("SomeService", { make: MakeSomeService }) {
   static readonly Default = this.toLayer(this.make)
 }
 
@@ -128,5 +128,7 @@ export const TestLive = Layer.effect(
   })
 )
 
-export class CustomError1 extends TaggedError<CustomError1>()("CustomError1", {}) {}
-export class CustomError2 extends TaggedError<CustomError2>()("CustomError2", {}) {}
+export class Counter extends Context.Opaque<Counter>()("Counter", { make: Effect.succeed({ a: 0 }) }) {}
+
+export class CustomError1 extends TaggedErrorClass<CustomError1>()("CustomError1", {}) {}
+export class CustomError2 extends TaggedErrorClass<CustomError2>()("CustomError2", {}) {}

package/test/query.test.ts

@@ -1,7 +1,8 @@
 /* eslint-disable unused-imports/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, flow, Layer, Option, pipe, S, ServiceMap, Struct } from "effect-app"
+import { SchemaTransformation } from "effect"
+import { Context, 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"
@@ -11,7 +12,7 @@ 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 })
+const num = S.Struct({ _tag: S.Literal("number"), value: S.Finite })
 const someUnion = S.Union([str, num])
 
 export class Something extends S.Class<Something>("Something")({
@@ -19,7 +20,7 @@ export class Something extends S.Class<Something>("Something")({
   displayName: S.NonEmptyString255,
   name: S.NullOr(S.NonEmptyString255).withDefault,
   n: S.Date.withDefault,
-  union: someUnion.pipe(S.withDefaultConstructor(() => ({ _tag: "string" as const, value: "hi" })))
+  union: someUnion.pipe(S.withConstructorDefault(Effect.succeed({ _tag: "string" as const, value: "hi" })))
 }) {}
 export declare namespace Something {
   // eslint-disable-next-line @typescript-eslint/no-empty-object-type
@@ -91,7 +92,7 @@ it("works", () => {
   const processed = memFilter(interpreted)(items.map((_) =>
     S.encodeUnknownSync(S.Struct({
       ...Something.omit("displayName"),
-      displayName: S.Literal("Verona", "Riley")
+      displayName: S.Literals(["Verona", "Riley"])
     }))(_)
   ))
 
@@ -99,7 +100,7 @@ it("works", () => {
 })
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class SomethingRepo extends ServiceMap.Service<SomethingRepo>()("SomethingRepo", {
+class SomethingRepo extends Context.Service<SomethingRepo>()("SomethingRepo", {
   make: Effect.gen(function*() {
     return yield* makeRepo("Something", Something, {})
   })
@@ -156,8 +157,6 @@ it("works with repo", () =>
 
       expectTypeOf(smtArr).toEqualTypeOf<readonly Something[]>()
 
-      console.log(" $$$$$$")
-      console.log(Struct.pick(["id", "displayName"]))
       expect(q1).toEqual(items.slice(0, 2).toReversed().map(Struct.pick(["id", "displayName"])))
       expect(q2).toEqual(items.slice(0, 2).toReversed().map(Struct.pick(["displayName"])))
     })
@@ -521,8 +520,8 @@ it(
         const schema = S.Struct({
           id: S.String,
           createdAt: S.Date.pipe(
-            S.withDecodingDefault(() => new Date().toISOString()),
-            S.withConstructorDefault(() => Option.some(new Date()))
+            S.withDecodingDefault(Effect.sync(() => new Date().toISOString())),
+            S.withConstructorDefault(Effect.sync(() => new Date()))
           )
         })
         const repo = yield* makeRepo(
@@ -534,8 +533,8 @@ it(
         const outputSchema = S.Struct({
           id: S.Literal("123"),
           createdAt: S.Date.pipe(
-            S.withDecodingDefault(() => new Date().toISOString()),
-            S.withConstructorDefault(() => Option.some(new Date()))
+            S.withDecodingDefault(Effect.sync(() => new Date().toISOString())),
+            S.withConstructorDefault(Effect.sync(() => new Date()))
           )
         })
 
@@ -553,7 +552,7 @@ it(
       .gen(function*() {
         const schema = S.Struct({
           id: S.String,
-          literals: S.Literal("a", "b", "c")
+          literals: S.Literals(["a", "b", "c"])
         })
 
         type Schema = typeof schema.Type
@@ -583,7 +582,7 @@ it(
       .gen(function*() {
         const schema = S.Struct({
           id: S.String,
-          literals: S.Union([S.Literal("a", "b", "c"), S.Null])
+          literals: S.Union([S.Literals(["a", "b", "c"]), S.Null])
         })
 
         type Schema = typeof schema.Type
@@ -674,7 +673,7 @@ it("remove null from one constituent of a tagged union", () =>
 
       class BB extends S.Class<BB>("BB")({
         id: S.Literal("BB"),
-        b: S.NullOr(S.Number)
+        b: S.NullOr(S.Finite)
       }) {}
 
       type Union = AA | BB
@@ -984,6 +983,153 @@ it("refine nested union", () =>
     })
     .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
 
+it("find with transformed id", () =>
+  Effect
+    .gen(function*() {
+      const ConfiguratorId = S.NonEmptyString255
+
+      class PreconfigurationId extends S.Class<PreconfigurationId>("PreconfigurationId")({
+        configuratorId: ConfiguratorId,
+        label: S.NonEmptyString50
+      }) {}
+
+      const PreconfigurationIdFromString = S.NonEmptyString255.pipe(
+        S.decodeTo(
+          S.toType(PreconfigurationId),
+          SchemaTransformation.transformOrFail({
+            decode: Effect.fnUntraced(function*(value) {
+              const values = value.split("_")
+              const label = yield* S.SchemaParser.decodeUnknownEffect(S.NonEmptyString50)(values.pop())
+              const configuratorId = yield* S.SchemaParser.decodeUnknownEffect(ConfiguratorId)(values.join("_"))
+              return new PreconfigurationId({ configuratorId, label })
+            }),
+            encode: (id) => Effect.succeed(S.NonEmptyString255(`${id.configuratorId}_${id.label}`))
+          })
+        ),
+        S.revealCodec
+      )
+
+      const Preconfiguration = S.Struct({
+        id: PreconfigurationIdFromString,
+        name: S.String
+      })
+
+      const repo = yield* makeRepo("Preconfiguration", Preconfiguration, { idKey: "id" as const })
+
+      const id = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("myConfigurator"),
+        label: S.NonEmptyString50("myLabel")
+      })
+      const item = { id, name: "test preconfig" }
+
+      yield* repo.saveAndPublish([item])
+
+      const found = yield* repo.find(id)
+      expect(Option.isSome(found)).toBe(true)
+      expect(Option.getOrThrow(found).name).toBe("test preconfig")
+      expect(Option.getOrThrow(found).id).toEqual(id)
+
+      const notFound = yield* repo.find(
+        new PreconfigurationId({
+          configuratorId: S.NonEmptyString255("other"),
+          label: S.NonEmptyString50("nope")
+        })
+      )
+      expect(Option.isNone(notFound)).toBe(true)
+    })
+    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+
+it("find with transformed id in tagged union", () =>
+  Effect
+    .gen(function*() {
+      const ConfiguratorId = S.NonEmptyString255
+
+      class PreconfigurationId extends S.Class<PreconfigurationId>("PreconfigurationId")({
+        configuratorId: ConfiguratorId,
+        label: S.NonEmptyString50
+      }) {}
+
+      const PreconfigurationIdFromString = S.NonEmptyString255.pipe(
+        S.decodeTo(
+          S.toType(PreconfigurationId),
+          SchemaTransformation.transformOrFail({
+            decode: Effect.fnUntraced(function*(value) {
+              const values = value.split("_")
+              const label = yield* S.SchemaParser.decodeUnknownEffect(S.NonEmptyString50)(values.pop())
+              const configuratorId = yield* S.SchemaParser.decodeUnknownEffect(ConfiguratorId)(values.join("_"))
+              return new PreconfigurationId({ configuratorId, label })
+            }),
+            encode: (id) => Effect.succeed(S.NonEmptyString255(`${id.configuratorId}_${id.label}`))
+          })
+        ),
+        S.revealCodec
+      )
+
+      class Draft extends S.TaggedClass<Draft>()("Draft", {
+        id: PreconfigurationIdFromString,
+        name: S.String
+      }) {}
+
+      class Published extends S.TaggedClass<Published>()("Published", {
+        id: PreconfigurationIdFromString,
+        name: S.String,
+        publishedAt: S.String
+      }) {}
+
+      class Archived extends S.TaggedClass<Archived>()("Archived", {
+        id: PreconfigurationIdFromString,
+        name: S.String,
+        archivedAt: S.String
+      }) {}
+
+      const Preconfiguration = S.Union([Draft, Published, Archived])
+
+      const repo = yield* makeRepo("Preconfiguration", Preconfiguration, {})
+
+      const id1 = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("conf1"),
+        label: S.NonEmptyString50("draft1")
+      })
+      const id2 = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("conf2"),
+        label: S.NonEmptyString50("pub1")
+      })
+      const id3 = new PreconfigurationId({
+        configuratorId: S.NonEmptyString255("conf3"),
+        label: S.NonEmptyString50("arch1")
+      })
+
+      const draft = new Draft({ id: id1, name: "my draft" })
+      const published = new Published({ id: id2, name: "my published", publishedAt: "2024-01-01" })
+      const archived = new Archived({ id: id3, name: "my archived", archivedAt: "2024-06-01" })
+
+      yield* repo.saveAndPublish([draft, published, archived])
+
+      // find each by their PreconfigurationId instance
+      const foundDraft = yield* repo.find(id1)
+      expect(Option.isSome(foundDraft)).toBe(true)
+      expect(Option.getOrThrow(foundDraft)._tag).toBe("Draft")
+      expect(Option.getOrThrow(foundDraft).name).toBe("my draft")
+
+      const foundPublished = yield* repo.find(id2)
+      expect(Option.isSome(foundPublished)).toBe(true)
+      expect(Option.getOrThrow(foundPublished)._tag).toBe("Published")
+
+      const foundArchived = yield* repo.find(id3)
+      expect(Option.isSome(foundArchived)).toBe(true)
+      expect(Option.getOrThrow(foundArchived)._tag).toBe("Archived")
+
+      // not found
+      const notFound = yield* repo.find(
+        new PreconfigurationId({
+          configuratorId: S.NonEmptyString255("nope"),
+          label: S.NonEmptyString50("nope")
+        })
+      )
+      expect(Option.isNone(notFound)).toBe(true)
+    })
+    .pipe(Effect.provide(MemoryStoreLive), setupRequestContextFromCurrent(), Effect.runPromise))
+
 it("refine union with nested union", () =>
   Effect
     .gen(function*() {

package/test/rawQuery.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "@effect/vitest"
-import { Array, Config, Effect, flow, Layer, ManagedRuntime, Redacted, References, Result, S, ServiceMap } from "effect-app"
+import { Array, Config, Effect, flow, Layer, ManagedRuntime, Redacted, References, Result, S, Context } from "effect-app"
 import { LogLevels } from "effect-app/utils"
 import { setupRequestContextFromCurrent } from "../src/api/setupRequest.js"
 import { and, or, project, where, whereEvery, whereSome } from "../src/Model/query.js"
@@ -24,7 +24,7 @@ class Something extends S.Class<Something>("Something")({
   id: S.String,
   name: S.String,
   description: S.String,
-  items: S.Array(S.Struct({ id: S.String, value: S.Number, description: S.String }))
+  items: S.Array(S.Struct({ id: S.String, value: S.Finite, description: S.String }))
 }) {}
 
 const items = [
@@ -49,7 +49,7 @@ const items = [
 ]
 
 // @effect-diagnostics-next-line missingEffectServiceDependency:off
-class SomethingRepo extends ServiceMap.Service<SomethingRepo>()(
+class SomethingRepo extends Context.Service<SomethingRepo>()(
   "SomethingRepo",
   {
     make: Effect.gen(function*() {
@@ -83,21 +83,23 @@ class SomethingRepo extends ServiceMap.Service<SomethingRepo>()(
     .layer
     .pipe(
       Layer.provide(
-        Effect.gen(function*() {
-          const url = yield* Config.redacted("STORAGE_URL").pipe(
-            Config.withDefault(
-              Redacted.make(
-                // the emulator doesn't implement array projections :/ so you need an actual cloud instance!
-                "AccountEndpoint=http://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
+        Effect
+          .gen(function*() {
+            const url = yield* Config.redacted("STORAGE_URL").pipe(
+              Config.withDefault(
+                Redacted.make(
+                  // the emulator doesn't implement array projections :/ so you need an actual cloud instance!
+                  "AccountEndpoint=http://localhost:8081/;AccountKey=C2y6yDjf5/R+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="
+                )
               )
             )
-          )
-          return CosmosStoreLayer({
-            dbName: "test",
-            prefix: "",
-            url
+            return CosmosStoreLayer({
+              dbName: "test",
+              prefix: "",
+              url
+            })
           })
-        }).pipe(Layer.unwrap)
+          .pipe(Layer.unwrap)
       )
     )
 }
@@ -107,7 +109,7 @@ describe("select first-level array fields", () => {
     .gen(function*() {
       const repo = yield* SomethingRepo
 
-      const projected = S.Struct({ name: S.String, items: S.Array(S.Struct({ id: S.String, value: S.Number })) })
+      const projected = S.Struct({ name: S.String, items: S.Array(S.Struct({ id: S.String, value: S.Finite })) })
 
       // ok crazy lol, "value" is a reserved word in CosmosDB, so we have to use t["value"] as a field name instead of t.value
       const items = yield* repo.queryRaw(projected, {
@@ -159,7 +161,7 @@ describe("select first-level array fields", () => {
       .pipe(Effect.provide(SomethingRepo.Test), rt.runPromise))
 })
 
-const projected = S.Struct({ name: S.String, items: S.Array(S.Struct({ id: S.String, value: S.Number })) })
+const projected = S.Struct({ name: S.String, items: S.Array(S.Struct({ id: S.String, value: S.Finite })) })
 
 const expected = [
   {

package/test/requires.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, expectTypeOf, it } from "@effect/vitest"
-import { Effect, Layer, Result, S, ServiceMap } from "effect-app"
+import { Context, Effect, Layer, Result, S } from "effect-app"
 import { NotLoggedInError, UnauthorizedError } from "effect-app/client"
 import { HttpHeaders } from "effect-app/http"
 import * as RpcX from "effect-app/rpc"
@@ -63,11 +63,12 @@ const testSuite = (_mw: typeof middleware3) =>
       "works",
       Effect.fn(function*() {
         const defaultOpts = {
+          client: null as any, // TODO?
           headers: HttpHeaders.fromRecordUnsafe({}),
           payload: { _tag: "Test" },
           clientId: 0,
           requestId: "test-id" as any,
-          rpc: { ...TestRpc, annotations: ServiceMap.make(_mw.requestContext, {}) }
+          rpc: { ...TestRpc, annotations: Context.make(_mw.requestContext, {}) }
         }
         const next = Effect.void as unknown as Effect.Effect<SuccessValue, unhandled, never>
         const layer = _mw.layer.pipe(
@@ -89,7 +90,7 @@ const testSuite = (_mw: typeof middleware3) =>
                 headers: HttpHeaders.fromRecordUnsafe({ "x-user": "test-user", "x-is-manager": "true" }),
                 rpc: {
                   ...defaultOpts.rpc,
-                  annotations: ServiceMap.make(_mw.requestContext, { requireRoles: ["manager"] })
+                  annotations: Context.make(_mw.requestContext, { requireRoles: ["manager"] })
                 }
               })
             )
@@ -127,7 +128,7 @@ const testSuite = (_mw: typeof middleware3) =>
                 Object.assign({ ...defaultOpts }, {
                   rpc: {
                     ...defaultOpts.rpc,
-                    annotations: ServiceMap.make(_mw.requestContext, { requireRoles: ["manager"] })
+                    annotations: Context.make(_mw.requestContext, { requireRoles: ["manager"] })
                   }
                 })
               )
@@ -153,7 +154,7 @@ const testSuite = (_mw: typeof middleware3) =>
                   {
                     rpc: {
                       ...defaultOpts.rpc,
-                      annotations: ServiceMap.make(_mw.requestContext, { requireRoles: ["manager"] })
+                      annotations: Context.make(_mw.requestContext, { requireRoles: ["manager"] })
                     }
                   }
                 )

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

@@ -1,14 +1,14 @@
 import { NodeHttpServer } from "@effect/platform-node"
 import { expect, expectTypeOf, it } from "@effect/vitest"
-import { Console, Effect, Layer, Result } from "effect"
-import { S } from "effect-app"
+import { Console, Effect, Layer, Ref, Result } from "effect"
+import { Context, S } from "effect-app"
 import { NotLoggedInError } from "effect-app/client"
 import { HttpRouter } from "effect-app/http"
 import { DefaultGenericMiddlewares } from "effect-app/middleware"
 import { MiddlewareMaker } from "effect-app/rpc"
 import { middlewareGroup } from "effect-app/rpc/MiddlewareMaker"
 import { FetchHttpClient } from "effect/unstable/http"
-import { RpcClient, RpcGroup, RpcSerialization, RpcServer, RpcTest } from "effect/unstable/rpc"
+import { Rpc, RpcClient, RpcGroup, RpcSerialization, RpcServer, RpcTest } from "effect/unstable/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"
@@ -109,7 +109,7 @@ export const RpcRealLayer = Layer
         Layer.provide(FetchHttpClient.layer)
       )
   )
-  .pipe(Layer.provide(RpcSerialization.layerJson))
+  .pipe(Layer.provide(RpcSerialization.layerNdjson))
 
 it.live(
   "require login",
@@ -136,3 +136,72 @@ it.live(
     Effect.provide(RpcTestLayer)
   )
 )
+
+// Per-request service isolation test
+
+class PerRequestCounter extends Context.Service<PerRequestCounter>()(
+  "PerRequestCounter",
+  { make: Effect.sync(() => ({ a: 0 })) }
+) {
+  static Default = Layer.effect(this, this.make)
+}
+
+class GlobalCounter extends Context.Service<GlobalCounter, {
+  readonly ref: Ref.Ref<number>
+}>()("GlobalCounter") {}
+
+const CounterRpcs = RpcGroup.make(
+  Rpc.make("incrementA", {
+    success: S.Number
+  }),
+  Rpc.make("incrementB", {
+    success: S.Number
+  })
+)
+
+const counterImpl = CounterRpcs
+  .toLayer({
+    incrementA: Effect.fn(function*() {
+      const counter = yield* PerRequestCounter
+      counter.a++
+      const global = yield* GlobalCounter
+      yield* Ref.update(global.ref, (n) => n + 1)
+      return counter.a
+    }, Effect.provide(PerRequestCounter.Default)),
+    incrementB: Effect.fn(function*() {
+      const counter = yield* PerRequestCounter
+      counter.a++
+      const global = yield* GlobalCounter
+      yield* Ref.update(global.ref, (n) => n + 1)
+      return counter.a
+    }, Effect.provide(PerRequestCounter.Default))
+  })
+
+const GlobalCounterLive = Layer.effect(
+  GlobalCounter,
+  Ref.make(0).pipe(Effect.map((ref) => ({ ref })))
+)
+
+const CounterTestLayer = counterImpl.pipe(Layer.provideMerge(GlobalCounterLive))
+
+it.live(
+  "per-request service isolation with shared global counter",
+  Effect.fnUntraced(
+    function*() {
+      const client = yield* RpcTest.makeClient(CounterRpcs)
+      const global = yield* GlobalCounter
+
+      const r1 = yield* client.incrementA()
+      const r2 = yield* client.incrementB()
+
+      // per-request counter is fresh each time → both return 1
+      expect(r1).toBe(1)
+      expect(r2).toBe(1)
+
+      // global counter is shared across requests → accumulates to 2
+      const globalCount = yield* Ref.get(global.ref)
+      expect(globalCount).toBe(2)
+    },
+    Effect.provide(CounterTestLayer)
+  )
+)

package/test/validateSample.test.ts

@@ -138,7 +138,7 @@ describe("validateSample", () => {
         // schema that expects a 'status' field
         class ItemWithStatus extends S.Class<ItemWithStatus>("ItemWithStatus")({
           id: S.String,
-          status: S.Literal("active", "inactive")
+          status: S.Literals(["active", "inactive"])
         }) {}
 
         // jitM that adds default status for items

package/tsconfig.json

@@ -32,7 +32,6 @@
     "outDir": "build/dist",
     "resolveJsonModule": true,
     "moduleResolution": "Node16",
-    "downlevelIteration": true,
     "noErrorTruncation": true,
     "forceConsistentCasingInFileNames": true,
     "types": [