@reventlessdev/reventless-seed-aws 1.0.0-alpha.2 → 1.0.0-alpha.21

package/tests/ObjectStoreResetTest.res.mjs

@@ -0,0 +1,211 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as JestGlobals from "@reventlessdev/rescript-jest/src/JestGlobals.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as ReventlessSeedAws_Reset from "../src/ReventlessSeedAws_Reset.res.mjs";
+
+function obj(entries) {
+  return Object.fromEntries(entries);
+}
+
+function str(prim) {
+  return prim;
+}
+
+function storeEntry(bucket, prefix) {
+  return Object.fromEntries([
+    [
+      "bucketName",
+      bucket
+    ],
+    [
+      "keyPrefix",
+      prefix
+    ]
+  ]);
+}
+
+function output(entries) {
+  return Object.fromEntries(entries);
+}
+
+function store(qualified, bucket, prefix) {
+  let match = Stdlib_Option.getOr(ReventlessSeedAws_Reset.splitQualified(qualified), [
+    "",
+    qualified
+  ]);
+  return {
+    qualified: qualified,
+    plugin: match[0],
+    store: match[1],
+    bucketName: bucket,
+    keyPrefix: prefix
+  };
+}
+
+globalThis.describe("parseObjectStores", () => {
+  globalThis.test("splits the qualified key into plugin and store", () => {
+    let entries = [[
+        "Catalog.productImages",
+        storeEntry("alpha-stores", "productImages")
+      ]];
+    let other = ReventlessSeedAws_Reset.parseObjectStores(Object.fromEntries(entries));
+    if (other.TAG === "Ok") {
+      let match = other._0;
+      if (match.length === 1) {
+        let s = match[0];
+        globalThis.expect([
+          s.plugin,
+          s.store,
+          s.bucketName,
+          s.keyPrefix
+        ]).toEqual([
+          "Catalog",
+          "productImages",
+          "alpha-stores",
+          "productImages"
+        ]);
+        return;
+      }
+    }
+    JestGlobals.fail(`expected one parsed store, got ` + Stdlib_Option.getOr(JSON.stringify(other), "?"));
+  });
+  globalThis.test("splits at the first dot only", () => {
+    let match = ReventlessSeedAws_Reset.splitQualified("Catalog.product.images");
+    if (match !== undefined) {
+      globalThis.expect([
+        match[0],
+        match[1]
+      ]).toEqual([
+        "Catalog",
+        "product.images"
+      ]);
+      return;
+    } else {
+      return JestGlobals.fail("expected a split");
+    }
+  });
+  globalThis.test("absent output yields no stores", () => {
+    let stores = ReventlessSeedAws_Reset.parseObjectStores(undefined);
+    if (stores.TAG !== "Ok") {
+      return JestGlobals.fail(stores._0);
+    }
+    globalThis.expect(stores._0.length).toBe(0);
+  });
+  globalThis.test("a malformed entry is an error, not a skip", () => {
+    let entries = [[
+        "Catalog.productImages",
+        Object.fromEntries([[
+            "keyPrefix",
+            "x"
+          ]])
+      ]];
+    let message = ReventlessSeedAws_Reset.parseObjectStores(Object.fromEntries(entries));
+    if (message.TAG === "Ok") {
+      return JestGlobals.fail("expected a malformed entry to be refused");
+    }
+    globalThis.expect(message._0.includes("Catalog.productImages")).toBe(true);
+  });
+  globalThis.test("an unqualified key is an error", () => {
+    let entries = [[
+        "productImages",
+        storeEntry("alpha-stores", "productImages")
+      ]];
+    let message = ReventlessSeedAws_Reset.parseObjectStores(Object.fromEntries(entries));
+    if (message.TAG === "Ok") {
+      return JestGlobals.fail("expected an unqualified key to be refused");
+    }
+    globalThis.expect(message._0.includes("productImages")).toBe(true);
+  });
+});
+
+globalThis.describe("validateStores", () => {
+  globalThis.test("distinct prefixes in one bucket are fine", () => {
+    globalThis.expect(ReventlessSeedAws_Reset.validateStores([
+      store("Catalog.productImages", "alpha-stores", "productImages"),
+      store("Ordering.labels", "alpha-stores", "labels")
+    ])).toEqual({
+      TAG: "Ok",
+      _0: undefined
+    });
+  });
+  globalThis.test("two plugins on one prefix are refused", () => {
+    let message = ReventlessSeedAws_Reset.validateStores([
+      store("Catalog.productImages", "alpha-stores", "productImages"),
+      store("Ordering.productImages", "alpha-stores", "productImages")
+    ]);
+    if (message.TAG === "Ok") {
+      return JestGlobals.fail("expected a collision to be refused");
+    }
+    let message$1 = message._0;
+    globalThis.expect(message$1.includes("Catalog.productImages") && message$1.includes("Ordering.productImages")).toBe(true);
+  });
+  globalThis.test("an enclosing prefix is refused", () => {
+    let message = ReventlessSeedAws_Reset.validateStores([
+      store("Legacy.catalog", "alpha-stores", "Catalog"),
+      store("Catalog.productImages", "alpha-stores", "Catalog/productImages")
+    ]);
+    if (message.TAG === "Ok") {
+      return JestGlobals.fail("expected an enclosing prefix to be refused");
+    }
+    globalThis.expect(message._0.includes("encloses")).toBe(true);
+  });
+  globalThis.test("one prefix in two different buckets is fine", () => {
+    globalThis.expect(ReventlessSeedAws_Reset.validateStores([
+      store("Catalog.productImages", "catalog-productImages", "productImages"),
+      store("Ordering.productImages", "ordering-productImages", "productImages")
+    ])).toEqual({
+      TAG: "Ok",
+      _0: undefined
+    });
+  });
+  globalThis.test("a sibling prefix sharing a character run is fine", () => {
+    globalThis.expect(ReventlessSeedAws_Reset.validateStores([
+      store("Catalog.images", "alpha-stores", "images"),
+      store("Catalog.imagesArchive", "alpha-stores", "images-archive")
+    ])).toEqual({
+      TAG: "Ok",
+      _0: undefined
+    });
+  });
+  globalThis.test("an empty or slash-bearing store name is refused", () => {
+    let match = ReventlessSeedAws_Reset.validateStores([store("Catalog.productImages", "alpha-stores", "")]);
+    if (match.TAG === "Ok") {
+      JestGlobals.fail("expected an empty prefix to be refused");
+    }
+    let match$1 = ReventlessSeedAws_Reset.validateStores([store("Catalog.a/b", "alpha-stores", "a/b")]);
+    if (match$1.TAG === "Ok") {
+      return JestGlobals.fail("expected a store name containing a slash to be refused");
+    }
+  });
+});
+
+globalThis.describe("pluginOf", () => {
+  globalThis.test("prefers the declared plugin name over the label", () => {
+    globalThis.expect(ReventlessSeedAws_Reset.pluginOf({
+      projectDir: "../catalog-aws",
+      label: "catalog",
+      group: "Domain",
+      plugin: "Catalog"
+    })).toBe("Catalog");
+  });
+  globalThis.test("falls back to the label when no plugin name is declared", () => {
+    globalThis.expect(ReventlessSeedAws_Reset.pluginOf({
+      projectDir: ".",
+      label: "platform",
+      group: "Platform"
+    })).toBe("platform");
+  });
+});
+
+let Reset;
+
+export {
+  Reset,
+  obj,
+  str,
+  storeEntry,
+  output,
+  store,
+}
+/*  Not a pure module */

