@reventlessdev/reventless-aws 3.0.0-alpha.343 → 3.0.0-alpha.345

package/src/adapter/Monitoring/Monitoring_CloudWatch.res

@@ -120,8 +120,7 @@ let alarmFor = (
   // also where the log group goes — an alert names the unit and the metric and
   // never where to read what happened. `~logLocator` is an Output, so the whole
   // description resolves late; `""` is a unit with no logs of its own.
-  let describe = logs =>
-    Util_AlarmSpec.description(~kind, ~name, ~plugin, ~platform, ~spec, ~logs)
+  let describe = logs => Util_AlarmSpec.description(~kind, ~name, ~plugin, ~platform, ~spec, ~logs)
   let alarmDescription =
     logLocator
     ->Pulumi.Output.map(g => describe(g == "" ? None : Some(g)))
@@ -172,20 +171,21 @@ module Backend: M.Backend = {
     switch ensureTopicArn() {
     | Unresolved | NoTopic => ()
     | Topic(topicArn) =>
-      Util_AlarmSpec.forKind(~kind, ~silenceWindowSeconds=silenceWindowSeconds())->Array.forEach(
-        spec => {
-          let _alarm = alarmFor(
-            ~spec,
-            ~kind,
-            ~name,
-            ~component,
-            ~plugin,
-            ~platform,
-            ~logLocator,
-            ~topicArn,
-          )
-        },
-      )
+      Util_AlarmSpec.forKind(
+        ~kind,
+        ~silenceWindowSeconds=silenceWindowSeconds(),
+      )->Array.forEach(spec => {
+        let _alarm = alarmFor(
+          ~spec,
+          ~kind,
+          ~name,
+          ~component,
+          ~plugin,
+          ~platform,
+          ~logLocator,
+          ~topicArn,
+        )
+      })
     }
   }
 }

package/src/adapter/Postgres/PgChangeFeedRelay_Builder.res

