@reventlessdev/reventless-aws 3.0.0-alpha.268 → 3.0.0-alpha.270

package/src/util/Util_Bundle.res

@@ -242,6 +242,33 @@ type codeArchive = {
   sourceCodeHash: string,
 }
 
+/**
+ * The module specifier of each registered runtime extension, in registration
+ * order — what a deployed runtime imports at cold start. `[]` when nothing is
+ * registered, which is what keeps an extension-free archive byte-identical.
+ *
+ * `ReventlessCore.RuntimeExtension` carries `import.meta.url`s because that is
+ * what an extension module can state about itself; the npm specifier a Lambda
+ * resolves is derived here, the same conversion spec and behavior modules go
+ * through.
+ */
+let runtimeExtensionSpecifiers = (): array<string> =>
+  ReventlessCore.RuntimeExtension.moduleUrls()->Array.map(getModuleSpecifier)
+
+/**
+ * Add every registered runtime extension's package to `packageDirs`, so the
+ * archive carries the modules the entry shell imports at cold start.
+ *
+ * Rooted through `getModuleSpecifier`, which caches the package root it walked
+ * to. That matters: an extension is an out-of-tree package the framework has no
+ * dependency on, so a framework-rooted `require.resolve` would not find it.
+ */
+let addRuntimeExtensionPackages = (packageDirs: dict<string>) =>
+  runtimeExtensionSpecifiers()->Array.forEach(specifier => {
+    let pkgName = extractPackageName(specifier)
+    packageDirs->Dict.set(pkgName, resolvePackageRoot(pkgName))
+  })
+
 /**
  * Build a Lambda code AssetArchive with a static re-export entry point and optional user packages.
  * Centralises the archive-building pattern used by every runtime builder.
@@ -263,6 +290,13 @@ let buildCodeArchive = (
   // Used to ship payloads that would otherwise blow the 5120-byte
   // UpdateFunctionConfiguration limit when packed into HANDLER_CONFIG.
   ~extraStringAssets: dict<string>=Dict.make(),
+  // Whether this archive carries the registered runtime extensions
+  // (`ReventlessCore.RuntimeExtension`). Default-on, so a runtime builder added
+  // later gets the seam by construction rather than by remembering — the same
+  // reason `EventLogProvisioning` fires from the builders and not from each
+  // storage adapter. Support Lambdas that never fire the seam pass `false`
+  // rather than carry modules they will not import.
+  ~bundleRuntimeExtensions: bool=true,
 ): codeArchive => {
   let reExportCode = `export { handler } from "${entryPointModule}";`
   let archiveContents: dict<Pulumi.Archive.assetOrArchive> = Dict.make()
@@ -288,6 +322,12 @@ let buildCodeArchive = (
     } else {
       packageDirs
     }
+  // Registered runtime extensions ride along, so the entry shell can import them
+  // at cold start. No-op when nothing is registered — the archive, and therefore
+  // `sourceCodeHash`, is unchanged.
+  if bundleRuntimeExtensions {
+    allPackageDirs->addRuntimeExtensionPackages
+  }
   let packageContentHashes: ref<array<string>> = ref([])
   allPackageDirs->Dict.forEachWithKey((pkgRoot, pkgName) => {
     let (archive, contentHash) = createFilteredPackageArchive(pkgRoot)

package/src/util/Util_Bundle.res.mjs

@@ -10,6 +10,7 @@ import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as RuntimeExtension$ReventlessCore from "@reventlessdev/reventless-core/src/adapter/RuntimeExtension/RuntimeExtension.res.mjs";
 
 let packageRootCache = {};
 
@@ -176,8 +177,20 @@ function createFilteredPackageArchive(packageRoot) {
   ];
 }
 
-function buildCodeArchive(entryPointModule, packageDirs, extraStringAssetsOpt) {
+function runtimeExtensionSpecifiers() {
+  return RuntimeExtension$ReventlessCore.moduleUrls().map(getModuleSpecifier);
+}
+
+function addRuntimeExtensionPackages(packageDirs) {
+  RuntimeExtension$ReventlessCore.moduleUrls().map(getModuleSpecifier).forEach(specifier => {
+    let pkgName = extractPackageName(specifier);
+    packageDirs[pkgName] = resolvePackageRoot(undefined, pkgName);
+  });
+}
+
+function buildCodeArchive(entryPointModule, packageDirs, extraStringAssetsOpt, bundleRuntimeExtensionsOpt) {
   let extraStringAssets = extraStringAssetsOpt !== undefined ? extraStringAssetsOpt : ({});
+  let bundleRuntimeExtensions = bundleRuntimeExtensionsOpt !== undefined ? bundleRuntimeExtensionsOpt : true;
   let reExportCode = `export { handler } from "` + entryPointModule + `";`;
   let archiveContents = {};
   archiveContents["index.mjs"] = new (Pulumi.asset.StringAsset)(reExportCode);
@@ -193,6 +206,9 @@ function buildCodeArchive(entryPointModule, packageDirs, extraStringAssetsOpt) {
   } else {
     allPackageDirs = packageDirs;
   }
+  if (bundleRuntimeExtensions) {
+    addRuntimeExtensionPackages(allPackageDirs);
+  }
   let packageContentHashes = {
     contents: []
   };
@@ -236,6 +252,8 @@ export {
   isSkippedDir,
   walkDir,
   createFilteredPackageArchive,
+  runtimeExtensionSpecifiers,
+  addRuntimeExtensionPackages,
   buildCodeArchive,
 }
 /* localRequire Not a pure module */

