@catladder/pipeline 0.0.0-node16-ddfae617 → 0.0.0-perf-cli-reduce-bundle-size-with-tsconfig-optimization-3556aaa4

package/src/deploy/cloudRun/createJobs/cloudRunJobs.ts

@@ -0,0 +1,198 @@
+import type { ComponentContext } from "../../../types/context";
+import { allowFailureInScripts } from "../../../utils/gitlab";
+
+import type {
+  DeployConfigCloudRunJob,
+  DeployConfigCloudRunJobWithSchedule,
+} from "../../types/googleCloudRun";
+import { createArgsString } from "../utils/createArgsString";
+import { getCloudRunJobName } from "../utils/jobName";
+import {
+  gcloudRunCmd,
+  gcloudSchedulerCmd,
+  getCloudRunDeployConfig,
+  getCommonCloudRunArgs,
+  getCommonDeployArgs,
+  makeLabelString,
+} from "./common";
+import { getLabels } from "../../../context/getLabels";
+import { createVolumeConfig } from "./volumes";
+import type {
+  BashExpression,
+  StringOrBashExpression,
+} from "../../../bash/BashExpression";
+import { ENV_VARS_FILENAME } from "./constants";
+
+const getJobRunScriptForJob = (
+  context: ComponentContext,
+  jobName: StringOrBashExpression,
+  wait: boolean,
+) => {
+  const commonArgs = getCommonCloudRunArgs(context);
+
+  const commonArgsString = createArgsString(commonArgs);
+  return `${gcloudRunCmd()} jobs execute ${jobName.toString()} ${commonArgsString}${
+    wait ? " --wait" : ""
+  }`;
+};
+
+export const getDeleteSchedulesScripts = (context: ComponentContext) => {
+  const deployConfig = getCloudRunDeployConfig(context);
+  const jobsWithSchedule = getCloudRunJobsWithSchedule(context);
+  const argsString = createArgsString({
+    project: deployConfig.projectId,
+    location: deployConfig.region,
+  });
+  return jobsWithSchedule
+    .map(({ schedulerName }) => {
+      return [
+        `${gcloudSchedulerCmd()} jobs delete ${schedulerName} ${argsString}`,
+      ];
+    })
+    .flat();
+};
+
+export const getDeleteJobsScripts = (context: ComponentContext) => {
+  const commonArgs = getCommonCloudRunArgs(context);
+  const commonArgsString = createArgsString(commonArgs);
+  const jobsWithNames = getCloudRunJobsWithNames(context);
+
+  return jobsWithNames.flatMap(({ jobName }) => [
+    // first delete all job executions. Otherwise delete might fail if one of those is still running
+    `${gcloudRunCmd()} jobs executions list ${commonArgsString} --job ${jobName} --format="value(name)" | xargs -I {} ${gcloudRunCmd()} jobs executions delete {}  --quiet ${commonArgsString}`,
+    `${gcloudRunCmd()} jobs delete ${jobName} ${commonArgsString}`,
+  ]);
+};
+
+export const getJobRunScripts = (
+  context: ComponentContext,
+  when: DeployConfigCloudRunJob["when"],
+) => {
+  const jobsWithNames = getCloudRunJobsWithNames(context);
+  return jobsWithNames
+    .filter(({ job }) => job.when === when)
+    .map(({ jobName }) =>
+      getJobRunScriptForJob(
+        context,
+        jobName,
+        // wait for completin on stop jobs, since stop will delete the jobs afterwards, so they will fail
+        ["preStop", "postStop"].includes(when),
+      ),
+    );
+};
+
+export const getJobCreateScripts = (context: ComponentContext) => {
+  const jobsWithNames = getCloudRunJobsWithNames(context);
+
+  return jobsWithNames
+    .map(({ job, jobName }) => getJobCreateScriptsForJob(context, jobName, job))
+    .flat();
+};
+
+const getJobCreateScriptsForJob = (
+  context: ComponentContext,
+  jobName: StringOrBashExpression,
+  job: DeployConfigCloudRunJob,
+) => {
+  const commonDeployArgs = getCommonDeployArgs(context);
+
+  // due to some oversight from google, jobs create does not yet accept `--add-volume` 🤦
+  // lucky, update on the other hand accepts it... so let's just imediatly update it
+  // we cannot upsert a job, so we have to create it and catch the error and then update
+  const commandArray = Array.isArray(job.command)
+    ? job.command
+    : job.command.split(" ");
+
+  const commonDeployArgsString = createArgsString({
+    command: '"' + commandArray.join(",") + '"',
+    ...commonDeployArgs,
+    labels: makeLabelString({
+      ...getLabels(context),
+      "cloud-run-job-name": jobName.toString(),
+    }),
+    image: job.image || commonDeployArgs.image,
+    cpu: job?.cpu,
+    memory: job.memory || "512Mi",
+    "task-timeout": job.timeout || "10m",
+    parallelism: job.parallelism || 1,
+    "env-vars-file": ENV_VARS_FILENAME,
+    "max-retries": 0,
+  });
+
+  const requiresBeta = job?.volumes && Object.keys(job?.volumes).length > 0;
+
+  const argsString = `${jobName} ${commonDeployArgsString}`;
+  return [
+    ...allowFailureInScripts([`${gcloudRunCmd()} jobs create ${argsString}`]),
+    `${gcloudRunCmd(
+      requiresBeta ? "beta" : undefined,
+    )} jobs update ${argsString} ${createArgsString(
+      ...createVolumeConfig(job?.volumes, "job"),
+    )}`,
+  ];
+};
+
+export const getCreateScheduleScripts = (context: ComponentContext) => {
+  const jobsWithSchedule = getCloudRunJobsWithSchedule(context);
+  const deployConfig = getCloudRunDeployConfig(context);
+
+  return jobsWithSchedule
+    .map(({ job, jobName, schedulerName }) => {
+      const argsString = createArgsString({
+        project: deployConfig.projectId,
+        location: deployConfig.region,
+        schedule: `"${job.schedule}"`,
+        "max-retry-attempts": job.maxRetryAttempts ?? 0,
+
+        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([
+          `${gcloudSchedulerCmd()} jobs create ${commonArgs}`,
+        ]),
+        `${gcloudSchedulerCmd()} jobs update ${commonArgs}`,
+      ];
+    })
+    .flat();
+};
+
+const getCloudRunJobsWithSchedule = (context: ComponentContext) => {
+  const jobsWithNames = getCloudRunJobsWithNames(context);
+
+  return jobsWithNames
+    .filter(
+      (
+        entry,
+      ): entry is {
+        jobName: BashExpression;
+        job: DeployConfigCloudRunJobWithSchedule;
+      } => entry.job.when === "schedule",
+    )
+    .map(({ job, jobName }) => ({
+      job,
+      jobName,
+      schedulerName: jobName.concat("-scheduler"),
+    }));
+};
+
+const getCloudRunJobsWithNames = (context: ComponentContext) => {
+  const deployConfig = getCloudRunDeployConfig(context);
+
+  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,
+    }));
+  return jobsWithNames;
+};

