@highstate/pulumi 0.4.4 → 0.4.6

package/dist/index.d.ts

@@ -16,7 +16,7 @@ type InputMap<T> = Input<Readonly<Record<string, Input<T>>>>;
 /**
  * The input or input array type for a value.
  */
-type InputOrArray<T> = Input<T> | InputArray<T> | undefined;
+type InputOrArray<T> = Input<T> | InputArray<T>;
 /**
  * The input of inputs of inputs of inputs, so you got the idea.
  */
@@ -31,14 +31,7 @@ type DeepInput<T> = [T] extends [Record<string, unknown> | undefined] ? [T] exte
  * @param values The values to merge.
  * @returns The merged output array.
  */
-declare function mergeInputs<T>(...values: InputOrArray<T>[]): Output<T[]>;
-/**
- * Flattens an array of input arrays into a single output array.
- *
- * @param array The input array.
- * @returns The output array.
- */
-declare function flattenInputs<T>(array: InputArray<InputArray<T>>): Output<T[]>;
+declare function flattenInputs<T>(...values: (InputOrArray<T> | undefined)[]): Output<T[]>;
 /**
  * Maps each element of an input array to a new value.
  * Produces an output array with the same length.
@@ -48,8 +41,8 @@ declare function flattenInputs<T>(array: InputArray<InputArray<T>>): Output<T[]>
  * @returns The output array.
  */
 declare function mapInputs<T, U>(array: InputArray<T>, fn: (v: Unwrap<T>, index: number, all: Unwrap<T>[]) => U): Output<U[]>;
-declare function mergeMapInputs<T, U>(v1: InputOrArray<T>, v2: InputOrArray<T>, fn: (v: Unwrap<T>, index: number, all: Unwrap<T>[]) => U): Output<U[]>;
-declare function mergeMapInputs<T, U>(v1: InputOrArray<T>, v2: InputOrArray<T>, v3: InputOrArray<T>, fn: (v: Unwrap<T>, index: number, all: Unwrap<T>[]) => U): Output<U[]>;
+declare function flatMapInput<T, U>(v1: InputOrArray<T>, v2: InputOrArray<T>, fn: (v: Unwrap<T>, index: number, all: Unwrap<T>[]) => U): Output<U[]>;
+declare function flatMapInput<T, U>(v1: InputOrArray<T>, v2: InputOrArray<T>, v3: InputOrArray<T>, fn: (v: Unwrap<T>, index: number, all: Unwrap<T>[]) => U): Output<U[]>;
 /**
  * Map an optional value to another optional value.
  *
@@ -58,40 +51,92 @@ declare function mergeMapInputs<T, U>(v1: InputOrArray<T>, v2: InputOrArray<T>,
  * @returns The output value, or `undefined` if the input value is `undefined`.
  */
 declare function mapOptional<T, U>(input: T | undefined, func: (value: T) => U): U | undefined;
-declare function toPromise<T>(output: Output<T>): Promise<T>;
+declare function toPromise<T>(input: Input<T>): Promise<Unwrap<T>>;
 declare function singleton<T>(factory: () => T): () => T;
-declare function namedSingleton<T>(factory: (name: string) => T): (name: string) => T;
+declare function providerFactory<TInput>(factory: (name: string) => TInput): (name: string) => TInput;
+declare function mergeInputObjects<T1 extends Record<string, unknown>, T2 extends Record<string, unknown>>(obj1: Input<T1 | undefined> | undefined, obj2: Input<T2 | undefined> | undefined): Output<T1 & T2>;
+declare function mergeInputObjects<T1 extends Record<string, unknown>, T2 extends Record<string, unknown>, T3 extends Record<string, unknown>>(obj1: Input<T1 | undefined> | undefined, obj2: Input<T2 | undefined> | undefined, obj3: Input<T3 | undefined> | undefined): Output<T1 & T2 & T3>;
+declare function normalize<T>(item: T | undefined, collection: T[] | undefined): T[];
+declare function apply<T, U>(fn: (value: Unwrap<T>) => U): (input: Input<T>) => Output<U>;
 
