MAINHACK

Viewing / Editing File: LayerMap.ts

/**
 * @since 3.14.0
 * @experimental
 */
import * as Context from "./Context.js"
import type * as Duration from "./Duration.js"
import * as Effect from "./Effect.js"
import * as FiberRefsPatch from "./FiberRefsPatch.js"
import { identity } from "./Function.js"
import * as core from "./internal/core.js"
import * as Layer from "./Layer.js"
import * as RcMap from "./RcMap.js"
import * as Runtime from "./Runtime.js"
import * as Scope from "./Scope.js"
import type { Mutable, NoExcessProperties } from "./Types.js"

/**
 * @since 3.14.0
 * @category Symbols
 */
export const TypeId: unique symbol = Symbol.for("effect/LayerMap")

/**
 * @since 3.14.0
 * @category Symbols
 */
export type TypeId = typeof TypeId

/**
 * @since 3.14.0
 * @category Models
 * @experimental
 */
export interface LayerMap<in K, in out I, out E = never> {
 readonly [TypeId]: TypeId

/**
 * The internal RcMap that stores the resources.
 */
 readonly rcMap: RcMap.RcMap<K, {
 readonly layer: Layer.Layer<I, E>
 readonly runtimeEffect: Effect.Effect<Runtime.Runtime, E, Scope.Scope>
 }, E>

/**
 * Retrieves a Layer for the resources associated with the key.
 */
 get(key: K): Layer.Layer<I, E>

/**
 * Retrieves a Runtime for the resources associated with the key.
 */
 runtime(key: K): Effect.Effect<Runtime.Runtime, E, Scope.Scope>

/**
 * Invalidates the resource associated with the key.
 */
 invalidate(key: K): Effect.Effect<void>
}

/**
 * @since 3.14.0
 * @category Constructors
 * @experimental
 *
 * A `LayerMap` allows you to create a map of Layer's that can be used to
 * dynamically access resources based on a key.
 *
 * ```ts
 * import { NodeRuntime } from "@effect/platform-node"
 * import { Context, Effect, FiberRef, Layer, LayerMap } from "effect"
 *
 * class Greeter extends Context.Tag("Greeter")<Greeter, {
 * greet: Effect.Effect<string>
 * }>() {}
 *
 * // create a service that wraps a LayerMap
 * class GreeterMap extends LayerMap.Service<GreeterMap>()("GreeterMap", {
 * // define the lookup function for the layer map
 * //
 * // The returned Layer will be used to provide the Greeter service for the
 * // given name.
 * lookup: (name: string) =>
 * Layer.succeed(Greeter, {
 * greet: Effect.succeed(`Hello, ${name}!`)
 * }).pipe(
 * Layer.merge(Layer.locallyScoped(FiberRef.currentConcurrency, 123))
 * ),
 *
 * // If a layer is not used for a certain amount of time, it can be removed
 * idleTimeToLive: "5 seconds",
 *
 * // Supply the dependencies for the layers in the LayerMap
 * dependencies: []
 * }) {}
 *
 * // usage
 * const program: Effect.Effect<void, never, GreeterMap> = Effect.gen(function*() {
 * // access and use the Greeter service
 * const greeter = yield* Greeter
 * yield* Effect.log(yield* greeter.greet)
 * }).pipe(
 * // use the GreeterMap service to provide a variant of the Greeter service
 * Effect.provide(GreeterMap.get("John"))
 * )
 *
 * // run the program
 * program.pipe(
 * Effect.provide(GreeterMap.Default),
 * NodeRuntime.runMain
 * )
 * ```
 */
export const make: <
 K,
 L extends Layer.Layer<any, any, any>,
 PreloadKeys extends Iterable<K> | undefined = undefined
>(
 lookup: (key: K) => L,
 options?: {
 readonly idleTimeToLive?: Duration.DurationInput | undefined
 readonly preloadKeys?: PreloadKeys
 } | undefined
) => Effect.Effect<
 LayerMap<
 K,
 L extends Layer.Layer<infer _A, infer _E, infer _R> ? _A : never,
 L extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never
 >,
 PreloadKeys extends undefined ? never : L extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never,
 Scope.Scope | (L extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never)
