@reventlessdev/reventless-aws 3.0.0-alpha.188 → 3.0.0-alpha.190

package/src/adapter/Runtime/DcbCommandTopicEntryPoint_Ops.res

@@ -0,0 +1,221 @@
+// Typed cold-start core for the DCB CommandTopic Lambda entry point.
+//
+// The "typed core, thin shell" split (docs/plans/minimize-lambda-entrypoint-mjs-shell.md).
+// The `.mjs` shell owns the one boundary that is inherently untyped: reading
+// `HANDLER_CONFIG` and dynamically `import()`-ing user Spec/Behavior modules at
+// cold start, whose types are unknowable here. Everything below is compiler-
+// checked against the *real* framework signatures, so the invariants that used
+// to live only in `.mjs` comments are now enforced by the build:
+//
+//   * decision-read scope derivation — re-deriving from annotations alone once
+//     dropped inferred cross-partition reference reads and rejected every
+//     reference-guarded command in prod. See
+//     docs/analysis/dcb-runtime-scope-annotation-drift.md.
+//   * storage `partitionTag` derivation + threading — dropping it collapsed the
+//     composite fence and produced TransactionConflict bursts in prod. See
+//     docs/plans/done/dcb-composite-fence-residual-burst-contention.md.
+//   * the storage-ops calls take *labeled* args; the `.mjs` called them
+//     positionally and relied on a comment to stay aligned with the compiled
+//     signature. Here a signature change is a compile error, not a silent
+//     runtime regression.
+
+// A user StateChangeSlice spec module, dynamically imported and id-patched by the
+// `.mjs` shell. Opaque here; only the fields the derivations read are projected
+// out through typed getters — the single sanctioned coercion point for specs.
+type specModule
+
+@get external specName: specModule => string = "name"
+@get external specModuleUrl: specModule => Nullable.t<string> = "moduleUrl"
+@get external specCommandSchema: specModule => S.t<unknown> = "commandSchema"
+@get external specConsumedEventSchema: specModule => S.t<unknown> = "consumedEventSchema"
+@get external specEventSchema: specModule => S.t<unknown> = "eventSchema"
+
+// The `pgConnection` object as it arrives in `HANDLER_CONFIG` — the
+// `PgConnection.connectionConfig` fields plus `lockStrategy`. Present iff this
+// DcbEventLog is Postgres-backed.
+type pgConnectionJson
+@get external pgLockStrategy: pgConnectionJson => Nullable.t<string> = "lockStrategy"
+external asConnectionConfig: pgConnectionJson => PgConnection.connectionConfig = "%identity"
+
+// The decision-read scope + storage partition tag for one consistency boundary,
+// derived exactly the way the deploy-time `Dcb_Builder` does (both call the same
+// `Reventless.DcbTag` functions — the single source of truth), so the runtime
+// query can't diverge from the storage/GSI scope.
+type derivedScope = {
+  crossPartitionTagKeys: array<string>,
+  tagKeysByEventType: dict<array<string>>,
+  partitionTag: option<Reventless.DcbTag.derivedPartitionTag>,
+}
+
+let deriveScope = (specs: array<specModule>): derivedScope => {
+  let scope = Reventless.DcbTag.deriveEffectiveScope(
+    specs->Array.map(s => {
+      Reventless.DcbTag.name: specName(s),
+      commandSchema: specCommandSchema(s),
+      consumedEventSchema: specConsumedEventSchema(s),
+      eventSchema: specEventSchema(s),
+    }),
+  )
+
+  // `derivePartitionTag` throws only on a misconfigured spec, which the deploy
+  // would already have rejected; degrade to untagged fences rather than crash
+  // cold start (matches the shell's prior defensive behaviour).
+  let partitionTag = try Some(
+    Reventless.DcbTag.derivePartitionTag(
+      specs->Array.map(s => (
+        specName(s),
+        specModuleUrl(s)->Nullable.toOption->Option.getOr(specName(s)),
+        specEventSchema(s),
+      )),
+    ),
+  ) catch {
+  | _ => None
+  }
+
+  {
+    crossPartitionTagKeys: scope.crossPartitionTagKeys,
+    tagKeysByEventType: scope.tagKeysByEventType,
+    partitionTag,
+  }
+}
+
+// The command TAG names this slice handles — used by the shell to build its
+// `handlersByType` routing map.
+let commandTypeNames = (spec: specModule): array<string> =>
+  Reventless.DcbTag.extractVariantNames(specCommandSchema(spec))
+
+// DynamoDB storage ops for the shared DcbEventLog, threading the derived scope.
+// Mirrors `DcbEventLogStorage_DynamoDb.res`'s deploy-time wiring minus the
+// Pulumi.Output layer (the table name is already resolved at runtime).
+let makeDynamoStorageOps = (
+  ~tableName: string,
+  scope: derivedScope,
+): ReventlessCore.DcbEventLog_Adapter.operations => {
+  let table: Util_DynamoDb_Runtime.resolvedTable = {
+    id: "",
+    name: tableName,
+    arn: "",
+    hashKey: "id",
+  }
+  {
+    ReventlessCore.DcbEventLog_Adapter.read: DcbEventLogStorage_DynamoDb_Runtime.read(
+      table,
+      ~crossPartitionTagKeys=scope.crossPartitionTagKeys,
+    ),
+    append: DcbEventLogStorage_DynamoDb_Runtime.append(
+      table,
+      ~partitionTag=?scope.partitionTag,
+      ~crossPartitionTagKeys=scope.crossPartitionTagKeys,
+    ),
+    readStream: DcbEventLogStorage_DynamoDb_Runtime.readStream(
+      table,
+      ~crossPartitionTagKeys=scope.crossPartitionTagKeys,
+    ),
+  }
+}
+
+// Postgres storage ops. `logName` is the `dcbEventLogTableName` (Postgres
+// evaluates the DCB query atomically, so scope/GSI routing doesn't apply).
+let makePostgresStorageOps = (
+  ~pgConnection: pgConnectionJson,
+  ~logName: string,
+): ReventlessCore.DcbEventLog_Adapter.operations => {
+  let lockStrategy = switch pgConnection->pgLockStrategy->Nullable.toOption {
+  | Some("RowLocks") => #RowLocks
+  | _ => #AdvisoryLocks
+  }
+  DcbEventLogStorage_Postgres_Runtime.opsFor(
+    pgConnection->asConnectionConfig,
+    ~logName,
+    ~lockStrategy,
+  )
+}
+
+// Storage-backend selection: Postgres when `pgConnection` is present, else
+// DynamoDB. One entry point for the shell.
+let makeStorageOps = (
+  ~tableName: string,
+  ~pgConnection: option<pgConnectionJson>,
+  scope: derivedScope,
+): ReventlessCore.DcbEventLog_Adapter.operations =>
+  switch pgConnection {
+  | Some(pg) => makePostgresStorageOps(~pgConnection=pg, ~logName=tableName)
+  | None => makeDynamoStorageOps(~tableName, scope)
+  }
+
+// ── Tier 2.5: typed slice-handler wiring ────────────────────────────────────
+// The shell previously invoked the compiled `StateChangeSlice_Callback.Make`
+// functor and its `handleCommands` result POSITIONALLY — the exact call the
+// line-146 comment flagged, and the 2026-06-21 incident's regression class
+// (a labelled arg added before the positional ones shifts `stream` to
+// undefined, crashing inside `Stream.mapEffect`). Moving the functor call, the
+// JSON→command decode, and the `handleCommands` invocation here makes all three
+// compiler-checked. The loaded Spec/Behavior modules enter opaque (a clean
+// pass-through to the functor — not poked at); `dcbEventLog` enters as a
+// boundary-typed parameter (the shell still builds it).
+
+// The loaded slice's `command` type — opaque; flows from the decode straight
+// into `handleCommands`, so decode and consume share one abstract type.
+type command
+type behaviorModule
+
+@get external specCommandSchemaTyped: specModule => S.t<command> = "commandSchema"
+
+// `StateChangeSlice_Callback.Make(Spec)(Behavior)` — curried in compiled form.
+type sliceCallback = {
+  handleCommands: (
+    ~tagKeysByEventType: dict<array<string>>=?,
+    ~crossPartitionTagKeys: array<string>=?,
+    ReventlessInfra.DcbEventLog.operations,
+    Stream.t<
+      ReventlessInfra.CommandTopic.topicItem<
+        ReventlessCore.Message.command'<Reventless.Id.String.t, command>,
+      >,
+      string,
+      unit,
+    >,
+  ) => Effect.t<array<result<string, string>>, string, unit>,
+}
+@module("@reventlessdev/reventless-core/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs")
+external makeSliceCallback: specModule => behaviorModule => sliceCallback = "Make"
+
+// Builds the per-slice JSON-command handler: decode each topic item's JSON
+// command against the slice's schema (dropping undecodable ones), then dispatch
+// the decoded stream through the slice callback. Returns the same
+// `Stream.t<topicItem<JSON>> => Effect` the shell's routing map keys on.
+let buildSliceHandler = (
+  spec: specModule,
+  behavior: behaviorModule,
+  ~tagKeysByEventType: dict<array<string>>,
+  ~crossPartitionTagKeys: array<string>,
+  dcbEventLog: ReventlessInfra.DcbEventLog.operations,
+) => {
+  let callback = makeSliceCallback(spec)(behavior)
+  let commandSchema = spec->specCommandSchemaTyped
+  (
+    jsonStream: Stream.t<ReventlessInfra.CommandTopic.topicItem<JSON.t>, string, unit>,
+  ): Effect.t<array<result<string, string>>, string, unit> => {
+    let decodedStream =
+      jsonStream
+      ->Stream.mapEffect(topicItem =>
+        Effect.sync(() =>
+          switch ReventlessCore.Message.decodeCommand'(
+            topicItem.command,
+            Reventless.Id.String.schema,
+            commandSchema,
+          ) {
+          | decoded =>
+            Some({ReventlessInfra.CommandTopic.command: decoded, reference: topicItem.reference})
+          | exception _ => None
+          }
+        )
+      )
+      ->Stream.flatMap(opt =>
+        switch opt {
+        | Some(item) => Stream.fromIterable([item])
+        | None => Stream.empty
+        }
+      )
+    callback.handleCommands(~tagKeysByEventType, ~crossPartitionTagKeys, dcbEventLog, decodedStream)
+  }
+}

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

