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

package/src/adapter/Postgres/PgProjectionFeed.res.mjs

@@ -0,0 +1,54 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aws from "@pulumi/aws";
+import * as SQS_Queue$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/SQS/SQS_Queue.res.mjs";
+import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
+import * as Util_DeadLetterQueue$ReventlessAws from "../../util/Util_DeadLetterQueue.res.mjs";
+import * as Util_EventSourceMapping$ReventlessAws from "../../util/Util_EventSourceMapping.res.mjs";
+
+let feedQueues = [];
+
+function getFeedQueues() {
+  return feedQueues;
+}
+
+function makeQueue(name, scope, includeClassic, includeDcb, opts) {
+  let queue = new (Aws.sqs.Queue)(name, {
+    redrivePolicy: Util_DeadLetterQueue$ReventlessAws.queue.arn.apply(dlqArn => SQS_Queue$PulumiAws.RedrivePolicy.make(dlqArn, 5)),
+    visibilityTimeoutSeconds: 120,
+    sqsManagedSseEnabled: false
+  }, opts);
+  feedQueues.push({
+    scope: scope,
+    includeClassic: includeClassic,
+    includeDcb: includeDcb,
+    url: queue.id,
+    arn: queue.arn
+  });
+  return queue;
+}
+
+function connect(name, queue, lambda, lambdaRole, opts) {
+  Util_EventSourceMapping$ReventlessAws.subscribeSqs(lambda, name, queue, undefined, opts);
+  queue.arn.apply(queueArn => new (Aws.iam.RolePolicy)(name + `Receive`, {
+    policy: PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + `ReceivePolicy`, [{
+        Sid: "AllowReceiveFeedQueue",
+        Effect: "Allow",
+        Action: [
+          "sqs:ReceiveMessage",
+          "sqs:DeleteMessage",
+          "sqs:GetQueueAttributes"
+        ],
+        Resource: queueArn
+      }])),
+    role: lambdaRole.id
+  }, opts));
+}
+
+export {
+  feedQueues,
+  getFeedQueues,
+  makeQueue,
+  connect,
+}
+/* @pulumi/aws Not a pure module */

package/src/adapter/QueryDb/PgQueryResolver_Lambda.res

