@catladder/pipeline 0.0.0-refactore-catenv-command-validates-argument-78d05852 → 0.0.0-reference-database-url-1befbbee

package/src/variables/__tests__/resolveReferencesOnce.test.ts

@@ -0,0 +1,117 @@
+import {
+  UnresolvableReference,
+  VariableReference,
+  createVariableValueContainingReferencesFromString,
+} from "../VariableValueContainingReferences";
+import { resolveReferencesOnce } from "../resolveReferencesOnce";
+
+describe("resolveReferencesOnce", () => {
+  it("should replace a reference to another component", async () => {
+    const value = createVariableValueContainingReferencesFromString(
+      "the other component has ${otherComponent:variableName}, isn't that cool?",
+      {
+        componentName: "myComponent",
+      },
+    );
+
+    const result = resolveReferencesOnce(
+      value,
+      ({ componentName, variableName }) => {
+        return createVariableValueContainingReferencesFromString(
+          `replaced ${componentName}:${variableName}`,
+          { componentName },
+        );
+      },
+    );
+
+    expect(result.parts).toEqual([
+      "the other component has ",
+      "replaced otherComponent:variableName",
+      ", isn't that cool?",
+    ]);
+  });
+  it("should keep references in replacement", async () => {
+    const value = createVariableValueContainingReferencesFromString(
+      "the other component has ${otherComponent:variableName}, isn't that cool?",
+      {
+        componentName: "myComponent",
+      },
+    );
+
+    const result = resolveReferencesOnce(
+      value,
+      ({ componentName, variableName }) => {
+        return createVariableValueContainingReferencesFromString(
+          `replaced ${componentName}:${variableName}, contains reference to \${thirdComponent:x}`,
+          { componentName },
+        );
+      },
+    );
+
+    expect(result.parts).toEqual([
+      "the other component has ",
+
+      "replaced otherComponent:variableName, contains reference to ",
+      new VariableReference("thirdComponent", "x"),
+      ", isn't that cool?",
+    ]);
+  });
+
+  it("can be run multiple times", async () => {
+    const value = createVariableValueContainingReferencesFromString(
+      "the other component has ${otherComponent:variableName}, isn't that cool?",
+      {
+        componentName: "myComponent",
+      },
+    );
+    const replacer = ({
+      componentName,
+      variableName,
+    }: {
+      componentName: string;
+      variableName: string;
+    }) => {
+      return createVariableValueContainingReferencesFromString(
+        componentName === "thirdComponent"
+          ? "value from third component"
+          : `replaced ${componentName}:${variableName}, contains reference to \${thirdComponent:x}`,
+        { componentName },
+      );
+    };
+    const result = resolveReferencesOnce(
+      resolveReferencesOnce(value, replacer),
+      replacer,
+    );
+
+    expect(result.parts).toEqual([
+      "the other component has ",
+      "replaced otherComponent:variableName, contains reference to ",
+      "value from third component",
+      ", isn't that cool?",
+    ]);
+  });
+
+  it("flags unresolveable", async () => {
+    const value = createVariableValueContainingReferencesFromString(
+      "the other component has ${otherComponent:variableName}, isn't that cool?",
+      {
+        componentName: "myComponent",
+      },
+    );
+
+    const result = resolveReferencesOnce(
+      value,
+      ({ componentName, variableName }) => {
+        return null;
+      },
+    );
+
+    expect(result.parts).toEqual([
+      "the other component has ",
+      new UnresolvableReference(
+        new VariableReference("otherComponent", "variableName"),
+      ),
+      ", isn't that cool?",
+    ]);
+  });
+});

package/src/variables/__tests__/variableValue.test.ts

@@ -0,0 +1,73 @@
+import {
+  VariableReference,
+  createVariableValueContainingReferencesFromString,
+} from "../VariableValueContainingReferences";
+
+describe("createVarialeValueFromString", () => {
+  it("should create a VariableValue from a simple string", () => {
+    const stringValue = "hello world";
+
+    const result = createVariableValueContainingReferencesFromString(
+      stringValue,
+      {
+        componentName: "myComponent",
+      },
+    );
+
+    expect(result.parts).toEqual([stringValue]);
+  });
+
+  it("extracts references to other components", () => {
+    const stringValue =
+      "the other component has ${otherComponent:variableName}, isn't that cool?";
+
+    const result = createVariableValueContainingReferencesFromString(
+      stringValue,
+      {
+        componentName: "myComponent",
+      },
+    );
+
+    expect(result.parts).toEqual([
+      "the other component has ",
+      new VariableReference("otherComponent", "variableName"),
+      ", isn't that cool?",
+    ]);
+  });
+
+  it("extracts self references", () => {
+    const stringValue = "my component has ${variableName}!";
+
+    const result = createVariableValueContainingReferencesFromString(
+      stringValue,
+      {
+        componentName: "myComponent",
+      },
+    );
+
+    expect(result.parts).toEqual([
+      "my component has ",
+      new VariableReference("myComponent", "variableName"),
+      "!",
+    ]);
+  });
+  it("extracts multiple references", () => {
+    const stringValue =
+      "my component has ${variableName} and the other component has ${otherComponent:variableName}!";
+
+    const result = createVariableValueContainingReferencesFromString(
+      stringValue,
+      {
+        componentName: "myComponent",
+      },
+    );
+
+    expect(result.parts).toEqual([
+      "my component has ",
+      new VariableReference("myComponent", "variableName"),
+      " and the other component has ",
+      new VariableReference("otherComponent", "variableName"),
+      "!",
+    ]);
+  });
+});

package/src/variables/resolveAllReferences.ts

@@ -0,0 +1,46 @@
+import type { VariableValue } from "./VariableValue";
+import type { VariableValueContainingReferences } from "./VariableValueContainingReferences";
+import { VariableReference } from "./VariableValueContainingReferences";
+import { resolveAllReferencesOnce as resolveAllReferencesOnce } from "./resolveAllReferencesOnce";
+
+export const resolveAllReferences = async (
+  values: Record<string, VariableValueContainingReferences>,
+  getEnvVars: (
+    componentName: string,
+  ) => Promise<Record<string, VariableValue | null | undefined>>,
+) => {
+  // replace until there aren't any references left
+  let result = values;
+
+  let i = 0;
+
+  while (
+    Object.values(result).some((value) =>
+      value.parts.some((part) => part instanceof VariableReference),
+    )
+  ) {
+    const replaced = await resolveAllReferencesOnce(result, getEnvVars);
+
+    result = replaced;
+    i++;
+    if (i > 1000) {
+      const unresolved = Object.entries(result).filter(([key, value]) =>
+        value.parts.some((part) => part instanceof VariableReference),
+      );
+
+      throw new Error(
+        "Infinite loop detected in these variables: " +
+          unresolved
+            .map(
+              ([key, value]) =>
+                `${key} (last reference: ${value.parts.find(
+                  (part) => part instanceof VariableReference,
+                )})`,
+            )
+            .join(", "),
+      );
+    }
+  }
+
+  return result;
+};

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");