@highstate/pulumi 0.4.1 → 0.4.2

package/dist/index.d.ts

@@ -20,9 +20,11 @@ type InputOrArray<T> = Input<T> | InputArray<T> | undefined;
 /**
  * The input of inputs of inputs of inputs, so you got the idea.
  */
-type DeepInput<T> = T extends Record<string, unknown> ? Input<{
+type DeepInput<T> = [T] extends [Record<string, unknown> | undefined] ? [T] extends [infer U | undefined] ? Input<{
+    [K in keyof U]: DeepInput<U[K]>;
+} | undefined> : Input<{
     [K in keyof T]: DeepInput<T[K]>;
-}> : T extends Array<unknown> ? Input<DeepInput<T[number]>[]> : T extends infer U | undefined ? Input<U | undefined> | undefined : Input<T>;
+}> : [T] extends [Array<unknown> | undefined] ? [T] extends [(infer U)[] | undefined] ? Input<DeepInput<U>[] | undefined> : Input<DeepInput<T>[]> : Input<T>;
 /**
  * Merges the given array of `InputOrArray` values into a single flat output array.
  *
@@ -60,19 +62,46 @@ declare function toPromise<T>(output: Output<T>): Promise<T>;
 declare function singleton<T>(factory: () => T): () => T;
 declare function namedSingleton<T>(factory: (name: string) => T): (name: string) => T;
 
+type Representation = {
+    content: string;
+    contentType?: string;
+    showQRCode?: boolean;
+    fileName?: string;
+};
+type TerminalFactory = {
+    image: string;
+    command: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    files?: Record<string, string>;
+};
+type StatusField = {
+    value: string;
+    displayName?: string;
+};
+type ExtraOutputs = {
+    $status?: Record<string, StatusField>;
+    $representation?: Representation;
+    $terminal?: TerminalFactory;
+};
+type OutputMapToDeepInputMap<T extends Record<string, unknown>> = T extends Record<string, never> ? DeepInput<ExtraOutputs> : {
+    [K in keyof T]: DeepInput<T[K]>;
+} & DeepInput<ExtraOutputs>;
 interface UnitContext<TArgs extends Record<string, ArgumentValue>, TInputs extends Record<string, unknown>, TOutputs extends Record<string, unknown>, TSecrets extends Record<string, ArgumentValue>> {
     args: TArgs;
     name: string;
     secrets: Output<TSecrets>;
     inputs: Output<TInputs>;
-    outputs(this: void, outputs: DeepInput<TOutputs>): Output<TOutputs>;
+    outputs(this: void, outputs: OutputMapToDeepInputMap<TOutputs>): Promise<unknown>;
 }
-type InputSpecToValue<T extends ComponentInputSpec> = T[2] extends true ? Static<T[0]["schema"]>[] : Static<T[0]["schema"]>;
-declare function forUnit<TArgs extends Record<string, ArgumentValue>, TInputs extends Record<string, ComponentInputSpec>, TOutputs extends Record<string, ComponentInputSpec>, TSecrets extends Record<string, ArgumentValue>>(unit: Unit<TArgs, TInputs, TOutputs, TSecrets>): UnitContext<TArgs, {
-    [K in keyof TInputs]: InputSpecToValue<TInputs[K]>;
-}, {
-    [K in keyof TOutputs]: InputSpecToValue<TOutputs[K]>;
-}, TSecrets>;
-type EntityInput<T extends Entity> = Output<Static<T["schema"]>>;
+type InputSpecToValue<T extends ComponentInputSpec> = T[2] extends true ? Static<T[0]["schema"]>[] : T[1] extends true ? Static<T[0]["schema"]> : Static<T[0]["schema"]> | undefined;
+type InputSpecMapToValueMap<T extends Record<string, ComponentInputSpec>> = T extends Record<string, never> ? Record<string, never> : {
+    [K in keyof T]: InputSpecToValue<T[K]>;
+};
+declare function forUnit<TArgs extends Record<string, ArgumentValue>, TInputs extends Record<string, ComponentInputSpec>, TOutputs extends Record<string, ComponentInputSpec>, TSecrets extends Record<string, ArgumentValue>>(unit: Unit<TArgs, TInputs, TOutputs, TSecrets>): UnitContext<TArgs, InputSpecMapToValueMap<TInputs>, InputSpecMapToValueMap<TOutputs>, TSecrets>;
+type EntityValue<T extends Entity> = Static<T["schema"]>;
+type EntityInput<T extends Entity> = Output<EntityValue<T>>;
+
+declare function getOrCreateSecret<TSecrets extends Record<string, unknown>, TResult extends TSecrets[keyof TSecrets]>(secrets: Output<TSecrets>, key: keyof TSecrets, create: () => Input<TResult>): Output<TResult>;
 
-export { type DeepInput, type EntityInput, type InputArray, type InputMap, type InputOrArray, type UnitContext, flattenInputs, forUnit, mapInputs, mapOptional, mergeInputs, mergeMapInputs, namedSingleton, singleton, toPromise };
+export { type DeepInput, type EntityInput, type EntityValue, type ExtraOutputs, type InputArray, type InputMap, type InputOrArray, type Representation, type StatusField, type TerminalFactory, type UnitContext, flattenInputs, forUnit, getOrCreateSecret, mapInputs, mapOptional, mergeInputs, mergeMapInputs, namedSingleton, singleton, toPromise };

package/dist/index.mjs

@@ -1,8 +1,199 @@
-import { all, output } from '@pulumi/pulumi';
+import { secret, Config, output, getStack, Output, StackReference, all } from '@pulumi/pulumi';
 export * from '@pulumi/pulumi';
+import { parseInstanceId } from '@highstate/contract';
+import { Type } from '@sinclair/typebox';
+import { Ajv } from 'ajv';
 
+function u$1(t,n,a){let o=r=>t(r,...n);return a===undefined?o:Object.assign(o,{lazy:a,lazyArgs:n})}
+
+function u(r,n,a){let o=r.length-n.length;if(o===0)return r(...n);if(o===1)return u$1(r,n,a);throw new Error("Wrong number of arguments")}
+
+function i(...e){return u(o,e)}function o(e,r){let a={};for(let[n,u]of Object.entries(e)){let l=r(u,n,e);a[n]=l;}return a}
+
+const createdSecrets = {};
+function getOrCreateSecret(secrets, key, create) {
+  return secrets[key].apply((value) => {
+    if (value !== undefined) {
+      createdSecrets[key] = value;
+      return value;
+    }
+    const secretValue = createdSecrets[key] ?? secret(create());
+    createdSecrets[key] = secretValue;
+    return secretValue;
+  });
+}
+
+const ajv = new Ajv();
+const stackRefMap = /* @__PURE__ */ new Map();
+function getStackRef(input) {
+  const [instanceType, instanceName] = parseInstanceId(input.instanceId);
+  const key = `organization/${instanceType}/${instanceName}`;
+  if (!stackRefMap.has(key)) {
+    stackRefMap.set(key, new StackReference(key));
+  }
+  return stackRefMap.get(key);
+}
+function getOutput(unit, input, refOrRefs) {
+  const entity = unit.entities.get(input.type);
+  if (!entity) {
+    throw new Error(`Entity '${input.type}' not found in the unit '${unit.model.type}'.`);
+  }
+  const _getOutput = (ref) => {
+    const value = getStackRef(ref).requireOutput(ref.output);
+    return value.apply((value2) => {
+      let schema = entity.schema;
+      if (input.multiple) {
+        schema = Type.Union([schema, Type.Array(schema)]);
+      }
+      if (!ajv.validate(schema, value2)) {
+        throw new Error(`Invalid output for '${input.type}': ${ajv.errorsText()}`);
+      }
+      if (Array.isArray(value2)) {
+        return value2;
+      }
+      return input.multiple ? [value2] : value2;
+    });
+  };
+  if (Array.isArray(refOrRefs)) {
+    return output(refOrRefs.map((ref) => _getOutput(ref))).apply((values) => values.flat());
+  }
+  return _getOutput(refOrRefs);
+}
+function isAnyOfSchema(schema, itemType) {
+  if (schema.anyOf) {
+    return Object.values(schema.anyOf).every(
+      (schema2) => isAnyOfSchema(schema2, itemType)
+    );
+  }
+  return schema.type === itemType;
+}
+function isStringSchema(schema) {
+  if (schema.type === "string") {
+    return true;
+  }
+  if (isAnyOfSchema(schema, "string")) {
+    return true;
+  }
+  return false;
+}
+function isNumberSchema(schema) {
+  if (schema.type === "number") {
+    return true;
+  }
+  if (isAnyOfSchema(schema, "number")) {
+    return true;
+  }
+  return false;
+}
+function isBooleanSchema(schema) {
+  if (schema.type === "boolean") {
+    return true;
+  }
+  if (isAnyOfSchema(schema, "boolean")) {
+    return true;
+  }
+  return false;
+}
 function forUnit(unit) {
-  throw new Error("Not implemented");
+  const config = new Config();
+  const args = i(unit.model.args, (arg, argName) => {
+    switch (true) {
+      case isStringSchema(arg.schema): {
+        return arg.required ? config.require(argName) : config.get(argName);
+      }
+      case isNumberSchema(arg.schema): {
+        return arg.required ? config.requireNumber(argName) : config.getNumber(argName);
+      }
+      case isBooleanSchema(arg.schema): {
+        return arg.required ? config.requireBoolean(argName) : config.getBoolean(argName);
+      }
+      default: {
+        const value = arg.required ? config.requireObject(argName) : config.getObject(argName);
+        if (value === undefined) return undefined;
+        if (!ajv.validate(arg.schema, value)) {
+          throw new Error(`Invalid config for '${argName}': ${ajv.errorsText()}`);
+        }
+        return value;
+      }
+    }
+  });
+  const secrets = output(
+    i(unit.model.secrets, (secret, secretName) => {
+      switch (true) {
+        case isStringSchema(secret.schema): {
+          return secret.required ? config.requireSecret(secretName) : config.getSecret(secretName);
+        }
+        case isNumberSchema(secret.schema): {
+          return secret.required ? config.requireSecretNumber(secretName) : config.getSecretNumber(secretName);
+        }
+        case isBooleanSchema(secret.schema): {
+          return secret.required ? config.requireSecretBoolean(secretName) : config.getSecretBoolean(secretName);
+        }
+        default: {
+          const value = secret.required ? config.requireSecretObject(secretName) : config.getSecretObject(secretName);
+          if (!ajv.validate(secret.schema, value)) {
+            throw new Error(`Invalid secret for '${secretName}': ${ajv.errorsText()}`);
+          }
+          return value;
+        }
+      }
+    })
+  );
+  const inputs = output(
+    i(unit.model.inputs, (input, inputName) => {
+      const value = input.required ? config.requireObject(`input.${inputName}`) : config.getObject(`input.${inputName}`);
+      if (!value) {
+        if (input.multiple) {
+          return output([]);
+        }
+        return output(undefined);
+      }
+      return getOutput(unit, input, value);
+    })
+  );
+  return {
+    args,
+    name: getStack(),
+    secrets,
+    inputs,
+    outputs: async (outputs) => {
+      const result = i(outputs, (outputValue, outputName) => {
+        if (outputName.startsWith("$")) {
+          if (Output.isInstance(outputValue)) {
+            return output(outputValue);
+          }
+          for (const key of Object.keys(outputValue)) {
+            outputValue[key] = output(outputValue[key]);
+          }
+          return outputValue;
+        }
+        const outputModel = unit.model.outputs[outputName];
+        if (!outputModel) {
+          throw new Error(`Output '${outputName}' not found in the unit '${unit.model.type}'.`);
+        }
+        const entity = unit.entities.get(outputModel.type);
+        if (!entity) {
+          throw new Error(
+            `Entity '${outputModel.type}' not found in the unit '${unit.model.type}'.`
+          );
+        }
+        return output(outputValue).apply((value) => {
+          if (!ajv.validate(entity.schema, value)) {
+            throw new Error(`Invalid output for '${outputModel.type}': ${ajv.errorsText()}`);
+          }
+          return value;
+        });
+      });
+      await Promise.all(Object.values(result).map((o) => outputToPromise(o)));
+      if (Object.keys(createdSecrets).length > 0) {
+        result.$secrets = createdSecrets;
+      }
+      return result;
+    }
+  };
+}
+function outputToPromise(o) {
+  return new Promise((resolve) => output(o).apply(resolve));
 }
 
 function mergeInputs(...values) {
@@ -32,8 +223,8 @@ function mergeMapInputs(...args) {
   return mapInputs(mergeInputs(...values), fn);
 }
 function mapOptional(input, func) {
-  if (input === void 0) {
-    return void 0;
+  if (input === undefined) {
+    return undefined;
   }
   return func(input);
 }
@@ -43,7 +234,7 @@ function toPromise(output2) {
 function singleton(factory) {
   let instance;
   return () => {
-    if (instance === void 0) {
+    if (instance === undefined) {
       instance = factory();
     }
     return instance;
@@ -59,4 +250,4 @@ function namedSingleton(factory) {
   };
 }
 
-export { flattenInputs, forUnit, mapInputs, mapOptional, mergeInputs, mergeMapInputs, namedSingleton, singleton, toPromise };
+export { flattenInputs, forUnit, getOrCreateSecret, mapInputs, mapOptional, mergeInputs, mergeMapInputs, namedSingleton, singleton, toPromise };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highstate/pulumi",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "type": "module",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -17,15 +17,16 @@
     "access": "public"
   },
   "scripts": {
-    "build": "pkgroll --clean-dist"
+    "build": "pkgroll --tsconfig=tsconfig.build.json"
   },
   "dependencies": {
-    "@highstate/contract": "^0.4.1",
+    "@highstate/contract": "^0.4.2",
     "@pulumi/pulumi": "^3.142.0",
-    "@sinclair/typebox": "^0.34.11"
+    "@sinclair/typebox": "^0.34.11",
+    "ajv": "^8.17.1"
   },
   "devDependencies": {
     "pkgroll": "^2.5.1"
   },
-  "gitHead": "0ebd5c9d6f0176a38e8786d239a0b0828fa635f0"
+  "gitHead": "e88c7c588267cf028c054f694d402902dc057919"
 }