@reventlessdev/reventless-aws 3.0.0-alpha.309 → 3.0.0-alpha.311

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.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
+
+* **aws:** normalize the null a table without a sort key resolves to ([8fb15ac](https://github.com/ReventlessDev/reventless-core/commit/8fb15ac066679b6799f4287c2c8d332e2367f599))
+
+
 # 3.0.0-alpha.309 (2026-08-18)
 
 * feat(core)!: tell the Monitoring seam where a unit's logs live ([6cbd595](https://github.com/ReventlessDev/reventless-core/commit/6cbd595e2474fce3f87b7720a332e82583899bae))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.309",
+  "version": "3.0.0-alpha.311",
   "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-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.0",
+    "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.1",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.146",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.32",
     "@reventlessdev/reventless-core": "3.0.0-alpha.240",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.32",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.118",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.104"
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.104",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.146"
   },
   "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,16 +671,16 @@ 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 =>
     JsError.throwWithMessage(

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,7 +521,7 @@ 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));

package/src/util/Util_DynamoDb.res

@@ -7,7 +7,12 @@ let log = ReventlessCore.Logger.fromEnv()
 let toResourceInfo: table => Pulumi.Output.t<ReventlessInfra.Adapter.resourceInfo> = ({hashKey, rangeKey}) =>
   (hashKey, rangeKey)
   ->Pulumi.Output.all2
-  ->Pulumi.Output.apply(((hashKey, rangeKey)) => ReventlessInfra.Adapter.StorageKeys({partitionKey: hashKey, sortKey: rangeKey}))
+  ->Pulumi.Output.apply(((hashKey, rangeKey)) => ReventlessInfra.Adapter.StorageKeys({
+    partitionKey: hashKey,
+    // Normalize here: a null reaching the plugin-structure export fails sury's
+    // encode-side validation, which expects `option`'s undefined.
+    sortKey: rangeKey->Nullable.toOption,
+  }))
 
 let toResolvedTableOutput = ({name, id, arn, hashKey, rangeKey}) =>
   (name, id, arn, hashKey, rangeKey)
@@ -17,7 +22,7 @@ let toResolvedTableOutput = ({name, id, arn, hashKey, rangeKey}) =>
     name,
     arn,
     hashKey,
-    rangeKey: ?(rangeKey->Option.map(rangeKey => rangeKey->Nullable.make)),
+    rangeKey: ?(rangeKey->Nullable.toOption->Option.map(Nullable.make)),
   })
 
 let toResource = (~tags=?, {id, name, arn} as table) =>

package/src/util/Util_DynamoDb.res.mjs

@@ -24,7 +24,7 @@ function toResourceInfo(param) {
   ]).apply(param => ({
     TAG: "StorageKeys",
     partitionKey: param[0],
-    sortKey: param[1]
+    sortKey: Primitive_option.fromNullable(param[1])
   }));
 }
 
@@ -40,7 +40,7 @@ function toResolvedTableOutput(param) {
     name: param[0],
     arn: param[2],
     hashKey: param[3],
-    rangeKey: Stdlib_Option.map(param[4], rangeKey => rangeKey)
+    rangeKey: Stdlib_Option.map(Primitive_option.fromNullable(param[4]), prim => prim)
   }));
 }
 

package/tests/EventCollectorPluginDefinitionAssetTest.res

@@ -0,0 +1,104 @@
+// 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)
+  })
+})

package/tests/EventCollectorPluginDefinitionAssetTest.res.mjs

@@ -0,0 +1,129 @@
+// 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 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);
+  });
+});
+
+export {
+  offloadedFragment,
+  inlineFragment,
+  writeAsset,
+  readAsset,
+}
+/*  Not a pure module */

package/tests/Util_DynamoDbTest.res