package/tests/RuntimeExtensionEntryPoint_OpsTest.res

@@ -0,0 +1,110 @@
+open JestGlobals
+
+// The deployed half of the runtime extension seam: what a Lambda makes of the
+// RUNTIME_EXTENSIONS env var `RuntimeEnvironment_Lambda.makeFromCodeAsset`
+// writes, and what it does with the hooks the shell lifted off the modules it
+// imported. The shell's `import()` is the one step not covered here — its types
+// are unknowable at compile time, which is exactly why everything either side of
+// it lives in the module under test.
+
+let fullConfig = `{"modules":["@acme/tracing/src/Ext.res.mjs"],"runtimeKind":"Aggregate","component":"AllAggregatesCmdHandler","plugin":"Catalog","platform":"Shop"}`
+
+let recordingHook = (label, into: array<string>): ReventlessCore.RuntimeExtension.coldStartHook =>
+  (~runtimeKind, ~component, ~plugin, ~platform) =>
+    into->Array.push(
+      `${label}|${runtimeKind->ReventlessCore.ComponentType.toString}|${component}|${plugin->Option.getOr(
+          "-",
+        )}|${platform->Option.getOr("-")}`,
+    )
+
+describe("RuntimeExtensionEntryPoint_Ops.parseConfig", () => {
+  testSync("reads the identity and module list makeFromCodeAsset writes", () => {
+    switch RuntimeExtensionEntryPoint_Ops.parseConfig(Some(fullConfig)) {
+    | None => fail("expected a parsed config")
+    | Some(config) =>
+      expect(config.modules)->toEqual(["@acme/tracing/src/Ext.res.mjs"])
+      expect(config.runtimeKind)->toBe("Aggregate")
+      expect(config.component)->toBe("AllAggregatesCmdHandler")
+      expect(config.plugin)->toEqual(Some("Catalog"))
+      expect(config.platform)->toEqual(Some("Shop"))
+    }
+  })
+
+  testSync("platform-scope runtimes carry null plugin/platform", () => {
+    let raw = `{"modules":["@acme/x/src/E.res.mjs"],"runtimeKind":"Heartbeat","component":"CatalogPluginHeartbeat","plugin":null,"platform":null}`
+    switch RuntimeExtensionEntryPoint_Ops.parseConfig(Some(raw)) {
+    | None => fail("expected a parsed config")
+    | Some(config) =>
+      expect(config.plugin)->toEqual(None)
+      expect(config.platform)->toEqual(None)
+    }
+  })
+
+  testSync("an absent env var is the default — no extensions registered", () => {
+    expect(RuntimeExtensionEntryPoint_Ops.parseConfig(None)->Option.isNone)->toBe(true)
+    expect(RuntimeExtensionEntryPoint_Ops.parseConfig(Some(""))->Option.isNone)->toBe(true)
+  })
+
+  testSync("a malformed or incomplete config never stops the runtime", () => {
+    // Each of these would be a framework bug, not an extension one; the seam
+    // reports and stands down rather than failing a runtime that can still serve.
+    expect(RuntimeExtensionEntryPoint_Ops.parseConfig(Some("not json"))->Option.isNone)->toBe(true)
+    expect(RuntimeExtensionEntryPoint_Ops.parseConfig(Some("[1,2]"))->Option.isNone)->toBe(true)
+    expect(
+      RuntimeExtensionEntryPoint_Ops.parseConfig(
+        Some(`{"modules":["a"],"component":"X"}`),
+      )->Option.isNone,
+    )->toBe(true)
+    expect(
+      RuntimeExtensionEntryPoint_Ops.parseConfig(
+        Some(`{"modules":[],"runtimeKind":"Aggregate","component":"X"}`),
+      )->Option.isNone,
+    )->toBe(true)
+  })
+})
+
+describe("RuntimeExtensionEntryPoint_Ops.fire", () => {
+  testSync("hands every hook the runtime's identity, in order", () => {
+    let seen: array<string> = []
+    let config = RuntimeExtensionEntryPoint_Ops.parseConfig(Some(fullConfig))->Option.getOrThrow
+
+    RuntimeExtensionEntryPoint_Ops.fire(
+      config,
+      [recordingHook("tracing", seen), recordingHook("accounting", seen)],
+    )
+
+    expect(seen)->toEqual([
+      "tracing|Aggregate|AllAggregatesCmdHandler|Catalog|Shop",
+      "accounting|Aggregate|AllAggregatesCmdHandler|Catalog|Shop",
+    ])
+  })
+
+  testSync("a throwing hook does not stop its siblings or the runtime", () => {
+    let seen: array<string> = []
+    let config = RuntimeExtensionEntryPoint_Ops.parseConfig(Some(fullConfig))->Option.getOrThrow
+    let broken: ReventlessCore.RuntimeExtension.coldStartHook = (
+      ~runtimeKind as _,
+      ~component as _,
+      ~plugin as _,
+      ~platform as _,
+    ) => JsError.throwWithMessage("extension blew up")
+
+    RuntimeExtensionEntryPoint_Ops.fire(config, [broken, recordingHook("accounting", seen)])
+
+    expect(seen)->toEqual(["accounting|Aggregate|AllAggregatesCmdHandler|Catalog|Shop"])
+  })
+
+  testSync("an unknown runtimeKind is skipped rather than guessed", () => {
+    // Only reachable on a framework version skew between the deploy-time
+    // ComponentType and the layer's. Firing under a guessed kind would silently
+    // attach a kind-routing extension to the wrong runtime.
+    let seen: array<string> = []
+    let config = RuntimeExtensionEntryPoint_Ops.parseConfig(
+      Some(`{"modules":["a"],"runtimeKind":"SomethingNewer","component":"X"}`),
+    )->Option.getOrThrow
+
+    RuntimeExtensionEntryPoint_Ops.fire(config, [recordingHook("tracing", seen)])
+
+    expect(seen)->toEqual([])
+  })
+})

