@catladder/pipeline 0.0.0-node16-ddfae617 → 0.0.0-prettier-cbceeed9

package/src/deploy/cloudRun/deployJob.ts

@@ -0,0 +1,276 @@
+import { dump } from "js-yaml";
+import { isNil, merge, omit } from "lodash";
+import { GCLOUD_DEPLOY_CREDENTIALS_KEY } from ".";
+import { getDockerJobBaseProps, gitlabDockerLogin } from "../../build/docker";
+import { getLabels } from "../../context/getLabels";
+import { getRunnerImage } from "../../runner";
+import type { Context } from "../../types/context";
+import type { CatladderJob } from "../../types/jobs";
+import { getBaseDeploymentJob, getBaseDeploymentStopJob } from "../base";
+import type {
+  DeployConfigCloudRun,
+  DeployConfigCloudRunJob,
+  DeployConfigCloudRunJobWithSchedule,
+  DeployConfigCloudRunService,
+} from "../types";
+import { isOfDeployType } from "../types";
+import { gcloudServiceAccountLoginCommands } from "./utils/gcloudServiceAccountLoginCommands";
+import {
+  getDatabaseCreateScript,
+  getDatabaseDeleteScript,
+} from "./utils/database";
+import { allowFailureInScripts } from "../../utils/gitlab";
+import { getCloudRunJobName } from "./utils/jobName";
+import { createArgsString } from "./utils/createArgsString";
+
+const setExtraVarsScripts = (deployConfig: DeployConfigCloudRun) => [
+  `export GCLOUD_PROJECT_NUMBER=$(gcloud projects describe ${deployConfig.projectId} --format="value(projectNumber)")`,
+  `echo "GCLOUD_PROJECT_NUMBER: $GCLOUD_PROJECT_NUMBER"`,
+];
+
+export const createGoogleCloudRunDeployJobs = (
+  context: Context
+): CatladderJob[] => {
+  const deployConfig = context.componentConfig.deploy;
+  if (deployConfig === false) {
+    return [];
+  }
+  if (!isOfDeployType(deployConfig, "google-cloudrun")) {
+    // should not happen
+    throw new Error("deploy config is wrong");
+  }
+  const baseDeploymentJob = getBaseDeploymentJob(context);
+
+  const fullAppName = `${context.fullConfig.customerName}-${context.fullConfig.appName}`;
+  const dockerUrl = `${deployConfig.region}-docker.pkg.dev/${deployConfig.projectId}/catladder-deploy/${fullAppName}`;
+  const gcloudImageName = `${dockerUrl}/$DOCKER_IMAGE_NAME:$DOCKER_IMAGE_TAG`;
+
+  const pushImageToArtifactsRegistry = [
+    gitlabDockerLogin,
+    `gcloud auth configure-docker ${deployConfig.region}-docker.pkg.dev`,
+    `docker pull $DOCKER_IMAGE:$DOCKER_IMAGE_TAG`,
+    `docker tag $DOCKER_IMAGE:$DOCKER_IMAGE_TAG ${gcloudImageName}`,
+    `docker push ${gcloudImageName}`,
+  ];
+
+  const allEnvVars = omit(
+    context.environment.envVars,
+    GCLOUD_DEPLOY_CREDENTIALS_KEY
+  );
+
+  const labelsString = Object.entries(getLabels(context))
+    .map(([key, value]) => `${key}=${value}`)
+    .join(",");
+
+  const commonArgs = {
+    project: deployConfig.projectId,
+    region: deployConfig.region,
+  };
+
+  const commonDeployArgs = {
+    image: gcloudImageName,
+    ...commonArgs,
+    "set-cloudsql-instances": deployConfig.cloudSql
+      ? deployConfig.cloudSql.instanceConnectionName
+      : undefined,
+    labels: labelsString,
+  };
+
+  const serviceName = context.environment.fullName.toLowerCase();
+
+  const getFullJobName = (name: string) =>
+    getCloudRunJobName(context.environment.fullName, name);
+
+  const jobsWithNames = Object.entries(deployConfig.jobs ?? {})
+    // filter out disabled jobs
+    .filter((entry): entry is [string, DeployConfigCloudRunJob] =>
+      Boolean(entry[1])
+    )
+    .map(([name, job]) => ({
+      jobName: getFullJobName(name),
+      job,
+    }));
+  const jobsWithSchedule = jobsWithNames
+    .filter(
+      (
+        entry
+      ): entry is {
+        jobName: string;
+        job: DeployConfigCloudRunJobWithSchedule;
+      } => entry.job.when === "schedule"
+    )
+    .map(({ job, jobName }) => ({
+      job,
+      jobName,
+      schedulerName: jobName + "-scheduler",
+    }));
+
+  const getServiceDeployScript = (
+    service: DeployConfigCloudRunService | true | undefined,
+    nameSuffix?: string
+  ) => {
+    const customConfig = service !== true ? service : undefined;
+    const command =
+      service !== true
+        ? service?.command ?? context.componentConfig.build.startCommand
+        : undefined;
+
+    const argsString = createArgsString({
+      // command as empty string resets it to default (uses the image's entrypoint)
+      command: command ? '"' + command.split(" ").join(",") + '"' : '""',
+      ...commonDeployArgs,
+      "env-vars-file": "____envvars.yaml",
+      "min-instances": customConfig?.minInstances ?? 0,
+      "max-instances": customConfig?.maxInstances ?? 100,
+      "cpu-throttling": customConfig?.noCpuThrottling !== true,
+      memory: customConfig?.memory,
+      "allow-unauthenticated": customConfig?.allowUnauthenticated ?? true,
+    });
+
+    return `gcloud run deploy ${serviceName}${nameSuffix ?? ""} ${argsString}`;
+  };
+
+  const getJobCreateScriptsForJob = (
+    jobName: string,
+    job: DeployConfigCloudRunJob
+  ) => {
+    // due to some oversight from google, jobs create does not accept `--env-vars-file` 🤦
+    // lucky, update on the other hand accepts it... so let's just imediatly update it
+
+    // also we cannot upsert a job, so we have to create it and catch the error and then update
+    const commonDeployArgsString = createArgsString({
+      command: '"' + job.command.split(" ").join(",") + '"',
+      ...commonDeployArgs,
+      memory: job.memory || "512Mi",
+    });
+
+    const argsString = `${jobName} ${commonDeployArgsString}`;
+    return [
+      ...allowFailureInScripts([`gcloud beta run jobs create ${argsString}`]),
+      `gcloud beta run jobs update ${argsString} --env-vars-file=____envvars.yaml`,
+    ];
+  };
+
+  const commonArgsString = createArgsString(commonArgs);
+
+  const getJobCreateScripts = () =>
+    jobsWithNames
+      .map(({ job, jobName }) => getJobCreateScriptsForJob(jobName, job))
+      .flat();
+
+  const getJobRunScriptForJob = (jobName: string) => {
+    return `gcloud beta run jobs execute ${jobName} ${commonArgsString}`;
+  };
+
+  const getJobRunScripts = (when: DeployConfigCloudRunJob["when"]) =>
+    jobsWithNames
+      .filter(({ job }) => job.when === when)
+      .map(({ jobName }) => getJobRunScriptForJob(jobName));
+
+  const getCreateScheduleScripts = () => {
+    return jobsWithSchedule
+      .map(({ job, jobName, schedulerName }) => {
+        const argsString = createArgsString({
+          project: deployConfig.projectId,
+          location: deployConfig.region,
+          schedule: `"${job.schedule}"`,
+          uri: `"https://${deployConfig.region}-run.googleapis.com/apis/run.googleapis.com/v1/namespaces/${deployConfig.projectId}/jobs/${jobName}:run"`,
+          "http-method": "POST",
+          "oauth-service-account-email":
+            "$GCLOUD_PROJECT_NUMBER-compute@developer.gserviceaccount.com",
+        });
+        const commonArgs = `http ${schedulerName} ${argsString}`;
+        return [
+          ...allowFailureInScripts([
+            `gcloud scheduler jobs create ${commonArgs}`,
+          ]),
+          `gcloud scheduler jobs update ${commonArgs}`,
+        ];
+      })
+      .flat();
+  };
+
+  const getDeleteSchedulesScripts = () => {
+    const argsString = createArgsString({
+      project: deployConfig.projectId,
+      location: deployConfig.region,
+    });
+    return jobsWithSchedule
+      .map(({ schedulerName }) => {
+        return [
+          ...allowFailureInScripts([
+            `gcloud scheduler jobs delete ${schedulerName} ${argsString}`,
+          ]),
+        ];
+      })
+      .flat();
+  };
+
+  const getDeleteJobsScripts = () =>
+    jobsWithNames.map(
+      ({ jobName }) =>
+        `gcloud beta run jobs delete ${jobName} ${commonArgsString}`
+    );
+
+  const deployScripts = [
+    ...gcloudServiceAccountLoginCommands(context),
+    ...setExtraVarsScripts(deployConfig),
+    ...pushImageToArtifactsRegistry,
+    `echo "$ENV_VARS" > ____envvars.yaml`, // TODO: split secrets out
+    ...(deployConfig.cloudSql
+      ? getDatabaseCreateScript(context, deployConfig) // we create the db, so that we can also delete it afterwards
+      : []),
+    ...getCreateScheduleScripts(),
+    ...getJobCreateScripts(),
+    ...getJobRunScripts("preDeploy"),
+
+    ...(deployConfig.service !== false
+      ? [getServiceDeployScript(deployConfig.service)]
+      : []),
+    ...Object.entries(deployConfig.additionalServices ?? {}).map(
+      ([name, service]) => getServiceDeployScript(service, "-" + name)
+    ),
+    ...getJobRunScripts("postDeploy"),
+
+    `docker image rm ${gcloudImageName}`,
+  ];
+
+  const stopScripts = [
+    ...gcloudServiceAccountLoginCommands(context),
+    ...(deployConfig.service !== false
+      ? [`gcloud run services delete ${serviceName} ${commonArgsString}`]
+      : []),
+    ...Object.entries(deployConfig.additionalServices ?? {}).map(
+      ([name]) =>
+        `gcloud run services delete ${serviceName}-${name} ${commonArgsString}`
+    ),
+    ...getDeleteSchedulesScripts(),
+    ...getDeleteJobsScripts(),
+    ...(deployConfig.cloudSql && deployConfig.cloudSql.deleteDatabaseOnStop
+      ? getDatabaseDeleteScript(context, deployConfig)
+      : []),
+  ];
+  return [
+    merge({}, baseDeploymentJob, getDockerJobBaseProps(context), {
+      artifacts: { paths: ["____envvars.yaml"] },
+      variables: {
+        CLOUDSDK_CORE_DISABLE_PROMPTS: "1",
+        ENV_VARS: dump(allEnvVars, {
+          lineWidth: -1,
+          quotingType: "'",
+          forceQuotes: true,
+        }),
+      },
+      image: getRunnerImage("gcloud"),
+      script: deployScripts,
+    }),
+
+    merge({}, getBaseDeploymentStopJob(context), {
+      image: getRunnerImage("gcloud"),
+      variables: {
+        CLOUDSDK_CORE_DISABLE_PROMPTS: "1",
+      },
+      script: stopScripts,
+    }),
+  ];
+};