package/src/deploy/cloudRun/createJobs/cloudRunServices.ts

@@ -0,0 +1,86 @@
+import { getLabels } from "../../../context/getLabels";
+import type { ComponentContext } from "../../../types/context";
+
+import type { DeployConfigCloudRunService } from "../../types/googleCloudRun";
+import { createArgsString } from "../utils/createArgsString";
+import { getServiceName } from "../utils/getServiceName";
+import {
+  gcloudRunCmd,
+  getCommonCloudRunArgs,
+  getCommonDeployArgs,
+  makeLabelString,
+} from "./common";
+import { ENV_VARS_FILENAME } from "./constants";
+import { createVolumeConfig } from "./volumes";
+
+export const getServiceDeployScript = (
+  context: ComponentContext,
+  service: DeployConfigCloudRunService | true | undefined,
+  nameSuffix?: string,
+) => {
+  const commonDeployArgs = getCommonDeployArgs(context);
+
+  const serviceName = getServiceName(context);
+
+  const customConfig = service !== true ? service : undefined;
+  const command =
+    service !== true
+      ? service?.command ?? context.build.config.startCommand
+      : undefined;
+
+  const commandArray = command
+    ? Array.isArray(command)
+      ? command
+      : command.split(" ")
+    : undefined;
+  const fullServiceName = serviceName.concat(nameSuffix ?? "");
+  const argsString = createArgsString(
+    {
+      // command as empty string resets it to default (uses the image's entrypoint)
+      command: commandArray ? '"' + commandArray.join(",") + '"' : '""',
+      ...commonDeployArgs,
+      labels: makeLabelString({
+        ...getLabels(context),
+        "cloud-run-service-name": fullServiceName,
+      }),
+      "env-vars-file": ENV_VARS_FILENAME,
+      "min-instances": customConfig?.minInstances ?? 0,
+      "max-instances": customConfig?.maxInstances ?? 100,
+      "cpu-throttling": customConfig?.noCpuThrottling !== true,
+      cpu: customConfig?.cpu,
+      memory: customConfig?.memory,
+      timeout: customConfig?.timeout,
+      "allow-unauthenticated": customConfig?.allowUnauthenticated ?? true,
+      ingress: customConfig?.ingress ?? "all",
+      "cpu-boost": true,
+      "execution-environment": customConfig?.executionEnvironment,
+    },
+    ...createVolumeConfig(customConfig?.volumes, "service"),
+  );
+  // volumes require beta
+  const requiresBeta =
+    customConfig?.volumes && Object.keys(customConfig?.volumes).length > 0;
+
+  return `${gcloudRunCmd(
+    requiresBeta ? "beta" : undefined,
+  )} deploy ${fullServiceName} ${argsString}`;
+};
+
+export const getServiceDeleteScript = (
+  context: ComponentContext,
+  serviceSuffix?: string,
+) => {
+  const commonArgs = getCommonCloudRunArgs(context);
+
+  const commonArgsString = createArgsString(commonArgs);
+
+  const serviceName = getServiceName(context);
+
+  const fullServiceName = serviceSuffix
+    ? `${serviceName}-${serviceSuffix}`
+    : serviceName;
+
+  return [
+    `${gcloudRunCmd()} services delete ${fullServiceName} ${commonArgsString}`,
+  ];
+};