package/tests/RuntimeExtensionEntryPoint_OpsTest.res.mjs

@@ -0,0 +1,88 @@
+// 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 Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as ComponentType$ReventlessCore from "@reventlessdev/reventless-core/src/ComponentType.res.mjs";
+import * as RuntimeExtensionEntryPoint_Ops$ReventlessAws from "../src/adapter/Runtime/RuntimeExtensionEntryPoint_Ops.res.mjs";
+
+let fullConfig = `{"modules":["@acme/tracing/src/Ext.res.mjs"],"runtimeKind":"Aggregate","component":"AllAggregatesCmdHandler","plugin":"Catalog","platform":"Shop"}`;
+
+function recordingHook(label, into) {
+  return (runtimeKind, component, plugin, platform) => {
+    into.push(label + `|` + ComponentType$ReventlessCore.toString(runtimeKind) + `|` + component + `|` + Stdlib_Option.getOr(plugin, "-") + `|` + Stdlib_Option.getOr(platform, "-"));
+  };
+}
+
+globalThis.describe("RuntimeExtensionEntryPoint_Ops.parseConfig", () => {
+  globalThis.test("reads the identity and module list makeFromCodeAsset writes", () => {
+    let config = RuntimeExtensionEntryPoint_Ops$ReventlessAws.parseConfig(fullConfig);
+    if (config !== undefined) {
+      globalThis.expect(config.modules).toEqual(["@acme/tracing/src/Ext.res.mjs"]);
+      globalThis.expect(config.runtimeKind).toBe("Aggregate");
+      globalThis.expect(config.component).toBe("AllAggregatesCmdHandler");
+      globalThis.expect(config.plugin).toEqual("Catalog");
+      globalThis.expect(config.platform).toEqual("Shop");
+      return;
+    } else {
+      return JestGlobals.fail("expected a parsed config");
+    }
+  });
+  globalThis.test("platform-scope runtimes carry null plugin/platform", () => {
+    let config = RuntimeExtensionEntryPoint_Ops$ReventlessAws.parseConfig(`{"modules":["@acme/x/src/E.res.mjs"],"runtimeKind":"Heartbeat","component":"CatalogPluginHeartbeat","plugin":null,"platform":null}`);
+    if (config !== undefined) {
+      globalThis.expect(config.plugin).toEqual(undefined);
+      globalThis.expect(config.platform).toEqual(undefined);
+      return;
+    } else {
+      return JestGlobals.fail("expected a parsed config");
+    }
+  });
+  globalThis.test("an absent env var is the default — no extensions registered", () => {
+    globalThis.expect(Stdlib_Option.isNone(RuntimeExtensionEntryPoint_Ops$ReventlessAws.parseConfig(undefined))).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(RuntimeExtensionEntryPoint_Ops$ReventlessAws.parseConfig(""))).toBe(true);
+  });
+  globalThis.test("a malformed or incomplete config never stops the runtime", () => {
+    globalThis.expect(Stdlib_Option.isNone(RuntimeExtensionEntryPoint_Ops$ReventlessAws.parseConfig("not json"))).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(RuntimeExtensionEntryPoint_Ops$ReventlessAws.parseConfig("[1,2]"))).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(RuntimeExtensionEntryPoint_Ops$ReventlessAws.parseConfig(`{"modules":["a"],"component":"X"}`))).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(RuntimeExtensionEntryPoint_Ops$ReventlessAws.parseConfig(`{"modules":[],"runtimeKind":"Aggregate","component":"X"}`))).toBe(true);
+  });
+});
+
+globalThis.describe("RuntimeExtensionEntryPoint_Ops.fire", () => {
+  globalThis.test("hands every hook the runtime's identity, in order", () => {
+    let seen = [];
+    let config = Stdlib_Option.getOrThrow(RuntimeExtensionEntryPoint_Ops$ReventlessAws.parseConfig(fullConfig), undefined);
+    RuntimeExtensionEntryPoint_Ops$ReventlessAws.fire(config, [
+      recordingHook("tracing", seen),
+      recordingHook("accounting", seen)
+    ]);
+    globalThis.expect(seen).toEqual([
+      "tracing|Aggregate|AllAggregatesCmdHandler|Catalog|Shop",
+      "accounting|Aggregate|AllAggregatesCmdHandler|Catalog|Shop"
+    ]);
+  });
+  globalThis.test("a throwing hook does not stop its siblings or the runtime", () => {
+    let seen = [];
+    let config = Stdlib_Option.getOrThrow(RuntimeExtensionEntryPoint_Ops$ReventlessAws.parseConfig(fullConfig), undefined);
+    let broken = (param, param$1, param$2, param$3) => Stdlib_JsError.throwWithMessage("extension blew up");
+    RuntimeExtensionEntryPoint_Ops$ReventlessAws.fire(config, [
+      broken,
+      recordingHook("accounting", seen)
+    ]);
+    globalThis.expect(seen).toEqual(["accounting|Aggregate|AllAggregatesCmdHandler|Catalog|Shop"]);
+  });
+  globalThis.test("an unknown runtimeKind is skipped rather than guessed", () => {
+    let seen = [];
+    let config = Stdlib_Option.getOrThrow(RuntimeExtensionEntryPoint_Ops$ReventlessAws.parseConfig(`{"modules":["a"],"runtimeKind":"SomethingNewer","component":"X"}`), undefined);
+    RuntimeExtensionEntryPoint_Ops$ReventlessAws.fire(config, [recordingHook("tracing", seen)]);
+    globalThis.expect(seen).toEqual([]);
+  });
+});
+
+export {
+  fullConfig,
+  recordingHook,
+}
+/*  Not a pure module */

