@highstate/backend 0.7.1 → 0.7.3

package/src/shared/resolvers/graph-resolver.ts

@@ -0,0 +1,111 @@
+import type { Logger } from "pino"
+import { unique } from "remeda"
+
+export type GraphResolverOptions<TNode, TOutput> = {
+  name: string
+
+  getNodeId(input: TNode): string
+
+  getNodeDependencies(input: TNode): string[]
+
+  process(
+    node: TNode,
+    dependencies: ReadonlyMap<string, TOutput>,
+    logger: Logger,
+  ): TOutput | Promise<TOutput>
+}
+
+export interface GraphResolverBackend<TOutput> {
+  promiseCache: Map<string, Promise<TOutput>>
+
+  setOutput?(id: string, value: TOutput): void
+  setDependencies?(id: string, dependencies: string[]): void
+}
+
+export type GraphResolverFactory<TNode, TOutput> = {
+  factoryName: string
+} & ((
+  nodes: ReadonlyMap<string, TNode>,
+  logger: Logger,
+  backend?: GraphResolverBackend<TOutput>,
+) => GraphResolver<TOutput>)
+
+export type GraphResolver<TOutput> = (id: string) => Promise<TOutput>
+
+export class CircularDependencyError extends Error {
+  constructor(path: string[]) {
+    super(`Circular dependency detected: ${path.join(" -> ")}`)
+    this.name = "CircularDependencyError"
+  }
+}
+
+export function createDefaultGraphResolverBackend<TOutput>(): GraphResolverBackend<TOutput> {
+  const promiseCache = new Map<string, Promise<TOutput>>()
+
+  return {
+    promiseCache,
+  }
+}
+
+export function defineGraphResolver<TInput, TOutput>(
+  options: GraphResolverOptions<TInput, TOutput>,
+): GraphResolverFactory<TInput, TOutput> {
+  const factory: GraphResolverFactory<TInput, TOutput> = (nodes, logger, backend) => {
+    backend ??= createDefaultGraphResolverBackend<TOutput>()
+    logger = logger.child({ resolver: options.name })
+
+    const outputs = new Map<string, TOutput>()
+
+    const resolver = (itemId: string, dependencyChain: string[]) => {
+      logger.trace({ itemId }, "resolving item")
+
+      const existingPromise = backend.promiseCache.get(itemId)
+      if (existingPromise) {
+        return existingPromise
+      }
+
+      if (dependencyChain.includes(itemId)) {
+        throw new CircularDependencyError([...dependencyChain, itemId])
+      }
+
+      const item = nodes.get(itemId)
+      if (!item) {
+        return Promise.resolve(undefined!)
+      }
+
+      const resolve = async () => {
+        const dependencies = unique(options.getNodeDependencies(item))
+
+        backend.setDependencies?.(itemId, dependencies)
+        logger.trace({ itemId, dependencies }, "resolving item dependencies")
+
+        const newChain = [...dependencyChain, itemId]
+
+        for (const depId of dependencies) {
+          await resolver(depId, newChain)
+        }
+
+        return await options.process(item, outputs, logger)
+      }
+
+      const promise = resolve().then(result => {
+        if (backend.promiseCache.get(itemId) === promise) {
+          // persist the result to the state if provided
+          // ignore if the promise has been replaced (which means this calculation was invalidated)
+          backend.setOutput?.(itemId, result)
+          outputs.set(itemId, result)
+        }
+
+        return result
+      })
+
+      backend.promiseCache.set(itemId, promise)
+      return promise
+    }
+
+    return id => resolver(id, [])
+  }
+
+  factory.factoryName = options.name
+  return factory
+}

package/src/shared/resolvers/input-hash.ts