@@ -0,0 +1,104 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws from "../DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res.mjs";
+import * as DcbEventLogStorage_Postgres_Runtime$ReventlessAws from "../DcbEventLog/DcbEventLogStorage_Postgres_Runtime.res.mjs";
+import * as StateChangeSlice_CallbackResMjs from "@reventlessdev/reventless-core/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs";
+
+function deriveScope(specs) {
+  let scope = DcbTag$Reventless.deriveEffectiveScope(specs.map(s => ({
+    name: s.name,
+    commandSchema: s.commandSchema,
+    consumedEventSchema: s.consumedEventSchema,
+    eventSchema: s.eventSchema
+  })));
+  let partitionTag;
+  try {
+    partitionTag = DcbTag$Reventless.derivePartitionTag(specs.map(s => [
+      s.name,
+      Stdlib_Option.getOr(Primitive_option.fromNullable(s.moduleUrl), s.name),
+      s.eventSchema
+    ]));
+  } catch (exn) {
+    partitionTag = undefined;
+  }
+  return {
+    crossPartitionTagKeys: scope.crossPartitionTagKeys,
+    tagKeysByEventType: scope.tagKeysByEventType,
+    partitionTag: partitionTag
+  };
+}
+
+function commandTypeNames(spec) {
+  return DcbTag$Reventless.extractVariantNames(spec.commandSchema);
+}
+
+function makeDynamoStorageOps(tableName, scope) {
+  let table = {
+    id: "",
+    name: tableName,
+    arn: "",
+    hashKey: "id"
+  };
+  return {
+    read: DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.read(table, scope.crossPartitionTagKeys),
+    append: DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.append(table, scope.partitionTag, scope.crossPartitionTagKeys),
+    readStream: DcbEventLogStorage_DynamoDb_Runtime$ReventlessAws.readStream(table, scope.crossPartitionTagKeys)
+  };
+}
+
+function makePostgresStorageOps(pgConnection, logName) {
+  let match = pgConnection.lockStrategy;
+  let lockStrategy = (match == null) || match !== "RowLocks" ? "AdvisoryLocks" : "RowLocks";
+  return DcbEventLogStorage_Postgres_Runtime$ReventlessAws.opsFor(pgConnection, logName, lockStrategy);
+}
+
+function makeStorageOps(tableName, pgConnection, scope) {
+  if (pgConnection !== undefined) {
+    return makePostgresStorageOps(Primitive_option.valFromOption(pgConnection), tableName);
+  } else {
+    return makeDynamoStorageOps(tableName, scope);
+  }
+}
+
+function buildSliceHandler(spec, behavior, tagKeysByEventType, crossPartitionTagKeys, dcbEventLog) {
+  let callback = StateChangeSlice_CallbackResMjs.Make(spec)(behavior);
+  let commandSchema = spec.commandSchema;
+  return jsonStream => {
+    let decodedStream = Stream.flatMap(Stream.mapEffect(jsonStream, topicItem => Effect.sync(() => {
+      let decoded;
+      try {
+        decoded = Message$ReventlessCore.decodeCommand$p(topicItem.command, Id$Reventless.$$String.schema, commandSchema);
+      } catch (exn) {
+        return;
+      }
+      return {
+        command: decoded,
+        reference: topicItem.reference
+      };
+    })), opt => {
+      if (opt !== undefined) {
+        return Stream.fromIterable([opt]);
+      } else {
+        return Stream.empty;
+      }
+    });
+    return callback.handleCommands(tagKeysByEventType, crossPartitionTagKeys, dcbEventLog, decodedStream);
+  };
+}
+
+export {
+  deriveScope,
+  commandTypeNames,
+  makeDynamoStorageOps,
+  makePostgresStorageOps,
+  makeStorageOps,
+  buildSliceHandler,
+}
+/* Id-Reventless Not a pure module */

