@vaharoni/devops 1.2.13 → 1.2.14

package/dist/chunk-WKP7EQNU.js

@@ -0,0 +1,421 @@
+import {
+  getConst,
+  getImageData,
+  globEnvYamlFiles
+} from "./chunk-RZ46YYZZ.js";
+
+// src/cli/common.ts
+import chalk from "chalk";
+import { execSync, spawn } from "child_process";
+import fs from "fs";
+
+// src/libs/k8s-constants.ts
+var MISSING_DOMAIN_KEY_ERROR = "$$$MISSING_DOMAIN_KEY$$$";
+var DEFAULT_REMOTE_ENVS = ["staging", "production"];
+var DEFAULT_LOCAL_ENVS = ["development", "test"];
+var _remoteSupportedEnvs;
+function remoteSupportedEnvs() {
+  if (_remoteSupportedEnvs) return _remoteSupportedEnvs;
+  const extra = getConst("extra-remote-environments", { ignoreIfInvalid: true }) ?? [];
+  _remoteSupportedEnvs = [...DEFAULT_REMOTE_ENVS, ...extra];
+  return _remoteSupportedEnvs;
+}
+var _localSupportedEnvs;
+function localSupportedEnvs() {
+  if (_localSupportedEnvs) return _localSupportedEnvs;
+  const extra = getConst("extra-local-environments", { ignoreIfInvalid: true }) ?? [];
+  _localSupportedEnvs = [...DEFAULT_LOCAL_ENVS, ...extra];
+  return _localSupportedEnvs;
+}
+function allSupportedEnvs() {
+  return [...remoteSupportedEnvs(), ...localSupportedEnvs()];
+}
+function isLocalOrRemoteEnv(monorepoEnv) {
+  if (remoteSupportedEnvs().includes(monorepoEnv)) return "remote";
+  if (localSupportedEnvs().includes(monorepoEnv)) return "local";
+  throw new Error(`Unsupported environment: ${monorepoEnv}`);
+}
+function validateEnv(monorepoEnv, { allowLocal = false } = {}) {
+  if (!monorepoEnv) throw new Error("MONOREPO_ENV cannot be empty");
+  if (allowLocal) {
+    if (!allSupportedEnvs().includes(monorepoEnv)) {
+      console.error(
+        `MONOREPO_ENV must be one of: ${allSupportedEnvs().join(", ")}. Can be set using --env flag.`
+      );
+      process.exit(1);
+    }
+  } else {
+    if (!remoteSupportedEnvs().includes(monorepoEnv)) {
+      console.error(
+        `MONOREPO_ENV must be one of: ${remoteSupportedEnvs().join(", ")}. Can be set using --env flag.`
+      );
+      process.exit(1);
+    }
+  }
+}
+function envToNamespace(monorepoEnv) {
+  validateEnv(monorepoEnv);
+  return `${getConst("project-name")}-${monorepoEnv}`;
+}
+function secretName() {
+  return `${getConst("project-name")}-secret`;
+}
+function imageDebugName(image) {
+  return `${image}-debug`;
+}
+function imageConfigMap(image) {
+  return `image-config-${image}`;
+}
+function containerRegistryImageName(image, monorepoEnv) {
+  validateEnv(monorepoEnv, { allowLocal: true });
+  return `${getConst("project-name")}-${monorepoEnv}-${image}`;
+}
+function containerRegistryPath() {
+  return [getConst("registry-base-url"), getConst("registry-image-path-prefix", { ignoreIfInvalid: true })].filter(Boolean).join("/");
+}
+function containerRegistryRepoPath(image, monorepoEnv, gitSha) {
+  const imageNameAndTag = [containerRegistryImageName(image, monorepoEnv), gitSha].join(":");
+  const imageData = getImageData(image);
+  if (imageData["cloudrun"]) {
+    return [
+      getConst("cloudrun-artifact-registry-repo-path"),
+      imageNameAndTag
+    ].join("/");
+  } else {
+    return [
+      getConst("registry-base-url"),
+      getConst("registry-image-path-prefix", { ignoreIfInvalid: true }),
+      imageNameAndTag
+    ].filter(Boolean).join("/");
+  }
+}
+function domainNameForEnv(image, monorepoEnv) {
+  const imageData = getImageData(image);
+  const value = imageData["domains"]?.[monorepoEnv] ?? MISSING_DOMAIN_KEY_ERROR;
+  return value;
+}
+function dbMigrateJobName(gitSha) {
+  return `db-migrate-job-${gitSha.slice(0, 8)}`;
+}
+
+// src/cli/common.ts
+var CLICommandParser = class {
+  command;
+  args;
+  env;
+  envForced;
+  help;
+  skipEnvCheck;
+  constructor(cmdArray) {
+    const parsedArgs = this._separateOptions(cmdArray.filter(Boolean), {
+      params: ["--env"],
+      booleans: ["--help", "--skip-env-check"]
+    });
+    const [command, ...args] = parsedArgs.args;
+    this.command = command;
+    this.args = args;
+    this.envForced = Boolean(parsedArgs.options["--env"]);
+    this.env = parsedArgs.options["--env"] ?? process.env["MONOREPO_ENV"] ?? "development";
+    this.help = Boolean(parsedArgs.options["--help"]);
+    this.skipEnvCheck = Boolean(parsedArgs.options["--skip-env-check"]);
+    if (this.command !== "init") {
+      this._validateEnv(this.env);
+    }
+  }
+  // Copies the env
+  executorFromEnv(commandStr, options = {}) {
+    const checkEnvYamlOverride = this.skipEnvCheck ? { checkEnvYaml: false } : {};
+    return new CommandExecutor(commandStr, {
+      env: this.env,
+      ...options,
+      ...checkEnvYamlOverride
+    });
+  }
+  // Example:
+  //    const cmd = new CLICommandParser('devops run --some-flag --in workspace arg1'.split(' '));
+  //    cmd.parseOptions({ boolean: ['--some-flag'], params: ['--in'] })
+  //    # => { args: ['arg1'], options: { '--some-flag': true, '--in': 'workspace' } }
+  //
+  // Note that the global param --env is already extracted and can be accessed with cmd.env
+  parseOptions({
+    params,
+    booleans,
+    passthroughArgs = false
+  } = {}) {
+    return this._separateOptions(this.args, {
+      params,
+      booleans,
+      passthroughArgs
+    });
+  }
+  _validateEnv(env) {
+    if (!allSupportedEnvs().includes(env)) {
+      console.error(
+        // prettier-ignore
+        `Environment must be one of: ${allSupportedEnvs().join(", ")}. Received: ${env}`
+      );
+      process.exit(1);
+    }
+    return true;
+  }
+  _separateOptions(args, {
+    params,
+    booleans,
+    passthroughArgs = false
+  } = {}) {
+    const paramsLookup = new Set(params ?? []);
+    const booleansLookup = new Set(booleans ?? []);
+    const isParam = (arg) => paramsLookup.has(arg);
+    const isBoolean = (arg) => booleansLookup.has(arg);
+    const passthroughArgsStart = passthroughArgs ? args.indexOf("--") : -1;
+    const numArgsToProcess = passthroughArgsStart === -1 ? args.length : passthroughArgsStart;
+    const getResPassthrough = () => {
+      if (!passthroughArgs || passthroughArgsStart < 0) return { passthrough: [] };
+      return { passthrough: args.slice(passthroughArgsStart + 1) };
+    };
+    const resArgs = [];
+    const resParams = {};
+    const resOptions = {};
+    for (let i = 0; i < numArgsToProcess; ++i) {
+      const curr = args[i];
+      if (isParam(curr)) {
+        const next = args[i + 1];
+        resParams[curr] = next;
+        ++i;
+      } else if (isBoolean(curr)) {
+        resOptions[curr] = true;
+      } else {
+        resArgs.push(curr);
+      }
+    }
+    return {
+      args: resArgs,
+      argsStr: resArgs.join(" "),
+      options: { ...resOptions, ...resParams },
+      ...getResPassthrough()
+    };
+  }
+};
+var CommandExecutor = class _CommandExecutor {
+  commandStr;
+  env;
+  quiet;
+  redactedCommand;
+  checkEnvYaml;
+  constructor(commandStr, {
+    env,
+    quiet = false,
+    redactedCommand,
+    checkEnvYaml = false
+  } = {}) {
+    this.env = env;
+    this.quiet = quiet ?? false;
+    this.commandStr = commandStr;
+    this.checkEnvYaml = checkEnvYaml;
+    this.redactedCommand = redactedCommand;
+  }
+  exec({
+    onlyStatusCode = false,
+    asObject = false,
+    env = {}
+  } = {}) {
+    this._checkEnvYamlFiles();
+    const fullCommand = this._prepareFullCommand();
+    const envToUse = this._getProcessEnv(env);
+    try {
+      const output = execSync(fullCommand, { env: envToUse });
+      if (onlyStatusCode) return 0;
+      if (!this.quiet) console.log(output.toString());
+      if (asObject) return { statusCode: 0, stdout: output.toString() };
+      return output.toString();
+    } catch (error) {
+      const typedError = error;
+      if (onlyStatusCode) return typedError.status;
+      const stdout = typedError.stdout?.toString().trim();
+      const stderr = typedError.stderr?.toString().trim();
+      if (!this.quiet) {
+        console.warn(stdout);
+        console.error(stderr);
+      }
+      if (asObject) return { statusCode: typedError.status, stdout, stderr };
+      process.exit(typedError.status);
+    }
+  }
+  /** Should be used for CLI commands intended to be used locally. Provides interactivity. Unlike exec(), stdout is not returned. */
+  spawn({ env, pipeStdoutTo } = {}) {
+    this._checkEnvYamlFiles();
+    const fullCommand = this._prepareFullCommand();
+    const envToUse = this._getProcessEnv(env);
+    const stdio = pipeStdoutTo === "stderr" ? ["inherit", "pipe", "inherit"] : "inherit";
+    return new Promise((resolve) => {
+      try {
+        const childProcess = spawn(fullCommand, {
+          stdio,
+          env: envToUse,
+          shell: true
+        });
+        if (pipeStdoutTo === "stderr") {
+          childProcess.stdout?.pipe(process.stderr);
+        }
+        childProcess.on("close", (code) => {
+          if (code !== 0) {
+            console.error(chalk.red(`Process exited with code ${code}`));
+            process.exit(code);
+          }
+          resolve(code);
+        });
+        childProcess.on("error", (error) => {
+          console.error(chalk.red(`Error: ${error.message}`));
+          process.exit(1);
+        });
+      } catch (error) {
+        if (error instanceof Error) {
+          console.error(chalk.red(`${error.message}`));
+        }
+        process.exit(1);
+      }
+    });
+  }
+  _prepareFullCommand() {
+    const envPrefix = this.env ? this._envInjectorPrefix() : "";
+    const fullCommand = [envPrefix, this.commandStr].join(" ").trim();
+    const envPrefixLog = this.env ? `MONOREPO_ENV=${this.env} MONOREPO_ROOT=${process.cwd()}` : "";
+    const fullCommandLog = [envPrefixLog, fullCommand].join(" ").trim();
+    if (this.redactedCommand) {
+      console.warn(
+        chalk.yellow(
+          fullCommandLog.replace(this.commandStr, this.redactedCommand)
+        )
+      );
+    } else {
+      console.warn(chalk.yellow(fullCommandLog));
+    }
+    return fullCommand;
+  }
+  _getProcessEnv(envOverride = {}) {
+    return { ...process.env, MONOREPO_ENV: this.env, MONOREPO_ROOT: process.cwd(), ...envOverride };
+  }
+  _envInjectorPrefix() {
+    const envFiles = dotEnvFilesForEnv(this.env);
+    if (envFiles.length === 0) {
+      return "";
+    } else {
+      return `bunx dotenvx -q run -f ${envFiles.join(" ")} -- `;
+    }
+  }
+  _checkEnvYamlFiles() {
+    if (!this.checkEnvYaml) return;
+    const envYamlFiles = globEnvYamlFiles();
+    const checkEnvCmd = new _CommandExecutor(
+      `devops env _validate ${envYamlFiles.join(" ")}`,
+      { env: this.env, quiet: true, checkEnvYaml: false }
+    );
+    checkEnvCmd.exec();
+  }
+};
+function dotEnvFilesForEnv(env) {
+  const globalEnvFilePath = "config/.env.global";
+  const specificEnvFilePath = `config/.env.${env}`;
+  const envFiles = [];
+  if (env && fs.existsSync(specificEnvFilePath))
+    envFiles.push(specificEnvFilePath);
+  if (fs.existsSync(globalEnvFilePath)) envFiles.push(globalEnvFilePath);
+  return envFiles;
+}
+function printUsageAndExit(text) {
+  console.warn(text);
+  process.exit(1);
+}
+var StrongParams = class {
+  constructor(usage, args) {
+    this.usage = usage;
+    this.args = args;
+  }
+  required(key) {
+    if (!this.args[key]) {
+      console.error(`Missing required argument: ${key}`);
+      printUsageAndExit(this.usage);
+    }
+    return this.args[key];
+  }
+  optional(key) {
+    return this.args[key];
+  }
+};
+
+// src/libs/k8s-helpers.ts
+import fs2 from "fs";
+var TMP_MANIFEST_FOLDER = "tmp/k8s-manifests";
+function kubectlCommand(cmd, opts = {}) {
+  if (opts.monorepoEnv || opts.namespace) {
+    const namespace = opts.namespace ?? envToNamespace(opts.monorepoEnv);
+    return `kubectl -n ${namespace} ${cmd}`;
+  } else {
+    return `kubectl ${cmd}`;
+  }
+}
+function upsertConfigMapCommand(monorepoEnv, configMapName, data) {
+  const manifest = {
+    apiVersion: "v1",
+    kind: "ConfigMap",
+    metadata: {
+      name: configMapName,
+      namespace: envToNamespace(monorepoEnv),
+      labels: {
+        env: monorepoEnv
+      }
+    },
+    data
+  };
+  const applyCmd = kubectlCommand(`apply -f -`, { monorepoEnv });
+  return `echo '${JSON.stringify(manifest)}' | ${applyCmd}`;
+}
+function patchSecretKeyCommand(monorepoEnv, secretName2, secretKey, secretValue) {
+  const redactedCommand = kubectlCommand(
+    `patch secret ${secretName2} -p='{"stringData": {"${secretKey}": **REDACTED**}}'`,
+    { monorepoEnv }
+  );
+  const fullCommand = redactedCommand.replace(
+    "**REDACTED**",
+    JSON.stringify(secretValue)
+  );
+  return { fullCommand, redactedCommand };
+}
+function applyHandler(filePrefix, command, manifest) {
+  if (!fs2.existsSync(TMP_MANIFEST_FOLDER)) {
+    fs2.mkdirSync(TMP_MANIFEST_FOLDER, { recursive: true });
+  }
+  const path2 = `${TMP_MANIFEST_FOLDER}/${filePrefix}-${Date.now()}.yaml`;
+  fs2.writeFileSync(path2, manifest);
+  new CommandExecutor(kubectlCommand(`${command} -f ${path2}`)).exec();
+}
+
+// src/pkg-root.ts
+import url from "url";
+import path from "path";
+var __file__ = url.fileURLToPath(import.meta.url);
+var pkgRoot = path.dirname(__file__);
+
+export {
+  MISSING_DOMAIN_KEY_ERROR,
+  isLocalOrRemoteEnv,
+  envToNamespace,
+  secretName,
+  imageDebugName,
+  imageConfigMap,
+  containerRegistryImageName,
+  containerRegistryPath,
+  containerRegistryRepoPath,
+  domainNameForEnv,
+  dbMigrateJobName,
+  CLICommandParser,
+  CommandExecutor,
+  dotEnvFilesForEnv,
+  printUsageAndExit,
+  StrongParams,
+  kubectlCommand,
+  upsertConfigMapCommand,
+  patchSecretKeyCommand,
+  applyHandler,
+  pkgRoot
+};

package/dist/devops.d.ts

@@ -1,3 +1 @@
 #!/usr/bin/env bun
-export {};
-//# sourceMappingURL=devops.d.ts.map