@highstate/backend 0.7.1 → 0.7.3

package/dist/library/worker/main.mjs

@@ -1,164 +0,0 @@
-import { workerData, parentPort } from 'node:worker_threads';
-import { createJiti } from 'jiti';
-import { pino } from 'pino';
-import { mapValues } from 'remeda';
-import { isComponent, isEntity, resetEvaluation, getCompositeInstances, getInstances } from '@highstate/contract';
-
-async function loadLibrary(jiti, logger, modulePaths) {
-  const modules = {};
-  for (const modulePath of modulePaths) {
-    try {
-      logger.debug("loading module", { modulePath });
-      modules[modulePath] = await jiti.import(modulePath);
-      logger.debug("module loaded", { modulePath });
-    } catch (error) {
-      logger.error("module load failed", { modulePath, error });
-    }
-  }
-  const components = {};
-  const entities = {};
-  _loadLibrary(modules, components, entities);
-  logger.info("library loaded", {
-    componentCount: Object.keys(components).length,
-    entityCount: Object.keys(entities).length
-  });
-  logger.trace("library content", { components, entities });
-  return { components, entities };
-}
-function _loadLibrary(value, components, entities) {
-  if (isComponent(value)) {
-    components[value.model.type] = value;
-    return;
-  }
-  if (isEntity(value)) {
-    entities[value.type] = value;
-    return;
-  }
-  if (typeof value !== "object" || value === null) {
-    return;
-  }
-  for (const key in value) {
-    _loadLibrary(value[key], components, entities);
-  }
-}
-
-async function evaluateModules(jiti, logger, modulePaths) {
-  resetEvaluation();
-  for (const modulePath of modulePaths) {
-    try {
-      logger.debug("loading module", { modulePath });
-      await jiti.import(modulePath);
-      logger.debug("module loaded", { modulePath });
-    } catch (error) {
-      logger.error("module load failed", { modulePath, error });
-    }
-  }
-  return getInstances();
-}
-function evaluateInstances(logger, library, allInstances, instanceIds) {
-  resetEvaluation();
-  const allInstancesMap = new Map(allInstances.map((instance) => [instance.id, instance]));
-  const instanceOutputs = /* @__PURE__ */ new Map();
-  for (const instanceId of instanceIds ?? allInstancesMap.keys()) {
-    logger.debug("evaluating top-level instance", { instanceId });
-    evaluateInstance(instanceId);
-  }
-  return getCompositeInstances();
-  function evaluateInstance(instanceId) {
-    let outputs = instanceOutputs.get(instanceId);
-    if (!outputs) {
-      outputs = _evaluateInstance(instanceId);
-      instanceOutputs.set(instanceId, outputs);
-    }
-    return outputs;
-  }
-  function _evaluateInstance(instanceId) {
-    const inputs = {};
-    const instance = allInstancesMap.get(instanceId);
-    logger.info("evaluating instance", { instanceId });
-    if (!instance) {
-      throw new Error(`Instance not found: ${instanceId}`);
-    }
-    for (const [inputName, input] of Object.entries(instance.inputs ?? {})) {
-      inputs[inputName] = input.map((input2) => {
-        const evaluated = evaluateInstance(input2.instanceId);
-        return evaluated[input2.output];
-      });
-    }
-    const component = library.components[instance.type];
-    if (!component) {
-      throw new Error(`Component not found: ${instance.type}, required by instance: ${instanceId}`);
-    }
-    return component({
-      name: instance.name,
-      args: instance.args,
-      inputs
-    });
-  }
-}
-
-const data = workerData;
-const logger = pino({ name: "library-worker", level: data.logLevel });
-let jiti;
-let library;
-try {
-  logger.info("worker started");
-  logger.trace("worker data", data);
-  jiti = createJiti(import.meta.filename);
-  logger.debug("jiti created", { filename: import.meta.filename });
-  library = await loadLibrary(jiti, logger, data.modulePaths);
-  parentPort.postMessage({
-    type: "library",
-    library: {
-      components: mapValues(library.components, (component) => component.model),
-      entities: library.entities
-    }
-  });
-  logger.info("library loaded and sent");
-} catch (error) {
-  logger.error("failed to load library", error);
-  parentPort.postMessage({
-    type: "error",
-    error: error instanceof Error ? error.stack ?? error.message : error
-  });
-}
-parentPort.on("message", async (message) => {
-  try {
-    const messageData = message;
-    if (messageData.type === "evaluate-composite-instances") {
-      logger.info("received evaluation request", {
-        totalInstanceCount: messageData.allInstances.length,
-        requestedInstanceCount: messageData.instanceIds?.length ?? -1
-      });
-      logger.trace("evaluation request data", messageData);
-      const instances = evaluateInstances(
-        logger,
-        library,
-        messageData.allInstances,
-        messageData.instanceIds
-      );
-      logger.info("evaluation completed", { instanceCount: instances.length });
-      parentPort.postMessage({
-        type: "instances",
-        instances
-      });
-    } else {
-      logger.info("received module evaluation request", {
-        moduleCount: messageData.modulePaths.length
-      });
-      logger.trace("module evaluation request data", messageData);
-      const instances = await evaluateModules(jiti, logger, messageData.modulePaths);
-      logger.info("module evaluation completed", { instanceCount: instances.length });
-      parentPort.postMessage({
-        type: "instances",
-        instances
-      });
-    }
-  } catch (error) {
-    logger.error("failed to evaluate", error);
-    parentPort.postMessage({
-      type: "error",
-      error: error instanceof Error ? error.stack ?? error.message : error
-    });
-  }
-});