package/src/adapter/EventLog/EventLogStorage_DynamoDb.res

@@ -1,27 +0,0 @@
-let make: ReventlessCore.EventLog_Adapter.storageMaker = (~name, ~owner, ~opts) => {
-  let tags = AWS.Tags.make(~name, ~kind=ReventlessCore.EventLog.componentType, ~role=EventLog, ~owner?)
-  let table = Util.DynamoDb.makeTable(
-    name,
-    ~attributes=[{name: "id", type_: "S"}, {name: "position", type_: "S"}],
-    ~rangeKey="position",
-    ~tags,
-    ~opts,
-  )
-
-  {
-    resources: [table->Util_DynamoDb.toResource(~tags=tags->Pulumi.Output.fromInput)],
-    operations: table
-    ->Util_DynamoDb.toResolvedTableOutput
-    ->Pulumi.Output.apply(resolvedTable => {
-      ReventlessCore.EventLog_Adapter.append: EventLogStorage_DynamoDb_Runtime.append(
-        resolvedTable,
-        ...
-      ),
-      replay: EventLogStorage_DynamoDb_Runtime.replay(resolvedTable, ...),
-      replayStream: EventLogStorage_DynamoDb_Runtime.replayStream(resolvedTable),
-      appendStream: EventLogStorage_DynamoDb_Runtime.appendStream(resolvedTable, ...),
-      latestSnapshot: EventLogStorage_DynamoDb_Runtime.latestSnapshot(resolvedTable),
-      writeSnapshot: EventLogStorage_DynamoDb_Runtime.writeSnapshot(resolvedTable),
-    }),
-  }
-}

