@reventlessdev/reventless-aws 3.0.0-alpha.232 → 3.0.0-alpha.233

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

@@ -0,0 +1,94 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+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 PgRuntime$ReventlessAws from "../Postgres/PgRuntime.res.mjs";
+import * as HandlerFactoryHelpersMjs from "./HandlerFactoryHelpers.mjs";
+import * as PgQueryResolver_Lambda$ReventlessAws from "../QueryDb/PgQueryResolver_Lambda.res.mjs";
+import * as ProjectionEntryPoint_Ops$ReventlessAws from "./ProjectionEntryPoint_Ops.res.mjs";
+import * as QueryEnginePostgres$ReventlessPostgres from "@reventlessdev/reventless-postgres/src/QueryEnginePostgres.res.mjs";
+import * as GraphQL_FragmentGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/GraphQL_FragmentGenerator.res.mjs";
+import * as QueryDbStorage_Postgres_Runtime$ReventlessAws from "../QueryDb/QueryDbStorage_Postgres_Runtime.res.mjs";
+
+function logDebug(prim0, prim1) {
+  HandlerFactoryHelpersMjs.log.debug(prim0, prim1);
+}
+
+function strOf(obj, key) {
+  return Stdlib_Option.flatMap(obj[key], Stdlib_JSON.Decode.string);
+}
+
+function decodeEntry(json) {
+  return Stdlib_Option.map(Stdlib_JSON.Decode.object(json), h => ({
+    readModelName: Stdlib_Option.getOr(strOf(h, "readModelName"), ""),
+    specModule: Stdlib_Option.getOr(strOf(h, "specModule"), ""),
+    labelField: Stdlib_Option.getOr(strOf(h, "labelField"), ""),
+    includeIdParam: Stdlib_Option.getOr(Stdlib_Option.flatMap(h["includeIdParam"], Stdlib_JSON.Decode.bool), false)
+  }));
+}
+
+function parseResolverConfig(rawJson) {
+  let obj = Stdlib_Option.getOr(Stdlib_JSON.Decode.object(JSON.parse(rawJson === "" ? `{"handlers":[]}` : rawJson)), {});
+  return {
+    pgConnection: Stdlib_Option.map(Stdlib_Option.filter(obj["pgConnection"], j => j !== null), prim => prim),
+    handlers: Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["handlers"], Stdlib_JSON.Decode.array), []), decodeEntry),
+    nodeTypes: Object.fromEntries(Stdlib_Array.filterMap(Object.entries(Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["nodeTypes"], Stdlib_JSON.Decode.object), {})), param => {
+      let k = param[0];
+      return Stdlib_Option.map(Stdlib_JSON.Decode.string(param[1]), s => [
+        k,
+        s
+      ]);
+    }))
+  };
+}
+
+function registerNodeTypes(config) {
+  Object.entries(config.nodeTypes).forEach(param => PgQueryResolver_Lambda$ReventlessAws.registerNodeType(param[0], param[1]));
+}
+
+function makePushdowns(pgConnection) {
+  let pool = PgRuntime$ReventlessAws.poolFor(pgConnection);
+  let Engine = QueryEnginePostgres$ReventlessPostgres.Make({
+    pool: pool
+  });
+  return {
+    indexLookup: Engine.indexLookup,
+    byIds: Engine.byIds,
+    listPage: Engine.listPage,
+    itemsPage: Engine.itemsPage,
+    scanAll: readModelName => Engine.scan(readModelName, [], 100000)
+  };
+}
+
+function registerBinding(pushdowns, pgConnection, entry, spec) {
+  let indexes = ProjectionEntryPoint_Ops$ReventlessAws.indexesOf(spec.config);
+  let subIdField = ProjectionEntryPoint_Ops$ReventlessAws.subIdFieldOf(spec.subIdConfig);
+  PgQueryResolver_Lambda$ReventlessAws.register(entry.readModelName, {
+    ops: QueryDbStorage_Postgres_Runtime$ReventlessAws.opsFor(pgConnection, entry.readModelName, indexes, subIdField),
+    pushdowns: pushdowns,
+    indexes: indexes,
+    subIdField: subIdField,
+    capability: GraphQL_FragmentGenerator$ReventlessCore.deriveServerCapability(spec.stateSchema),
+    labelField: entry.labelField,
+    includeIdParam: entry.includeIdParam,
+    authorization: spec.authorization
+  });
+  HandlerFactoryHelpersMjs.log.debug("registered resolver binding for " + entry.readModelName, {
+    comp: "PgQueryResolver"
+  });
+}
+
+let scanAllLimit = 100000;
+
+export {
+  logDebug,
+  strOf,
+  decodeEntry,
+  parseResolverConfig,
+  registerNodeTypes,
+  scanAllLimit,
+  makePushdowns,
+  registerBinding,
+}
+/* PgRuntime-ReventlessAws Not a pure module */