package/tests/QuiesceResetTest.res

@@ -0,0 +1,133 @@
+// Holding a stack's runtimes still for the length of a wipe: what gets held, and
+// what the reset says when a store comes back anyway.
+//
+// A truncate is not durable while the runtimes that own the data are running — a
+// slice runtime keeps its TODO list in memory for the life of its execution
+// environment and re-saves every row it holds at the end of each invocation,
+// including the scheduled sweep that carries no events. So the reset now
+// discovers the stack's Lambda functions alongside its stores and holds them at
+// zero concurrency across the wipe.
+//
+// The pure half of that is what these pin: which ARNs resolve to a function to
+// hold, the bounded fan-out the control-plane calls go through, and the failure
+// message — which used to say "re-run to finish" for a condition re-running
+// could not clear. The impure half is the Lambda control-plane calls themselves.
+
+open JestGlobals
+
+module Reset = ReventlessSeedAws_Reset
+module Quiesce = ReventlessSeedAws_Quiesce
+
+describe("classify", () => {
+  testSync("reads the function name out of a Lambda ARN", () =>
+    expect(Reset.classify("arn:aws:lambda:eu-west-1:123456789012:function:AllAutomationSlices-28b116c"))
+    ->toEqual(Reset.Function("AllAutomationSlices-28b116c"))
+  )
+
+  // The tagging API returns unqualified ARNs, but a qualified one must still
+  // yield the function name — every Lambda control-plane call the hold makes
+  // takes a name, and "Name:1" is not one.
+  testSync("drops a version or alias qualifier", () =>
+    expect(Reset.classify("arn:aws:lambda:eu-west-1:123456789012:function:AllReadModels-0287438:42"))
+    ->toEqual(Reset.Function("AllReadModels-0287438"))
+  )
+
+  testSync("still classifies tables and buckets", () => {
+    expect(Reset.classify("arn:aws:dynamodb:eu-west-1:123456789012:table/Products-0ba6849"))
+    ->toEqual(Reset.Table("Products-0ba6849"))
+    expect(Reset.classify("arn:aws:s3:::alpha-product-images"))->toEqual(
+      Reset.Bucket("alpha-product-images"),
+    )
+  })
+
+  testSync("ignores anything else the tag scope returns", () =>
+    expect(Reset.classify("arn:aws:sqs:eu-west-1:123456789012:OrderingDcbCmdTopic-4b3658c"))
+    ->toEqual(Reset.Other)
+  )
+})
+
+describe("mapBounded", () => {
+  // Results must line up with their inputs regardless of which worker finished
+  // first: the hold pairs each result with the function it came from, and a
+  // shuffled array would restore the wrong concurrency to the wrong function.
+  test("keeps results in input order under out-of-order completion", async () => {
+    let delays = [40, 0, 30, 10, 20, 5]
+    let out = await delays->Quiesce.mapBounded(~limit=3, async ms => {
+      await ReventlessSeed.Seed.Client.sleep(ms)
+      ms
+    })
+    expect(out)->toEqual(delays)
+  })
+
+  test("never runs more than the limit at once", async () => {
+    let inFlight = ref(0)
+    let peak = ref(0)
+    let _ = await Array.make(~length=12, 0)->Quiesce.mapBounded(~limit=4, async _ => {
+      inFlight := inFlight.contents + 1
+      peak := Math.Int.max(peak.contents, inFlight.contents)
+      await ReventlessSeed.Seed.Client.sleep(5)
+      inFlight := inFlight.contents - 1
+    })
+    expect(peak.contents)->toBe(4)
+  })
+
+  test("an empty list spawns no workers and returns nothing", async () => {
+    let out = await []->Quiesce.mapBounded(~limit=4, async x => x)
+    expect(out->Array.length)->toBe(0)
+  })
+})
+
+describe("refillMessage", () => {
+  // The whole point of the change: the operator has to be able to see WHICH
+  // store came back, not just a total.
+  testSync("names every store that came back, with its count", () => {
+    let message = Reset.refillMessage(
+      ~refilled=[("AutoShipOrderTodo-61f39a2", 12), ("GeocodeCustomerAddressTodo-50d9488", 1)],
+      ~heldCount=41,
+    )
+    expect(message->String.includes("AutoShipOrderTodo-61f39a2"))->toBe(true)
+    expect(message->String.includes("GeocodeCustomerAddressTodo-50d9488"))->toBe(true)
+    expect(message->String.startsWith("13 item(s)/object(s) came back"))->toBe(true)
+  })
+
+  // Under a hold nothing could START during the wipe, so the only writer left is
+  // an invocation already running when the hold landed — and that one really
+  // does go away. This is the only case where "re-run" is honest advice.
+  testSync("advises re-running only when the runtimes were held", () => {
+    let message = Reset.refillMessage(~refilled=[("AutoShipOrderTodo-61f39a2", 12)], ~heldCount=41)
+    expect(message->String.includes("already in flight"))->toBe(true)
+    expect(message->String.includes("Re-running clears it"))->toBe(true)
+  })
+
+  // Without a hold, the writer holds the rows in memory and restores them every
+  // invocation — the exact condition the old "re-run to finish" sent operators
+  // round in circles on. It must not appear here.
+  testSync("refuses to advise re-running when the stack was not held", () => {
+    let message = Reset.refillMessage(~refilled=[("AutoShipOrderTodo-61f39a2", 12)], ~heldCount=0)
+    expect(message->String.includes("re-running will not help"->String.toLowerCase))->toBe(true)
+    expect(message->String.includes("SEED_RESET_NO_QUIESCE"))->toBe(true)
+  })
+})
+
+describe("noQuiesce", () => {
+  let set = v => NodeProcess.env->Dict.set("SEED_RESET_NO_QUIESCE", v)
+
+  // Fail-closed: the hold is what makes the wipe durable, so anything other than
+  // a deliberate opt-out keeps it on.
+  testSync("defaults to holding the platform", () => {
+    set("")
+    expect(Reset.noQuiesce())->toBe(false)
+    set("0")
+    expect(Reset.noQuiesce())->toBe(false)
+    set("no")
+    expect(Reset.noQuiesce())->toBe(false)
+  })
+
+  testSync("accepts the spellings an operator would actually type", () => {
+    ["1", "true", "TRUE", " yes "]->Array.forEach(v => {
+      set(v)
+      expect(Reset.noQuiesce())->toBe(true)
+    })
+    set("")
+  })
+})