@@ -0,0 +1,192 @@
+// Runtime handler for the shared Postgres GraphQL-read Lambda (B3.2).
+//
+// Postgres-backed read models have no per-table AppSync data source, so their
+// GraphQL Query fields route through one in-VPC "PgQueryResolver" Lambda
+// registered as an AppSync Lambda data source (B3.2b). Each resolver field's
+// APPSYNC_JS template invokes this Lambda with
+//   { readModelName, kind, index?, arguments, identity }
+// and this handler dispatches to the Postgres query push-downs
+// (QueryEnginePostgres) + the shared connection spec (QueryDbListQuery).
+//
+// This module is the provider-agnostic *dispatch* — the headless twin of
+// reventless-local's `QueryDbResolvers_GraphQL` (which registers graphql-yoga
+// resolvers). It returns JSON straight to AppSync instead. The per-read-model
+// context (ops set, push-downs, indexes, capability, …) is bound at Lambda init
+// by the entry point (PgQueryResolverEntryPoint.mjs, B3.2b) and registered here;
+// `dispatch` itself is pure over a `binding`, so it is unit-tested with an
+// in-memory mock (no Postgres) — the SQL correctness lives in
+// QueryEnginePostgres and is covered by its PG_URL-gated parity test.
+
+let log = ReventlessCore.Logger.fromEnv()
+
+// Wire payload from the resolver template. `arguments` mirrors the field name the
+// other Invoke templates use (QueryInterceptor_Lambda, invokeCommandGenerator).
+type payload = {
+  readModelName: string,
+  kind: string,
+  index?: string,
+  arguments: JSON.t,
+  identity: Reventless.Identity.t,
+}
+
+// The Postgres query push-downs a binding needs (QueryEnginePostgres.Make
+// provides these; the mock in tests provides in-memory equivalents).
+type pushdowns = {
+  indexLookup: (~readModelName: string, string, string) => promise<array<JSON.t>>,
+  byIds: (~readModelName: string, array<string>) => promise<array<JSON.t>>,
+  listPage: (
+    ~readModelName: string,
+    ~argsDict: dict<JSON.t>,
+    ~capability: ReventlessCore.GraphQL_FragmentGenerator.serverCapability,
+    ~labelField: string,
+  ) => promise<option<JSON.t>>,
+  // Full materialisation for the list fallback (shapes listPage declines).
+  scanAll: (~readModelName: string) => promise<array<JSON.t>>,
+}
+
+// Per-read-model dispatch context, bound once at Lambda init.
+type binding = {
+  ops: ReventlessCore.QueryDb_Adapter.operations,
+  pushdowns: pushdowns,
+  indexes: array<Reventless.ReadModel.indexConfig>,
+  subIdField: option<string>,
+  capability: ReventlessCore.GraphQL_FragmentGenerator.serverCapability,
+  labelField: string,
+  includeIdParam: bool,
+  authorization: Reventless.Authorization.permission,
+}
+
+// -- arg helpers -------------------------------------------------------------
+let argObj = (args: JSON.t): dict<JSON.t> =>
+  args->JSON.Decode.object->Option.getOr(Dict.make())
+let argStr = (args: JSON.t, key: string): option<string> =>
+  args->argObj->Dict.get(key)->Option.flatMap(JSON.Decode.string)
+let argStrs = (args: JSON.t, key: string): array<string> =>
+  args
+  ->argObj
+  ->Dict.get(key)
+  ->Option.flatMap(JSON.Decode.array)
+  ->Option.getOr([])
+  ->Array.filterMap(JSON.Decode.string)
+
+// Add `id` (= partition key) to an item when absent — matches the shape the
+// DynamoDB resolvers and the shared spec return.
+let withId = (item: JSON.t, id: string): JSON.t =>
+  switch item->JSON.Decode.object {
+  | Some(obj) if obj->Dict.get("id")->Option.isNone =>
+    let copy = Dict.copy(obj)
+    copy->Dict.set("id", JSON.Encode.string(id))
+    JSON.Encode.object(copy)
+  | _ => item
+  }
+
+let emptyConnection = (): JSON.t =>
+  ReventlessCore.QueryDbListQuery.buildConnection(
+    ~pageItems=[],
+    ~hasNextPage=false,
+    ~hasPreviousPage=false,
+    ~cursorValueOf=_ => "",
+  )
+
+// Spec-level authorization then the (optional) user interceptor — mirrors
+// QueryDbResolvers_GraphQL.runInterceptor. Denials return the kind's empty shape
+// (the provider-agnostic resolver behaviour), not an error.
+let runInterceptor = async (~binding, ~payload): ReventlessCore.QueryDb_Callback.interceptResult => {
+  if !Reventless.Authorization.isAllowed(binding.authorization, payload.identity) {
+    Deny("Forbidden")
+  } else {
+    switch ReventlessCore.QueryDb_Callback.queryInterceptorHook.contents {
+    | None => Allow
+    | Some(interceptor) =>
+      await interceptor(
+        ~identity=payload.identity,
+        ~readModelName=payload.readModelName,
+        ~args=payload.arguments,
+      )
+    }
+  }
+}
+
+let dispatch = async (~binding: binding, ~payload: payload): JSON.t => {
+  let rm = payload.readModelName
+  switch await runInterceptor(~binding, ~payload) {
+  | Deny(_) =>
+    // Empty shape per kind (null for single, [] for lists, empty connection).
+    switch payload.kind {
+    | "getById" => JSON.Encode.null
+    | "list" => emptyConnection()
+    | _ => JSON.Encode.array([])
+    }
+  | Allow =>
+    switch payload.kind {
+    | "getById" =>
+      let id = payload.arguments->argStr("id")->Option.getOr("")
+      switch await binding.ops.load(id) {
+      | Ok(items) =>
+        switch items->Array.get(0) {
+        | Some(item) => binding.includeIdParam ? withId(item, id) : item
+        | None => JSON.Encode.null
+        }
+      | Error(_) => JSON.Encode.null
+      }
+
+    | "byIds" =>
+      let ids = payload.arguments->argStrs("ids")
+      JSON.Encode.array(await binding.pushdowns.byIds(~readModelName=rm, ids))
+
+    | "index" =>
+      // The index arg name is the index; its stored field is idField ?? index.
+      let indexName = payload.index->Option.getOr("")
+      let field =
+        binding.indexes
+        ->Array.find(ic => ic.index === indexName)
+        ->Option.flatMap(ic => ic.idField)
+        ->Option.getOr(indexName)
+      let value = payload.arguments->argStr(indexName)->Option.getOr("")
+      JSON.Encode.array(await binding.pushdowns.indexLookup(~readModelName=rm, field, value))
+
+    | "list" =>
+      let argsDict = payload.arguments->argObj
+      switch await binding.pushdowns.listPage(
+        ~readModelName=rm,
+        ~argsDict,
+        ~capability=binding.capability,
+        ~labelField=binding.labelField,
+      ) {
+      | Some(conn) => conn
+      | None =>
+        // Shapes listPage declines (search/searchPrefix/ids/backward) → run the
+        // shared spec over the materialised model. No Relay global-id decoding
+        // in the Lambda, so `decodeLocalId` is a no-op (the `ids` filter still
+        // matches raw item ids).
+        let items = await binding.pushdowns.scanAll(~readModelName=rm)
+        ReventlessCore.QueryDbListQuery.run(
+          ~items,
+          ~argsDict,
+          ~capability=binding.capability,
+          ~labelField=binding.labelField,
+          ~decodeLocalId=_ => None,
+        )
+      }
+
+    | other =>
+      // Fail loudly on unmapped kinds (feature-parity guard, per the B3.2 plan).
+      log.error(~comp="PgQueryResolver_Lambda", `unmapped resolver kind '${other}' for ${rm}`)
+      JsError.throwWithMessage(`PgQueryResolver: unmapped resolver kind '${other}' for ${rm}`)
+    }
+  }
+}
+
+// Per-read-model binding registry, populated by the entry point at Lambda init.
+let bindings: dict<binding> = Dict.make()
+let register = (~readModelName: string, binding: binding): unit =>
+  bindings->Dict.set(readModelName, binding)
+
+let handler = async (payload: payload, _context) =>
+  switch bindings->Dict.get(payload.readModelName) {
+  | Some(binding) => await dispatch(~binding, ~payload)
+  | None =>
+    JsError.throwWithMessage(
+      "PgQueryResolver: no binding registered for read model " ++ payload.readModelName,
+    )
+  }

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