@@ -0,0 +1,44 @@
+open JestGlobals
+
+// Guards the null a table without a sort key resolves to.
+//
+// Pulumi resolves an absent `rangeKey` to `null`, and ReScript's `option` reads
+// None as undefined — so the null travelled into `resourceInfo` unconverted and
+// the plugin-structure export threw `Expected string | undefined, received null`
+// out of sury's encode-side validation, failing the deploy after it had already
+// applied part of the stack.
+
+let resolve = (output: Pulumi.Output.t<'a>): promise<'a> =>
+  Promise.make((resolve, _) => {
+    let _ = output->Pulumi.Output.apply(value => resolve(value))
+  })
+
+let table = (~rangeKey): PulumiAws.DynamoDb.Table.t => {
+  arn: "arn:aws:dynamodb:eu-west-1:123456789012:table/UiFragments-abc123"->Pulumi.Output.make,
+  name: "UiFragments-abc123"->Pulumi.Output.make,
+  id: "UiFragments-abc123"->Pulumi.Output.make,
+  hashKey: "id"->Pulumi.Output.make,
+  rangeKey: rangeKey->Pulumi.Output.make,
+  streamEnabled: None->Pulumi.Output.make,
+  streamArn: ""->Pulumi.Output.make,
+  streamLabel: ""->Pulumi.Output.make,
+  ttl: {PulumiAws.DynamoDb.Table.attributeName: ""}->Pulumi.Output.make,
+  pointInTimeRecovery: {PulumiAws.DynamoDb.Table.enabled: true}->Pulumi.Output.make,
+}
+
+describe("Util_DynamoDb.toResourceInfo", () => {
+  test("reads a table without a sort key as None", async () => {
+    let resourceInfo = await table(~rangeKey=Nullable.null)->Util_DynamoDb.toResourceInfo->resolve
+    expect(resourceInfo)->toEqual(
+      ReventlessInfra.Adapter.StorageKeys({partitionKey: "id", sortKey: None}),
+    )
+  })
+
+  test("carries a sort key when the table has one", async () => {
+    let resourceInfo =
+      await table(~rangeKey=Nullable.make("seq"))->Util_DynamoDb.toResourceInfo->resolve
+    expect(resourceInfo)->toEqual(
+      ReventlessInfra.Adapter.StorageKeys({partitionKey: "id", sortKey: Some("seq")}),
+    )
+  })
+})

package/tests/Util_DynamoDbTest.res.mjs

@@ -0,0 +1,54 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Pulumi from "@pulumi/pulumi";
+import * as Util_DynamoDb$ReventlessAws from "../src/util/Util_DynamoDb.res.mjs";
+
+function resolve(output) {
+  return new Promise((resolve, param) => {
+    output.apply(value => resolve(value));
+  });
+}
+
+function table(rangeKey) {
+  return {
+    arn: Pulumi.output("arn:aws:dynamodb:eu-west-1:123456789012:table/UiFragments-abc123"),
+    name: Pulumi.output("UiFragments-abc123"),
+    id: Pulumi.output("UiFragments-abc123"),
+    hashKey: Pulumi.output("id"),
+    rangeKey: Pulumi.output(rangeKey),
+    streamEnabled: Pulumi.output(undefined),
+    streamArn: Pulumi.output(""),
+    streamLabel: Pulumi.output(""),
+    ttl: Pulumi.output({
+      attributeName: ""
+    }),
+    pointInTimeRecovery: Pulumi.output({
+      enabled: true
+    })
+  };
+}
+
+globalThis.describe("Util_DynamoDb.toResourceInfo", () => {
+  globalThis.test("reads a table without a sort key as None", async () => {
+    let resourceInfo = await resolve(Util_DynamoDb$ReventlessAws.toResourceInfo(table(null)));
+    globalThis.expect(resourceInfo).toEqual({
+      TAG: "StorageKeys",
+      partitionKey: "id",
+      sortKey: undefined
+    });
+  });
+  globalThis.test("carries a sort key when the table has one", async () => {
+    let resourceInfo = await resolve(Util_DynamoDb$ReventlessAws.toResourceInfo(table("seq")));
+    globalThis.expect(resourceInfo).toEqual({
+      TAG: "StorageKeys",
+      partitionKey: "id",
+      sortKey: "seq"
+    });
+  });
+});
+
+export {
+  resolve,
+  table,
+}
+/*  Not a pure module */