@reventlessdev/reventless-aws 3.0.0-alpha.332 → 3.0.0-alpha.334

package/tests/AutomationSliceEntryPoint_OpsTest.res

@@ -83,6 +83,128 @@ describe("AutomationSliceEntryPoint_Ops.parseHandlerConfig", () => {
   })
 })
 
+// The compact form the builder emits: module paths and context ride in the
+// archive registry, and the DCB queue + source urn are hoisted out of every
+// entry that does not override them. Together these are what keep the Lambda's
+// environment under AWS's 4KB ceiling as a plugin gains slices.
+describe("AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules", () => {
+  let modules =
+    obj([
+      (
+        "Restock",
+        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")),
+          (
+            "context",
+            obj([
+              ("environment", str("alpha")),
+              ("platformName", str("OnlineShop")),
+              ("pluginName", str("Ordering")),
+              ("sliceName", str("Restock")),
+            ]),
+          ),
+        ]),
+      ),
+      (
+        "Ship",
+        obj([
+          ("specModule", str("@x/plugin/src/Order/OutboundTranslationSlice/Ship.res.mjs")),
+          ("bodyModule", str("@x/plugin/src/Order/OutboundTranslationSlice/Ship_Translation.res.mjs")),
+          ("callbackType", str("outbound")),
+        ]),
+      ),
+    ])->JSON.stringify
+
+  let compactConfig = handlers =>
+    obj([
+      ("queueUrl", str("https://sqs/dcb")),
+      ("commandQueueIsFifo", JSON.Encode.bool(false)),
+      ("urns", JSON.Encode.array([str("arn:dcb:log")])),
+      ("handlers", JSON.Encode.array(handlers)),
+    ])->JSON.stringify
+
+  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)
+    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")
+    expect(e.queryDbTableName)->toBe("RestockTodo-abc")
+    expect(e.dcbQueueUrl)->toBe("https://sqs/dcb")
+    expect(e.commandQueueIsFifo)->toEqual(Some(false))
+    expect(e.sourceUrn)->toBe("arn:dcb:log")
+    switch e.context {
+    | Some(ctx) => expect(ctx.sliceName)->toBe("Restock")
+    | None => JsError.throwWithMessage("expected Some(context)")
+    }
+  })
+
+  testSync("per-entry queue and urn override the shared defaults", () => {
+    let config = compactConfig([
+      obj([
+        ("n", str("Ship")),
+        ("q", str("ShipTodo-abc")),
+        ("u", JSON.Encode.array([str("arn:aggregate:orders"), str("arn:dcb:log")])),
+        ("k", str("https://sqs/orders.fifo")),
+        ("f", JSON.Encode.bool(true)),
+      ]),
+    ])
+    let e =
+      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))
+    // The first of its own urns, not the shared one.
+    expect(e.sourceUrn)->toBe("arn:aggregate:orders")
+    expect(e.context->Option.isNone)->toBe(true)
+  })
+
+  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)
+    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")),
+          ]),
+        ]),
+      ),
+    ])->JSON.stringify
+    let e =
+      AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules(
+        modules,
+        config,
+      )->Array.getUnsafe(0)
+    expect(e.specModule)->toBe("a.res.mjs")
+    expect(e.dcbQueueUrl)->toBe("u")
+  })
+})
+
 // Shared stubs — the pipelines only touch phase1/phase2 plus the injected
 // sync/publish, so the callback records carry empty TODO dicts.
 let noopPublish: ReventlessCore.CommandTopic.publishJsons = async _ => ()

package/tests/AutomationSliceEntryPoint_OpsTest.res.mjs

@@ -119,6 +119,193 @@ globalThis.describe("AutomationSliceEntryPoint_Ops.parseHandlerConfig", () => {
   });
 });
 
