118 lines
3.9 KiB
TypeScript
118 lines
3.9 KiB
TypeScript
import { Layer } from "effect"
|
|
import { LayerNode } from "./layer-node"
|
|
|
|
type AnyNode = LayerNode.Node<unknown, unknown, any>
|
|
type RuntimeLayer = Layer.Layer<never, unknown, unknown>
|
|
|
|
export function hoist<A, E, T extends LayerNode.Tag>(
|
|
root: LayerNode.Node<A, E, any>,
|
|
tag: T,
|
|
): {
|
|
readonly node: LayerNode.Node<A, E>
|
|
readonly hoisted: LayerNode.Node<unknown, E>
|
|
} {
|
|
const visited = new Map<AnyNode, AnyNode>()
|
|
const hoisted = new Map<string, AnyNode>()
|
|
const visiting = new Set<AnyNode>()
|
|
const stack: AnyNode[] = []
|
|
|
|
const visit = (node: AnyNode): AnyNode => {
|
|
if (node.kind === "group") {
|
|
return { ...node, dependencies: node.dependencies.map(visit) }
|
|
}
|
|
|
|
const existingNode = visited.get(node)
|
|
if (existingNode) return existingNode
|
|
|
|
if (node.tag === tag) {
|
|
const existing = hoisted.get(node.name)
|
|
if (existing && existing !== node) {
|
|
throw new Error(`Tag ${tag} has conflicting implementations for ${node.name}`)
|
|
}
|
|
hoisted.set(node.name, node)
|
|
const empty = LayerNode.group([])
|
|
visited.set(node, empty)
|
|
return empty
|
|
}
|
|
if (node.kind === "unbound") {
|
|
return node
|
|
}
|
|
|
|
if (visiting.has(node)) {
|
|
const start = stack.indexOf(node)
|
|
throw new Error(
|
|
`Cycle detected in layer tree: ${[...stack.slice(start), node].map((item) => item.name).join(" -> ")}`,
|
|
)
|
|
}
|
|
visiting.add(node)
|
|
stack.push(node)
|
|
try {
|
|
const dependencies = node.dependencies.map(visit)
|
|
const clone = { ...node, dependencies }
|
|
visited.set(node, clone)
|
|
return clone
|
|
} finally {
|
|
stack.pop()
|
|
visiting.delete(node)
|
|
}
|
|
}
|
|
|
|
return {
|
|
node: visit(root) as LayerNode.Node<A, E>,
|
|
hoisted: LayerNode.group(Array.from(hoisted.values())) as LayerNode.Node<unknown, E>,
|
|
}
|
|
}
|
|
|
|
export function compile<A, E>(
|
|
root: LayerNode.Node<A, E, any>,
|
|
replacements?: ReadonlyMap<Layer.Any, Layer.Any>,
|
|
): Layer.Layer<A, E> {
|
|
const cache = new Map<AnyNode, RuntimeLayer>()
|
|
const compileNode = (node: AnyNode): RuntimeLayer => {
|
|
if (node.kind === "unbound") throw new Error(`Unbound layer node: ${node.name}`)
|
|
const cached = cache.get(node)
|
|
if (cached) return cached
|
|
const dependencies = node.dependencies.flatMap(flatten).map(compileNode)
|
|
const implementation = (replacements?.get(node.implementation!) ?? node.implementation!) as RuntimeLayer
|
|
const layer =
|
|
dependencies.length === 0
|
|
? implementation
|
|
: implementation.pipe(Layer.provide(dependencies as [RuntimeLayer, ...RuntimeLayer[]]))
|
|
cache.set(node, layer)
|
|
return layer
|
|
}
|
|
const layers = flatten(root).map((node) => compileNode(node))
|
|
const layer = layers.reduce<RuntimeLayer>((result, layer) => layer.pipe(Layer.provideMerge(result)), Layer.empty)
|
|
return layer as Layer.Layer<A, E>
|
|
}
|
|
|
|
export function bind<A, E, T extends LayerNode.Tag | undefined>(
|
|
root: LayerNode.Node<A, E, T>,
|
|
source: AnyNode,
|
|
replacement: AnyNode,
|
|
): LayerNode.Node<A, E, T> {
|
|
if (source.kind !== "unbound") throw new Error(`Cannot bind non-unbound layer node: ${source.name}`)
|
|
if (source.name !== replacement.name) {
|
|
throw new Error(`Cannot bind ${source.name} to ${replacement.name}`)
|
|
}
|
|
if (source.tag !== replacement.tag) {
|
|
throw new Error(`Cannot bind ${source.name} across tags`)
|
|
}
|
|
const visited = new Map<AnyNode, AnyNode>()
|
|
const visit = (node: AnyNode): AnyNode => {
|
|
if (node === source) return replacement
|
|
const existing = visited.get(node)
|
|
if (existing) return existing
|
|
if (node.kind === "unbound") return node
|
|
const clone = { ...node, dependencies: node.dependencies.map(visit) }
|
|
visited.set(node, clone)
|
|
return clone
|
|
}
|
|
return visit(root) as LayerNode.Node<A, E, T>
|
|
}
|
|
|
|
function flatten(node: AnyNode): readonly AnyNode[] {
|
|
return node.kind === "group" ? node.dependencies.flatMap(flatten) : [node]
|
|
}
|
|
|
|
export * as LayerNodeTree from "./layer-node-tree"
|