@@ -0,0 +1,77 @@
+import type { ComponentModel, InstanceModel } from "@highstate/contract"
+import type { InstanceState } from "../state"
+import type { ResolvedInstanceInput } from "./input"
+import { sha256 } from "crypto-hash"
+import { defineGraphResolver } from "./graph-resolver"
+
+export type InputHashResolverInput = {
+  instance: InstanceModel
+  component: ComponentModel
+  resolvedInputs: Record<string, ResolvedInstanceInput[]>
+  state: InstanceState | undefined
+  sourceHash: string | undefined
+}
+
+export type InputHashResolverOutput = {
+  inputHash: string
+  outputHash: string
+}
+
+/**
+ * Resolves the hash of the instance based on its args, resolved input hashes, source hash, and the output hash.
+ */
+export const createInputHashResolver = defineGraphResolver<
+  InputHashResolverInput,
+  InputHashResolverOutput
+>({
+  name: "input-hash-resolver",
+  getNodeId: node => node.instance.id,
+
+  getNodeDependencies({ resolvedInputs }) {
+    const dependencies: string[] = []
+
+    for (const inputs of Object.values(resolvedInputs ?? {})) {
+      for (const input of inputs) {
+        dependencies.push(input.input.instanceId)
+      }
+    }
+
+    return dependencies
+  },
+
+  async process({ instance, component, resolvedInputs, sourceHash, state }, dependencies) {
+    let sink = component.definitionHash + JSON.stringify(instance.args ?? {})
+
+    if (sourceHash) {
+      sink += sourceHash
+    }
+
+    const sortedInputs = Object.entries(resolvedInputs)
+      //
+      .sort(([a], [b]) => a.localeCompare(b))
+
+    for (const [inputKey, inputs] of sortedInputs) {
+      if (Object.keys(inputs).length === 0) {
+        continue
+      }
+
+      sink += inputKey
+
+      const instanceIds = inputs.map(input => input.input.instanceId)
+      instanceIds.sort()
+
+      for (const instanceId of instanceIds) {
+        const dependency = dependencies.get(instanceId)
+        if (!dependency) continue
+
+        sink += dependency.inputHash
+        sink += dependency.outputHash
+      }
+    }
+
+    return {
+      inputHash: await sha256(sink),
+      outputHash: state?.outputHash ?? "",
+    }
+  },
+})

package/src/shared/resolvers/input.ts