package/src/deploy/cloudRun/createJobs/common.ts

@@ -0,0 +1,59 @@
+import type { ComponentContext } from "../../../types/context";
+
+import { isOfDeployType } from "../../types";
+import type { DeployConfigCloudRun } from "../../types/googleCloudRun";
+import { getArtifactsRegistryImage } from "../artifactsRegistry";
+
+export const gcloudCmd = (version?: "beta") => {
+  return version ? `gcloud ${version}` : "gcloud";
+};
+export const gcloudRunCmd = (version?: "beta") => {
+  return `${gcloudCmd(version)} run`;
+};
+
+export const gcloudSchedulerCmd = (version?: "beta") => {
+  return `${gcloudCmd(version)} scheduler`;
+};
+
+export const setGoogleProjectNumberScript = (
+  deployConfig: DeployConfigCloudRun,
+) => [
+  `export GCLOUD_PROJECT_NUMBER=$(${gcloudCmd()} projects describe ${
+    deployConfig.projectId
+  } --format="value(projectNumber)")`,
+  'echo "GCLOUD_PROJECT_NUMBER: $GCLOUD_PROJECT_NUMBER"',
+];
+
+export const makeLabelString = (obj: Record<string, unknown>) =>
+  Object.entries(obj)
+    .map(([key, value]) => `${key}=${value}`)
+    .join(",");
+
+export const getCloudRunDeployConfig = (context: ComponentContext) => {
+  const deployConfig = context.deploy?.config;
+  if (!isOfDeployType(deployConfig, "google-cloudrun")) {
+    // should not happen
+    throw new Error("deploy config is wrong");
+  }
+  return deployConfig;
+};
+
+export function getCommonCloudRunArgs(context: ComponentContext) {
+  const deployConfig = getCloudRunDeployConfig(context);
+  return {
+    project: deployConfig.projectId,
+    region: deployConfig.region,
+  };
+}
+
+export function getCommonDeployArgs(context: ComponentContext) {
+  const commonArgs = getCommonCloudRunArgs(context);
+  const deployConfig = getCloudRunDeployConfig(context);
+  return {
+    image: getArtifactsRegistryImage(context),
+    ...commonArgs,
+    "set-cloudsql-instances": deployConfig.cloudSql
+      ? deployConfig.cloudSql.instanceConnectionName
+      : undefined,
+  };
+}

