@highstate/contract 0.4.1 → 0.4.2

package/dist/index.d.ts

@@ -1,24 +1,33 @@
-import { Static, TUnion, TString, TNumber, TBoolean, TArray, TLiteral, TSchema, TAnySchema, TObject, TOptional } from '@sinclair/typebox';
+import { TString, TNumber, TBoolean, TArray, TUnion, TLiteral, TRecordOrObject, TAny, Static, TSchema, TAnySchema, TObject, TOptional } from '@sinclair/typebox';
 
-type UnitRegistration = Readonly<{
+type InstanceInput<TType extends string = string> = {
+    type: TType;
+    instanceId: string;
+    output: string;
+};
+type InstanceInputMap = Record<string, InstanceInput | InstanceInput[]>;
+type BaseInstanceModel = {
+    id: string;
     type: string;
     name: string;
-    config: Readonly<Record<string, string>>;
-    dependencies: readonly string[];
-}>;
-declare function getUnitRegistrations(): Readonly<Record<string, UnitRegistration>>;
+    parentId?: string;
+    args: Record<string, unknown>;
+    inputs: InstanceInputMap;
+    outputs?: InstanceInputMap;
+};
+declare function getInstanceId(instanceType: string, instanceName: string): string;
+declare function parseInstanceId(key: string): [string, string];
 
-/**
- * The schema for a single argument value.
- *
- * This argument can have a limited set of types: primitive types, arrays of strings or numbers.
- * This limitation is due to the fact that we need to display the arguments in the UI, and we can't display more complex types.
- * Moreover, it encourages using separate components for organizing complex data.
- */
-declare const argumentValueSchema: TUnion<[TString, TNumber, TBoolean, TArray<TString>, TArray<TNumber>]>;
-type ArgumentValueSchema = typeof argumentValueSchema;
+type CompositeInstance = {
+    instance: BaseInstanceModel;
+    children: BaseInstanceModel[];
+};
+declare function resetEvaluation(): void;
+declare function getInstances(): readonly BaseInstanceModel[];
+declare function getCompositeInstances(): readonly CompositeInstance[];
+
+type ArgumentValueSchema = TString | TNumber | TBoolean | TArray<TString> | TArray<TNumber> | TUnion<TLiteral[]> | TRecordOrObject<TString, TAny> | TArray;
 type ArgumentValue = Static<ArgumentValueSchema>;
-type AllowedArgumentSchema = TString | TNumber | TBoolean | TArray<TString> | TArray<TNumber> | TUnion<TLiteral[]>;
 /**
  * The generic metadata of some contract.
  */
@@ -96,12 +105,6 @@ type Entity<TType extends string = string, TEntitySchema extends TSchema = TSche
 type EntityOptions<TType extends string, TSchema extends TAnySchema> = PartialKeys<Entity<TType, TSchema>, "sensitive" | "meta">;
 declare function defineEntity<TType extends string, TSchema extends TAnySchema>(options: EntityOptions<TType, TSchema>): Entity<TType, TSchema>;
 declare function isEntity(value: unknown): value is Entity;