@@ -0,0 +1,314 @@
+import type { HubModel } from "../project"
+import {
+  isUnitModel,
+  type ComponentModel,
+  type HubInput,
+  type InstanceInput,
+  type InstanceModel,
+} from "@highstate/contract"
+import { fromEntries, mapValues } from "remeda"
+import { defineGraphResolver } from "./graph-resolver"
+
+export type InputResolverInput =
+  | {
+      kind: "instance"
+      instance: InstanceModel
+      component: ComponentModel
+    }
+  | {
+      kind: "hub"
+      hub: HubModel
+    }
+
+export type ResolvedInstanceInput = {
+  input: InstanceInput
+  type: string
+}
+
+export type InputResolverOutput =
+  | {
+      kind: "instance"
+      component: ComponentModel
+      resolvedInputs: Record<string, ResolvedInstanceInput[]>
+      resolvedOutputs: Record<string, InstanceInput[]>
+      resolvedInjectionInputs: ResolvedInstanceInput[]
+      matchedInjectionInputs: ResolvedInstanceInput[]
+    }
+  | {
+      kind: "hub"
+      resolvedInputs: ResolvedInstanceInput[]
+    }
+
+/**
+ * Resolves the all recursive instance and hub inputs based on its direct inputs and injected inputs.
+ */
+export const createInputResolver = defineGraphResolver<InputResolverInput, InputResolverOutput>({
+  name: "input-resolver",
+  getNodeId(node) {
+    if (node.kind === "hub") {
+      return `hub:${node.hub.id}`
+    }
+
+    return `instance:${node.instance.id}`
+  },
+
+  getNodeDependencies(node) {
+    const dependencies: string[] = []
+
+    if (node.kind === "hub") {
+      for (const input of node.hub.inputs ?? []) {
+        dependencies.push(`instance:${input.instanceId}`)
+      }
+
+      for (const input of node.hub.injectionInputs ?? []) {
+        dependencies.push(`hub:${input.hubId}`)
+      }
+
+      return dependencies
+    }
+
+    for (const inputs of Object.values(node.instance.inputs ?? {})) {
+      for (const input of inputs) {
+        dependencies.push(`instance:${input.instanceId}`)
+      }
+    }
+
+    for (const inputs of Object.values(node.instance.hubInputs ?? {})) {
+      for (const input of inputs) {
+        dependencies.push(`hub:${input.hubId}`)
+      }
+    }
+
+    for (const input of node.instance.injectionInputs ?? []) {
+      dependencies.push(`hub:${input.hubId}`)
+    }
+
+    return dependencies
+  },
+
+  process(node, dependencies, logger) {
+    const getHubOutput = (input: HubInput) => {
+      const output = dependencies.get(`hub:${input.hubId}`)
+      if (!output) {
+        return { resolvedInputs: [] }
+      }
+
+      if (output.kind !== "hub") {
+        throw new Error("Expected hub node")
+      }
+
+      return output
+    }
+
+    const getInstanceOutput = (input: InstanceInput) => {
+      const output = dependencies.get(`instance:${input.instanceId}`)
+      if (!output) {
+        return {
+          component: null,
+          resolvedInputs: [] as ResolvedInstanceInput[],
+          resolvedOutputs: [] as InstanceInput[],
+        }
+      }
+
+      if (output.kind !== "instance") {
+        throw new Error("Expected instance node")
+      }
+
+      return {
+        component: output.component,
+        resolvedInputs: output.resolvedInputs[input.output] ?? [],
+        resolvedOutputs: output.resolvedOutputs[input.output] ?? [],
+      }
+    }
+
+    // resolve inputs for hub
+
+    if (node.kind === "hub") {
+      const hubResult: Map<string, ResolvedInstanceInput> = new Map()
+
+      const addHubResult = (input: ResolvedInstanceInput) => {
+        hubResult.set(`${input.input.instanceId}:${input.input.output}`, input)
+      }
+
+      for (const input of node.hub.inputs ?? []) {
+        const { component } = getInstanceOutput(input)
+        const componentInput = component?.outputs[input.output]
+
+        if (!componentInput) {
+          logger.warn({ msg: "output not found in the component", input, component })
+          continue
+        }
+
+        addHubResult({ input, type: componentInput.type })
+      }
+
+      for (const injectionInput of node.hub.injectionInputs ?? []) {
+        const { resolvedInputs } = getHubOutput(injectionInput)
+
+        for (const input of resolvedInputs) {
+          addHubResult(input)
+        }
+      }
+
+      return {
+        kind: "hub",
+        resolvedInputs: Array.from(hubResult.values()),
+      }
+    }
+
+    // хуяк (which translates as "lets reuse resolved inputs of level 2+ composite instances provided by the evaluator")
+    if (node.instance.resolvedInputs) {
+      return {
+        kind: "instance",
+        component: node.component,
+        resolvedInputs: mapValues(node.instance.resolvedInputs, (inputs, inputName) => {
+          const componentInput = node.component.inputs[inputName]
+          if (!componentInput) {
+            logger.warn({
+              msg: "input not found in the component",
+              inputName,
+              component: node.component,
+            })
+            return []
+          }
+
+          return inputs.map(input => ({ input, type: componentInput.type }))
+        }),
+        resolvedOutputs: node.instance.resolvedOutputs ?? {},
+        resolvedInjectionInputs: [],
+        matchedInjectionInputs: [],
+      }
+    }
+
+    // resolve inputs for instance
+
+    const resolvedInputsMap: Map<string, Map<string, ResolvedInstanceInput>> = new Map()
+
+    const addInstanceResult = (inputName: string, input: ResolvedInstanceInput) => {
+      let inputs = resolvedInputsMap.get(inputName)
+      if (!inputs) {
+        inputs = new Map()
+        resolvedInputsMap.set(inputName, inputs)
+      }
+
+      inputs.set(`${input.input.instanceId}:${input.input.output}`, input)
+    }
+
+    const addInstanceInput = (inputName: string, input: InstanceInput) => {
+      const componentInput = node.component.inputs[inputName]
+      if (!componentInput) {
+        logger.warn({ msg: "input not found in the component", input, component: node.component })
+        return
+      }
+
+      const { component, resolvedOutputs } = getInstanceOutput(input)
+
+      if (!component) {
+        logger.warn({ instanceId: node.instance.id, input }, "no output found for the input")
+        return
+      }
+
+      if (isUnitModel(component)) {
+        addInstanceResult(inputName, { input, type: componentInput.type })
+        return
+      }
+
+      for (const output of resolvedOutputs) {
+        addInstanceResult(inputName, { input: output, type: componentInput.type })
+      }
+    }
+
+    for (const [inputName, inputs] of Object.entries(node.instance.inputs ?? {})) {
+      for (const input of inputs) {
+        addInstanceInput(inputName, input)
+      }
+    }
+
+    const injectionInputs: Map<string, ResolvedInstanceInput> = new Map()
+    const matchedInjectionInputs: Map<string, ResolvedInstanceInput> = new Map()
+
+    for (const injectionInput of node.instance.injectionInputs ?? []) {
+      const { resolvedInputs } = getHubOutput(injectionInput)
+      for (const input of resolvedInputs) {
+        injectionInputs.set(`${input.input.instanceId}:${input.input.output}`, input)
+      }
+    }
+
+    for (const [inputName, componentInput] of Object.entries(node.component.inputs ?? {})) {
+      const allInputs = new Map<string, ResolvedInstanceInput>(injectionInputs)
+      const hubInputs = node.instance.hubInputs?.[inputName] ?? []
+
+      for (const hubInput of hubInputs) {
+        const { resolvedInputs } = getHubOutput(hubInput)
+        for (const input of resolvedInputs) {
+          allInputs.set(`${input.input.instanceId}:${input.input.output}`, input)
+        }
+      }
+
+      for (const input of allInputs.values()) {
+        if (input.type === componentInput.type) {
+          addInstanceInput(inputName, input.input)
+
+          const key = `${input.input.instanceId}:${input.input.output}`
+          if (injectionInputs.has(key)) {
+            matchedInjectionInputs.set(key, input)
+          }
+        }
+      }
+    }
+
+    const resolvedInputs = fromEntries(
+      Array.from(resolvedInputsMap.entries()).map(([inputName, inputs]) => [
+        inputName,
+        Array.from(inputs.values()),
+      ]),
+    )
+
+    return {
+      kind: "instance",
+      component: node.component,
+      resolvedInputs,
+      resolvedOutputs: node.instance.resolvedOutputs ?? {},
+      resolvedInjectionInputs: Array.from(injectionInputs.values()),
+      matchedInjectionInputs: Array.from(matchedInjectionInputs.values()),
+    }
+  },
+})
+
+export function getResolvedHubInputs(output: InputResolverOutput): ResolvedInstanceInput[] {
+  if (output.kind !== "hub") {
+    throw new Error("Expected hub node")
+  }
+
+  return output.resolvedInputs
+}
+
+export function getResolvedInstanceInputs(
+  output: InputResolverOutput,
+): Record<string, ResolvedInstanceInput[]> {
+  if (output.kind !== "instance") {
+    throw new Error("Expected instance node")
+  }
+
+  return output.resolvedInputs
+}
+
+export function getResolvedInjectionInstanceInputs(
+  output: InputResolverOutput,
+): ResolvedInstanceInput[] {
+  if (output.kind !== "instance") {
+    throw new Error("Expected instance node")
+  }
+
+  return output.resolvedInjectionInputs
+}
+
+export function getMatchedInjectionInstanceInputs(
+  output: InputResolverOutput,
+): ResolvedInstanceInput[] {
+  if (output.kind !== "instance") {
+    throw new Error("Expected instance node")
+  }
+
+  return output.matchedInjectionInputs
+}