@@ -0,0 +1,141 @@
+// 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 Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as Authorization$Reventless from "@reventlessdev/reventless-spec/src/types/Authorization.res.mjs";
+import * as QueryDbListQuery$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/QueryDbListQuery.res.mjs";
+import * as QueryDb_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb_Callback.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+function argObj(args) {
+  return Stdlib_Option.getOr(Stdlib_JSON.Decode.object(args), {});
+}
+
+function argStr(args, key) {
+  return Stdlib_Option.flatMap(argObj(args)[key], Stdlib_JSON.Decode.string);
+}
+
+function argStrs(args, key) {
+  return Stdlib_Array.filterMap(Stdlib_Option.getOr(Stdlib_Option.flatMap(argObj(args)[key], Stdlib_JSON.Decode.array), []), Stdlib_JSON.Decode.string);
+}
+
+function withId(item, id) {
+  let obj = Stdlib_JSON.Decode.object(item);
+  if (obj === undefined) {
+    return item;
+  }
+  if (!Stdlib_Option.isNone(obj["id"])) {
+    return item;
+  }
+  let copy = Object.assign({}, obj);
+  copy["id"] = id;
+  return copy;
+}
+
+function emptyConnection() {
+  return QueryDbListQuery$ReventlessCore.buildConnection([], false, false, param => "");
+}
+
+async function runInterceptor(binding, payload) {
+  if (!Authorization$Reventless.isAllowed(binding.authorization, payload.identity)) {
+    return {
+      TAG: "Deny",
+      _0: "Forbidden"
+    };
+  }
+  let interceptor = QueryDb_Callback$ReventlessCore.queryInterceptorHook.contents;
+  if (interceptor !== undefined) {
+    return await interceptor(payload.identity, payload.readModelName, payload.arguments);
+  } else {
+    return "Allow";
+  }
+}
+
+async function dispatch(binding, payload) {
+  let rm = payload.readModelName;
+  let match = await runInterceptor(binding, payload);
+  if (typeof match !== "object") {
+    let other = payload.kind;
+    switch (other) {
+      case "byIds" :
+        let ids = argStrs(payload.arguments, "ids");
+        return await binding.pushdowns.byIds(rm, ids);
+      case "getById" :
+        let id = Stdlib_Option.getOr(argStr(payload.arguments, "id"), "");
+        let items = await binding.ops.load(id);
+        if (items.TAG !== "Ok") {
+          return null;
+        }
+        let item = items._0[0];
+        if (item !== undefined) {
+          if (binding.includeIdParam) {
+            return withId(item, id);
+          } else {
+            return item;
+          }
+        } else {
+          return null;
+        }
+      case "index" :
+        let indexName = Stdlib_Option.getOr(payload.index, "");
+        let field = Stdlib_Option.getOr(Stdlib_Option.flatMap(binding.indexes.find(ic => ic.index === indexName), ic => ic.idField), indexName);
+        let value = Stdlib_Option.getOr(argStr(payload.arguments, indexName), "");
+        return await binding.pushdowns.indexLookup(rm, field, value);
+      case "list" :
+        let argsDict = argObj(payload.arguments);
+        let conn = await binding.pushdowns.listPage(rm, argsDict, binding.capability, binding.labelField);
+        if (conn !== undefined) {
+          return conn;
+        }
+        let items$1 = await binding.pushdowns.scanAll(rm);
+        return QueryDbListQuery$ReventlessCore.run(items$1, argsDict, binding.capability, binding.labelField, param => {});
+      default:
+        log.error("PgQueryResolver_Lambda", undefined, `unmapped resolver kind '` + other + `' for ` + rm);
+        return Stdlib_JsError.throwWithMessage(`PgQueryResolver: unmapped resolver kind '` + other + `' for ` + rm);
+    }
+  } else {
+    let match$1 = payload.kind;
+    switch (match$1) {
+      case "getById" :
+        return null;
+      case "list" :
+        return emptyConnection();
+      default:
+        return [];
+    }
+  }
+}
+
+let bindings = {};
+
+function register(readModelName, binding) {
+  bindings[readModelName] = binding;
+}
+
+async function handler(payload, _context) {
+  let binding = bindings[payload.readModelName];
+  if (binding !== undefined) {
+    return await dispatch(binding, payload);
+  } else {
+    return Stdlib_JsError.throwWithMessage("PgQueryResolver: no binding registered for read model " + payload.readModelName);
+  }
+}
+
+export {
+  log,
+  argObj,
+  argStr,
+  argStrs,
+  withId,
+  emptyConnection,
+  runInterceptor,
+  dispatch,
+  bindings,
+  register,
+  handler,
+}
+/* log Not a pure module */