package/src/deploy/cloudRun/createJobs/constants.ts

@@ -0,0 +1 @@
+export const ENV_VARS_FILENAME = "____envvars.yaml";

package/src/deploy/cloudRun/createJobs/getCloudRunDeployScripts.ts

@@ -0,0 +1,79 @@
+import { isNil, omit } from "lodash";
+import type {
+  ComponentContext,
+  UnspecifiedEnvVars,
+} from "../../../types/context";
+import { collapseableSection } from "../../../utils/gitlab";
+import { getDependencyTrackUploadScript } from "../../sbom";
+
+import { getRemoveOldRevisionsAndImagesCommand } from "../cleanup";
+import { getDatabaseCreateScript } from "../utils/database";
+import { gcloudServiceAccountLoginCommands } from "../utils/gcloudServiceAccountLoginCommands";
+import {
+  getCreateScheduleScripts,
+  getJobCreateScripts,
+  getJobRunScripts,
+} from "./cloudRunJobs";
+import { getServiceDeployScript } from "./cloudRunServices";
+import {
+  getCloudRunDeployConfig,
+  setGoogleProjectNumberScript,
+} from "./common";
+import { GCLOUD_DEPLOY_CREDENTIALS_KEY } from "..";
+import type { StringOrBashExpression } from "../../../bash/BashExpression";
+import { BashExpression, bashEscape } from "../../../bash/BashExpression";
+import { ENV_VARS_FILENAME } from "./constants";
+import {
+  writeBashYamlToFileScript,
+  yamlBashString,
+} from "../../../bash/bashYaml";
+
+export function getCloudRunDeployScripts(context: ComponentContext) {
+  const deployConfig = getCloudRunDeployConfig(context);
+  const allEnvVars = omit(
+    context.environment.envVars,
+    GCLOUD_DEPLOY_CREDENTIALS_KEY,
+  );
+
+  return [
+    ...collapseableSection(
+      "prepare",
+      "Prepare...",
+    )([
+      ...gcloudServiceAccountLoginCommands(context),
+      ...setGoogleProjectNumberScript(deployConfig),
+    ]),
+    ...collapseableSection(
+      "writeenvvars",
+      "Write env vars to file",
+    )(writeBashYamlToFileScript(allEnvVars, ENV_VARS_FILENAME)),
+
+    ...collapseableSection(
+      "deploy",
+      "Deploy to cloud run",
+    )([
+      ...(deployConfig.cloudSql
+        ? getDatabaseCreateScript(context, deployConfig) // we create the db, so that we can also delete it afterwards
+        : []),
+      ...getCreateScheduleScripts(context),
+      ...getJobCreateScripts(context),
+      ...getJobRunScripts(context, "preDeploy"),
+
+      ...(deployConfig.service !== false
+        ? [getServiceDeployScript(context, deployConfig.service)]
+        : []),
+      ...Object.entries(deployConfig.additionalServices ?? {}).map(
+        ([name, service]) =>
+          getServiceDeployScript(context, service, "-" + name),
+      ),
+      ...getJobRunScripts(context, "postDeploy"),
+    ]),
+    ...collapseableSection(
+      "cleanup",
+      "Cleanup",
+    )(
+      getRemoveOldRevisionsAndImagesCommand(context, "postDeploy"), // we cleanup inactive images both on deploy and stop
+    ),
+    ...getDependencyTrackUploadScript(context),
+  ];
+}

package/src/deploy/cloudRun/createJobs/getCloudRunStopScripts.ts

