@reventlessdev/reventless-aws 3.0.0-alpha.167

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

@@ -0,0 +1,306 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "@reventlessdev/rescript-effect/src/Effect.res.mjs";
+import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
+import * as Stdlib_Math from "@rescript/runtime/lib/es6/Stdlib_Math.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 Effect$1 from "effect/Effect";
+import * as LibDynamodb from "@aws-sdk/lib-dynamodb";
+import * as QueryDb$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb.res.mjs";
+import * as Util_Error$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_Error.res.mjs";
+import * as EffectLogger$ReventlessCore from "@reventlessdev/reventless-core/src/util/EffectLogger.res.mjs";
+import * as DynamoDb_Error$ReventlessAws from "../../errors/DynamoDb_Error.res.mjs";
+import * as DynamoDb_DocumentClient$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_DocumentClient.res.mjs";
+import * as Util_DynamoDb_Runtime$ReventlessAws from "../../util/Util_DynamoDb_Runtime.res.mjs";
+
+function loadStream(table) {
+  return id => {
+    let baseParams_TableName = table.name;
+    let baseParams_ConsistentRead = true;
+    let baseParams_ExpressionAttributeValues = Object.fromEntries([[
+        ":id",
+        id
+      ]]);
+    let baseParams_KeyConditionExpression = "id=:id";
+    let baseParams = {
+      TableName: baseParams_TableName,
+      ConsistentRead: baseParams_ConsistentRead,
+      ExpressionAttributeValues: baseParams_ExpressionAttributeValues,
+      KeyConditionExpression: baseParams_KeyConditionExpression
+    };
+    return Stream.paginateEffect(undefined, cursor => Effect$1.map(Effect$1.catchAll(Effect$1.retry(Effect.tryPromise(DynamoDb_Error$ReventlessAws.classify, () => {
+      let params;
+      if (cursor !== undefined) {
+        let newrecord = {...baseParams};
+        newrecord.ExclusiveStartKey = cursor;
+        params = newrecord;
+      } else {
+        params = baseParams;
+      }
+      return DynamoDb_DocumentClient$AwsSdk.QueryCommand.send(new LibDynamodb.QueryCommand(params));
+    }), DynamoDb_Error$ReventlessAws.retrySchedule), err => Effect$1.fail({
+      TAG: "NotLoadedFromStorage",
+      _0: DynamoDb_Error$ReventlessAws.message(err)
+    })), result => [
+      Stdlib_Option.getOr(result.Items, []).map(js => JSON.parse(Stdlib_Option.getOr(JSON.stringify(js), ""))),
+      Stdlib_Option.map(result.LastEvaluatedKey, key => key)
+    ]));
+  };
+}
+
+function load(table) {
+  return id => Effect$1.runPromise(Effect$1.catchAll(Effect$1.map(Stream.runCollect(loadStream(table)(id)), arr => ({
+    TAG: "Ok",
+    _0: arr
+  })), err => {
+    let tableName = table.name;
+    let msg = QueryDb$ReventlessCore.storageErrorToString(err);
+    return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `load: Couldn't load state for ` + id + ` from ` + tableName + `: ` + msg), () => ({
+      TAG: "Error",
+      _0: err
+    }));
+  }));
+}
+
+function save(table) {
+  return (id, json, saveMode, ttl) => {
+    let tableName = table.name;
+    let json$1 = Util_DynamoDb_Runtime$ReventlessAws.insertTtl(json, ttl);
+    let tmp;
+    let exit = 0;
+    switch (saveMode) {
+      case "Init" :
+        tmp = Effect$1.flatMap(Util_DynamoDb_Runtime$ReventlessAws.putIfNotExistsWithRetries(table.hashKey, table.rangeKey, table, id, json$1), result => {
+          if (result.TAG === "Ok") {
+            return Effect$1.map(EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `save: saved Init state to ` + tableName + `: id=` + id), () => ({
+              TAG: "Ok",
+              _0: undefined
+            }));
+          }
+          let errorMsg = result._0;
+          return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `save: Couldn't save Init state to ` + tableName + `, id=` + id + `: ` + errorMsg), () => ({
+            TAG: "Error",
+            _0: {
+              TAG: "NotSavedToStorage",
+              _0: errorMsg
+            }
+          }));
+        });
+        break;
+      case "Overwrite" :
+      case "Any" :
+        exit = 1;
+        break;
+    }
+    if (exit === 1) {
+      tmp = Effect$1.flatMap(Util_DynamoDb_Runtime$ReventlessAws.putWithRetries(table, id, json$1), result => {
+        if (result.TAG === "Ok") {
+          return Effect$1.map(EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `save: saved state to ` + tableName + `: id=` + id), () => ({
+            TAG: "Ok",
+            _0: undefined
+          }));
+        }
+        let errorMsg = result._0;
+        return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `save: Couldn't save state to ` + tableName + `, id=` + id + `: ` + errorMsg), () => ({
+          TAG: "Error",
+          _0: {
+            TAG: "NotSavedToStorage",
+            _0: errorMsg
+          }
+        }));
+      });
+    }
+    return Effect$1.runPromise(tmp);
+  };
+}
+
+function sliceBatch(arr, batchNr) {
+  let start = batchNr * DynamoDb_DocumentClient$AwsSdk.BatchWriteCommand.maxBatchSize | 0;
+  let end = start + DynamoDb_DocumentClient$AwsSdk.BatchWriteCommand.maxBatchSize | 0;
+  return arr.slice(start, end);
+}
+
+function writeMultiple(writeRequests, op, ids, table) {
+  let tableName = table.name;
+  let count = ids.length.toString();
+  let allIdsStr = ids.join(", ");
+  let size = writeRequests.length;
+  let batches = Stdlib_Math.Int.ceil(size / DynamoDb_DocumentClient$AwsSdk.BatchWriteCommand.maxBatchSize);
+  let logSplitEffect = batches > 1 ? EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `writeBatch: splitting up batch of size ` + size.toString() + ` into ` + batches.toString() + ` batches`) : Effect$1.succeed();
+  let batchEffects = Stdlib_Array.fromInitializer(batches, batchNr => Effect$1.map(Util_DynamoDb_Runtime$ReventlessAws.batchWriteWithRetries(Util_DynamoDb_Runtime$ReventlessAws.toTable(sliceBatch(writeRequests, batchNr), tableName)), result => {
+    let batchIds = sliceBatch(ids, batchNr);
+    let batchCount = batchIds.length.toString();
+    let batchIdsStr = batchIds.join(", ");
+    if (result.TAG === "Ok") {
+      return;
+    } else {
+      return `Batch ` + batchNr.toString() + `: ` + batchCount + ` ids:` + batchIdsStr + `: ` + result._0;
+    }
+  }));
+  return Effect$1.runPromise(Effect$1.catchAll(Effect$1.flatMap(Effect$1.map(Effect$1.flatMap(logSplitEffect, () => Effect$1.all(batchEffects, {
+    concurrency: "unbounded"
+  })), results => Stdlib_Array.filterMap(results, x => x)), errors => {
+    if (errors.length === 0) {
+      return Effect$1.map(EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `writeBatch: ` + op + ` ` + count + ` states: ` + tableName + `, ids:` + allIdsStr), () => ({
+        TAG: "Ok",
+        _0: undefined
+      }));
+    }
+    let errorsStr = errors.join("; ");
+    let errorMsg = `writeBatch: Couldn't save states to ` + tableName + `: ` + errorsStr;
+    return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, errorMsg), () => ({
+      TAG: "Error",
+      _0: {
+        TAG: "BatchNotFullyWrittenToStorage",
+        _0: errorMsg
+      }
+    }));
+  }), err => {
+    let msg = DynamoDb_Error$ReventlessAws.message(err);
+    let errorMsg = `writeBatch: Couldn't save states to ` + tableName + `, ` + count + ` ids:` + allIdsStr + `: ` + msg;
+    return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, errorMsg), () => ({
+      TAG: "Error",
+      _0: {
+        TAG: "BatchNotFullyWrittenToStorage",
+        _0: errorMsg
+      }
+    }));
+  }));
+}
+
+function saveBatch(table) {
+  return async items => {
+    let len = items.length;
+    if (len !== 1) {
+      if (len === 0) {
+        return {
+          TAG: "Ok",
+          _0: undefined
+        };
+      }
+      let ids = items.map(param => param[0]);
+      return await writeMultiple(items.map(param => Util_DynamoDb_Runtime$ReventlessAws.toPutRequest(Util_DynamoDb_Runtime$ReventlessAws.insertTtl(Util_DynamoDb_Runtime$ReventlessAws.injectId(param[1], table.hashKey, param[0]), param[2]))), "finished put", ids, table);
+    }
+    let match = items[0];
+    return await save(table)(match[0], match[1], "Any", match[2]);
+  };
+}
+
+function count(table) {
+  return (id, fieldName, inc) => {
+    let tableName = table.name;
+    return Effect$1.runPromise(Effect$1.catchAll(Effect$1.flatMap(Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `count: ` + tableName + `, ` + id + `, ` + fieldName + `, ` + inc.toString()), () => Effect.tryPromise(err => Util_Error$ReventlessCore.messageFromUnknown(err, "count"), () => DynamoDb_DocumentClient$AwsSdk.UpdateCommand.send(new LibDynamodb.UpdateCommand({
+      Key: Object.fromEntries([[
+          "id",
+          id
+        ]]),
+      TableName: tableName,
+      ExpressionAttributeNames: Object.fromEntries([[
+          "#fieldName",
+          fieldName
+        ]]),
+      ExpressionAttributeValues: Object.fromEntries([[
+          ":inc",
+          inc
+        ]]),
+      ReturnValues: "UPDATED_NEW",
+      UpdateExpression: "ADD #fieldName :inc"
+    })))), updateOutput => {
+      let value = DynamoDb_DocumentClient$AwsSdk.getIntAttribute(updateOutput.Attributes, "count");
+      if (value !== undefined) {
+        return Effect$1.succeed({
+          TAG: "Ok",
+          _0: value
+        });
+      } else {
+        return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `count: Invalid updateOutput in count on ` + tableName), () => ({
+          TAG: "Error",
+          _0: {
+            TAG: "NotCountedOnStorage",
+            _0: "Invalid updateOutput in count"
+          }
+        }));
+      }
+    }), errorMsg => Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `count: Couldn't count on ` + tableName + `: ` + errorMsg), () => ({
+      TAG: "Error",
+      _0: {
+        TAG: "NotCountedOnStorage",
+        _0: errorMsg
+      }
+    }))));
+  };
+}
+
+function $$delete(table) {
+  return (id, sort) => {
+    let tableName = table.name;
+    return Effect$1.runPromise(Effect$1.flatMap(Util_DynamoDb_Runtime$ReventlessAws.deleteWithRetries(sort, table, id), result => {
+      if (result.TAG === "Ok") {
+        return Effect$1.map(EffectLogger$ReventlessCore.logInfo("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `delete: deleted state from ` + tableName + `: id=` + id + `, sort=` + Stdlib_Option.getOr(JSON.stringify(sort), "None")), () => ({
+          TAG: "Ok",
+          _0: undefined
+        }));
+      }
+      let errorMsg = result._0;
+      return Effect$1.map(EffectLogger$ReventlessCore.logError("QueryDbStorage_DynamoDb_Runtime-ReventlessAws", undefined, `delete: Couldn't delete state from ` + tableName + `, id=` + id + `, sort=` + Stdlib_Option.getOr(JSON.stringify(sort), "None") + `: ` + errorMsg), () => ({
+        TAG: "Error",
+        _0: {
+          TAG: "NotDeletedFromStorage",
+          _0: errorMsg
+        }
+      }));
+    }));
+  };
+}
+
+function deleteBatch(table) {
+  return async items => {
+    let len = items.length;
+    if (len !== 1) {
+      if (len === 0) {
+        return {
+          TAG: "Ok",
+          _0: undefined
+        };
+      }
+      let ids = items.map(param => param[0]);
+      return await writeMultiple(items.map(param => {
+        let sort = param[1];
+        let id = param[0];
+        if (sort !== undefined) {
+          return Util_DynamoDb_Runtime$ReventlessAws.toDeleteRequest(Object.fromEntries([
+            [
+              "id",
+              id
+            ],
+            [
+              sort[0],
+              sort[1]
+            ]
+          ]));
+        } else {
+          return Util_DynamoDb_Runtime$ReventlessAws.toDeleteRequest(Object.fromEntries([[
+              "id",
+              id
+            ]]));
+        }
+      }), "deleted", ids, table);
+    }
+    let match = items[0];
+    return await $$delete(table)(match[0], match[1]);
+  };
+}
+
+export {
+  loadStream,
+  load,
+  save,
+  sliceBatch,
+  writeMultiple,
+  saveBatch,
+  count,
+  $$delete,
+  deleteBatch,
+}
+/* Effect Not a pure module */