package/src/deploy/cloudRun/index.ts

@@ -0,0 +1,95 @@
+import type { DeployTypeDefinition } from "..";
+import { getSecretVarName } from "../../context";
+import { sanitizeForBashVariable } from "../../utils/gitlab";
+import type { EnvironmentContext } from "../../types/environmentContext";
+import { createGoogleCloudRunDeployJobs } from "./deployJob";
+import { getCloudRunJobName } from "./utils/jobName";
+
+export const GCLOUD_DEPLOY_CREDENTIALS_KEY = "GCLOUD_DEPLOY_credentialsKey";
+
+export const GCLOUD_RUN_CANONICAL_HOST_SUFFIX =
+  "GCLOUD_RUN_canonicalHostSuffix";
+
+const getCloudSqlVariables = ({
+  deployConfigRaw,
+  environmentSlugPrefix,
+  env,
+  componentName,
+  fullConfig,
+}: EnvironmentContext<any, "google-cloudrun">) => {
+  if (deployConfigRaw && deployConfigRaw.cloudSql) {
+    const DB_NAME = [
+      deployConfigRaw.cloudSql.dbNamePrefix ??
+        `${fullConfig.customerName}-${fullConfig.appName}`,
+      environmentSlugPrefix,
+      deployConfigRaw.cloudSql.dbBaseName ?? componentName,
+    ]
+      .filter(Boolean)
+      .join("-");
+
+    const additionalQueryParamsString = Object.entries(
+      deployConfigRaw.cloudSql.dbAdditionalQueryParams ?? {}
+    )
+      .map(([key, value]) => `&${key}=${value}`)
+      .join("");
+
+    return {
+      CLOUD_SQL_INSTANCE_CONNECTION_NAME:
+        deployConfigRaw.cloudSql.instanceConnectionName,
+      DB_NAME: DB_NAME,
+      DB_USER: deployConfigRaw.cloudSql.dbUser ?? "postgres",
+      DB_PASSWORD: "$" + getSecretVarName(env, componentName, "DB_PASSWORD"),
+      DATABASE_URL: `postgresql://$DB_USER:$DB_PASSWORD@localhost/$DB_NAME?host=/cloudsql/$CLOUD_SQL_INSTANCE_CONNECTION_NAME${additionalQueryParamsString}`,
+      DATABASE_JDBC_URL: `jdbc:postgresql:///$DB_NAME?cloudSqlInstance=$CLOUD_SQL_INSTANCE_CONNECTION_NAME&socketFactory=com.google.cloud.sql.postgres.SocketFactory&user=$DB_USER&password=$DB_PASSWORD${additionalQueryParamsString}`,
+    };
+  }
+  return {};
+};
+export const GCLOUD_RUN_DEPLOY_TYPE: DeployTypeDefinition<"google-cloudrun"> = {
+  jobs: createGoogleCloudRunDeployJobs,
+  defaults: ({ deployConfigRaw, envType }) => {
+    if (deployConfigRaw && deployConfigRaw.cloudSql) {
+      return {
+        cloudSql: {
+          deleteDatabaseOnStop: envType === "review",
+        },
+      };
+    }
+    return {};
+  },
+  additionalSecretKeys: (ctx) => [
+    GCLOUD_DEPLOY_CREDENTIALS_KEY,
+    ...(ctx.deployConfigRaw && ctx.deployConfigRaw.cloudSql
+      ? ["DB_PASSWORD"]
+      : []),
+  ],
+  getAdditionalEnvVars: (ctx) => {
+    const { fullName, env, componentName, deployConfigRaw } = ctx;
+    const HOST_CANONICAL =
+      fullName.toLowerCase() +
+      "-" +
+      (process.env[
+        getSecretVarName(env, componentName, GCLOUD_RUN_CANONICAL_HOST_SUFFIX)
+      ] ?? "unknown-host.example.com");
+
+    const jobTriggers =
+      deployConfigRaw && deployConfigRaw.jobs
+        ? Object.fromEntries(
+            Object.entries(deployConfigRaw.jobs).map(([name, job]) => [
+              "CLOUD_RUN_JOB_TRIGGER_URL_" + sanitizeForBashVariable(name),
+              `https://${
+                deployConfigRaw.region
+              }-run.googleapis.com/apis/run.googleapis.com/v1/namespaces/${
+                deployConfigRaw.projectId
+              }/jobs/${getCloudRunJobName(fullName, name)}:run`,
+            ])
+          )
+        : {};
+
+    return {
+      HOST_CANONICAL,
+      ...getCloudSqlVariables(ctx),
+      ...jobTriggers,
+    };
+  },
+};