@@ -0,0 +1,34 @@
+import type { ComponentContext } from "../../../types/context";
+import { getDependencyTrackDeleteScript } from "../../sbom";
+
+import { getRemoveOldRevisionsAndImagesCommand } from "../cleanup";
+import { getDatabaseDeleteScript } from "../utils/database";
+import { gcloudServiceAccountLoginCommands } from "../utils/gcloudServiceAccountLoginCommands";
+import {
+  getDeleteJobsScripts,
+  getDeleteSchedulesScripts,
+  getJobRunScripts,
+} from "./cloudRunJobs";
+import { getServiceDeleteScript } from "./cloudRunServices";
+import { getCloudRunDeployConfig } from "./common";
+
+export function getCloudRunStopScripts(context: ComponentContext) {
+  const deployConfig = getCloudRunDeployConfig(context);
+  return [
+    ...gcloudServiceAccountLoginCommands(context),
+    ...getJobRunScripts(context, "preStop"),
+    ...(deployConfig.service !== false ? getServiceDeleteScript(context) : []),
+    ...Object.entries(deployConfig.additionalServices ?? {}).flatMap(([name]) =>
+      getServiceDeleteScript(context, name),
+    ),
+    ...getJobRunScripts(context, "postStop"),
+    ...getDeleteSchedulesScripts(context),
+    ...getDeleteJobsScripts(context),
+    ...(deployConfig.cloudSql && deployConfig.cloudSql.deleteDatabaseOnStop
+      ? getDatabaseDeleteScript(context, deployConfig)
+      : []),
+
+    ...getRemoveOldRevisionsAndImagesCommand(context, "onStop"), // we cleanup inactive images both on deploy and stop
+    ...getDependencyTrackDeleteScript(context),
+  ];
+}

package/src/deploy/cloudRun/createJobs/index.ts

@@ -0,0 +1,51 @@
+import { getRunnerImage } from "../../../runner";
+import type { ComponentContext } from "../../../types/context";
+import type { CatladderJob } from "../../../types/jobs";
+import { allowFailureInScripts } from "../../../utils/gitlab";
+import { createDeployementJobs } from "../../base";
+
+import { isOfDeployType } from "../../types";
+import { ENV_VARS_FILENAME } from "./constants";
+import { getCloudRunDeployScripts } from "./getCloudRunDeployScripts";
+import { getCloudRunStopScripts } from "./getCloudRunStopScripts";
+
+export const createGoogleCloudRunDeployJobs = (
+  context: ComponentContext,
+): CatladderJob[] => {
+  const deployConfig = context.deploy?.config;
+  if (!isOfDeployType(deployConfig, "google-cloudrun")) {
+    // should not happen
+    throw new Error("deploy config is wrong");
+  }
+
+  const deployScripts = getCloudRunDeployScripts(context);
+  const stopScripts = getCloudRunStopScripts(context);
+
+  return createDeployementJobs(context, {
+    deploy: {
+      variables: {
+        CLOUDSDK_CORE_DISABLE_PROMPTS: "1",
+      },
+      ...(deployConfig.debug
+        ? {
+            artifacts: {
+              paths: [
+                ENV_VARS_FILENAME, // debug
+              ],
+              when: "always",
+            },
+          }
+        : {}),
+
+      image: getRunnerImage("gcloud"),
+      script: deployScripts,
+    },
+    stop: {
+      image: getRunnerImage("gcloud"),
+      variables: {
+        CLOUDSDK_CORE_DISABLE_PROMPTS: "1",
+      },
+      script: allowFailureInScripts(stopScripts),
+    },
+  });
+};

package/src/deploy/cloudRun/createJobs/volumes.ts

@@ -0,0 +1,23 @@
+import type { DeployConfigCloudRunVolumes } from "../../types";
+import type { keyValuesArg } from "../utils/createArgsString";
+
+export const createVolumeConfig = (
+  volumes: DeployConfigCloudRunVolumes | undefined,
+  type: "service" | "job",
+): keyValuesArg[] => {
+  if (!volumes) {
+    return [];
+  }
+
+  return [
+    ...Object.entries(volumes).map(
+      ([volumeName, { type, bucket, mountPath, readonly }]) => ({
+        "add-volume": `name=${volumeName},type=${type},bucket=${bucket}${
+          readonly ? ",readonly=true" : ""
+        }`,
+        "add-volume-mount": `volume=${volumeName},mount-path=${mountPath}`,
+      }),
+    ),
+    type === "service" ? { "execution-environment": "gen2" } : {},
+  ];
+};

