@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/QueryDb/QueryDbResolvers_AppSync_NoOp.res

@@ -0,0 +1,21 @@
+// No-op AppSync resolver adapter — creates no resolvers.
+// Used for admin-internal read models (e.g. Plugin) that have a DynamoDB QueryDb
+// but no AppSync query fields (accessed only via queryEngine at runtime).
+type api = Types.AppSync.api
+type role = Types.AppSync.role
+
+let make: ReventlessCore.QueryDb_Adapter.resolversMaker<api, role> = (
+  ~name as _,
+  ~api as _,
+  ~apiRole as _,
+  ~dataSourceName as _,
+  ~indexes as _,
+  ~subIdField as _,
+  ~idResolverConfigs as _,
+  ~idsResolverConfigs as _,
+  ~authorization as _: Reventless.Authorization.permission,
+  ~opts as _,
+) => {
+  resources: [],
+  resourcesMaker: _ => [],
+}

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

@@ -0,0 +1,14 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function make(param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8, param$9) {
+  return {
+    resources: [],
+    resourcesMaker: param => []
+  };
+}
+
+export {
+  make,
+}
+/* No side effect */

package/src/adapter/QueryDb/QueryDbResolvers_NoOp.res

@@ -0,0 +1,21 @@
+open ReventlessCore
+open Reventless.ReadModel
+
+type api = unit
+type role = unit
+
+let make: QueryDb_Adapter.resolversMaker<api, role> = (
+  ~name as _: string,
+  ~api as _: api,
+  ~apiRole as _: role,
+  ~dataSourceName as _,
+  ~indexes as _: array<indexConfig>,
+  ~subIdField as _,
+  ~idResolverConfigs as _: array<idResolverConfig>,
+  ~idsResolverConfigs as _: array<idsResolverConfig>,
+  ~authorization as _: Reventless.Authorization.permission,
+  ~opts as _,
+) => {
+  resources: [],
+  resourcesMaker: _ => [],
+}

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

@@ -0,0 +1,14 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function make(param, param$1, param$2, param$3, param$4, param$5, param$6, param$7, param$8, param$9) {
+  return {
+    resources: [],
+    resourcesMaker: param => []
+  };
+}
+
+export {
+  make,
+}
+/* No side effect */

package/src/adapter/QueryDb/QueryDbStorage.res

@@ -0,0 +1,5 @@
+let name = "QueryDbStorage"
+
+module DynamoDb = QueryDbStorage_DynamoDb
+module DynamoDbStream = QueryDbStorage_DynamoDbStream
+module DynamoDb_Runtime = QueryDbStorage_DynamoDb_Runtime

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

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

package/src/adapter/QueryDb/QueryDbStorage_DynamoDb.res