package/src/adapter/QueryDb/QueryDbBackend.res

@@ -0,0 +1,52 @@
+// AWS-side selection for the QueryDb (read model) storage backend — the QueryDb
+// analogue of `EventLogBackend` / `DcbBackend` (B3.1,
+// docs/plans/aws-postgres-querydb-adapter.md).
+//
+// When `Platform.MakeWithConfig` is given a `~pgConnection`, it records the
+// resolved selection here BEFORE any admin/plugin `construct` runs. Read by:
+//   - `QueryDbStorage.Selectable(Stream)` — route app read-model storage to
+//     Postgres (no DynamoDB table) and bind the Postgres operation set;
+//   - `QueryDbResolvers.Selectable` — suppress AppSync resolvers for
+//     Postgres-backed read models (GraphQL reads land with B3.2's Lambda data
+//     source; until then those fields are unresolved);
+//   - the ReadModel/StateViewSlice runtime builders — inject `pgConnection` into
+//     Postgres-backed handlers' HANDLER_CONFIG entries and put the projection
+//     Lambdas in-VPC with secret access.
+//
+// ADMIN EXEMPTION: platform/admin read models (Plugins, UIFragmentRegistry, …)
+// stay on DynamoDB even when Postgres is selected. Deploy-time consumers (the
+// AppSync schema-clobber guard's Plugin-RM scan, `PLUGIN_RM_TABLE_NAME` gates,
+// retire hooks) query these tables during `pulumi up` — from outside the VPC —
+// and the whole platform lifecycle depends on them. The platform registers the
+// exempt names before Admin.construct.
+
+type selection = {
+  connectionConfig: Pulumi.Output.t<PgConnection.connectionConfig>,
+  /** DB-access security group every projection Lambda attaches (PgConnection.securityGroupId). */
+  securityGroupId: Pulumi.Output.t<string>,
+  /** Private subnets for the in-VPC projection Lambdas (PgConnection.subnetIds). */
+  subnetIds: array<Pulumi.Input.t<string>>,
+}
+
+let selectionRef: ref<option<selection>> = ref(None)
+
+/** Record the QueryDb Postgres selection. Called once by the platform before construct. */
+let set = (sel: selection) => selectionRef := Some(sel)
+
+/** The active QueryDb Postgres selection, if the platform was given a `PgConnection`. */
+let get = (): option<selection> => selectionRef.contents
+
+// Read-model names that stay on DynamoDB regardless of the selection.
+let exemptNames: array<string> = []
+
+/** Exempt an (admin) read model from the Postgres selection. Called by the
+    platform for every admin read model before Admin.construct. */
+let exempt = (name: string) => exemptNames->Array.push(name)->ignore
+
+/** Whether this read model's QueryDb is Postgres-backed on this platform. */
+let isPostgresFor = (name: string): bool =>
+  selectionRef.contents->Option.isSome && !(exemptNames->Array.includes(name))
+
+/** Whether ANY read model on this platform is Postgres-backed (used to decide
+    whether the projection Lambdas need VPC/secret access). */
+let isPostgres = (): bool => selectionRef.contents->Option.isSome

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

