@catladder/pipeline 1.170.0 → 2.0.0

package/examples/kubernetes-with-cloud-sql-legacy.ts

@@ -1,35 +0,0 @@
-import type { Config } from "../src";
-
-const config: Config = {
-  appName: "test-app",
-  customerName: "pan",
-  components: {
-    api: {
-      dir: "api",
-      build: {
-        type: "node",
-      },
-      deploy: {
-        type: "kubernetes",
-        cluster: {
-          name: "some-cluster-name",
-          region: "europe-west6",
-          projectId: "some-project-id",
-          type: "gcloud",
-          domainCanonical: "panter.cloud",
-        },
-        values: {
-          cloudsql: {
-            enabled: true,
-          },
-        },
-      },
-    },
-  },
-};
-
-export default config;
-
-export const information = {
-  title: "K8s: With Cloud SQL Legacy",
-};

package/scripts/bundle

@@ -1,2 +0,0 @@
-#!/bin/bash
-ncc build dist/catladder-gitlab.js -o dist/bundles/catladder-gitlab -e 'tsx/cjs/api' $( ((SHOULD_MINIFY == 1)) && printf %s '-m')

package/src/bash/replaceAsync.ts

@@ -1,54 +0,0 @@
-import { BashExpression, bashEscape } from "./BashExpression";
-
-// from https://github.com/dsblv/string-replace-async/blob/main/index.js
-// and adjusted a bit
-export default async function replaceAsync(
-  string: string | BashExpression,
-  searchValue: any,
-  replacer: (
-    substring: string,
-    ...args: any[]
-  ) => Promise<string | BashExpression>,
-) {
-  const wasBashExpression = string instanceof BashExpression;
-
-  const stringRepresentation = wasBashExpression
-    ? string.toString()
-    : bashEscape(string);
-  try {
-    // 1. Run fake pass of `replace`, collect values from `replacer` calls
-    // 2. Resolve them with `Promise.all`
-    // 3. Run `replace` with resolved values
-    const values: Array<Promise<string | BashExpression>> = [];
-    String.prototype.replace.call(
-      stringRepresentation,
-      searchValue,
-      function (...args) {
-        // eslint-disable-next-line prefer-spread
-        const result = replacer.apply(undefined, args);
-        values.push(result);
-        return "";
-      },
-    );
-    const resolvedValues = await Promise.all(values);
-
-    const containsBashExpression = resolvedValues.some(
-      (value) => value instanceof BashExpression,
-    );
-
-    const result = String.prototype.replace.call(
-      stringRepresentation,
-      searchValue,
-      function () {
-        return resolvedValues.shift()?.toString() ?? "";
-      },
-    );
-    if (wasBashExpression || containsBashExpression) {
-      return new BashExpression(result);
-    } else {
-      return result;
-    }
-  } catch (error) {
-    return Promise.reject(error);
-  }
-}

package/src/context/__tests__/resolveReferences.test.ts

