@catladder/pipeline 0.0.0-node16-ddfae617 → 0.0.0-refactor-env-context-9e652b63

package/src/deploy/cloudRun/index.ts

@@ -0,0 +1,48 @@
+import type { DeployTypeDefinition } from "..";
+import { getSecretVarName } from "../../context";
+import { createGoogleCloudRunDeployJobs } from "./deployJob";
+
+export const GCLOUD_DEPLOY_CREDENTIALS_KEY = "GCLOUD_DEPLOY_credentialsKey";
+
+export const GCLOUD_RUN_CANONICAL_HOST_SUFFIX =
+  "GCLOUD_RUN_canonicalHostSuffix";
+
+export const GCLOUD_RUN_DEPLOY_TYPE: DeployTypeDefinition<"google-cloudrun"> = {
+  jobs: createGoogleCloudRunDeployJobs,
+  defaults: () => ({}),
+  additionalSecretKeys: () => [GCLOUD_DEPLOY_CREDENTIALS_KEY],
+  getAdditionalEnvVars: ({ fullName, env, componentName }) => {
+    const HOST_CANONICAL =
+      fullName.toLowerCase() +
+      "-" +
+      process.env[
+        getSecretVarName(env, componentName, GCLOUD_RUN_CANONICAL_HOST_SUFFIX)
+      ];
+
+    return {
+      HOST_CANONICAL,
+    };
+  },
+};
+
+export const GCLOUD_RUN_JOB_DEPLOY_TYPE: DeployTypeDefinition<"google-cloudrun-job"> =
+  {
+    jobs: createGoogleCloudRunDeployJobs,
+    defaults: () => ({}),
+    additionalSecretKeys: () => [GCLOUD_DEPLOY_CREDENTIALS_KEY],
+    getAdditionalEnvVars: ({ deployConfigRaw, fullName }) => {
+      if (!deployConfigRaw) {
+        return {};
+      }
+
+      const jobName = fullName.toLowerCase();
+      const CLOUD_RUN_JOB_TRIGGER_URL = `https://${deployConfigRaw.region}-run.googleapis.com/apis/run.googleapis.com/v1/namespaces/${deployConfigRaw.projectId}/jobs/${jobName}:run`;
+
+      return { CLOUD_RUN_JOB_TRIGGER_URL };
+    },
+  };
+
+export const GCLOUD_RUN_DEPLOY_TYPES = {
+  "google-cloudrun": GCLOUD_RUN_DEPLOY_TYPE,
+  "google-cloudrun-job": GCLOUD_RUN_JOB_DEPLOY_TYPE,
+};

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/cloudSql/index.ts

@@ -0,0 +1,16 @@
+import type { Context } from "../../types";
+import { isOfDeployType } from "../types";
+
+export const hasCloudSQL = (context: Context) => {
+  if (isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
+    return context.componentConfig.deploy.values?.cloudsql?.enabled;
+  }
+  return false;
+};
+
+export const getCloudSQLConfig = (context: Context) => {
+  if (isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
+    return context.componentConfig.deploy.values?.cloudsql;
+  }
+  throw new Error("cannot get cloud sql config");
+};

package/src/deploy/custom/deployJob.ts

@@ -1,6 +1,8 @@
 import { merge } from "lodash";
-import { Context } from "../../types/context";
-import { CatladderJob } from "../../types/jobs";
+
+import { getYarnInstall } from "../../build/node/yarn";
+import type { Context } from "../../types/context";
+import type { CatladderJob } from "../../types/jobs";
 import { getBaseDeploymentJob } from "../base";
 import { isOfDeployType } from "../types";
 
@@ -15,9 +17,14 @@ export const createCustomDeployJobs = (context: Context): CatladderJob[] => {
   }
   const baseDeploymentJob = getBaseDeploymentJob(context);
 