@@ -0,0 +1,44 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+
+let selectionRef = {
+  contents: undefined
+};
+
+function set(sel) {
+  selectionRef.contents = sel;
+}
+
+function get() {
+  return selectionRef.contents;
+}
+
+let exemptNames = [];
+
+function exempt(name) {
+  exemptNames.push(name);
+}
+
+function isPostgresFor(name) {
+  if (Stdlib_Option.isSome(selectionRef.contents)) {
+    return !exemptNames.includes(name);
+  } else {
+    return false;
+  }
+}
+
+function isPostgres() {
+  return Stdlib_Option.isSome(selectionRef.contents);
+}
+
+export {
+  selectionRef,
+  set,
+  get,
+  exemptNames,
+  exempt,
+  isPostgresFor,
+  isPostgres,
+}
+/* No side effect */

package/src/adapter/QueryDb/QueryDbResolvers.res

@@ -1,2 +1,50 @@
 module AppSync = QueryDbResolvers_AppSync
 module NoOp = QueryDbResolvers_NoOp
+
+// 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.
+module Selectable = {
+  type api = QueryDbResolvers_AppSync_NoOp.api
+  type role = QueryDbResolvers_AppSync_NoOp.role
+  let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
+    ~name,
+    ~api,
+    ~apiRole,
+    ~dataSourceName,
+    ~indexes,
+    ~subIdField,
+    ~idResolverConfigs,
+    ~idsResolverConfigs,
+    ~authorization,
+    ~opts,
+  ) =>
+    if QueryDbBackend.isPostgresFor(name) {
+      QueryDbResolvers_AppSync_NoOp.make(
+        ~name,
+        ~api,
+        ~apiRole,
+        ~dataSourceName,
+        ~indexes,
+        ~subIdField,
+        ~idResolverConfigs,
+        ~idsResolverConfigs,
+        ~authorization,
+        ~opts,
+      )
+    } else {
+      QueryDbResolvers_AppSync.make(
+        ~name,
+        ~api,
+        ~apiRole,
+        ~dataSourceName,
+        ~indexes,
+        ~subIdField,
+        ~idResolverConfigs,
+        ~idsResolverConfigs,
+        ~authorization,
+        ~opts,
+      )
+    }
+}

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