package/dist/runner/source-resolution-worker.mjs

@@ -1,22 +0,0 @@
-import { workerData, parentPort } from 'node:worker_threads';
-import { fileURLToPath } from 'node:url';
-import { dirname } from 'node:path';
-import pino from 'pino';
-import { resolve } from 'import-meta-resolve';
-import { readPackageJSON } from 'pkg-types';
-
-const { source, logLevel } = workerData;
-const logger = pino({ name: "source-resolution-worker", level: logLevel ?? "silent" });
-const fullPath = source.path ? `${source.package}/${source.path}` : source.package;
-const url = resolve(fullPath, import.meta.url);
-const path = fileURLToPath(url);
-const projectPath = dirname(path);
-logger.info("source path resolved", { url, path, projectPath });
-const packageJson = await readPackageJSON(projectPath);
-const allowedDependencies = Object.keys(packageJson.peerDependencies ?? {});
-logger.info("package.json read", { packageJson, allowedDependencies });
-parentPort.postMessage({
-  type: "result",
-  projectPath,
-  allowedDependencies
-});

package/dist/shared/index.d.ts

@@ -1,85 +0,0 @@
-import { H as HubModel, b as InstanceState } from '../terminal-Cm2WqcyB.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, $ as OperationOptions, _ as OperationStatus, Z as OperationType, P as ProjectOperation, g as ProjectOperationRequest, T as TerminalSession, O as applyPartialInstanceState, R as buildDependentInstanceStateMap, l as compositeInstanceSchema, N as createInstanceState, Q as createInstanceStateFrontendPatch, S as getAllDependentInstanceIds, 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, a0 as isFinalOperationStatus, W as operationOptionsSchema, V as operationStatusSchema, U as operationTypeSchema, p as positionSchema, X as projectOperationRequestSchema, Y as projectOperationSchema, a1 as terminalSessionSchema } from '../terminal-Cm2WqcyB.js';
-import { Logger } from 'pino';
-import { InstanceModel, ComponentModel, InstanceInput } from '@highstate/contract';
-import 'zod';
-
-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;
-}
-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>;
-
-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,54 +0,0 @@
-import { q as defineGraphResolver } from '../terminal-CqIsctlZ.mjs';
-export { M as CircularDependencyError, o as applyPartialInstanceState, G as buildDependentInstanceStateMap, k as compositeInstanceSchema, N as createDefaultGraphResolverBackend, a as createInputHashResolver, c as createInputResolver, b as createInstanceState, n as createInstanceStateFrontendPatch, H as getAllDependentInstanceIds, R as getMatchedInjectionInstanceInputs, O as getResolvedHubInputs, Q as getResolvedInjectionInstanceInputs, P 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, K as operationOptionsSchema, J as operationStatusSchema, I as operationTypeSchema, r as positionSchema, L as projectOperationRequestSchema, p as projectOperationSchema, t as terminalSessionSchema } from '../terminal-CqIsctlZ.mjs';
-import { Ajv } from 'ajv';
-import 'zod';
-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 };