package/src/adapter/Runtime/ProjectionEntryPoint_Ops.res

@@ -0,0 +1,80 @@
+// Typed QueryDb-assembly core shared by the two projection Lambda entry points
+// (ReadModelEntryPoint.mjs, StateViewSliceEntryPoint.mjs).
+//
+// The "typed core, thin shell" split (docs/plans/minimize-lambda-entrypoint-mjs-shell.md):
+// both shells build the QueryDb operation set (DynamoDB or Postgres, live-update
+// wrapped) for each projection from spec-module reads; that machinery lives
+// here, fully type-checked. The routed dispatch boundary they share (with the
+// AutomationSlice entry point, which has no Postgres backend) lives in
+// StreamRoutedEntryPoint_Ops — kept separate so this module's `pg`/PgRuntime
+// imports stay out of the graphs that only need dispatch.
+//
+// Deliberately NOT folded into QueryDbEntryPoint_Ops: that module is also
+// imported by DcbCommandTopicEntryPoint.mjs, and the Postgres branch here
+// would drag `pg`/PgRuntime into the DCB command Lambda's cold-start graph.
+//
+// Runtime-pure: no `open PulumiAws` values — Pulumi appears in type positions
+// only (erased).
+
+@val @scope("process") external processEnv: dict<string> = "env"
+
+// ── Runtime-loaded spec-module reads (typed at the seam) ────────────────────
+// The shells read `config` / `subIdConfig` off dynamically imported spec
+// modules; these are the shapes those reads are typed against. `indexes` is
+// optional so a module whose `config` lacks the field degrades to `[]` exactly
+// as the former JS `(config && config.indexes) || []` did.
+
+type specConfig = {indexes?: array<Reventless.ReadModel.indexConfig>}
+
+let indexesOf = (config: option<specConfig>): array<Reventless.ReadModel.indexConfig> =>
+  config->Option.flatMap(c => c.indexes)->Option.getOr([])
+
+let subIdFieldOf = (
+  subIdConfig: option<Reventless.ReadModel.subIdConfig<JSON.t>>,
+): option<string> => subIdConfig->Option.map(c => c.subIdField)
+
+// ── QueryDb operations (DynamoDB / Postgres backend branch) ─────────────────
+// `pgConnection`, when present, selects the Postgres QueryDb runtime for the
+// projection's view table (`queryDbTableName` is then the spec name, the shared
+// `qdb_<name>` discriminator). Absent → the DynamoDB operation set.
+//
+// On a subscription-enabled (Stream) Postgres projection, every save/delete
+// also publishes a live-update descriptor (no DynamoDB stream exists).
+// `stateTopicName` (present only for stream projections) + APPSYNC_ENDPOINT
+// gate it; absent → withLiveUpdates returns the ops unchanged.
+
+type liveConfig = {
+  endpoint?: string,
+  region?: string,
+  topicName?: string,
+  subIdField?: string,
+}
+
+@module("./StateTopicPublish.mjs")
+external withLiveUpdates: (
+  ReventlessCore.QueryDb_Adapter.operations,
+  liveConfig,
+) => ReventlessCore.QueryDb_Adapter.operations = "withLiveUpdates"
+
+let makeQueryDbOps = (
+  ~queryDbTableName: string,
+  ~pgConnection: option<PgConnection.connectionConfig>,
+  ~stateTopicName: option<string>,
+  ~indexes: array<Reventless.ReadModel.indexConfig>,
+  ~subIdField: option<string>,
+): ReventlessCore.QueryDb_Adapter.operations =>
+  switch pgConnection {
+  | Some(connection) =>
+    QueryDbStorage_Postgres_Runtime.opsFor(
+      connection,
+      ~name=queryDbTableName,
+      ~indexes,
+      ~subIdField?,
+    )->withLiveUpdates({
+      endpoint: ?(processEnv->Dict.get("APPSYNC_ENDPOINT")),
+      region: ?(processEnv->Dict.get("AWS_REGION")),
+      topicName: ?stateTopicName,
+      subIdField: ?subIdField,
+    })
+  | None => QueryDbEntryPoint_Ops.makeDynamoQueryDbOps(~tableName=queryDbTableName)
+  }

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

