effect-app 4.0.0-beta.3 → 4.0.0-beta.300

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