@@ -89,14 +89,10 @@ let make = (
 
   let vpcConfig =
     securityGroupId
-    ->Pulumi.Output.apply(sgId =>
-      (
-        {
-          Lambda.Function.subnetIds: subnetIds->Pulumi.Input.make,
-          securityGroupIds: [sgId->Pulumi.Input.make]->Pulumi.Input.make,
-        }: Lambda.Function.vpcConfig
-      )
-    )
+    ->Pulumi.Output.apply((sgId): Lambda.Function.vpcConfig => {
+      Lambda.Function.subnetIds: subnetIds->Pulumi.Input.make,
+      securityGroupIds: [sgId->Pulumi.Input.make]->Pulumi.Input.make,
+    })
     ->Pulumi.Output.asInput
 
   let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
@@ -111,8 +107,7 @@ let make = (
   )
 
   // IAM: GetSecretValue on each log's DB secret + SendMessage on each target queue.
-  let secretArns =
-    logs->Array.map(l => l.connectionConfig->Pulumi.Output.apply(cc => cc.secretArn))
+  let secretArns = logs->Array.map(l => l.connectionConfig->Pulumi.Output.apply(cc => cc.secretArn))
   let queueArns = logs->Array.map(l => l.targetQueueArn)
   let _iam =
     (Pulumi.Output.all(secretArns), Pulumi.Output.all(queueArns), runtime.parts.lambdaRole.id)

package/src/adapter/Postgres/PgChangeFeedRelay_Runtime.res

@@ -25,8 +25,10 @@ let toEventCollectorJson = (
   let item = Dict.make()
   item->Dict.set(
     "id",
-    DcbEventLogStorage_DynamoDb_Runtime.derivePartitionKey(~partitionTag?, event.tags)
-    ->JSON.Encode.string,
+    DcbEventLogStorage_DynamoDb_Runtime.derivePartitionKey(
+      ~partitionTag?,
+      event.tags,
+    )->JSON.Encode.string,
   )
   item->Dict.set("position", event.position->JSON.Encode.string)
   item->Dict.set("event", event.eventType->JSON.Encode.string)

package/src/adapter/Postgres/PgConnection.res

@@ -19,7 +19,6 @@
 
   Aurora / Aurora Serverless v2 is a planned second engine behind the same
   `connectionConfig` output shape (tracked in the AWS-Postgres plan). */
-
 /** Resolved at deploy time, serialized into the handler Lambda env, and consumed
   at cold start to build a `PgDriver` pool. `secretArn` points at the
   RDS-managed `{username, password}` secret; `host`/`port`/`database` come from
@@ -54,7 +53,8 @@ let connectionConfigToJson = (
     ("secretArn", cc.secretArn->JSON.Encode.string),
   ]
   switch lockStrategy {
-  | Some(#AdvisoryLocks) => fields->Array.push(("lockStrategy", "AdvisoryLocks"->JSON.Encode.string))
+  | Some(#AdvisoryLocks) =>
+    fields->Array.push(("lockStrategy", "AdvisoryLocks"->JSON.Encode.string))
   | Some(#RowLocks) => fields->Array.push(("lockStrategy", "RowLocks"->JSON.Encode.string))
   | None => ()
   }
@@ -195,9 +195,10 @@ let make = (
   // instance's so the B-phase storage adapters can order after the schema exists.
   // The connection is passed as pre-serialized pieces to avoid a module cycle
   // (PgMigration_Builder must not reference this module's `connectionConfig`).
-  let migrationHandlerConfig = connectionConfig->Pulumi.Output.apply(cc =>
-    `{"pgConnection":${cc->connectionConfigToJson->JSON.stringify}}`
-  )
+  let migrationHandlerConfig =
+    connectionConfig->Pulumi.Output.apply(cc =>
+      `{"pgConnection":${cc->connectionConfigToJson->JSON.stringify}}`
+    )
   let migrationResources = PgMigration_Builder.make(
     ~name=`${name}-pg-migrate`,
     ~handlerConfig=migrationHandlerConfig,

package/src/adapter/Postgres/PgMigration_Builder.res

@@ -41,14 +41,10 @@ let make = (
 
   let vpcConfig =
     securityGroupId
-    ->Pulumi.Output.apply(sgId =>
-      (
-        {
-          Lambda.Function.subnetIds: subnetIds->Pulumi.Input.make,
-          securityGroupIds: [sgId->Pulumi.Input.make]->Pulumi.Input.make,
-        }: Lambda.Function.vpcConfig
-      )
-    )
+    ->Pulumi.Output.apply((sgId): Lambda.Function.vpcConfig => {
+      Lambda.Function.subnetIds: subnetIds->Pulumi.Input.make,
+      securityGroupIds: [sgId->Pulumi.Input.make]->Pulumi.Input.make,
+    })
     ->Pulumi.Output.asInput
 
   let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(

package/src/adapter/Postgres/PgRuntime.res

@@ -10,15 +10,13 @@
   (as a promise) to avoid a Secrets Manager round trip on every connection; a
   password rotation surfaces as auth failures that recycle the container, after
   which the next cold start re-fetches. */
-
 /** RDS-managed master secret payload (`{username, password}` JSON). We only need
   the password here — the username is carried on `connectionConfig` (deploy-time
   known) so the pool can be constructed without first awaiting the secret. */
 let passwordFromSecret = async (secretArn: string): string => {
-  let out =
-    await {AwsSdk.SecretsManager.GetSecretValueCommand.secretId: secretArn}
-    ->AwsSdk.SecretsManager.GetSecretValueCommand.make
-    ->AwsSdk.SecretsManager.GetSecretValueCommand.send
+  let out = await {AwsSdk.SecretsManager.GetSecretValueCommand.secretId: secretArn}
+  ->AwsSdk.SecretsManager.GetSecretValueCommand.make
+  ->AwsSdk.SecretsManager.GetSecretValueCommand.send
   switch out.secretString {
   | Some(str) =>
     switch str->JSON.parseOrThrow->JSON.Decode.object {
@@ -29,8 +27,7 @@ let passwordFromSecret = async (secretArn: string): string => {
       }
     | None => JsError.throwWithMessage("Secrets Manager secret is not a JSON object")
     }
-  | None =>
-    JsError.throwWithMessage(`Secrets Manager secret ${secretArn} has no SecretString`)
+  | None => JsError.throwWithMessage(`Secrets Manager secret ${secretArn} has no SecretString`)
   }
 }
 

package/src/adapter/QueryDb/PgQueryResolver_Builder.res

@@ -41,8 +41,7 @@ type resolverEntry = {
   includeIdParam: bool,
 }
 let entries: dict<resolverEntry> = Dict.make()
-let register = (entry: resolverEntry): unit =>
-  entries->Dict.set(entry.readModelName, entry)
+let register = (entry: resolverEntry): unit => entries->Dict.set(entry.readModelName, entry)
 
 // Relay node type → read-model-name, populated per RM by QueryDbResolvers_Lambda.
 // Baked into the env config so the entry point can serve the shared node(id).
@@ -138,14 +137,10 @@ let provision = (
     // In-VPC on the DB-access security group + private subnets (reach RDS).
     let vpcConfig =
       selection.securityGroupId
-      ->Pulumi.Output.apply(sgId =>
-        (
-          {
-            Lambda.Function.subnetIds: selection.subnetIds->Pulumi.Input.make,
-            securityGroupIds: [sgId->Pulumi.Input.make]->Pulumi.Input.make,
-          }: Lambda.Function.vpcConfig
-        )
-      )
+      ->Pulumi.Output.apply((sgId): Lambda.Function.vpcConfig => {
+        Lambda.Function.subnetIds: selection.subnetIds->Pulumi.Input.make,
+        securityGroupIds: [sgId->Pulumi.Input.make]->Pulumi.Input.make,
+      })
       ->Pulumi.Output.asInput
 
     let runtime = RuntimeEnvironment_Lambda.makeFromCodeAsset(
@@ -239,6 +234,9 @@ let provision = (
 
     // Fulfil the deferred name the Postgres storage maker handed to resolvers.
     let _ = dataSource.name->Pulumi.Output.apply(n => resolveDataSourceName.contents(n))
-    log.info(~comp="PgQueryResolver_Builder", `provisioned for ${handlers->Array.length->Int.toString} read model(s)`)
+    log.info(
+      ~comp="PgQueryResolver_Builder",
+      `provisioned for ${handlers->Array.length->Int.toString} read model(s)`,
+    )
   }
 }

package/src/adapter/QueryDb/PgQueryResolver_Lambda.res

@@ -53,7 +53,8 @@ type payload = {
 // "Owner" → "ownerId" (auth-table owner field name, matching authorizeIndexedAccess).
 let authIdField = (group: string): string =>
   switch group->String.get(0) {
-  | Some(c) => c->String.toLowerCase ++ group->String.slice(~start=1, ~end=group->String.length) ++ "Id"
+  | Some(c) =>
+    c->String.toLowerCase ++ group->String.slice(~start=1, ~end=group->String.length) ++ "Id"
   | None => "Id"
   }
 
@@ -110,8 +111,7 @@ type binding = {
 }
 
 // -- arg helpers -------------------------------------------------------------
-let argObj = (args: JSON.t): dict<JSON.t> =>
-  args->JSON.Decode.object->Option.getOr(Dict.make())
+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> =>
@@ -144,7 +144,10 @@ let emptyConnection = (): JSON.t =>
 // 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 => {
+let runInterceptor = async (
+  ~binding,
+  ~payload,
+): ReventlessCore.QueryDb_Callback.interceptResult => {
   if !Reventless.Authorization.isAllowed(binding.authorization, payload.identity) {
     Deny("Forbidden")
   } else {
@@ -187,8 +190,7 @@ let dispatch = async (
       switch payload.identity->Reventless.OwnerScope.decide(~ownerField=binding.ownerField) {
       | Unscoped => true
       | RefuseOwned => false
-      | ScopeTo(field, required) =>
-        item->argStr(field)->Option.mapOr(false, v => v == required)
+      | ScopeTo(field, required) => item->argStr(field)->Option.mapOr(false, v => v == required)
       }
     // The caller's request to see the archive, honoured only where the
     // classification says it counts.
@@ -254,9 +256,8 @@ let dispatch = async (
         found->Array.length < ids->Array.length
           ? ids->Array.filterMap(ReventlessCore.Api_Ids.alternateKey)
           : []
-      let extra = missing->Array.length > 0
-        ? await binding.pushdowns.byIds(~readModelName=rm, missing)
-        : []
+      let extra =
+        missing->Array.length > 0 ? await binding.pushdowns.byIds(~readModelName=rm, missing) : []
       JSON.Encode.array(
         Array.concat(found, extra)->Array.filter(item => ownerAllows(item) && retiredAllows(item)),
       )
@@ -272,9 +273,8 @@ let dispatch = async (
         found->Array.length < ids->Array.length
           ? ids->Array.filterMap(ReventlessCore.Api_Ids.alternateKey)
           : []
-      let extra = missing->Array.length > 0
-        ? await binding.pushdowns.byIds(~readModelName=rm, missing)
-        : []
+      let extra =
+        missing->Array.length > 0 ? await binding.pushdowns.byIds(~readModelName=rm, missing) : []
       let retirementOf = (item: JSON.t) =>
         switch binding.retiredField {
         | None => (false, None)
@@ -386,9 +386,9 @@ let dispatch = async (
       }
       if authorized {
         JSON.Encode.array(
-          (await binding.pushdowns.indexLookup(~readModelName=rm, field, value))->Array.filter(
-            item => ownerAllows(item) && retiredAllows(item),
-          ),
+          (
+            await binding.pushdowns.indexLookup(~readModelName=rm, field, value)
+          )->Array.filter(item => ownerAllows(item) && retiredAllows(item)),
         )
       } else {
         JSON.Encode.array([])
@@ -448,11 +448,10 @@ let dispatch = async (
       // Optional target sort-key filter (source field or GraphQL arg).
       let filtered = switch (payload.sourceSubId, binding.subIdField) {
       | (Some({kind, name}), Some(subField)) =>
-        let subVal =
-          switch kind {
-          | "arg" => payload.arguments->argStr(name)
-          | _ => source->argStr(name)
-          }->Option.getOr("")
+        let subVal = switch kind {
+        | "arg" => payload.arguments->argStr(name)
+        | _ => source->argStr(name)
+        }->Option.getOr("")
         items->Array.filter(it => it->argStr(subField)->Option.getOr("") == subVal)
       | _ => items
       }
@@ -555,7 +554,9 @@ let handler = async (payload: payload, _context) => {
     | Some(binding) =>
       await dispatch(~binding, ~lookupBinding=name => bindings->Dict.get(name), ~payload)
     | None =>
-      JsError.throwWithMessage("PgQueryResolver: no binding registered for read model " ++ bindingKey)
+      JsError.throwWithMessage(
+        "PgQueryResolver: no binding registered for read model " ++ bindingKey,
+      )
     }
   }
 }

package/src/adapter/QueryDb/QueryDbResolvers_AppSync.res

@@ -250,7 +250,8 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
     // SDL the in-memory adapter does, so the AWS Filter / OrderBy stays in lockstep
     // with the SDL emitted by GraphQL_FragmentGenerator at runtime.
     let capability = switch stateSchemaOpt {
-    | Some(s) => ReventlessCore.GraphQL_FragmentGenerator.deriveServerCapability(~entityName=name, s)
+    | Some(s) =>
+      ReventlessCore.GraphQL_FragmentGenerator.deriveServerCapability(~entityName=name, s)
     | None => ReventlessCore.GraphQL_FragmentGenerator.emptyCapability
     }
     let filterFieldNames = capability.filterFields->Array.map(f => f.name)
@@ -262,11 +263,10 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
     // JS-runtime per-page sort over a full Scan (expensive in production).
     switch stateSchemaOpt {
     | Some(s) =>
-      let knownSortFields =
-        switch subIdField {
-        | Some(f) => [f]
-        | None => []
-        }->Array.concat(indexes->Array.filterMap(({subIdField: ?sf}) => sf))
+      let knownSortFields = switch subIdField {
+      | Some(f) => [f]
+      | None => []
+      }->Array.concat(indexes->Array.filterMap(({subIdField: ?sf}) => sf))
       ReventlessCore.GraphQL_FragmentGenerator.validateScanSortAlignment(
         ~schema=s,
         ~readModelName=name,
@@ -314,8 +314,7 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
         `${name}: @owner field "${f}" keys no index on this table, so owner-scoped ` ++
         "reads Scan the table and filter after the page is read — cost grows with the " ++
         "table while the answer shrinks with the caller's share of it. Drop " ++
-        "`@owner({index: false})` to let the framework derive the index, or accept " ++
-        "the cost on a view that stays small.",
+        "`@owner({index: false})` to let the framework derive the index, or accept " ++ "the cost on a view that stays small.",
       )
     | _ => ()
     }
@@ -347,8 +346,7 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
         ~comp="QueryDbResolvers_AppSync",
         `${name}: @retired field "${f}" is filtered after the page is read, so pages ` ++
         `shrink as the archive's share of the rows grows. This view is scoped on "${o}", ` ++
-        "so a scoped caller only sifts their own partition and pays in proportion to " ++
-        "their rows; it is the elevated whole-table read that pays in full.",
+        "so a scoped caller only sifts their own partition and pays in proportion to " ++ "their rows; it is the elevated whole-table read that pays in full.",
       )
     | (Some(f), None) =>
       log.warn(
@@ -356,8 +354,7 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
         `${name}: @retired field "${f}" is filtered after the page is read, so pages ` ++
         "shrink as the archive's share of the rows grows. An @index on that field " ++
         "would not help — the list read does not use one, and a flag makes a poor " ++
-        "partition key. Reshape the view so the rows you serve are the rows you " ++
-        "keep, or accept the cost while the archive stays small.",
+        "partition key. Reshape the view so the rows you serve are the rows you " ++ "keep, or accept the cost while the archive stays small.",
       )
     | (None, _) => ()
     }
@@ -385,108 +382,109 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
     // Derived indexes are absent from the SDL (`GraphQL_FragmentGenerator` skips
     // them), so a resolver here would attach to a field that does not exist and
     // fail the deploy. The list resolver above is the only thing that reads one.
-    let resolversByIndex = indexes
-    ->Array.filter(ic => !Reventless.ReadModel.isDerivedIndex(ic))
-    ->Array.map(({index} as indexConfig) => {
-      // Name and key field both come from `GraphQL_FragmentGenerator`, which is
-      // where the SDL field this attaches to is derived. Deriving them here as
-      // well is how the two came to disagree: the emitted field declared `id`
-      // while this resolver read the index key, so the door could not be called.
-      let fieldName = ReventlessCore.GraphQL_FragmentGenerator.indexQueryFieldName(
-        ~singleFieldName=fieldNameForSingle,
-        ~index,
-      )
-      let resolverName = fieldName->String.capitalize
-      let idField = ReventlessCore.GraphQL_FragmentGenerator.indexKeyField(indexConfig)
-      switch indexConfig.authorization {
-      | None =>
-        makeQueryResolver(
-          ~resolverName,
-          ~field=fieldName->Pulumi.Input.make,
-          ~code=switch indexConfig.subIdField {
-          | Some(sortField) =>
-            Resolver.Functions.queryByIndexSortFiltered(
-              ~index,
-              ~idField,
-              ~sortField,
-              ~ownerField?,
-              ~retiredField?,
-              ~retiredValues?,
-              ~elevatedGroups,
-            )
-          | None =>
-            Resolver.Functions.queryByIndexFiltered(
+    let resolversByIndex =
+      indexes
+      ->Array.filter(ic => !Reventless.ReadModel.isDerivedIndex(ic))
+      ->Array.map(({index} as indexConfig) => {
+        // Name and key field both come from `GraphQL_FragmentGenerator`, which is
+        // where the SDL field this attaches to is derived. Deriving them here as
+        // well is how the two came to disagree: the emitted field declared `id`
+        // while this resolver read the index key, so the door could not be called.
+        let fieldName = ReventlessCore.GraphQL_FragmentGenerator.indexQueryFieldName(
+          ~singleFieldName=fieldNameForSingle,
+          ~index,
+        )
+        let resolverName = fieldName->String.capitalize
+        let idField = ReventlessCore.GraphQL_FragmentGenerator.indexKeyField(indexConfig)
+        switch indexConfig.authorization {
+        | None =>
+          makeQueryResolver(
+            ~resolverName,
+            ~field=fieldName->Pulumi.Input.make,
+            ~code=switch indexConfig.subIdField {
+            | Some(sortField) =>
+              Resolver.Functions.queryByIndexSortFiltered(
+                ~index,
+                ~idField,
+                ~sortField,
+                ~ownerField?,
+                ~retiredField?,
+                ~retiredValues?,
+                ~elevatedGroups,
+              )
+            | None =>
+              Resolver.Functions.queryByIndexFiltered(
+                ~index,
+                ~idField,
+                ~ownerField?,
+                ~retiredField?,
+                ~retiredValues?,
+                ~elevatedGroups,
+              )
+            },
+          )
+        | Some({tableName, group}) =>
+          let authDataSource = DataSource.makeDynamoDBDataSourceWithTableName(
+            ~name=resolverName ++ "Auth",
+            ~api,
+            ~tableName=(
+              allQueryDbs
+              ->ReventlessCore.Util.QueryDb.getLocalStorageResources(tableName)
+              ->Util.DynamoDb.findResource
+            ).name,
+            ~serviceRole=apiRole,
+            ~opts,
+          )
+          let authFunction = Function.makeJs(
+            ~name=resolverName ++ "Auth",
+            ~api,
+            ~dataSource=authDataSource.name->Pulumi.Output.asInput,
+            ~code=Resolver.Functions.authorizeIndexedAccess(~index, ~group),
+            ~opts,
+          )
+          let queryFunction = Function.makeJs(
+            ~name=resolverName,
+            ~api,
+            ~dataSource=dataSourceName,
+            // No `~ownerField`, deliberately: this index declares its own
+            // authorization, and the rows it grants a group member are by
+            // construction owned by somebody else — an order assigned to a
+            // fulfilment operator belongs to the customer who placed it. Adding the
+            // owner predicate here would return nothing and revoke the access the
+            // auth table exists to grant. Retirement still applies: an archived row
+            // is withdrawn from everyone who has not asked, whoever owns it.
+            ~code=Resolver.Functions.queryByIndexFiltered(
               ~index,
               ~idField,
-              ~ownerField?,
               ~retiredField?,
               ~retiredValues?,
               ~elevatedGroups,
-            )
-          },
-        )
-      | Some({tableName, group}) =>
-        let authDataSource = DataSource.makeDynamoDBDataSourceWithTableName(
-          ~name=resolverName ++ "Auth",
-          ~api,
-          ~tableName=(
-            allQueryDbs
-            ->ReventlessCore.Util.QueryDb.getLocalStorageResources(tableName)
-            ->Util.DynamoDb.findResource
-          ).name,
-          ~serviceRole=apiRole,
-          ~opts,
-        )
-        let authFunction = Function.makeJs(
-          ~name=resolverName ++ "Auth",
-          ~api,
-          ~dataSource=authDataSource.name->Pulumi.Output.asInput,
-          ~code=Resolver.Functions.authorizeIndexedAccess(~index, ~group),
-          ~opts,
-        )
-        let queryFunction = Function.makeJs(
-          ~name=resolverName,
-          ~api,
-          ~dataSource=dataSourceName,
-          // No `~ownerField`, deliberately: this index declares its own
-          // authorization, and the rows it grants a group member are by
-          // construction owned by somebody else — an order assigned to a
-          // fulfilment operator belongs to the customer who placed it. Adding the
-          // owner predicate here would return nothing and revoke the access the
-          // auth table exists to grant. Retirement still applies: an archived row
-          // is withdrawn from everyone who has not asked, whoever owns it.
-          ~code=Resolver.Functions.queryByIndexFiltered(
-            ~index,
-            ~idField,
-            ~retiredField?,
-            ~retiredValues?,
-            ~elevatedGroups,
-          ),
-          ~opts,
-        )
-        // The interceptor leads the chain, as it does in every other Query
-        // pipeline. That position means an attempt refused by the row-level index
-        // authorization below has still been counted — the same "attempts, not
-        // outcomes" bound the hook has everywhere, since it fires before the read
-        // and never learns how it ended. Putting it after the auth step would buy
-        // outcome-accurate counts and cost the property that matters more: the
-        // interceptor is the one place a read can be REFUSED, so it has to be
-        // reachable before the pipeline spends a second table read deciding
-        // whether this caller may use the index.
-        Resolver.makePipelineJsResolver(
-          ~name=resolverName,
-          ~api,
-          ~type_="Query"->Pulumi.Input.make,
-          ~field=fieldName->Pulumi.Input.make,
-          ~code=Resolver.Functions.pipelinePassThrough,
-          ~functions=switch interceptorFunction(~resolverName) {
-          | None => [authFunction, queryFunction]
-          | Some(interceptorFn) => [interceptorFn, authFunction, queryFunction]
-          },
-          ~opts,
-        )
-      }
-    })
+            ),
+            ~opts,
+          )
+          // The interceptor leads the chain, as it does in every other Query
+          // pipeline. That position means an attempt refused by the row-level index
+          // authorization below has still been counted — the same "attempts, not
+          // outcomes" bound the hook has everywhere, since it fires before the read
+          // and never learns how it ended. Putting it after the auth step would buy
+          // outcome-accurate counts and cost the property that matters more: the
+          // interceptor is the one place a read can be REFUSED, so it has to be
+          // reachable before the pipeline spends a second table read deciding
+          // whether this caller may use the index.
+          Resolver.makePipelineJsResolver(
+            ~name=resolverName,
+            ~api,
+            ~type_="Query"->Pulumi.Input.make,
+            ~field=fieldName->Pulumi.Input.make,
+            ~code=Resolver.Functions.pipelinePassThrough,
+            ~functions=switch interceptorFunction(~resolverName) {
+            | None => [authFunction, queryFunction]
+            | Some(interceptorFn) => [interceptorFn, authFunction, queryFunction]
+            },
+            ~opts,
+          )
+        }
+      })
 
     let storageResource = (~pluginName: option<string>, ~tableName: string) =>
       allQueryDbs
@@ -711,8 +709,13 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
     // is independent of whether this view has a sub-id door, and adding a third
     // dimension to that match would spell eight cases to say one thing.
     let refsResolvers = resolverRefs->Option.mapOr([], r => [r])
-    Array.flat([mainResolvers, refsResolvers, resolversByIndex, idResolvers, idsResolvers])
-    ->Array.map(Util.AppSync.toResourceNative)
+    Array.flat([
+      mainResolvers,
+      refsResolvers,
+      resolversByIndex,
+      idResolvers,
+      idsResolvers,
+    ])->Array.map(Util.AppSync.toResourceNative)
   }
 
   {resources: [], resourcesMaker}

package/src/adapter/QueryDb/QueryDbResolvers_Lambda.res

@@ -184,13 +184,7 @@ let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
     // 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",
-        ),
-      ]
+      [mkResolver(~resolverName=byIdsField->String.capitalize, ~field=byIdsField, ~kind="byIds")]
     } else {
       []
     }

package/src/adapter/QueryDb/QueryDbStorage.res

@@ -24,7 +24,8 @@ module Selectable = {
     ~ttl=?,
     ~api,
     ~apiRole,
-    ~owner, ~opts,
+    ~owner,
+    ~opts,
   ) =>
     if QueryDbBackend.isPostgresFor(name) {
       Postgres.make(~name, ~indexes, ~subIdField?, ~ttl?, ~api, ~apiRole, ~owner, ~opts)
@@ -43,7 +44,8 @@ module SelectableStream = {
     ~ttl=?,
     ~api,
     ~apiRole,
-    ~owner, ~opts,
+    ~owner,
+    ~opts,
   ) =>
     if QueryDbBackend.isPostgresFor(name) {
       QueryDbBackend.postgresStreamRegistry->Set.add(name)