package/src/deploy/cloudRun/utils/createArgsString.ts

@@ -0,0 +1,26 @@
+import { isNil } from "lodash";
+
+/**
+ * creates arguments string:
+ *
+ * --key=value
+ *
+ * - undefined or null values will get removed completly
+ * - true will just be "--key"
+ * @param args args record
+ * @returns
+ */
+export const createArgsString = (
+  args: Record<string, string | number | true | false | undefined>
+) =>
+  Object.entries(args)
+    .filter(([, value]) => !isNil(value))
+    .map(([key, value]) => {
+      if (value === true) {
+        return `--${key}`;
+      } else if (value === false) {
+        return `--no-${key}`;
+      }
+      return `--${key}=${value}`;
+    })
+    .join(" ");

package/src/deploy/cloudRun/utils/database.ts

@@ -0,0 +1,55 @@
+import type { Context } from "../../../types";
+import { allowFailureInScripts, repeatOnFailure } from "../../../utils/gitlab";
+import type { DeployConfigCloudRun } from "../../types";
+
+export const getDatabaseDeleteScript = (
+  context: Context,
+  deployConfig: DeployConfigCloudRun
+): string[] => {
+  if (!deployConfig.cloudSql || !deployConfig.cloudSql.deleteDatabaseOnStop) {
+    throw new Error("not possible");
+  }
+
+  const { DB_NAME } = context.environment.envVars ?? {};
+  if (!DB_NAME) {
+    throw new Error("error: env vars did not specify DB_NAME");
+  }
+
+  const [projectId, region, instanceId] =
+    deployConfig.cloudSql.instanceConnectionName.split(":");
+  // unfortunatly the database cannot be deleted right after the service has stopped, as it might still have connections
+  // we have to repeate this process
+  return [
+    `echo "deleting database ${DB_NAME}..."`,
+    `echo "👆 this can take multiple attemps (3-5min), because google cloud run may still have a connection to the database after the cloud run service is shut down"`,
+    repeatOnFailure(
+      `gcloud sql databases delete ${DB_NAME} --instance=${instanceId} --project ${projectId}`,
+      {
+        pauseInSeconds: 10,
+      }
+    ),
+  ];
+};
+
+export const getDatabaseCreateScript = (
+  context: Context,
+  deployConfig: DeployConfigCloudRun
+): string[] => {
+  if (!deployConfig.cloudSql) {
+    throw new Error("not possible");
+  }
+
+  const { DB_NAME } = context.environment.envVars ?? {};
+
+  if (!DB_NAME) {
+    throw new Error("error: env vars did not specify DB_NAME");
+  }
+
+  const [projectId, region, instanceId] =
+    deployConfig.cloudSql.instanceConnectionName.split(":");
+  // may fail if it already exists
+  return allowFailureInScripts([
+    `echo "ensuring Database..."`,
+    `gcloud sql databases create ${DB_NAME} --instance=${instanceId} --project ${projectId}`,
+  ]);
+};