@@ -0,0 +1,115 @@
+open PulumiAws
+open DynamoDb.Table
+
+type api = Types.AppSync.api
+type role = Types.AppSync.role
+
+let globalSecondaryIndexes = (indexes: array<Reventless.ReadModel.indexConfig>) =>
+  indexes
+  ->Array.map((indexConfig: Reventless.ReadModel.indexConfig) => {
+    let {index, projectionType} = indexConfig
+    let (projectionType, includes) = switch projectionType {
+    | Reventless.ReadModel.ALL as _projection => (PulumiAws.DynamoDb.Table.ALL, None)
+    | Reventless.ReadModel.KEYS_ONLY as _projection => (
+        PulumiAws.DynamoDb.Table.KEYS_ONLY,
+        None,
+      )
+    | Reventless.ReadModel.INCLUDE(includes) => (
+        PulumiAws.DynamoDb.Table.INCLUDE,
+        Some(includes),
+      )
+    }
+    {
+      name: index,
+      hashKey: indexConfig.idField->Option.getOr(index),
+      rangeKey: ?indexConfig.subIdField,
+      projectionType,
+      nonKeyAttributes: ?includes,
+    }->Pulumi.Input.make
+  })
+  ->Pulumi.Input.make
+
+let attributes = (sortField, indexes: array<Reventless.ReadModel.indexConfig>) =>
+  [
+    [{name: "id", type_: "S"}],
+    sortField->Option.mapOr([], sortField => [{name: sortField, type_: "S"}]),
+    indexes
+    ->Array.map((indexConfig: Reventless.ReadModel.indexConfig) => {
+      let {index, type_} = indexConfig
+      [
+        [{name: indexConfig.idField->Option.getOr(index), type_}],
+        indexConfig.subIdField->Option.mapOr([], sortField => [{name: sortField, type_: "S"}]),
+      ]->Array.flat
+    })
+    ->Array.flat,
+  ]->Array.flat
+
+let dataSource = (name, table, api, apiRole, opts) => {
+  let _dataSourceRolePolicy = {
+    IAM.RolePolicy.make(
+      ~name,
+      ~args={
+        IAM.RolePolicy.policy: table.arn
+        ->Pulumi.Output.apply(tableArn => {
+          open PolicyDocument
+          PolicyDocument.make(
+            ~id=name ++ "DataSourcePolicy",
+            ~statements=[
+              {
+                sid: "AllowDynamoDbActions",
+                effect: Allow,
+                actions: Action("dynamodb:*"),
+                resources: Resource(tableArn),
+              },
+            ],
+          )->toJsonString
+        })
+        ->Pulumi.Output.asInput,
+        role: apiRole
+        ->Pulumi.Output.flatMap((role: PulumiAws.IAM.Role.t) => role.id)
+        ->Pulumi.Output.asInput,
+      },
+      ~opts,
+    )
+  }
+
+  AppSync.DataSource.makeDynamoDBDataSource(~name, ~api, ~table, ~serviceRole=apiRole, ~opts)
+}
+
+let make: ReventlessCore.QueryDb_Adapter.storageMaker<api, role> = (
+  ~name,
+  ~indexes,
+  ~subIdField=?,
+  ~ttl=?,
+  ~api,
+  ~apiRole,
+  ~opts,
+) => {
+  let tags = AWS.Tags.make(~name, ReventlessCore.QueryDb.componentType)
+  let table = Util_DynamoDb.makeTable(
+    name,
+    ~attributes=attributes(subIdField, indexes),
+    ~rangeKey=?subIdField,
+    ~globalSecondaryIndexes=indexes->globalSecondaryIndexes,
+    ~ttl?,
+    ~tags,
+    ~opts,
+  )
+
+  open QueryDbStorage_DynamoDb_Runtime
+  {
+    resources: [table->Util_DynamoDb.toResource(~tags=tags->Pulumi.Output.fromInput)],
+    dataSourceName: dataSource(name, table, api, apiRole, opts).name,
+    operations: table
+    ->Util_DynamoDb.toResolvedTableOutput
+    ->Pulumi.Output.apply(resolvedTable => {
+      ReventlessCore.QueryDb.load: resolvedTable->load,
+      loadStream: resolvedTable->loadStream,
+      save: resolvedTable->save,
+      saveBatch: resolvedTable->saveBatch,
+      count: resolvedTable->count,
+      delete: resolvedTable->delete,
+      deleteBatch: resolvedTable->deleteBatch,
+    }),
+  }
+}

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

