@highstate/pulumi 0.9.16 → 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,30 +0,0 @@
-import { secret, type Input, type Output } from "@pulumi/pulumi"
-
-export const createdSecrets: Record<string, Output<unknown>> = {}
-
-export function getOrCreateSecret<
-  TSecrets extends Record<string, unknown>,
-  TResult extends TSecrets[keyof TSecrets],
->(secrets: Output<TSecrets>, key: keyof TSecrets, create: () => Input<TResult>): Output<TResult> {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
-  return secrets[key as any].apply(value => {
-    if (value !== undefined) {
-      // if the secret is accessed via "getOrCreateSecret" with assume it automatically created (even if it was not)
-      // in order to provide stable stack outputs
-      createdSecrets[key as string] = value as Output<unknown>
-      return value as TResult
-    }
-
-    const secretValue = createdSecrets[key as string] ?? secret(create())
-    createdSecrets[key as string] = secretValue
-
-    return secretValue
-  }) as Output<TResult>
-}
-
-export function storeSecret<
-  TSecrets extends Record<string, unknown>,
-  TResult extends TSecrets[keyof TSecrets],
->(_secrets: Output<TSecrets>, key: keyof TSecrets, value: Input<TResult>): void {
-  createdSecrets[key as string] = value as Output<unknown>
-}