package/src/adapter/Runtime/QueryDbEntryPoint_Ops.res

@@ -0,0 +1,33 @@
+// Typed cold-start core shared by the QueryDb-backed entry-point shells
+// (ReadModelEntryPoint.mjs, StateViewSliceEntryPoint.mjs).
+//
+// The "typed core, thin shell" split (docs/plans/minimize-lambda-entrypoint-mjs-shell.md).
+// The DynamoDB QueryDb operations were built in each shell with seven positional
+// `load(table)` / `save(table)` / … calls into the compiled runtime, assembled
+// into an object the shell then passes to the ReadModel/StateViewSlice callback
+// functor. Typing the return as `QueryDb_Adapter.operations` makes that assembly
+// compiler-checked: a field rename/reorder or a `QueryDbStorage_DynamoDb_Runtime`
+// signature change is a build error, not a silent runtime break.
+//
+// The Postgres branch (`pgQdbOpsFor` + env-gated `withLiveUpdates`) and the
+// id-injection wrappers (`mkInjectIdSave`) stay in the shell: `pgQdbOpsFor` is
+// already a single typed call, and the wrappers/live-update publishing are
+// env-driven shell business logic, not framework-call drift.
+
+let makeDynamoQueryDbOps = (~tableName: string): ReventlessCore.QueryDb_Adapter.operations => {
+  let table: Util_DynamoDb_Runtime.resolvedTable = {
+    id: "",
+    name: tableName,
+    arn: "",
+    hashKey: "id",
+  }
+  {
+    load: QueryDbStorage_DynamoDb_Runtime.load(table),
+    loadStream: QueryDbStorage_DynamoDb_Runtime.loadStream(table),
+    save: QueryDbStorage_DynamoDb_Runtime.save(table),
+    saveBatch: QueryDbStorage_DynamoDb_Runtime.saveBatch(table),
+    count: QueryDbStorage_DynamoDb_Runtime.count(table),
+    delete: QueryDbStorage_DynamoDb_Runtime.delete(table),
+    deleteBatch: QueryDbStorage_DynamoDb_Runtime.deleteBatch(table),
+  }
+}

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