@@ -0,0 +1,100 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Aws from "@pulumi/aws";
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as AWS_Tags$ReventlessAws from "../AWS_Tags.res.mjs";
+import * as QueryDb$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb.res.mjs";
+import * as PolicyDocument$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/IAM/PolicyDocument.res.mjs";
+import * as Util_DynamoDb$ReventlessAws from "../../util/Util_DynamoDb.res.mjs";
+import * as AppSync_DataSource$PulumiAws from "@reventlessdev/rescript-pulumi-aws/src/AppSync/AppSync_DataSource.res.mjs";
+import * as QueryDbStorage_DynamoDb_Runtime$ReventlessAws from "./QueryDbStorage_DynamoDb_Runtime.res.mjs";
+
+function globalSecondaryIndexes(indexes) {
+  return indexes.map(indexConfig => {
+    let projectionType = indexConfig.projectionType;
+    let index = indexConfig.index;
+    let match;
+    match = typeof projectionType !== "object" ? (
+        projectionType === "KEYS_ONLY" ? [
+            "KEYS_ONLY",
+            undefined
+          ] : [
+            "ALL",
+            undefined
+          ]
+      ) : [
+        "INCLUDE",
+        projectionType._0
+      ];
+    return {
+      hashKey: Stdlib_Option.getOr(indexConfig.idField, index),
+      name: index,
+      projectionType: match[0],
+      nonKeyAttributes: match[1],
+      rangeKey: indexConfig.subIdField
+    };
+  });
+}
+
+function attributes(sortField, indexes) {
+  return [
+    [{
+        name: "id",
+        type: "S"
+      }],
+    Stdlib_Option.mapOr(sortField, [], sortField => [{
+        name: sortField,
+        type: "S"
+      }]),
+    indexes.map(indexConfig => [
+      [{
+          name: Stdlib_Option.getOr(indexConfig.idField, indexConfig.index),
+          type: indexConfig.type_
+        }],
+      Stdlib_Option.mapOr(indexConfig.subIdField, [], sortField => [{
+          name: sortField,
+          type: "S"
+        }])
+    ].flat()).flat()
+  ].flat();
+}
+
+function dataSource(name, table, api, apiRole, opts) {
+  new (Aws.iam.RolePolicy)(name, {
+    policy: table.arn.apply(tableArn => PolicyDocument$PulumiAws.toJsonString(PolicyDocument$PulumiAws.make(undefined, name + "DataSourcePolicy", [{
+        Sid: "AllowDynamoDbActions",
+        Effect: "Allow",
+        Action: "dynamodb:*",
+        Resource: tableArn
+      }]))),
+    role: Output$Pulumi.flatMap(apiRole, role => role.id)
+  }, opts);
+  return AppSync_DataSource$PulumiAws.makeDynamoDBDataSource(name, api, table, apiRole, opts);
+}
+
+function make(name, indexes, subIdField, ttl, api, apiRole, opts) {
+  let tags = AWS_Tags$ReventlessAws.make(name, QueryDb$ReventlessCore.componentType);
+  let table = Util_DynamoDb$ReventlessAws.makeTable(attributes(subIdField, indexes), globalSecondaryIndexes(indexes), ttl, subIdField, tags, opts, name);
+  return {
+    resources: [Util_DynamoDb$ReventlessAws.toResource(tags, table)],
+    dataSourceName: dataSource(name, table, api, apiRole, opts).name,
+    operations: Util_DynamoDb$ReventlessAws.toResolvedTableOutput(table).apply(resolvedTable => ({
+      load: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.load(resolvedTable),
+      loadStream: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.loadStream(resolvedTable),
+      save: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.save(resolvedTable),
+      saveBatch: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.saveBatch(resolvedTable),
+      count: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.count(resolvedTable),
+      delete: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.$$delete(resolvedTable),
+      deleteBatch: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.deleteBatch(resolvedTable)
+    }))
+  };
+}
+
+export {
+  globalSecondaryIndexes,
+  attributes,
+  dataSource,
+  make,
+}
+/* @pulumi/aws Not a pure module */

package/src/adapter/QueryDb/QueryDbStorage_DynamoDbStream.res

