effect-app 4.0.0-beta.99 → 4.0.1

package/src/Pure.ts

@@ -1,7 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Chunk, Effect, Layer, Result } from "effect"
-import * as Context from "./Context.js"
-import { tuple } from "./Function.js"
+import * as Chunk from "effect/Chunk"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Result from "effect/Result"
+import * as Tuple from "effect/Tuple"
+import * as Context from "./Context.ts"
 
 const S1 = Symbol()
 const S2 = Symbol()
@@ -156,10 +159,10 @@ export function runAll<R, E, A, W3, S1, S3, S4 extends S1>(
         )
         .pipe(
           Effect.map(
-            ({ log, state }) => tuple(log, Result.succeed(tuple(state, x)))
+            ({ log, state }) => Tuple.make(log, Result.succeed(Tuple.make(state, x)))
           )
         ))
-    .pipe(Effect.catch((err: any) => tagg.useSync((env) => tuple(env.env.log, Result.fail(err)))))
+    .pipe(Effect.catch((err: any) => tagg.useSync((env) => Tuple.make(env.env.log, Result.fail(err)))))
   return Effect.provide(a, Layer.succeed(tagg, { env: makePureEnv<W3, S3, S4>(s) as any }) as any) as any
 }
 
@@ -167,7 +170,7 @@ export function runResult<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
 ) {
-  return Effect.map(runAll(self, s), ([log, r]) => tuple(log, Result.map(r, ([s]) => s)))
+  return Effect.map(runAll(self, s), ([log, r]) => Tuple.make(log, Result.map(r, ([s]) => s)))
 }
 
 export function runTerm<R, E, A, W3, S1, S3, S4 extends S1>(
@@ -176,7 +179,7 @@ export function runTerm<R, E, A, W3, S1, S3, S4 extends S1>(
 ) {
   return Effect.flatMap(
     runAll(self, s),
-    ([evts, r]) => Effect.map(Effect.fromResult(r), ([s3, a]) => tuple(s3, Chunk.toArray(evts), a))
+    ([evts, r]) => Effect.map(Effect.fromResult(r), ([s3, a]) => Tuple.make(s3, Chunk.toArray(evts), a))
   )
 }
 
@@ -184,14 +187,14 @@ export function runTermDiscard<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
 ) {
-  return Effect.map(runTerm(self, s), ([s3, w3]) => tuple(s3, w3))
+  return Effect.map(runTerm(self, s), ([s3, w3]) => Tuple.make(s3, w3))
 }
 
 export function runA<R, E, A, W3, S1, S3, S4 extends S1>(
   self: Effect.Effect<A, E, FixEnv<R, W3, S1, S3>>,
   s: S4
 ) {
-  return Effect.map(runAll(self, s), ([log, r]) => tuple(log, Result.map(r, ([, a]) => a)))
+  return Effect.map(runAll(self, s), ([log, r]) => Tuple.make(log, Result.map(r, ([, a]) => a)))
 }
 
 export function modify<S2, A, S3>(
@@ -221,14 +224,14 @@ export function modifyM<W, R, E, A, S2, S3>(
 export function updateWith<S2, S3>(upd: (s: S2) => S3) {
   return modify((_: S2) => {
     const r = upd(_)
-    return tuple(r, r)
+    return Tuple.make(r, r)
   })
 }
 
 export function updateWithEffect<W, R, E, S2, S3>(
   upd: (s: S2, log: (evt: W) => PureLogT<W>) => Effect.Effect<S3, E, FixEnv<R, W, S2, S3>>
 ): Effect.Effect<S3, E, FixEnv<R, W, S2, S3>> {
-  return modifyM((_: S2) => Effect.map(upd(_, log), (_) => tuple(_, _)))
+  return modifyM((_: S2) => Effect.map(upd(_, log), (_) => Tuple.make(_, _)))
 }
 
 export type FixEnv<R, W, S, S2> =
@@ -298,11 +301,11 @@ export type FixEnv<R, W, S, S2> =
 //   }
 
 //   function update<S3>(upd: (s: S2) => S3) {
-//     return modify(_ => tuple(upd(_), void 0 as void))
+//     return modify(_ => Tuple.make(upd(_), void 0 as void))
 //   }
 
 //   function updateM<R, E, S3>(upd: (s: S2) => Effect.Effect<R, E, S3>) {
-//     return modifyM(_ => upd(_).map(_ => tuple(_, void 0 as void)))
+//     return modifyM(_ => upd(_).map(_ => Tuple.make(_, void 0 as void)))
 //   }
 
 //   const accessLog = Effect.serviceWithEffect(tag, _ => _.env.log.get)
@@ -318,12 +321,12 @@ export type FixEnv<R, W, S, S2> =
 //       ).map(
 //         (
 //           { log, state }
-//         ) => tuple(log, Either.right(tuple(state, x)) as Either.Either<E, readonly [S3, A]>)
+//         ) => Tuple.make(log, Either.right(Tuple.make(state, x)) as Either.Either<E, readonly [S3, A]>)
 //       )
 //     ).catchAll(
 //       err =>
 //         accessLog.map(log =>
-//           tuple(log, Either.left(err) as Either.Either<E, readonly [S3, A]>)
+//           Tuple.make(log, Either.left(err) as Either.Either<E, readonly [S3, A]>)
 //         )
 //     ).provideService(tag, { env: makePureEnv<W3, S3, S4>(s) as any }) as any
 //   }
@@ -332,14 +335,14 @@ export type FixEnv<R, W, S, S2> =
 //     self: Effect.Effect<FixEnv<R, W3, S1, S3>, E, A>,
 //     s: S4
 //   ) {
-//     return runAll(self, s).map(([log, r]) => tuple(log, r.map(([s]) => s)))
+//     return runAll(self, s).map(([log, r]) => Tuple.make(log, r.map(([s]) => s)))
 //   }
 
 //   function runA<R, E, A, W3, S1, S3, S4 extends S1>(
 //     self: Effect.Effect<FixEnv<R, W3, S1, S3>, E, A>,
 //     s: S4
 //   ) {
-//     return runAll(self, s).map(([log, r]) => tuple(log, r.map(([, a]) => a)))
+//     return runAll(self, s).map(([log, r]) => Tuple.make(log, r.map(([, a]) => a)))
 //   }
 
 //   return {

package/src/QueueMaker.ts

@@ -0,0 +1,11 @@
+import { RequestContext } from "./RequestContext.ts"
+
+/**
+ * Per-message context envelope (tenant/store id, request metadata) carried
+ * alongside message-schema payloads. Alias of {@link RequestContext}.
+ *
+ * All that remains of the former queue machinery (SB/SQLite/mem `QueueMaker`
+ * implementations and the `QueueBase` interface) after the move to cluster
+ * entities — the message schemas that embed it still reference this envelope.
+ */
+export const QueueMeta = RequestContext

package/src/RequestContext.ts

@@ -0,0 +1,48 @@
+import * as Context from "./Context.ts"
+import { UserProfileId } from "./ids.ts"
+import * as S from "./Schema.ts"
+import { NonEmptyString255 } from "./Schema.ts"
+
+export const Locale = S.Literals(["en", "de"])
+export type Locale = typeof Locale.Type
+
+export class LocaleRef extends Context.Reference("Locale", { defaultValue: (): Locale => "en" }) {}
+
+export class RequestContext extends S.Opaque<RequestContext>()(S.Struct({
+  span: S.Struct({
+    traceId: S.String,
+    spanId: S.String,
+    sampled: S.Boolean
+  }),
+  name: NonEmptyString255,
+  locale: Locale,
+  sourceId: S.optional(NonEmptyString255), // TODO?
+  namespace: NonEmptyString255,
+  /** @deprecated */
+  userProfile: S.optional(S.Struct({ sub: UserProfileId })) //
+})) {
+  static toMonitoring(this: void, self: RequestContext) {
+    return {
+      operationName: self.name,
+      locale: self.locale
+    }
+  }
+}
+
+export const spanAttributes = (ctx: Pick<RequestContext, "locale" | "namespace"> & Partial<RequestContext>) => ({
+  "code.function.name": ctx.name,
+  "app.locale": ctx.locale,
+  "app.tenant.id": ctx.namespace,
+  ...ctx.sourceId ? { "client.id": ctx.sourceId } : {},
+  ...(ctx.userProfile?.sub
+    ? {
+      "user.id": ctx
+        .userProfile
+        .sub,
+      "user.roles": "roles" in ctx
+          .userProfile
+        ? ctx.userProfile.roles
+        : undefined
+    }
+    : {})
+})

package/src/RequestScopedDependencies.ts

@@ -0,0 +1,45 @@
+import * as Data from "effect/Data"
+import type * as Scope from "effect/Scope"
+import * as Context from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import * as Layer from "./Layer.ts"
+
+export type Root = "root"
+
+export class RequestScopedDependencyNotStartedError extends Data.TaggedError(
+  "RequestScopedDependencyNotStartedError"
+)<{ readonly key: string }> {}
+
+export interface RequestScopedDependency<Service, E = never, R = never> extends Context.Reference<Service | Root> {
+  readonly current: Effect.Effect<Service, RequestScopedDependencyNotStartedError>
+  readonly layer: Layer.Layer<never, E, R>
+}
+
+export const access = <Service>(
+  dependency: Context.Reference<Service | Root>,
+  key: string
+): Effect.Effect<Service, RequestScopedDependencyNotStartedError> =>
+  dependency.pipe(
+    Effect.filterOrFail((_): _ is Service => _ !== "root", () => new RequestScopedDependencyNotStartedError({ key }))
+  )
+
+export const make = <Service, E = never, R = never>(
+  key: string,
+  service: Effect.Effect<Service, E, R>
+): RequestScopedDependency<Service, E, Exclude<R, Scope.Scope>> => {
+  const dependency = Context.Reference<Service | Root>(key, { defaultValue: () => "root" })
+  return Object.assign(dependency, {
+    current: access(dependency, key),
+    layer: Layer.effect(dependency, service)
+  })
+}
+
+export const layer = <
+  Deps extends readonly [RequestScopedDependency<any, any, any>, ...Array<RequestScopedDependency<any, any, any>>]
+>(
+  ...dependencies: Deps
+): Layer.Layer<
+  never,
+  { [K in keyof Deps]: Deps[K] extends RequestScopedDependency<any, infer E, any> ? E : never }[number],
+  { [K in keyof Deps]: Deps[K] extends RequestScopedDependency<any, any, infer R> ? R : never }[number]
+> => dependencies.map((_) => _.layer).reduce((acc, l) => Layer.merge(acc, l)) as any