@reventlessdev/reventless-aws 3.0.0-alpha.176 → 3.0.0-alpha.178

package/src/adapter/QueryDb/QueryDbBackend.res.mjs

@@ -32,6 +32,8 @@ function isPostgres() {
   return Stdlib_Option.isSome(selectionRef.contents);
 }
 
+let postgresStreamRegistry = new Set();
+
 export {
   selectionRef,
   set,
@@ -40,5 +42,6 @@ export {
   exempt,
   isPostgresFor,
   isPostgres,
+  postgresStreamRegistry,
 }
-/* No side effect */
+/* postgresStreamRegistry Not a pure module */

package/src/adapter/QueryDb/QueryDbResolvers.res

@@ -1,10 +1,11 @@
 module AppSync = QueryDbResolvers_AppSync
 module NoOp = QueryDbResolvers_NoOp
+module Lambda = QueryDbResolvers_Lambda
 
-// B3.1: Postgres-backed read models have no DynamoDB data source — suppress the
-// direct AppSync resolvers (their GraphQL fields stay unresolved until B3.2's
-// Lambda data source). DynamoDB-backed (incl. admin-exempt) read models keep the
-// full resolver set.
+// B3.2b: Postgres-backed read models have no DynamoDB data source — their
+// GraphQL Query fields are served by the shared PgQueryResolver Lambda data
+// source (`QueryDbResolvers_Lambda`, Invoke templates → PgQueryResolver_Lambda).
+// DynamoDB-backed (incl. admin-exempt) read models keep the direct resolver set.
 module Selectable = {
   type api = QueryDbResolvers_AppSync_NoOp.api
   type role = QueryDbResolvers_AppSync_NoOp.role
@@ -21,7 +22,7 @@ module Selectable = {
     ~opts,
   ) =>
     if QueryDbBackend.isPostgresFor(name) {
-      QueryDbResolvers_AppSync_NoOp.make(
+      QueryDbResolvers_Lambda.make(
         ~name,
         ~api,
         ~apiRole,

package/src/adapter/QueryDb/QueryDbResolvers.res.mjs

@@ -1,12 +1,12 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as QueryDbBackend$ReventlessAws from "./QueryDbBackend.res.mjs";
+import * as QueryDbResolvers_Lambda$ReventlessAws from "./QueryDbResolvers_Lambda.res.mjs";
 import * as QueryDbResolvers_AppSync$ReventlessAws from "./QueryDbResolvers_AppSync.res.mjs";
-import * as QueryDbResolvers_AppSync_NoOp$ReventlessAws from "./QueryDbResolvers_AppSync_NoOp.res.mjs";
 
 function make(name, api, apiRole, dataSourceName, indexes, subIdField, idResolverConfigs, idsResolverConfigs, authorization, opts) {
   if (QueryDbBackend$ReventlessAws.isPostgresFor(name)) {
-    return QueryDbResolvers_AppSync_NoOp$ReventlessAws.make(name, api, apiRole, dataSourceName, indexes, subIdField, idResolverConfigs, idsResolverConfigs, authorization, opts);
+    return QueryDbResolvers_Lambda$ReventlessAws.make(name, api, apiRole, dataSourceName, indexes, subIdField, idResolverConfigs, idsResolverConfigs, authorization, opts);
   } else {
     return QueryDbResolvers_AppSync$ReventlessAws.make(name, api, apiRole, dataSourceName, indexes, subIdField, idResolverConfigs, idsResolverConfigs, authorization, opts);
   }
@@ -20,9 +20,12 @@ let AppSync;
 
 let NoOp;
 
+let Lambda;
+
 export {
   AppSync,
   NoOp,
+  Lambda,
   Selectable,
 }
-/* QueryDbResolvers_AppSync-ReventlessAws Not a pure module */
+/* QueryDbBackend-ReventlessAws Not a pure module */

package/src/adapter/QueryDb/QueryDbResolvers_Lambda.res

@@ -0,0 +1,288 @@
+// AppSync resolvers for Postgres-backed read models (B3.2b) — the Lambda-data-
+// source parallel to QueryDbResolvers_AppSync's direct DynamoDB resolvers.
+//
+// Every Query field becomes a thin APPSYNC_JS unit resolver whose `Invoke`
+// template carries { readModelName, kind, index?, arguments, identity } to the
+// ONE shared PgQueryResolver Lambda (PgQueryResolver_Builder), which dispatches
+// via PgQueryResolver_Lambda.dispatch. `dataSourceName` is the shared data
+// source's (deferred) name, the same for every Postgres read model.
+//
+// Field names / includeIdParam / connectionSpec come from the same registry the
+// AppSync path reads, so the SDL emitted by GraphQL_FragmentGenerator stays in
+// lockstep. Kinds covered: getById, list (connection), index, byIds. Deferred to
+// B3.2c: items (sub-id connection), @resolves/@resolvesMany, node, auth-table.
+
+module Resolver = AppSync_Resolver_Retrying
+open Reventless.ReadModel
+
+type api = Types.AppSync.api
+type role = Types.AppSync.role
+
+// Identity block shared by every Invoke template (Cognito vs IAM), matching the
+// shape PgQueryResolver_Lambda decodes (Reventless.Identity.t).
+let identityBlock = `id != null && id.sub != null
+      ? { userId: id.sub, username: id.username, groups: id.claims?.['cognito:groups'] ?? [], claims: id.claims, provider: 'Cognito' }
+      : id != null
+        ? { userArn: id.userArn ?? null, accountId: id.accountId ?? null, username: id.username ?? null, provider: 'IAM' }
+        : null`
+
+let invokeTemplate = (
+  ~readModelName: string,
+  ~kind: string,
+  ~index: option<string>=?,
+  ~authTable: option<string>=?,
+  ~authGroup: option<string>=?,
+) => {
+  let indexFrag = switch index {
+  | Some(ix) => `\n      index: '${ix}',`
+  | None => ""
+  }
+  let authFrag = switch (authTable, authGroup) {
+  | (Some(t), Some(g)) => `\n      authTable: '${t}',\n      authGroup: '${g}',`
+  | _ => ""
+  }
+  `import { util } from '@aws-appsync/utils';
+export function request(ctx) {
+  const id = ctx.identity;
+  return {
+    operation: 'Invoke',
+    payload: {
+      readModelName: '${readModelName}',
+      kind: '${kind}',${indexFrag}${authFrag}
+      arguments: ctx.args,
+      identity: ${identityBlock}
+    }
+  };
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  return ctx.result;
+}
+`->Pulumi.Input.make
+}
+
+// Cross-table field resolver (@resolves/@resolvesMany, B3.2c): on a parent
+// entity type's field, carrying the parent object (ctx.source) + baked target
+// metadata (`extra`). `sourceType` is the parent read model (used only for auth
+// scoping in dispatch); `target` is the target read model's binding key.
+let invokeFieldTemplate = (~sourceType: string, ~kind: string, ~target: string, ~extra: string) =>
+  `import { util } from '@aws-appsync/utils';
+export function request(ctx) {
+  const id = ctx.identity;
+  return {
+    operation: 'Invoke',
+    payload: {
+      readModelName: '${sourceType}',
+      kind: '${kind}',
+      target: '${target}',
+      source: ctx.source,
+      arguments: ctx.args,${extra}
+      identity: ${identityBlock}
+    }
+  };
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  return ctx.result;
+}
+`->Pulumi.Input.make
+
+let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
+  ~name: string,
+  ~api: api,
+  ~apiRole as _: role,
+  ~dataSourceName,
+  ~indexes: array<indexConfig>,
+  ~subIdField,
+  ~idResolverConfigs: array<idResolverConfig>,
+  ~idsResolverConfigs: array<idsResolverConfig>,
+  ~authorization as _: Reventless.Authorization.permission,
+  ~opts,
+) => {
+  let dataSourceName = dataSourceName->Pulumi.Output.asInput
+  let name = name->String.capitalize
+  let registryEntry = ReventlessCore.Plugin_Helpers.queryFieldNamesRegistry->Dict.get(name)
+
+  let fieldNameForSingle = switch registryEntry {
+  | Some({singleFieldName}) => singleFieldName
+  | None => name->Resolver.Functions.uncapitalize
+  }
+  let includeIdParam = switch registryEntry {
+  | Some({includeIdParam}) => includeIdParam
+  | None => true
+  }
+  let connectionSpec = switch registryEntry {
+  | Some({connectionSpec}) => connectionSpec
+  | None => true
+  }
+  let fieldNameForAll = switch registryEntry {
+  | Some({listFieldName}) => listFieldName
+  | None => name ++ "s"
+  }
+  let labelField = switch registryEntry {
+  | Some({labelField: ?lf}) => lf->Option.getOr("id")
+  | None => "id"
+  }
+  let returnTypeName = switch registryEntry {
+  | Some({returnTypeName: rt}) => rt
+  | None => name
+  }
+
+  // Register the binding info the shared Lambda's env config needs (the entry
+  // point gets indexes/subIdField/schema from the spec module; labelField and
+  // includeIdParam come from this deploy-time registry). Keyed by spec name.
+  PgQueryResolver_Builder.register({readModelName: name, labelField, includeIdParam})
+
+  // Relay node type → this read model (for the shared node(id) resolver, B3.2c).
+  // Only entities addressable by id participate in node resolution.
+  if includeIdParam {
+    PgQueryResolver_Builder.registerNodeType(~typeName=returnTypeName, ~readModelName=name)
+  }
+
+  let mkResolver = (~resolverName, ~field, ~kind, ~index=?, ~authTable=?, ~authGroup=?) =>
+    Resolver.makeUnitJsResolver(
+      ~name=resolverName,
+      ~api,
+      ~dataSourceName,
+      ~type_="Query"->Pulumi.Input.make,
+      ~field=field->Pulumi.Input.make,
+      ~code=invokeTemplate(~readModelName=name, ~kind, ~index?, ~authTable?, ~authGroup?),
+      ~opts,
+    )
+
+  let stripLeadingBy = s =>
+    if s->String.startsWith("by") && s->String.length > 2 {
+      s->String.slice(~start=2, ~end=s->String.length)
+    } else {
+      s
+    }
+
+  // Resolvers are deferred into resourcesMaker (created inside the schema-pushed
+  // builderOutputs.apply, like the AppSync path) — so they only exist after the
+  // fields are ACTIVE and after PgQueryResolver_Builder.provision has resolved
+  // the shared data source name.
+  let resourcesMaker: ReventlessCore.QueryDb.resolversResourcesMaker = _allQueryDbs => {
+    // getById (or listAll when the read model has no id param, e.g. singletons).
+    let byId = mkResolver(
+      ~resolverName=fieldNameForSingle->String.capitalize,
+      ~field=fieldNameForSingle,
+      ~kind=includeIdParam ? "getById" : "list",
+    )
+
+    // Main list — Relay connection (or legacy list when connectionSpec=false).
+    let all = mkResolver(
+      ~resolverName=fieldNameForAll->String.capitalize,
+      ~field=fieldNameForAll,
+      ~kind=connectionSpec ? "list" : "list",
+    )
+
+    // Sub-id connection — {single}Items(id, filter, …); only when subId configured.
+    let items = switch subIdField {
+    | Some(_) => [
+        mkResolver(
+          ~resolverName=fieldNameForSingle->String.capitalize ++ "Items",
+          ~field=fieldNameForSingle ++ "Items",
+          ~kind="items",
+        ),
+      ]
+    | None => []
+    }
+
+    // Batched-by-ids — single-key projections only (mirrors the SDL).
+    let byIds = if includeIdParam && subIdField === None {
+      let byIdsField = fieldNameForAll ++ "ByIds"
+      [
+        mkResolver(
+          ~resolverName=byIdsField->String.capitalize,
+          ~field=byIdsField,
+          ~kind="byIds",
+        ),
+      ]
+    } else {
+      []
+    }
+
+    // Per-index equality queries: {single}By{Index}. A group-restricted index
+    // (indexConfig.authorization) bakes the auth-table pipeline params — the
+    // Lambda verifies group membership + ownership against the auth read model.
+    let byIndex = indexes->Array.map((ic: indexConfig) => {
+      let index = ic.index
+      let resolverName =
+        fieldNameForSingle->String.capitalize ++ "By" ++ index->stripLeadingBy->String.capitalize
+      let field = fieldNameForSingle ++ "By" ++ index->stripLeadingBy->String.capitalize
+      switch ic.authorization {
+      | Some({tableName, group}) =>
+        mkResolver(
+          ~resolverName,
+          ~field,
+          ~kind="index",
+          ~index,
+          ~authTable=tableName->String.capitalize,
+          ~authGroup=group,
+        )
+      | None => mkResolver(~resolverName, ~field, ~kind="index", ~index)
+      }
+    })
+
+    // @resolves — single cross-table field resolver on this (parent) type. The
+    // target's binding key is its capitalized spec name (mirrors how the binding
+    // registry is keyed); the parent object flows via ctx.source.
+    let idResolvers = idResolverConfigs->Array.map(config => {
+      let {source: {idField, subId, resolvedField}, target} = config
+      let targetKey = target.tableName->String.capitalize
+      let (field, multi) = switch resolvedField {
+      | Single(f) => (f, false)
+      | Multi(f) => (f, true)
+      }
+      let targetFrag = switch target.idField {
+      | Index(ix) => `\n      targetIndex: '${ix}',\n      targetIndexIdField: '${ix}',`
+      | IndexWithId(ix, idf) => `\n      targetIndex: '${ix}',\n      targetIndexIdField: '${idf}',`
+      | Id => ""
+      }
+      let subIdFrag = switch subId {
+      | Field(f) => `\n      sourceSubId: { kind: 'field', name: '${f}' },`
+      | Argument(a) => `\n      sourceSubId: { kind: 'arg', name: '${a}' },`
+      | NoSubId => ""
+      }
+      let extra =
+        `\n      sourceIdField: '${idField}',\n      multi: ${multi ? "true" : "false"},` ++
+        targetFrag ++
+        subIdFrag
+      Resolver.makeUnitJsResolver(
+        ~name=name ++ field->String.capitalize,
+        ~api,
+        ~dataSourceName,
+        ~type_=name->Pulumi.Input.make,
+        ~field=field->Pulumi.Input.make,
+        ~code=invokeFieldTemplate(~sourceType=name, ~kind="resolveOne", ~target=targetKey, ~extra),
+        ~opts,
+      )
+    })
+
+    // @resolvesMany — batch cross-table field resolver (BatchGet by ids).
+    let idsResolvers = idsResolverConfigs->Array.map(config => {
+      let {source: {idsField, resolvedField}, target} = config
+      let targetKey = target.tableName->String.capitalize
+      let extra = `\n      sourceIdsField: '${idsField}',`
+      Resolver.makeUnitJsResolver(
+        ~name=name ++ resolvedField->String.capitalize,
+        ~api,
+        ~dataSourceName,
+        ~type_=name->Pulumi.Input.make,
+        ~field=resolvedField->Pulumi.Input.make,
+        ~code=invokeFieldTemplate(~sourceType=name, ~kind="resolveMany", ~target=targetKey, ~extra),
+        ~opts,
+      )
+    })
+
+    [byId, all]
+    ->Array.concat(items)
+    ->Array.concat(byIds)
+    ->Array.concat(byIndex)
+    ->Array.concat(idResolvers)
+    ->Array.concat(idsResolvers)
+    ->Array.map(Util.AppSync.toResourceNative)
+  }
+
+  {ReventlessCore.QueryDb_Adapter.resources: [], resourcesMaker}
+}

package/src/adapter/QueryDb/QueryDbResolvers_Lambda.res.mjs

@@ -0,0 +1,170 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
+import * as Util_AppSync$ReventlessAws from "../../util/Util_AppSync.res.mjs";
+import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
+import * as AppSync_Resolver_Functions$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_Resolver_Functions.res.mjs";
+import * as PgQueryResolver_Builder$ReventlessAws from "./PgQueryResolver_Builder.res.mjs";
+import * as AppSync_Resolver_Retrying$ReventlessAws from "../Api/AppSync_Resolver_Retrying.res.mjs";
+
+let identityBlock = `id != null && id.sub != null
+      ? { userId: id.sub, username: id.username, groups: id.claims?.['cognito:groups'] ?? [], claims: id.claims, provider: 'Cognito' }
+      : id != null
+        ? { userArn: id.userArn ?? null, accountId: id.accountId ?? null, username: id.username ?? null, provider: 'IAM' }
+        : null`;
+
+function invokeTemplate(readModelName, kind, index, authTable, authGroup) {
+  let indexFrag = index !== undefined ? `\n      index: '` + index + `',` : "";
+  let authFrag = authTable !== undefined && authGroup !== undefined ? `\n      authTable: '` + authTable + `',\n      authGroup: '` + authGroup + `',` : "";
+  return `import { util } from '@aws-appsync/utils';
+export function request(ctx) {
+  const id = ctx.identity;
+  return {
+    operation: 'Invoke',
+    payload: {
+      readModelName: '` + readModelName + `',
+      kind: '` + kind + `',` + indexFrag + authFrag + `
+      arguments: ctx.args,
+      identity: ` + identityBlock + `
+    }
+  };
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  return ctx.result;
+}
+`;
+}
+
+function invokeFieldTemplate(sourceType, kind, target, extra) {
+  return `import { util } from '@aws-appsync/utils';
+export function request(ctx) {
+  const id = ctx.identity;
+  return {
+    operation: 'Invoke',
+    payload: {
+      readModelName: '` + sourceType + `',
+      kind: '` + kind + `',
+      target: '` + target + `',
+      source: ctx.source,
+      arguments: ctx.args,` + extra + `
+      identity: ` + identityBlock + `
+    }
+  };
+}
+export function response(ctx) {
+  if (ctx.error) util.error(ctx.error.message, ctx.error.type);
+  return ctx.result;
+}
+`;
+}
+
+function make(name, api, param, dataSourceName, indexes, subIdField, idResolverConfigs, idsResolverConfigs, param$1, opts) {
+  let name$1 = Stdlib_String.capitalize(name);
+  let registryEntry = Plugin_Helpers$ReventlessCore.queryFieldNamesRegistry[name$1];
+  let fieldNameForSingle = registryEntry !== undefined ? registryEntry.singleFieldName : AppSync_Resolver_Functions$PulumiAws.uncapitalize(name$1);
+  let includeIdParam = registryEntry !== undefined ? registryEntry.includeIdParam : true;
+  let fieldNameForAll = registryEntry !== undefined ? registryEntry.listFieldName : name$1 + "s";
+  let labelField = registryEntry !== undefined ? Stdlib_Option.getOr(registryEntry.labelField, "id") : "id";
+  let returnTypeName = registryEntry !== undefined ? registryEntry.returnTypeName : name$1;
+  PgQueryResolver_Builder$ReventlessAws.register({
+    readModelName: name$1,
+    labelField: labelField,
+    includeIdParam: includeIdParam
+  });
+  if (includeIdParam) {
+    PgQueryResolver_Builder$ReventlessAws.registerNodeType(returnTypeName, name$1);
+  }
+  let mkResolver = (resolverName, field, kind, index, authTable, authGroup) => AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(resolverName, api, dataSourceName, "Query", field, invokeTemplate(name$1, kind, index, authTable, authGroup), opts);
+  let stripLeadingBy = s => {
+    if (s.startsWith("by") && s.length > 2) {
+      return s.slice(2, s.length);
+    } else {
+      return s;
+    }
+  };
+  let resourcesMaker = _allQueryDbs => {
+    let byId = mkResolver(Stdlib_String.capitalize(fieldNameForSingle), fieldNameForSingle, includeIdParam ? "getById" : "list", undefined, undefined, undefined);
+    let all = mkResolver(Stdlib_String.capitalize(fieldNameForAll), fieldNameForAll, "list", undefined, undefined, undefined);
+    let items = subIdField !== undefined ? [mkResolver(Stdlib_String.capitalize(fieldNameForSingle) + "Items", fieldNameForSingle + "Items", "items", undefined, undefined, undefined)] : [];
+    let byIds;
+    if (includeIdParam && subIdField === undefined) {
+      let byIdsField = fieldNameForAll + "ByIds";
+      byIds = [mkResolver(Stdlib_String.capitalize(byIdsField), byIdsField, "byIds", undefined, undefined, undefined)];
+    } else {
+      byIds = [];
+    }
+    let byIndex = indexes.map(ic => {
+      let index = ic.index;
+      let resolverName = Stdlib_String.capitalize(fieldNameForSingle) + "By" + Stdlib_String.capitalize(stripLeadingBy(index));
+      let field = fieldNameForSingle + "By" + Stdlib_String.capitalize(stripLeadingBy(index));
+      let match = ic.authorization;
+      if (match !== undefined) {
+        return mkResolver(resolverName, field, "index", index, Stdlib_String.capitalize(match.tableName), match.group);
+      } else {
+        return mkResolver(resolverName, field, "index", index, undefined, undefined);
+      }
+    });
+    let idResolvers = idResolverConfigs.map(config => {
+      let target = config.target;
+      let match = config.source;
+      let resolvedField = match.resolvedField;
+      let subId = match.subId;
+      let targetKey = Stdlib_String.capitalize(target.tableName);
+      let match$1;
+      match$1 = resolvedField.TAG === "Single" ? [
+          resolvedField._0,
+          false
+        ] : [
+          resolvedField._0,
+          true
+        ];
+      let field = match$1[0];
+      let ix = target.idField;
+      let targetFrag;
+      if (typeof ix !== "object") {
+        targetFrag = "";
+      } else if (ix.TAG === "Index") {
+        let ix$1 = ix._0;
+        targetFrag = `\n      targetIndex: '` + ix$1 + `',\n      targetIndexIdField: '` + ix$1 + `',`;
+      } else {
+        targetFrag = `\n      targetIndex: '` + ix._0 + `',\n      targetIndexIdField: '` + ix._1 + `',`;
+      }
+      let subIdFrag;
+      subIdFrag = typeof subId !== "object" ? "" : (
+          subId.TAG === "Field" ? `\n      sourceSubId: { kind: 'field', name: '` + subId._0 + `' },` : `\n      sourceSubId: { kind: 'arg', name: '` + subId._0 + `' },`
+        );
+      let extra = `\n      sourceIdField: '` + match.idField + `',\n      multi: ` + (
+        match$1[1] ? "true" : "false"
+      ) + `,` + targetFrag + subIdFrag;
+      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(name$1 + Stdlib_String.capitalize(field), api, dataSourceName, name$1, field, invokeFieldTemplate(name$1, "resolveOne", targetKey, extra), opts);
+    });
+    let idsResolvers = idsResolverConfigs.map(config => {
+      let match = config.source;
+      let resolvedField = match.resolvedField;
+      let targetKey = Stdlib_String.capitalize(config.target.tableName);
+      let extra = `\n      sourceIdsField: '` + match.idsField + `',`;
+      return AppSync_Resolver_Retrying$ReventlessAws.makeUnitJsResolver(name$1 + Stdlib_String.capitalize(resolvedField), api, dataSourceName, name$1, resolvedField, invokeFieldTemplate(name$1, "resolveMany", targetKey, extra), opts);
+    });
+    return [
+      byId,
+      all
+    ].concat(items).concat(byIds).concat(byIndex).concat(idResolvers).concat(idsResolvers).map(Util_AppSync$ReventlessAws.toResourceNative);
+  };
+  return {
+    resources: [],
+    resourcesMaker: resourcesMaker
+  };
+}
+
+let Resolver;
+
+export {
+  Resolver,
+  identityBlock,
+  invokeTemplate,
+  invokeFieldTemplate,
+  make,
+}
+/* Util_AppSync-ReventlessAws Not a pure module */

package/src/adapter/QueryDb/QueryDbStorage.res

@@ -9,7 +9,11 @@ module Postgres = QueryDbStorage_Postgres
 // platform when a `PgConnection` is supplied — and dispatch per read model:
 // Postgres (no table, no data source) unless the name is admin-exempt. The Stream
 // selector falls back to the streamed DynamoDB maker; on Postgres there is no
-// stream — live updates for Postgres-backed read models are deferred (B3.3).
+// stream, so live updates (B3.3) are published from the projection Lambda after
+// each save/delete instead. SelectableStream records subscription-enabled
+// Postgres read models in `QueryDbBackend.postgresStreamRegistry` (a leaf module,
+// to avoid a build cycle) so the projection-Lambda runtime builder knows which
+// handlers need the AppSync-Events publish wiring.
 module Selectable = {
   type api = QueryDbStorage_Postgres.api
   type role = QueryDbStorage_Postgres.role
@@ -42,6 +46,7 @@ module SelectableStream = {
     ~opts,
   ) =>
     if QueryDbBackend.isPostgresFor(name) {
+      QueryDbBackend.postgresStreamRegistry->Set.add(name)
       Postgres.make(~name, ~indexes, ~subIdField?, ~ttl?, ~api, ~apiRole, ~opts)
     } else {
       DynamoDbStream.make(~name, ~indexes, ~subIdField?, ~ttl?, ~api, ~apiRole, ~opts)

package/src/adapter/QueryDb/QueryDbStorage.res.mjs

@@ -19,6 +19,7 @@ let Selectable = {
 
 function make$1(name, indexes, subIdField, ttl, api, apiRole, opts) {
   if (QueryDbBackend$ReventlessAws.isPostgresFor(name)) {
+    QueryDbBackend$ReventlessAws.postgresStreamRegistry.add(name);
     return QueryDbStorage_Postgres$ReventlessAws.make(name, indexes, subIdField, ttl, api, apiRole, opts);
   } else {
     return QueryDbStorage_DynamoDbStream$ReventlessAws.make(name, indexes, subIdField, ttl, api, apiRole, opts);
@@ -48,4 +49,4 @@ export {
   Selectable,
   SelectableStream,
 }
-/* QueryDbStorage_DynamoDb-ReventlessAws Not a pure module */
+/* QueryDbBackend-ReventlessAws Not a pure module */

package/src/adapter/QueryDb/QueryDbStorage_Postgres.res

@@ -37,7 +37,11 @@ let make: ReventlessCore.QueryDb_Adapter.storageMaker<api, role> = (
   }
   {
     ReventlessCore.QueryDb_Adapter.resources: [],
-    dataSourceName: ""->Pulumi.Output.make,
+    // B3.2b: the shared PgQueryResolver Lambda data source. Deferred — resolved
+    // by PgQueryResolver_Builder.provision after every plugin is built (the
+    // resolvers that read it are created even later, inside the schema-pushed
+    // resourcesMaker). Same value for every Postgres read model.
+    dataSourceName: PgQueryResolver_Builder.dataSourceName,
     operations,
   }
 }

package/src/adapter/QueryDb/QueryDbStorage_Postgres.res.mjs

@@ -1,8 +1,8 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as Pulumi from "@pulumi/pulumi";
 import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as QueryDbBackend$ReventlessAws from "./QueryDbBackend.res.mjs";
+import * as PgQueryResolver_Builder$ReventlessAws from "./PgQueryResolver_Builder.res.mjs";
 import * as QueryDbStorage_Postgres_Runtime$ReventlessAws from "./QueryDbStorage_Postgres_Runtime.res.mjs";
 
 function make(name, indexes, subIdField, param, param$1, param$2, param$3) {
@@ -10,7 +10,7 @@ function make(name, indexes, subIdField, param, param$1, param$2, param$3) {
   let operations = match !== undefined ? match.connectionConfig.apply(config => QueryDbStorage_Postgres_Runtime$ReventlessAws.opsFor(config, name, indexes, subIdField)) : Stdlib_JsError.throwWithMessage("QueryDbStorage_Postgres.make called without a QueryDbBackend selection");
   return {
     resources: [],
-    dataSourceName: Pulumi.output(""),
+    dataSourceName: PgQueryResolver_Builder$ReventlessAws.dataSourceName,
     operations: operations
   };
 }
@@ -18,4 +18,4 @@ function make(name, indexes, subIdField, param, param$1, param$2, param$3) {
 export {
   make,
 }
-/* @pulumi/pulumi Not a pure module */
+/* QueryDbBackend-ReventlessAws Not a pure module */

package/src/adapter/Runtime/AggregateRuntime_Builder_Single.res

@@ -214,20 +214,9 @@ let finish = () =>
         let pgSelection = EventLogBackend.get()
         let pgConnectionFragment = switch pgSelection {
         | Some(sel) =>
-          sel.connectionConfig->Pulumi.Output.apply(cc => {
-            let pgConnectionJson =
-              [
-                ("host", cc.host->JSON.Encode.string),
-                ("port", cc.port->Int.toFloat->JSON.Encode.float),
-                ("database", cc.database->JSON.Encode.string),
-                ("username", cc.username->JSON.Encode.string),
-                ("secretArn", cc.secretArn->JSON.Encode.string),
-              ]
-              ->Dict.fromArray
-              ->JSON.Encode.object
-              ->JSON.stringify
-            `,"pgConnection":${pgConnectionJson}`
-          })
+          sel.connectionConfig->Pulumi.Output.apply(cc =>
+            `,"pgConnection":${cc->PgConnection.connectionConfigToJson->JSON.stringify}`
+          )
         | None => Pulumi.Output.make("")
         }
 

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

@@ -10,6 +10,7 @@ import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/
 import * as Component$ReventlessCore from "@reventlessdev/reventless-core/src/components/Component.res.mjs";
 import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
 import * as Util_Bundle$ReventlessAws from "../../util/Util_Bundle.res.mjs";
+import * as PgConnection$ReventlessAws from "../Postgres/PgConnection.res.mjs";
 import * as EventLogBackend$ReventlessAws from "../EventLog/EventLogBackend.res.mjs";
 import * as RuntimeEnvironment_Lambda$ReventlessAws from "./RuntimeEnvironment_Lambda.res.mjs";
 import * as CommandTopicChannel_SQS_Sync$ReventlessAws from "../CommandTopic/CommandTopicChannel_SQS_Sync.res.mjs";
@@ -156,31 +157,7 @@ function finish() {
       let handlerOutputs = [];
       let packageDirs = {};
       let pgSelection = EventLogBackend$ReventlessAws.get();
-      let pgConnectionFragment = pgSelection !== undefined ? pgSelection.connectionConfig.apply(cc => {
-          let pgConnectionJson = JSON.stringify(Object.fromEntries([
-            [
-              "host",
-              cc.host
-            ],
-            [
-              "port",
-              cc.port
-            ],
-            [
-              "database",
-              cc.database
-            ],
-            [
-              "username",
-              cc.username
-            ],
-            [
-              "secretArn",
-              cc.secretArn
-            ]
-          ]));
-          return `,"pgConnection":` + pgConnectionJson;
-        }) : Pulumi.output("");
+      let pgConnectionFragment = pgSelection !== undefined ? pgSelection.connectionConfig.apply(cc => `,"pgConnection":` + JSON.stringify(PgConnection$ReventlessAws.connectionConfigToJson(undefined, cc))) : Pulumi.output("");
       specs.forEach(spec => {
         let info = aggregateInfos[spec.aggregateName];
         if (info === undefined) {