@highstate/contract 0.7.2 → 0.7.4

package/dist/index.js

@@ -0,0 +1,240 @@
+import { mapValues, pickBy, isNonNullish } from 'remeda';
+import { OptionalKind, Type as Type$1 } from '@sinclair/typebox';
+import { Ajv } from 'ajv';
+
+const boundaryInput = Symbol("boundaryInput");
+function getInstanceId(instanceType, instanceName) {
+  return `${instanceType}:${instanceName}`;
+}
+function parseInstanceId(instanceId) {
+  const parts = instanceId.split(":");
+  if (parts.length !== 2) {
+    throw new Error(`Invalid instance key: ${instanceId}`);
+  }
+  return parts;
+}
+function findInput(inputs, name) {
+  const matchedInputs = inputs.filter(
+    (input) => parseInstanceId(input.instanceId)[1] === name || input.instanceId === name
+  );
+  if (matchedInputs.length === 0) {
+    return null;
+  }
+  if (1 < matchedInputs.length) {
+    throw new Error(
+      `Multiple inputs found for "${name}": ${matchedInputs.map((input) => input.instanceId).join(", ")}. Specify the full instance id to disambiguate.`
+    );
+  }
+  return matchedInputs[0];
+}
+function findRequiredInput(inputs, name) {
+  const input = findInput(inputs, name);
+  if (input === null) {
+    throw new Error(`Required input "${name}" not found.`);
+  }
+  return input;
+}
+
+function text(array, ...values) {
+  const str = array.reduce(
+    // eslint-disable-next-line @typescript-eslint/no-base-to-string
+    (result, part, i) => result + part + (values[i] ? String(values[i]) : ""),
+    ""
+  );
+  return trimIndentation(str);
+}
+function trimIndentation(text2) {
+  const lines = text2.split("\n");
+  const indent = lines.filter((line) => line.trim() !== "").map((line) => line.match(/^\s*/)?.[0].length ?? 0).reduce((min, indent2) => Math.min(min, indent2), Infinity);
+  return lines.map((line) => line.slice(indent)).join("\n").trim();
+}
+
+const ajv = new Ajv();
+const originalCreate = Symbol("originalCreate");
+function defineComponent(options) {
+  function create(params) {
+    const { name, args, inputs } = params;
+    const id = `${options.type}:${name}`;
+    validateArgs(id, create.model, args ?? {});
+    const flatInputs = mapValues(pickBy(inputs ?? {}, isNonNullish), (inputs2) => [inputs2].flat(2));
+    return registerInstance(
+      create.model,
+      {
+        id,
+        type: options.type,
+        name,
+        args: args ?? {},
+        inputs: mapValues(flatInputs, (inputs2) => inputs2.map((input) => input[boundaryInput] ?? input)),
+        resolvedInputs: flatInputs
+      },
+      () => {
+        const markedInputs = mapValues(flatInputs, (inputs2, key) => {
+          const result = inputs2.map((input) => ({
+            ...input,
+            [boundaryInput]: { instanceId: id, output: key }
+          }));
+          return create.model.inputs?.[key]?.multiple === false ? result[0] : result;
+        });
+        const outputs = options.create({
+          id,
+          name,
+          args: args ?? {},
+          inputs: markedInputs
+        }) ?? {};
+        return mapValues(pickBy(outputs, isNonNullish), (outputs2) => [outputs2].flat(2));
+      }
+    );
+  }
+  create.entities = /* @__PURE__ */ new Map();
+  const mapInput = createInputMapper(create.entities);
+  create.model = {
+    type: options.type,
+    args: mapValues(options.args ?? {}, mapArgument),
+    inputs: mapValues(options.inputs ?? {}, mapInput),
+    outputs: mapValues(options.outputs ?? {}, mapInput),
+    meta: options.meta ?? {}
+  };
+  create[originalCreate] = options.create;
+  return create;
+}
+function isComponent(value) {
+  return typeof value === "function" && "model" in value;
+}
+function mapArgument(value) {
+  if ("schema" in value) {
+    return {
+      schema: value.schema,
+      required: value.required ?? (!value.schema[OptionalKind] && !value.schema.default),
+      meta: {
+        displayName: value.displayName,
+        description: value.description,
+        color: value.color
+      }
+    };
+  }
+  return {
+    schema: value,
+    required: !value[OptionalKind] && !value.default,
+    meta: {}
+  };
+}
+function createInputMapper(entities) {
+  return (value) => {
+    if ("entity" in value) {
+      entities.set(value.entity.type, value.entity);
+      return {
+        type: value.entity.type,
+        required: value.required ?? true,
+        multiple: value.multiple ?? false,
+        meta: {
+          displayName: value.displayName,
+          description: value.description,
+          color: value.color
+        }
+      };
+    }
+    entities.set(value.type, value);
+    return {
+      type: value.type,
+      required: true,
+      multiple: false,
+      meta: {}
+    };
+  };
+}
+function validateArgs(instanceId, model, args) {
+  for (const [key, argModel] of Object.entries(model.args)) {
+    const value = args[key];
+    if (!value && argModel.required) {
+      throw new Error(`Missing required argument "${key}" for instance "${instanceId}"`);
+    }
+    if (value && !ajv.validate(argModel.schema, value)) {
+      throw new Error(`Invalid argument "${key}" for instance "${instanceId}": ${ajv.errorsText()}`);
+    }
+  }
+}
+
+function isUnitModel(model) {
+  return "source" in model;
+}
+function defineUnit(options) {
+  const component = defineComponent({
+    ...options,
+    create({ id }) {
+      const outputs = {};
+      for (const key in options.outputs ?? {}) {
+        outputs[key] = [
+          {
+            instanceId: id,
+            output: key
+          }
+        ];
+      }
+      return outputs;
+    }
+  });
+  component.model.source = options.source ?? {};
+  component.model.secrets = mapValues(options.secrets ?? {}, mapArgument);
+  return component;
+}
+
+const compositeInstances = /* @__PURE__ */ new Map();
+let currentCompositeInstance = null;
+function resetEvaluation() {
+  compositeInstances.clear();
+  currentCompositeInstance = null;
+}
+function getCompositeInstances() {
+  return Array.from(compositeInstances.values());
+}
+function registerInstance(component, instance, fn) {
+  if (currentCompositeInstance) {
+    instance.parentId = currentCompositeInstance.instance.id;
+    currentCompositeInstance.children.push(instance);
+  }
+  let previousParentInstance = null;
+  if (!isUnitModel(component)) {
+    previousParentInstance = currentCompositeInstance;
+    currentCompositeInstance = { instance, children: [] };
+    compositeInstances.set(currentCompositeInstance.instance.id, currentCompositeInstance);
+  }
+  try {
+    const outputs = fn();
+    instance.resolvedOutputs = outputs;
+    instance.outputs = mapValues(
+      outputs ?? {},
+      (outputs2) => outputs2.map((output) => output[boundaryInput] ?? output)
+    );
+    return mapValues(
+      outputs,
+      (outputs2, outputKey) => outputs2.map((output) => ({
+        ...output,
+        [boundaryInput]: { instanceId: instance.id, output: outputKey }
+      }))
+    );
+  } finally {
+    if (previousParentInstance) {
+      currentCompositeInstance = previousParentInstance;
+    }
+  }
+}
+
+function defineEntity(options) {
+  return {
+    meta: {},
+    ...options
+  };
+}
+function isEntity(value) {
+  return typeof value === "object" && value !== null && "type" in value && "schema" in value && "meta" in value;
+}
+
+function StringEnum(values) {
+  return Type.Union(values.map((value) => Type.Literal(value)));
+}
+const Type = {
+  ...Type$1,
+  StringEnum
+};
+
+export { Type, defineComponent, defineEntity, defineUnit, findInput, findRequiredInput, getCompositeInstances, getInstanceId, isComponent, isEntity, isUnitModel, originalCreate, parseInstanceId, resetEvaluation, text, trimIndentation };