package/src/adapter/EventLog/EventLogStorage_DynamoDb.res.mjs

@@ -1,36 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as AWS_Tags$ReventlessAws from "../AWS_Tags.res.mjs";
-import * as EventLog$ReventlessCore from "@reventlessdev/reventless-core/src/components/EventLog/EventLog.res.mjs";
-import * as Util_DynamoDb$ReventlessAws from "../../util/Util_DynamoDb.res.mjs";
-import * as EventLogStorage_DynamoDb_Runtime$ReventlessAws from "./EventLogStorage_DynamoDb_Runtime.res.mjs";
-
-function make(name, owner, opts) {
-  let tags = AWS_Tags$ReventlessAws.make(name, EventLog$ReventlessCore.componentType, "EventLog", undefined, undefined, owner, undefined, undefined);
-  let table = Util_DynamoDb$ReventlessAws.makeTable([
-    {
-      name: "id",
-      type: "S"
-    },
-    {
-      name: "position",
-      type: "S"
-    }
-  ], undefined, undefined, "position", tags, opts, name);
-  return {
-    resources: [Util_DynamoDb$ReventlessAws.toResource(tags, table)],
-    operations: Util_DynamoDb$ReventlessAws.toResolvedTableOutput(table).apply(resolvedTable => ({
-      append: EventLogStorage_DynamoDb_Runtime$ReventlessAws.append(resolvedTable),
-      replay: EventLogStorage_DynamoDb_Runtime$ReventlessAws.replay(resolvedTable),
-      replayStream: EventLogStorage_DynamoDb_Runtime$ReventlessAws.replayStream(resolvedTable),
-      appendStream: EventLogStorage_DynamoDb_Runtime$ReventlessAws.appendStream(resolvedTable),
-      latestSnapshot: EventLogStorage_DynamoDb_Runtime$ReventlessAws.latestSnapshot(resolvedTable),
-      writeSnapshot: EventLogStorage_DynamoDb_Runtime$ReventlessAws.writeSnapshot(resolvedTable)
-    }))
-  };
-}
-
-export {
-  make,
-}
-/* AWS_Tags-ReventlessAws Not a pure module */