+  const yarnInstall = getYarnInstall(context);
   return [
     merge({}, baseDeploymentJob, {
-      script: [`cd ${context.componentConfig.dir}`, ...deployConfig.script],
+      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 { GCLOUD_RUN_DEPLOY_TYPES } 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 "./cloudSql";
 export * from "./kubernetes";
 export * from "./types";
 export * from "./utils";
+
+export type DeployTypeDefinition<T extends DeployConfigType> = {
+  jobs: (context: Context) => CatladderJob[];
+  defaults: (
+    envVarContext: EnvironmentContext<any, T>
+  ) => Partial<DeployConfigGeneric<T>>;
+  additionalSecretKeys: (envVarContext: EnvironmentContext<any, T>) => string[];
+  getAdditionalEnvVars: (
+    envVarContext: 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,
+  ...GCLOUD_RUN_DEPLOY_TYPES,
 };

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.ts

@@ -1,4 +1,5 @@
-import { Context, getSecretVarNameForContext } from "../..";
+import type { Context} from "../..";
+import { getSecretVarNameForContext } from "../..";
 
 export const createCloudsqlBaseConfig = (context: Context) => {
   return {

package/src/deploy/kubernetes/deployJob.ts

@@ -1,16 +1,16 @@
 import { dump } from "js-yaml";
 import { merge } from "lodash";
-import { DeployConfigKubernetesValues } from "..";
 import { getSecretVarNameForContext } from "../..";
 import { getRunnerImage } from "../../runner";
-import { Context } from "../../types/context";
-import { CatladderJob } from "../../types/jobs";
-import { mergeWithMergingArrays } from "../../utils";
-import { getBaseDeploymentJob, getBaseDeploymentStopJob } from "../base";
+import type { Context } from "../../types/context";
+import type { CatladderJob } from "../../types/jobs";
+import {
+  getBaseDeploymentJob,
+  getBaseDeploymentStopJob,
+  getBaseRollbackJob,
+} from "../base";
 import { isOfDeployType } from "../types";
-import { createCloudsqlBaseConfig } from "./cloudsql";
-import { createMongodbBaseConfig } from "./mongodb";
-import { processSecretsAsFiles } from "./processSecretsAsFiles";
+import { createKubeValues } from "./kubeValues";
 
 export const createKubernetesDeployJobs = (
   context: Context
@@ -24,71 +24,7 @@ export const createKubernetesDeployJobs = (
     throw new Error("deploy config is not kubernetes");
   }
 
-  const allEnvVars = context.environment.envVars;
-  /**
-   * separate by secrets and public.
-   * we evalulate the actual values later, but want to store the secrets in kubernetes secrets
-   */
-  const env = Object.entries(allEnvVars).reduce<{
-    secret: Record<string, string>;
-    public: Record<string, string>;
-  }>(
-    (acc, [key, value]) => {
-      if (String(value)?.startsWith("$CL_")) {
-        acc.secret = {
-          ...acc.secret,
-          [key]: value,
-        };
-        return acc;
-      }
-      acc.public = {
-        ...acc.public,
-        [key]: value,
-      };
-      return acc;
-    },
-    {
-      secret: {},
-      public: {},
-    }
-  );
-
-  const defaultAppConfig: DeployConfigKubernetesValues["application"] = {
-    host: context.environment.host,
-    command: context.componentConfig.build.startCommand,
-    livenessProbe: {
-      httpGet: {
-        path: deployConfig.values?.application?.healthRoute ?? "__health",
-      },
-    },
-    readinessProbe: {
-      httpGet: {
-        path: deployConfig.values?.application?.healthRoute ?? "__health",
-      },
-    },
-    startupProbe: {
-      httpGet: {
-        path: deployConfig.values?.application?.healthRoute ?? "__health",
-      },
-    },
-  };
-
-  const defaultKubeValues = {
-    application: defaultAppConfig,
-
-    env: env,
-    ...(deployConfig.values?.cloudsql?.enabled
-      ? createCloudsqlBaseConfig(context)
-      : {}),
-    ...(deployConfig.values?.mongodb?.enabled
-      ? createMongodbBaseConfig(context)
-      : {}),
-  };
-
-  const kubeValues = processSecretsAsFiles(
-    mergeWithMergingArrays(defaultKubeValues, deployConfig.values)
-  );
-
+  const kubeValues = createKubeValues(context);
   const kubernetesEnvironment = {
     namespace: context.environment.envVars.KUBE_NAMESPACE,
   };
@@ -96,8 +32,9 @@ export const createKubernetesDeployJobs = (
     image: getRunnerImage("kubernetes"),
     variables: {
       ...context.environment.envVars,
+      RELEASE_NAME: context.environment.fullName,
       HELM_EXPERIMENTAL_OCI: "1",
-      IMAGE_PULL_SECRET: `gitlab-registry-${context.componentName}`,
+      KUBE_DOCKER_IMAGE_PULL_SECRET: `gitlab-registry-${context.componentName}`,
       KUBE_VALUES: dump(kubeValues, {
         lineWidth: -1,
         quotingType: "'",
@@ -110,14 +47,12 @@ export const createKubernetesDeployJobs = (
       ].join(" "),
       COMPONENT_NAME: context.componentName,
       BUILD_ID: context.commitInfo?.buildId,
-      // TODO: unify with docker build stage
-      IMAGE_NAME: context.environment.shortName + "/" + context.componentName,
-      IMAGE_TAG: "$CI_COMMIT_SHA",
     },
   };
 
   const baseDeploymentJob = getBaseDeploymentJob(context);
   const baseStopJob = getBaseDeploymentStopJob(context);
+  const baseRollbackJob = getBaseRollbackJob(context);
   const clusterName = `kube-${context.environment.fullName}`;
   const connectContext = [
     `kubectl config set-cluster "${clusterName}" --server="$${getSecretVarNameForContext(
@@ -152,5 +87,12 @@ export const createKubernetesDeployJobs = (
         kubernetes: kubernetesEnvironment,
       },
     }),
+
+    merge({}, baseRollbackJob, shared, {
+      script: [...connectContext, "kubernetesRollback"],
+      environment: {
+        kubernetes: kubernetesEnvironment,
+      },
+    }),
   ];
 };

package/src/deploy/kubernetes/index.ts

@@ -1 +1,42 @@
-export * from "./deployJob";
+import slugify from "slugify";
+import type { DeployTypeDefinition } from "..";
+import { getKubernetesNamespace } from "..";
+import { additionalKubernetesSecretKeys } from "./additionalSecretKeys";
+import { createKubernetesDeployJobs } from "./deployJob";
+
+export const KUBERNETES_DEPLOY_TYPE: DeployTypeDefinition<"kubernetes"> = {
+  jobs: createKubernetesDeployJobs,
+  defaults: () => ({}),
+  additionalSecretKeys: additionalKubernetesSecretKeys,
+  getAdditionalEnvVars: ({
+    componentName,
+    fullConfig,
+    deployConfigRaw,
+    env,
+    envType,
+    commitInfo,
+  }) => {
+    const KUBE_APP_NAME_PREFIX =
+      envType === "review" && commitInfo ? `${commitInfo.reviewSlug}-` : "";
+    const KUBE_APP_NAME = `${KUBE_APP_NAME_PREFIX}${componentName}`;
+    const KUBE_NAMESPACE = getKubernetesNamespace(fullConfig, env);
+    const componentSlug = slugify(componentName);
+    const envInUrl =
+      envType === "review" && commitInfo
+        ? `${commitInfo.reviewSlug}.${env}`
+        : env;
+
+    const domainCanonical =
+      (deployConfigRaw && deployConfigRaw.cluster?.domainCanonical) || // for convenience, we allow clusters to define a canonical domain, because a cluster has a fixed ip and you will usually have a domain pointing to that cluster
+      fullConfig.domainCanonical ||
+      "panter.cloud";
+    const HOST_CANONICAL = `${componentSlug}.${envInUrl}.${fullConfig.appName}.${fullConfig.customerName}.${domainCanonical}`; // default for kubernetes and rest
+
+    return {
+      KUBE_NAMESPACE,
+      KUBE_APP_NAME,
+      KUBE_APP_NAME_PREFIX,
+      HOST_CANONICAL,
+    };
+  },
+};

package/src/deploy/kubernetes/kubeEnv.ts

@@ -0,0 +1,48 @@
+import type { Context } from "../../types";
+import { isOfDeployType } from "../types";
+
+const shouldGoIntoSecrets = (key: string, value: string) => {
+  if (String(value)?.includes("$CL_")) {
+    return true;
+  }
+  return false;
+};
+
+/**
+ * separate by secrets and public.
+ * we evalulate the actual values later, but want to store the secrets in kubernetes secrets
+ */
+export const createKubeEnv = (context: Context) => {
+  if (!isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
+    // should not happen
+    throw new Error("deploy config is not kubernetes");
+  }
+
+  const allEnvVars = context.environment.envVars;
+
+  const env = Object.entries(allEnvVars).reduce<{
+    secret: Record<string, string>;
+    public: Record<string, string>;
+  }>(
+    (acc, [key, value]) => {
+      if (shouldGoIntoSecrets(key, value)) {
+        acc.secret = {
+          ...acc.secret,
+          [key]: value,
+        };
+        return acc;
+      }
+      acc.public = {
+        ...acc.public,
+        [key]: value,
+      };
+      return acc;
+    },
+    {
+      secret: {},
+      public: {},
+    }
+  );
+
+  return env;
+};

package/src/deploy/kubernetes/kubeValues.ts

@@ -0,0 +1,82 @@
+import { merge } from "lodash";
+
+import type { Context } from "../../types/context";
+import { mergeWithMergingArrays } from "../../utils";
+import { hasCloudSQL } from "../cloudSql";
+import type { DeployConfigKubernetesValues } from "../types";
+import { isOfDeployType } from "../types";
+import { createCloudsqlBaseConfig } from "./cloudsql";
+import { createKubeEnv } from "./kubeEnv";
+import { createMongodbBaseConfig } from "./mongodb";
+import { processSecretsAsFiles } from "./processSecretsAsFiles";
+
+const createAppConfig = (
+  context: Context,
+  application: DeployConfigKubernetesValues["application"]
+): DeployConfigKubernetesValues["application"] => {
+  if (application === false) {
+    return {
+      enabled: false,
+    };
+  }
+
+  return mergeWithMergingArrays(
+    {
+      host: context.environment.host,
+      command: context.componentConfig.build.startCommand,
+      livenessProbe: {
+        httpGet: {
+          path: application?.healthRoute ?? "__health",
+        },
+      },
+      readinessProbe: {
+        httpGet: {
+          path: application?.healthRoute ?? "__health",
+        },
+      },
+      startupProbe: {
+        httpGet: {
+          path: application?.healthRoute ?? "__health",
+        },
+      },
+    }, // default
+    application // merge rest in
+  );
+};
+
+export const createKubeValues = (context: Context) => {
+  const deployConfig = context.componentConfig.deploy;
+  if (deployConfig === false) {
+    return [];
+  }
+  if (!isOfDeployType(deployConfig, "kubernetes")) {
+    // should not happen
+    throw new Error("deploy config is not kubernetes");
+  }
+
+  const { values } = deployConfig;
+
+  // we remove the application config because it can be just the value `false` which is a convenience feature, but not supported in the helm chart
+  // we only merge the rest of the values in
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { application, ...rest } = values ?? {};
+
+  const env = createKubeEnv(context);
+
+  const defaultKubeValues = merge(
+    {
+      env,
+      application: createAppConfig(context, application),
+    },
+    hasCloudSQL(context) ? createCloudsqlBaseConfig(context) : {},
+    deployConfig.values?.mongodb?.enabled
+      ? createMongodbBaseConfig(context)
+      : {}
+  );
+
+  const kubeValues = processSecretsAsFiles(
+    mergeWithMergingArrays(defaultKubeValues, rest)
+  );
+
+  return kubeValues;
+};

package/src/deploy/kubernetes/mongodb.ts

@@ -1,17 +1,114 @@
-import { Context } from "../..";
+import { range } from "lodash";
+import type { Context } from "../..";
+import { getSecretVarNameForContext, isOfDeployType } from "../..";
 
+const getCredentialString = (context: Context) =>
+  `root:$${getSecretVarNameForContext(context, "MONGODB_ROOT_PASSWORD")}@`;
+const getMongodbHost = (context: Context, name: string) => {
+  const namespace = context.environment.envVars.KUBE_NAMESPACE;
+  return `${name}.${namespace}.svc.cluster.local:27017`;
+};
+
+const getMongodbStandaloneHost = (context: Context) => {
+  const fullAppname = context.environment.envVars.KUBE_APP_NAME;
+  return getMongodbHost(context, `${fullAppname}-mongodb`);
+};
+
+const getMongodbReplicasetHost = (context: Context, index: number) => {
+  const fullAppname = context.environment.envVars.KUBE_APP_NAME;
+  return getMongodbHost(
+    context,
+    `${fullAppname}-mongodb-${index}.${fullAppname}-mongodb-headless`
+  );
+};
+const createMongodbUrl = (context: Context, dbName: string) => {
+  if (!isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
+    throw new Error("can only createMongodbUrl on supported deploys");
+  }
+  const mongodbConfig = context.componentConfig.deploy.values?.mongodb;
+
+  let queryParams: string | undefined = undefined;
+
+  let hosts = "";
+  if (mongodbConfig?.architecture === "replicaset") {
+    hosts = range(0, mongodbConfig?.replicaCount ?? 2)
+      .map((i) => getMongodbReplicasetHost(context, i))
+      .join(",");
+
+    queryParams = "replicaSet=rs0&authSource=admin";
+  } else {
+    hosts = getMongodbStandaloneHost(context);
+    queryParams = "authSource=admin";
+  }
+
+  return `mongodb://${getCredentialString(context)}${hosts}/${dbName}${
+    queryParams ? `?${queryParams}` : ""
+  }`;
+};
+const createMongoBackupDefaultConfig = (context: Context) => {
+  if (!isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
+    throw new Error("can only create mongodb base config on supported deploys");
+  }
+  const mongodbConfig = context.componentConfig.deploy.values?.mongodb;
+  const fullAppName = context.environment.envVars.KUBE_APP_NAME;
+  const backupEnabled = ["prod", "stage"].includes(context.environment.envType);
+
+  let hostToBackup: string;
+  let pvcToBackup: string;
+
+  if (mongodbConfig?.architecture === "replicaset") {
+    // bit quirky, we need to specify the host and its volume
+    // on replicaset its probably best to not use the first one, whcih usually starts as master, so we take the second (last one would also be ok)
+    const backupHostIndex =
+      mongodbConfig?.architecture === "replicaset" &&
+      mongodbConfig.replicaCount &&
+      mongodbConfig.replicaCount > 1
+        ? 1
+        : 0;
+
+    hostToBackup = getMongodbReplicasetHost(context, backupHostIndex);
+    pvcToBackup = `datadir-${fullAppName}-mongodb-${backupHostIndex}`;
+  } else {
+    hostToBackup = getMongodbStandaloneHost(context);
+    pvcToBackup = `${fullAppName}-mongodb`;
+  }
+
+  return {
+    enabled: backupEnabled,
+    hostToBackup,
+    pvcToBackup,
+    image: "mrelite/kubectlmongoshell:v1.0",
+    schedule: "0 4 * * *",
+    volumeSnapshotClass: "snapshotclass",
+  };
+};
 export const createMongodbBaseConfig = (context: Context) => {
+  if (!isOfDeployType(context.componentConfig.deploy, "kubernetes")) {
+    throw new Error("can only create mongodb base config on supported deploys");
+  }
+  const mongodbConfig = context.componentConfig.deploy.values?.mongodb;
+
   return {
     mongodb: {
       enabled: true,
-      backup: {
-        enabled: ["prod", "stage"].includes(context.environment.envType),
+      auth: {
+        enabled: true,
+        rootPassword:
+          "$" + getSecretVarNameForContext(context, "MONGODB_ROOT_PASSWORD"),
+        replicaSetKey:
+          "$" + getSecretVarNameForContext(context, "MONGODB_REPLICASET_KEY"),
+      },
+      persistence: {
+        storageClass: "standard-rwo",
       },
+      backup: createMongoBackupDefaultConfig(context),
     },
-    "mongodb-replicaset": {
-      replicas: 1,
-      persistentVolume: {
-        storageClass: "standard",
+    env: {
+      secret: {
+        MONGO_URL: createMongodbUrl(context, mongodbConfig?.dbName ?? "app"),
+        ...(mongodbConfig?.architecture === "replicaset"
+          ? { MONGO_OPLOG_URL: createMongodbUrl(context, "local") } // oplog only works with replicasets
+          : {}),
       },
     },
   };