-type OutputRef<TType extends string = string> = {
-    type: TType;
-    project: string;
-    stack: string;
-    output: string;
-};
 
 type ComponentArgument = {
     schema: ArgumentValueSchema;
@@ -109,10 +112,10 @@ type ComponentArgument = {
     meta: Meta;
 };
 type ComponentArgumentFullOptions = Meta & {
-    schema: AllowedArgumentSchema;
+    schema: ArgumentValueSchema;
     required?: boolean;
 };
-type ComponentArgumentOptions = AllowedArgumentSchema | ComponentArgumentFullOptions;
+type ComponentArgumentOptions = ArgumentValueSchema | ComponentArgumentFullOptions;
 type ComponentArgumentOptionsToSchema<T extends ComponentArgumentOptions> = T extends TSchema ? T : T["required"] extends false ? TOptional<T["schema"]> : T["schema"];
 type ComponentArgumentMapToValue<T extends Record<string, ComponentArgumentOptions>> = {
     [K in keyof T]: Static<ComponentArgumentOptionsToSchema<T[K]>>;
@@ -129,13 +132,18 @@ type ComponentInputFullOptions = Meta & {
     multiple?: boolean;
 };
 type ComponentInputOptions = Entity | ComponentInputFullOptions;
-type ComponentInputOptionsToOutputRef<T extends ComponentInputOptions> = T extends Entity ? OutputRef<T["type"]> : T extends ComponentInputFullOptions ? T["required"] extends false ? T["multiple"] extends true ? OutputRef<T["entity"]["type"]>[] | undefined : OutputRef<T["entity"]["type"]> | undefined : T["multiple"] extends true ? OutputRef<T["entity"]["type"]>[] : OutputRef<T["entity"]["type"]> : never;
+type ComponentInputOptionsToOutputRef<T extends ComponentInputOptions> = T extends Entity ? InstanceInput<T["type"]> : T extends ComponentInputFullOptions ? T["required"] extends false ? T["multiple"] extends true ? InstanceInput<T["entity"]["type"]>[] | undefined : InstanceInput<T["entity"]["type"]> | undefined : T["multiple"] extends true ? InstanceInput<T["entity"]["type"]>[] : InstanceInput<T["entity"]["type"]> : never;
 type ComponentInputSpec = [entity: Entity, required: boolean, multiple: boolean];
 type ComponentInputOptionsToSpec<T extends ComponentInputOptions> = T extends Entity ? [T, true, false] : T extends ComponentInputFullOptions ? T["required"] extends false ? T["multiple"] extends true ? [T["entity"], false, true] : [T["entity"], false, false] : T["multiple"] extends true ? [T["entity"], true, true] : [T["entity"], true, false] : never;
+type ComponentInputOptionsMapToSpecMap<T extends Record<string, ComponentInputOptions>> = T extends Record<string, never> ? Record<string, never> : {
+    [K in keyof T]: ComponentInputOptionsToSpec<T[K]>;
+};
 type ComponentInputMapToValue<T extends Record<string, ComponentInputOptions>> = OptionalUndefinedFields<{
     [K in keyof T]: ComponentInputOptionsToOutputRef<T[K]>;
 }>;
+type ComponentInputMapToReturnType<T extends Record<string, ComponentInputOptions>> = T extends Record<string, never> ? void : ComponentInputMapToValue<T>;
 type ComponentParams<TArgs extends Record<string, ComponentArgumentOptions>, TInputs extends Record<string, ComponentInputOptions>> = {
+    id: string;
     name: string;
     args: ComponentArgumentMapToValue<TArgs>;
     inputs: ComponentInputMapToValue<TInputs>;
@@ -152,7 +160,7 @@ type ComponentOptions<TArgs extends Record<string, ComponentArgumentOptions>, TI
     args?: TArgs;
     inputs?: TInputs;
     outputs?: TOutputs;
-    create: (params: ComponentParams<TArgs, TInputs>) => ComponentInputMapToValue<TOutputs>;
+    create: (params: ComponentParams<TArgs, TInputs>) => ComponentInputMapToReturnType<TOutputs>;
 };
 type ComponentMeta = Meta & {
     primaryIcon?: string;
@@ -160,6 +168,7 @@ type ComponentMeta = Meta & {
     secondaryIcon?: string;
     secondaryIconColor?: string;
     category?: string;
+    defaultNamePrefix?: string;
 };
 type ComponentModel = {
     /**
@@ -183,7 +192,7 @@ type ComponentModel = {
      */
     meta: ComponentMeta;
 };
-type InputSpecToOutputRef<T extends ComponentInputSpec> = T[1] extends true ? T[2] extends true ? OutputRef<T[0]["type"]>[] : OutputRef<T[0]["type"]> : T[2] extends true ? OutputRef<T[0]["type"]>[] | undefined : OutputRef<T[0]["type"]> | undefined;
+type InputSpecToOutputRef<T extends ComponentInputSpec> = T[1] extends true ? T[2] extends true ? InstanceInput<T[0]["type"]>[] : InstanceInput<T[0]["type"]> : T[2] extends true ? InstanceInput<T[0]["type"]>[] | undefined : InstanceInput<T[0]["type"]> | undefined;
 type OutputRefMap<TInputs extends Record<string, ComponentInputSpec>> = TInputs extends Record<string, [string, never, never]> ? Record<string, never> : {
     [K in keyof TInputs]: InputSpecToOutputRef<TInputs[K]>;
 };
@@ -192,6 +201,10 @@ type Component<TArgs extends Record<string, ArgumentValue> = Record<string, neve
      * The non-generic model of the component.
      */
     model: ComponentModel;
+    /**
+     * The entities used in the inputs or outputs of the component.
+     */
+    entities: Map<string, Entity>;
     /**
      * Creates the component at the evaluation time.
      */
@@ -200,11 +213,7 @@ type Component<TArgs extends Record<string, ArgumentValue> = Record<string, neve
 type ArgumentOptionsMapToStatic<T extends Record<string, ComponentArgumentOptions>> = T extends Record<string, never> ? Record<string, never> : Static<TObject<{
     [K in keyof T]: ComponentArgumentOptionsToSchema<T[K]>;
 }>>;
-declare function defineComponent<TArgs extends Record<string, ComponentArgumentOptions> = Record<string, never>, TInputs extends Record<string, ComponentInputOptions> = Record<string, never>, TOutputs extends Record<string, ComponentInputOptions> = Record<string, never>>(options: ComponentOptions<TArgs, TInputs, TOutputs>): Component<ArgumentOptionsMapToStatic<TArgs>, {
-    [K in keyof TInputs]: ComponentInputOptionsToSpec<TInputs[K]>;
-}, {
-    [K in keyof TOutputs]: ComponentInputOptionsToSpec<TOutputs[K]>;
-}>;
+declare function defineComponent<TArgs extends Record<string, ComponentArgumentOptions> = Record<string, never>, TInputs extends Record<string, ComponentInputOptions> = Record<string, never>, TOutputs extends Record<string, ComponentInputOptions> = Record<string, never>>(options: ComponentOptions<TArgs, TInputs, TOutputs>): Component<ArgumentOptionsMapToStatic<TArgs>, ComponentInputOptionsMapToSpecMap<TInputs>, ComponentInputOptionsMapToSpecMap<TOutputs>>;
 declare function isComponent(value: unknown): value is Component;
 
 type UnitOptions<TArgs extends Record<string, ComponentArgumentOptions>, TInputs extends Record<string, ComponentInputOptions>, TOutputs extends Record<string, ComponentInputOptions>, TSecrets extends Record<string, ComponentArgumentOptions>> = Omit<ComponentOptions<TArgs, TInputs, TOutputs>, "create"> & {
@@ -214,11 +223,17 @@ type UnitOptions<TArgs extends Record<string, ComponentArgumentOptions>, TInputs
 type UnitSource = {
     type: "npm";
     package: string;
+    path?: string;
     version?: string;
+} | {
+    type: "local";
     path?: string;
 };
 type UnitModel = ComponentModel & {
-    source: UnitSource;
+    /**
+     * The source of the unit.
+     */
+    source?: UnitSource;
     /**
      * The record of the secret argument schemas.
      */
@@ -229,10 +244,6 @@ type Unit<TArgs extends Record<string, ArgumentValue> = Record<string, never>, T
     model: UnitModel;
 };
 declare function isUnitModel(model: ComponentModel): model is UnitModel;
-declare function defineUnit<TArgs extends Record<string, ComponentArgumentOptions> = Record<string, never>, TInputs extends Record<string, ComponentInputOptions> = Record<string, never>, TOutputs extends Record<string, ComponentInputOptions> = Record<string, never>, TSecrets extends Record<string, ComponentArgumentOptions> = Record<string, never>>(options: UnitOptions<TArgs, TInputs, TOutputs, TSecrets>): Unit<ArgumentOptionsMapToStatic<TArgs>, {
-    [K in keyof TInputs]: ComponentInputOptionsToSpec<TInputs[K]>;
-}, {
-    [K in keyof TOutputs]: ComponentInputOptionsToSpec<TOutputs[K]>;
-}, ArgumentOptionsMapToStatic<TSecrets>>;
+declare function defineUnit<TArgs extends Record<string, ComponentArgumentOptions> = Record<string, never>, TInputs extends Record<string, ComponentInputOptions> = Record<string, never>, TOutputs extends Record<string, ComponentInputOptions> = Record<string, never>, TSecrets extends Record<string, ComponentArgumentOptions> = Record<string, never>>(options: UnitOptions<TArgs, TInputs, TOutputs, TSecrets>): Unit<ArgumentOptionsMapToStatic<TArgs>, ComponentInputOptionsMapToSpecMap<TInputs>, ComponentInputOptionsMapToSpecMap<TOutputs>, ArgumentOptionsMapToStatic<TSecrets>>;
 
-export { type ArgumentValue, type Component, type ComponentArgument, type ComponentInput, type ComponentInputSpec, type ComponentMeta, type ComponentModel, type Entity, type OutputRef, type Unit, type UnitModel, type UnitRegistration, type UnitSource, defineComponent, defineEntity, defineUnit, getUnitRegistrations, isComponent, isEntity, isUnitModel, text };
+export { type ArgumentValue, type ArgumentValueSchema, type BaseInstanceModel, type Component, type ComponentArgument, type ComponentInput, type ComponentInputSpec, type ComponentMeta, type ComponentModel, type CompositeInstance, type Entity, type InstanceInput, type InstanceInputMap, type Unit, type UnitModel, type UnitSource, defineComponent, defineEntity, defineUnit, getCompositeInstances, getInstanceId, getInstances, isComponent, isEntity, isUnitModel, parseInstanceId, resetEvaluation, text };

package/dist/index.mjs

@@ -1,12 +1,51 @@
-import { OptionalKind, Type } from '@sinclair/typebox';
+import { OptionalKind } from '@sinclair/typebox';
 import { mapValues } from 'remeda';
 
-const unitRegistrations = {};
-function getUnitRegistrations() {
-  return unitRegistrations;
+function getInstanceId(instanceType, instanceName) {
+  return `${instanceType}:${instanceName}`;
 }
-function registerUnit(unit) {
-  unitRegistrations[`${unit.type}.${unit.name}`] = unit;
+function parseInstanceId(key) {
+  const parts = key.split(":");
+  if (parts.length !== 2) {
+    throw new Error(`Invalid instance key: ${key}`);
+  }
+  return parts;
+}
+
+const instances = [];
+const compositeInstances = /* @__PURE__ */ new Map();
+let currentParentInstance = null;
+function resetEvaluation() {
+  instances.length = 0;
+  compositeInstances.clear();
+  currentParentInstance = null;
+}
+function getInstances() {
+  return instances;
+}
+function getCompositeInstances() {
+  return Array.from(compositeInstances.values());
+}
+function registerInstance(instance, fn) {
+  instances.push(instance);
+  if (currentParentInstance) {
+    instance.parentId = currentParentInstance.id;
+    let compositeInstance = compositeInstances.get(currentParentInstance.id);
+    if (!compositeInstance) {
+      compositeInstance = { instance: currentParentInstance, children: [] };
+      compositeInstances.set(currentParentInstance.id, compositeInstance);
+    }
+    compositeInstance.children.push(instance);
+  }
+  const previousParentInstance = currentParentInstance;
+  currentParentInstance = instance;
+  try {
+    const [outputs, instanceOutputs] = fn();
+    instance.outputs = instanceOutputs;
+    return outputs;
+  } finally {
+    currentParentInstance = previousParentInstance;
+  }
 }
 
 function defineEntity(options) {
@@ -23,12 +62,39 @@ function isEntity(value) {
 function defineComponent(options) {
   function create(params) {
     const { name, args, inputs } = params;
-    return options.create({
-      name,
-      args: args ?? {},
-      inputs: inputs ?? {}
-    });
+    const id = `${options.type}:${name}`;
+    return registerInstance(
+      {
+        id,
+        type: options.type,
+        name,
+        args: args ?? {},
+        inputs: inputs ?? {}
+      },
+      () => {
+        const outputs = options.create({
+          id,
+          name,
+          args: args ?? {},
+          inputs: mapValues(inputs ?? {}, (value, key) => {
+            if (Array.isArray(value)) {
+              return value.map((x) => substituteInstanceInput(id, x, key));
+            }
+            return substituteInstanceInput(id, value, key);
+          })
+        }) ?? {};
+        const substitutedOutputs = mapValues(outputs, (value, key) => {
+          if (Array.isArray(value)) {
+            return value.map((x) => substituteInstanceInput(id, x, key));
+          }
+          return substituteInstanceInput(id, value, key);
+        });
+        return [substitutedOutputs, outputs];
+      }
+    );
   }
+  create.entities = /* @__PURE__ */ new Map();
+  const mapInput = createInputMapper(create.entities);
   create.model = {
     type: options.type,
     args: mapValues(options.args ?? {}, mapArgument),
@@ -38,6 +104,13 @@ function defineComponent(options) {
   };
   return create;
 }
+function substituteInstanceInput(instanceId, input, outputKey) {
+  return {
+    type: input.type,
+    instanceId,
+    output: outputKey
+  };
+}
 function isComponent(value) {
   return typeof value === "function" && "model" in value;
 }
@@ -60,24 +133,28 @@ function mapArgument(value) {
     meta: {}
   };
 }
-function mapInput(value) {
-  if ("entity" in value) {
+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.entity.type,
-      required: value.required ?? true,
-      multiple: value.multiple ?? false,
-      meta: {
-        displayName: value.displayName,
-        description: value.description,
-        color: value.color
-      }
+      type: value.type,
+      required: true,
+      multiple: false,
+      meta: {}
     };
-  }
-  return {
-    type: value.type,
-    required: true,
-    multiple: false,
-    meta: {}
   };
 }
 
@@ -87,30 +164,21 @@ function isUnitModel(model) {
 function defineUnit(options) {
   const component = defineComponent({
     ...options,
-    create({ name, args, inputs }) {
-      registerUnit({
-        type: options.type,
-        name,
-        config: {
-          ...mapValues(args, (value) => typeof value === "string" ? value : JSON.stringify(value)),
-          ...mapValues(inputs, (value) => JSON.stringify(value))
-        },
-        dependencies: Object.values(inputs).map((value) => `${value.project}.${value.stack}`)
-      });
-      return fillUnitOutputs(name, options.type, options.outputs);
+    create({ id }) {
+      return fillUnitOutputs(id, options.outputs);
     }
   });
   component.model.source = options.source;
   component.model.secrets = mapValues(options.secrets ?? {}, mapArgument);
   return component;
 }
-function fillUnitOutputs(name, type, optionsOutputs = {}) {
+function fillUnitOutputs(instanceId, optionsOutputs = {}) {
   const outputs = {};
   for (const key in optionsOutputs) {
+    const entity = "entity" in optionsOutputs[key] ? optionsOutputs[key].entity : optionsOutputs[key];
     outputs[key] = {
-      type,
-      project: type,
-      stack: name,
+      type: entity.type,
+      instanceId,
       output: key
     };
   }
@@ -124,12 +192,4 @@ function text(array, ...values) {
   return lines.map((line) => line.slice(indent)).join("\n").trim();
 }
 
-Type.Union([
-  Type.String(),
-  Type.Number(),
-  Type.Boolean(),
-  Type.Array(Type.String()),
-  Type.Array(Type.Number())
-]);
-
-export { defineComponent, defineEntity, defineUnit, getUnitRegistrations, isComponent, isEntity, isUnitModel, text };
+export { defineComponent, defineEntity, defineUnit, getCompositeInstances, getInstanceId, getInstances, isComponent, isEntity, isUnitModel, parseInstanceId, resetEvaluation, text };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highstate/contract",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "type": "module",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -8,7 +8,7 @@
     "dist"
   ],
   "exports": {
-    "import": {
+    ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.mjs"
     }
@@ -17,7 +17,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "pkgroll --clean-dist",
+    "build": "pkgroll --tsconfig=tsconfig.build.json",
     "test": "vitest run --coverage"
   },
   "dependencies": {
@@ -29,5 +29,5 @@
     "pkgroll": "^2.5.1",
     "vitest": "^2.1.8"
   },
-  "gitHead": "0ebd5c9d6f0176a38e8786d239a0b0828fa635f0"
+  "gitHead": "e88c7c588267cf028c054f694d402902dc057919"
 }