package/src/adapter/QueryDb/QueryInterceptor_Lambda.res

@@ -0,0 +1,20 @@
+type payload = {
+  readModelName: string,
+  arguments: JSON.t,
+  identity: Reventless.Identity.t,
+}
+
+let handler = async (event: payload, _context) => {
+  switch ReventlessCore.QueryDb_Callback.queryInterceptorHook.contents {
+  | None => true
+  | Some(interceptor) =>
+    switch await interceptor(
+      ~identity=event.identity,
+      ~readModelName=event.readModelName,
+      ~args=event.arguments,
+    ) {
+    | Allow => true
+    | Deny(msg) => JsError.throwWithMessage(msg)
+    }
+  }
+}

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

@@ -0,0 +1,22 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as QueryDb_Callback$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb_Callback.res.mjs";
+
+async function handler(event, _context) {
+  let interceptor = QueryDb_Callback$ReventlessCore.queryInterceptorHook.contents;
+  if (interceptor === undefined) {
+    return true;
+  }
+  let msg = await interceptor(event.identity, event.readModelName, event.arguments);
+  if (typeof msg !== "object") {
+    return true;
+  } else {
+    return Stdlib_JsError.throwWithMessage(msg._0);
+  }
+}
+
+export {
+  handler,
+}
+/* No side effect */

