@highstate/backend 0.4.3 → 0.4.5

package/dist/terminal-C1HuyJ6e.mjs

@@ -0,0 +1,512 @@
+import { z } from 'zod';
+import { omit, unique, fromEntries } from 'remeda';
+import { sha256 } from 'crypto-hash';
+
+const positionSchema = z.object({
+  x: z.number(),
+  y: z.number()
+});
+const instanceInputSchema = z.object({
+  instanceId: z.string(),
+  output: z.string()
+});
+const hubInstanceInputSchema = z.object({
+  hubId: z.string()
+});
+const instanceModelPatchSchema = z.object({
+  args: z.record(z.unknown()).optional(),
+  inputs: z.record(z.array(instanceInputSchema)).optional(),
+  hubInputs: z.record(z.array(hubInstanceInputSchema)).optional(),
+  injectionInputs: z.array(hubInstanceInputSchema).optional(),
+  position: positionSchema.optional()
+});
+const instanceModelSchema = z.object({
+  id: z.string(),
+  type: z.string(),
+  name: z.string(),
+  ...instanceModelPatchSchema.shape,
+  parentId: z.string().optional(),
+  outputs: z.record(z.array(instanceInputSchema)).optional()
+});
+const compositeInstanceSchema = z.object({
+  instance: instanceModelSchema,
+  children: z.array(instanceModelSchema)
+});
+const hubModelPatchSchema = z.object({
+  position: positionSchema.optional(),
+  inputs: z.array(instanceInputSchema).optional(),
+  injectionInputs: z.array(hubInstanceInputSchema).optional()
+});
+const hubModelSchema = z.object({
+  id: z.string().nanoid(),
+  position: positionSchema,
+  inputs: z.array(instanceInputSchema).optional(),
+  injectionInputs: z.array(hubInstanceInputSchema).optional()
+});
+
+const instanceStatusSchema = z.enum([
+  "not_created",
+  "updating",
+  "destroying",
+  "refreshing",
+  "created",
+  "error",
+  "pending",
+  "unknown"
+]);
+const instanceStatusFieldSchema = z.object({
+  name: z.string(),
+  value: z.string().optional(),
+  displayName: z.string().optional(),
+  sensitive: z.boolean().optional(),
+  url: z.string().optional()
+});
+const instanceFileMetaSchema = z.object({
+  name: z.string(),
+  contentType: z.string(),
+  isBinary: z.boolean().optional()
+});
+const instanceFileSchema = z.object({
+  ...instanceFileMetaSchema.shape,
+  content: z.string()
+});
+const instancePageBlockSchema = z.union([
+  z.object({
+    type: z.literal("markdown"),
+    content: z.string()
+  }),
+  z.object({
+    type: z.literal("qr"),
+    content: z.string(),
+    showContent: z.coerce.boolean(),
+    language: z.string().optional()
+  }),
+  z.object({
+    type: z.literal("file"),
+    fileMeta: instanceFileMetaSchema
+  })
+]);
+const instancePageMetaSchema = z.object({
+  name: z.string(),
+  title: z.string()
+});
+const instancePageSchema = z.object({
+  ...instancePageMetaSchema.shape,
+  content: z.array(instancePageBlockSchema)
+});
+const instanceTerminalMetaSchema = z.object({
+  name: z.string(),
+  title: z.string(),
+  description: z.string().optional()
+});
+const instanceTerminalFileSchema = z.object({
+  content: z.string().optional(),
+  isBinary: z.boolean().optional()
+});
+const instanceTerminalSchema = z.object({
+  ...instanceTerminalMetaSchema.shape,
+  image: z.string(),
+  command: z.string().array(),
+  cwd: z.string().optional(),
+  env: z.record(z.string()).optional(),
+  files: z.record(instanceTerminalFileSchema).optional()
+});
+const instanceTriggerSpecSchema = z.union([
+  z.object({
+    type: z.literal("before-destroy")
+  }),
+  z.object({
+    type: z.literal("schedule"),
+    schedule: z.string()
+  })
+]);
+const instanceTriggerSchema = z.object({
+  name: z.string(),
+  title: z.string(),
+  description: z.string().optional(),
+  spec: instanceTriggerSpecSchema
+});
+const instanceTriggerInvocationSchema = z.object({
+  name: z.string()
+});
+const instanceStateSchema = z.object({
+  id: z.string(),
+  parentId: z.string().nullable().default(null),
+  status: instanceStatusSchema,
+  latestOperationId: z.string().nullable().default(null),
+  currentResourceCount: z.number().nullable().default(null),
+  totalResourceCount: z.number().nullable().default(null),
+  inputHash: z.string().nullable().default(null),
+  outputHash: z.string().nullable().default(null),
+  error: z.string().nullable().default(null),
+  statusFields: z.array(instanceStatusFieldSchema).default(() => []),
+  files: z.array(instanceFileMetaSchema).default(() => []),
+  pages: z.array(instancePageMetaSchema).default(() => []),
+  terminals: z.array(instanceTerminalMetaSchema).default(() => []),
+  triggers: z.array(instanceTriggerSchema).default(() => [])
+});
+const instanceStatePatchSchema = z.object({
+  ...instanceStateSchema.shape,
+  // secrets updated by the unit
+  secrets: z.record(z.string()).nullable(),
+  // log line emitted by the unit
+  logLine: z.string().nullable()
+}).partial();
+function createInstanceState(id, status = "not_created", fields = {}) {
+  return {
+    id,
+    parentId: null,
+    status,
+    latestOperationId: null,
+    currentResourceCount: null,
+    totalResourceCount: null,
+    inputHash: null,
+    outputHash: null,
+    error: null,
+    statusFields: [],
+    files: [],
+    pages: [],
+    terminals: [],
+    triggers: [],
+    ...fields
+  };
+}
+function applyPartialInstanceState(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 !== void 0) {
+    state.status = patch.status;
+  }
+  if (patch.latestOperationId !== void 0) {
+    state.latestOperationId = patch.latestOperationId;
+  }
+  if (patch.currentResourceCount !== void 0) {
+    state.currentResourceCount = patch.currentResourceCount;
+  }
+  if (patch.totalResourceCount !== void 0) {
+    state.totalResourceCount = patch.totalResourceCount;
+  }
+  if (patch.inputHash !== void 0) {
+    state.inputHash = patch.inputHash;
+  }
+  if (patch.outputHash !== void 0) {
+    state.outputHash = patch.outputHash;
+  }
+  if (patch.error !== void 0) {
+    state.error = patch.error;
+  }
+  if (patch.statusFields !== void 0) {
+    state.statusFields = patch.statusFields;
+  }
+  if (patch.files !== void 0) {
+    state.files = patch.files;
+  }
+  if (patch.pages !== void 0) {
+    state.pages = patch.pages;
+  }
+  if (patch.terminals !== void 0) {
+    state.terminals = patch.terminals;
+  }
+  if (patch.triggers !== void 0) {
+    state.triggers = patch.triggers;
+  }
+  return state;
+}
+function createInstanceStateFrontendPatch(patch) {
+  return omit(patch, ["secrets", "logLine"]);
+}
+
+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())
+});
+function isFinalOperationStatus(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+
+class CircularDependencyError extends Error {
+  constructor(path) {
+    super(`Circular dependency detected: ${path.join(" -> ")}`);
+    this.name = "CircularDependencyError";
+  }
+}
+function createDefaultGraphResolverBackend() {
+  const promiseCache = /* @__PURE__ */ new Map();
+  return {
+    promiseCache,
+    setOutput() {
+    },
+    setDependencies() {
+    }
+  };
+}
+function defineGraphResolver(options) {
+  return (nodes, logger, backend) => {
+    backend ??= createDefaultGraphResolverBackend();
+    const resolver = (itemId, dependencyChain) => {
+      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(void 0);
+      }
+      const resolve = async () => {
+        const dependencies = unique(options.getNodeDependencies(item));
+        backend.setDependencies(itemId, dependencies);
+        logger.trace({ itemId, dependencies }, "resolving item dependencies");
+        const resolvedDependencies = /* @__PURE__ */ new Map();
+        const newChain = [...dependencyChain, itemId];
+        for (const depId of dependencies) {
+          const depResult = await resolver(depId, newChain);
+          if (depResult !== void 0) {
+            resolvedDependencies.set(depId, depResult);
+          }
+        }
+        return await options.process(item, resolvedDependencies, logger);
+      };
+      const promise = resolve().then((result) => {
+        if (backend.promiseCache.get(itemId) === promise) {
+          backend.setOutput(itemId, result);
+        }
+        return result;
+      });
+      backend.promiseCache.set(itemId, promise);
+      return promise;
+    };
+    return (id) => resolver(id, []);
+  };
+}
+
+const createInputResolver = defineGraphResolver({
+  getNodeId(node) {
+    if (node.kind === "hub") {
+      return `hub:${node.hub.id}`;
+    }
+    return `instance:${node.instance.id}`;
+  },
+  getNodeDependencies(node) {
+    const dependencies = [];
+    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.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) => {
+      const output = dependencies.get(`hub:${input.hubId}`);
+      if (!output) {
+        throw new Error("Hub not found");
+      }
+      if (output.kind !== "hub") {
+        throw new Error("Expected hub node");
+      }
+      return output;
+    };
+    const getInstanceOutput = (input) => {
+      const output = dependencies.get(`instance:${input.instanceId}`);
+      if (!output) {
+        throw new Error("Instance not found");
+      }
+      if (output.kind !== "instance") {
+        throw new Error("Expected instance node");
+      }
+      return output;
+    };
+    if (node.kind === "hub") {
+      const hubResult = /* @__PURE__ */ new Map();
+      const addHubResult = (input) => {
+        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: resolvedInputs2 } = getHubOutput(injectionInput);
+        for (const input of resolvedInputs2) {
+          addHubResult(input);
+        }
+      }
+      return {
+        kind: "hub",
+        resolvedInputs: Array.from(hubResult.values())
+      };
+    }
+    const resolvedInputsMap = /* @__PURE__ */ new Map();
+    const addInstanceResult = (inputName, input) => {
+      let inputs = resolvedInputsMap.get(inputName);
+      if (!inputs) {
+        inputs = /* @__PURE__ */ new Map();
+        resolvedInputsMap.set(inputName, inputs);
+      }
+      inputs.set(`${input.input.instanceId}:${input.input.output}`, input);
+    };
+    for (const [inputName, inputs] of Object.entries(node.instance.inputs ?? {})) {
+      for (const input of inputs) {
+        const componentInput = node.component.inputs[inputName];
+        if (!componentInput) {
+          logger.warn({ msg: "input not found in the component", input, component: node.component });
+          continue;
+        }
+        addInstanceResult(inputName, { input, type: componentInput.type });
+      }
+    }
+    const injectionInputs = /* @__PURE__ */ new Map();
+    const matchedInjectionInputs = /* @__PURE__ */ new Map();
+    for (const injectionInput of node.instance.injectionInputs ?? []) {
+      const { resolvedInputs: resolvedInputs2 } = getHubOutput(injectionInput);
+      for (const input of resolvedInputs2) {
+        injectionInputs.set(`${input.input.instanceId}:${input.input.output}`, input);
+      }
+    }
+    for (const [inputName, componentInput] of Object.entries(node.component.inputs ?? {})) {
+      const allInputs = new Map(injectionInputs);
+      const hubInputs = node.instance.hubInputs?.[inputName] ?? [];
+      for (const hubInput of hubInputs) {
+        const { resolvedInputs: resolvedInputs2 } = getHubOutput(hubInput);
+        for (const input of resolvedInputs2) {
+          allInputs.set(`${input.input.instanceId}:${input.input.output}`, input);
+        }
+      }
+      for (const input of allInputs.values()) {
+        if (input.type === componentInput.type) {
+          addInstanceResult(inputName, 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,
+      resolvedInjectionInputs: Array.from(injectionInputs.values()),
+      matchedInjectionInputs: Array.from(matchedInjectionInputs.values())
+    };
+  }
+});
+function getResolvedHubInputs(output) {
+  if (output.kind !== "hub") {
+    throw new Error("Expected hub node");
+  }
+  return output.resolvedInputs;
+}
+function getResolvedInstanceInputs(output) {
+  if (output.kind !== "instance") {
+    throw new Error("Expected instance node");
+  }
+  return output.resolvedInputs;
+}
+function getResolvedInjectionInstanceInputs(output) {
+  if (output.kind !== "instance") {
+    throw new Error("Expected instance node");
+  }
+  return output.resolvedInjectionInputs;
+}
+function getMatchedInjectionInstanceInputs(output) {
+  if (output.kind !== "instance") {
+    throw new Error("Expected instance node");
+  }
+  return output.matchedInjectionInputs;
+}
+
+const createInputHashResolver = 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;
+  },
+  async process({ instance, resolvedInputs, sourceHash, state }, dependencies) {
+    let sink = JSON.stringify(instance.args ?? {});
+    if (sourceHash) {
+      sink += sourceHash;
+    }
+    if (state?.outputHash) {
+      sink += state.outputHash;
+    }
+    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) {
+        sink += dependencies.get(instanceId);
+      }
+    }
+    return await sha256(sink);
+  }
+});
+
+const terminalSessionSchema = z.object({
+  id: z.string().uuid(),
+  terminalName: z.string()
+});
+
+export { instancePageMetaSchema as A, instanceTerminalMetaSchema as B, instanceTerminalFileSchema as C, instanceTriggerSpecSchema as D, instanceTriggerInvocationSchema as E, instanceStatePatchSchema as F, operationTypeSchema as G, operationStatusSchema as H, projectOperationRequestSchema as I, CircularDependencyError as J, createDefaultGraphResolverBackend as K, getResolvedHubInputs as L, getResolvedInstanceInputs as M, getResolvedInjectionInstanceInputs as N, getMatchedInjectionInstanceInputs as O, createInputHashResolver as a, createInstanceState as b, createInputResolver as c, instanceTerminalSchema as d, instancePageSchema as e, instanceFileSchema as f, instanceStatusFieldSchema as g, hubModelSchema as h, instanceModelSchema as i, instanceTriggerSchema as j, compositeInstanceSchema as k, instanceStateSchema as l, isFinalOperationStatus as m, applyPartialInstanceState as n, createInstanceStateFrontendPatch as o, projectOperationSchema as p, defineGraphResolver as q, positionSchema as r, instanceInputSchema as s, terminalSessionSchema as t, hubInstanceInputSchema as u, instanceModelPatchSchema as v, hubModelPatchSchema as w, instanceStatusSchema as x, instanceFileMetaSchema as y, instancePageBlockSchema as z };