@@ -1,148 +0,0 @@
-import type { BashExpression } from "../../bash/BashExpression";
-import {
-  resolveReferences,
-  translateLegacyFromComponents,
-} from "../resolveReferences";
-
-const unpackBashExpressions = (obj: Record<string, string | BashExpression>) =>
-  Object.fromEntries(
-    Object.entries(obj).map(([key, value]) => [key, value.toString()]),
-  );
-describe("resolveReferences", () => {
-  it("replaces occurences of ${componentName:VARIABLE_NAME}", async () => {
-    const variables = {
-      a: "hello world",
-      b: "a replaced value looks like this: '${api:FOO}', nice!",
-    };
-    const otherVariables: Record<string, Record<string, string>> = {
-      api: {
-        FOO: "foo from api",
-      },
-      frontend: {
-        FOO: "foo from frontend",
-      },
-    };
-    const result = await resolveReferences(variables, async (componentName) => {
-      return otherVariables[componentName];
-    });
-
-    expect(unpackBashExpressions(result)).toEqual({
-      a: "hello world",
-      b: "a replaced value looks like this: 'foo from api', nice!",
-    });
-  });
-
-  it("replaces self references with structure ${VARIABLE_NAME}", async () => {
-    const variables = {
-      FOO: "hello world",
-      BAR: "this: ${FOO}!",
-    };
-    const result = await resolveReferences(variables);
-
-    expect(unpackBashExpressions(result)).toEqual({
-      FOO: "hello world",
-      BAR: "this: hello world!",
-    });
-  });
-
-  it("replaces self references mixed with other vars", async () => {
-    const variables = {
-      FOO: "hello from ${api:FOO}",
-      BAR: "this: ${FOO}!",
-    };
-    const otherVariables: Record<string, Record<string, string>> = {
-      api: {
-        FOO: "foo from api",
-      },
-    };
-    const result = await resolveReferences(variables, async (componentName) => {
-      return otherVariables[componentName];
-    });
-
-    expect(unpackBashExpressions(result)).toEqual({
-      FOO: "hello from foo from api",
-      BAR: "this: hello from foo from api!",
-    });
-  });
-
-  it("keeps variables as is if not found (when null is returned)", async () => {
-    const variables = {
-      a: "hello world",
-      b: "a not found value looks like this: '${api:FOO}'",
-    };
-    const otherVariables: Record<string, Record<string, string>> = {};
-    const result = await resolveReferences(variables, async (componentName) => {
-      return otherVariables[componentName];
-    });
-
-    expect(unpackBashExpressions(result)).toEqual({
-      a: "hello world",
-      b: "a not found value looks like this: '${api:FOO}'",
-    });
-  });
-
-  it("replaces mulitple levels deep", async () => {
-    const variables = {
-      a: "value is ${frontend:FOO}!",
-    };
-    const otherVariables: Record<string, Record<string, string>> = {
-      api: {
-        FOO: "foo from api",
-      },
-      frontend: {
-        FOO: "hi, ${api:FOO}",
-      },
-    };
-    const result = await resolveReferences(variables, async (componentName) => {
-      return otherVariables[componentName];
-    });
-
-    expect(unpackBashExpressions(result)).toEqual({
-      a: "value is hi, foo from api!",
-    });
-  });
-
-  it("prevents endless loops", async () => {
-    const variables = {
-      a: "value is ${frontend:FOO}!",
-    };
-    const otherVariables: Record<string, Record<string, string>> = {
-      api: {
-        FOO: "api ${frontend:FOO}",
-      },
-      frontend: {
-        FOO: "frontend ${api:FOO}",
-      },
-    };
-    const result = await resolveReferences(variables, async (componentName) => {
-      return otherVariables[componentName];
-    });
-
-    expect(unpackBashExpressions(result)).toEqual({
-      a: "value is frontend api ${frontend:FOO}!",
-    });
-  });
-});
-
-describe("translateLegacyFromComponents", () => {
-  it("translatetes the old `fromComponents` approach to ${componentName:variableName}", () => {
-    const fromComponents = {
-      api: {
-        API_FOO: "FOO",
-        API_BAR: "BAR",
-      },
-      www: {
-        WWW_X: "X",
-        WWW_Y: "Y",
-      },
-    };
-
-    const result = translateLegacyFromComponents(fromComponents);
-    expect(result).toEqual({
-      API_FOO: "${api:FOO}",
-      API_BAR: "${api:BAR}",
-      WWW_X: "${www:X}",
-      WWW_Y: "${www:Y}",
-    });
-  });
-});

package/src/context/resolveReferences.ts