> = Effect.fnUntraced(function*<I, K, EL, RL>(
 lookup: (key: K) => Layer.Layer<I, EL, RL>,
 options?: {
 readonly idleTimeToLive?: Duration.DurationInput | undefined
 readonly preloadKeys?: Iterable<K> | undefined
 } | undefined
) {
 const context = yield* Effect.context<never>()

// If we are inside another layer build, use the current memo map,
  // otherwise create a new one.
  const memoMap = context.unsafeMap.has(Layer.CurrentMemoMap.key)
    ? Context.get(context, Layer.CurrentMemoMap)
    : yield* Layer.makeMemoMap

const rcMap = yield* RcMap.make({
 lookup: (key: K) =>
 Effect.scopeWith((scope) => Effect.diffFiberRefs(Layer.buildWithMemoMap(lookup(key), memoMap, scope))).pipe(
 Effect.map(([patch, context]) => ({
 layer: Layer.scopedContext(
 core.withFiberRuntime<Context.Context, any, Scope.Scope>((fiber) => {
 const scope = Context.unsafeGet(fiber.currentContext, Scope.Scope)
 const oldRefs = fiber.getFiberRefs()
 const newRefs = FiberRefsPatch.patch(patch, fiber.id(), oldRefs)
 const revert = FiberRefsPatch.diff(newRefs, oldRefs)
 fiber.setFiberRefs(newRefs)
 return Effect.as(
 Scope.addFinalizerExit(scope, () => {
 fiber.setFiberRefs(FiberRefsPatch.patch(revert, fiber.id(), fiber.getFiberRefs()))
 return Effect.void
 }),
 context
 )
 })
 ),
 runtimeEffect: Effect.withFiberRuntime<Runtime.Runtime, any, Scope.Scope>((fiber) => {
 const fiberRefs = FiberRefsPatch.patch(patch, fiber.id(), fiber.getFiberRefs())
 return Effect.succeed(Runtime.make({
 context,
 fiberRefs,
 runtimeFlags: Runtime.defaultRuntime.runtimeFlags
 }))
 })
 } as const))
 ),
 idleTimeToLive: options?.idleTimeToLive
 })

if (options?.preloadKeys) {
 for (const key of options.preloadKeys) {
 yield* (RcMap.get(rcMap, key) as Effect.Effect<any, EL, RL | Scope.Scope>)
 }
 }

return identity<LayerMap<K, Exclude<I, Scope.Scope>, any>>({
 [TypeId]: TypeId,
 rcMap,
 get: (key) => Layer.unwrapScoped(Effect.map(RcMap.get(rcMap, key), ({ layer }) => layer)),
 runtime: (key) => Effect.flatMap(RcMap.get(rcMap, key), ({ runtimeEffect }) => runtimeEffect),
 invalidate: (key) => RcMap.invalidate(rcMap, key)
 })
})

/**
 * @since 3.14.0
 * @category Constructors
 * @experimental
 */
export const fromRecord = <
 const Layers extends Record<string, Layer.Layer<any, any, any>>,
 const Preload extends boolean = false
>(
 layers: Layers,
 options?: {
 readonly idleTimeToLive?: Duration.DurationInput | undefined
 readonly preload?: Preload | undefined
 } | undefined
): Effect.Effect<
 LayerMap<
 keyof Layers,
 Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _A : never,
 Preload extends true ? never : Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never
 >,
 Preload extends true ? never : Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never,
 Scope.Scope | (Layers[keyof Layers] extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never)
> =>
 make((key: keyof Layers) => layers[key], {
 ...options,
 preloadKeys: options?.preload ? Object.keys(layers) : undefined
 }) as any

/**
 * @since 3.14.0
 * @category Service
 */
export interface TagClass<
 in out Self,
 in out Id extends string,
 in out K,
 in out I,
 in out E,
 in out R,
 in out LE,
 in out Deps extends Layer.Layer<any, any, any>
> extends Context.TagClass<Self, Id, LayerMap<K, I, E>> {
 /**
 * A default layer for the `LayerMap` service.
 */
 readonly Default: Layer.Layer<
 Self,
 (Deps extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never) | LE,
 | Exclude<R, (Deps extends Layer.Layer<infer _A, infer _E, infer _R> ? _A : never)>
 | (Deps extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never)
 >

/**
 * A default layer for the `LayerMap` service without the dependencies provided.
 */
 readonly DefaultWithoutDependencies: Layer.Layer<Self, LE, R>

/**
 * Retrieves a Layer for the resources associated with the key.
 */
 readonly get: (key: K) => Layer.Layer<I, E, Self>

/**
 * Retrieves a Runtime for the resources associated with the key.
 */
 readonly runtime: (key: K) => Effect.Effect<Runtime.Runtime, E, Scope.Scope | Self>

/**
 * Invalidates the resource associated with the key.
 */
 readonly invalidate: (key: K) => Effect.Effect<void, never, Self>
}

/**
 * @since 3.14.0
 * @category Service
 * @experimental
 *
 * Create a `LayerMap` service that provides a dynamic set of resources based on
 * a key.
 *
 * ```ts
 * import { NodeRuntime } from "@effect/platform-node"
 * import { Context, Effect, FiberRef, Layer, LayerMap } from "effect"
 *
 * class Greeter extends Context.Tag("Greeter")<Greeter, {
 * greet: Effect.Effect<string>
 * }>() {}
 *
 * // create a service that wraps a LayerMap
 * class GreeterMap extends LayerMap.Service<GreeterMap>()("GreeterMap", {
 * // define the lookup function for the layer map
 * //
 * // The returned Layer will be used to provide the Greeter service for the
 * // given name.
 * lookup: (name: string) =>
 * Layer.succeed(Greeter, {
 * greet: Effect.succeed(`Hello, ${name}!`)
 * }).pipe(
 * Layer.merge(Layer.locallyScoped(FiberRef.currentConcurrency, 123))
 * ),
 *
 * // If a layer is not used for a certain amount of time, it can be removed
 * idleTimeToLive: "5 seconds",
 *
 * // Supply the dependencies for the layers in the LayerMap
 * dependencies: []
 * }) {}
 *
 * // usage
 * const program: Effect.Effect<void, never, GreeterMap> = Effect.gen(function*() {
 * // access and use the Greeter service
 * const greeter = yield* Greeter
 * yield* Effect.log(yield* greeter.greet)
 * }).pipe(
 * // use the GreeterMap service to provide a variant of the Greeter service
 * Effect.provide(GreeterMap.get("John"))
 * )
 *
 * // run the program
 * program.pipe(
 * Effect.provide(GreeterMap.Default),
 * NodeRuntime.runMain
 * )
 * ```
 */