@@ -0,0 +1,26 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as QueryDbStorage_DynamoDb_Runtime$ReventlessAws from "../QueryDb/QueryDbStorage_DynamoDb_Runtime.res.mjs";
+
+function makeDynamoQueryDbOps(tableName) {
+  let table = {
+    id: "",
+    name: tableName,
+    arn: "",
+    hashKey: "id"
+  };
+  return {
+    load: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.load(table),
+    loadStream: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.loadStream(table),
+    save: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.save(table),
+    saveBatch: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.saveBatch(table),
+    count: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.count(table),
+    delete: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.$$delete(table),
+    deleteBatch: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.deleteBatch(table)
+  };
+}
+
+export {
+  makeDynamoQueryDbOps,
+}
+/* QueryDbStorage_DynamoDb_Runtime-ReventlessAws Not a pure module */

package/src/adapter/Runtime/ReadModelEntryPoint.mjs

@@ -3,10 +3,13 @@
 // wires ReadModel_Callback.Make, builds handler map keyed by source URN.
 
 import * as Effect from "effect/Effect";
-import { patchSpecId, makeTableRef, log, pluginName } from "./HandlerFactoryHelpers.mjs";
+import { patchSpecId, log, pluginName } from "./HandlerFactoryHelpers.mjs";
 import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
 import { Make as readModelCallbackMake } from "@reventlessdev/reventless-core/src/components/ReadModel/ReadModel_Callback.res.mjs";
