@highstate/backend 0.4.1 → 0.4.2

package/dist/input-hash-C8HEDMjz.mjs

@@ -0,0 +1,292 @@
+import { z } from 'zod';
+import '@highstate/contract';
+import { sha256 } from 'crypto-hash';
+
+const positionSchema = z.object({
+  x: z.number(),
+  y: z.number()
+});
+const instanceInputSchema = z.object({
+  type: z.string(),
+  instanceId: z.string(),
+  output: z.string()
+});
+const instanceInputMapSchema = z.record(
+  z.union([instanceInputSchema, z.array(instanceInputSchema)])
+);
+const instanceModelSchema = z.object({
+  id: z.string(),
+  parentId: z.string().optional(),
+  type: z.string(),
+  name: z.string(),
+  position: positionSchema.optional(),
+  args: z.record(z.unknown()),
+  inputs: instanceInputMapSchema,
+  outputs: instanceInputMapSchema.optional()
+});
+const compositeInstanceSchema = z.object({
+  instance: instanceModelSchema,
+  children: z.array(instanceModelSchema)
+});
+
+const instanceStatusSchema = z.enum([
+  "not_created",
+  "updating",
+  "destroying",
+  "refreshing",
+  "created",
+  "error",
+  "pending",
+  "unknown"
+]);
+const instanceStatusFieldSchema = z.object({
+  value: z.string().optional(),
+  sensitive: z.boolean().optional(),
+  displayName: z.string().optional()
+});
+const instanceStatusFieldMapSchema = z.record(instanceStatusFieldSchema);
+const instanceRepresentationMetaSchema = z.object({
+  showQRCode: z.boolean().optional(),
+  contentType: z.string().optional(),
+  fileName: z.string().optional()
+});
+const instanceRepresentationSchema = z.object({
+  ...instanceRepresentationMetaSchema.shape,
+  content: z.string()
+});
+const terminalFactorySchema = z.object({
+  image: z.string(),
+  command: z.string().array(),
+  cwd: z.string().optional(),
+  env: z.record(z.string()).optional(),
+  files: z.record(z.string()).optional()
+});
+const instanceStatePatchSchema = z.object({
+  id: z.string(),
+  status: instanceStatusSchema.optional(),
+  latestOperationId: z.string().nullable().optional(),
+  currentResourceCount: z.number().nullable().optional(),
+  totalResourceCount: z.number().nullable().optional(),
+  dependentKeys: z.array(z.string()).nullable().optional(),
+  inputHash: z.string().nullable().optional(),
+  error: z.string().nullable().optional(),
+  message: z.string().nullable().optional(),
+  // secrets updated by the unit
+  secrets: z.record(z.string()).nullable().optional(),
+  statusFields: instanceStatusFieldMapSchema.nullable().optional(),
+  representationMeta: instanceRepresentationMetaSchema.nullable().optional(),
+  hasTerminal: z.boolean().optional()
+});
+const instanceStateSchema = z.object({
+  id: z.string(),
+  parentId: z.string().nullable(),
+  status: instanceStatusSchema,
+  latestOperationId: z.string().nullable(),
+  currentResourceCount: z.number().nullable(),
+  totalResourceCount: z.number().nullable(),
+  dependentKeys: z.array(z.string()).nullable(),
+  inputHash: z.string().nullable(),
+  error: z.string().nullable(),
+  statusFields: instanceStatusFieldMapSchema.nullable(),
+  representationMeta: instanceRepresentationMetaSchema.nullable(),
+  hasTerminal: z.boolean()
+});
+function createInstanceState(id, status = "not_created", fields = {}) {
+  return {
+    id,
+    parentId: null,
+    status,
+    latestOperationId: null,
+    currentResourceCount: null,
+    totalResourceCount: null,
+    dependentKeys: null,
+    inputHash: null,
+    error: null,
+    statusFields: null,
+    representationMeta: null,
+    hasTerminal: false,
+    ...fields
+  };
+}
+function applyInstanceStatePatch(states, patch) {
+  let state = states.get(patch.id);
+  if (!state) {
+    state = createInstanceState(patch.id, "unknown");
+    states.set(patch.id, state);
+  }
+  if (patch.status !== undefined) {
+    state.status = patch.status;
+  }
+  if (patch.latestOperationId !== undefined) {
+    state.latestOperationId = patch.latestOperationId;
+  }
+  if (patch.currentResourceCount !== undefined) {
+    state.currentResourceCount = patch.currentResourceCount;
+  }
+  if (patch.totalResourceCount !== undefined) {
+    state.totalResourceCount = patch.totalResourceCount;
+  }
+  if (patch.dependentKeys !== undefined) {
+    state.dependentKeys = patch.dependentKeys;
+  }
+  if (patch.inputHash !== undefined) {
+    state.inputHash = patch.inputHash;
+  }
+  if (patch.error !== undefined) {
+    state.error = patch.error;
+  }
+  if (patch.statusFields !== undefined) {
+    state.statusFields = patch.statusFields;
+  }
+  if (patch.representationMeta !== undefined) {
+    state.representationMeta = patch.representationMeta;
+  }
+  if (patch.hasTerminal !== undefined) {
+    state.hasTerminal = patch.hasTerminal;
+  }
+  return state;
+}
+function applyInstanceStateFrontendPatch(states, patch) {
+  if (!patch.id) {
+    throw new Error("The ID of the instance state is required.");
+  }
+  let state = states.get(patch.id);
+  if (!state) {
+    state = createInstanceState(patch.id, "unknown");
+    states.set(patch.id, state);
+  }
+  if (patch.status !== undefined) {
+    state.status = patch.status;
+  }
+  if (patch.latestOperationId !== undefined) {
+    state.latestOperationId = patch.latestOperationId;
+  }
+  if (patch.currentResourceCount !== undefined) {
+    state.currentResourceCount = patch.currentResourceCount;
+  }
+  if (patch.totalResourceCount !== undefined) {
+    state.totalResourceCount = patch.totalResourceCount;
+  }
+  if (patch.dependentKeys !== undefined) {
+    state.dependentKeys = patch.dependentKeys;
+  }
+  if (patch.inputHash !== undefined) {
+    state.inputHash = patch.inputHash;
+  }
+  if (patch.error !== undefined) {
+    state.error = patch.error;
+  }
+  if (patch.statusFields !== undefined) {
+    state.statusFields = patch.statusFields;
+  }
+  if (patch.representationMeta !== undefined) {
+    state.representationMeta = patch.representationMeta;
+  }
+  if (patch.hasTerminal !== undefined) {
+    state.hasTerminal = patch.hasTerminal;
+  }
+  return state;
+}
+function createInstanceStateFrontendPatch(patch) {
+  return {
+    id: patch.id,
+    status: patch.status,
+    latestOperationId: patch.latestOperationId,
+    currentResourceCount: patch.currentResourceCount,
+    totalResourceCount: patch.totalResourceCount,
+    dependentKeys: patch.dependentKeys,
+    inputHash: patch.inputHash,
+    error: patch.error,
+    statusFields: patch.statusFields,
+    representationMeta: patch.representationMeta,
+    hasTerminal: patch.hasTerminal
+  };
+}
+
+const operationTypeSchema = z.enum(["update", "destroy", "recreate", "refresh", "evaluate"]);
+const operationStatusSchema = z.enum([
+  "pending",
+  "evaluating",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+const projectOperationSchema = z.object({
+  id: z.string().uuid(),
+  projectId: z.string(),
+  type: operationTypeSchema,
+  status: operationStatusSchema,
+  instanceIds: z.array(z.string()),
+  error: z.string().nullable(),
+  startedAt: z.number(),
+  completedAt: z.number().nullable()
+});
+const projectOperationRequestSchema = z.object({
+  projectId: z.string(),
+  type: operationTypeSchema,
+  instanceIds: z.array(z.string())
+});
+
+class InputHashCalculator {
+  constructor(instances) {
+    this.instances = instances;
+  }
+  cache = /* @__PURE__ */ new Map();
+  promiseCache = /* @__PURE__ */ new Map();
+  reset(instanceId) {
+    this.cache.delete(instanceId);
+  }
+  async calculate(instance) {
+    const entry = await this.calculateFull(instance);
+    return entry.inputHash;
+  }
+  async calculateFull(instance) {
+    const existingPromise = this.promiseCache.get(instance.id);
+    if (existingPromise) {
+      return existingPromise;
+    }
+    const promise = this._calculate(instance).finally(() => this.promiseCache.delete(instance.id));
+    this.promiseCache.set(instance.id, promise);
+    return promise;
+  }
+  async _calculate(instance) {
+    let entry = this.cache.get(instance.id);
+    if (entry) return entry;
+    if (entry === null) {
+      throw new Error(`Circular dependency detected: ${instance.id}`);
+    }
+    this.cache.set(instance.id, null);
+    let sink = JSON.stringify(instance.args);
+    const dependencies = [];
+    const updateWithInput = async (inputName, input) => {
+      const inputInstance = this.instances.get(input.instanceId);
+      if (!inputInstance) {
+        throw new Error(`Instance not found: ${input.instanceId}`);
+      }
+      const inputEntry = await this.calculateFull(inputInstance);
+      inputEntry.dependents.push(inputInstance.id);
+      dependencies.push(inputInstance.id);
+      sink += inputName;
+      sink += inputEntry.inputHash;
+    };
+    for (const [inputName, input] of Object.entries(instance.inputs)) {
+      if (!Array.isArray(input)) {
+        await updateWithInput(inputName, input);
+        continue;
+      }
+      for (const inputRef of input) {
+        await updateWithInput(inputName, inputRef);
+      }
+    }
+    entry = {
+      inputHash: await sha256(sink),
+      dependents: [],
+      dependencies
+    };
+    this.cache.set(instance.id, entry);
+    return entry;
+  }
+}
+
+export { InputHashCalculator as I, instanceInputMapSchema as a, instanceModelSchema as b, compositeInstanceSchema as c, instanceStatusSchema as d, instanceStatusFieldSchema as e, instanceStatusFieldMapSchema as f, instanceRepresentationMetaSchema as g, instanceRepresentationSchema as h, instanceInputSchema as i, instanceStatePatchSchema as j, instanceStateSchema as k, createInstanceState as l, applyInstanceStatePatch as m, applyInstanceStateFrontendPatch as n, createInstanceStateFrontendPatch as o, positionSchema as p, operationTypeSchema as q, operationStatusSchema as r, projectOperationSchema as s, terminalFactorySchema as t, projectOperationRequestSchema as u };

package/dist/library/worker/main.mjs

@@ -0,0 +1,169 @@
+import { parentPort, workerData } 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';
+
+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)) {
+      if (!Array.isArray(input)) {
+        const outputs = evaluateInstance(input.instanceId);
+        inputs[inputName] = outputs[input.output];
+        continue;
+      }
+      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
+    });
+  }
+});