@reventlessdev/reventless-seed-aws 1.0.0-alpha.3 → 1.0.0-alpha.4

package/lib/bs/src/ReventlessSeedAws_Reset.res.mjs

@@ -0,0 +1,675 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as S3$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/S3.res.mjs";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+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_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as ReventlessSeedAws from "./ReventlessSeedAws.res.mjs";
+import * as ClientS3 from "@aws-sdk/client-s3";
+import * as Seed$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as LibDynamodb from "@aws-sdk/lib-dynamodb";
+import * as ClientDynamodb from "@aws-sdk/client-dynamodb";
+import * as DynamoDb_DynamoDb$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DynamoDb.res.mjs";
+import * as Seed_Prompt$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed_Prompt.res.mjs";
+import * as Seed_Runner$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed_Runner.res.mjs";
+import * as DynamoDb_DocumentClient$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DocumentClient.res.mjs";
+import * as ResourceGroupsTaggingApi$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/ResourceGroupsTaggingApi.res.mjs";
+import * as ClientResourceGroupsTaggingApi from "@aws-sdk/client-resource-groups-tagging-api";
+
+function projectName(projectDir) {
+  let path = projectDir + `/Pulumi.yaml`;
+  let raw;
+  try {
+    raw = Nodefs.readFileSync(path, "utf8");
+  } catch (exn) {
+    throw {
+      RE_EXN_ID: Seed$ReventlessSeed.Failed,
+      _1: `could not read ` + path + ` to scope the wipe to this Pulumi project.`,
+      Error: new Error()
+    };
+  }
+  let line = raw.split("\n").find(line => line.trim().startsWith("name:"));
+  if (line !== undefined) {
+    let trimmed = line.trim();
+    return trimmed.slice("name:".length, trimmed.length).trim().replace(/^[\"']|[\"']$/g, "");
+  }
+  throw {
+    RE_EXN_ID: Seed$ReventlessSeed.Failed,
+    _1: `could not find a \`name:\` field in ` + path + `.`,
+    Error: new Error()
+  };
+}
+
+function field(json, key) {
+  if (typeof json === "object" && json !== null && !Array.isArray(json)) {
+    return json[key];
+  }
+}
+
+function asString(json) {
+  if (typeof json === "string") {
+    return json;
+  }
+}
+
+function chunk(arr, size) {
+  let out = [];
+  let i = 0;
+  while (i < arr.length) {
+    out.push(arr.slice(i, i + size | 0));
+    i = i + size | 0;
+  };
+  return out;
+}
+
+let nameAllowlist = /^(alpha|dev|pr-.+)$/;
+
+function readStackConfig(projectDir, backend, stack) {
+  let raw;
+  try {
+    raw = ReventlessSeedAws.pulumi(projectDir, backend, [
+      "config",
+      "--json",
+      "--stack",
+      stack
+    ]);
+  } catch (exn) {
+    raw = undefined;
+  }
+  if (raw === undefined) {
+    return {
+      TAG: "Error",
+      _0: `could not read the Pulumi config for stack "` + stack + `" — is pulumi logged in to the right backend, and is the stack deployed?`
+    };
+  }
+  let match;
+  try {
+    match = JSON.parse(raw);
+  } catch (exn$1) {
+    match = undefined;
+  }
+  if (typeof match === "object" && match !== null && !Array.isArray(match)) {
+    return {
+      TAG: "Ok",
+      _0: match
+    };
+  }
+  return {
+    TAG: "Error",
+    _0: `could not parse \`pulumi config --json\` output for stack "` + stack + `".`
+  };
+}
+
+function configValue(cfg, key) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(cfg[key], v => field(v, "value")), asString);
+}
+
+function classify(arn) {
+  if (!arn.startsWith("arn:aws:dynamodb:")) {
+    if (arn.startsWith("arn:aws:s3:::")) {
+      return {
+        TAG: "Bucket",
+        _0: arn.slice("arn:aws:s3:::".length, arn.length)
+      };
+    } else {
+      return "Other";
+    }
+  }
+  let match = arn.split(":table/");
+  if (match.length !== 2) {
+    return "Other";
+  }
+  let name = match[1];
+  return {
+    TAG: "Table",
+    _0: name
+  };
+}
+
+function tagValue(tags, key) {
+  return Stdlib_Array.findMap(tags, t => {
+    if (t.Key === key) {
+      return t.Value;
+    }
+  });
+}
+
+async function discover(region, stack, platform) {
+  let client = ResourceGroupsTaggingApi$AwsSdk.client(region, undefined);
+  let tables = [];
+  let buckets = [];
+  let loop = async token => {
+    let out = await client.send(new ClientResourceGroupsTaggingApi.GetResourcesCommand({
+      TagFilters: [
+        {
+          Key: "reventless:platform",
+          Values: [platform]
+        },
+        {
+          Key: "reventless:environment",
+          Values: [stack]
+        }
+      ],
+      ResourceTypeFilters: [
+        "dynamodb:table",
+        "s3"
+      ],
+      ResourcesPerPage: 100,
+      PaginationToken: token
+    }));
+    Stdlib_Option.getOr(out.ResourceTagMappingList, []).forEach(m => {
+      let tags = Stdlib_Option.getOr(m.Tags, []);
+      let assertTag = (key, expected) => {
+        let v = tagValue(tags, key);
+        if (v !== undefined && v === expected) {
+          return;
+        }
+        throw {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: `refusing: discovered resource ` + m.ResourceARN + ` carries ` + key + `=` + Stdlib_Option.getOr(v, "<none>") + `, not "` + expected + `".`,
+          Error: new Error()
+        };
+      };
+      assertTag("reventless:platform", platform);
+      assertTag("reventless:environment", stack);
+      let name = classify(m.ResourceARN);
+      if (typeof name !== "object") {
+        return;
+      }
+      if (name.TAG === "Table") {
+        tables.push(name._0);
+        return;
+      }
+      buckets.push(name._0);
+    });
+    let t = out.PaginationToken;
+    if (t !== undefined && t !== "") {
+      return await loop(t);
+    }
+  };
+  await loop(undefined);
+  return [
+    tables,
+    buckets
+  ];
+}
+
+async function countTable(table) {
+  let loop = async (start, acc) => {
+    let out = await DynamoDb_DocumentClient$AwsSdk.ScanCommand.send(new LibDynamodb.ScanCommand({
+      TableName: table,
+      ExclusiveStartKey: start,
+      Select: "COUNT"
+    }));
+    let acc$1 = acc + Stdlib_Option.getOr(out.Count, 0) | 0;
+    let k = out.LastEvaluatedKey;
+    if (k !== undefined) {
+      return await loop(k, acc$1);
+    } else {
+      return acc$1;
+    }
+  };
+  return await loop(undefined, 0);
+}
+
+async function countBucket(bucket) {
+  let loop = async (keyMarker, versionMarker, acc) => {
+    let out = await S3$AwsSdk.ListObjectVersionsCommand.send(new ClientS3.ListObjectVersionsCommand({
+      Bucket: bucket,
+      KeyMarker: keyMarker,
+      VersionIdMarker: versionMarker
+    }));
+    let n = Stdlib_Option.getOr(out.Versions, []).length + Stdlib_Option.getOr(out.DeleteMarkers, []).length | 0;
+    if (Stdlib_Option.getOr(out.IsTruncated, false)) {
+      return await loop(out.NextKeyMarker, out.NextVersionIdMarker, acc + n | 0);
+    } else {
+      return acc + n | 0;
+    }
+  };
+  return await loop(undefined, undefined, 0);
+}
+
+async function sendBatch(table, requests, attempt) {
+  if (requests.length === 0) {
+    return;
+  }
+  if (attempt > 8) {
+    throw {
+      RE_EXN_ID: Seed$ReventlessSeed.Failed,
+      _1: `table ` + table + `: ` + requests.length.toString() + ` item(s) still unprocessed after 8 retries.`,
+      Error: new Error()
+    };
+  }
+  let out = await DynamoDb_DocumentClient$AwsSdk.BatchWriteCommand.send(new LibDynamodb.BatchWriteCommand({
+    RequestItems: Object.fromEntries([[
+        table,
+        requests
+      ]])
+  }));
+  let unprocessed = Stdlib_Option.getOr(Stdlib_Option.flatMap(out.UnprocessedItems, d => d[table]), []);
+  if (unprocessed.length !== 0) {
+    return await sendBatch(table, unprocessed, attempt + 1 | 0);
+  }
+}
+
+async function truncateTable(table) {
+  let desc = await DynamoDb_DynamoDb$AwsSdk.DescribeTableCommand.send(new ClientDynamodb.DescribeTableCommand({
+    TableName: table
+  }));
+  let keyAttrs = Stdlib_Option.getOr(Stdlib_Option.flatMap(desc.Table, t => t.KeySchema), []).map(k => k.AttributeName);
+  if (keyAttrs.length === 0) {
+    throw {
+      RE_EXN_ID: Seed$ReventlessSeed.Failed,
+      _1: `could not read a key schema for table ` + table + `.`,
+      Error: new Error()
+    };
+  }
+  let names = keyAttrs.map((name, i) => [
+    `#k` + i.toString(),
+    name
+  ]);
+  let projection = names.map(param => param[0]).join(", ");
+  let loop = async start => {
+    let out = await DynamoDb_DocumentClient$AwsSdk.ScanCommand.send(new LibDynamodb.ScanCommand({
+      TableName: table,
+      ExclusiveStartKey: start,
+      ExpressionAttributeNames: Object.fromEntries(names),
+      ProjectionExpression: projection
+    }));
+    let requests = Stdlib_Option.getOr(out.Items, []).map(item => {
+      let key = Object.fromEntries(Stdlib_Array.filterMap(keyAttrs, attr => Stdlib_Option.map(field(item, attr), v => [
+        attr,
+        v
+      ])));
+      return {
+        DeleteRequest: {
+          Key: key
+        }
+      };
+    });
+    let batches = chunk(requests, DynamoDb_DocumentClient$AwsSdk.BatchWriteCommand.maxBatchSize);
+    for (let i = 0, i_finish = batches.length; i < i_finish; ++i) {
+      let b = batches[i];
+      if (b !== undefined) {
+        await sendBatch(table, b, 1);
+      }
+    }
+    let k = out.LastEvaluatedKey;
+    if (k !== undefined) {
+      return await loop(k);
+    }
+  };
+  return await loop(undefined);
+}
+
+async function emptyBucket(bucket) {
+  let loop = async (keyMarker, versionMarker) => {
+    let out = await S3$AwsSdk.ListObjectVersionsCommand.send(new ClientS3.ListObjectVersionsCommand({
+      Bucket: bucket,
+      KeyMarker: keyMarker,
+      VersionIdMarker: versionMarker
+    }));
+    let ids = Stdlib_Option.getOr(out.Versions, []).concat(Stdlib_Option.getOr(out.DeleteMarkers, [])).map(v => ({
+      Key: v.Key,
+      VersionId: v.VersionId
+    }));
+    if (ids.length !== 0) {
+      let res = await S3$AwsSdk.DeleteObjectsCommand.send(new ClientS3.DeleteObjectsCommand({
+        Bucket: bucket,
+        Delete: {
+          Objects: ids,
+          Quiet: true
+        }
+      }));
+      let errs = res.Errors;
+      if (errs !== undefined && errs.length !== 0) {
+        throw {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: `failed to delete ` + errs.length.toString() + ` object(s) from ` + bucket + `: ` + Stdlib_Option.getOr(Stdlib_Option.flatMap(errs[0], e => e.Message), "unknown"),
+          Error: new Error()
+        };
+      }
+    }
+    if (Stdlib_Option.getOr(out.IsTruncated, false)) {
+      return await loop(out.NextKeyMarker, out.NextVersionIdMarker);
+    }
+  };
+  return await loop(undefined, undefined);
+}
+
+async function chooseScope(targets) {
+  let domain = targets.filter(t => t.group === "Domain");
+  let platform = targets.filter(t => t.group === "Platform");
+  let labelsOf = ts => ts.map(t => t.label).join(", ");
+  let other = Stdlib_Option.map(Seed_Prompt$ReventlessSeed.envValue("SEED_RESET_SCOPE"), prim => prim.toLowerCase());
+  if (other !== undefined) {
+    switch (other) {
+      case "domain" :
+        return domain;
+      case "all" :
+      case "both" :
+      case "everything" :
+        return targets;
+      case "platform" :
+        return platform;
+      default:
+        let t = targets.find(t => t.label.toLowerCase() === other);
+        if (t !== undefined) {
+          return [t];
+        }
+        throw {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: `SEED_RESET_SCOPE="` + other + `" is not a scope — use domain, platform, everything, or a plugin label (` + labelsOf(domain) + `).`,
+          Error: new Error()
+        };
+    }
+  } else {
+    let options = [];
+    if (domain.length !== 0) {
+      options.push([
+        `domain — ` + labelsOf(domain),
+        domain
+      ]);
+      if (domain.length > 1) {
+        domain.forEach(t => {
+          options.push([
+            t.label,
+            [t]
+          ]);
+        });
+      }
+    }
+    if (platform.length !== 0) {
+      options.push([
+        `platform — ` + labelsOf(platform),
+        platform
+      ]);
+    }
+    if (domain.length !== 0 && platform.length !== 0) {
+      options.push([
+        `everything — ` + labelsOf(targets),
+        targets
+      ]);
+    }
+    return await Seed_Prompt$ReventlessSeed.select("Reset scope:", options, undefined);
+  }
+}
+
+function gateTarget(target, backend, stack) {
+  let c = readStackConfig(target.projectDir, backend, stack);
+  let cfg;
+  if (c.TAG === "Ok") {
+    cfg = c._0;
+  } else {
+    throw {
+      RE_EXN_ID: Seed$ReventlessSeed.Failed,
+      _1: c._0,
+      Error: new Error()
+    };
+  }
+  let match = Stdlib_Option.map(configValue(cfg, "reventless:wipeable"), v => v.trim().toLowerCase());
+  let exit = 0;
+  if (match !== "true") {
+    exit = 1;
+  }
+  if (exit === 1) {
+    throw {
+      RE_EXN_ID: Seed$ReventlessSeed.Failed,
+      _1: target.label + `: stack "` + stack + `" does not declare \`reventless:wipeable: "true"\` in its Pulumi.` + stack + `.yaml — refusing. Add that line only on disposable dev stacks (see the alpha example configs).`,
+      Error: new Error()
+    };
+  }
+  let r = Seed_Prompt$ReventlessSeed.envValue("AWS_REGION");
+  let exit$1 = 0;
+  if (r !== undefined) {
+    if (r !== "") {
+      return r;
+    }
+    exit$1 = 1;
+  } else {
+    exit$1 = 1;
+  }
+  if (exit$1 === 1) {
+    let r$1 = configValue(cfg, "aws:region");
+    let exit$2 = 0;
+    if (r$1 !== undefined) {
+      if (r$1 !== "") {
+        return r$1;
+      }
+      exit$2 = 2;
+    } else {
+      exit$2 = 2;
+    }
+    if (exit$2 === 2) {
+      throw {
+        RE_EXN_ID: Seed$ReventlessSeed.Failed,
+        _1: target.label + `: could not resolve the AWS region — set AWS_REGION or \`aws:region\` in the stack config.`,
+        Error: new Error()
+      };
+    }
+  }
+}
+
+function reportAll(resolvedList, stack, region) {
+  Seed_Runner$ReventlessSeed.heading(`Reset target: stack "` + stack + `" in ` + region);
+  let total = {
+    contents: 0
+  };
+  resolvedList.forEach(r => {
+    console.log("");
+    console.log(`  ` + r.target.label + `  (` + r.platform + `)`);
+    console.log("    DynamoDB tables:");
+    r.tables.forEach((t, i) => {
+      let c = Stdlib_Option.getOr(r.tableCounts[i], 0);
+      total.contents = total.contents + c | 0;
+      console.log(`      ` + c.toString().padStart(8, " ") + `  ` + t);
+    });
+    if (r.tables.length === 0) {
+      console.log("      (none)");
+    }
+    console.log("    S3 buckets:");
+    r.bucketCounts.forEach(param => {
+      let c = param[1];
+      total.contents = total.contents + c | 0;
+      console.log(`      ` + c.toString().padStart(8, " ") + `  ` + param[0]);
+    });
+    if (r.bucketCounts.length === 0) {
+      console.log("      (none)");
+      return;
+    }
+  });
+  return total.contents;
+}
+
+function run(stack, backend, targets, param) {
+  let go = async () => {
+    try {
+      if (targets.length === 0) {
+        throw {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: "no targets were declared — nothing to reset.",
+          Error: new Error()
+        };
+      }
+      let url = Seed_Prompt$ReventlessSeed.envValue("SEED_PULUMI_BACKEND");
+      let backend$1 = url !== undefined ? url : backend;
+      let baseTarget = Stdlib_Option.getOr(targets.find(t => t.group === "Platform"), targets[0]);
+      let stack$1 = await ReventlessSeedAws.resolveStack(baseTarget.projectDir, backend$1, stack);
+      if (!nameAllowlist.test(stack$1)) {
+        throw {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: `stack "` + stack$1 + `" is not on the wipe name-allowlist (alpha, dev, pr-*) — refusing.`,
+          Error: new Error()
+        };
+      }
+      let selected = await chooseScope(targets);
+      let regions = selected.map(t => gateTarget(t, backend$1, stack$1));
+      let region = regions[0];
+      if (regions.some(r => r !== region)) {
+        throw {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: `selected targets span more than one region (` + regions.join(", ") + `) — reset them one region at a time.`,
+          Error: new Error()
+        };
+      }
+      process.env["AWS_REGION"] = region;
+      let resolvedList = [];
+      for (let i = 0, i_finish = selected.length; i < i_finish; ++i) {
+        let target = selected[i];
+        if (target !== undefined) {
+          let platform = projectName(target.projectDir);
+          let match = await discover(region, stack$1, platform);
+          let tables = match[0].toSorted(Primitive_string.compare);
+          let buckets = match[1].toSorted(Primitive_string.compare);
+          let tableCounts = [];
+          for (let j = 0, j_finish = tables.length; j < j_finish; ++j) {
+            let t = tables[j];
+            if (t !== undefined) {
+              tableCounts.push(await countTable(t));
+            }
+          }
+          let bucketCounts = [];
+          for (let j$1 = 0, j_finish$1 = buckets.length; j$1 < j_finish$1; ++j$1) {
+            let b = buckets[j$1];
+            if (b !== undefined) {
+              bucketCounts.push([
+                b,
+                await countBucket(b)
+              ]);
+            }
+          }
+          resolvedList.push({
+            target: target,
+            platform: platform,
+            tables: tables,
+            tableCounts: tableCounts,
+            bucketCounts: bucketCounts
+          });
+        }
+      }
+      let total = reportAll(resolvedList, stack$1, region);
+      if (total === 0) {
+        Seed_Prompt$ReventlessSeed.close();
+        console.log("");
+        console.log(`Nothing to reset — the selected scope already reads empty in ` + region + `.`);
+        process.exit(0);
+      }
+      let interactive = Stdlib_Option.getOr(process.stdin.isTTY, false);
+      let confirmed;
+      if (interactive) {
+        let typed = await Seed_Prompt$ReventlessSeed.ask(`About to permanently empty ` + total.toString() + ` item(s)/object(s) across the selected scope of "` + stack$1 + `". Type the stack name to confirm, or press Enter to keep this a dry run: `);
+        confirmed = typed.trim() === stack$1;
+      } else {
+        confirmed = Primitive_object.equal(Seed_Prompt$ReventlessSeed.envValue("REVENTLESS_WIPE_CONFIRM"), stack$1);
+      }
+      Seed_Prompt$ReventlessSeed.close();
+      if (!confirmed) {
+        console.log("");
+        console.log(interactive ? "Dry run — nothing was deleted." : `Dry run — nothing was deleted. Set REVENTLESS_WIPE_CONFIRM=` + stack$1 + ` to empty this scope non-interactively.`);
+        process.exit(0);
+      }
+      for (let i$1 = 0, i_finish$1 = resolvedList.length; i$1 < i_finish$1; ++i$1) {
+        let r = resolvedList[i$1];
+        if (r !== undefined) {
+          Seed_Runner$ReventlessSeed.heading(`Emptying ` + r.target.label + ` …`);
+          for (let j$2 = 0, j_finish$2 = r.tables.length; j$2 < j_finish$2; ++j$2) {
+            let t$1 = r.tables[j$2];
+            if (t$1 !== undefined) {
+              await truncateTable(t$1);
+              console.log(`  truncated ` + t$1);
+            }
+          }
+          for (let j$3 = 0, j_finish$3 = r.bucketCounts.length; j$3 < j_finish$3; ++j$3) {
+            let match$1 = r.bucketCounts[j$3];
+            if (match$1 !== undefined) {
+              let b$1 = match$1[0];
+              await emptyBucket(b$1);
+              console.log(`  emptied ` + b$1);
+            }
+          }
+        }
+      }
+      let remaining = 0;
+      for (let i$2 = 0, i_finish$2 = resolvedList.length; i$2 < i_finish$2; ++i$2) {
+        let r$1 = resolvedList[i$2];
+        if (r$1 !== undefined) {
+          for (let j$4 = 0, j_finish$4 = r$1.tables.length; j$4 < j_finish$4; ++j$4) {
+            let t$2 = r$1.tables[j$4];
+            if (t$2 !== undefined) {
+              remaining = remaining + await countTable(t$2) | 0;
+            }
+          }
+          for (let j$5 = 0, j_finish$5 = r$1.bucketCounts.length; j$5 < j_finish$5; ++j$5) {
+            let match$2 = r$1.bucketCounts[j$5];
+            if (match$2 !== undefined) {
+              remaining = remaining + await countBucket(match$2[0]) | 0;
+            }
+          }
+        }
+      }
+      if (remaining !== 0) {
+        throw {
+          RE_EXN_ID: Seed$ReventlessSeed.Failed,
+          _1: remaining.toString() + ` item(s)/object(s) remain after the wipe — re-run to finish.`,
+          Error: new Error()
+        };
+      }
+      console.log("");
+      console.log(`Reset complete — the selected scope of "` + stack$1 + `" reads empty and is re-seedable.`);
+      process.exit(0);
+      return;
+    } catch (raw_message) {
+      let message = Primitive_exceptions.internalToException(raw_message);
+      if (message.RE_EXN_ID === Seed$ReventlessSeed.Failed) {
+        Seed_Prompt$ReventlessSeed.close();
+        console.error("");
+        console.error(`Reset aborted — ` + message._1);
+        process.exit(1);
+      } else {
+        Seed_Prompt$ReventlessSeed.close();
+        console.error("");
+        console.error("Reset aborted with an unexpected error:");
+        console.error(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(message), Stdlib_JsExn.message), "unknown"));
+        process.exit(1);
+      }
+      return;
+    }
+  };
+  go();
+}
+
+let Ddb;
+
+let Rgt;
+
+let S3;
+
+export {
+  Ddb,
+  Rgt,
+  S3,
+  projectName,
+  field,
+  asString,
+  chunk,
+  nameAllowlist,
+  readStackConfig,
+  configValue,
+  classify,
+  tagValue,
+  discover,
+  countTable,
+  countBucket,
+  sendBatch,
+  truncateTable,
+  emptyBucket,
+  chooseScope,
+  gateTarget,
+  reportAll,
+  run,
+}
+/* node:fs Not a pure module */

package/lib/ocaml/.compiler.log

@@ -1,2 +1,2 @@
-#Start(1785139469141)
-#Done(1785139473591)
+#Start(1785181007711)
+#Done(1785181012329)