+globalThis.describe("AutomationSliceEntryPoint_Ops.parseHandlerConfigWithModules", () => {
+  let modules = JSON.stringify(Object.fromEntries([
+    [
+      "Restock",
+      Object.fromEntries([
+        [
+          "specModule",
+          "@x/plugin/src/Order/AutomationSlice/Restock.res.mjs"
+        ],
+        [
+          "bodyModule",
+          "@x/plugin/src/Order/AutomationSlice/Restock_Automation.res.mjs"
+        ],
+        [
+          "callbackType",
+          "automation"
+        ],
+        [
+          "context",
+          Object.fromEntries([
+            [
+              "environment",
+              "alpha"
+            ],
+            [
+              "platformName",
+              "OnlineShop"
+            ],
+            [
+              "pluginName",
+              "Ordering"
+            ],
+            [
+              "sliceName",
+              "Restock"
+            ]
+          ])
+        ]
+      ])
+    ],
+    [
+      "Ship",
+      Object.fromEntries([
+        [
+          "specModule",
+          "@x/plugin/src/Order/OutboundTranslationSlice/Ship.res.mjs"
+        ],
+        [
+          "bodyModule",
+          "@x/plugin/src/Order/OutboundTranslationSlice/Ship_Translation.res.mjs"
+        ],
+        [
+          "callbackType",
+          "outbound"
+        ]
+      ])
+    ]
+  ]));
+  let compactConfig = handlers => JSON.stringify(Object.fromEntries([
+    [
+      "queueUrl",
+      "https://sqs/dcb"
+    ],
+    [
+      "commandQueueIsFifo",
+      false
+    ],
+    [
+      "urns",
+      ["arn:dcb:log"]
+    ],
+    [
+      "handlers",
+      handlers
+    ]
+  ]));
+  globalThis.test("a compact entry takes its modules from the registry and the shared defaults", () => {
+    let config = compactConfig([Object.fromEntries([
+        [
+          "n",
+          "Restock"
+        ],
+        [
+          "q",
+          "RestockTodo-abc"
+        ]
+      ])]);
+    let e = AutomationSliceEntryPoint_Ops$ReventlessAws.parseHandlerConfigWithModules(modules, config)[0];
+    globalThis.expect(e.specModule).toBe("@x/plugin/src/Order/AutomationSlice/Restock.res.mjs");
+    globalThis.expect(e.bodyModule).toBe("@x/plugin/src/Order/AutomationSlice/Restock_Automation.res.mjs");
+    globalThis.expect(e.callbackType).toBe("automation");
+    globalThis.expect(e.queryDbTableName).toBe("RestockTodo-abc");
+    globalThis.expect(e.dcbQueueUrl).toBe("https://sqs/dcb");
+    globalThis.expect(e.commandQueueIsFifo).toEqual(false);
+    globalThis.expect(e.sourceUrn).toBe("arn:dcb:log");
+    let ctx = e.context;
+    if (ctx !== undefined) {
+      globalThis.expect(ctx.sliceName).toBe("Restock");
+      return;
+    } else {
+      return Stdlib_JsError.throwWithMessage("expected Some(context)");
+    }
+  });
+  globalThis.test("per-entry queue and urn override the shared defaults", () => {
+    let config = compactConfig([Object.fromEntries([
+        [
+          "n",
+          "Ship"
+        ],
+        [
+          "q",
+          "ShipTodo-abc"
+        ],
+        [
+          "u",
+          [
+            "arn:aggregate:orders",
+            "arn:dcb:log"
+          ]
+        ],
+        [
+          "k",
+          "https://sqs/orders.fifo"
+        ],
+        [
+          "f",
+          true
+        ]
+      ])]);
+    let e = AutomationSliceEntryPoint_Ops$ReventlessAws.parseHandlerConfigWithModules(modules, config)[0];
+    globalThis.expect(e.callbackType).toBe("outbound");
+    globalThis.expect(e.dcbQueueUrl).toBe("https://sqs/orders.fifo");
+    globalThis.expect(e.commandQueueIsFifo).toEqual(true);
+    globalThis.expect(e.sourceUrn).toBe("arn:aggregate:orders");
+    globalThis.expect(Stdlib_Option.isNone(e.context)).toBe(true);
+  });
+  globalThis.test("a compact entry with no registry match yields no bodyModule to skip on", () => {
+    let config = compactConfig([Object.fromEntries([
+        [
+          "n",
+          "Gone"
+        ],
+        [
+          "q",
+          "GoneTodo-abc"
+        ]
+      ])]);
+    let e = AutomationSliceEntryPoint_Ops$ReventlessAws.parseHandlerConfigWithModules(modules, config)[0];
+    globalThis.expect(e.specModule).toBe("");
+    globalThis.expect(e.bodyModule).toBe("");
+  });
+  globalThis.test("full-key entries still decode when a registry is present", () => {
+    let config = JSON.stringify(Object.fromEntries([[
+        "handlers",
+        [Object.fromEntries([
+            [
+              "specModule",
+              "a.res.mjs"
+            ],
+            [
+              "bodyModule",
+              "b.res.mjs"
+            ],
+            [
+              "callbackType",
+              "outbound"
+            ],
+            [
+              "queryDbTableName",
+              "t"
+            ],
+            [
+              "dcbQueueUrl",
+              "u"
+            ],
+            [
+              "sourceUrn",
+              "arn"
+            ]
+          ])]
+      ]]));
+    let e = AutomationSliceEntryPoint_Ops$ReventlessAws.parseHandlerConfigWithModules(modules, config)[0];
+    globalThis.expect(e.specModule).toBe("a.res.mjs");
+    globalThis.expect(e.dcbQueueUrl).toBe("u");
+  });
+});
+
 async function noopPublish(param) {
   
 }