-type Representation = {
-    content: string;
-    contentType?: string;
-    showQRCode?: boolean;
-    fileName?: string;
+type InstanceTerminalFile = {
+    content: Input<string | undefined>;
+    isBinary?: Input<boolean>;
 };
-type TerminalFactory = {
-    image: string;
-    command: string[];
-    cwd?: string;
-    env?: Record<string, string>;
-    files?: Record<string, string>;
+type InstanceTerminal = {
+    name: Input<string>;
+    title: Input<string>;
+    description?: Input<string>;
+    image: Input<string>;
+    command: InputArray<string>;
+    cwd?: Input<string | undefined>;
+    env?: InputMap<string | undefined>;
+    files?: InputMap<InstanceTerminalFile | string | undefined>;
 };
 type StatusField = {
-    value: string;
-    displayName?: string;
+    name: Input<string>;
+    value?: Input<string | undefined>;
+    displayName?: Input<string | undefined>;
+    sensitive?: Input<boolean | undefined>;
+    url?: Input<string | undefined>;
+};
+type InstanceFile = {
+    name: Input<string>;
+    contentType: Input<string>;
+    content: Input<string>;
+};
+type InstancePageBlock = {
+    type: "markdown";
+    content: Input<string>;
+} | {
+    type: "qr";
+    content: Input<string>;
+    showContent?: boolean;
+    language?: string;
+} | {
+    type: "file";
+    fileMeta: Omit<InstanceFile, "content">;
+};
+type InstancePage = {
+    name: Input<string>;
+    title: Input<string>;
+    content: InputArray<InstancePageBlock>;
+};
+type InstanceTriggerSpec = {
+    type: "before-destroy";
+} | {
+    type: "schedule";
+    schedule: string;
+};
+type InstanceTrigger = {
+    name: Input<string>;
+    title: Input<string>;
+    description?: Input<string>;
+    spec: Input<InstanceTriggerSpec>;
 };
 type ExtraOutputs = {
-    $status?: Record<string, StatusField>;
-    $representation?: Representation;
-    $terminal?: TerminalFactory;
+    $status?: InputMap<Omit<StatusField, "name"> | string | undefined> | InputArray<StatusField | undefined>;
+    $terminals?: InputMap<Omit<InstanceTerminal, "name"> | undefined> | InputArray<InstanceTerminal | undefined>;
+    $pages?: InputMap<Omit<InstancePage, "name"> | undefined> | InputArray<InstancePage | undefined>;
+    $files?: InputMap<Omit<InstanceFile, "name"> | undefined> | InputArray<InstanceFile | undefined>;
+    $triggers?: InputMap<Omit<InstanceTrigger, "name"> | undefined> | InputArray<InstanceTrigger | undefined>;
 };
-type OutputMapToDeepInputMap<T extends Record<string, unknown>> = T extends Record<string, never> ? DeepInput<ExtraOutputs> : {
+type InstanceTriggerInvocation = {
+    name: string;
+};
+type OutputMapToDeepInputMap<T extends Record<string, unknown>> = T extends Record<string, never> ? ExtraOutputs : {
     [K in keyof T]: DeepInput<T[K]>;
-} & DeepInput<ExtraOutputs>;
+} & 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;
+    instanceId: string;
+    type: string;
     name: string;
     secrets: Output<TSecrets>;
-    inputs: Output<TInputs>;
+    inputs: {
+        [K in keyof TInputs]: undefined extends TInputs[K] ? Output<NonNullable<TInputs[K]>> | undefined : Output<TInputs[K]>;
+    };
+    invokedTriggers: InstanceTriggerInvocation[];
     outputs(this: void, outputs: OutputMapToDeepInputMap<TOutputs>): Promise<unknown>;
 }
 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;
@@ -104,4 +149,7 @@ 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 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 };
+declare function resolvePackagePath(packageName: string, path: string, parent: string): string;
+declare function readResolvedPackageFileSync(packageName: string, path: string, parent: string): string;
+
+export { type DeepInput, type EntityInput, type EntityValue, type ExtraOutputs, type InputArray, type InputMap, type InputOrArray, type InstanceFile, type InstancePage, type InstancePageBlock, type InstanceTerminal, type InstanceTerminalFile, type InstanceTrigger, type InstanceTriggerInvocation, type InstanceTriggerSpec, type StatusField, type UnitContext, apply, flatMapInput, flattenInputs, forUnit, getOrCreateSecret, mapInputs, mapOptional, mergeInputObjects, normalize, providerFactory, readResolvedPackageFileSync, resolvePackagePath, singleton, toPromise };

