@reventlessdev/reventless-aws 3.0.0-alpha.343 → 3.0.0-alpha.345

package/tests/AutomationSliceEntryPoint_OpsTest.res

@@ -21,30 +21,31 @@ describe("AutomationSliceEntryPoint_Ops.parseHandlerConfig", () => {
   })
 
   testSync("decodes a full entry incl. bodyModule and context", () => {
-    let config = obj([
-      (
-        "handlers",
-        JSON.Encode.array([
-          obj([
-            ("specModule", str("@x/plugin/src/Order/AutomationSlice/Restock.res.mjs")),
-            ("bodyModule", str("@x/plugin/src/Order/AutomationSlice/Restock_Automation.res.mjs")),
-            ("callbackType", str("automation")),
-            ("queryDbTableName", str("RestockTodo-abc")),
-            ("dcbQueueUrl", str("https://sqs/queue.fifo")),
-            ("sourceUrn", str("arn:aws:dynamodb:eu-west-1:1:table/log/stream/x")),
-            (
-              "context",
-              obj([
-                ("environment", str("alpha")),
-                ("platformName", str("OnlineShop")),
-                ("pluginName", str("Ordering")),
-                ("sliceName", str("Restock")),
-              ]),
-            ),
+    let config =
+      obj([
+        (
+          "handlers",
+          JSON.Encode.array([
+            obj([
+              ("specModule", str("@x/plugin/src/Order/AutomationSlice/Restock.res.mjs")),
+              ("bodyModule", str("@x/plugin/src/Order/AutomationSlice/Restock_Automation.res.mjs")),
+              ("callbackType", str("automation")),
+              ("queryDbTableName", str("RestockTodo-abc")),
+              ("dcbQueueUrl", str("https://sqs/queue.fifo")),
+              ("sourceUrn", str("arn:aws:dynamodb:eu-west-1:1:table/log/stream/x")),
+              (
+                "context",
+                obj([
+                  ("environment", str("alpha")),
+                  ("platformName", str("OnlineShop")),
+                  ("pluginName", str("Ordering")),
+                  ("sliceName", str("Restock")),
+                ]),
+              ),
+            ]),
           ]),
-        ]),
-      ),
-    ])->JSON.stringify
+        ),
+      ])->JSON.stringify
     let entries = AutomationSliceEntryPoint_Ops.parseHandlerConfig(config)
     expect(entries->Array.length)->toBe(1)
     let e = entries->Array.getUnsafe(0)
@@ -63,20 +64,21 @@ describe("AutomationSliceEntryPoint_Ops.parseHandlerConfig", () => {
   })
 
   testSync("a stale entry without bodyModule/context decodes with defaults", () => {
-    let config = obj([
-      (
-        "handlers",
-        JSON.Encode.array([
-          obj([
-            ("specModule", str("a.res.mjs")),
-            ("callbackType", str("outbound")),
-            ("queryDbTableName", str("t")),
-            ("dcbQueueUrl", str("u")),
-            ("sourceUrn", str("arn")),
+    let config =
+      obj([
+        (
+          "handlers",
+          JSON.Encode.array([
+            obj([
+              ("specModule", str("a.res.mjs")),
+              ("callbackType", str("outbound")),
+              ("queryDbTableName", str("t")),
+              ("dcbQueueUrl", str("u")),
+              ("sourceUrn", str("arn")),
+            ]),
           ]),
-        ]),
-      ),
-    ])->JSON.stringify
+        ),
+      ])->JSON.stringify
     let e = AutomationSliceEntryPoint_Ops.parseHandlerConfig(config)->Array.getUnsafe(0)
     expect(e.bodyModule)->toBe("")
     expect(e.context->Option.isNone)->toBe(true)
@@ -111,7 +113,10 @@ describe("AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules", () => {
         "Ship",
         obj([
           ("specModule", str("@x/plugin/src/Order/OutboundTranslationSlice/Ship.res.mjs")),
-          ("bodyModule", str("@x/plugin/src/Order/OutboundTranslationSlice/Ship_Translation.res.mjs")),
+          (
+            "bodyModule",
+            str("@x/plugin/src/Order/OutboundTranslationSlice/Ship_Translation.res.mjs"),
+          ),
           ("callbackType", str("outbound")),
         ]),
       ),
@@ -128,10 +133,9 @@ describe("AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules", () => {
   testSync("a compact entry takes its modules from the registry and the shared defaults", () => {
     let config = compactConfig([obj([("n", str("Restock")), ("q", str("RestockTodo-abc"))])])
     let e =
-      AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules(
-        modules,
-        config,
-      )->Array.getUnsafe(0)
+      AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules(modules, config)->Array.getUnsafe(
+        0,
+      )
     expect(e.specModule)->toBe("@x/plugin/src/Order/AutomationSlice/Restock.res.mjs")
     expect(e.bodyModule)->toBe("@x/plugin/src/Order/AutomationSlice/Restock_Automation.res.mjs")
     expect(e.callbackType)->toBe("automation")
@@ -156,10 +160,9 @@ describe("AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules", () => {
       ]),
     ])
     let e =
-      AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules(
-        modules,
-        config,
-      )->Array.getUnsafe(0)
+      AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules(modules, config)->Array.getUnsafe(
+        0,
+      )
     expect(e.callbackType)->toBe("outbound")
     expect(e.dcbQueueUrl)->toBe("https://sqs/orders.fifo")
     expect(e.commandQueueIsFifo)->toEqual(Some(true))
@@ -171,35 +174,34 @@ describe("AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules", () => {
   testSync("a compact entry with no registry match yields no bodyModule to skip on", () => {
     let config = compactConfig([obj([("n", str("Gone")), ("q", str("GoneTodo-abc"))])])
     let e =
-      AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules(
-        modules,
-        config,
-      )->Array.getUnsafe(0)
+      AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules(modules, config)->Array.getUnsafe(
+        0,
+      )
     expect(e.specModule)->toBe("")
     expect(e.bodyModule)->toBe("")
   })
 
   testSync("full-key entries still decode when a registry is present", () => {
-    let config = obj([
-      (
-        "handlers",
-        JSON.Encode.array([
-          obj([
-            ("specModule", str("a.res.mjs")),
-            ("bodyModule", str("b.res.mjs")),
-            ("callbackType", str("outbound")),
-            ("queryDbTableName", str("t")),
-            ("dcbQueueUrl", str("u")),
-            ("sourceUrn", str("arn")),
+    let config =
+      obj([
+        (
+          "handlers",
+          JSON.Encode.array([
+            obj([
+              ("specModule", str("a.res.mjs")),
+              ("bodyModule", str("b.res.mjs")),
+              ("callbackType", str("outbound")),
+              ("queryDbTableName", str("t")),
+              ("dcbQueueUrl", str("u")),
+              ("sourceUrn", str("arn")),
+            ]),
           ]),
-        ]),
-      ),
-    ])->JSON.stringify
+        ),
+      ])->JSON.stringify
     let e =
-      AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules(
-        modules,
-        config,
-      )->Array.getUnsafe(0)
+      AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules(modules, config)->Array.getUnsafe(
+        0,
+      )
     expect(e.specModule)->toBe("a.res.mjs")
     expect(e.dcbQueueUrl)->toBe("u")
   })

package/tests/BakeConvergenceTest.res

@@ -17,9 +17,10 @@ open JestGlobals
 
 // Mirrors the deploy-time hook in aws/src/Platform.res: content-addressed key, and
 // the key the stack exports as `pluginStructureRef` is the one the hook returned.
-let deployStructure = (
-  structure: Reventless.Plugin.pluginStructure,
-): (string, Reventless.Offload.payload<Reventless.Plugin.pluginStructure>) => {
+let deployStructure = (structure: Reventless.Plugin.pluginStructure): (
+  string,
+  Reventless.Offload.payload<Reventless.Plugin.pluginStructure>,
+) => {
   let exported = ref("")
   ReventlessCore.Plugin_Helpers.registerOffload((~store, ~bytes) => {
     let hash = NodeCrypto.sha256Hex(bytes)
@@ -125,9 +126,7 @@ describe("the bake converges when a plugin's structure changes", () => {
 
   // If this ever stops holding, the two keys can never converge and every retry is
   // spent waiting for something that cannot happen.
-  testSync("a changed structure hashes to a different key", () =>
-    expect(keyA == keyB)->toBe(false)
-  )
+  testSync("a changed structure hashes to a different key", () => expect(keyA == keyB)->toBe(false))
 
   // The invariant convergence rests on: the structure the deploy hashes and the
   // structure the plugin's registration carries are the same bytes, because they
@@ -135,9 +134,7 @@ describe("the bake converges when a plugin's structure changes", () => {
   // deploy's reference and hands it back.
   testSync("the key the deploy exported is the key the registration carries", () =>
     expect(
-      Platform_ComponentDefinitions_Lambda_Ops.structureRefKey(
-        row(shipped(defB), ~at=afterDeploy),
-      ),
+      Platform_ComponentDefinitions_Lambda_Ops.structureRefKey(row(shipped(defB), ~at=afterDeploy)),
     )->toEqual(Some(keyB))
   )
 
@@ -155,18 +152,18 @@ describe("the bake converges when a plugin's structure changes", () => {
   // definition must re-emit VersionConnected. `decide` is idempotent on an
   // unchanged one, so this is the step a broken chain silently skips.
   testSync("a redeploy with a changed structure re-emits VersionConnected", () => {
-    let connected = ReventlessCore.PluginBehavior.initialState->apply(connect(
-      ReventlessCore.PluginBehavior.initialState,
-      shipped(defA),
-    ))
+    let connected =
+      ReventlessCore.PluginBehavior.initialState->apply(
+        connect(ReventlessCore.PluginBehavior.initialState, shipped(defA)),
+      )
     expect(connect(connected, shipped(defB))->Array.length)->toBe(1)
   })
 
   testSync("once it lands, the plugin reads as registered by this deploy", () => {
-    let connected = ReventlessCore.PluginBehavior.initialState->apply(connect(
-      ReventlessCore.PluginBehavior.initialState,
-      shipped(defA),
-    ))
+    let connected =
+      ReventlessCore.PluginBehavior.initialState->apply(
+        connect(ReventlessCore.PluginBehavior.initialState, shipped(defA)),
+      )
     let redeployed = connected->apply(connect(connected, shipped(defB)))
     let def = switch redeployed.known->Dict.get("1.0.0") {
     | Some({definition}) => definition
@@ -182,10 +179,10 @@ describe("the bake converges when a plugin's structure changes", () => {
   // exercising the chain at all. Correct, and no evidence — which is why the bake
   // counts it apart from a plugin that did register.
   testSync("an unchanged structure passes without re-registering", () => {
-    let connected = ReventlessCore.PluginBehavior.initialState->apply(connect(
-      ReventlessCore.PluginBehavior.initialState,
-      shipped(defA),
-    ))
+    let connected =
+      ReventlessCore.PluginBehavior.initialState->apply(
+        connect(ReventlessCore.PluginBehavior.initialState, shipped(defA)),
+      )
     expect(connect(connected, shipped(defA)))->toEqual([])
     expect(
       stateOf(
@@ -200,10 +197,10 @@ describe("the bake converges when a plugin's structure changes", () => {
   // version; without it a redeploy of the same version never re-runs the handshake
   // and the changed structure never reaches the read model.
   testSync("a redeploy re-detects an already-connected version", () => {
-    let connected = ReventlessCore.PluginBehavior.initialState->apply(connect(
-      ReventlessCore.PluginBehavior.initialState,
-      shipped(defA),
-    ))
+    let connected =
+      ReventlessCore.PluginBehavior.initialState->apply(
+        connect(ReventlessCore.PluginBehavior.initialState, shipped(defA)),
+      )
     expect(
       ReventlessCore.PluginBehavior.decide(connected, ReventlessCore.PluginSpec.Redetect("1.0.0")),
     )->toEqual(Ok([ReventlessCore.PluginSpec.VersionDetected("1.0.0")]))

package/tests/Capability_MessagingTest.res

@@ -19,8 +19,10 @@ describe("Capability_Messaging — reading a configured value", () => {
   // `Pulumi.Config`, which needs a deploy-time runtime this suite does not have.
   // `configured` returns before touching it whenever the variable is set.
   testSync("an address set in the environment is the sender", () => {
-    let sender = withEnv("REVENTLESS_MESSAGING_EMAIL_SENDER", "mail@shop.test", () =>
-      Messaging.configured(Messaging.emailSenderKey)
+    let sender = withEnv(
+      "REVENTLESS_MESSAGING_EMAIL_SENDER",
+      "mail@shop.test",
+      () => Messaging.configured(Messaging.emailSenderKey),
     )
     expect(sender)->toEqual(Some("mail@shop.test"))
   })
@@ -28,8 +30,10 @@ describe("Capability_Messaging — reading a configured value", () => {
   // A stray `REVENTLESS_MESSAGING_EMAIL_SENDER=` in CI, or a blank line in the
   // sidecar. Reading it as an address asks SES for an identity with none.
   testSync("an empty value is not an address", () => {
-    let sender = withEnv("REVENTLESS_MESSAGING_EMAIL_SENDER", "", () =>
-      Messaging.configured(Messaging.emailSenderKey)
+    let sender = withEnv(
+      "REVENTLESS_MESSAGING_EMAIL_SENDER",
+      "",
+      () => Messaging.configured(Messaging.emailSenderKey),
     )
     expect(sender)->toEqual(None)
   })
@@ -37,22 +41,28 @@ describe("Capability_Messaging — reading a configured value", () => {
   // The one that is not obviously empty: a key left with a space after the colon.
   // It reached SES as an identity request for " " before this was trimmed.
   testSync("a whitespace-only value is not an address either", () => {
-    let sender = withEnv("REVENTLESS_MESSAGING_EMAIL_SENDER", "   ", () =>
-      Messaging.configured(Messaging.emailSenderKey)
+    let sender = withEnv(
+      "REVENTLESS_MESSAGING_EMAIL_SENDER",
+      "   ",
+      () => Messaging.configured(Messaging.emailSenderKey),
     )
     expect(sender)->toEqual(None)
   })
 
   testSync("a surviving value is the trimmed one", () => {
-    let sender = withEnv("REVENTLESS_MESSAGING_EMAIL_SENDER", "  mail@shop.test  ", () =>
-      Messaging.configured(Messaging.emailSenderKey)
+    let sender = withEnv(
+      "REVENTLESS_MESSAGING_EMAIL_SENDER",
+      "  mail@shop.test  ",
+      () => Messaging.configured(Messaging.emailSenderKey),
     )
     expect(sender)->toEqual(Some("mail@shop.test"))
   })
 
   testSync("the sms sender reads off its own key", () => {
-    let sender = withEnv("REVENTLESS_MESSAGING_SMS_SENDER", "+15550100", () =>
-      Messaging.configured(Messaging.smsSenderKey)
+    let sender = withEnv(
+      "REVENTLESS_MESSAGING_SMS_SENDER",
+      "+15550100",
+      () => Messaging.configured(Messaging.smsSenderKey),
     )
     expect(sender)->toEqual(Some("+15550100"))
   })
@@ -61,7 +71,9 @@ describe("Capability_Messaging — reading a configured value", () => {
 describe("Capability_Messaging — choosing a transport", () => {
   testSync("ses and log are the two a stack can name", () => {
     let pair: (Messaging.emailProvider, Messaging.emailProvider) = (Ses, Log)
-    expect((Messaging.parseEmailProvider("ses"), Messaging.parseEmailProvider("log")))->toEqual(pair)
+    expect((Messaging.parseEmailProvider("ses"), Messaging.parseEmailProvider("log")))->toEqual(
+      pair,
+    )
   })
 
   // Config files are written by hand; a capitalised or padded value means what it
@@ -85,7 +97,11 @@ describe("Capability_Messaging — choosing a transport", () => {
   // SES is the default so that a deployment saying nothing still mails: a stack
   // that means not to send says so, rather than silence meaning it.
   testSync("a named transport wins over the default", () => {
-    let chosen = withEnv("REVENTLESS_MESSAGING_EMAIL_PROVIDER", "log", () => Messaging.emailProvider())
+    let chosen = withEnv(
+      "REVENTLESS_MESSAGING_EMAIL_PROVIDER",
+      "log",
+      () => Messaging.emailProvider(),
+    )
     let expected: Messaging.emailProvider = Log
     expect(chosen)->toEqual(expected)
   })

package/tests/CommandTopicQueuePolicyTest.res

@@ -16,8 +16,7 @@ let policy =
     ~lambdaArn,
   )->JSON.parseOrThrow
 
-let field = (json, key) =>
-  json->JSON.Decode.object->Option.flatMap(o => o->Dict.get(key))
+let field = (json, key) => json->JSON.Decode.object->Option.flatMap(o => o->Dict.get(key))
 
 let statement = sid =>
   policy

package/tests/CounterEntryPoint_OpsTest.res

@@ -26,8 +26,8 @@ let mkRecord = (
   awsRegion: "eu-west-1",
   dynamodb: {
     keys: {id: attrS(keysId)},
-    newImage: ?newImage,
-    oldImage: ?oldImage,
+    ?newImage,
+    ?oldImage,
   },
   eventID: "e1",
   eventName: INSERT,
@@ -83,11 +83,7 @@ describe("CounterEntryPoint_Ops.splitRecords", () => {
         ~oldImage=Dict.fromArray([("id", attrS("c2")), ("count", attrN("4"))]),
       ),
       // foreign stream / foreign source → dropped
-      mkRecord(
-        ~arn="arn:other",
-        ~keysId="x",
-        ~newImage=Dict.fromArray([("id", attrS("x"))]),
-      ),
+      mkRecord(~arn="arn:other", ~keysId="x", ~newImage=Dict.fromArray([("id", attrS("x"))])),
       mkRecord(
         ~arn=refsArn,
         ~source="aws:sqs",