@deployfoundation/foundation-deploy 0.2.50 → 0.2.52

package/dist/chunk-9zx95xs6.js

@@ -0,0 +1,259 @@
+import {
+  instanceNames,
+  loadInstanceFile
+} from "./chunk-rxetj2p9.js";
+
+// src/deploy/aws.ts
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+// src/deploy/instance.ts
+import { dirname } from "node:path";
+var INSTANCE_FILE_ENV = "FOUNDATION_INSTANCE_FILE";
+function resolveInstanceFilePath(argv = [], env = {}) {
+  for (let i = 0;i < argv.length; i++) {
+    const arg = argv[i] ?? "";
+    if (arg === "--instance") {
+      const next = argv[i + 1];
+      if (next === undefined || next.startsWith("-"))
+        throw new Error("--instance needs a path, e.g. --instance .foundation/instance.yaml");
+      return next;
+    }
+    if (arg.startsWith("--instance=")) {
+      const value = arg.slice("--instance=".length);
+      if (value === "")
+        throw new Error("--instance needs a path");
+      return value;
+    }
+  }
+  const fromEnv = env[INSTANCE_FILE_ENV];
+  if (fromEnv !== undefined && fromEnv !== "")
+    return fromEnv;
+  throw new Error(`--instance <path> is required (or set ${INSTANCE_FILE_ENV}); it is the path to the deployment's instance YAML`);
+}
+function loadInstanceContext(path, cwd = process.cwd()) {
+  const file = loadInstanceFile(path, cwd);
+  return { ...file, root: dirname(file.path) };
+}
+function loadInstanceFromArgs(argv = process.argv.slice(2), env = process.env) {
+  return loadInstanceContext(resolveInstanceFilePath(argv, env));
+}
+function instanceBanner(context) {
+  const { instance } = context;
+  return `instance: ${instance.name} (account ${instance.aws.account}, region ${instance.aws.region})
+  file: ${context.path}
+  config: ${context.configPath}`;
+}
+
+// src/deploy/sh.ts
+import { spawn as nodeSpawn } from "node:child_process";
+function formatCommand(cmd, env) {
+  const prefix = Object.entries(env ?? {}).map(([k, v]) => `${k}=${quote(v)}`).join(" ");
+  const body = cmd.map(quote).join(" ");
+  return prefix === "" ? body : `${prefix} ${body}`;
+}
+function quote(value) {
+  return /^[A-Za-z0-9_@%+=:,./-]+$/.test(value) ? value : `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function start(cmd, opts, stdout) {
+  const [bin, ...rest] = cmd;
+  if (bin === undefined)
+    throw new Error("run: empty command");
+  const child = nodeSpawn(bin, rest, {
+    cwd: opts.cwd,
+    env: { ...process.env, ...opts.env },
+    stdio: [
+      opts.stdin === undefined ? "ignore" : "pipe",
+      stdout,
+      stdout === "inherit" ? "inherit" : "pipe"
+    ]
+  });
+  if (opts.stdin !== undefined && child.stdin !== null) {
+    child.stdin.end(opts.stdin);
+  }
+  return child;
+}
+function exited(child) {
+  return new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("close", (code, signal) => resolve(code ?? (signal === null ? 1 : 128)));
+  });
+}
+function collect(stream) {
+  if (stream === null)
+    return Promise.resolve("");
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    stream.on("data", (c) => chunks.push(c));
+    stream.once("error", reject);
+    stream.once("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+  });
+}
+async function run(cmd, opts = {}) {
+  if (opts.dryRun === true) {
+    console.log(`  $ ${formatCommand(cmd, opts.env)}`);
+    return;
+  }
+  const code = await exited(start(cmd, opts, "inherit"));
+  if (code !== 0)
+    throw new Error(`${formatCommand(cmd)} exited ${code}`);
+}
+async function runCapture(cmd, opts = {}) {
+  const child = start(cmd, opts, "pipe");
+  const [out, err, code] = await Promise.all([
+    collect(child.stdout),
+    collect(child.stderr),
+    exited(child)
+  ]);
+  if (code !== 0)
+    throw new Error(`${formatCommand(cmd)} exited ${code}: ${err.trim()}`);
+  return out.trim();
+}
+
+// src/deploy/aws.ts
+function resolveProfile(fallback, explicit, env = process.env) {
+  if (env.FOUNDATION_NO_PROFILE === "1")
+    return "";
+  if (explicit !== undefined)
+    return explicit;
+  if (env.AWS_PROFILE !== undefined && env.AWS_PROFILE !== "")
+    return env.AWS_PROFILE;
+  if (env.GITHUB_ACTIONS === "true")
+    return "";
+  return fallback;
+}
+function awsContext(overrides = {}) {
+  const env = overrides.env ?? process.env;
+  const paths = overrides.paths ?? loadInstanceFromArgs();
+  const instance = paths.instance;
+  return {
+    profile: resolveProfile(instance.aws.profile, overrides.profile, env),
+    region: overrides.region ?? env.AWS_REGION ?? instance.aws.region,
+    dryRun: overrides.dryRun ?? false,
+    instance,
+    paths,
+    names: instanceNames(instance)
+  };
+}
+function argv(ctx, args) {
+  const profile = ctx.profile === "" ? [] : ["--profile", ctx.profile];
+  return ["aws", ...args, ...profile, "--region", ctx.region];
+}
+function cdkEnv(ctx) {
+  return {
+    ...ctx.profile === "" ? {} : { AWS_PROFILE: ctx.profile },
+    AWS_REGION: ctx.region,
+    CDK_DEFAULT_REGION: ctx.region
+  };
+}
+async function aws(ctx, args, stdin) {
+  return runCapture(argv(ctx, args), { stdin });
+}
+async function awsMutate(ctx, args, stdin) {
+  if (ctx.dryRun === true) {
+    console.log(`  $ ${argv(ctx, args).join(" ")}${stdin === undefined ? "" : " < (stdin)"}`);
+    return;
+  }
+  await run(argv(ctx, args), { stdin });
+}
+async function stackOutput(ctx, stack, key) {
+  const value = await aws(ctx, [
+    "cloudformation",
+    "describe-stacks",
+    "--stack-name",
+    stack,
+    "--query",
+    `Stacks[0].Outputs[?OutputKey=='${key}'].OutputValue`,
+    "--output",
+    "text"
+  ]);
+  if (value === "" || value === "None")
+    throw new Error(`stack ${stack} has no output ${key} — has it been deployed?`);
+  return value;
+}
+async function stackExists(ctx, stack) {
+  try {
+    await aws(ctx, [
+      "cloudformation",
+      "describe-stacks",
+      "--stack-name",
+      stack,
+      "--output",
+      "text"
+    ]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function secretExists(ctx, secretId) {
+  try {
+    await aws(ctx, [
+      "secretsmanager",
+      "describe-secret",
+      "--secret-id",
+      secretId,
+      "--output",
+      "text"
+    ]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readSecretString(ctx, secretId) {
+  return aws(ctx, [
+    "secretsmanager",
+    "get-secret-value",
+    "--secret-id",
+    secretId,
+    "--query",
+    "SecretString",
+    "--output",
+    "text"
+  ]);
+}
+async function readSecretJson(ctx, secretId) {
+  return JSON.parse(await readSecretString(ctx, secretId));
+}
+async function putSecretString(ctx, secretId, value) {
+  await throughSecretFile(value, (file) => awsMutate(ctx, [
+    "secretsmanager",
+    "put-secret-value",
+    "--secret-id",
+    secretId,
+    "--secret-string",
+    `file://${file}`
+  ]));
+}
+async function createSecretString(ctx, secretId, value, description) {
+  await throughSecretFile(value, (file) => awsMutate(ctx, [
+    "secretsmanager",
+    "create-secret",
+    "--name",
+    secretId,
+    "--description",
+    description,
+    "--secret-string",
+    `file://${file}`
+  ]));
+}
+async function throughSecretFile(value, body) {
+  const dir = mkdtempSync(join(tmpdir(), "foundation-secret-"));
+  const file = join(dir, "value.json");
+  try {
+    writeFileSync(file, value, { mode: 384 });
+    await body(file);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+async function putSecretJson(ctx, secretId, value) {
+  await putSecretString(ctx, secretId, JSON.stringify(value));
+}
+async function callerAccountId(ctx) {
+  return aws(ctx, ["sts", "get-caller-identity", "--query", "Account", "--output", "text"]);
+}
+
+export { resolveInstanceFilePath, loadInstanceContext, instanceBanner, run, runCapture, awsContext, argv, cdkEnv, aws, awsMutate, stackOutput, stackExists, secretExists, readSecretString, readSecretJson, putSecretString, createSecretString, putSecretJson, callerAccountId };