@@ -1,93 +0,0 @@
-import { merge } from "lodash";
-
-import type { BashExpression } from "../bash/BashExpression";
-import replaceAsync from "../bash/replaceAsync";
-import type { UnspecifiedEnvVars } from "..";
-
-// regex to resolve references in catladder variables
-// those expressions have the pattern ${componentName:variableName}
-const REGEX = /\$\{(([^:}]+):)?([^}]+)}/gm;
-
-export const resolveReferences = async (
-  vars: Record<string, string | BashExpression | undefined | null>,
-  getOtherVariables?: (
-    componentName: string,
-    alreadyVisited: Record<string, Record<string, boolean>>,
-  ) => Promise<UnspecifiedEnvVars>,
-  alreadyVisitedBase: Record<string, Record<string, boolean>> = {},
-) => {
-  /**
-   *
-   * replace referenced variables with their values in a value string
-   */
-  const replaceSingleValue = async (
-    value: string | BashExpression,
-    alreadyVisited: Record<
-      string,
-      Record<string, boolean>
-    > = alreadyVisitedBase,
-  ): Promise<string | BashExpression> => {
-    if (REGEX.test(value.toString())) {
-      // we consider variables that got references in it  BashExpressions, because the replacement may be one
-
-      return await replaceAsync(
-        value,
-        REGEX,
-        async (match, _, componentName, variableName) => {
-          if (alreadyVisited[componentName]?.[variableName]) {
-            return match; // prevent endless loop
-          }
-          const newAlreadyVisited = merge({}, alreadyVisited, {
-            [componentName]: {
-              [variableName]: true,
-            },
-          });
-          const result = componentName
-            ? (await getOtherVariables?.(componentName, newAlreadyVisited).then(
-                (r) => r?.[variableName],
-              )) ?? null
-            : vars[variableName]; // is self reference
-
-          const replaced =
-            result !== null && result !== undefined
-              ? await replaceSingleValue(result, newAlreadyVisited)
-              : match;
-
-          return replaced;
-        },
-      );
-    } else {
-      return value;
-    }
-  };
-
-  return Object.fromEntries(
-    await Promise.all(
-      Object.entries(vars).map(async ([key, value]) => {
-        if (value === null || value === undefined) {
-          return [key, null];
-        }
-
-        return [
-          key,
-          value !== null && value !== undefined
-            ? await replaceSingleValue(value)
-            : null,
-        ];
-      }),
-    ),
-  ) as Record<string, BashExpression>;
-};
-
-export const translateLegacyFromComponents = (
-  fromComponents: Record<string, Record<string, string>>,
-) => {
-  return Object.fromEntries(
-    Object.entries(fromComponents).flatMap(([componentName, variables]) => {
-      return Object.entries(variables).map(([ourName, otherName]) => [
-        ourName,
-        "${" + componentName + ":" + otherName + "}",
-      ]);
-    }),
-  );
-};

package/src/deploy/kubernetes/processSecretsAsFiles.ts

@@ -1,35 +0,0 @@
-import { omit } from "lodash";
-import type { DeployConfigKubernetesValues } from "../types";
-import type { StringOrBashExpression } from "../../bash/BashExpression";
-
-export const processSecretsAsFiles = <
-  T extends {
-    env: {
-      secret: Record<string, StringOrBashExpression>;
-    };
-  } & DeployConfigKubernetesValues,
->(
-  values: T,
-): T => {
-  if (!values.secretsAsFile || values.secretsAsFile.length === 0) {
-    return values;
-  }
-  // the initial idea was that we "shadow" secrets that we mount as files,
-  // but there is a weird kubernetes  issue with that (https://github.com/kubernetes/kubernetes/issues/46861),
-  // so instead we rename the secrets and append _content, so that inside kuberentes, we can use the original name to contain the path and name+_content as the actual content
-  return {
-    ...values,
-    env: {
-      ...values.env,
-      secret: {
-        ...omit(values.env.secret, values.secretsAsFile),
-        ...Object.fromEntries(
-          values.secretsAsFile.map((key) => [
-            key + "_content",
-            values.env.secret[key],
-          ]),
-        ),
-      },
-    },
-  };
-};