package/tests/Capability_MessagingTest.res

@@ -0,0 +1,100 @@
+open JestGlobals
+
+// Which transport a stack mails through, and who it sends as. There is no
+// default address: a placeholder would provision an identity nobody can verify,
+// so "unset" has to survive the whole way to the deploy gate as absence rather
+// than as an address.
+
+module Messaging = Capability_Messaging
+
+let withEnv = (key, value, f) => {
+  Dict.set(NodeProcess.env, key, value)
+  let result = f()
+  Dict.delete(NodeProcess.env, key)
+  result
+}
+
+describe("Capability_Messaging — reading a configured value", () => {
+  // Only the env-var rung is reachable here: the rungs below it end at
+  // `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)
+    )
+    expect(sender)->toEqual(Some("mail@shop.test"))
+  })
+
+  // 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)
+    )
+    expect(sender)->toEqual(None)
+  })
+
+  // 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)
+    )
+    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)
+    )
+    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)
+    )
+    expect(sender)->toEqual(Some("+15550100"))
+  })
+})
+
+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)
+  })
+
+  // Config files are written by hand; a capitalised or padded value means what it
+  // says, and refusing it would be pedantry rather than safety.
+  testSync("the value is read case- and whitespace-insensitively", () => {
+    expect(Messaging.parseEmailProvider("  LOG "))->toEqual(Messaging.Log)
+  })
+
+  // The one that matters: defaulting a typo to SES would provision a real
+  // identity for a stack that asked to only log.
+  testSync("an unrecognised transport is refused, not defaulted", () => {
+    let outcome = try {
+      let _ = Messaging.parseEmailProvider("smtp")
+      None
+    } catch {
+    | JsExn(e) => e->JsExn.message
+    }
+    expect(outcome->Option.getOr("")->String.includes("is not an email provider"))->toBe(true)
+  })
+
+  // 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 expected: Messaging.emailProvider = Log
+    expect(chosen)->toEqual(expected)
+  })
+})
+
+describe("Capability_Messaging — the log transport's default sender", () => {
+  // Hard-coded where the SES address is required, because a logged message
+  // reaches nobody. `.test` can never resolve, so it cannot be a real inbox.
+  testSync("is a reserved address", () => {
+    expect(Messaging.logDefaultAddress->String.endsWith(".test"))->toBe(true)
+  })
+})

package/tests/Capability_MessagingTest.res.mjs

