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

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

@@ -1,33 +0,0 @@
-import type { Config } from "../src";
-import { createAllPipelines } from "./__utils__/helpers";
-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,
-          },
-        },
-      },
-    },
-  },
-};
-
-it("matches snapshot", async () => {
-  expect(await createAllPipelines(config)).toMatchSnapshot();
-});

package/scripts/bundle

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

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

@@ -1,143 +0,0 @@
-import {
-  resolveReferences,
-  translateLegacyFromComponents,
-} from "../resolveReferences";
-
-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(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(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(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(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(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(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,70 +0,0 @@
-import { merge } from "lodash";
-import replaceAsync from "string-replace-async";
-
-const REGEX = /\$\{(([^:}]+):)?([^}]+)}/gm;
-
-export const resolveReferences = async (
-  vars: Record<string, string>,
-  getOtherVariables?: (
-    componentName: string,
-    alreadyVisited: Record<string, Record<string, boolean>>
-  ) => Promise<Record<string, string | null>>,
-  alreadyVisitedBase: Record<string, Record<string, boolean>> = {}
-) => {
-  const replaceSingleValue = async (
-    value: string,
-    alreadyVisited: Record<string, Record<string, boolean>> = alreadyVisitedBase
-  ): Promise<string> => {
-    if (REGEX.test(value)) {
-      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]) => {
-        return [key, await replaceSingleValue(value)];
-      })
-    )
-  ) as Record<string, string>;
-};
-
-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/cloudRun/createJobs/variables.ts

@@ -1,21 +0,0 @@
-import { dump } from "js-yaml";
-import { omit } from "lodash";
-
-import type { Context } from "../../../types/context";
-
-import { GCLOUD_DEPLOY_CREDENTIALS_KEY } from "../../..";
-
-export function getDeployJobVariables(context: Context) {
-  const allEnvVars = omit(
-    context.environment.envVars,
-    GCLOUD_DEPLOY_CREDENTIALS_KEY
-  );
-  return {
-    CLOUDSDK_CORE_DISABLE_PROMPTS: "1",
-    ENV_VARS: dump(allEnvVars, {
-      lineWidth: -1,
-      quotingType: "'",
-      forceQuotes: true,
-    }),
-  };
-}

package/src/deploy/kubernetes/processSecretsAsFiles.ts

@@ -1,34 +0,0 @@
-import { omit } from "lodash";
-import type { DeployConfigKubernetesValues } from "../types";
-
-export const processSecretsAsFiles = <
-  T extends {
-    env: {
-      secret: Record<string, string>;
-    };
-  } & 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],
-          ])
-        ),
-      },
-    },
-  };
-};

package/src/pipeline/commitInfo/getBuildId.ts

@@ -1,17 +0,0 @@
-import { exec } from "child-process-promise";
-
-export const getBuildId = async () =>
-  await exec("git describe --tags || git rev-parse HEAD").then((s) =>
-    s.stdout.trim()
-  );
-
-// thx chat gpt
-/**
- * returns the last tagged version string Major.minor.patch
- * returns 0.0.0 if there is no tag
- */
-export const getCurrentVersionString = async () => {
-  return await exec(
-    'latest_tag=$(git describe --tags --abbrev=0 2>/dev/null); if [ -z "$latest_tag" ]; then echo "0.0.0"; else echo "${latest_tag#v}"; fi | cut -d "." -f 1-3'
-  ).then((s) => s.stdout.trim());
-};

package/src/pipeline/commitInfo/getCommitInfo.ts

@@ -1,15 +0,0 @@
-import type { CommitInfo } from "../../types";
-import { getBuildId, getCurrentVersionString } from "./getBuildId";
-export const getBaseCommitInfo = async (): Promise<
-  Omit<CommitInfo, "trigger">
-> => ({
-  refName: process.env.CI_COMMIT_REF_NAME ?? "unknown",
-  reviewSlug: process.env.CI_MERGE_REQUEST_IID
-    ? `mr${process.env.CI_MERGE_REQUEST_IID}`
-    : process.env.CI_COMMIT_REF_SLUG
-    ? `hf${process.env.CI_COMMIT_REF_SLUG}`
-    : "unknown",
-  buildTime: new Date().toISOString(),
-  buildId: await getBuildId(),
-  currentVersion: await getCurrentVersionString(),
-});

package/src/pipeline/createChildPipeline.ts

@@ -1,46 +0,0 @@
-import { getAllEnvsInAllComponents } from "../config";
-import { RULES_ALWAYS } from "../rules";
-import { getRunnerImage } from "../runner";
-import type { GitlabPipeline, Pipeline, PipelineType } from "../types";
-import type { Config, PipelineTrigger } from "../types/config";
-import { BASE_STAGES } from "../types/jobs";
-import { createAllJobs } from "./createAllJobs";
-import { createGitlabJobs } from "./gitlab/createGitlabJobs";
-
-export const createChildPipeline = async <T extends PipelineType>(
-  type: T,
-  trigger: PipelineTrigger,
-  config: Config
-): Promise<Pipeline<T>> => {
-  const jobs = await createAllJobs(config, trigger);
-
-  // while technically not required, we group different envs in its own stage
-  // each job from `createJobs` that is defined as `envMode: "stagePerEnv"` will have `deploy dev`, etc. instead of just `deploy`
-  // this is just so that it looks nicer in gitlab and makes running mutliple manual tasks more easy to use
-
-  const allEnvs = getAllEnvsInAllComponents(config);
-  const stages = BASE_STAGES.reduce<string[]>(
-    (acc, baseStage) => [
-      ...acc,
-      baseStage,
-      ...allEnvs.map((e) => `${baseStage} ${e}`),
-    ],
-    []
-  );
-  if (type === "gitlab") {
-    const pipeline: GitlabPipeline = {
-      image: getRunnerImage("jobs-default"), // default image
-      variables: {
-        FF_USE_FASTZIP: "true",
-        GIT_DEPTH: 1, // no need the full depth
-      },
-      workflow: {
-        rules: RULES_ALWAYS,
-      },
-      stages,
-      jobs: await createGitlabJobs(jobs),
-    };
-    return pipeline as Pipeline<T>;
-  }
-  throw new Error(`${type} is not supported`);
-};