package/src/deploy/cloudRun/utils/gcloudServiceAccountLoginCommands.ts

@@ -0,0 +1,14 @@
+import { GCLOUD_DEPLOY_CREDENTIALS_KEY } from "..";
+import { getSecretVarNameForContext } from "../../../context";
+import type { Context } from "../../../types";
+
+export const gcloudServiceAccountLoginCommands = (context: Context) => {
+  return [
+    `echo $${getSecretVarNameForContext(
+      context,
+      GCLOUD_DEPLOY_CREDENTIALS_KEY
+    )} > ./____keyfile.json
+          `,
+    `gcloud auth activate-service-account --key-file="./____keyfile.json"`,
+  ];
+};

package/src/deploy/cloudRun/utils/jobName.ts

@@ -0,0 +1,2 @@
+export const getCloudRunJobName = (fullAppName: string, jobName: string) =>
+  fullAppName.toLowerCase() + "-" + jobName.toLowerCase();

package/src/deploy/custom/deployJob.ts

@@ -1,6 +1,9 @@
 import { merge } from "lodash";
-import { Context } from "../../types/context";
-import { CatladderJob } from "../../types/jobs";
+
+import { getYarnInstall } from "../../build/node/yarn";
+import { getRunnerImage } from "../../runner";
+import type { Context } from "../../types/context";
+import type { CatladderJob } from "../../types/jobs";
 import { getBaseDeploymentJob } from "../base";
 import { isOfDeployType } from "../types";
 
