@reventlessdev/reventless-aws 3.0.0-alpha.346 → 3.0.0-alpha.348

package/scripts/BakeManifest.res.mjs

@@ -0,0 +1,487 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Lambda$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/Lambda.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as ClientLambda from "@aws-sdk/client-lambda";
+import * as PulumiCli$ReventlessAws from "./PulumiCli.res.mjs";
+import * as Util_AwsError$ReventlessAws from "../src/util/Util_AwsError.res.mjs";
+import * as DeployManifest$ReventlessAws from "./DeployManifest.res.mjs";
+
+function parseArgs(argv) {
+  let acc = {
+    TAG: "Ok",
+    _0: {
+      manifest: undefined,
+      stack: undefined,
+      since: undefined,
+      help: false
+    }
+  };
+  let i = 0;
+  let count = argv.length;
+  while (i < count) {
+    let flag = argv[i];
+    let value = argv[i + 1 | 0];
+    let match = acc;
+    let exit = 0;
+    if (match.TAG === "Ok") {
+      let a = match._0;
+      let exit$1 = 0;
+      switch (flag) {
+        case "--manifest" :
+          if (value !== undefined) {
+            acc = {
+              TAG: "Ok",
+              _0: {
+                manifest: value,
+                stack: a.stack,
+                since: a.since,
+                help: a.help
+              }
+            };
+            i = i + 2 | 0;
+          } else {
+            exit = 1;
+          }
+          break;
+        case "--since" :
+          if (value !== undefined) {
+            acc = {
+              TAG: "Ok",
+              _0: {
+                manifest: a.manifest,
+                stack: a.stack,
+                since: value === "" ? undefined : value,
+                help: a.help
+              }
+            };
+            i = i + 2 | 0;
+          } else {
+            exit = 1;
+          }
+          break;
+        case "--stack" :
+          if (value !== undefined) {
+            acc = {
+              TAG: "Ok",
+              _0: {
+                manifest: a.manifest,
+                stack: value,
+                since: a.since,
+                help: a.help
+              }
+            };
+            i = i + 2 | 0;
+          } else {
+            exit = 1;
+          }
+          break;
+        case "--help" :
+        case "-h" :
+          exit$1 = 2;
+          break;
+        default:
+          acc = {
+            TAG: "Error",
+            _0: `unknown argument "` + flag + `"`
+          };
+      }
+      if (exit$1 === 2) {
+        acc = {
+          TAG: "Ok",
+          _0: {
+            manifest: a.manifest,
+            stack: a.stack,
+            since: a.since,
+            help: true
+          }
+        };
+        i = i + 1 | 0;
+      }
+    } else {
+      i = count;
+    }
+    if (exit === 1) {
+      acc = {
+        TAG: "Error",
+        _0: flag + ` needs a value`
+      };
+    }
+  };
+  return acc;
+}
+
+let usage = `
+Bake the component manifest of a deployed platform.
+
+  --manifest <path>   The deploy manifest. Defaults to ` + DeployManifest$ReventlessAws.defaultFile + `
+                      in the working directory.
+  --stack <name>      The stack to bake. Defaults to the stack selected in the
+                      platform's folder.
+  --since <instant>   When this deploy started (ISO 8601). Lets the report tell a
+                      plugin that re-registered from one that was unchanged.
+
+Reads the bake function from the platform stack and each plugin's structure key
+from its stack, then asks the function to bake — again every
+15 seconds, up to 20 times, while a plugin's registration has
+not arrived. A registration this deploy wrote with another key cannot arrive by
+waiting, so that stops the run at once.
+`;
+
+function targetOf(outputs) {
+  let match = PulumiCli$ReventlessAws.stringOutput(outputs, "bakedManifestFunction");
+  let match$1 = PulumiCli$ReventlessAws.stringOutput(outputs, "bakedManifestBucket");
+  if (match !== undefined && match$1 !== undefined) {
+    return {
+      functionName: match,
+      bucket: match$1,
+      key: Stdlib_Option.getOr(PulumiCli$ReventlessAws.stringOutput(outputs, "bakedManifestKey"), "")
+    };
+  }
+}
+
+function structureRefOf(outputs) {
+  let ref = Stdlib_Option.flatMap(outputs["pluginStructureRef"], Stdlib_JSON.Decode.object);
+  if (ref === undefined) {
+    return;
+  }
+  let match = Stdlib_Option.flatMap(ref["plugin"], Stdlib_JSON.Decode.string);
+  let match$1 = Stdlib_Option.flatMap(ref["key"], Stdlib_JSON.Decode.string);
+  if (match !== undefined && match$1 !== undefined) {
+    return [
+      match,
+      match$1
+    ];
+  }
+}
+
+function payload(target, expect, since) {
+  let fields = [
+    [
+      "bake",
+      true
+    ],
+    [
+      "bucket",
+      target.bucket
+    ],
+    [
+      "key",
+      target.key
+    ],
+    [
+      "expect",
+      Stdlib_Dict.mapValues(expect, prim => prim)
+    ]
+  ];
+  Stdlib_Option.forEach(since, s => {
+    fields.push([
+      "since",
+      s
+    ]);
+  });
+  return Object.fromEntries(fields);
+}
+
+function _string(o, name) {
+  return Stdlib_Option.flatMap(o[name], Stdlib_JSON.Decode.string);
+}
+
+function _int(o, name) {
+  return Stdlib_Option.mapOr(Stdlib_Option.flatMap(o[name], Stdlib_JSON.Decode.float), 0, prim => prim | 0);
+}
+
+function _registrations(o) {
+  return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(o["registrations"], Stdlib_JSON.Decode.array), []), Stdlib_JSON.Decode.object).map(r => ({
+    plugin: Stdlib_Option.getOr(_string(r, "plugin"), "?"),
+    state: Stdlib_Option.getOr(_string(r, "state"), "?"),
+    expected: Stdlib_Option.getOr(_string(r, "expected"), "?"),
+    found: _string(r, "found"),
+    writtenAt: _string(r, "writtenAt")
+  }));
+}
+
+function readAnswer(json) {
+  let entries = Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_JSON.Decode.array(json), []), Stdlib_JSON.Decode.object);
+  let first = entries[0];
+  if (first === undefined) {
+    return {
+      TAG: "Error",
+      _0: `the bake function answered ` + JSON.stringify(json)
+    };
+  }
+  if (Primitive_object.equal(first["baked"], false)) {
+    return {
+      TAG: "Ok",
+      _0: {
+        TAG: "Pending",
+        pending: Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(first["pending"], Stdlib_JSON.Decode.array), []), Stdlib_JSON.Decode.string),
+        registrations: _registrations(first)
+      }
+    };
+  }
+  let summaryEntry = entries.find(e => Primitive_object.equal(e["summary"], true));
+  return {
+    TAG: "Ok",
+    _0: {
+      TAG: "Baked",
+      written: entries.filter(e => Primitive_object.equal(e["baked"], true)).map(e => ({
+        bucket: Stdlib_Option.getOr(_string(e, "bucket"), "?"),
+        key: Stdlib_Option.getOr(_string(e, "key"), "?"),
+        bytes: _int(e, "bytes"),
+        group: _string(e, "group")
+      })),
+      summary: Stdlib_Option.map(summaryEntry, s => ({
+        plugins: _int(s, "plugins"),
+        registered: _int(s, "registered"),
+        unchanged: _int(s, "unchanged"),
+        matched: _int(s, "matched")
+      })),
+      registrations: Stdlib_Option.mapOr(summaryEntry, [], _registrations)
+    }
+  };
+}
+
+function registrationLine(r) {
+  return `  ` + r.plugin + `: ` + r.state + ` — expected ` + r.expected + `, row holds ` + Stdlib_Option.getOr(r.found, "no row") + ` (written ` + Stdlib_Option.getOr(r.writtenAt, "never") + `)`;
+}
+
+function unreachable(registrations) {
+  return registrations.filter(r => r.state === "diverged");
+}
+
+async function converge(invoke, sleep, log, attempts) {
+  let attempt = async n => {
+    let e = await invoke();
+    if (e.TAG !== "Ok") {
+      return e;
+    }
+    let e$1 = readAnswer(e._0);
+    if (e$1.TAG !== "Ok") {
+      return e$1;
+    }
+    let match = e$1._0;
+    if (match.TAG === "Baked") {
+      return {
+        TAG: "Ok",
+        _0: {
+          written: match.written,
+          summary: match.summary,
+          registrations: match.registrations
+        }
+      };
+    }
+    let registrations = match.registrations;
+    let pending = match.pending;
+    registrations.forEach(r => log(registrationLine(r)));
+    let diverged = unreachable(registrations);
+    if (diverged.length !== 0) {
+      return {
+        TAG: "Error",
+        _0: diverged.map(r => r.plugin).join(", ") + ` registered during this deploy with a different structure than its stack exported; waiting will not change that, so nothing was written`
+      };
+    } else if (n < attempts) {
+      log(`Attempt ` + n.toString() + `: registration has not caught up yet — ` + pending.join(", "));
+      await sleep();
+      return await attempt(n + 1 | 0);
+    } else {
+      return {
+        TAG: "Error",
+        _0: `registration never caught up with this deploy (` + pending.join(", ") + `); the manifest would describe the previous one, so nothing was written`
+      };
+    }
+  };
+  return await attempt(1);
+}
+
+function inGitHubActions() {
+  return Primitive_object.equal(process.env["GITHUB_ACTIONS"], "true");
+}
+
+function invokeWith(client, functionName, payload) {
+  return async () => {
+    let exit = 0;
+    let output;
+    try {
+      output = await client.send(new ClientLambda.InvokeCommand({
+        FunctionName: functionName,
+        Payload: Buffer.from(JSON.stringify(payload), "utf8")
+      }));
+      exit = 1;
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      return {
+        TAG: "Error",
+        _0: `could not invoke ` + functionName + `: ` + Util_AwsError$ReventlessAws.describe(exn)
+      };
+    }
+    if (exit === 1) {
+      let text = Stdlib_Option.mapOr(output.Payload, "", bytes => Buffer.from(bytes).toString("utf8"));
+      let match = output.FunctionError;
+      if (match !== undefined) {
+        return {
+          TAG: "Error",
+          _0: `baking the component manifest failed: ` + text
+        };
+      }
+      let exit$1 = 0;
+      let json;
+      try {
+        json = JSON.parse(text);
+        exit$1 = 2;
+      } catch (exn$1) {
+        return {
+          TAG: "Error",
+          _0: `the bake function answered something that is not JSON: ` + text
+        };
+      }
+      if (exit$1 === 2) {
+        return {
+          TAG: "Ok",
+          _0: json
+        };
+      }
+    }
+  };
+}
+
+async function bake(manifest, stack, since) {
+  let e = PulumiCli$ReventlessAws.stackOutputs(manifest.platform.dir, stack);
+  if (e.TAG !== "Ok") {
+    return e;
+  }
+  let target = targetOf(e._0);
+  if (target !== undefined) {
+    let refs = [];
+    manifest.plugins.forEach(p => {
+      if (!PulumiCli$ReventlessAws.hasStackFile(p.dir, stack)) {
+        return;
+      }
+      let o = PulumiCli$ReventlessAws.stackOutputs(p.dir, stack);
+      if (o.TAG === "Ok") {
+        return Stdlib_Option.forEach(structureRefOf(o._0), r => {
+          refs.push(r);
+        });
+      }
+      console.error(p.name + `: ` + o._0 + ` — not waited for`);
+    });
+    let expect = Object.fromEntries(refs);
+    console.log(`Expecting: ` + JSON.stringify(Stdlib_Dict.mapValues(expect, prim => prim)));
+    console.log(`Baking ` + target.bucket + `/` + target.key + ` via ` + target.functionName);
+    let client = Lambda$AwsSdk.client(manifest.region, undefined);
+    let e$1 = await converge(invokeWith(client, target.functionName, payload(target, expect, since)), () => new Promise((resolve, param) => {
+      setTimeout(() => resolve(), 15000);
+    }), prim => {
+      console.log(prim);
+    }, 20);
+    if (e$1.TAG !== "Ok") {
+      return e$1;
+    }
+    let match = e$1._0;
+    match.written.forEach(w => {
+      console.log(`Wrote ` + w.bucket + `/` + w.key + ` (` + w.bytes.toString() + ` bytes` + Stdlib_Option.mapOr(w.group, "", g => `, for ` + g) + `)`);
+    });
+    match.registrations.forEach(r => {
+      console.log(registrationLine(r));
+    });
+    Stdlib_Option.forEach(match.summary, s => {
+      console.log(s.registered.toString() + `/` + s.plugins.toString() + ` plugin(s) re-registered during this deploy (` + s.unchanged.toString() + ` unchanged, ` + s.matched.toString() + ` undated).`);
+      if (s.registered !== 0) {
+        return;
+      }
+      let note = "The manifest is current, but no plugin exercised the registration chain on this deploy — it is unverified, not proven working.";
+      console.log(inGitHubActions() ? `::notice::` + note : `note: ` + note);
+    });
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
+  console.log("This platform declares no baked manifest — nothing to bake.");
+  return {
+    TAG: "Ok",
+    _0: undefined
+  };
+}
+
+async function run() {
+  let e = parseArgs(process.argv.slice(2, process.argv.length));
+  if (e.TAG !== "Ok") {
+    return e;
+  }
+  let args = e._0;
+  if (args.help) {
+    console.log(usage);
+    return {
+      TAG: "Ok",
+      _0: undefined
+    };
+  }
+  let e$1 = DeployManifest$ReventlessAws.load(Stdlib_Option.getOr(args.manifest, DeployManifest$ReventlessAws.defaultFile));
+  if (e$1.TAG !== "Ok") {
+    return e$1;
+  }
+  let manifest = e$1._0;
+  let stack = Stdlib_Option.orElse(args.stack, PulumiCli$ReventlessAws.selectedStack(manifest.platform.dir));
+  if (stack !== undefined) {
+    return await bake(manifest, stack, args.since);
+  } else {
+    return {
+      TAG: "Error",
+      _0: `no stack selected in ` + manifest.platform.dir + ` — pass --stack`
+    };
+  }
+}
+
+async function main() {
+  let message;
+  try {
+    message = await run();
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    console.error(`bake-manifest: ` + Util_AwsError$ReventlessAws.describe(exn));
+    process.exit(1);
+    return;
+  }
+  if (message.TAG === "Ok") {
+    return;
+  }
+  let message$1 = message._0;
+  console.error(inGitHubActions() ? `::error::` + message$1 : `bake-manifest: ` + message$1);
+  process.exit(1);
+}
+
+let Lambda;
+
+let attempts = 20;
+
+let intervalMs = 15000;
+
+export {
+  Lambda,
+  parseArgs,
+  usage,
+  targetOf,
+  structureRefOf,
+  payload,
+  _string,
+  _int,
+  _registrations,
+  readAnswer,
+  registrationLine,
+  unreachable,
+  converge,
+  attempts,
+  intervalMs,
+  inGitHubActions,
+  invokeWith,
+  bake,
+  run,
+  main,
+}
+/* Lambda-AwsSdk Not a pure module */