package/dist/index.mjs

@@ -1,19 +1,18 @@
-import { secret, Config, output, getStack, Output, StackReference, all } from '@pulumi/pulumi';
+import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import { secret, Config, output, getStack, StackReference, all } from '@pulumi/pulumi';
 export * from '@pulumi/pulumi';
-import { parseInstanceId } from '@highstate/contract';
+import { getInstanceId, parseInstanceId } from '@highstate/contract';
 import { Type } from '@sinclair/typebox';
+import { mapValues, pipe, pickBy } from 'remeda';
 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}
+import { fileURLToPath } from 'node:url';
+import { readFileSync } from 'node:fs';
+import { resolve as resolve$1 } from 'node:path';
+import { resolve } from 'import-meta-resolve';
 
 const createdSecrets = {};
 function getOrCreateSecret(secrets, key, create) {
   return secrets[key].apply((value) => {
-    if (value !== undefined) {
+    if (value !== void 0) {
       createdSecrets[key] = value;
       return value;
     }
@@ -33,7 +32,7 @@ function getStackRef(input) {
   }
   return stackRefMap.get(key);
 }
-function getOutput(unit, input, refOrRefs) {
+function getOutput(unit, input, refs) {
   const entity = unit.entities.get(input.type);
   if (!entity) {
     throw new Error(`Entity '${input.type}' not found in the unit '${unit.model.type}'.`);
@@ -54,10 +53,11 @@ function getOutput(unit, input, refOrRefs) {
       return input.multiple ? [value2] : value2;
     });
   };
-  if (Array.isArray(refOrRefs)) {
-    return output(refOrRefs.map((ref) => _getOutput(ref))).apply((values) => values.flat());
+  const values = output(refs.map((ref) => _getOutput(ref))).apply((values2) => values2.flat());
+  if (!input.multiple) {
+    return values.apply((values2) => values2[0]);
   }
-  return _getOutput(refOrRefs);
+  return values;
 }
 function isAnyOfSchema(schema, itemType) {
   if (schema.anyOf) {
@@ -96,7 +96,7 @@ function isBooleanSchema(schema) {
 }
 function forUnit(unit) {
   const config = new Config();
-  const args = i(unit.model.args, (arg, argName) => {
+  const args = mapValues(unit.model.args, (arg, argName) => {
     switch (true) {
       case isStringSchema(arg.schema): {
         return arg.required ? config.require(argName) : config.get(argName);
@@ -109,7 +109,7 @@ function forUnit(unit) {
       }
       default: {
         const value = arg.required ? config.requireObject(argName) : config.getObject(argName);
-        if (value === undefined) return undefined;
+        if (value === void 0) return void 0;
         if (!ajv.validate(arg.schema, value)) {
           throw new Error(`Invalid config for '${argName}': ${ajv.errorsText()}`);
         }
@@ -118,7 +118,7 @@ function forUnit(unit) {
     }
   });
   const secrets = output(
-    i(unit.model.secrets, (secret, secretName) => {
+    mapValues(unit.model.secrets, (secret, secretName) => {
       switch (true) {
         case isStringSchema(secret.schema): {
           return secret.required ? config.requireSecret(secretName) : config.getSecret(secretName);
@@ -139,33 +139,45 @@ function forUnit(unit) {
       }
     })
   );
-  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);
+  const inputs = mapValues(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 getOutput(unit, input, value);
-    })
-  );
+      return void 0;
+    }
+    return getOutput(unit, input, value);
+  });
+  const type = unit.model.type;
+  const name = getStack();
   return {
     args,
-    name: getStack(),
+    instanceId: getInstanceId(type, name),
+    type,
+    name,
     secrets,
     inputs,
+    invokedTriggers: config.getObject("$invokedTriggers") ?? [],
     outputs: async (outputs) => {
-      const result = i(outputs, (outputValue, outputName) => {
+      const result = mapValues(outputs, (outputValue, outputName) => {
+        if (outputName === "$status") {
+          return output(outputValue).apply(mapStatus);
+        }
+        if (outputName === "$pages") {
+          return output(outputValue).apply(mapPages);
+        }
+        if (outputName === "$files") {
+          return output(outputValue).apply(mapFiles);
+        }
+        if (outputName === "$terminals") {
+          return output(outputValue).apply(mapTerminals);
+        }
+        if (outputName === "$triggers") {
+          return output(outputValue).apply(mapTriggers);
+        }
         if (outputName.startsWith("$")) {
-          if (Output.isInstance(outputValue)) {
-            return output(outputValue);
-          }
-          for (const key of Object.keys(outputValue)) {
-            outputValue[key] = output(outputValue[key]);
-          }
-          return outputValue;
+          throw new Error(`Unknown extra output '${outputName}'.`);
         }
         const outputModel = unit.model.outputs[outputName];
         if (!outputModel) {
@@ -195,8 +207,83 @@ function forUnit(unit) {
 function outputToPromise(o) {
   return new Promise((resolve) => output(o).apply(resolve));
 }
+function mapStatus(status) {
+  if (!status) {
+    return [];
+  }
+  if (Array.isArray(status)) {
+    return status.filter((field) => !!field?.value);
+  }
+  return Object.entries(status).map(([name, field]) => {
+    if (!field) {
+      return void 0;
+    }
+    if (typeof field === "string") {
+      return { name, value: field };
+    }
+    return { ...field, name };
+  }).filter((field) => !!field?.value);
+}
+function mapPages(pages) {
+  if (!pages) {
+    return [];
+  }
+  if (Array.isArray(pages)) {
+    return pages.filter((page) => !!page);
+  }
+  return Object.entries(pages).filter(([, page]) => !!page).map(([name, page]) => ({ ...page, name }));
+}
+function mapFiles(files) {
+  if (!files) {
+    return [];
+  }
+  if (Array.isArray(files)) {
+    return files.filter((file) => !!file);
+  }
+  return Object.entries(files).filter(([, file]) => !!file).map(([name, file]) => ({ ...file, name }));
+}
+function mapTerminals(terminals) {
+  if (!terminals) {
+    return [];
+  }
+  if (!Array.isArray(terminals)) {
+    terminals = Object.entries(terminals).map(([name, terminal]) => {
+      if (!terminal) {
+        return void 0;
+      }
+      return { ...terminal, name };
+    });
+  }
+  return terminals.filter((terminal) => !!terminal).map((terminal) => {
+    if (!terminal.files) {
+      return terminal;
+    }
+    return {
+      ...terminal,
+      files: pipe(
+        terminal.files,
+        mapValues((file) => {
+          if (typeof file === "string") {
+            return { content: file };
+          }
+          return file;
+        }),
+        pickBy((value) => !!value?.content)
+      )
+    };
+  });
+}
+function mapTriggers(triggers) {
+  if (!triggers) {
+    return [];
+  }
+  if (Array.isArray(triggers)) {
+    return triggers.filter((trigger) => !!trigger);
+  }
+  return Object.entries(triggers).filter(([, trigger]) => !!trigger).map(([name, trigger]) => ({ ...trigger, name }));
+}
 
-function mergeInputs(...values) {
+function flattenInputs(...values) {
   return all(values).apply((allValues) => {
     const result = [];
     for (const value of allValues) {
@@ -209,38 +296,35 @@ function mergeInputs(...values) {
     return result;
   });
 }
-function flattenInputs(array) {
-  return output(array).apply((array2) => array2.flat());
-}
 function mapInputs(array, fn) {
-  return output(array).apply(
-    (array2) => array2.map((v, index) => fn(v, index, array2))
-  );
+  return output(array).apply((array2) => {
+    return array2?.map((v, index) => fn(v, index, array2)) ?? [];
+  });
 }
-function mergeMapInputs(...args) {
+function flatMapInput(...args) {
   const fn = args.pop();
   const values = args;
-  return mapInputs(mergeInputs(...values), fn);
+  return mapInputs(flattenInputs(...values), fn);
 }
 function mapOptional(input, func) {
-  if (input === undefined) {
-    return undefined;
+  if (input === void 0) {
+    return void 0;
   }
   return func(input);
 }
-function toPromise(output2) {
-  return new Promise((resolve) => output2.apply(resolve));
+function toPromise(input) {
+  return new Promise((resolve) => output(input).apply(resolve));
 }
 function singleton(factory) {
   let instance;
   return () => {
-    if (instance === undefined) {
+    if (instance === void 0) {
       instance = factory();
     }
     return instance;
   };
 }
-function namedSingleton(factory) {
+function providerFactory(factory) {
   const instances = /* @__PURE__ */ new Map();
   return (name) => {
     if (!instances.has(name)) {
@@ -249,5 +333,45 @@ function namedSingleton(factory) {
     return instances.get(name);
   };
 }
+function mergeInputObjects(...objects) {
+  return output(objects).apply((array) => {
+    return Object.assign({}, ...array);
+  });
+}
+function normalize(item, collection) {
+  if (item && collection) {
+    return [item, ...collection];
+  }
+  if (item) {
+    return [item];
+  }
+  return collection ?? [];
+}
+function apply(fn) {
+  return (input) => output(input).apply(fn);
+}
+
+function resolvePackagePath(packageName, path, parent) {
+  let resolved = fileURLToPath(resolve(packageName, parent));
+  let singlePackageName = packageName;
+  if (packageName.startsWith("@")) {
+    singlePackageName = packageName.split("/")[1];
+  } else {
+    singlePackageName = packageName.split("/")[0];
+  }
+  if (!singlePackageName) {
+    throw new Error(`Invalid package name: ${packageName}`);
+  }
+  while (!resolved.endsWith(singlePackageName)) {
+    if (resolved === "/") {
+      throw new Error(`Could not find package root of "${packageName}" in resolved path`);
+    }
+    resolved = resolve$1(resolved, "..");
+  }
+  return resolve$1(resolved, path);
+}
+function readResolvedPackageFileSync(packageName, path, parent) {
+  return readFileSync(resolvePackagePath(packageName, path, parent), "utf-8");
+}
 
-export { flattenInputs, forUnit, getOrCreateSecret, mapInputs, mapOptional, mergeInputs, mergeMapInputs, namedSingleton, singleton, toPromise };
+export { apply, flatMapInput, flattenInputs, forUnit, getOrCreateSecret, mapInputs, mapOptional, mergeInputObjects, normalize, providerFactory, readResolvedPackageFileSync, resolvePackagePath, singleton, toPromise };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highstate/pulumi",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "type": "module",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -20,13 +20,15 @@
     "build": "pkgroll --tsconfig=tsconfig.build.json"
   },
   "dependencies": {
-    "@highstate/contract": "^0.4.4",
-    "@pulumi/pulumi": "^3.142.0",
+    "@highstate/contract": "^0.4.6",
+    "@pulumi/pulumi": "^3.152.0",
     "@sinclair/typebox": "^0.34.11",
-    "ajv": "^8.17.1"
+    "ajv": "^8.17.1",
+    "import-meta-resolve": "^4.1.0",
+    "remeda": "^2.21.0"
   },
   "devDependencies": {
     "pkgroll": "^2.5.1"
   },
-  "gitHead": "58a1b969cca5dad233f885f2e67185a0384ea1aa"
+  "gitHead": "dbb1d8125884cfe3a9d95df2e0710333c01c7edf"
 }