@@ -15,9 +18,16 @@ export const createCustomDeployJobs = (context: Context): CatladderJob[] => {
   }
   const baseDeploymentJob = getBaseDeploymentJob(context);
 
+  const yarnInstall = getYarnInstall(context);
   return [
     merge({}, baseDeploymentJob, {
-      script: [`cd ${context.componentConfig.dir}`, ...deployConfig.script],
+      image: deployConfig.jobImage ?? getRunnerImage("jobs-default"),
+      cache: deployConfig.jobCache ?? [],
+      script: [
+        `cd ${context.componentConfig.dir}`,
+        ...(deployConfig.requiresYarnInstall ? yarnInstall : []),
+        ...deployConfig.script,
+      ],
     }),
   ];
 };

package/src/deploy/custom/index.ts

@@ -1 +1,9 @@
-export * from "./deployJob";
+import type { DeployTypeDefinition } from "..";
+import { createCustomDeployJobs } from "./deployJob";
+
+export const CUSTOM_DEPLOY_TYPE: DeployTypeDefinition<"custom"> = {
+  jobs: createCustomDeployJobs,
+  defaults: () => ({}),
+  additionalSecretKeys: () => [],
+  getAdditionalEnvVars: () => ({}),
+};

package/src/deploy/dockerTag/deployJob.ts