@@ -1,5 +1,20 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as QueryDbBackend$ReventlessAws from "./QueryDbBackend.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);
+  } else {
+    return QueryDbResolvers_AppSync$ReventlessAws.make(name, api, apiRole, dataSourceName, indexes, subIdField, idResolverConfigs, idsResolverConfigs, authorization, opts);
+  }
+}
+
+let Selectable = {
+  make: make
+};
 
 let AppSync;
 
@@ -8,5 +23,6 @@ let NoOp;
 export {
   AppSync,
   NoOp,
+  Selectable,
 }
-/* No side effect */
+/* QueryDbResolvers_AppSync-ReventlessAws Not a pure module */

package/src/adapter/QueryDb/QueryDbStorage.res

@@ -3,3 +3,47 @@ let name = "QueryDbStorage"
 module DynamoDb = QueryDbStorage_DynamoDb
 module DynamoDbStream = QueryDbStorage_DynamoDbStream
 module DynamoDb_Runtime = QueryDbStorage_DynamoDb_Runtime
+module Postgres = QueryDbStorage_Postgres
+
+// Build-time QueryDb storage selectors (B3.1). Read `QueryDbBackend` — set by the
+// 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).
+module Selectable = {
+  type api = QueryDbStorage_Postgres.api
+  type role = QueryDbStorage_Postgres.role
+  let make: ReventlessCore.QueryDb_Adapter.storageMaker<api, role> = (
+    ~name,
+    ~indexes,
+    ~subIdField=?,
+    ~ttl=?,
+    ~api,
+    ~apiRole,
+    ~opts,
+  ) =>
+    if QueryDbBackend.isPostgresFor(name) {
+      Postgres.make(~name, ~indexes, ~subIdField?, ~ttl?, ~api, ~apiRole, ~opts)
+    } else {
+      DynamoDb.make(~name, ~indexes, ~subIdField?, ~ttl?, ~api, ~apiRole, ~opts)
+    }
+}
+
+module SelectableStream = {
+  type api = QueryDbStorage_Postgres.api
+  type role = QueryDbStorage_Postgres.role
+  let make: ReventlessCore.QueryDb_Adapter.storageMaker<api, role> = (
+    ~name,
+    ~indexes,
+    ~subIdField=?,
+    ~ttl=?,
+    ~api,
+    ~apiRole,
+    ~opts,
+  ) =>
+    if QueryDbBackend.isPostgresFor(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

@@ -1,5 +1,33 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as QueryDbBackend$ReventlessAws from "./QueryDbBackend.res.mjs";
+import * as QueryDbStorage_DynamoDb$ReventlessAws from "./QueryDbStorage_DynamoDb.res.mjs";
+import * as QueryDbStorage_Postgres$ReventlessAws from "./QueryDbStorage_Postgres.res.mjs";
+import * as QueryDbStorage_DynamoDbStream$ReventlessAws from "./QueryDbStorage_DynamoDbStream.res.mjs";
+
+function make(name, indexes, subIdField, ttl, api, apiRole, opts) {
+  if (QueryDbBackend$ReventlessAws.isPostgresFor(name)) {
+    return QueryDbStorage_Postgres$ReventlessAws.make(name, indexes, subIdField, ttl, api, apiRole, opts);
+  } else {
+    return QueryDbStorage_DynamoDb$ReventlessAws.make(name, indexes, subIdField, ttl, api, apiRole, opts);
+  }
+}
+
+let Selectable = {
+  make: make
+};
+
+function make$1(name, indexes, subIdField, ttl, api, apiRole, opts) {
+  if (QueryDbBackend$ReventlessAws.isPostgresFor(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);
+  }
+}
+
+let SelectableStream = {
+  make: make$1
+};
 
 let name = "QueryDbStorage";
 
@@ -9,10 +37,15 @@ let DynamoDbStream;
 
 let DynamoDb_Runtime;
 
+let Postgres;
+
 export {
   name,
   DynamoDb,
   DynamoDbStream,
   DynamoDb_Runtime,
+  Postgres,
+  Selectable,
+  SelectableStream,
 }
-/* No side effect */
+/* QueryDbStorage_DynamoDb-ReventlessAws Not a pure module */