@@ -0,0 +1,85 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.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_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Capability_Messaging$ReventlessAws from "../src/capability/Capability_Messaging.res.mjs";
+
+function withEnv(key, value, f) {
+  process.env[key] = value;
+  let result = f();
+  Stdlib_Dict.$$delete(process.env, key);
+  return result;
+}
+
+globalThis.describe("Capability_Messaging — reading a configured value", () => {
+  globalThis.test("an address set in the environment is the sender", () => {
+    let sender = withEnv("REVENTLESS_MESSAGING_EMAIL_SENDER", "mail@shop.test", () => Capability_Messaging$ReventlessAws.configured(Capability_Messaging$ReventlessAws.emailSenderKey));
+    globalThis.expect(sender).toEqual("mail@shop.test");
+  });
+  globalThis.test("an empty value is not an address", () => {
+    let sender = withEnv("REVENTLESS_MESSAGING_EMAIL_SENDER", "", () => Capability_Messaging$ReventlessAws.configured(Capability_Messaging$ReventlessAws.emailSenderKey));
+    globalThis.expect(sender).toEqual(undefined);
+  });
+  globalThis.test("a whitespace-only value is not an address either", () => {
+    let sender = withEnv("REVENTLESS_MESSAGING_EMAIL_SENDER", "   ", () => Capability_Messaging$ReventlessAws.configured(Capability_Messaging$ReventlessAws.emailSenderKey));
+    globalThis.expect(sender).toEqual(undefined);
+  });
+  globalThis.test("a surviving value is the trimmed one", () => {
+    let sender = withEnv("REVENTLESS_MESSAGING_EMAIL_SENDER", "  mail@shop.test  ", () => Capability_Messaging$ReventlessAws.configured(Capability_Messaging$ReventlessAws.emailSenderKey));
+    globalThis.expect(sender).toEqual("mail@shop.test");
+  });
+  globalThis.test("the sms sender reads off its own key", () => {
+    let sender = withEnv("REVENTLESS_MESSAGING_SMS_SENDER", "+15550100", () => Capability_Messaging$ReventlessAws.configured(Capability_Messaging$ReventlessAws.smsSenderKey));
+    globalThis.expect(sender).toEqual("+15550100");
+  });
+});
+
+globalThis.describe("Capability_Messaging — choosing a transport", () => {
+  globalThis.test("ses and log are the two a stack can name", () => {
+    globalThis.expect([
+      Capability_Messaging$ReventlessAws.parseEmailProvider("ses"),
+      Capability_Messaging$ReventlessAws.parseEmailProvider("log")
+    ]).toEqual([
+      "Ses",
+      "Log"
+    ]);
+  });
+  globalThis.test("the value is read case- and whitespace-insensitively", () => {
+    globalThis.expect(Capability_Messaging$ReventlessAws.parseEmailProvider("  LOG ")).toEqual("Log");
+  });
+  globalThis.test("an unrecognised transport is refused, not defaulted", () => {
+    let outcome;
+    try {
+      Capability_Messaging$ReventlessAws.parseEmailProvider("smtp");
+      outcome = undefined;
+    } catch (raw_e) {
+      let e = Primitive_exceptions.internalToException(raw_e);
+      if (e.RE_EXN_ID === "JsExn") {
+        outcome = Stdlib_JsExn.message(e._1);
+      } else {
+        throw e;
+      }
+    }
+    globalThis.expect(Stdlib_Option.getOr(outcome, "").includes("is not an email provider")).toBe(true);
+  });
+  globalThis.test("a named transport wins over the default", () => {
+    let chosen = withEnv("REVENTLESS_MESSAGING_EMAIL_PROVIDER", "log", () => Capability_Messaging$ReventlessAws.emailProvider());
+    globalThis.expect(chosen).toEqual("Log");
+  });
+});
+
+globalThis.describe("Capability_Messaging — the log transport's default sender", () => {
+  globalThis.test("is a reserved address", () => {
+    globalThis.expect(Capability_Messaging$ReventlessAws.logDefaultAddress.endsWith(".test")).toBe(true);
+  });
+});
+
+let Messaging;
+
+export {
+  Messaging,
+  withEnv,
+}
+/*  Not a pure module */