@@ -0,0 +1,31 @@
+import { merge } from "lodash";
+import { getDockerJobBaseProps, gitlabDockerLogin } from "../../build/docker";
+
+import type { Context } from "../../types/context";
+import type { CatladderJob } from "../../types/jobs";
+import { getBaseDeploymentJob } from "../base";
+import { isOfDeployType } from "../types";
+
+export const createDockerTagDeployJobs = (context: Context): CatladderJob[] => {
+  const deployConfig = context.componentConfig.deploy;
+  if (deployConfig === false) {
+    return [];
+  }
+  if (!isOfDeployType(deployConfig, "dockerTag")) {
+    // should not happen
+    throw new Error("deploy config is not dockerTag");
+  }
+  const baseDeploymentJob = getBaseDeploymentJob(context);
+  const tag = deployConfig.tag;
+  return [
+    merge({}, baseDeploymentJob, getDockerJobBaseProps(context), {
+      script: [
+        gitlabDockerLogin,
+        `docker pull $DOCKER_IMAGE:$DOCKER_IMAGE_TAG`,
+        `docker tag $DOCKER_IMAGE:$DOCKER_IMAGE_TAG $DOCKER_IMAGE:${tag}`,
+        `docker push $DOCKER_IMAGE:${tag}`,
+        `echo "pushed as $DOCKER_IMAGE:${tag}"`,
+      ],
+    }),
+  ];
+};

package/src/deploy/dockerTag/index.ts

@@ -0,0 +1,9 @@
+import type { DeployTypeDefinition } from "..";
+import { createDockerTagDeployJobs } from "./deployJob";
+
+export const DOCKER_TAG_DEPLOY_TYPE: DeployTypeDefinition<"dockerTag"> = {
+  jobs: createDockerTagDeployJobs,
+  defaults: () => ({}),
+  additionalSecretKeys: () => [],
+  getAdditionalEnvVars: () => ({}),
+};

package/src/deploy/index.ts