-import { load as qdbLoad, loadStream as qdbLoadStream, save as qdbSave, saveBatch as qdbSaveBatch, count as qdbCount, $$delete as qdbDelete, deleteBatch as qdbDeleteBatch } from "@reventlessdev/reventless-aws/src/adapter/QueryDb/QueryDbStorage_DynamoDb_Runtime.res.mjs";
+// Typed cold-start core — DynamoDB QueryDb ops, compiler-checked against the
+// framework signatures (see the module header and
+// docs/plans/minimize-lambda-entrypoint-mjs-shell.md).
+import { makeDynamoQueryDbOps } from "./QueryDbEntryPoint_Ops.res.mjs";
 import { opsFor as pgQdbOpsFor } from "@reventlessdev/reventless-aws/src/adapter/QueryDb/QueryDbStorage_Postgres_Runtime.res.mjs";
 import { withLiveUpdates } from "./StateTopicPublish.mjs";
 import { handleStreamEvent } from "@reventlessdev/reventless-aws/src/adapter/EventCollector/EventCollectorChannel_DynamoDbStream_Runtime.res.mjs";
@@ -99,18 +102,13 @@ function buildReadModelHandler(specModule, mappingsModule, queryDbTableName, pgC
       saveBatch: mkInjectIdSaveBatch(livePgOps.saveBatch),
     };
   } else {
-    const table = makeTableRef(queryDbTableName);
-    const rawSave = qdbSave(table);
-    const rawSaveBatch = qdbSaveBatch(table);
-
+    // Typed core builds the 7 DynamoDB QueryDb ops; the shell keeps the id-
+    // injection wrap on save/saveBatch (business logic, not framework-call drift).
+    const base = makeDynamoQueryDbOps(queryDbTableName);
     operations = {
-      load: qdbLoad(table),
-      loadStream: qdbLoadStream(table),
-      save: mkInjectIdSave(rawSave),
-      saveBatch: mkInjectIdSaveBatch(rawSaveBatch),
-      count: qdbCount(table),
-      delete: qdbDelete(table),
-      deleteBatch: qdbDeleteBatch(table),
+      ...base,
+      save: mkInjectIdSave(base.save),
+      saveBatch: mkInjectIdSaveBatch(base.saveBatch),
     };
   }
 

package/src/adapter/Runtime/StateViewSliceEntryPoint.mjs

@@ -6,10 +6,13 @@
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
 import { parseJsonOrThrow } from "sury/src/S.res.mjs";
-import { makeTableRef, log, pluginName } from "./HandlerFactoryHelpers.mjs";
+import { log, pluginName } from "./HandlerFactoryHelpers.mjs";
 import { tag as requestContextTag } from "@reventlessdev/reventless-core/src/RequestContext.res.mjs";
 import { handleAction } from "@reventlessdev/reventless-core/src/Projection.res.mjs";
