@catladder/pipeline 1.170.0 → 2.0.0

package/src/variables/resolveAllReferencesOnce.ts

@@ -0,0 +1,44 @@
+import type { VariableValue } from "./VariableValue";
+import type { VariableValueContainingReferences } from "./VariableValueContainingReferences";
+import { VariableReference } from "./VariableValueContainingReferences";
+import { resolveReferencesOnce } from "./resolveReferencesOnce";
+
+export const resolveAllReferencesOnce = async (
+  values: Record<string, VariableValueContainingReferences>,
+  getEnvVars: (
+    componentName: string,
+  ) => Promise<Record<string, VariableValue | undefined | null>>,
+) => {
+  const allReferences = Object.values(values).flatMap(
+    (value) =>
+      value?.parts.filter(
+        (part) => part instanceof VariableReference,
+      ) as VariableReference[],
+  );
+
+  const allComponentsUnique = Array.from(
+    new Set(allReferences.map((reference) => reference.componentName)),
+  );
+
+  const allEnvVarsInComponents = Object.fromEntries(
+    await Promise.all(
+      allComponentsUnique.map(async (componentName) => [
+        componentName,
+        await getEnvVars(componentName),
+      ]) as Array<
+        Promise<[string, Record<string, VariableValue | undefined | null>]>
+      >,
+    ),
+  );
+
+  return Object.fromEntries(
+    Object.entries(values).map(([key, value]) => [
+      key,
+      value !== null && value !== undefined
+        ? resolveReferencesOnce(value, ({ componentName, variableName }) => {
+            return allEnvVarsInComponents[componentName][variableName];
+          })
+        : value,
+    ]),
+  );
+};

package/src/variables/resolveReferencesOnce.ts

@@ -0,0 +1,29 @@
+import type { VariableValue } from "./VariableValue";
+import {
+  UnresolvableReference,
+  VariableReference,
+  VariableValueContainingReferences,
+} from "./VariableValueContainingReferences";
+
+type Resolver = (args: {
+  componentName: string;
+  variableName: string;
+}) => VariableValue | null | undefined;
+export const resolveReferencesOnce = (
+  value: VariableValueContainingReferences,
+  resolver: Resolver,
+) => {
+  const replacedParts = value.parts.map((part) => {
+    if (part instanceof VariableReference) {
+      const result = resolver({
+        componentName: part.componentName,
+        variableName: part.variableName,
+      });
+      return result ?? new UnresolvableReference(part);
+    } else {
+      return part;
+    }
+  });
+
+  return new VariableValueContainingReferences(replacedParts);
+};

package/bin/catladder-gitlab-dev.js

@@ -1,3 +0,0 @@
-#! /usr/bin/env node
-
-require("../dist/catladder-gitlab.js");

package/bin/catladder-gitlab.js

@@ -1,3 +0,0 @@
-#! /usr/bin/env node
-
-require("../dist/bundles/catladder-gitlab/index.js");

package/dist/bash/replaceAsync.d.ts

@@ -1,2 +0,0 @@
-import { BashExpression } from "./BashExpression";
-export default function replaceAsync(string: string | BashExpression, searchValue: any, replacer: (substring: string, ...args: any[]) => Promise<string | BashExpression>): Promise<string | BashExpression>;