@reventlessdev/reventless-aws 3.0.0-alpha.310 → 3.0.0-alpha.312

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.312 (2026-08-19)
+
+### Bug Fixes
+
+* **aws:** build the platform's definition asset from the shared value ([c0e432d](https://github.com/ReventlessDev/reventless-core/commit/c0e432d98d96af3ff4c305b62f658ae102c5d142))
+
+
+# 3.0.0-alpha.311 (2026-08-19)
+
+### Bug Fixes
+
+* **aws:** decode the plugin definition asset instead of casting it ([5ac8a75](https://github.com/ReventlessDev/reventless-core/commit/5ac8a758673da63479049ba17658c8f91c5d72c5))
+
+
 # 3.0.0-alpha.310 (2026-08-18)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.310",
+  "version": "3.0.0-alpha.312",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "dependencies": {
@@ -13,17 +13,17 @@
     "sury": "11.0.0-rc.1",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.12",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.1",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.240",
+    "@reventlessdev/reventless-core": "3.0.0-alpha.241",
     "@reventlessdev/reventless-infra": "3.0.0-alpha.146",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.104",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.32",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.118"
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.105",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.118",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.32"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/adapter/Runtime/EventCollectorEntryPoint_Ops.res

@@ -12,8 +12,8 @@
 // Plugin_Callback wiring, and the Lambda dispatch boundary.
 //
 // Runtime-pure: no `open PulumiAws` values — Pulumi appears in type positions
-// only (erased). The two `%identity` casts below sit on documented JSON
-// contracts (same pattern as AggregateEntryPoint_Ops.asConnectionConfig).
+// only (erased). The one `%identity` cast below sits on a documented JSON
+// contract (same pattern as AggregateEntryPoint_Ops.asConnectionConfig).
 
 // ── Shim bindings (HandlerFactoryHelpers.mjs) ───────────────────────────────
 // The structured-log + Effect dispatch boundary shared by every deployed entry
@@ -325,8 +325,8 @@ let projectPluginRow = (row: JSON.t): option<pluginProjection> =>
 
 // A pluginDefinition viewed as a projection (the manage logic reads only the
 // shared subset; `status` is never read for the acting plugin). Array/option
-// fields are js_nullable-normalized — the definition may come from a plain
-// JSON.parse of pluginDefinition.json.
+// fields stay js_nullable-normalized: a definition arriving over the wire, rather
+// than from loadPluginDefinition's decode, still carries null for an absent field.
 let projectionOfDefinition = (d: Reventless.Plugin.pluginDefinition): pluginProjection => {
   id: d.id,
   status: "",
@@ -671,20 +671,24 @@ let warnSkippedExtension = (ext: extensionConfig) =>
 
 let assetPath = (fileName: string): string => NodePath.join([NodeProcess.cwd(), fileName])
 
-// pluginDefinition.json is written at deploy time as a stable JSON literal
-// matching Reventless.Plugin.pluginDefinitionSchema (PluginRuntime_Builder), so
-// the parsed object IS the record shape — cast at the documented contract (the
-// AggregateEntryPoint_Ops.asConnectionConfig pattern). js_nullable option
-// fields may hold null; consumers normalize via jsOption.
-external asPluginDefinition: JSON.t => Reventless.Plugin.pluginDefinition = "%identity"
-
+// pluginDefinition.json is written through the schema's encoder (Plugin_Helpers),
+// so it holds the wire form, which is not the record's runtime shape: an @offload
+// field is {"$offload": …} on the wire and Offloaded(…) in ReScript. Decode it
+// back through the same schema — a cast leaves the wire form in a value typed as
+// the record, and the next encode of it (the Connect handshake) throws.
 let loadPluginDefinition = (): Reventless.Plugin.pluginDefinition =>
   try {
-    assetPath("pluginDefinition.json")->NodeFs.readFileSync->JSON.parseOrThrow->asPluginDefinition
+    assetPath("pluginDefinition.json")
+    ->NodeFs.readFileSync
+    ->Reventless.Util_Sury.fromJsonString(Reventless.Plugin.pluginDefinitionSchema)
   } catch {
   | exn =>
+    // Util_Sury.exnMessage, not the local one: sury raises S.Exn, which is not a
+    // JsExn, so the local reader yields "unknown error" and loses the field path —
+    // the whole diagnosis for a decode failure here.
     JsError.throwWithMessage(
-      "Failed to load pluginDefinition.json from asset zip: " ++ exnMessage(exn),
+      "Failed to load pluginDefinition.json from asset zip: " ++
+      Reventless.Util_Sury.exnMessage(exn),
     )
   }
 

package/src/adapter/Runtime/EventCollectorEntryPoint_Ops.res.mjs

@@ -8,8 +8,10 @@ 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 Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
 import * as SNS_Helpers$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/SNS_Helpers.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as HandlerFactoryHelpersMjs from "./HandlerFactoryHelpers.mjs";
 import * as Plugin_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Callback.res.mjs";
 import * as Util_PluginMessage_Runtime$ReventlessAws from "../../plugin/runtime/Util_PluginMessage_Runtime.res.mjs";
@@ -519,10 +521,10 @@ function assetPath(fileName) {
 
 function loadPluginDefinition() {
   try {
-    return JSON.parse(Nodefs.readFileSync(assetPath("pluginDefinition.json"), "utf8"));
+    return Util_Sury$Reventless.fromJsonString(Nodefs.readFileSync(assetPath("pluginDefinition.json"), "utf8"), Plugin$Reventless.pluginDefinitionSchema);
   } catch (raw_exn) {
     let exn = Primitive_exceptions.internalToException(raw_exn);
-    return Stdlib_JsError.throwWithMessage("Failed to load pluginDefinition.json from asset zip: " + exnMessage(exn));
+    return Stdlib_JsError.throwWithMessage("Failed to load pluginDefinition.json from asset zip: " + Util_Sury$Reventless.exnMessage(exn, undefined));
   }
 }
 

package/src/plugin/runtime/PluginRuntime_Builder.res

@@ -268,12 +268,13 @@ module Make = (
   // keeps the JSON shape consistent so the entry point can parse uniformly.
   let synthesizeAdminContext = (): ReventlessCore.Plugin_Helpers.eventCollectorContext => {
     let config = configRef.contents
-    // Stable JSON literal — matches Reventless.Plugin.pluginDefinitionSchema
-    // (optional fields encoded as null via js_nullable). Must stay byte-aligned with
-    // the ReScript-built twin in `Platform_Admin.construct`'s `fakePluginDefinition`.
-    let platformId = ReventlessCore.Platform_Admin_Structure.pluginId
+    // Encoded from the one placeholder value, through the same schema the entry
+    // point decodes with. It was a hand-written JSON literal, which drifted: the
+    // schema gained `dcbEventLog` and `kind` and the literal did not follow.
     let fakePluginDefinitionJson =
-      `{"id":"${platformId}@INTERNAL","name":"${platformId}","version":"INTERNAL","extensionPoints":[],"extensions":[],"eventCollector":"NOT-SET","extensionProtocols":[],"apiSchemaFragment":null,"apiTarget":null,"structure":null}`->Pulumi.Output.make
+      ReventlessCore.Platform_Admin_Structure.internalPluginDefinition
+      ->Reventless.Util_Sury.toJsonString(Reventless.Plugin.pluginDefinitionSchema)
+      ->Pulumi.Output.make
     let adminEpEventTopicArn = switch config.eventTopicArn {
     | Some(arn) => arn
     | None => Pulumi.Output.make("NOT_AVAILABLE")

package/src/plugin/runtime/PluginRuntime_Builder.res.mjs

@@ -5,6 +5,8 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Pulumi from "@pulumi/pulumi";
 import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
 import * as DcbBackend$ReventlessAws from "../../adapter/DcbEventLog/DcbBackend.res.mjs";
@@ -202,7 +204,7 @@ function Make(EventCollectorChannel) {
   };
   let synthesizeAdminContext = () => {
     let config = configRef.contents;
-    let fakePluginDefinitionJson = Pulumi.output(`{"id":"` + Platform_Admin_Structure$ReventlessCore.pluginId + `@INTERNAL","name":"` + Platform_Admin_Structure$ReventlessCore.pluginId + `","version":"INTERNAL","extensionPoints":[],"extensions":[],"eventCollector":"NOT-SET","extensionProtocols":[],"apiSchemaFragment":null,"apiTarget":null,"structure":null}`);
+    let fakePluginDefinitionJson = Pulumi.output(Util_Sury$Reventless.toJsonString(Platform_Admin_Structure$ReventlessCore.internalPluginDefinition, Plugin$Reventless.pluginDefinitionSchema, undefined));
     let arn = config.eventTopicArn;
     let adminEpEventTopicArn = arn !== undefined ? arn : Pulumi.output("NOT_AVAILABLE");
     return {

package/tests/EventCollectorPluginDefinitionAssetTest.res

@@ -0,0 +1,115 @@
+// Guards the write/read symmetry of the `pluginDefinition.json` asset.
+//
+// The deploy side writes it with the schema's encoder (Plugin_Helpers); the
+// runtime side (EventCollectorEntryPoint_Ops.loadPluginDefinition) reads it back
+// and republishes the value inside the Connect handshake. Those two have to be
+// the same schema in opposite directions.
+//
+// They stopped being that once a field carried @offload, whose wire form is
+// deliberately untagged: {"$offload": …} on the wire, Offloaded(…) in ReScript.
+// The read side cast the parsed JSON instead of decoding it, so the wire form
+// survived inside a value typed as the record and the *next* encode — publishing
+// ConnectPlugin — threw. Registration then froze at the previous version with the
+// deploy reporting success, so this asserts the round trip rather than the read.
+
+open JestGlobals
+
+let offloadedFragment: Reventless.Plugin.pluginDefinition = {
+  id: "Catalog@1.0.0-alpha.215",
+  name: "Catalog",
+  version: "1.0.0-alpha.215",
+  extensionPoints: [],
+  extensions: [],
+  eventCollector: "arn:aws:sqs:eu-west-1:1:CatalogPluginEventColl",
+  extensionProtocols: [],
+  apiSchemaFragment: Some(
+    Offloaded({
+      store: "pluginApiFragments",
+      key: "sha256/a3db053a9ca51d63982811b0c1faa42cbb83ef6011ea140841375c7b1c9e9695",
+      hash: "a3db053a9ca51d63982811b0c1faa42cbb83ef6011ea140841375c7b1c9e9695",
+      bytes: 14594,
+    }),
+  ),
+  apiTarget: Some("Domain"),
+  structure: None,
+  dcbEventLog: None,
+  kind: Domain,
+}
+
+let inlineFragment: Reventless.Plugin.pluginDefinition = {
+  ...offloadedFragment,
+  apiSchemaFragment: Some(Inline({encoded: "{\"types\":[]}", protocol: "1"})),
+}
+
+// The asset as it lands in the code archive — the deploy side, verbatim.
+let writeAsset = (def: Reventless.Plugin.pluginDefinition): string =>
+  def->Reventless.Util_Sury.toJsonString(Reventless.Plugin.pluginDefinitionSchema)
+
+// The runtime side, through the real entry point: loadPluginDefinition resolves
+// the asset against process.cwd(), so the file has to be laid down where it looks
+// rather than the decode re-implemented here — re-implementing it is what would
+// let a cast come back green.
+let readAsset = (json: string): Reventless.Plugin.pluginDefinition => {
+  let dir = NodeFs.mkdtempSync(NodePath.join([NodeOs.tmpdir(), "plugindef-"]))
+  let previousCwd = NodeProcess.cwd()
+  NodeFs.writeFileSync(NodePath.join([dir, "pluginDefinition.json"]), json)
+  NodeProcess.chdir(dir)
+  let restore = () => {
+    NodeProcess.chdir(previousCwd)
+    NodeFs.rmSync(dir, {recursive: true, force: true})
+  }
+  switch EventCollectorEntryPoint_Ops.loadPluginDefinition() {
+  | def =>
+    restore()
+    def
+  | exception exn =>
+    restore()
+    throw(exn)
+  }
+}
+
+describe("pluginDefinition.json write/read symmetry", () => {
+  testSync("an offloaded field reaches the runtime as Offloaded, not as its wire form", () => {
+    let def = offloadedFragment->writeAsset->readAsset
+    switch def.apiSchemaFragment {
+    | Some(Offloaded({store, bytes})) =>
+      expect(store)->toBe("pluginApiFragments")
+      expect(bytes)->toBe(14594)
+    | Some(Inline(_)) => fail("offloaded fragment decoded as Inline")
+    | None => fail("offloaded fragment decoded as None")
+    }
+  })
+
+  testSync("a definition read back from the asset can be published to the Connect handshake", () => {
+    // The encode the old cast broke. Both arms, because only Offloaded diverges
+    // between wire and runtime shape and an Inline-only test would stay green.
+    [offloadedFragment, inlineFragment]->Array.forEach(def => {
+      let published =
+        ReventlessInfra.PluginExtensionPointSpec.ConnectPlugin(def->writeAsset->readAsset)
+        ->Reventless.Util_Sury.toJson(ReventlessInfra.PluginExtensionPointSpec.commandSchema)
+      expect(published->JSON.Decode.object->Option.isSome)->toBe(true)
+    })
+  })
+
+  testSync("the asset round-trips byte-identically, so no stored message shifts", () => {
+    let once = offloadedFragment->writeAsset
+    expect(once->readAsset->writeAsset)->toBe(once)
+  })
+
+  testSync("an absent optional reaches the runtime as None, not as null", () => {
+    let def = offloadedFragment->writeAsset->readAsset
+    expect(def.structure->Option.isNone)->toBe(true)
+    expect(def.dcbEventLog->Option.isNone)->toBe(true)
+  })
+
+  // The platform's own EventCollector ships a placeholder rather than a real
+  // definition — the admin IS the Plugin extension point — but it is read back on
+  // this same path, so it has to satisfy the same schema. Its asset used to be a
+  // hand-written JSON literal in PluginRuntime_Builder and fell two fields behind
+  // (dcbEventLog, kind) with nothing to notice.
+  testSync("the platform's own placeholder asset survives the same round trip", () => {
+    let def = ReventlessCore.Platform_Admin_Structure.internalPluginDefinition->writeAsset->readAsset
+    expect(def.id)->toBe(ReventlessCore.Platform_Admin_Structure.pluginId ++ "@INTERNAL")
+    expect(def.kind)->toBe(Reventless.Plugin.Domain)
+  })
+})

package/tests/EventCollectorPluginDefinitionAssetTest.res.mjs

@@ -0,0 +1,135 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodefs from "node:fs";
+import * as Nodeos from "node:os";
+import * as Nodepath from "node:path";
+import * as JestGlobals from "@reventlessdev/rescript-jest/src/JestGlobals.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
+import * as Platform_Admin_Structure$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_Admin_Structure.res.mjs";
+import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
+import * as EventCollectorEntryPoint_Ops$ReventlessAws from "../src/adapter/Runtime/EventCollectorEntryPoint_Ops.res.mjs";
+
+let offloadedFragment = {
+  id: "Catalog@1.0.0-alpha.215",
+  name: "Catalog",
+  version: "1.0.0-alpha.215",
+  extensionPoints: [],
+  extensions: [],
+  eventCollector: "arn:aws:sqs:eu-west-1:1:CatalogPluginEventColl",
+  extensionProtocols: [],
+  apiSchemaFragment: {
+    TAG: "Offloaded",
+    _0: {
+      store: "pluginApiFragments",
+      key: "sha256/a3db053a9ca51d63982811b0c1faa42cbb83ef6011ea140841375c7b1c9e9695",
+      hash: "a3db053a9ca51d63982811b0c1faa42cbb83ef6011ea140841375c7b1c9e9695",
+      bytes: 14594
+    }
+  },
+  apiTarget: "Domain",
+  structure: undefined,
+  dcbEventLog: undefined,
+  kind: "Domain"
+};
+
+let inlineFragment = {
+  id: offloadedFragment.id,
+  name: offloadedFragment.name,
+  version: offloadedFragment.version,
+  extensionPoints: offloadedFragment.extensionPoints,
+  extensions: offloadedFragment.extensions,
+  eventCollector: offloadedFragment.eventCollector,
+  extensionProtocols: offloadedFragment.extensionProtocols,
+  apiSchemaFragment: {
+    TAG: "Inline",
+    _0: {
+      encoded: "{\"types\":[]}",
+      protocol: "1"
+    }
+  },
+  apiTarget: offloadedFragment.apiTarget,
+  structure: offloadedFragment.structure,
+  dcbEventLog: offloadedFragment.dcbEventLog,
+  kind: offloadedFragment.kind
+};
+
+function writeAsset(def) {
+  return Util_Sury$Reventless.toJsonString(def, Plugin$Reventless.pluginDefinitionSchema, undefined);
+}
+
+function readAsset(json) {
+  let dir = Nodefs.mkdtempSync(Nodepath.join(Nodeos.tmpdir(), "plugindef-"));
+  let previousCwd = process.cwd();
+  Nodefs.writeFileSync(Nodepath.join(dir, "pluginDefinition.json"), json, "utf8");
+  process.chdir(dir);
+  let restore = () => {
+    process.chdir(previousCwd);
+    Nodefs.rmSync(dir, {
+      recursive: true,
+      force: true
+    });
+  };
+  let def;
+  try {
+    def = EventCollectorEntryPoint_Ops$ReventlessAws.loadPluginDefinition();
+  } catch (exn) {
+    restore();
+    throw exn;
+  }
+  restore();
+  return def;
+}
+
+globalThis.describe("pluginDefinition.json write/read symmetry", () => {
+  globalThis.test("an offloaded field reaches the runtime as Offloaded, not as its wire form", () => {
+    let def = readAsset(Util_Sury$Reventless.toJsonString(offloadedFragment, Plugin$Reventless.pluginDefinitionSchema, undefined));
+    let match = def.apiSchemaFragment;
+    if (match === undefined) {
+      return JestGlobals.fail("offloaded fragment decoded as None");
+    }
+    if (match.TAG === "Inline") {
+      return JestGlobals.fail("offloaded fragment decoded as Inline");
+    }
+    let match$1 = match._0;
+    globalThis.expect(match$1.store).toBe("pluginApiFragments");
+    globalThis.expect(match$1.bytes).toBe(14594);
+  });
+  globalThis.test("a definition read back from the asset can be published to the Connect handshake", () => {
+    [
+      offloadedFragment,
+      inlineFragment
+    ].forEach(def => {
+      let published = Util_Sury$Reventless.toJson({
+        TAG: "ConnectPlugin",
+        _0: readAsset(Util_Sury$Reventless.toJsonString(def, Plugin$Reventless.pluginDefinitionSchema, undefined))
+      }, PluginExtensionPointSpec$ReventlessInfra.commandSchema);
+      globalThis.expect(Stdlib_Option.isSome(Stdlib_JSON.Decode.object(published))).toBe(true);
+    });
+  });
+  globalThis.test("the asset round-trips byte-identically, so no stored message shifts", () => {
+    let once = Util_Sury$Reventless.toJsonString(offloadedFragment, Plugin$Reventless.pluginDefinitionSchema, undefined);
+    let def = readAsset(once);
+    globalThis.expect(Util_Sury$Reventless.toJsonString(def, Plugin$Reventless.pluginDefinitionSchema, undefined)).toBe(once);
+  });
+  globalThis.test("an absent optional reaches the runtime as None, not as null", () => {
+    let def = readAsset(Util_Sury$Reventless.toJsonString(offloadedFragment, Plugin$Reventless.pluginDefinitionSchema, undefined));
+    globalThis.expect(Stdlib_Option.isNone(def.structure)).toBe(true);
+    globalThis.expect(Stdlib_Option.isNone(def.dcbEventLog)).toBe(true);
+  });
+  globalThis.test("the platform's own placeholder asset survives the same round trip", () => {
+    let def = readAsset(Util_Sury$Reventless.toJsonString(Platform_Admin_Structure$ReventlessCore.internalPluginDefinition, Plugin$Reventless.pluginDefinitionSchema, undefined));
+    globalThis.expect(def.id).toBe(Platform_Admin_Structure$ReventlessCore.pluginId + "@INTERNAL");
+    globalThis.expect(def.kind).toBe("Domain");
+  });
+});
+
+export {
+  offloadedFragment,
+  inlineFragment,
+  writeAsset,
+  readAsset,
+}
+/*  Not a pure module */