@@ -0,0 +1,39 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as StateTopicPublishMjs from "./StateTopicPublish.mjs";
+import * as QueryDbEntryPoint_Ops$ReventlessAws from "./QueryDbEntryPoint_Ops.res.mjs";
+import * as QueryDbStorage_Postgres_Runtime$ReventlessAws from "../QueryDb/QueryDbStorage_Postgres_Runtime.res.mjs";
+
+function indexesOf(config) {
+  return Stdlib_Option.getOr(Stdlib_Option.flatMap(config, c => c.indexes), []);
+}
+
+function subIdFieldOf(subIdConfig) {
+  return Stdlib_Option.map(subIdConfig, c => c.subIdField);
+}
+
+function withLiveUpdates(prim0, prim1) {
+  return StateTopicPublishMjs.withLiveUpdates(prim0, prim1);
+}
+
+function makeQueryDbOps(queryDbTableName, pgConnection, stateTopicName, indexes, subIdField) {
+  if (pgConnection !== undefined) {
+    return StateTopicPublishMjs.withLiveUpdates(QueryDbStorage_Postgres_Runtime$ReventlessAws.opsFor(pgConnection, queryDbTableName, indexes, subIdField), {
+      endpoint: process.env["APPSYNC_ENDPOINT"],
+      region: process.env["AWS_REGION"],
+      topicName: stateTopicName,
+      subIdField: subIdField
+    });
+  } else {
+    return QueryDbEntryPoint_Ops$ReventlessAws.makeDynamoQueryDbOps(queryDbTableName);
+  }
+}
+
+export {
+  indexesOf,
+  subIdFieldOf,
+  withLiveUpdates,
+  makeQueryDbOps,
+}
+/* ./StateTopicPublish.mjs Not a pure module */

package/src/adapter/Runtime/QueryDbEntryPoint_Ops.res

@@ -9,10 +9,10 @@
 // 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.
