@highstate/pulumi 0.9.18 → 0.9.19

package/src/utils.ts

@@ -1,4 +1,4 @@
-import { type Input, type Unwrap, type Output, output, all } from "@pulumi/pulumi"
+import { type Input, type Output, output, type Unwrap } from "@pulumi/pulumi"
 
 /**
  * The input type for an array of inputs.
@@ -7,182 +7,97 @@ import { type Input, type Unwrap, type Output, output, all } from "@pulumi/pulum
 export type InputArray<T> = Input<Input<T>[]>
 
 /**
- * The input type for a map of inputs.
+ * The input type for a record of inputs.
  * The same as `Input<Record<string, Input<T>>>`, but more readable.
  */
-export type InputMap<T> = Input<Readonly<Record<string, Input<T>>>>
+export type InputRecord<T> = Input<Record<string, Input<T>>>
 
 /**
  * The input or input array type for a value.
  */
 export type InputOrArray<T> = Input<T> | InputArray<T>
 
+type LeafValue = string | number | boolean | null | undefined
+type IsUnknown<T> = unknown extends T ? (T extends unknown ? true : false) : false
+
 /**
- * The input of inputs of inputs of inputs, so you got the idea.
+ * The recursive input type for a value.
  */
-export type DeepInput<T> = [T] extends [Record<string, unknown> | undefined]
-  ? [T] extends [infer U | undefined]
-    ? Input<{ [K in keyof U]: DeepInput<U[K]> } | undefined>
+export type DeepInput<T> = [T] extends [LeafValue]
+  ? Input<T>
+  : IsUnknown<T> extends true
+    ? Input<unknown>
     : Input<{ [K in keyof T]: DeepInput<T[K]> }>