@@ -0,0 +1,52 @@
+open QueryDbStorage_DynamoDb
+
+type api = Types.AppSync.api
+type role = Types.AppSync.role
+
+/** ReadModel Spec.names for which a stream-enabled QueryDb was created in this deploy.
+    Read by subscriptionInfraHook to decide which QueryDbs get a StateTopic Lambda. */
+let streamRegistry: Set.t<string> = Set.make()
+
+let make: ReventlessCore.QueryDb_Adapter.storageMaker<api, role> = (
+  ~name,
+  ~indexes,
+  ~subIdField=?,
+  ~ttl=?,
+  ~api,
+  ~apiRole,
+  ~opts,
+) => {
+  streamRegistry->Set.add(name)
+  let tags = AWS.Tags.make(~name, ReventlessCore.QueryDb.componentType)
+  let table = Util_DynamoDbStream.makeTable(
+    name,
+    ~attributes=attributes(subIdField, indexes),
+    ~rangeKey=?subIdField,
+    ~globalSecondaryIndexes=indexes->globalSecondaryIndexes,
+    ~ttl?,
+    ~streamViewType=NEW_AND_OLD_IMAGES,
+    ~tags,
+    ~opts,
+  )
+  open QueryDbStorage_DynamoDb_Runtime
+  {
+    resources: [
+      // DynamoDb service resource required by QueryEngine_DynamoDb and QueryDbResolvers_AppSync
+      table->Util_DynamoDb.toResource(~tags=tags->Pulumi.Output.fromInput),
+      // DynamoDbStream service resource required by StateTopic_AppSync (stream ARN in resourceInfo)
+      table->Util_DynamoDbStream.toResource(~tags=tags->Pulumi.Output.fromInput),
+    ],
+    dataSourceName: dataSource(name, table, api, apiRole, opts).name,
+    operations: table
+    ->Util_DynamoDb.toResolvedTableOutput
+    ->Pulumi.Output.apply(resolvedTable => {
+      ReventlessCore.QueryDb.load: resolvedTable->load,
+      loadStream: resolvedTable->loadStream,
+      save: resolvedTable->save,
+      saveBatch: resolvedTable->saveBatch,
+      count: resolvedTable->count,
+      delete: resolvedTable->delete,
+      deleteBatch: resolvedTable->deleteBatch,
+    }),
+  }
+}

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

@@ -0,0 +1,38 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as AWS_Tags$ReventlessAws from "../AWS_Tags.res.mjs";
+import * as QueryDb$ReventlessCore from "@reventlessdev/reventless-core/src/components/QueryDb/QueryDb.res.mjs";
+import * as Util_DynamoDb$ReventlessAws from "../../util/Util_DynamoDb.res.mjs";
+import * as Util_DynamoDbStream$ReventlessAws from "../../util/Util_DynamoDbStream.res.mjs";
+import * as QueryDbStorage_DynamoDb$ReventlessAws from "./QueryDbStorage_DynamoDb.res.mjs";
+import * as QueryDbStorage_DynamoDb_Runtime$ReventlessAws from "./QueryDbStorage_DynamoDb_Runtime.res.mjs";
+
+let streamRegistry = new Set();
+
+function make(name, indexes, subIdField, ttl, api, apiRole, opts) {
+  streamRegistry.add(name);
+  let tags = AWS_Tags$ReventlessAws.make(name, QueryDb$ReventlessCore.componentType);
+  let table = Util_DynamoDbStream$ReventlessAws.makeTable(QueryDbStorage_DynamoDb$ReventlessAws.attributes(subIdField, indexes), QueryDbStorage_DynamoDb$ReventlessAws.globalSecondaryIndexes(indexes), ttl, subIdField, "NEW_AND_OLD_IMAGES", tags, opts, name);
+  return {
+    resources: [
+      Util_DynamoDb$ReventlessAws.toResource(tags, table),
+      Util_DynamoDbStream$ReventlessAws.toResource(tags, table)
+    ],
+    dataSourceName: QueryDbStorage_DynamoDb$ReventlessAws.dataSource(name, table, api, apiRole, opts).name,
+    operations: Util_DynamoDb$ReventlessAws.toResolvedTableOutput(table).apply(resolvedTable => ({
+      load: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.load(resolvedTable),
+      loadStream: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.loadStream(resolvedTable),
+      save: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.save(resolvedTable),
+      saveBatch: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.saveBatch(resolvedTable),
+      count: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.count(resolvedTable),
+      delete: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.$$delete(resolvedTable),
+      deleteBatch: QueryDbStorage_DynamoDb_Runtime$ReventlessAws.deleteBatch(resolvedTable)
+    }))
+  };
+}
+
+export {
+  streamRegistry,
+  make,
+}
+/* streamRegistry Not a pure module */