package/src/shared/resolvers/registry.ts

@@ -0,0 +1,10 @@
+import type { GraphResolverFactory } from "./graph-resolver"
+import { createInputResolver } from "./input"
+import { createInputHashResolver } from "./input-hash"
+import { createValidationResolver } from "./validation"
+
+export const resolverFactories: Record<string, GraphResolverFactory<any, any>> = {
+  [createInputResolver.factoryName]: createInputResolver,
+  [createInputHashResolver.factoryName]: createInputHashResolver,
+  [createValidationResolver.factoryName]: createValidationResolver,
+}

package/src/shared/resolvers/validation.ts

@@ -0,0 +1,94 @@
+import type { ComponentModel, InstanceModel } from "@highstate/contract"
+import type { ResolvedInstanceInput } from "./input"
+import { Ajv } from "ajv"
+import { defineGraphResolver } from "./graph-resolver"
+
+export type ValidationResolverInput = {
+  instance: InstanceModel
+  component: ComponentModel
+  resolvedInputs: Record<string, ResolvedInstanceInput[]>
+}
+
+export type ValidationResolverOutput =
+  | {
+      status: "ok"
+    }
+  | {
+      status: "invalid-args"
+      errorText: string
+    }
+  | {
+      status: "invalid-inputs" | "missing-inputs"
+      errorText: string
+    }
+
+/**
+ * Validates the instance based on its arguments and inputs.
+ */
+export const createValidationResolver = defineGraphResolver<
+  ValidationResolverInput,
+  ValidationResolverOutput
+>({
+  name: "validation-resolver",
+  getNodeId: node => node.instance.id,
+
+  getNodeDependencies({ resolvedInputs }) {
+    const dependencies: string[] = []
+
+    for (const inputs of Object.values(resolvedInputs)) {
+      for (const input of inputs) {
+        dependencies.push(input.input.instanceId)
+      }
+    }
+
+    return dependencies
+  },
+
+  process({ instance, component, resolvedInputs }, dependencies, logger) {
+    const ajv = new Ajv()
+
+    logger.debug({ instanceId: instance.id }, "validating instance")
+
+    for (const [name, argument] of Object.entries(component.args)) {
+      if (!argument.required && !instance.args?.[name]) {
+        continue
+      }
+
+      if (!ajv.validate(argument.schema, instance.args?.[name])) {
+        logger.debug({ instanceId: instance.id, argumentName: name }, "invalid argument")
+
+        return {
+          status: "invalid-args",
+          errorText: ajv.errorsText(),
+        }
+      }
+    }
+
+    for (const inputs of Object.values(resolvedInputs)) {
+      for (const input of inputs) {
+        const inputInstance = dependencies.get(input.input.instanceId)
+        if (inputInstance?.status !== "ok") {
+          return {
+            status: "invalid-inputs",
+            errorText: `instance "${input.input.instanceId}" is invalid`,
+          }
+        }
+      }
+    }
+
+    for (const [name, input] of Object.entries(component.inputs)) {
+      if (!input.required || input.multiple) {
+        continue
+      }
+
+      if (!resolvedInputs[name] || !resolvedInputs[name].length) {
+        return {
+          status: "missing-inputs",
+          errorText: `input "${name}" is missing`,
+        }
+      }
+    }
+
+    return { status: "ok" }
+  },
+})