-  : [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.
+ * Transforms an input value to a promise that resolves to the unwrapped value.
  *
- * @param values The values to merge.
- * @returns The merged output array.
+ * @param input The input value to transform.
+ * @returns A promise that resolves to the unwrapped value.
  */
-export function flattenInputs<T>(...values: (InputOrArray<T> | undefined)[]): Output<T[]> {
-  return all(values).apply(allValues => {
-    const result: T[] = []
-    for (const value of allValues) {
-      if (Array.isArray(value)) {
-        result.push(...(value as T[]))
-      } else if (value) {
-        result.push(value as T)
-      }
-    }
-    return result
-  })
+export function toPromise<T>(input: Input<T>): Promise<Unwrap<T>> {
+  return new Promise(resolve => output(input).apply(resolve))
 }
 
 /**
- * Maps each element of an input array to a new value.
- * Produces an output array with the same length.
+ * Receives an item and a collection, and returns an array containing the item and the collection.
+ *
+ * Excludes the item if it is undefined.
  *
- * @param array The input array.
- * @param fn The mapping function.
- * @returns The output array.
+ * @param item The single item input.
+ * @param collection The collection of items input.
  */
-export function mapInputs<T, U>(
-  array: InputArray<T>,
-  fn: (v: Unwrap<T>, index: number, all: Unwrap<T>[]) => U,
-): Output<U[]> {
-  return output(array).apply(array => {
-    return array?.map((v, index) => fn(v as Unwrap<T>, index, array as Unwrap<T>[])) ?? []
-  })
-}
+export function normalize<T>(item: T | undefined, collection: T[] | undefined): T[] {
+  if (item && collection) {
+    return [item, ...collection]
+  }
 
-export function flatMapInput<T, U>(
-  v1: InputOrArray<T>,
-  v2: InputOrArray<T>,
-  fn: (v: Unwrap<T>, index: number, all: Unwrap<T>[]) => U,
-): Output<U[]>
+  if (item) {
+    return [item]
+  }
 
-export 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[]>
+  return collection ?? []
+}
 
 /**
- * Merges the given array of `InputOrArray` values into a single flat output array and maps each element to a new value.
+ * The same as `normalize`, but accepts inputs and returns output.
  *
- * @param values The values to merge.
- * @param fn The mapping function.
+ * @param item The single item input.
+ * @param collection The collection of items input.
  */
-export function flatMapInput<T, U>(
-  ...args: (InputOrArray<T> | ((v: Unwrap<T>, index: number, all: Unwrap<T>[]) => U))[]
-): Output<U[]> {
-  const fn = args.pop() as (v: Unwrap<T>, index: number, all: Unwrap<T>[]) => U
-  const values = args as InputOrArray<T>[]
-
-  return mapInputs(flattenInputs(...values), fn)
+export function normalizeInputs<T>(
+  item: Input<T> | undefined,
+  collection: InputArray<T> | undefined,
+): Output<Unwrap<T>[]> {
+  return (
+    output({ item, collection })
+      //
+      .apply(({ item, collection }) => normalize(item, collection)) as Output<Unwrap<T>[]>
+  )
 }
 
 /**
- * Map an optional value to another optional value.
+ * The convenience function to normalize inputs and map them to a new type.
  *
- * @param input The input value.
- * @param func The function to apply to the input value.
- * @returns The output value, or `undefined` if the input value is `undefined`.
+ * @param item The single item input.
+ * @param collection The collection of items input.
+ * @param mapFn The function to map each item to a new type.
  */
-export function mapOptional<T, U>(input: T | undefined, func: (value: T) => U): U | undefined {
-  if (input === undefined) {
-    return undefined
-  }
-
-  return func(input)
-}
-
-export function toPromise<T>(input: Input<T>): Promise<Unwrap<T>> {
-  return new Promise(resolve => output(input).apply(resolve))
-}
-
-export function singleton<T>(factory: () => T): () => T {
-  let instance: T | undefined
-  return () => {
-    if (instance === undefined) {
-      instance = factory()
-    }
-
-    return instance
-  }
-}
-
-export function providerFactory<TInput>(
-  factory: (name: string) => TInput,
-): (name: string) => TInput {
-  const instances = new Map<string, TInput>()
-  return name => {
-    if (!instances.has(name)) {
-      instances.set(name, factory(name))
-    }
-
-    return instances.get(name)!
-  }
+export function normalizeInputsAndMap<T, U>(
+  item: Input<T> | undefined,
+  collection: InputArray<T> | undefined,
+  mapFn: (value: Unwrap<T>) => U,
+): Output<U[]> {
+  return normalizeInputs(item, collection).apply(values => values.map(mapFn))
 }
 
-export 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>
-
-export 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>
-
 /**
- * Merges the given input objects into a single output object.
+ * Applies a function to the input and returns an output.
+ *
+ * Can be used in `remeda` pipelines.
  *
- * @param objects The input objects.
- * @returns The output object.
+ * @param fn The function to apply to the input.
  */
-export function mergeInputObjects(
-  ...objects: Input<Record<string, unknown>>[]
-): Output<Record<string, unknown>> {
-  return output(objects).apply(array => {
-    return Object.assign({}, ...array) as Record<string, unknown>
-  })
-}
-
-export function normalize<T>(item: T | undefined, collection: T[] | undefined): T[] {
-  if (item && collection) {
-    return [item, ...collection]
-  }
-
-  if (item) {
-    return [item]
-  }
-
-  return collection ?? []
-}
-
 export function apply<T, U>(fn: (value: Unwrap<T>) => U): (input: Input<T>) => Output<U> {
   return input => output(input).apply(fn)
 }
-
-export function applyMap<T, U>(fn: (value: Unwrap<T>) => U): (input: Input<T[]>) => Output<U[]> {
-  return input => output(input).apply(array => array.map(fn))
-}

package/src/secret.ts

@@ -1,61 +0,0 @@
-import { HighstateSignature, type UnitSecretModel } from "@highstate/contract"
-import { type Input, output, type Output, secret as pulumiSecret } from "@pulumi/pulumi"
-
-export type UnitSecret<TValue> = Omit<UnitSecretModel, "value"> & {
-  value: Output<TValue>
-}
-
-export const updatedSecretValues: Record<string, unknown> = {}
-
-/**
- * Ensures that the provided secret contains a value.
- * If the secret value is undefined, it will create a new secret value using the provided create function.
- *
- * NOTE: This function mutates the internal state and affects the output of the unit.
- * Avoid calling this function multiple times for the same secret in a single unit execution.
- *
- * @param secret The secret to ensure a value for.
- * @param create The function to create a new secret value if the current value is undefined.
- * @return The secret with a guaranteed value.
- */
-export function ensureSecretValue<TValue>(
-  secret: UnitSecret<TValue>,
-  create: () => Input<TValue>,
-): UnitSecret<NonNullable<TValue>> {
-  return {
-    [HighstateSignature.Secret]: true,
-    id: secret.id,
-    value: secret.value.apply(value => {
-      if (value !== undefined) {
-        return value
-      }
-
-      updatedSecretValues[secret.id] = pulumiSecret(create())
-      return updatedSecretValues[secret.id]
-    }) as Output<NonNullable<TValue>>,
-  }
-}
-
-/**
- * Updates the value of the provided secret.
- * This function is used to store a new value for the secret regardless of its current value.
- *
- * NOTE: This function mutates the internal state and affects the output of the unit.
- * Avoid calling this function multiple times for the same secret in a single unit execution.
- *
- * @param secret The secret to update.
- * @param value The new value to store in the secret.
- * @returns The updated secret with the new value.
- */
-export function updateSecretValue<TValue>(
-  secret: UnitSecret<TValue>,
-  value: Input<TValue>,
-): UnitSecret<TValue> {
-  updatedSecretValues[secret.id] = pulumiSecret(value)
-
-  return {
-    [HighstateSignature.Secret]: true,
-    id: secret.id,
-    value: output(updatedSecretValues[secret.id]),
-  }
-}