-import { load, loadStream, save, saveBatch, count, $$delete, deleteBatch } from "@reventlessdev/reventless-aws/src/adapter/QueryDb/QueryDbStorage_DynamoDb_Runtime.res.mjs";
+// Typed cold-start core — DynamoDB QueryDb ops, compiler-checked against the
+// framework signatures (see the module header and
+// docs/plans/minimize-lambda-entrypoint-mjs-shell.md).
+import { makeDynamoQueryDbOps } from "./QueryDbEntryPoint_Ops.res.mjs";
 import { opsFor as pgQdbOpsFor } from "@reventlessdev/reventless-aws/src/adapter/QueryDb/QueryDbStorage_Postgres_Runtime.res.mjs";
 import { withLiveUpdates } from "./StateTopicPublish.mjs";
 import { handleStreamEvent } from "@reventlessdev/reventless-aws/src/adapter/EventCollector/EventCollectorChannel_DynamoDbStream_Runtime.res.mjs";
@@ -62,16 +65,7 @@ export function buildJsonEventsHandler(specModule, projectionModule, queryDbTabl
       subIdField,
     });
   } else {
-    const table = makeTableRef(queryDbTableName);
-    queryDbOps = {
-      load: load(table),
-      loadStream: loadStream(table),
-      save: save(table),
-      saveBatch: saveBatch(table),
-      count: count(table),
-      delete: $$delete(table),
-      deleteBatch: deleteBatch(table),
-    };
+    queryDbOps = makeDynamoQueryDbOps(queryDbTableName);
   }
   // Spec module exports `consumedEventSchema`; the `project` function lives in
   // the sibling projection module (`<Name>_Projection.res`).

package/tests/integration/AggIntegrationHarness.res

@@ -0,0 +1,53 @@
+// Test-only harness for the Aggregate EventLog integration suite.
+//
+// Boots against a DynamoDB Local instance (see
+// `scripts/run-integration-tests.sh` + `docker-compose.dynamodb-local.yml`); the
+// production adapter's singleton DynamoDB client resolves its endpoint from
+// `AWS_ENDPOINT_URL_DYNAMODB` (set by `jest.integration.setup.cjs`).
+//
+// The aggregate EventLog table is a plain `id` (HASH) + `position` (RANGE) table
+// — no tag GSIs (that is the DCB store). Mirrors the deploy-time schema in
+// `EventLogStorage_DynamoDb.res` (`~attributes=[id, position], ~rangeKey=position`).
+
+type command
+
+@new @module("@aws-sdk/client-dynamodb")
+external createTableCommand: JSON.t => command = "CreateTableCommand"
+
+@new @module("@aws-sdk/client-dynamodb")
+external deleteTableCommand: JSON.t => command = "DeleteTableCommand"
+
+@send
+external sendRaw: (AwsSdk.DynamoDb.DynamoDb.client, command) => promise<JSON.t> = "send"
+
+let send = cmd => sendRaw(AwsSdk.DynamoDb.DynamoDb.client(), cmd)
+
+let s = JSON.Encode.string
+
+let attrDef = name =>
+  Dict.fromArray([("AttributeName", s(name)), ("AttributeType", s("S"))])->JSON.Encode.object
+
+let keyEl = (name, keyType) =>
+  Dict.fromArray([("AttributeName", s(name)), ("KeyType", s(keyType))])->JSON.Encode.object
+
+let createEventLogTable = async (tableName): Util_DynamoDb_Runtime.resolvedTable => {
+  let input =
+    Dict.fromArray([
+      ("TableName", s(tableName)),
+      ("AttributeDefinitions", [attrDef("id"), attrDef("position")]->JSON.Encode.array),
+      ("KeySchema", [keyEl("id", "HASH"), keyEl("position", "RANGE")]->JSON.Encode.array),
+      ("BillingMode", s("PAY_PER_REQUEST")),
+    ])->JSON.Encode.object
+  let _ = await send(createTableCommand(input))
+  {
+    Util_DynamoDb_Runtime.id: tableName,
+    name: tableName,
+    arn: `arn:aws:dynamodb:local:000000000000:table/${tableName}`,
+    hashKey: "id",
+  }
+}
+
+let deleteTable = async (table: Util_DynamoDb_Runtime.resolvedTable) => {
+  let input = Dict.fromArray([("TableName", s(table.name))])->JSON.Encode.object
+  let _ = await send(deleteTableCommand(input))
+}