export const Service = <Self>() =>
<
 const Id extends string,
 Options extends
 | NoExcessProperties<
 {
 readonly lookup: (key: any) => Layer.Layer<any, any, any>
 readonly dependencies?: ReadonlyArray<Layer.Layer<any, any, any>>
 readonly idleTimeToLive?: Duration.DurationInput | undefined
 readonly preloadKeys?:
 | Iterable<Options extends { readonly lookup: (key: infer K) => any } ? K : never>
 | undefined
 },
 Options
 >
 | NoExcessProperties<{
 readonly layers: Record<string, Layer.Layer<any, any, any>>
 readonly dependencies?: ReadonlyArray<Layer.Layer<any, any, any>>
 readonly idleTimeToLive?: Duration.DurationInput | undefined
 readonly preload?: boolean
 }, Options>
>(
 id: Id,
 options: Options
): TagClass<
 Self,
 Id,
 Options extends { readonly lookup: (key: infer K) => any } ? K
 : Options extends { readonly layers: infer Layers } ? keyof Layers
 : never,
 Service.Success<Options>,
 Options extends { readonly preload: true } ? never : Service.Error<Options>,
 Service.Context<Options>,
 Options extends { readonly preload: true } ? Service.Error<Options>
 : Options extends { readonly preloadKey: Iterable<any> } ? Service.Error<Options>
 : never,
 Options extends { readonly dependencies: ReadonlyArray<any> } ? Options["dependencies"][number] : never
> => {
 const Err = globalThis.Error as any
 const limit = Err.stackTraceLimit
 Err.stackTraceLimit = 2
 const creationError = new Err()
 Err.stackTraceLimit = limit

function TagClass() {}
 const TagClass_ = TagClass as any as Mutable<TagClass<Self, Id, string, any, any, any, any, any>>
 Object.setPrototypeOf(TagClass, Object.getPrototypeOf(Context.GenericTag<Self, any>(id)))
 TagClass.key = id
 Object.defineProperty(TagClass, "stack", {
 get() {
 return creationError.stack
 }
 })

TagClass_.DefaultWithoutDependencies = Layer.scoped(
    TagClass_,
    "lookup" in options
      ? make(options.lookup, options)
      : fromRecord(options.layers as any, options)
  )
  TagClass_.Default = options.dependencies && options.dependencies.length > 0 ?
    Layer.provide(TagClass_.DefaultWithoutDependencies, options.dependencies as any) :
    TagClass_.DefaultWithoutDependencies

TagClass_.get = (key: string) => Layer.unwrapScoped(Effect.map(TagClass_, (layerMap) => layerMap.get(key)))
  TagClass_.runtime = (key: string) => Effect.flatMap(TagClass_, (layerMap) => layerMap.runtime(key))
  TagClass_.invalidate = (key: string) => Effect.flatMap(TagClass_, (layerMap) => layerMap.invalidate(key))

return TagClass as any
}

/**
 * @since 3.14.0
 * @category Service
 * @experimental
 */
export declare namespace Service {
 /**
 * @since 3.14.0
 * @category Service
 * @experimental
 */
 export type Key<Options> = Options extends { readonly lookup: (key: infer K) => any } ? K
 : Options extends { readonly layers: infer Layers } ? keyof Layers
 : never

/**
 * @since 3.14.0
 * @category Service
 * @experimental
 */
 export type Layers<Options> = Options extends { readonly lookup: (key: infer _K) => infer Layers } ? Layers
 : Options extends { readonly layers: infer Layers } ? Layers[keyof Layers]
 : never

/**
 * @since 3.14.0
 * @category Service
 * @experimental
 */
 export type Success<Options> = Layers<Options> extends Layer.Layer<infer _A, infer _E, infer _R> ? _A : never

/**
 * @since 3.14.0
 * @category Service
 * @experimental
 */
 export type Error<Options> = Layers<Options> extends Layer.Layer<infer _A, infer _E, infer _R> ? _E : never

/**
 * @since 3.14.0
 * @category Service
 * @experimental
 */
 export type Context<Options> = Layers<Options> extends Layer.Layer<infer _A, infer _E, infer _R> ? _R : never
}

Cancel / Back

[ MAINHACK ]

Viewing / Editing File: LayerMap.ts

Server Info

System Features

User Info