+// The Postgres branch and the id-injection wrappers live in
+// ProjectionEntryPoint_Ops / ReadModelEntryPoint_Ops — NOT here, because this
+// module is also imported by DcbCommandTopicEntryPoint.mjs, which must not
+// carry `pg`/PgRuntime in its cold-start graph.
 
 let makeDynamoQueryDbOps = (~tableName: string): ReventlessCore.QueryDb_Adapter.operations => {
   let table: Util_DynamoDb_Runtime.resolvedTable = {

package/src/adapter/Runtime/ReadModelEntryPoint.mjs

@@ -1,47 +1,25 @@
 // ReadModel Lambda entry point.
 // At cold start: reads HANDLER_CONFIG, dynamically imports Spec/Mappings modules,
 // wires ReadModel_Callback.Make, builds handler map keyed by source URN.
-
-import {
-  patchSpecId,
-  log,
-  runEffect,
-  setRequestId,
-  extractMetaField,
-  extractSentTimestamp,
-  extractRetryCount,
-} from "./HandlerFactoryHelpers.mjs";
+//
+// Thin untyped shell ("typed core, thin shell" —
+// docs/plans/minimize-lambda-entrypoint-mjs-shell.md): this file owns ONLY the
+// seams that are inherently untyped — the dynamic `import()` of spec/mappings
+// modules named in HANDLER_CONFIG, the shape fix-ups on those runtime-loaded
+// modules (patchSpecId / fixMappingsModule), and the ReadModel_Callback.Make
+// functor application consuming them. Everything else (HANDLER_CONFIG parsing,
+// the QueryDb operation assembly incl. the id-injection wrap and the
+// Postgres / live-update branch, handler registration, the routed dispatch
+// boundary) lives type-checked in ReadModelEntryPoint_Ops.res /
+// ProjectionEntryPoint_Ops.res / StreamRoutedEntryPoint_Ops.res.
+
+import { patchSpecId } from "./HandlerFactoryHelpers.mjs";
 import { Make as readModelCallbackMake } from "@reventlessdev/reventless-core/src/components/ReadModel/ReadModel_Callback.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";
+import * as StreamOps from "./StreamRoutedEntryPoint_Ops.res.mjs";
+import * as Ops from "./ReadModelEntryPoint_Ops.res.mjs";
 
 const dynamicImport = (specifier) => import('/var/task/node_modules/' + specifier);
 
-// Inject 'id' key into saved state objects
-function mkInjectIdSave(rawSave) {
-  return (id, state, saveMode, ttl) => {
-    const injected = (state && typeof state === "object" && !Array.isArray(state))
-      ? { ...state, id }
-      : state;
-    return rawSave(id, injected, saveMode, ttl);
-  };
-}
-
-function mkInjectIdSaveBatch(rawSaveBatch) {
-  return (items) =>
-    rawSaveBatch(items.map(([id, state, ttl]) => {
-      const injected = (state && typeof state === "object" && !Array.isArray(state))
-        ? { ...state, id }
-        : state;
-      return [id, injected, ttl];
-    }));
-}
-
 // Fix mappings module: ensure it has a `mappings` array
 function fixMappingsModule(mod) {
   if (mod.mappings) return mod;
@@ -54,126 +32,29 @@ function fixMappingsModule(mod) {
   return mod;
 }
 
-function groupBySource(records) {
-  const dict = {};
-  records.forEach(record => {
-    const arn = record.eventSourceARN;
-    const existing = dict[arn] || [];
-    dict[arn] = existing.concat([record]);
-  });
-  return dict;
-}
-
-// `pgConnection`, when present, is the resolved PgConnection.connectionConfig the
-// runtime builder injected for a Postgres-backed read model: bind the Postgres
-// operation set (queryDbTableName is then the read-model spec name, the shared
-// `qdb_<name>` discriminator). Absent → the DynamoDB path is byte-identical.
-function buildReadModelHandler(specModule, mappingsModule, queryDbTableName, pgConnection, stateTopicName) {
-  const patchedSpec = patchSpecId(specModule);
-  let operations;
-  if (pgConnection) {
-    const indexes = (patchedSpec.config && patchedSpec.config.indexes) || [];
-    const subIdField = patchedSpec.subIdConfig ? patchedSpec.subIdConfig.subIdField : undefined;
-    const pgOps = pgQdbOpsFor(pgConnection, queryDbTableName, indexes, subIdField);
-    // B3.3: on a subscription-enabled (Stream) Postgres read model, publish a
-    // live-update descriptor after each save/delete (no DynamoDB stream exists).
-    // `stateTopicName` (present only for stream RMs) + APPSYNC_ENDPOINT gate it;
-    // absent → withLiveUpdates returns pgOps unchanged. Wrap BEFORE mkInjectIdSave
-    // so the publish sees the id-injected state (id, subId, updatedAt).
-    const livePgOps = withLiveUpdates(pgOps, {
-      endpoint: process.env.APPSYNC_ENDPOINT,
-      region: process.env.AWS_REGION,
-      topicName: stateTopicName,
-      subIdField,
-    });
-    operations = {
-      ...livePgOps,
-      save: mkInjectIdSave(livePgOps.save),
-      saveBatch: mkInjectIdSaveBatch(livePgOps.saveBatch),
-    };
-  } else {
-    // 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 = {
-      ...base,
-      save: mkInjectIdSave(base.save),
-      saveBatch: mkInjectIdSaveBatch(base.saveBatch),
-    };
-  }
-
-  const effectiveMappings = fixMappingsModule(mappingsModule);
-  const callback = readModelCallbackMake(patchedSpec)(effectiveMappings)({
-    ReadModelSpec: patchedSpec,
-    operations,
-  });
-
-  return (event, context) => handleStreamEvent(callback.handleJsonEvents, event, context);
-}
-
 async function buildAllHandlers() {
-  const configStr = process.env["HANDLER_CONFIG"] || '{"handlers":[]}';
-  const config = JSON.parse(configStr);
   const handlers = {};
-
-  await Promise.all(config.handlers.map(async h => {
-    const specModule = await dynamicImport(h.specModule);
-    const mappingsModule = await dynamicImport(h.mappingsModule);
-    const handler = buildReadModelHandler(specModule, mappingsModule, h.queryDbTableName, h.pgConnection, h.stateTopicName);
-    // `comp` / `plugin` are resolved at deploy time and baked into
-    // HANDLER_CONFIG (EventCollectorRuntime_Builder_Single) so the shell doesn't
-    // re-derive component identity from module paths, and so the string matches
-    // the ReScript dispatch boundary's `EventCollector(<Name>)` byte for byte.
-    // Kept next to the handler: this Lambda hosts every read model, so the comp
-    // is what separates their log lines.
-    const registered = { handler, comp: h.comp, plugin: h.plugin };
-    // Multiple read models can share one source stream — e.g. every admin read
-    // model (Plugins, PluginHistory, PlatformEventGraph, UIFragmentRegistry)
-    // projects the Plugin aggregate's EventLog stream. Accumulate ALL handlers
-    // per source ARN; a plain `handlers[urn] = handler` collapses them to one
-    // (whichever async builder wins the Promise.all race), silently dropping the
-    // rest — which leaves their QueryDbs empty.
-    (handlers[h.sourceUrn] ||= []).push(registered);
+  const entries = Ops.parseHandlerConfig(process.env["HANDLER_CONFIG"] || "");
+
+  await Promise.all(entries.map(async (entry) => {
+    const specModule = patchSpecId(await dynamicImport(entry.specModule));
+    const mappingsModule = fixMappingsModule(await dynamicImport(entry.mappingsModule));
+    const operations = Ops.buildOperations(entry, {
+      config: specModule.config,
+      subIdConfig: specModule.subIdConfig,
+    });
+    const callback = readModelCallbackMake(specModule)(mappingsModule)({
+      ReadModelSpec: specModule,
+      operations,
+    });
+    StreamOps.addToRegistry(
+      handlers,
+      entry.sourceUrn,
+      Ops.makeRegisteredHandler(entry, callback.handleJsonEvents)
+    );
   }));
 
   return handlers;
 }
 
-const initPromise = buildAllHandlers();
-
-export async function handler(event, context) {
-  setRequestId(context?.awsRequestId);
-  const handlers = await initPromise;
-  const records = event.Records || [];
-  const grouped = groupBySource(records);
-
-  await Promise.all(Object.entries(grouped).map(async ([arn, subRecords]) => {
-    const streamHandlers = handlers[arn];
-    if (streamHandlers !== undefined && streamHandlers.length > 0) {
-      log.debug("found " + streamHandlers.length + " handler(s) for " + arn, { comp: "ReadModelRuntime" });
-      const correlationId = extractMetaField(subRecords, "correlationId");
-      const causationId = extractMetaField(subRecords, "causationId");
-      const timestamp = extractSentTimestamp(subRecords);
-      const retryCount = extractRetryCount(subRecords);
-      // Run every read model registered for this source stream (independent
-      // QueryDbs, so concurrent is safe). Each carries its own comp so the
-      // shared Lambda's log lines stay separable per read model.
-      await Promise.all(
-        streamHandlers.map(({ handler: streamHandler, comp, plugin }) =>
-          runEffect(streamHandler({ Records: subRecords }, context), {
-            correlationId,
-            causationId,
-            comp,
-            plugin,
-            timestamp,
-            retryCount,
-          })
-        )
-      );
-    } else {
-      log.warn("no handler found: " + arn, { comp: "ReadModelRuntime" });
-    }
-  }));
-
-  return "";
-}
+export const handler = StreamOps.makeRoutedHandler("ReadModelRuntime", buildAllHandlers());

package/src/adapter/Runtime/ReadModelEntryPoint_Ops.res

@@ -0,0 +1,114 @@
+// Typed cold-start core for the ReadModel Lambda entry point.
+//
+// The "typed core, thin shell" split (docs/plans/minimize-lambda-entrypoint-mjs-shell.md):
+// ReadModelEntryPoint.mjs keeps only the untyped seams — the dynamic `import()`
+// of spec/mappings modules named in HANDLER_CONFIG, the `patchSpecId` /
+// `fixMappingsModule` shape fix-ups on those runtime-loaded modules, and the
+// ReadModel_Callback.Make functor application consuming them. HANDLER_CONFIG
+// parsing, the QueryDb operation assembly (including the id-injection wrap),
+// and handler registration live here, fully type-checked; the QueryDb backend
+// branch is shared with the StateViewSlice entry point in
+// ProjectionEntryPoint_Ops and the routed dispatch boundary lives in
+// StreamRoutedEntryPoint_Ops.
+
+type handlerEntry = {
+  specModule: string,
+  mappingsModule: string,
+  queryDbTableName: string,
+  sourceUrn: string,
+  // Resolved at deploy time and baked into HANDLER_CONFIG
+  // (EventCollectorRuntime_Builder_Single) so the shell doesn't re-derive
+  // component identity from module paths, and so the string matches the
+  // ReScript dispatch boundary's `EventCollector(<Name>)` byte for byte. This
+  // Lambda hosts every read model, so the comp is what separates their log
+  // lines; the plugin beats the Lambda-name-derived fallback in runEffect.
+  comp: option<string>,
+  plugin: option<string>,
+  pgConnection: option<PgConnection.connectionConfig>,
+  stateTopicName: option<string>,
+}
+
+// The builder writes `pgConnection` via PgConnection.connectionConfigToJson, so
+// the parsed object IS the record shape — cast at the documented JSON contract
+// (the AggregateEntryPoint_Ops.asConnectionConfig pattern).
+external asPgConnection: JSON.t => PgConnection.connectionConfig = "%identity"
+
+let strOf = (obj: dict<JSON.t>, key: string): option<string> =>
+  obj->Dict.get(key)->Option.flatMap(JSON.Decode.string)
+
+let decodeEntry = (json: JSON.t): option<handlerEntry> =>
+  json
+  ->JSON.Decode.object
+  ->Option.map(h => {
+    specModule: h->strOf("specModule")->Option.getOr(""),
+    mappingsModule: h->strOf("mappingsModule")->Option.getOr(""),
+    queryDbTableName: h->strOf("queryDbTableName")->Option.getOr(""),
+    sourceUrn: h->strOf("sourceUrn")->Option.getOr(""),
+    comp: h->strOf("comp"),
+    plugin: h->strOf("plugin"),
+    pgConnection: h
+    ->Dict.get("pgConnection")
+    ->Option.filter(j => j != JSON.Null)
+    ->Option.map(asPgConnection),
+    stateTopicName: h->strOf("stateTopicName"),
+  })
+
+let parseHandlerConfig = (rawJson: string): array<handlerEntry> =>
+  rawJson == ""
+    ? []
+    : rawJson
+      ->JSON.parseOrThrow
+      ->JSON.Decode.object
+      ->Option.flatMap(obj => obj->Dict.get("handlers"))
+      ->Option.flatMap(JSON.Decode.array)
+      ->Option.getOr([])
+      ->Array.filterMap(decodeEntry)
+
+// ── QueryDb operations with id injection ────────────────────────────────────
+// Saved read-model states get an `id` key injected (query resolvers and the
+// live-update publisher read it off the row). Applied OUTSIDE the live-update
+// wrap so the publish sees the id-injected state (id, subId, updatedAt).
+
+let injectId = (id: string, state: JSON.t): JSON.t =>
+  switch state {
+  | Object(fields) =>
+    let injected = fields->Dict.copy
+    injected->Dict.set("id", JSON.String(id))
+    JSON.Object(injected)
+  | other => other
+  }
+
+let withInjectedId = (
+  base: ReventlessCore.QueryDb_Adapter.operations,
+): ReventlessCore.QueryDb_Adapter.operations => {
+  ...base,
+  save: (id, state, saveMode, ttl) => base.save(id, injectId(id, state), saveMode, ttl),
+  saveBatch: items =>
+    base.saveBatch(items->Array.map(((id, state, ttl)) => (id, injectId(id, state), ttl))),
+}
+
+type specInfo = {
+  config: option<ProjectionEntryPoint_Ops.specConfig>,
+  subIdConfig: option<Reventless.ReadModel.subIdConfig<JSON.t>>,
+}
+
+let buildOperations = (
+  entry: handlerEntry,
+  spec: specInfo,
+): ReventlessCore.QueryDb_Adapter.operations =>
+  ProjectionEntryPoint_Ops.makeQueryDbOps(
+    ~queryDbTableName=entry.queryDbTableName,
+    ~pgConnection=entry.pgConnection,
+    ~stateTopicName=entry.stateTopicName,
+    ~indexes=ProjectionEntryPoint_Ops.indexesOf(spec.config),
+    ~subIdField=ProjectionEntryPoint_Ops.subIdFieldOf(spec.subIdConfig),
+  )->withInjectedId
+
+let makeRegisteredHandler = (
+  entry: handlerEntry,
+  handleJsonEvents: ReventlessCore.EventCollector.jsonEventsHandler,
+): StreamRoutedEntryPoint_Ops.registeredHandler => {
+  handler: StreamRoutedEntryPoint_Ops.toStreamHandler(handleJsonEvents),
+  comp: ?entry.comp,
+  plugin: ?entry.plugin,
+}

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

@@ -0,0 +1,83 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+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 ProjectionEntryPoint_Ops$ReventlessAws from "./ProjectionEntryPoint_Ops.res.mjs";
+import * as StreamRoutedEntryPoint_Ops$ReventlessAws from "./StreamRoutedEntryPoint_Ops.res.mjs";
+
+function strOf(obj, key) {
+  return Stdlib_Option.flatMap(obj[key], Stdlib_JSON.Decode.string);
+}
+
+function decodeEntry(json) {
+  return Stdlib_Option.map(Stdlib_JSON.Decode.object(json), h => ({
+    specModule: Stdlib_Option.getOr(strOf(h, "specModule"), ""),
+    mappingsModule: Stdlib_Option.getOr(strOf(h, "mappingsModule"), ""),
+    queryDbTableName: Stdlib_Option.getOr(strOf(h, "queryDbTableName"), ""),
+    sourceUrn: Stdlib_Option.getOr(strOf(h, "sourceUrn"), ""),
+    comp: strOf(h, "comp"),
+    plugin: strOf(h, "plugin"),
+    pgConnection: Stdlib_Option.map(Stdlib_Option.filter(h["pgConnection"], j => j !== null), prim => prim),
+    stateTopicName: strOf(h, "stateTopicName")
+  }));
+}
+
+function parseHandlerConfig(rawJson) {
+  if (rawJson === "") {
+    return [];
+  } else {
+    return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(JSON.parse(rawJson)), obj => obj["handlers"]), Stdlib_JSON.Decode.array), []), decodeEntry);
+  }
+}
+
+function injectId(id, state) {
+  if (typeof state !== "object" || state === null || Array.isArray(state)) {
+    return state;
+  }
+  let injected = Object.assign({}, state);
+  injected["id"] = id;
+  return injected;
+}
+
+function withInjectedId(base) {
+  return {
+    load: base.load,
+    loadStream: base.loadStream,
+    save: (id, state, saveMode, ttl) => base.save(id, injectId(id, state), saveMode, ttl),
+    saveBatch: items => base.saveBatch(items.map(param => {
+      let id = param[0];
+      return [
+        id,
+        injectId(id, param[1]),
+        param[2]
+      ];
+    })),
+    count: base.count,
+    delete: base.delete,
+    deleteBatch: base.deleteBatch
+  };
+}
+
+function buildOperations(entry, spec) {
+  return withInjectedId(ProjectionEntryPoint_Ops$ReventlessAws.makeQueryDbOps(entry.queryDbTableName, entry.pgConnection, entry.stateTopicName, ProjectionEntryPoint_Ops$ReventlessAws.indexesOf(spec.config), ProjectionEntryPoint_Ops$ReventlessAws.subIdFieldOf(spec.subIdConfig)));
+}
+
+function makeRegisteredHandler(entry, handleJsonEvents) {
+  return {
+    handler: StreamRoutedEntryPoint_Ops$ReventlessAws.toStreamHandler(handleJsonEvents),
+    comp: entry.comp,
+    plugin: entry.plugin
+  };
+}
+
+export {
+  strOf,
+  decodeEntry,
+  parseHandlerConfig,
+  injectId,
+  withInjectedId,
+  buildOperations,
+  makeRegisteredHandler,
+}
+/* ProjectionEntryPoint_Ops-ReventlessAws Not a pure module */