@reventlessdev/reventless-aws 3.0.0-alpha.167

package/src/adapter/DcbEventLog/DcbEventLogStorage_DynamoDb_Runtime.res.mjs

@@ -0,0 +1,1143 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Uuid from "uuid";
+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_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Queue from "effect/Queue";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Effect$1 from "effect/Effect";
+import * as Stream$1 from "effect/Stream";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
+import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as LibDynamodb from "@aws-sdk/lib-dynamodb";
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.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 generatePosition() {
+  let timestamp = new Date().getTime().toString();
+  let uuid = Uuid.v4();
+  return timestamp + `-` + uuid;
+}
+
+function generatePositionForBatch(basePosition, index) {
+  if (index === 0) {
+    return basePosition;
+  } else {
+    return basePosition + `-` + index.toString().padStart(3, "0");
+  }
+}
+
+function tagToAttributeName(tagKey) {
+  return `tag_` + tagKey;
+}
+
+let compositeIndexName = "tag_composite";
+
+function indexKeepsFullProjection(indexName) {
+  return indexName === compositeIndexName;
+}
+
+function compositeTagKey(tags) {
+  return tags.toSorted((a, b) => Primitive_string.compare(a.key, b.key)).map(t => t.key + `:` + t.value).join("#");
+}
+
+function derivePartitionKey(partitionTag, tags) {
+  if (tags.length === 0) {
+    return "dcb";
+  }
+  if (partitionTag !== undefined) {
+    if (partitionTag.TAG !== "Simple") {
+      return DcbTag$Reventless.getCompositePartitionKeyValue(tags, partitionTag._0);
+    }
+    let pt = partitionTag._0;
+    let t = tags.find(t => t.key === pt.key);
+    let tag = t !== undefined ? t : tags[0];
+    return tag.key + `:` + tag.value;
+  }
+  let tag$1 = tags[0];
+  return tag$1.key + `:` + tag$1.value;
+}
+
+function toItem(position, event, partitionTag, recordedAt) {
+  let item = {};
+  item["id"] = derivePartitionKey(partitionTag, event.tags);
+  item["position"] = position;
+  item["event"] = event.eventType;
+  item["data"] = event.data;
+  item["recordedAt"] = recordedAt;
+  let tagsJson = event.tags.map(tag => Object.fromEntries([
+    [
+      "key",
+      tag.key
+    ],
+    [
+      "value",
+      tag.value
+    ]
+  ]));
+  item["tags"] = tagsJson;
+  Message$ReventlessCore.decomposeMeta(event.meta).forEach(param => {
+    item[param[0]] = param[1];
+  });
+  event.tags.forEach(tag => {
+    let attrName = tagToAttributeName(tag.key);
+    item[attrName] = tag.value;
+  });
+  if (event.tags.length > 1) {
+    let composite = compositeTagKey(event.tags);
+    item["tag_composite"] = composite;
+  }
+  return item;
+}
+
+function fromItem(item) {
+  let obj = Stdlib_JSON.Decode.object(item);
+  if (obj === undefined) {
+    return Stdlib_JsError.throwWithMessage("Invalid DcbEventLog item: not an object");
+  }
+  let position = Stdlib_Option.getOrThrow(Stdlib_Option.flatMap(obj["position"], Stdlib_JSON.Decode.string), undefined);
+  let eventType = Stdlib_Option.getOrThrow(Stdlib_Option.flatMap(obj["event"], Stdlib_JSON.Decode.string), undefined);
+  let data = Stdlib_Option.getOrThrow(obj["data"], undefined);
+  let tags = Stdlib_Option.mapOr(Stdlib_Option.flatMap(obj["tags"], Stdlib_JSON.Decode.array), [], tagArray => Stdlib_Array.filterMap(tagArray, tagJson => {
+    let tagObj = Stdlib_JSON.Decode.object(tagJson);
+    if (tagObj === undefined) {
+      return;
+    }
+    let key = Stdlib_Option.flatMap(tagObj["key"], Stdlib_JSON.Decode.string);
+    let value = Stdlib_Option.flatMap(tagObj["value"], Stdlib_JSON.Decode.string);
+    if (key !== undefined && value !== undefined) {
+      return {
+        key: key,
+        value: value
+      };
+    }
+  }));
+  let recordedAt = Stdlib_Option.getOr(Stdlib_Option.flatMap(obj["recordedAt"], Stdlib_JSON.Decode.string), "");
+  let meta = S.parseJsonOrThrow(Message$ReventlessCore.composeMeta(obj), Message$Reventless.metaSchema);
+  return {
+    position: position,
+    eventType: eventType,
+    data: data,
+    tags: tags,
+    meta: meta,
+    recordedAt: recordedAt
+  };
+}
+
+async function queryByCompositeTags(table, tags, after) {
+  let composite = compositeTagKey(tags);
+  let expressionAttributeValues = Object.fromEntries([[
+      ":composite",
+      composite
+    ]]);
+  let match = after !== undefined ? (expressionAttributeValues[":after"] = after, [
+      "tag_composite = :composite AND #pos > :after",
+      Object.fromEntries([[
+          "#pos",
+          "position"
+        ]])
+    ]) : [
+      "tag_composite = :composite",
+      undefined
+    ];
+  let queryParams_TableName = table.name;
+  let queryParams_ExpressionAttributeNames = match[1];
+  let queryParams_ExpressionAttributeValues = expressionAttributeValues;
+  let queryParams_IndexName = "tag_composite";
+  let queryParams_KeyConditionExpression = match[0];
+  let queryParams = {
+    TableName: queryParams_TableName,
+    ExpressionAttributeNames: queryParams_ExpressionAttributeNames,
+    ExpressionAttributeValues: queryParams_ExpressionAttributeValues,
+    IndexName: queryParams_IndexName,
+    KeyConditionExpression: queryParams_KeyConditionExpression
+  };
+  return await Effect$1.runPromise(Stream.runCollect(Util_DynamoDb_Runtime$ReventlessAws.queryStream(queryParams)));
+}
+
+function buildScanFilter(eventTypes) {
+  let expressionAttributeValues = {};
+  let expressionAttributeNames = Object.fromEntries([[
+      "#evt",
+      "event"
+    ]]);
+  let filterParts = ["attribute_exists(#evt)"];
+  if (eventTypes !== undefined && eventTypes.length !== 0) {
+    let typeConditions = eventTypes.map((typ, idx) => {
+      let placeholder = `:type` + idx.toString();
+      expressionAttributeValues[placeholder] = typ;
+      return `#evt = ` + placeholder;
+    });
+    filterParts.push(`(` + typeConditions.join(" OR ") + `)`);
+  }
+  let hasAttributeValues = Object.keys(expressionAttributeValues).length !== 0;
+  return {
+    filterExpression: filterParts.join(" AND "),
+    expressionAttributeNames: expressionAttributeNames,
+    expressionAttributeValues: hasAttributeValues ? expressionAttributeValues : undefined
+  };
+}
+
+async function scanWithFilter(table, eventTypes, after) {
+  let filter = buildScanFilter(eventTypes);
+  let scanParams_TableName = table.name;
+  let scanParams_ExpressionAttributeNames = filter.expressionAttributeNames;
+  let scanParams_ExpressionAttributeValues = filter.expressionAttributeValues;
+  let scanParams_FilterExpression = filter.filterExpression;
+  let scanParams = {
+    TableName: scanParams_TableName,
+    ExpressionAttributeNames: scanParams_ExpressionAttributeNames,
+    ExpressionAttributeValues: scanParams_ExpressionAttributeValues,
+    FilterExpression: scanParams_FilterExpression
+  };
+  let rawItems = await Effect$1.runPromise(Stream.runCollect(Util_DynamoDb_Runtime$ReventlessAws.scanStream(scanParams)));
+  if (after !== undefined) {
+    return rawItems.filter(item => Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), obj => obj["position"]), Stdlib_JSON.Decode.string), false, pos => Primitive_string.compare(pos, after) > 0));
+  } else {
+    return rawItems;
+  }
+}
+
+function buildQueryByPartitionKeyInput(table, partitionKey, after, strongConsistencyOpt) {
+  let strongConsistency = strongConsistencyOpt !== undefined ? strongConsistencyOpt : false;
+  let expressionAttributeValues = Object.fromEntries([[
+      ":pk",
+      partitionKey
+    ]]);
+  let match = after !== undefined ? (expressionAttributeValues[":after"] = after, [
+      "id = :pk AND #pos > :after",
+      Object.fromEntries([[
+          "#pos",
+          "position"
+        ]])
+    ]) : [
+      "id = :pk",
+      undefined
+    ];
+  let consistentRead = strongConsistency ? true : undefined;
+  return {
+    TableName: table.name,
+    ConsistentRead: consistentRead,
+    ExpressionAttributeNames: match[1],
+    ExpressionAttributeValues: expressionAttributeValues,
+    KeyConditionExpression: match[0]
+  };
+}
+
+async function queryByPartitionKey(table, partitionKey, after) {
+  let queryParams = buildQueryByPartitionKeyInput(table, partitionKey, after, undefined);
+  return await Effect$1.runPromise(Stream.runCollect(Util_DynamoDb_Runtime$ReventlessAws.queryStream(queryParams)));
+}
+
+function resolveBaseItem(table, keyItem) {
+  let obj = Stdlib_JSON.Decode.object(keyItem);
+  if (obj === undefined) {
+    return Effect$1.succeed(undefined);
+  }
+  let match = obj["id"];
+  let match$1 = obj["position"];
+  if (match === undefined) {
+    return Effect$1.succeed(undefined);
+  }
+  if (match$1 === undefined) {
+    return Effect$1.succeed(undefined);
+  }
+  let key = Object.fromEntries([
+    [
+      "id",
+      match
+    ],
+    [
+      "position",
+      match$1
+    ]
+  ]);
+  return Effect$1.map(Effect$1.catchAll(Effect$1.retry(Effect.tryPromise(DynamoDb_Error$ReventlessAws.classify, () => DynamoDb_DocumentClient$AwsSdk.GetCommand.send(new LibDynamodb.GetCommand({
+    TableName: table.name,
+    Key: key
+  }))), DynamoDb_Error$ReventlessAws.retrySchedule), err => Effect$1.fail(DynamoDb_Error$ReventlessAws.message(err))), result => result.Item);
+}
+
+function queryBySingleTagCrossPartitionStream(table, tag, after) {
+  let indexName = tagToAttributeName(tag.key);
+  let expressionAttributeValues = Object.fromEntries([[
+      ":val",
+      tag.value
+    ]]);
+  let expressionAttributeNames = Object.fromEntries([[
+      "#tag",
+      indexName
+    ]]);
+  let keyConditionExpression = after !== undefined ? (expressionAttributeValues[":after"] = after, expressionAttributeNames["#pos"] = "position", "#tag = :val AND #pos > :after") : "#tag = :val";
+  let baseParams_TableName = table.name;
+  let baseParams_ExpressionAttributeNames = expressionAttributeNames;
+  let baseParams_ExpressionAttributeValues = expressionAttributeValues;
+  let baseParams_IndexName = indexName;
+  let baseParams_KeyConditionExpression = keyConditionExpression;
+  let baseParams = {
+    TableName: baseParams_TableName,
+    ExpressionAttributeNames: baseParams_ExpressionAttributeNames,
+    ExpressionAttributeValues: baseParams_ExpressionAttributeValues,
+    IndexName: baseParams_IndexName,
+    KeyConditionExpression: baseParams_KeyConditionExpression
+  };
+  return Stream$1.flatMap(Stream$1.mapEffect(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(DynamoDb_Error$ReventlessAws.message(err))), result => [
+    Stdlib_Option.getOr(result.Items, []),
+    Stdlib_Option.map(result.LastEvaluatedKey, key => key)
+  ])), keyItem => resolveBaseItem(table, keyItem)), opt => {
+    if (opt !== undefined) {
+      return Stream$1.fromIterable([opt]);
+    } else {
+      return Stream$1.empty;
+    }
+  });
+}
+
+async function executeQueryItem(table, queryItem, after, crossPartitionTagKeysOpt) {
+  let crossPartitionTagKeys = crossPartitionTagKeysOpt !== undefined ? crossPartitionTagKeysOpt : [];
+  let tags = queryItem.tags;
+  if (tags !== undefined) {
+    if (tags.length !== 1) {
+      if (tags.length > 1) {
+        return await queryByCompositeTags(table, tags, after);
+      }
+      tags.length !== 0;
+    } else {
+      let tag = tags[0];
+      if (crossPartitionTagKeys.includes(tag.key)) {
+        return await Effect$1.runPromise(Stream.runCollect(queryBySingleTagCrossPartitionStream(table, tag, after)));
+      } else {
+        return await queryByPartitionKey(table, tag.key + `:` + tag.value, after);
+      }
+    }
+  }
+  let eventTypes = queryItem.eventTypes;
+  if (eventTypes !== undefined) {
+    return await scanWithFilter(table, eventTypes, after);
+  } else {
+    return await scanWithFilter(table, undefined, after);
+  }
+}
+
+function deduplicateByPosition(events) {
+  let seen = new Set();
+  return events.filter(event => {
+    if (seen.has(event.position)) {
+      return false;
+    } else {
+      seen.add(event.position);
+      return true;
+    }
+  });
+}
+
+function initSlot(stream) {
+  return Effect$1.flatMap(Queue.bounded(1), queue => {
+    let producer = Effect$1.catchAll(Effect$1.ensuring(Stream$1.runForEach(stream, event => Effect$1.map(Queue.offer(queue, event), param => {})), Effect$1.map(Queue.offer(queue, undefined), param => {})), param => Effect$1.succeed());
+    return Effect$1.flatMap(Effect$1.fork(producer), param => Effect$1.map(Queue.take(queue), head => ({
+      queue: queue,
+      head: head
+    })));
+  });
+}
+
+function findMinSlotIdx(slots) {
+  return Stdlib_Array.reduceWithIndex(slots, undefined, (minOpt, slot, idx) => {
+    let match = slot.head;
+    if (match === undefined) {
+      return minOpt;
+    }
+    if (minOpt === undefined) {
+      return idx;
+    }
+    let minSlot = slots[minOpt];
+    let minHead = minSlot.head;
+    if (minHead !== undefined && Primitive_string.compare(match.position, minHead.position) >= 0) {
+      return minOpt;
+    } else {
+      return idx;
+    }
+  });
+}
+
+function dedupByPosition(stream) {
+  let lastPos = {
+    contents: undefined
+  };
+  return Stream$1.filter(stream, event => {
+    let pos = lastPos.contents;
+    if (pos !== undefined && pos === event.position) {
+      return false;
+    } else {
+      lastPos.contents = event.position;
+      return true;
+    }
+  });
+}
+
+function mergeSortedEvents(streams) {
+  return Stream$1.flatMap(Stream$1.fromEffect(Effect$1.all(streams.map(initSlot), {
+    concurrency: "unbounded"
+  })), initialSlots => Stream.paginateEffect(initialSlots, slots => {
+    let idx = findMinSlotIdx(slots);
+    if (idx === undefined) {
+      return Effect$1.succeed([
+        [],
+        undefined
+      ]);
+    }
+    let slot = slots[idx];
+    let emitEvent = Stdlib_Option.getOrThrow(slot.head, undefined);
+    return Effect$1.map(Queue.take(slot.queue), nextHead => {
+      let newSlots = slots.map((s, i) => {
+        if (i === idx) {
+          return {
+            queue: s.queue,
+            head: nextHead
+          };
+        } else {
+          return s;
+        }
+      });
+      let hasActive = newSlots.some(s => Stdlib_Option.isSome(s.head));
+      return [
+        [emitEvent],
+        hasActive ? newSlots : undefined
+      ];
+    });
+  }));
+}
+
+function read(table, $staropt$star) {
+  return async (query, after) => {
+    let crossPartitionTagKeys = $staropt$star !== undefined ? $staropt$star : [];
+    let queryResults = await Promise.all(query.map(queryItem => executeQueryItem(table, queryItem, after, crossPartitionTagKeys)));
+    let allItems = queryResults.flat();
+    let allEvents = allItems.map(fromItem);
+    let deduplicatedEvents = deduplicateByPosition(allEvents);
+    let sortedEvents = deduplicatedEvents.toSorted((a, b) => Primitive_string.compare(a.position, b.position));
+    let headPosition = Stdlib_Option.map(sortedEvents.toReversed().at(0), event => event.position);
+    return {
+      events: sortedEvents,
+      headPosition: headPosition
+    };
+  };
+}
+
+let fenceSortKey = "FENCE";
+
+function fencePartitionKey(tag) {
+  return `fence#` + tag.key + `:` + tag.value;
+}
+
+function fenceKey(tag) {
+  return Object.fromEntries([
+    [
+      "id",
+      fencePartitionKey(tag)
+    ],
+    [
+      "position",
+      fenceSortKey
+    ]
+  ]);
+}
+
+function collectQueryTags(query) {
+  let seen = new Set();
+  let acc = [];
+  query.forEach(qi => {
+    let tags = qi.tags;
+    if (tags !== undefined) {
+      tags.forEach(tag => {
+        let k = tag.key + `:` + tag.value;
+        if (!seen.has(k)) {
+          seen.add(k);
+          acc.push(tag);
+          return;
+        }
+      });
+      return;
+    }
+  });
+  return acc;
+}
+
+function collectEventTags(events) {
+  let seen = new Set();
+  let acc = [];
+  events.forEach(event => {
+    event.tags.forEach(tag => {
+      let k = tag.key + `:` + tag.value;
+      if (!seen.has(k)) {
+        seen.add(k);
+        acc.push(tag);
+        return;
+      }
+    });
+  });
+  return acc;
+}
+
+function fenceTypeAttr(eventType) {
+  return `pos#` + eventType;
+}
+
+function dedupStrings(xs) {
+  let seen = new Set();
+  return xs.filter(x => {
+    if (seen.has(x)) {
+      return false;
+    } else {
+      seen.add(x);
+      return true;
+    }
+  });
+}
+
+function carriedTypesByTag(events) {
+  let d = {};
+  events.forEach(e => {
+    e.tags.forEach(t => {
+      let k = t.key + `:` + t.value;
+      let cur = Stdlib_Option.getOr(d[k], []);
+      if (!cur.includes(e.eventType)) {
+        d[k] = cur.concat([e.eventType]);
+        return;
+      }
+    });
+  });
+  return d;
+}
+
+function buildConditionalFenceUpdate(tableName, tag, consumedTypes, producedTypes, newPosition, after) {
+  let names = {};
+  let values = Object.fromEntries([[
+      ":new",
+      newPosition
+    ]]);
+  let setClauses = producedTypes.map((pt, i) => {
+    let ph = `#p` + i.toString();
+    names[ph] = fenceTypeAttr(pt);
+    return ph + ` = :new`;
+  });
+  let conditionExpression;
+  if (after !== undefined) {
+    values[":after"] = after;
+    let checkTypes = consumedTypes.length === 0 ? producedTypes : consumedTypes;
+    conditionExpression = checkTypes.map((t, i) => {
+      let ph = `#c` + i.toString();
+      names[ph] = fenceTypeAttr(t);
+      return `(attribute_not_exists(` + ph + `) OR ` + ph + ` <= :after)`;
+    }).join(" AND ");
+  } else {
+    conditionExpression = dedupStrings(consumedTypes.concat(producedTypes)).map((t, i) => {
+      let ph = `#c` + i.toString();
+      names[ph] = fenceTypeAttr(t);
+      return `attribute_not_exists(` + ph + `)`;
+    }).join(" AND ");
+  }
+  return {
+    Key: fenceKey(tag),
+    TableName: tableName,
+    UpdateExpression: `SET ` + setClauses.join(", "),
+    ConditionExpression: conditionExpression,
+    ExpressionAttributeNames: names,
+    ExpressionAttributeValues: values
+  };
+}
+
+function buildUnconditionalFenceUpdate(tableName, tag, producedTypes, newPosition) {
+  let names = {};
+  let values = Object.fromEntries([[
+      ":new",
+      newPosition
+    ]]);
+  let setClauses = producedTypes.map((pt, i) => {
+    let ph = `#p` + i.toString();
+    names[ph] = fenceTypeAttr(pt);
+    return ph + ` = :new`;
+  });
+  return {
+    Key: fenceKey(tag),
+    TableName: tableName,
+    UpdateExpression: `SET ` + setClauses.join(", "),
+    ExpressionAttributeNames: names,
+    ExpressionAttributeValues: values
+  };
+}
+
+function buildFenceConditionCheck(tableName, tag, consumedTypes, after) {
+  let names = {};
+  if (after !== undefined) {
+    let conditionExpression = consumedTypes.map((t, i) => {
+      let ph = `#c` + i.toString();
+      names[ph] = fenceTypeAttr(t);
+      return `(attribute_not_exists(` + ph + `) OR ` + ph + ` <= :after)`;
+    }).join(" AND ");
+    return {
+      Key: fenceKey(tag),
+      TableName: tableName,
+      ConditionExpression: conditionExpression,
+      ExpressionAttributeNames: names,
+      ExpressionAttributeValues: Object.fromEntries([[
+          ":after",
+          after
+        ]])
+    };
+  }
+  let conditionExpression$1 = consumedTypes.map((t, i) => {
+    let ph = `#c` + i.toString();
+    names[ph] = fenceTypeAttr(t);
+    return `attribute_not_exists(` + ph + `)`;
+  }).join(" AND ");
+  return {
+    Key: fenceKey(tag),
+    TableName: tableName,
+    ConditionExpression: conditionExpression$1,
+    ExpressionAttributeNames: names
+  };
+}
+
+function buildEventPuts(table, events, basePosition, partitionTag) {
+  return events.map((event, idx) => {
+    let position = generatePositionForBatch(basePosition, idx);
+    let recordedAt = Message$ReventlessCore.nowAsISOString();
+    let item = toItem(position, event, partitionTag, recordedAt);
+    let put_TableName = table.name;
+    let put = {
+      Item: item,
+      TableName: put_TableName
+    };
+    return {
+      Put: put
+    };
+  });
+}
+
+async function runTransactWrite(input, basePosition, errorPrefix) {
+  return await Effect$1.runPromise(Effect$1.catchAll(Effect$1.map(Effect.tryPromise(DynamoDb_Error$ReventlessAws.classify, () => DynamoDb_DocumentClient$AwsSdk.TransactWriteCommand.send(new LibDynamodb.TransactWriteCommand(input))), param => ({
+    TAG: "Ok",
+    _0: basePosition
+  })), err => {
+    switch (err.TAG) {
+      case "StaleState" :
+        return Effect$1.succeed({
+          TAG: "Error",
+          _0: `Conflict: ` + err._0
+        });
+      case "Transient" :
+      case "Permanent" :
+        break;
+    }
+    return Effect$1.succeed({
+      TAG: "Error",
+      _0: errorPrefix + `: ` + err._0
+    });
+  }));
+}
+
+async function appendUnconditional(table, events, partitionTag) {
+  let eventTags = collectEventTags(events);
+  let totalItems = events.length + eventTags.length | 0;
+  if (events.length === 0) {
+    return {
+      TAG: "Ok",
+      _0: generatePosition()
+    };
+  }
+  if (totalItems > 100) {
+    return {
+      TAG: "Error",
+      _0: `DCB append: TransactWriteItems limit exceeded (` + totalItems.toString() + ` > ` + (100).toString() + `); reduce events or distinct tag values per command`
+    };
+  }
+  let basePosition = generatePosition();
+  let carriedMap = carriedTypesByTag(events);
+  let putItems = buildEventPuts(table, events, basePosition, partitionTag);
+  let updateItems = Stdlib_Array.filterMap(eventTags, tag => {
+    let producedTypes = Stdlib_Option.getOr(carriedMap[tag.key + `:` + tag.value], []);
+    if (producedTypes.length === 0) {
+      return;
+    } else {
+      return {
+        Update: buildUnconditionalFenceUpdate(table.name, tag, producedTypes, basePosition)
+      };
+    }
+  });
+  let input_TransactItems = putItems.concat(updateItems);
+  let input = {
+    TransactItems: input_TransactItems
+  };
+  return await runTransactWrite(input, basePosition, "DCB append failed");
+}
+
+function eventPartitionTags(event, partitionTag) {
+  if (partitionTag !== undefined) {
+    if (partitionTag.TAG !== "Simple") {
+      return event.tags;
+    }
+    let pt = partitionTag._0;
+    let t = event.tags.find(t => t.key === pt.key);
+    if (t !== undefined) {
+      return [t];
+    }
+    let t$1 = event.tags[0];
+    if (t$1 !== undefined) {
+      return [t$1];
+    } else {
+      return [];
+    }
+  }
+  let t$2 = event.tags[0];
+  if (t$2 !== undefined) {
+    return [t$2];
+  } else {
+    return [];
+  }
+}
+
+function collectEventPartitionTags(events, partitionTag) {
+  let seen = new Set();
+  let acc = [];
+  events.forEach(event => {
+    eventPartitionTags(event, partitionTag).forEach(tag => {
+      let k = tag.key + `:` + tag.value;
+      if (!seen.has(k)) {
+        seen.add(k);
+        acc.push(tag);
+        return;
+      }
+    });
+  });
+  return acc;
+}
+
+function partitionTypesByTag(events, partitionTag) {
+  let d = {};
+  events.forEach(e => {
+    eventPartitionTags(e, partitionTag).forEach(t => {
+      let k = t.key + `:` + t.value;
+      let cur = Stdlib_Option.getOr(d[k], []);
+      if (!cur.includes(e.eventType)) {
+        d[k] = cur.concat([e.eventType]);
+        return;
+      }
+    });
+  });
+  return d;
+}
+
+function buildConditionalTransactItems(table, events, cond, basePosition, partitionTag, crossPartitionTagKeysOpt) {
+  let crossPartitionTagKeys = crossPartitionTagKeysOpt !== undefined ? crossPartitionTagKeysOpt : [];
+  let partitionTags = collectEventPartitionTags(events, partitionTag);
+  let partitionKeySet = new Set();
+  partitionTags.forEach(t => {
+    partitionKeySet.add(t.key + `:` + t.value);
+  });
+  let isPartition = t => partitionKeySet.has(t.key + `:` + t.value);
+  let isCrossPartition = t => crossPartitionTagKeys.includes(t.key);
+  let crossPartitionEventTags = collectEventTags(events).filter(isCrossPartition);
+  let carriedMap = carriedTypesByTag(events);
+  let partitionMap = partitionTypesByTag(events, partitionTag);
+  let producedTypesFor = t => {
+    let k = t.key + `:` + t.value;
+    return Stdlib_Option.getOr((
+        isPartition(t) && !crossPartitionTagKeys.includes(t.key) ? partitionMap : carriedMap
+      )[k], []);
+  };
+  let consumedMap = {};
+  cond.query.forEach(qi => {
+    let match = qi.tags;
+    let match$1 = qi.eventTypes;
+    if (match !== undefined && match$1 !== undefined) {
+      match.forEach(t => {
+        let k = t.key + `:` + t.value;
+        let cur = Stdlib_Option.getOr(consumedMap[k], []);
+        consumedMap[k] = dedupStrings(cur.concat(match$1));
+      });
+      return;
+    }
+  });
+  let consumedTypesFor = t => Stdlib_Option.getOr(consumedMap[t.key + `:` + t.value], []);
+  let compositeKeySet = new Set();
+  let compositeQueryTags = [];
+  cond.query.forEach(qi => {
+    let tags = qi.tags;
+    if (tags !== undefined && tags.length > 1) {
+      tags.forEach(tag => {
+        let k = tag.key + `:` + tag.value;
+        if (!compositeKeySet.has(k)) {
+          compositeKeySet.add(k);
+          compositeQueryTags.push(tag);
+          return;
+        }
+      });
+      return;
+    }
+  });
+  let isCompositeQueryTag = t => compositeKeySet.has(t.key + `:` + t.value);
+  let updateKeySet = new Set();
+  let conditionalUpdateTags = [];
+  let checkKeySet = new Set();
+  let conditionCheckTags = [];
+  let pushUpdate = tag => {
+    let k = tag.key + `:` + tag.value;
+    if (!updateKeySet.has(k)) {
+      updateKeySet.add(k);
+      conditionalUpdateTags.push(tag);
+      return;
+    }
+  };
+  cond.query.forEach(qi => {
+    let tags = qi.tags;
+    if (tags === undefined) {
+      return;
+    }
+    if (tags.length !== 1) {
+      if (tags.length <= 1) {
+        return;
+      }
+      let match = cond.after;
+      if (match !== undefined) {
+        tags.forEach(pushUpdate);
+        return;
+      } else {
+        return;
+      }
+    }
+    let tag = tags[0];
+    if (crossPartitionTagKeys.includes(tag.key)) {
+      return pushUpdate(tag);
+    }
+    let match$1 = cond.after;
+    if (match$1 !== undefined) {
+      if (isPartition(tag) || isCompositeQueryTag(tag)) {
+        return pushUpdate(tag);
+      } else {
+        let k = tag.key + `:` + tag.value;
+        if (!checkKeySet.has(k)) {
+          checkKeySet.add(k);
+          conditionCheckTags.push(tag);
+          return;
+        } else {
+          return;
+        }
+      }
+    } else if (isPartition(tag)) {
+      return pushUpdate(tag);
+    } else {
+      return;
+    }
+  });
+  let match = cond.after;
+  if (match !== undefined) {
+    
+  } else {
+    partitionTags.forEach(pushUpdate);
+  }
+  let bumpSeen = new Set();
+  conditionalUpdateTags.forEach(t => {
+    bumpSeen.add(t.key + `:` + t.value);
+  });
+  let bumpTags = [];
+  let match$1 = cond.after;
+  let candidateBumps = match$1 !== undefined ? partitionTags.concat(crossPartitionEventTags) : partitionTags.concat(compositeQueryTags.concat(crossPartitionEventTags));
+  candidateBumps.forEach(tag => {
+    let k = tag.key + `:` + tag.value;
+    if (!bumpSeen.has(k)) {
+      bumpSeen.add(k);
+      bumpTags.push(tag);
+      return;
+    }
+  });
+  let putItems = buildEventPuts(table, events, basePosition, partitionTag);
+  let updateItems = Stdlib_Array.filterMap(conditionalUpdateTags, tag => {
+    let producedTypes = producedTypesFor(tag);
+    if (producedTypes.length === 0) {
+      return;
+    } else {
+      return {
+        Update: buildConditionalFenceUpdate(table.name, tag, consumedTypesFor(tag), producedTypes, basePosition, cond.after)
+      };
+    }
+  });
+  let checkItems = Stdlib_Array.filterMap(conditionCheckTags, tag => {
+    let consumedTypes = consumedTypesFor(tag);
+    if (consumedTypes.length === 0) {
+      return;
+    } else {
+      return {
+        ConditionCheck: buildFenceConditionCheck(table.name, tag, consumedTypes, cond.after)
+      };
+    }
+  });
+  let bumpItems = Stdlib_Array.filterMap(bumpTags, tag => {
+    let producedTypes = producedTypesFor(tag);
+    if (producedTypes.length === 0) {
+      return;
+    } else {
+      return {
+        Update: buildUnconditionalFenceUpdate(table.name, tag, producedTypes, basePosition)
+      };
+    }
+  });
+  return putItems.concat(updateItems.concat(checkItems.concat(bumpItems)));
+}
+
+async function appendConditional(table, events, cond, partitionTag, crossPartitionTagKeysOpt) {
+  let crossPartitionTagKeys = crossPartitionTagKeysOpt !== undefined ? crossPartitionTagKeysOpt : [];
+  let queryTags = collectQueryTags(cond.query);
+  if (queryTags.length === 0) {
+    return {
+      TAG: "Error",
+      _0: "DCB append: tagless conditions are not supported on DynamoDB — every queryItem must have at least one tag"
+    };
+  }
+  let basePosition = generatePosition();
+  let transactItems = buildConditionalTransactItems(table, events, cond, basePosition, partitionTag, crossPartitionTagKeys);
+  let totalItems = transactItems.length;
+  if (totalItems > 100) {
+    return {
+      TAG: "Error",
+      _0: `DCB append: TransactWriteItems limit exceeded (` + totalItems.toString() + ` > ` + (100).toString() + `); reduce events or distinct tag values per command`
+    };
+  }
+  let input = {
+    TransactItems: transactItems
+  };
+  return await runTransactWrite(input, basePosition, "DCB append failed");
+}
+
+function append(table, partitionTag, $staropt$star) {
+  return async (events, condition) => {
+    let crossPartitionTagKeys = $staropt$star !== undefined ? $staropt$star : [];
+    if (condition !== undefined) {
+      return await appendConditional(table, events, condition, partitionTag, crossPartitionTagKeys);
+    } else {
+      return await appendUnconditional(table, events, partitionTag);
+    }
+  };
+}
+
+function queryByPartitionKeyStream(table, partitionKey, after, strongConsistencyOpt) {
+  let strongConsistency = strongConsistencyOpt !== undefined ? strongConsistencyOpt : false;
+  let baseParams = buildQueryByPartitionKeyInput(table, partitionKey, after, strongConsistency);
+  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(DynamoDb_Error$ReventlessAws.message(err))), result => [
+    Stdlib_Option.getOr(result.Items, []),
+    Stdlib_Option.map(result.LastEvaluatedKey, key => key)
+  ]));
+}
+
+function queryByCompositeTagsStream(table, tags, after) {
+  let composite = compositeTagKey(tags);
+  let expressionAttributeValues = Object.fromEntries([[
+      ":composite",
+      composite
+    ]]);
+  let match = after !== undefined ? (expressionAttributeValues[":after"] = after, [
+      "tag_composite = :composite AND #pos > :after",
+      Object.fromEntries([[
+          "#pos",
+          "position"
+        ]])
+    ]) : [
+      "tag_composite = :composite",
+      undefined
+    ];
+  let baseParams_TableName = table.name;
+  let baseParams_ExpressionAttributeNames = match[1];
+  let baseParams_ExpressionAttributeValues = expressionAttributeValues;
+  let baseParams_IndexName = "tag_composite";
+  let baseParams_KeyConditionExpression = match[0];
+  let baseParams = {
+    TableName: baseParams_TableName,
+    ExpressionAttributeNames: baseParams_ExpressionAttributeNames,
+    ExpressionAttributeValues: baseParams_ExpressionAttributeValues,
+    IndexName: baseParams_IndexName,
+    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(DynamoDb_Error$ReventlessAws.message(err))), result => [
+    Stdlib_Option.getOr(result.Items, []),
+    Stdlib_Option.map(result.LastEvaluatedKey, key => key)
+  ]));
+}
+
+function scanWithFilterStream(table, eventTypes, after) {
+  let filter = buildScanFilter(eventTypes);
+  let baseParams_TableName = table.name;
+  let baseParams_ExpressionAttributeNames = filter.expressionAttributeNames;
+  let baseParams_ExpressionAttributeValues = filter.expressionAttributeValues;
+  let baseParams_FilterExpression = filter.filterExpression;
+  let baseParams = {
+    TableName: baseParams_TableName,
+    ExpressionAttributeNames: baseParams_ExpressionAttributeNames,
+    ExpressionAttributeValues: baseParams_ExpressionAttributeValues,
+    FilterExpression: baseParams_FilterExpression
+  };
+  let baseStream = 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.ScanCommand.send(new LibDynamodb.ScanCommand(params));
+  }), DynamoDb_Error$ReventlessAws.retrySchedule), err => Effect$1.fail(DynamoDb_Error$ReventlessAws.message(err))), result => [
+    Stdlib_Option.getOr(result.Items, []),
+    Stdlib_Option.map(result.LastEvaluatedKey, key => key)
+  ]));
+  if (after !== undefined) {
+    return Stream$1.filter(baseStream, item => Stdlib_Option.mapOr(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(item), obj => obj["position"]), Stdlib_JSON.Decode.string), false, pos => Primitive_string.compare(pos, after) > 0));
+  } else {
+    return baseStream;
+  }
+}
+
+function executeQueryItemStream(table, queryItem, after, strongConsistencyOpt, crossPartitionTagKeysOpt) {
+  let strongConsistency = strongConsistencyOpt !== undefined ? strongConsistencyOpt : false;
+  let crossPartitionTagKeys = crossPartitionTagKeysOpt !== undefined ? crossPartitionTagKeysOpt : [];
+  let tags = queryItem.tags;
+  if (tags !== undefined) {
+    if (tags.length !== 1) {
+      if (tags.length > 1) {
+        return queryByCompositeTagsStream(table, tags, after);
+      }
+      tags.length !== 0;
+    } else {
+      let tag = tags[0];
+      if (crossPartitionTagKeys.includes(tag.key)) {
+        return queryBySingleTagCrossPartitionStream(table, tag, after);
+      } else {
+        return queryByPartitionKeyStream(table, tag.key + `:` + tag.value, after, strongConsistency);
+      }
+    }
+  }
+  let eventTypes = queryItem.eventTypes;
+  if (eventTypes !== undefined) {
+    return scanWithFilterStream(table, eventTypes, after);
+  } else {
+    return scanWithFilterStream(table, undefined, after);
+  }
+}
+
+function readStream(table, $staropt$star) {
+  return (query, after, $staropt$star$1) => {
+    let crossPartitionTagKeys = $staropt$star !== undefined ? $staropt$star : [];
+    let strongConsistency = $staropt$star$1 !== undefined ? $staropt$star$1 : false;
+    let streams = query.map(qi => executeQueryItemStream(table, qi, after, strongConsistency, crossPartitionTagKeys));
+    let match = streams.length;
+    if (match === 0) {
+      return Stream$1.empty;
+    }
+    if (match === 1) {
+      return Stream$1.map(streams[0], fromItem);
+    }
+    let hasScan = query.some(qi => qi.tags === undefined);
+    if (hasScan) {
+      return Stream$1.flatMap(Stream$1.fromEffect(Effect$1.map(Effect$1.all(streams.map(Stream.runCollect), {
+        concurrency: 3
+      }), results => {
+        let allItems = results.flat().map(fromItem);
+        let deduped = deduplicateByPosition(allItems);
+        return deduped.toSorted((a, b) => Primitive_string.compare(a.position, b.position));
+      })), events => Stream$1.fromIterable(events));
+    } else {
+      return dedupByPosition(mergeSortedEvents(streams.map(s => Stream$1.map(s, fromItem))));
+    }
+  };
+}
+
+let transactWriteItemsLimit = 100;
+
+export {
+  generatePosition,
+  generatePositionForBatch,
+  tagToAttributeName,
+  compositeIndexName,
+  indexKeepsFullProjection,
+  compositeTagKey,
+  derivePartitionKey,
+  toItem,
+  fromItem,
+  queryByCompositeTags,
+  buildScanFilter,
+  scanWithFilter,
+  buildQueryByPartitionKeyInput,
+  queryByPartitionKey,
+  resolveBaseItem,
+  queryBySingleTagCrossPartitionStream,
+  executeQueryItem,
+  deduplicateByPosition,
+  initSlot,
+  findMinSlotIdx,
+  dedupByPosition,
+  mergeSortedEvents,
+  read,
+  fenceSortKey,
+  fencePartitionKey,
+  fenceKey,
+  collectQueryTags,
+  collectEventTags,
+  fenceTypeAttr,
+  dedupStrings,
+  carriedTypesByTag,
+  buildConditionalFenceUpdate,
+  buildUnconditionalFenceUpdate,
+  buildFenceConditionCheck,
+  transactWriteItemsLimit,
+  buildEventPuts,
+  runTransactWrite,
+  appendUnconditional,
+  eventPartitionTags,
+  collectEventPartitionTags,
+  partitionTypesByTag,
+  buildConditionalTransactItems,
+  appendConditional,
+  append,
+  queryByPartitionKeyStream,
+  queryByCompositeTagsStream,
+  scanWithFilterStream,
+  executeQueryItemStream,
+  readStream,
+}
+/* S Not a pure module */