package/tests/integration/AggIntegrationHarness.res.mjs

@@ -0,0 +1,92 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as ClientDynamodb from "@aws-sdk/client-dynamodb";
+import * as DynamoDb_DynamoDb$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DynamoDb.res.mjs";
+
+function send(cmd) {
+  return DynamoDb_DynamoDb$AwsSdk.client().send(cmd);
+}
+
+function s(prim) {
+  return prim;
+}
+
+function attrDef(name) {
+  return Object.fromEntries([
+    [
+      "AttributeName",
+      name
+    ],
+    [
+      "AttributeType",
+      "S"
+    ]
+  ]);
+}
+
+function keyEl(name, keyType) {
+  return Object.fromEntries([
+    [
+      "AttributeName",
+      name
+    ],
+    [
+      "KeyType",
+      keyType
+    ]
+  ]);
+}
+
+async function createEventLogTable(tableName) {
+  let input = Object.fromEntries([
+    [
+      "TableName",
+      tableName
+    ],
+    [
+      "AttributeDefinitions",
+      [
+        attrDef("id"),
+        attrDef("position")
+      ]
+    ],
+    [
+      "KeySchema",
+      [
+        keyEl("id", "HASH"),
+        keyEl("position", "RANGE")
+      ]
+    ],
+    [
+      "BillingMode",
+      "PAY_PER_REQUEST"
+    ]
+  ]);
+  let cmd = new ClientDynamodb.CreateTableCommand(input);
+  await DynamoDb_DynamoDb$AwsSdk.client().send(cmd);
+  return {
+    id: tableName,
+    name: tableName,
+    arn: `arn:aws:dynamodb:local:000000000000:table/` + tableName,
+    hashKey: "id"
+  };
+}
+
+async function deleteTable(table) {
+  let input = Object.fromEntries([[
+      "TableName",
+      table.name
+    ]]);
+  let cmd = new ClientDynamodb.DeleteTableCommand(input);
+  await DynamoDb_DynamoDb$AwsSdk.client().send(cmd);
+}
+
+export {
+  send,
+  s,
+  attrDef,
+  keyEl,
+  createEventLogTable,
+  deleteTable,
+}
+/* @aws-sdk/client-dynamodb Not a pure module */

package/tests/integration/AggTestAggregate.res

@@ -0,0 +1,21 @@
+// Tiny aggregate spec exercised by `AggregateEntryPoint_IntegrationTest`.
+// Standalone schema — does not depend on the example apps — so the test is
+// self-contained and the fixture's shape can drift independently of any shipped
+// aggregate. Hand-written (no `@@reventless.spec` PPX: reventless-ppx is only
+// wired into reventless-core's rescript.json, not reventless-aws's), exposing
+// exactly the fields the compiled `@@reventless.spec` output would: name, Id
+// (patched in at runtime by patchSpecId), commandSchema/eventSchema/errorSchema
+// (via sury-ppx), moduleUrl, commandAuthorization.
+
+@schema
+type command = Add({name: string})
+
+@schema
+type event = Added({name: string})
+
+@schema
+type error = AlreadyExists
+
+let name = "AggTestAggregate"
+let moduleUrl = "agg-test://AggTestAggregate"
+let commandAuthorization = (_: command): Reventless.Authorization.permission => AllowAnonymous

package/tests/integration/AggTestAggregate.res.mjs

@@ -0,0 +1,33 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+
+let commandSchema = S.schema(s => ({
+  TAG: "Add",
+  name: s.m(S.string)
+}));
+
+let eventSchema = S.schema(s => ({
+  TAG: "Added",
+  name: s.m(S.string)
+}));
+
+let errorSchema = S.literal("AlreadyExists");
+
+function commandAuthorization(param) {
+  return "AllowAnonymous";
+}
+
+let name = "AggTestAggregate";
+
+let moduleUrl = "agg-test://AggTestAggregate";
+
+export {
+  commandSchema,
+  eventSchema,
+  errorSchema,
+  name,
+  moduleUrl,
+  commandAuthorization,
+}
+/* commandSchema Not a pure module */