@highstate/backend 0.4.4 → 0.4.6

package/dist/library/worker/main.mjs

@@ -1,8 +1,8 @@
-import { parentPort, workerData } from 'node:worker_threads';
+import { workerData, parentPort } from 'node:worker_threads';
 import { createJiti } from 'jiti';
 import { pino } from 'pino';
 import { mapValues } from 'remeda';
-import { isComponent, isEntity, resetEvaluation, getInstances, getCompositeInstances } from '@highstate/contract';
+import { isComponent, isEntity, resetEvaluation, getCompositeInstances, getInstances } from '@highstate/contract';
 
 async function loadLibrary(jiti, logger, modulePaths) {
   const modules = {};
@@ -79,12 +79,7 @@ function evaluateInstances(logger, library, allInstances, instanceIds) {
     if (!instance) {
       throw new Error(`Instance not found: ${instanceId}`);
     }
-    for (const [inputName, input] of Object.entries(instance.inputs)) {
-      if (!Array.isArray(input)) {
-        const outputs = evaluateInstance(input.instanceId);
-        inputs[inputName] = outputs[input.output];
-        continue;
-      }
+    for (const [inputName, input] of Object.entries(instance.inputs ?? {})) {
       inputs[inputName] = input.map((input2) => {
         const evaluated = evaluateInstance(input2.instanceId);
         return evaluated[input2.output];

package/dist/shared/index.d.ts

@@ -1,21 +1,85 @@
-export { I as InstanceModel, u as InstanceRepresentationMeta, b as InstanceState, c as InstanceStatePatch, d as InstanceStatus, r as InstanceStatusField, s as InstanceStatusFieldMap, D as OperationStatus, O as OperationType, P as Position, a as ProjectOperation, e as ProjectOperationRequest, T as TerminalFactory, x as applyInstanceStateFrontendPatch, w as applyInstanceStatePatch, h as compositeInstanceSchema, v as createInstanceState, y as createInstanceStateFrontendPatch, f as instanceInputMapSchema, i as instanceInputSchema, g as instanceModelSchema, m as instanceRepresentationMetaSchema, n as instanceRepresentationSchema, o as instanceStatePatchSchema, q as instanceStateSchema, l as instanceStatusFieldMapSchema, k as instanceStatusFieldSchema, j as instanceStatusSchema, A as operationStatusSchema, z as operationTypeSchema, p as positionSchema, C as projectOperationRequestSchema, B as projectOperationSchema, t as terminalFactorySchema } from '../operation-8k4Tv4dw.js';
-import { BaseInstanceModel } from '@highstate/contract';
+import { H as HubModel, b as InstanceState } from '../terminal-_gg6j6_K.js';
+export { C as CompositeInstance, a as HubModelPatch, J as InstanceFileMeta, I as InstanceModelPatch, e as InstancePageBlock, G as InstancePageMeta, d as InstanceStatePatch, c as InstanceStatus, F as InstanceStatusField, f as InstanceTerminal, L as InstanceTrigger, M as InstanceTriggerInvocation, K as InstanceTriggerSpec, X as OperationStatus, W as OperationType, P as ProjectOperation, g as ProjectOperationRequest, T as TerminalSession, O as applyPartialInstanceState, l as compositeInstanceSchema, N as createInstanceState, Q as createInstanceStateFrontendPatch, h as hubInstanceInputSchema, m as hubModelPatchSchema, n as hubModelSchema, r as instanceFileMetaSchema, s as instanceFileSchema, i as instanceInputSchema, j as instanceModelPatchSchema, k as instanceModelSchema, t as instancePageBlockSchema, u as instancePageMetaSchema, v as instancePageSchema, E as instanceStatePatchSchema, D as instanceStateSchema, q as instanceStatusFieldSchema, o as instanceStatusSchema, x as instanceTerminalFileSchema, w as instanceTerminalMetaSchema, y as instanceTerminalSchema, B as instanceTriggerInvocationSchema, A as instanceTriggerSchema, z as instanceTriggerSpecSchema, Y as isFinalOperationStatus, S as operationStatusSchema, R as operationTypeSchema, p as positionSchema, V as projectOperationRequestSchema, U as projectOperationSchema, Z as terminalSessionSchema } from '../terminal-_gg6j6_K.js';
+import { Logger } from 'pino';
+import { InstanceModel, ComponentModel, InstanceInput } from '@highstate/contract';
 import 'zod';
 
-interface CacheEntry {
-    inputHash: string;
-    dependencies: string[];
-    dependents: string[];
+type GraphResolverOptions<TNode, TOutput> = {
+    getNodeId(input: TNode): string;
+    getNodeDependencies(input: TNode): string[];
+    process(node: TNode, dependencies: Map<string, TOutput>, logger: Logger): TOutput | Promise<TOutput>;
+};
+interface GraphResolverBackend<TOutput> {
+    promiseCache: Map<string, Promise<TOutput>>;
+    setOutput(id: string, value: TOutput): void;
+    setDependencies(id: string, dependencies: string[]): void;
 }
-declare class InputHashCalculator {
-    private readonly instances;
-    private readonly cache;
-    private readonly promiseCache;
-    constructor(instances: Map<string, BaseInstanceModel>);
-    reset(instanceId: string): void;
-    calculate(instance: BaseInstanceModel): Promise<string>;
-    calculateFull(instance: BaseInstanceModel): Promise<CacheEntry>;
-    private _calculate;
+type GraphResolverFactory<TNode, TOutput> = (nodes: ReadonlyMap<string, TNode>, logger: Logger, backend?: GraphResolverBackend<TOutput>) => GraphResolver<TOutput>;
+type GraphResolver<TOutput> = (id: string) => Promise<TOutput>;
+declare class CircularDependencyError extends Error {
+    constructor(path: string[]);
 }
+declare function createDefaultGraphResolverBackend<TOutput>(): GraphResolverBackend<TOutput>;
+declare function defineGraphResolver<TInput, TOutput>(options: GraphResolverOptions<TInput, TOutput>): GraphResolverFactory<TInput, TOutput>;
 
-export { type CacheEntry, InputHashCalculator };
+type InputResolverNode = {
+    kind: "instance";
+    instance: InstanceModel;
+    component: ComponentModel;
+} | {
+    kind: "hub";
+    hub: HubModel;
+};
+type ResolvedInstanceInput = {
+    input: InstanceInput;
+    type: string;
+};
+type InputResolverOutput = {
+    kind: "instance";
+    component: ComponentModel;
+    resolvedInputs: Record<string, ResolvedInstanceInput[]>;
+    resolvedInjectionInputs: ResolvedInstanceInput[];
+    matchedInjectionInputs: ResolvedInstanceInput[];
+} | {
+    kind: "hub";
+    resolvedInputs: ResolvedInstanceInput[];
+};
+/**
+ * Resolves the all recursive instance and hub inputs based on its direct inputs and injected inputs.
+ */
+declare const createInputResolver: GraphResolverFactory<InputResolverNode, InputResolverOutput>;
+declare function getResolvedHubInputs(output: InputResolverOutput): ResolvedInstanceInput[];
+declare function getResolvedInstanceInputs(output: InputResolverOutput): Record<string, ResolvedInstanceInput[]>;
+declare function getResolvedInjectionInstanceInputs(output: InputResolverOutput): ResolvedInstanceInput[];
+declare function getMatchedInjectionInstanceInputs(output: InputResolverOutput): ResolvedInstanceInput[];
+
+type InputHashNode = {
+    instance: InstanceModel;
+    resolvedInputs: Record<string, ResolvedInstanceInput[]>;
+    state: InstanceState | undefined;
+    sourceHash: string | undefined;
+};
+/**
+ * Resolves the hash of the instance based on its args, resolved input hashes, source hash, and the output hash.
+ */
+declare const createInputHashResolver: GraphResolverFactory<InputHashNode, string>;
+
+type ValidationNode = {
+    instance: InstanceModel;
+    component: ComponentModel;
+    resolvedInputs: Record<string, ResolvedInstanceInput[]>;
+};
+type InstanceValidationResult = {
+    status: "ok";
+} | {
+    status: "invalid-args";
+    errorsText: string;
+} | {
+    status: "invalid-inputs" | "missing-inputs";
+};
+/**
+ * Validates the instance based on its arguments and inputs.
+ */
+declare const createInstanceValidationResolver: GraphResolverFactory<ValidationNode, InstanceValidationResult>;
+
+export { CircularDependencyError, type GraphResolver, type GraphResolverBackend, type GraphResolverFactory, type GraphResolverOptions, HubModel, type InputHashNode, type InputResolverNode, type InputResolverOutput, InstanceState, type InstanceValidationResult, type ResolvedInstanceInput, type ValidationNode, createDefaultGraphResolverBackend, createInputHashResolver, createInputResolver, createInstanceValidationResolver, defineGraphResolver, getMatchedInjectionInstanceInputs, getResolvedHubInputs, getResolvedInjectionInstanceInputs, getResolvedInstanceInputs };

package/dist/shared/index.mjs

@@ -1,4 +1,54 @@
-export { I as InputHashCalculator, n as applyInstanceStateFrontendPatch, m as applyInstanceStatePatch, c as compositeInstanceSchema, l as createInstanceState, o as createInstanceStateFrontendPatch, a as instanceInputMapSchema, i as instanceInputSchema, b as instanceModelSchema, g as instanceRepresentationMetaSchema, h as instanceRepresentationSchema, j as instanceStatePatchSchema, k as instanceStateSchema, f as instanceStatusFieldMapSchema, e as instanceStatusFieldSchema, d as instanceStatusSchema, r as operationStatusSchema, q as operationTypeSchema, p as positionSchema, u as projectOperationRequestSchema, s as projectOperationSchema, t as terminalFactorySchema } from '../input-hash-C8HEDMjz.mjs';
+import { q as defineGraphResolver } from '../terminal-C1HuyJ6e.mjs';
+export { J as CircularDependencyError, n as applyPartialInstanceState, k as compositeInstanceSchema, K as createDefaultGraphResolverBackend, a as createInputHashResolver, c as createInputResolver, b as createInstanceState, o as createInstanceStateFrontendPatch, O as getMatchedInjectionInstanceInputs, L as getResolvedHubInputs, N as getResolvedInjectionInstanceInputs, M as getResolvedInstanceInputs, u as hubInstanceInputSchema, w as hubModelPatchSchema, h as hubModelSchema, y as instanceFileMetaSchema, f as instanceFileSchema, s as instanceInputSchema, v as instanceModelPatchSchema, i as instanceModelSchema, z as instancePageBlockSchema, A as instancePageMetaSchema, e as instancePageSchema, F as instanceStatePatchSchema, l as instanceStateSchema, g as instanceStatusFieldSchema, x as instanceStatusSchema, C as instanceTerminalFileSchema, B as instanceTerminalMetaSchema, d as instanceTerminalSchema, E as instanceTriggerInvocationSchema, j as instanceTriggerSchema, D as instanceTriggerSpecSchema, m as isFinalOperationStatus, H as operationStatusSchema, G as operationTypeSchema, r as positionSchema, I as projectOperationRequestSchema, p as projectOperationSchema, t as terminalSessionSchema } from '../terminal-C1HuyJ6e.mjs';
+import { Ajv } from 'ajv';
 import 'zod';
-import '@highstate/contract';
+import 'remeda';
 import 'crypto-hash';
+
+const createInstanceValidationResolver = defineGraphResolver({
+  getNodeId: (node) => node.instance.id,
+  getNodeDependencies({ resolvedInputs }) {
+    const dependencies = [];
+    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",
+          errorsText: 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" };
+        }
+      }
+    }
+    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" };
+      }
+    }
+    return { status: "ok" };
+  }
+});
+
+export { createInstanceValidationResolver, defineGraphResolver };