package/src/adapter/QueryDb/QueryDbStorage_DynamoDb_Runtime.res

@@ -0,0 +1,271 @@
+open AwsSdk.DynamoDb.DocumentClient
+open Util_DynamoDb_Runtime
+// Belt.Result removed — Ok/Error are global in RescriptCore
+
+// True lazy pagination: each DynamoDB page is fetched on demand.
+// Per-page retry is handled inside the paginateEffect callback.
+// Stream.take(n) short-circuits pagination once n items are consumed.
+let loadStream = table =>
+  id => {
+    let baseParams: QueryCommand.input = {
+      tableName: table.name,
+      consistentRead: true,
+      keyConditionExpression: "id=:id",
+      expressionAttributeValues: [(":id", id->JSON.Encode.string)]->Dict.fromArray,
+    }
+    Stream.paginateEffect((None: option<dict<JSON.t>>), cursor =>
+      Effect.tryPromise(
+        ~catch=DynamoDb_Error.classify,
+        () => {
+          let params = switch cursor {
+          | None => baseParams
+          | Some(key) => {...baseParams, exclusiveStartKey: key}
+          }
+          QueryCommand.send(params->QueryCommand.make)
+        },
+      )
+      ->Effect.retry(DynamoDb_Error.retrySchedule)
+      ->Effect.catchAll(err =>
+        Effect.fail(
+          ReventlessInfra.QueryDb.NotLoadedFromStorage(DynamoDb_Error.message(err)),
+        )
+      )
+      ->Effect.map(result => (
+        result.items
+        ->Option.getOr([])
+        ->Array.map(js => js->JSON.stringifyAny->Option.getOr("")->JSON.parseOrThrow),
+        result.lastEvaluatedKey->Option.map(key => Some(key)),
+      ))
+    )
+  }
+
+// Eager load derived from loadStream — collects all items into an array.
+let load = table =>
+  id =>
+    loadStream(table)(id)
+    ->Stream.runCollect
+    ->Effect.map(arr => arr->Ok)
+    ->Effect.catchAll(err => {
+      let tableName = table.name
+      let msg = ReventlessCore.QueryDb.storageErrorToString(err)
+      ReventlessCore.EffectLogger.logError(
+        ~comp=__MODULE__,
+        `load: Couldn't load state for ${id} from ${tableName}: ${msg}`,
+      )
+      ->Effect.map(_ => Error(err))
+    })
+    ->Effect.runPromise
+
+let save = table =>
+  (id, json, saveMode: ReventlessCore.QueryDb.saveMode, ttl) => {
+    let tableName = table.name
+    let json = json->insertTtl(ttl)
+
+    let effect = switch saveMode {
+    | Init =>
+      table->putIfNotExistsWithRetries(~idKey=table.hashKey, ~sortKey=?table.rangeKey, id, json)
+      ->Effect.flatMap(result =>
+        switch result {
+        | Ok() =>
+          ReventlessCore.EffectLogger.logInfo(~comp=__MODULE__, `save: saved Init state to ${tableName}: id=${id}`)
+          ->Effect.map(_ => Ok())
+        | Error(errorMsg) =>
+          ReventlessCore.EffectLogger.logError(
+            ~comp=__MODULE__,
+            `save: Couldn't save Init state to ${tableName}, id=${id}: ${errorMsg}`,
+          )
+          ->Effect.map(_ => Error(ReventlessInfra.QueryDb.NotSavedToStorage(errorMsg)))
+        }
+      )
+    | Any
+    | Overwrite =>
+      table
+      ->putWithRetries(id, json)
+      ->Effect.flatMap(result =>
+        switch result {
+        | Ok() =>
+          ReventlessCore.EffectLogger.logInfo(~comp=__MODULE__, `save: saved state to ${tableName}: id=${id}`)
+          ->Effect.map(_ => Ok())
+        | Error(errorMsg) =>
+          ReventlessCore.EffectLogger.logError(
+            ~comp=__MODULE__,
+            `save: Couldn't save state to ${tableName}, id=${id}: ${errorMsg}`,
+          )
+          ->Effect.map(_ => Error(ReventlessInfra.QueryDb.NotSavedToStorage(errorMsg)))
+        }
+      )
+    }
+    effect->Effect.runPromise
+  }
+
+let sliceBatch = (arr, batchNr) => {
+  let start = batchNr * BatchWriteCommand.maxBatchSize
+  let end = start + BatchWriteCommand.maxBatchSize
+  arr->Array.slice(~start, ~end)
+}
+
+let writeMultiple = (writeRequests, op, ids, table) => {
+  let tableName = table.name
+  let count = ids->Array.length->Int.toString
+  let allIdsStr = ids->Array.joinUnsafe(", ")
+  let size = writeRequests->Array.length
+  let batches = (size->Int.toFloat /. BatchWriteCommand.maxBatchSize->Int.toFloat)->Math.Int.ceil
+
+  let logSplitEffect =
+    if batches > 1 {
+      ReventlessCore.EffectLogger.logInfo(
+        ~comp=__MODULE__,
+        `writeBatch: splitting up batch of size ${size->Int.toString} into ${batches->Int.toString} batches`,
+      )
+    } else {
+      Effect.succeed()
+    }
+
+  let batchEffects =
+    Array.fromInitializer(~length=batches, batchNr =>
+      writeRequests
+      ->sliceBatch(batchNr)
+      ->toTable(tableName)
+      ->batchWriteWithRetries
+      ->Effect.map(result => {
+        let batchIds = ids->sliceBatch(batchNr)
+        let batchCount = batchIds->Array.length->Int.toString
+        let batchIdsStr = batchIds->Array.joinUnsafe(", ")
+        switch result {
+        | Ok() => None
+        | Error(error) =>
+          Some(`Batch ${batchNr->Int.toString}: ${batchCount} ids:${batchIdsStr}: ${error}`)
+        }
+      })
+    )
+
+  logSplitEffect
+  ->Effect.flatMap(_ =>
+    Effect.all(batchEffects, {"concurrency": "unbounded"})
+  )
+  ->Effect.map(results => results->Array.filterMap(x => x))
+  ->Effect.flatMap(errors =>
+    switch errors {
+    | [] =>
+      ReventlessCore.EffectLogger.logInfo(
+        ~comp=__MODULE__,
+        `writeBatch: ${op} ${count} states: ${tableName}, ids:${allIdsStr}`,
+      )
+      ->Effect.map(_ => Ok())
+    | errors =>
+      let errorsStr = errors->Array.joinUnsafe("; ")
+      let errorMsg = `writeBatch: Couldn't save states to ${tableName}: ${errorsStr}`
+      ReventlessCore.EffectLogger.logError(~comp=__MODULE__, errorMsg)
+      ->Effect.map(_ => Error(ReventlessInfra.QueryDb.BatchNotFullyWrittenToStorage(errorMsg)))
+    }
+  )
+  ->Effect.catchAll(err => {
+    let msg = DynamoDb_Error.message(err)
+    let errorMsg = `writeBatch: Couldn't save states to ${tableName}, ${count} ids:${allIdsStr}: ${msg}`
+    ReventlessCore.EffectLogger.logError(~comp=__MODULE__, errorMsg)
+    ->Effect.map(_ => Error(ReventlessInfra.QueryDb.BatchNotFullyWrittenToStorage(errorMsg)))
+  })
+  ->Effect.runPromise
+}
+
+let saveBatch = table =>
+  async items =>
+    switch items {
+    | [] => Ok()
+    | [(id, json, ttl)] => await save(table)(id, json, Any, ttl)
+    | items =>
+      let _tableName = table.name
+      let ids = items->Array.map(((id, _, _)) => id)
+      await items
+      ->Array.map(((id, json, ttl)) => {
+        json->Util_DynamoDb_Runtime.injectId(table.hashKey, id)->insertTtl(ttl)->toPutRequest
+      })
+      ->writeMultiple("finished put", ids, table)
+    }
+
+let count = table =>
+  (id, fieldName, inc) => {
+    let tableName = table.name
+    ReventlessCore.EffectLogger.logInfo(
+      ~comp=__MODULE__,
+      `count: ${tableName}, ${id}, ${fieldName}, ${inc->Int.toString}`,
+    )
+    ->Effect.flatMap(_ =>
+      Effect.tryPromise(
+        ~catch=err => ReventlessCore.Util.Error.messageFromUnknown(err, "count"),
+        () =>
+          UpdateCommand.make({
+            tableName,
+            key: [("id", id->JSON.Encode.string)]->Dict.fromArray,
+            updateExpression: "ADD #fieldName :inc",
+            expressionAttributeNames: [("#fieldName", fieldName)]->Dict.fromArray,
+            expressionAttributeValues: [(":inc", inc->Int.toFloat->JSON.Encode.float)]
+            ->Dict.fromArray,
+            returnValues: #UPDATED_NEW,
+          })->UpdateCommand.send,
+      )
+    )
+    ->Effect.flatMap(updateOutput =>
+      switch updateOutput.attributes->AwsSdk.DynamoDb.DocumentClient.getIntAttribute("count") {
+      | Some(value) => Effect.succeed(Ok(value))
+      | None =>
+        ReventlessCore.EffectLogger.logError(
+          ~comp=__MODULE__,
+          `count: Invalid updateOutput in count on ${tableName}`,
+        )
+        ->Effect.map(_ =>
+          Error(ReventlessInfra.QueryDb.NotCountedOnStorage("Invalid updateOutput in count"))
+        )
+      }
+    )
+    ->Effect.catchAll(errorMsg =>
+      ReventlessCore.EffectLogger.logError(~comp=__MODULE__, `count: Couldn't count on ${tableName}: ${errorMsg}`)
+      ->Effect.map(_ => Error(ReventlessInfra.QueryDb.NotCountedOnStorage(errorMsg)))
+    )
+    ->Effect.runPromise
+  }
+
+let delete = table =>
+  (id, sort) => {
+    let tableName = table.name
+    table
+    ->deleteWithRetries(id, ~sort?)
+    ->Effect.flatMap(result =>
+      switch result {
+      | Ok() =>
+        ReventlessCore.EffectLogger.logInfo(
+          ~comp=__MODULE__,
+          `delete: deleted state from ${tableName}: id=${id}, sort=${sort->JSON.stringifyAny->Option.getOr("None")}`,
+        )
+        ->Effect.map(_ => Ok())
+      | Error(errorMsg) =>
+        ReventlessCore.EffectLogger.logError(
+          ~comp=__MODULE__,
+          `delete: Couldn't delete state from ${tableName}, id=${id}, sort=${sort->JSON.stringifyAny->Option.getOr("None")}: ${errorMsg}`,
+        )
+        ->Effect.map(_ => Error(ReventlessInfra.QueryDb.NotDeletedFromStorage(errorMsg)))
+      }
+    )
+    ->Effect.runPromise
+  }
+
+let deleteBatch = table =>
+  async items =>
+    switch items {
+    | [] => Ok()
+    | [(id, sort)] => await delete(table)(id, sort)
+    | items =>
+      let _tableName = table.name
+      let ids = items->Array.map(((id, _)) => id)
+      await items
+      ->Array.map(((id, sort)) =>
+        switch sort {
+        | Some((sortField, sortKey)) =>
+          [("id", id->JSON.Encode.string), (sortField, sortKey->JSON.Encode.string)]
+          ->Dict.fromArray
+          ->toDeleteRequest
+        | None => [("id", id->JSON.Encode.string)]->Dict.fromArray->toDeleteRequest
+        }
+      )
+      ->writeMultiple("deleted", ids, table)
+    }