package/src/deploy/cloudRun/index.ts

@@ -0,0 +1,127 @@
+import type { DeployConfigCloudRun, DeployTypeDefinition } from "..";
+import {
+  getBashVariable,
+  joinBashExpressions,
+} from "../../bash/BashExpression";
+import type { BuildConfig } from "../../build";
+import { getSecretVarName } from "../../context";
+import type { EnvironmentContext } from "../../types/environmentContext";
+import { sanitizeForBashVariable } from "../../utils/gitlab";
+import { getFullDbName } from "../cloudSql/utils";
+import { createGoogleCloudRunDeployJobs } from "./createJobs";
+import {
+  DATABASE_JDBC_URL,
+  getDatabaseConnectionString,
+} from "./utils/database";
+import { getCloudRunJobName } from "./utils/jobName";
+
+export const GCLOUD_DEPLOY_CREDENTIALS_KEY = "GCLOUD_DEPLOY_credentialsKey";
+
+// FIXME: rename to internalHostSuffix, but this means that project-setup needs to be rerun, so its kindof a breaking change
+export const GCLOUD_RUN_CANONICAL_HOST_SUFFIX =
+  "GCLOUD_RUN_canonicalHostSuffix";
+
+const getCloudSqlVariables = ({
+  deployConfigRaw,
+  environmentSlugPrefix,
+  env,
+  componentName,
+  fullConfig,
+}: EnvironmentContext<BuildConfig, DeployConfigCloudRun>) => {
+  if (deployConfigRaw && deployConfigRaw.cloudSql) {
+    const DB_NAME = getFullDbName(
+      deployConfigRaw.cloudSql,
+      fullConfig,
+      environmentSlugPrefix,
+      componentName,
+    );
+
+    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: `${getDatabaseConnectionString(
+        deployConfigRaw.cloudSql,
+      )}${additionalQueryParamsString}`,
+      DATABASE_JDBC_URL: DATABASE_JDBC_URL,
+    };
+  }
+  return {};
+};
+export const GCLOUD_RUN_DEPLOY_TYPE: DeployTypeDefinition<DeployConfigCloudRun> =
+  {
+    jobs: createGoogleCloudRunDeployJobs,
+    defaults: ({ deployConfigRaw, envType }) => {
+      if (deployConfigRaw && deployConfigRaw.cloudSql) {
+        return {
+          cloudSql: {
+            deleteDatabaseOnStop: envType === "review",
+          },
+        };
+      }
+      return {};
+    },
+    additionalSecretKeys: (ctx) => [
+      {
+        key: GCLOUD_DEPLOY_CREDENTIALS_KEY,
+        hidden: true,
+      },
+      {
+        key: GCLOUD_RUN_CANONICAL_HOST_SUFFIX,
+        hidden: true,
+      },
+      ...(ctx.deployConfigRaw && ctx.deployConfigRaw.cloudSql
+        ? [{ key: "DB_PASSWORD" }]
+        : []),
+    ],
+    getAdditionalEnvVars: (ctx) => {
+      const { fullName, env, componentName, deployConfigRaw } = ctx;
+
+      const HOST_INTERNAL = joinBashExpressions(
+        [
+          fullName,
+          getBashVariable(
+            getSecretVarName(
+              env,
+              componentName,
+              GCLOUD_RUN_CANONICAL_HOST_SUFFIX,
+            ),
+          ),
+        ],
+        "-",
+      ).toLowerCase();
+      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_INTERNAL,
+        ...getCloudSqlVariables(ctx),
+        ...jobTriggers,
+        DEPLOY_CLOUD_RUN_PROJECT_ID: deployConfigRaw
+          ? deployConfigRaw.projectId
+          : undefined,
+        DEPLOY_CLOUD_RUN_REGION: deployConfigRaw
+          ? deployConfigRaw.region
+          : undefined,
+      };
+    },
+  };