package/src/adapter/QueryEngine/QueryEngine.res

@@ -0,0 +1,3 @@
+let name = "QueryEngine"
+
+module DynamoDb = QueryEngine_DynamoDb

package/src/adapter/QueryEngine/QueryEngine.res.mjs

@@ -0,0 +1,12 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let name = "QueryEngine";
+
+let DynamoDb;
+
+export {
+  name,
+  DynamoDb,
+}
+/* No side effect */

package/src/adapter/QueryEngine/QueryEngine_DynamoDb.res

@@ -0,0 +1,184 @@
+open Reventless.QueryEngine
+
+let toJson = x =>
+  switch x {
+  | String(str) => JSON.Encode.string(str)
+  | Int(int) => JSON.Encode.float(Int.toFloat(int))
+  | Bool(bool) => JSON.Encode.bool(bool)
+  }
+
+@val @scope("JSON") external parseJs: string => _ = "parse"
+
+let createSubIdExprNamesValues = (subIdConfig: option<SubId.config>) =>
+  subIdConfig->Option.map(((subIdName, comparator, value)) => {
+    (
+      [
+        switch comparator {
+        | SubId.Equal => `#${subIdName} = :${subIdName}`
+        | Unequal => `#${subIdName} <> :${subIdName}`
+        | LessOrEqual => `#${subIdName} <= :${subIdName}`
+        | Less => `#${subIdName} < :${subIdName}`
+        | GreaterOrEqual => `#${subIdName} >= :${subIdName}`
+        | Greater => `#${subIdName} > :${subIdName}`
+        | BeginsWith => `begins_with( #${subIdName}, :${subIdName} )`
+        },
+      ],
+      [((`#${subIdName}`, subIdName), (`:${subIdName}`, value->toJson))],
+    )
+  })
+
+let createFilterExprNamesValues = filterConfigs =>
+  filterConfigs
+  ->Array.mapWithIndex(((fieldName, comparator, value), idx) => {
+    let valueName = `${fieldName}${idx->Int.toString}`
+    (
+      switch comparator {
+      | Filter.Equal => `#${fieldName} = :${valueName}`
+      | Unequal => `#${fieldName} <> :${valueName}`
+      | LessOrEqual => `#${fieldName} <= :${valueName}`
+      | Less => `#${fieldName} < :${valueName}`
+      | GreaterOrEqual => `#${fieldName} >= :${valueName}`
+      | Greater => `#${fieldName} > :${valueName}`
+      | Exists => `attribute_exists( #${fieldName} )`
+      | NotExists => `attribute_not_exists( #${fieldName} )`
+      | Contains => `contains( #${fieldName}, :${valueName} )`
+      | NotContains => `NOT contains( #${fieldName}, :${valueName} )`
+      | BeginsWith => `begins_with( #${fieldName}, :${valueName} )`
+      },
+      ((`#${fieldName}`, fieldName), (`:${valueName}`, value->toJson)),
+    )
+  })
+  ->Array.unzip
+
+let queryByTableName = (
+  ~tableName,
+  ~key="id",
+  ~id,
+  ~subIdConfig=?,
+  ~filterConfigs=[],
+  ~ascending=true,
+  ~limit=1,
+) => {
+  let (subIdExpressions, subIdNamesValues) =
+    subIdConfig->createSubIdExprNamesValues->Option.getOr(([], []))
+  let (filterExpressions, filterNamesValues) = filterConfigs->createFilterExprNamesValues
+
+  let keyConditionExpression =
+    ["#key = :value"]->Array.concat(subIdExpressions)->Array.joinUnsafe(" AND ")
+  let filterExpression = switch filterExpressions {
+  | [] => None
+  | filterExpressions => Some(filterExpressions->Array.joinUnsafe(" AND "))
+  }
+
+  let (names, values) = subIdNamesValues->Array.concat(filterNamesValues)->Array.unzip
+  let attributeValues =
+    Array.flat([[(":value", id->toJson)], values])
+    ->Dict.fromArray
+    ->JSON.Encode.object
+    ->JSON.stringify
+    ->parseJs
+
+  let attributeNames = Array.flat([[("#key", key)], names])->Dict.fromArray
+
+  let params: AwsSdk.DynamoDb.DocumentClient.QueryCommand.input = {
+    {
+      tableName,
+      indexName: ?(
+        if key == "id" {
+          None
+        } else {
+          Some(key)
+        }
+      ),
+      keyConditionExpression,
+      ?filterExpression,
+      expressionAttributeNames: attributeNames,
+      expressionAttributeValues: attributeValues,
+      scanIndexForward: ascending,
+      limit,
+    }
+  }
+  ReventlessCore.EffectLogger.logDebug(~comp=__MODULE__, "queryByTableName params: " ++ params->JSON.stringifyAny->Option.getOr(""))
+  ->Effect.flatMap(_ =>
+    Util_DynamoDb_Runtime.queryStream(params)
+    ->Stream.runCollect
+    ->Effect.map(items => items->Array.map(js => js->JSON.stringify->JSON.parseOrThrow))
+    ->Effect.catchAll(err => {
+      let msg = DynamoDb_Error.message(err)
+      ReventlessCore.EffectLogger.logError(~comp=__MODULE__, "queryByTableName: " ++ msg)->Effect.map(_ => [])
+    })
+  )
+  ->Effect.runPromise
+}
+
+let scanByTableName = (~tableName, ~filterConfigs, ~limit) => {
+  let (filterExpressions, filterNamesValues) = filterConfigs->createFilterExprNamesValues
+  let (filterNames, filterValues) = filterNamesValues->Array.unzip
+  let (filterExpression, attributeNames, attributeValues) = switch filterExpressions {
+  | [] => (None, None, None)
+  | filterExpressions => (
+      Some(filterExpressions->Array.joinUnsafe(" AND ")),
+      Some(filterNames->Dict.fromArray),
+      Some(filterValues->Dict.fromArray->JSON.Encode.object->JSON.stringify->parseJs),
+    )
+  }
+
+  let params: AwsSdk.DynamoDb.DocumentClient.ScanCommand.input = {
+    tableName,
+    ?filterExpression,
+    expressionAttributeNames: ?attributeNames,
+    expressionAttributeValues: ?attributeValues,
+    limit,
+  }
+  ReventlessCore.EffectLogger.logDebug(~comp=__MODULE__, "scanByTableName params: " ++ params->JSON.stringifyAny->Option.getOr(""))
+  ->Effect.flatMap(_ =>
+    Util_DynamoDb_Runtime.scanStream(params)
+    ->Stream.runCollect
+    ->Effect.map(items => items->Array.map(js => js->JSON.stringify->JSON.parseOrThrow))
+    ->Effect.catchAll(err => {
+      let msg = DynamoDb_Error.message(err)
+      ReventlessCore.EffectLogger.logError(~comp=__MODULE__, "scanByTableName: " ++ msg)->Effect.map(_ => [])
+    })
+  )
+  ->Effect.runPromise
+}
+
+let make: ReventlessCore.QueryDb_Adapter.queryEngineMaker = allQueryDbs => {
+  let allRuntimeQueryDbsOutputs = Dict.mapValues(allQueryDbs, (
+    queryDb: ReventlessCore.QueryDb.outputs,
+  ) =>
+    queryDb.resources
+    ->Util.DynamoDb.findResource
+    ->ReventlessCore.Adapter.resourceToResolvedOutput
+  )->Pulumi.Output.allDict
+
+  let tableName = (allRuntimeQueryDbs, readModelName) =>
+    (allRuntimeQueryDbs->ReventlessCore.Util_QueryDbRuntime.getRuntimeResource(readModelName)).name
+
+  allRuntimeQueryDbsOutputs->Pulumi.Output.apply(allRuntimeQueryDbs => {
+    scan: (~readModelName, ~filterConfigs, ~limit) =>
+      scanByTableName(
+        ~tableName=allRuntimeQueryDbs->tableName(readModelName),
+        ~filterConfigs,
+        ~limit,
+      ),
+    query: (
+      ~readModelName,
+      ~key=?,
+      ~id,
+      ~subIdConfig=?,
+      ~filterConfigs=?,
+      ~ascending=?,
+      ~limit=?,
+    ) =>
+      queryByTableName(
+        ~tableName=allRuntimeQueryDbs->tableName(readModelName),
+        ~key?,
+        ~id,
+        ~subIdConfig?,
+        ~filterConfigs?,
+        ~ascending?,
+        ~limit?,
+      ),
+  })
+}