package/package.json

@@ -1,27 +1,27 @@
 {
   "name": "@highstate/contract",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "type": "module",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.mjs"
+      "types": "./src/index.ts",
+      "default": "./dist/index.js"
     }
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "pkgroll --tsconfig=tsconfig.build.json",
+    "build": "pkgroll --clean --tsconfig=tsconfig.build.json",
     "test": "vitest run --coverage"
   },
   "dependencies": {
     "@sinclair/typebox": "^0.34.11",
+    "ajv": "^8.17.1",
     "remeda": "^2.21.0"
   },
   "devDependencies": {
@@ -29,5 +29,5 @@
     "pkgroll": "^2.5.1",
     "vitest": "^2.1.8"
   },
-  "gitHead": "e177535015e0fa3c74ae8ddc0bc6d31b191d2c54"
+  "gitHead": "c482cdf650746f6814122602d65bf5b842a2bc2c"
 }

package/src/component.spec.ts

@@ -0,0 +1,166 @@
+import { Type } from "@sinclair/typebox"
+import { describe, it } from "vitest"
+import { defineComponent } from "./component"
+import { defineEntity } from "./entity"
+
+describe("defineComponent", () => {
+  it("should return a component with no args", () => {
+    const virtualMachine = defineComponent({
+      type: "proxmox.virtual_machine",
+      create: () => ({}),
+    })
+
+    virtualMachine({
+      name: "test",
+    })
+
+    virtualMachine({
+      name: "test",
+      args: {},
+    })
+  })
+
+  it("should return a component with args", () => {
+    const virtualMachine = defineComponent({
+      type: "proxmox.virtual_machine",
+      args: {
+        cores: Type.Optional(Type.Number()),
+      },
+      create: () => ({}),
+    })
+
+    virtualMachine({
+      name: "test",
+      args: {
+        cores: 2,
+      },
+    })
+  })
+
+  it("should return a component with inputs", () => {
+    const server = defineEntity({
+      type: "common.server",
+
+      schema: Type.Object({
+        endpoint: Type.String(),
+      }),
+
+      meta: {
+        displayName: "Server",
+        description: "A server entity",
+        color: "#ff0000",
+      },
+    })
+
+    const cluster = defineComponent({
+      type: "talos.cluster",
+      inputs: {
+        servers: {
+          entity: server,
+          multiple: true,
+        },
+      },
+      create: () => ({}),
+    })
+
+    cluster({
+      name: "test",
+      inputs: {
+        servers: [
+          {
+            instanceId: "test",
+            output: "test",
+          },
+        ],
+      },
+    })
+  })
+
+  it("should return a component with outputs", () => {
+    const server = defineEntity({
+      type: "common.server",
+
+      schema: Type.Object({
+        endpoint: Type.String(),
+      }),
+
+      meta: {
+        displayName: "Server",
+        description: "A server entity",
+        color: "#ff0000",
+      },
+    })
+
+    const cluster = defineComponent({
+      type: "talos.cluster",
+      outputs: {
+        servers: {
+          entity: server,
+          multiple: true,
+          required: false,
+        },
+      },
+      create: () => ({
+        servers: [],
+      }),
+    })
+
+    cluster({
+      name: "test",
+    })
+  })
+
+  it("should return a component with args, inputs and outputs", () => {
+    const server = defineEntity({
+      type: "common.server",
+
+      schema: Type.Object({
+        endpoint: Type.String(),
+      }),
+
+      meta: {
+        displayName: "Server",
+        description: "A server entity",
+        color: "#ff0000",
+      },
+    })
+
+    const cluster = defineComponent({
+      type: "talos.cluster",
+      args: {
+        name: Type.String(),
+      },
+      inputs: {
+        servers: {
+          entity: server,
+          multiple: true,
+          required: false,
+        },
+      },
+      outputs: {
+        servers: {
+          entity: server,
+          multiple: true,
+        },
+      },
+      create: ({ inputs }) => ({ servers: inputs.servers ?? [] }),
+    })
+
+    const { servers } = cluster({
+      name: "test",
+      args: {
+        name: "test",
+      },
+      inputs: {
+        servers: [
+          {
+            instanceId: "test",
+            output: "test",
+          },
+        ],
+      },
+    })
+
+    void servers
+  })
+})