package/tests/QuiesceResetTest.res.mjs

@@ -0,0 +1,141 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as ReventlessSeedAws_Reset from "../src/ReventlessSeedAws_Reset.res.mjs";
+import * as ReventlessSeedAws_Quiesce from "../src/ReventlessSeedAws_Quiesce.res.mjs";
+import * as Seed_Client$ReventlessSeed from "@reventlessdev/reventless-seed/src/Seed_Client.res.mjs";
+
+globalThis.describe("classify", () => {
+  globalThis.test("reads the function name out of a Lambda ARN", () => {
+    globalThis.expect(ReventlessSeedAws_Reset.classify("arn:aws:lambda:eu-west-1:123456789012:function:AllAutomationSlices-28b116c")).toEqual({
+      TAG: "Function",
+      _0: "AllAutomationSlices-28b116c"
+    });
+  });
+  globalThis.test("drops a version or alias qualifier", () => {
+    globalThis.expect(ReventlessSeedAws_Reset.classify("arn:aws:lambda:eu-west-1:123456789012:function:AllReadModels-0287438:42")).toEqual({
+      TAG: "Function",
+      _0: "AllReadModels-0287438"
+    });
+  });
+  globalThis.test("still classifies tables and buckets", () => {
+    globalThis.expect(ReventlessSeedAws_Reset.classify("arn:aws:dynamodb:eu-west-1:123456789012:table/Products-0ba6849")).toEqual({
+      TAG: "Table",
+      _0: "Products-0ba6849"
+    });
+    globalThis.expect(ReventlessSeedAws_Reset.classify("arn:aws:s3:::alpha-product-images")).toEqual({
+      TAG: "Bucket",
+      _0: "alpha-product-images"
+    });
+  });
+  globalThis.test("ignores anything else the tag scope returns", () => {
+    globalThis.expect(ReventlessSeedAws_Reset.classify("arn:aws:sqs:eu-west-1:123456789012:OrderingDcbCmdTopic-4b3658c")).toEqual("Other");
+  });
+});
+
+globalThis.describe("mapBounded", () => {
+  globalThis.test("keeps results in input order under out-of-order completion", async () => {
+    let delays = [
+      40,
+      0,
+      30,
+      10,
+      20,
+      5
+    ];
+    let out = await ReventlessSeedAws_Quiesce.mapBounded(delays, 3, async ms => {
+      await Seed_Client$ReventlessSeed.sleep(ms);
+      return ms;
+    });
+    globalThis.expect(out).toEqual(delays);
+  });
+  globalThis.test("never runs more than the limit at once", async () => {
+    let inFlight = {
+      contents: 0
+    };
+    let peak = {
+      contents: 0
+    };
+    await ReventlessSeedAws_Quiesce.mapBounded(Stdlib_Array.make(12, 0), 4, async param => {
+      inFlight.contents = inFlight.contents + 1 | 0;
+      peak.contents = Math.max(peak.contents, inFlight.contents);
+      await Seed_Client$ReventlessSeed.sleep(5);
+      inFlight.contents = inFlight.contents - 1 | 0;
+    });
+    globalThis.expect(peak.contents).toBe(4);
+  });
+  globalThis.test("an empty list spawns no workers and returns nothing", async () => {
+    let out = await ReventlessSeedAws_Quiesce.mapBounded([], 4, async x => x);
+    globalThis.expect(out.length).toBe(0);
+  });
+});
+
+globalThis.describe("refillMessage", () => {
+  globalThis.test("names every store that came back, with its count", () => {
+    let message = ReventlessSeedAws_Reset.refillMessage([
+      [
+        "AutoShipOrderTodo-61f39a2",
+        12
+      ],
+      [
+        "GeocodeCustomerAddressTodo-50d9488",
+        1
+      ]
+    ], 41);
+    globalThis.expect(message.includes("AutoShipOrderTodo-61f39a2")).toBe(true);
+    globalThis.expect(message.includes("GeocodeCustomerAddressTodo-50d9488")).toBe(true);
+    globalThis.expect(message.startsWith("13 item(s)/object(s) came back")).toBe(true);
+  });
+  globalThis.test("advises re-running only when the runtimes were held", () => {
+    let message = ReventlessSeedAws_Reset.refillMessage([[
+        "AutoShipOrderTodo-61f39a2",
+        12
+      ]], 41);
+    globalThis.expect(message.includes("already in flight")).toBe(true);
+    globalThis.expect(message.includes("Re-running clears it")).toBe(true);
+  });
+  globalThis.test("refuses to advise re-running when the stack was not held", () => {
+    let message = ReventlessSeedAws_Reset.refillMessage([[
+        "AutoShipOrderTodo-61f39a2",
+        12
+      ]], 0);
+    globalThis.expect(message.includes("re-running will not help".toLowerCase())).toBe(true);
+    globalThis.expect(message.includes("SEED_RESET_NO_QUIESCE")).toBe(true);
+  });
+});
+
+globalThis.describe("noQuiesce", () => {
+  let set = v => {
+    process.env["SEED_RESET_NO_QUIESCE"] = v;
+  };
+  globalThis.test("defaults to holding the platform", () => {
+    set("");
+    globalThis.expect(ReventlessSeedAws_Reset.noQuiesce()).toBe(false);
+    set("0");
+    globalThis.expect(ReventlessSeedAws_Reset.noQuiesce()).toBe(false);
+    set("no");
+    globalThis.expect(ReventlessSeedAws_Reset.noQuiesce()).toBe(false);
+  });
+  globalThis.test("accepts the spellings an operator would actually type", () => {
+    [
+      "1",
+      "true",
+      "TRUE",
+      " yes "
+    ].forEach(v => {
+      set(v);
+      globalThis.expect(ReventlessSeedAws_Reset.noQuiesce()).toBe(true);
+    });
+    set("");
+  });
+});
+
+let Reset;
+
+let Quiesce;
+
+export {
+  Reset,
+  Quiesce,
+}
+/*  Not a pure module */