@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/util/Util_DynamoDbStream_Runtime.res

@@ -0,0 +1,94 @@
+type result =
+  | NewImage(string, JSON.t)
+  | OldImage(string, JSON.t)
+  | NewAndOldImage(string, JSON.t, JSON.t)
+  | Invalid
+
+// Returns None for rows that aren't events — e.g. DCB FENCE rows (no `event`
+// column). The caller filters these out via `Invalid` rather than synthesising
+// a bogus event that sury would later reject.
+let buildJsonEvent' = dict => {
+  switch (dict->Dict.get("event"), dict->Dict.get("data")) {
+  | (Some(JSON.String(eventType)), data) =>
+    let payload = switch data {
+    | Some(JSON.Object(d)) => d
+    | _ => Dict.make()
+    }
+    // DCB events lack meta fields (service, time, msgId) — synthesise a minimal
+    // meta so composeMeta doesn't crash on Option.getOrThrow.
+    let hasMeta = dict->Dict.get("service")->Option.isSome
+    let meta = if hasMeta {
+      dict->ReventlessCore.Message.composeMeta
+    } else {
+      let position =
+        dict->Dict.get("position")->Option.flatMap(JSON.Decode.string)->Option.getOr("")
+      [
+        ("service", ""->JSON.Encode.string),
+        ("time", position->JSON.Encode.string),
+        ("ip", ""->JSON.Encode.string),
+        ("user", ""->JSON.Encode.string),
+        ("msgId", position->JSON.Encode.string),
+        ("correlationId", position->JSON.Encode.string),
+      ]
+      ->Dict.fromArray
+      ->JSON.Encode.object
+    }
+    Some(
+      [
+        ("id", dict->Dict.get("id")->Option.getOrThrow),
+        ("meta", meta),
+        ("event", ReventlessCore.Message.combineMessage(eventType, payload)),
+      ]
+      ->Dict.fromArray
+      ->JSON.Encode.object,
+    )
+  | _ => None
+  }
+}
+
+let buildJsonState = dict => Some(dict->JSON.Encode.object)
+
+let parseDynamoDbStreamRecord = (buildJson, record: PulumiAws.DynamoDb.Stream.record) => {
+  let record = record.dynamodb
+  let id = record->Option.flatMap(record => AwsSdk.DynamoDb_Util_Helpers.unmarshall(record.keys.id))
+
+  let newImageJson =
+    record
+    ->Option.flatMap(dynamodb => dynamodb.newImage)
+    ->Option.map(newImage => AwsSdk.DynamoDb_Util_Helpers.unmarshallDict(newImage))
+    ->Option.flatMap(buildJson)
+
+  let oldImageJson =
+    record
+    ->Option.flatMap(dynamodb => dynamodb.oldImage)
+    ->Option.map(oldImage => AwsSdk.DynamoDb_Util_Helpers.unmarshallDict(oldImage))
+    ->Option.flatMap(buildJson)
+
+  switch (id, newImageJson, oldImageJson) {
+  | (Some(id), Some(newImage), Some(oldImage)) => NewAndOldImage(id, newImage, oldImage)
+  | (Some(id), Some(newImage), None) => NewImage(id, newImage)
+  | (Some(id), None, Some(oldImage)) => OldImage(id, oldImage)
+  | _ => Invalid
+  }
+}
+
+let parseDynamoDbStreamRecordEvent: PulumiAws.DynamoDb.Stream.record => result = record =>
+  parseDynamoDbStreamRecord(buildJsonEvent', record)
+
+// let parseDynamoDbStreamRecord = record =>
+//   switch record
+//   ->PulumiAws.DynamoDb.Stream.asRecord
+//   ->parseDynamoDbStreamRecordEvent {
+//   | NewImage(_, newImage)
+//   | NewAndOldImage(_, newImage, _) =>
+//     Some(newImage)
+//   | _ =>
+//     Console.log(__MODULE__ ++ ".handleChannelEvent: no NewImage included in Stream event !")
+//     None
+//   }
+
+let parseDynamoDbStreamRecordState: PulumiAws.DynamoDb.Stream.record => result = record =>
+  parseDynamoDbStreamRecord(buildJsonState, record)
+
+let findResource = resources =>
+  resources->ReventlessCore.Util.AdapterRuntime.findResource(AWS.DynamoDbStream.service)

package/src/util/Util_DynamoDbStream_Runtime.res.mjs

@@ -0,0 +1,131 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as AWS$ReventlessAws from "../adapter/AWS.res.mjs";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as DynamoDb_Util_Helpers$AwsSdk from "@reventlessdev/rescript-aws-sdk/src/DynamoDb_Util_Helpers.res.mjs";
+import * as Util_AdapterRuntime$ReventlessCore from "@reventlessdev/reventless-core/src/util/Util_AdapterRuntime.res.mjs";
+
+function buildJsonEvent$p(dict) {
+  let match = dict["event"];
+  let match$1 = dict["data"];
+  if (match === undefined) {
+    return;
+  }
+  if (typeof match !== "string") {
+    return;
+  }
+  let payload = match$1 !== undefined ? (
+      typeof match$1 === "object" && match$1 !== null && !Array.isArray(match$1) ? match$1 : ({})
+    ) : ({});
+  let hasMeta = Stdlib_Option.isSome(dict["service"]);
+  let meta;
+  if (hasMeta) {
+    meta = Message$ReventlessCore.composeMeta(dict);
+  } else {
+    let position = Stdlib_Option.getOr(Stdlib_Option.flatMap(dict["position"], Stdlib_JSON.Decode.string), "");
+    meta = Object.fromEntries([
+      [
+        "service",
+        ""
+      ],
+      [
+        "time",
+        position
+      ],
+      [
+        "ip",
+        ""
+      ],
+      [
+        "user",
+        ""
+      ],
+      [
+        "msgId",
+        position
+      ],
+      [
+        "correlationId",
+        position
+      ]
+    ]);
+  }
+  return Object.fromEntries([
+    [
+      "id",
+      Stdlib_Option.getOrThrow(dict["id"], undefined)
+    ],
+    [
+      "meta",
+      meta
+    ],
+    [
+      "event",
+      Message$ReventlessCore.combineMessage(match, payload)
+    ]
+  ]);
+}
+
+function buildJsonState(dict) {
+  return dict;
+}
+
+function parseDynamoDbStreamRecord(buildJson, record) {
+  let record$1 = record.dynamodb;
+  let id = Stdlib_Option.flatMap(record$1, record => DynamoDb_Util_Helpers$AwsSdk.unmarshall(undefined, record.Keys.id));
+  let newImageJson = Stdlib_Option.flatMap(Stdlib_Option.map(Stdlib_Option.flatMap(record$1, dynamodb => dynamodb.NewImage), newImage => DynamoDb_Util_Helpers$AwsSdk.unmarshallDict(undefined, newImage)), buildJson);
+  let oldImageJson = Stdlib_Option.flatMap(Stdlib_Option.map(Stdlib_Option.flatMap(record$1, dynamodb => dynamodb.OldImage), oldImage => DynamoDb_Util_Helpers$AwsSdk.unmarshallDict(undefined, oldImage)), buildJson);
+  if (id === undefined) {
+    return "Invalid";
+  }
+  let id$1 = Primitive_option.valFromOption(id);
+  if (newImageJson !== undefined) {
+    if (oldImageJson !== undefined) {
+      return {
+        TAG: "NewAndOldImage",
+        _0: id$1,
+        _1: newImageJson,
+        _2: oldImageJson
+      };
+    } else {
+      return {
+        TAG: "NewImage",
+        _0: id$1,
+        _1: newImageJson
+      };
+    }
+  } else if (oldImageJson !== undefined) {
+    return {
+      TAG: "OldImage",
+      _0: id$1,
+      _1: oldImageJson
+    };
+  } else {
+    return "Invalid";
+  }
+}
+
+function parseDynamoDbStreamRecordEvent(record) {
+  return parseDynamoDbStreamRecord(buildJsonEvent$p, record);
+}
+
+function parseDynamoDbStreamRecordState(record) {
+  return parseDynamoDbStreamRecord(buildJsonState, record);
+}
+
+function findResource(resources) {
+  return Util_AdapterRuntime$ReventlessCore.findResource(resources, AWS$ReventlessAws.DynamoDbStream.service);
+}
+
+export {
+  buildJsonEvent$p,
+  buildJsonState,
+  parseDynamoDbStreamRecord,
+  parseDynamoDbStreamRecordEvent,
+  parseDynamoDbStreamRecordState,
+  findResource,
+}
+/* Message-ReventlessCore Not a pure module */

package/src/util/Util_DynamoDb_Runtime.res

@@ -0,0 +1,216 @@
+open AwsSdk.DynamoDb.DocumentClient
+
+type resolvedTable = {
+  id: string,
+  name: string,
+  arn: string,
+  hashKey: string,
+  rangeKey?: Nullable.t<string>,
+}
+
+let put = (table, item) => {
+  {PutCommand.tableName: table.name, item}->PutCommand.make->PutCommand.send
+}
+
+let injectId = (item, key, id) =>
+  switch item->JSON.Decode.object {
+  | Some(obj) =>
+    obj->Dict.set(key, id->JSON.Encode.string)
+    obj->JSON.Encode.object
+  | None => item
+  }
+
+let putWithRetries = (table, id, item) => {
+  let item = item->injectId(table.hashKey, id)
+  Effect.tryPromise(~catch=DynamoDb_Error.classify, () => table->put(item))
+  ->Effect.map(_ => Ok())
+  ->Effect.retry(DynamoDb_Error.retrySchedule)
+  ->Effect.catchAll(err =>
+    switch err {
+    | Transient(msg) | Permanent(msg) =>
+      ReventlessCore.EffectLogger.logError(
+        ~comp=__MODULE__,
+        `putWithRetries: id=${id}: ${msg}`,
+      )
+      ->Effect.map(_ => Error(`put id=${id} failed: ${msg}`))
+    | StaleState(msg) =>
+      Effect.succeed(Error(`Stale State: id=${id}: ${msg}`))
+    }
+  )
+}
+
+let putIfNotExistsWithRetries = (~idKey, ~sortKey=?, table, id, item) => {
+  let item = item->injectId(idKey, id)
+  Effect.tryPromise(
+    ~catch=DynamoDb_Error.classify,
+    () => putIfNotExists(table.name, idKey, sortKey, item),
+  )
+  ->Effect.map(_ => Ok())
+  ->Effect.retry(DynamoDb_Error.retrySchedule)
+  ->Effect.catchAll(err =>
+    switch err {
+    | StaleState(_) => Effect.succeed(Error(`Stale State: id=${id}`))
+    | Transient(msg) | Permanent(msg) =>
+      ReventlessCore.EffectLogger.logError(
+        ~comp=__MODULE__,
+        `putIfNotExistsWithRetries: id=${id}: ${msg}`,
+      )
+      ->Effect.map(_ => Error(`putIfNotExists id=${id} failed: ${msg}`))
+    }
+  )
+}
+
+let delete = (table, ~sort=?, id) => {
+  delete(~tableName=table.name, ~sort?, ~id)
+}
+
+let deleteWithRetries = (~sort=?, table, id) =>
+  Effect.tryPromise(
+    ~catch=DynamoDb_Error.classify,
+    () => table->delete(id, ~sort?),
+  )
+  ->Effect.map(_ => Ok())
+  ->Effect.retry(DynamoDb_Error.retrySchedule)
+  ->Effect.catchAll(err => {
+    let msg = DynamoDb_Error.message(err)
+    ReventlessCore.EffectLogger.logError(
+      ~comp=__MODULE__,
+      `delete: id=${id}: ${msg}`,
+    )
+    ->Effect.map(_ => Error(`delete id=${id} failed: ${msg}`))
+  })
+
+// Streams all items matching a QueryCommand, fetching one DynamoDB page at a time.
+// Each page fetch retries independently on transient errors.
+let queryStream = (params: QueryCommand.input): Stream.t<JSON.t, DynamoDb_Error.t, unit> =>
+  Stream.paginateEffect((None: option<dict<JSON.t>>), cursor =>
+    Effect.tryPromise(
+      ~catch=DynamoDb_Error.classify,
+      () => {
+        let p = switch cursor {
+        | None => params
+        | Some(key) => {...params, exclusiveStartKey: key}
+        }
+        QueryCommand.send(p->QueryCommand.make)
+      },
+    )
+    ->Effect.retry(DynamoDb_Error.retrySchedule)
+    ->Effect.map(res => (
+      res.items->Option.getOr([]),
+      res.lastEvaluatedKey->Option.map(key => Some(key)),
+    ))
+  )
+
+// Streams all items matching a ScanCommand, fetching one DynamoDB page at a time.
+// Each page fetch retries independently on transient errors.
+let scanStream = (params: ScanCommand.input): Stream.t<JSON.t, DynamoDb_Error.t, unit> =>
+  Stream.paginateEffect((None: option<dict<JSON.t>>), cursor =>
+    Effect.tryPromise(
+      ~catch=DynamoDb_Error.classify,
+      () => {
+        let p = switch cursor {
+        | None => params
+        | Some(key) => {...params, exclusiveStartKey: key}
+        }
+        ScanCommand.send(ScanCommand.make(p))
+      },
+    )
+    ->Effect.retry(DynamoDb_Error.retrySchedule)
+    ->Effect.map(res => (
+      res.items->Option.getOr([]),
+      res.lastEvaluatedKey->Option.map(key => Some(key)),
+    ))
+  )
+
+// Convenience wrapper: streams all events for a given id.
+// Returns the stream directly — callers decide how to consume it.
+let queryById = (table, id): Stream.t<JSON.t, DynamoDb_Error.t, unit> =>
+  queryStream({
+    tableName: table.name,
+    consistentRead: true,
+    keyConditionExpression: "id=:id",
+    expressionAttributeValues: [(":id", id->JSON.Encode.string)]->Dict.fromArray,
+  })
+
+let keysFromResource: ReventlessInfra.Adapter.resource => (string, option<string>) = resource =>
+  switch resource.resourceInfo->Pulumi.Output.get {
+  | StorageKeys({partitionKey, sortKey}) => (partitionKey, sortKey)
+  | _ =>
+    JsError.throwWithMessage("No StorageKeys given for table " ++ resource.name->Pulumi.Output.get)
+  }
+
+let purgeTimeAttributeName = "reventlessPurgeTime"
+
+let calcPurgeTime = ttl => {
+  let now_ms = ReventlessCore.Message.now()
+  let now_s = now_ms /. 1000.0
+  let now_s_rounded = now_s->Float.toInt
+
+  (now_s_rounded + ttl)->Int.toFloat
+}
+
+let insertTtl: (JSON.t, option<int>) => JSON.t = (json, ttl) =>
+  switch ttl {
+  | None => json
+  | Some(ttl) =>
+    switch json->JSON.Decode.object {
+    | Some(obj) =>
+      obj->Dict.set(purgeTimeAttributeName, ttl->calcPurgeTime->JSON.Encode.float)
+      obj->JSON.Encode.object
+    | None => json
+    }
+  }
+
+/** max. batch size is 25 */
+let batchWrite = itemRequestMap => {
+  {
+    requestItems: itemRequestMap,
+    returnConsumedCapacity: #NONE,
+    returnItemCollectionMetrics: #NONE,
+  }
+  ->BatchWriteCommand.make
+  ->BatchWriteCommand.send
+}
+
+let hasUnprocessedItems = writeOutput =>
+  writeOutput.BatchWriteCommand.unprocessedItems->Option.mapOr(0, items =>
+    items->Dict.keysToArray->Array.length
+  ) > 0
+
+let batchWriteWithRetries = batchWriteRequests => {
+  let all = batchWriteRequests->Dict.valuesToArray->Array.flat->Array.length->Int.toString
+  let rec attempt = (retry, requests) =>
+    Effect.tryPromise(
+      ~catch=DynamoDb_Error.classify,
+      () => batchWrite(requests),
+    )
+    ->Effect.retry(DynamoDb_Error.retrySchedule)
+    ->Effect.flatMap(writeOutput =>
+      if writeOutput->hasUnprocessedItems {
+        let unprocessedRequests = writeOutput.BatchWriteCommand.unprocessedItems->Option.getOrThrow
+        let count = unprocessedRequests->Dict.keysToArray->Array.length->Int.toString
+        ReventlessCore.EffectLogger.logInfo(
+          ~comp=__MODULE__,
+          `batchWriteWithRetries: retry ${retry->Int.toString}: ${count} unprocessed items`,
+        )
+        ->Effect.flatMap(_ => attempt(retry + 1, unprocessedRequests))
+      } else {
+        Effect.succeed(Ok())
+      }
+    )
+    ->Effect.catchAll(err => {
+      let msg = DynamoDb_Error.message(err)
+      Effect.succeed(Error(`batchWrite failed ${all} requests: ${msg}`))
+    })
+  attempt(0, batchWriteRequests)
+}
+
+let toPutRequest: JSON.t => BatchWriteCommand.writeRequest = json => {
+  {putRequest: {BatchWriteCommand.item: json}}
+}
+
+let toDeleteRequest: dict<JSON.t> => BatchWriteCommand.writeRequest = keys => {
+  {deleteRequest: {BatchWriteCommand.key: keys}}
+}
+
+let toTable = (writeRequests, tableName) => Dict.fromArray([(tableName, writeRequests)])

package/src/util/Util_DynamoDb_Runtime.res.mjs

@@ -0,0 +1,257 @@
+// 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_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect$1 from "effect/Effect";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as LibDynamodb from "@aws-sdk/lib-dynamodb";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.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";
+
+function put(table, item) {
+  return DynamoDb_DocumentClient$AwsSdk.PutCommand.send(new LibDynamodb.PutCommand({
+    Item: item,
+    TableName: table.name
+  }));
+}
+
+function injectId(item, key, id) {
+  let obj = Stdlib_JSON.Decode.object(item);
+  if (obj !== undefined) {
+    obj[key] = id;
+    return obj;
+  } else {
+    return item;
+  }
+}
+
+function putWithRetries(table, id, item) {
+  let item$1 = injectId(item, table.hashKey, id);
+  return Effect$1.catchAll(Effect$1.retry(Effect$1.map(Effect.tryPromise(DynamoDb_Error$ReventlessAws.classify, () => put(table, item$1)), param => ({
+    TAG: "Ok",
+    _0: undefined
+  })), DynamoDb_Error$ReventlessAws.retrySchedule), err => {
+    switch (err.TAG) {
+      case "StaleState" :
+        return Effect$1.succeed({
+          TAG: "Error",
+          _0: `Stale State: id=` + id + `: ` + err._0
+        });
+      case "Transient" :
+      case "Permanent" :
+        break;
+    }
+    let msg = err._0;
+    return Effect$1.map(EffectLogger$ReventlessCore.logError("Util_DynamoDb_Runtime-ReventlessAws", undefined, `putWithRetries: id=` + id + `: ` + msg), () => ({
+      TAG: "Error",
+      _0: `put id=` + id + ` failed: ` + msg
+    }));
+  });
+}
+
+function putIfNotExistsWithRetries(idKey, sortKey, table, id, item) {
+  let item$1 = injectId(item, idKey, id);
+  return Effect$1.catchAll(Effect$1.retry(Effect$1.map(Effect.tryPromise(DynamoDb_Error$ReventlessAws.classify, () => DynamoDb_DocumentClient$AwsSdk.putIfNotExists(table.name, idKey, sortKey, item$1)), param => ({
+    TAG: "Ok",
+    _0: undefined
+  })), DynamoDb_Error$ReventlessAws.retrySchedule), err => {
+    switch (err.TAG) {
+      case "StaleState" :
+        return Effect$1.succeed({
+          TAG: "Error",
+          _0: `Stale State: id=` + id
+        });
+      case "Transient" :
+      case "Permanent" :
+        break;
+    }
+    let msg = err._0;
+    return Effect$1.map(EffectLogger$ReventlessCore.logError("Util_DynamoDb_Runtime-ReventlessAws", undefined, `putIfNotExistsWithRetries: id=` + id + `: ` + msg), () => ({
+      TAG: "Error",
+      _0: `putIfNotExists id=` + id + ` failed: ` + msg
+    }));
+  });
+}
+
+function $$delete(table, sort, id) {
+  return DynamoDb_DocumentClient$AwsSdk.$$delete(sort, table.name, id);
+}
+
+function deleteWithRetries(sort, table, id) {
+  return Effect$1.catchAll(Effect$1.retry(Effect$1.map(Effect.tryPromise(DynamoDb_Error$ReventlessAws.classify, () => $$delete(table, sort, id)), param => ({
+    TAG: "Ok",
+    _0: undefined
+  })), DynamoDb_Error$ReventlessAws.retrySchedule), err => {
+    let msg = DynamoDb_Error$ReventlessAws.message(err);
+    return Effect$1.map(EffectLogger$ReventlessCore.logError("Util_DynamoDb_Runtime-ReventlessAws", undefined, `delete: id=` + id + `: ` + msg), () => ({
+      TAG: "Error",
+      _0: `delete id=` + id + ` failed: ` + msg
+    }));
+  });
+}
+
+function queryStream(params) {
+  return Stream.paginateEffect(undefined, cursor => Effect$1.map(Effect$1.retry(Effect.tryPromise(DynamoDb_Error$ReventlessAws.classify, () => {
+    let p;
+    if (cursor !== undefined) {
+      let newrecord = {...params};
+      newrecord.ExclusiveStartKey = cursor;
+      p = newrecord;
+    } else {
+      p = params;
+    }
+    return DynamoDb_DocumentClient$AwsSdk.QueryCommand.send(new LibDynamodb.QueryCommand(p));
+  }), DynamoDb_Error$ReventlessAws.retrySchedule), res => [
+    Stdlib_Option.getOr(res.Items, []),
+    Stdlib_Option.map(res.LastEvaluatedKey, key => key)
+  ]));
+}
+
+function scanStream(params) {
+  return Stream.paginateEffect(undefined, cursor => Effect$1.map(Effect$1.retry(Effect.tryPromise(DynamoDb_Error$ReventlessAws.classify, () => {
+    let p;
+    if (cursor !== undefined) {
+      let newrecord = {...params};
+      newrecord.ExclusiveStartKey = cursor;
+      p = newrecord;
+    } else {
+      p = params;
+    }
+    return DynamoDb_DocumentClient$AwsSdk.ScanCommand.send(new LibDynamodb.ScanCommand(p));
+  }), DynamoDb_Error$ReventlessAws.retrySchedule), res => [
+    Stdlib_Option.getOr(res.Items, []),
+    Stdlib_Option.map(res.LastEvaluatedKey, key => key)
+  ]));
+}
+
+function queryById(table, id) {
+  return queryStream({
+    TableName: table.name,
+    ConsistentRead: true,
+    ExpressionAttributeValues: Object.fromEntries([[
+        ":id",
+        id
+      ]]),
+    KeyConditionExpression: "id=:id"
+  });
+}
+
+function keysFromResource(resource) {
+  let match = resource.resourceInfo.get();
+  if (typeof match !== "object") {
+    return Stdlib_JsError.throwWithMessage("No StorageKeys given for table " + resource.name.get());
+  } else if (match.TAG === "StorageKeys") {
+    return [
+      match.partitionKey,
+      match.sortKey
+    ];
+  } else {
+    return Stdlib_JsError.throwWithMessage("No StorageKeys given for table " + resource.name.get());
+  }
+}
+
+let purgeTimeAttributeName = "reventlessPurgeTime";
+
+function calcPurgeTime(ttl) {
+  let now_ms = Message$ReventlessCore.now();
+  let now_s = now_ms / 1000.0;
+  let now_s_rounded = now_s | 0;
+  return now_s_rounded + ttl | 0;
+}
+
+function insertTtl(json, ttl) {
+  if (ttl === undefined) {
+    return json;
+  }
+  let obj = Stdlib_JSON.Decode.object(json);
+  if (obj !== undefined) {
+    obj[purgeTimeAttributeName] = calcPurgeTime(ttl);
+    return obj;
+  } else {
+    return json;
+  }
+}
+
+function batchWrite(itemRequestMap) {
+  return DynamoDb_DocumentClient$AwsSdk.BatchWriteCommand.send(new LibDynamodb.BatchWriteCommand({
+    RequestItems: itemRequestMap,
+    ReturnConsumedCapacity: "NONE",
+    ReturnItemCollectionMetrics: "NONE"
+  }));
+}
+
+function hasUnprocessedItems(writeOutput) {
+  return Stdlib_Option.mapOr(writeOutput.UnprocessedItems, 0, items => Object.keys(items).length) > 0;
+}
+
+function batchWriteWithRetries(batchWriteRequests) {
+  let all = Object.values(batchWriteRequests).flat().length.toString();
+  let attempt = (retry, requests) => Effect$1.catchAll(Effect$1.flatMap(Effect$1.retry(Effect.tryPromise(DynamoDb_Error$ReventlessAws.classify, () => batchWrite(requests)), DynamoDb_Error$ReventlessAws.retrySchedule), writeOutput => {
+    if (!hasUnprocessedItems(writeOutput)) {
+      return Effect$1.succeed({
+        TAG: "Ok",
+        _0: undefined
+      });
+    }
+    let unprocessedRequests = Stdlib_Option.getOrThrow(writeOutput.UnprocessedItems, undefined);
+    let count = Object.keys(unprocessedRequests).length.toString();
+    return Effect$1.flatMap(EffectLogger$ReventlessCore.logInfo("Util_DynamoDb_Runtime-ReventlessAws", undefined, `batchWriteWithRetries: retry ` + retry.toString() + `: ` + count + ` unprocessed items`), () => attempt(retry + 1 | 0, unprocessedRequests));
+  }), err => {
+    let msg = DynamoDb_Error$ReventlessAws.message(err);
+    return Effect$1.succeed({
+      TAG: "Error",
+      _0: `batchWrite failed ` + all + ` requests: ` + msg
+    });
+  });
+  return attempt(0, batchWriteRequests);
+}
+
+function toPutRequest(json) {
+  return {
+    PutRequest: {
+      Item: json
+    }
+  };
+}
+
+function toDeleteRequest(keys) {
+  return {
+    DeleteRequest: {
+      Key: keys
+    }
+  };
+}
+
+function toTable(writeRequests, tableName) {
+  return Object.fromEntries([[
+      tableName,
+      writeRequests
+    ]]);
+}
+
+export {
+  put,
+  injectId,
+  putWithRetries,
+  putIfNotExistsWithRetries,
+  $$delete,
+  deleteWithRetries,
+  queryStream,
+  scanStream,
+  queryById,
+  keysFromResource,
+  purgeTimeAttributeName,
+  calcPurgeTime,
+  insertTtl,
+  batchWrite,
+  hasUnprocessedItems,
+  batchWriteWithRetries,
+  toPutRequest,
+  toDeleteRequest,
+  toTable,
+}
+/* Effect Not a pure module */