@@ -1,25 +1,34 @@
-import { Context } from "../types/context";
-import { CatladderJob } from "../types/jobs";
-import { createCustomDeployJobs } from "./custom";
-import { createKubernetesDeployJobs } from "./kubernetes";
-import { DeployConfig } from "./types";
+import type { Context } from "../types/context";
+import type { EnvironmentContext } from "../types/environmentContext";
+import type { CatladderJob } from "../types/jobs";
+import type { PartialDeep } from "../types/utils";
+import { GCLOUD_RUN_DEPLOY_TYPE } from "./cloudRun";
+import { CUSTOM_DEPLOY_TYPE } from "./custom";
+import { DOCKER_TAG_DEPLOY_TYPE } from "./dockerTag";
+import { KUBERNETES_DEPLOY_TYPE } from "./kubernetes";
+import type { DeployConfigGeneric, DeployConfigType } from "./types";
+export * from "./cloudRun";
 export * from "./kubernetes";
 export * from "./types";
 export * from "./utils";
+
+export type DeployTypeDefinition<T extends DeployConfigType> = {
+  jobs: (context: Context) => CatladderJob[];
+  defaults: (
+    envContext: EnvironmentContext<any, T>
+  ) => PartialDeep<DeployConfigGeneric<T>>;
+  additionalSecretKeys: (envContext: EnvironmentContext<any, T>) => string[];
+  getAdditionalEnvVars: (
+    envContext: EnvironmentContext<any, T>
+  ) => Record<string, string | undefined | null>;
+};
 export type DeployTypes = {
-  [type in DeployConfig["type"]]: {
-    jobs: (context: Context) => CatladderJob[];
-    defaults: () => Partial<Extract<DeployConfig, { type: type }>>;
-  };
+  [T in DeployConfigType]: DeployTypeDefinition<T>;
 };
 
 export const DEPLOY_TYPES: DeployTypes = {
-  kubernetes: {
-    jobs: createKubernetesDeployJobs,
-    defaults: () => ({}),
-  },
-  custom: {
-    jobs: createCustomDeployJobs,
-    defaults: () => ({}),
-  },
+  kubernetes: KUBERNETES_DEPLOY_TYPE,
+  custom: CUSTOM_DEPLOY_TYPE,
+  dockerTag: DOCKER_TAG_DEPLOY_TYPE,
+  "google-cloudrun": GCLOUD_RUN_DEPLOY_TYPE,
 };

package/src/deploy/kubernetes/additionalSecretKeys.ts

@@ -0,0 +1,23 @@
+import type { EnvironmentContext } from "../../types/environmentContext";
+
+export const additionalKubernetesSecretKeys = ({
+  deployConfigRaw,
+}: EnvironmentContext<any, "kubernetes">) => {
+  if (!deployConfigRaw) {
+    return [];
+  }
+  const keys = [];
+  if (deployConfigRaw.values?.mongodb?.enabled) {
+    keys.push("MONGODB_ROOT_PASSWORD");
+    if (deployConfigRaw.values.mongodb.architecture === "replicaset") {
+      keys.push("MONGODB_REPLICASET_KEY");
+    }
+  }
+
+  if (deployConfigRaw.values?.cloudsql?.enabled) {
+    keys.push("POSTGRESQL_PASSWORD");
+    keys.push("cloudsqlProxyCredentials");
+  }
+
+  return keys;
+};

package/src/deploy/kubernetes/cloudSql/index.ts

@@ -0,0 +1,28 @@
+import { getSecretVarNameForContext } from "../../../context";
+import type { Context } from "../../../types";
+import { isOfDeployType } from "../../types";
+
+export const hasKubernetesCloudSQL = (context: Context) => {
+  if (isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
+    return context.componentConfig.deploy.values?.cloudsql?.enabled;
+  }
+  return false;
+};
+
+export const getKubernetesCloudSQLConfig = (context: Context) => {
+  if (isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
+    return context.componentConfig.deploy.values?.cloudsql;
+  }
+  throw new Error("cannot get cloud sql config");
+};
+
+export const createCloudsqlBaseConfig = (context: Context) => {
+  return {
+    cloudsql: {
+      proxyCredentials: `$${getSecretVarNameForContext(
+        context,
+        "cloudsqlProxyCredentials"
+      )}`,
+    },
+  };
+};