@http-client-toolkit/store-dynamodb 0.0.1

package/lib/index.js

@@ -0,0 +1,1800 @@
+import { DynamoDBClient, ResourceNotFoundException } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient, GetCommand, PutCommand, DeleteCommand, ScanCommand, UpdateCommand, TransactWriteCommand, QueryCommand, BatchWriteCommand } from '@aws-sdk/lib-dynamodb';
+import { randomUUID } from 'crypto';
+import { DEFAULT_RATE_LIMIT, AdaptiveCapacityCalculator } from '@http-client-toolkit/core';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __pow = Math.pow;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var MAX_BATCH_WRITE_RETRIES = 8;
+var MAX_DYNAMO_KEY_PART_BYTES = 512;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getRetryDelayMs(attempt) {
+  const backoff = Math.min(1e3, 50 * __pow(2, attempt));
+  const jitter = Math.floor(Math.random() * 25);
+  return backoff + jitter;
+}
+function batchDeleteWithRetries(docClient, tableName, keys) {
+  return __async(this, null, function* () {
+    var _a, _b;
+    for (let i = 0; i < keys.length; i += 25) {
+      const batch = keys.slice(i, i + 25);
+      let pendingWrites = batch.map((key) => ({ DeleteRequest: { Key: key } }));
+      for (let attempt = 0; pendingWrites.length > 0; attempt++) {
+        const response = yield docClient.send(
+          new BatchWriteCommand({
+            RequestItems: {
+              [tableName]: pendingWrites
+            }
+          })
+        );
+        const unprocessed = (_b = (_a = response.UnprocessedItems) == null ? void 0 : _a[tableName]) != null ? _b : [];
+        if (unprocessed.length === 0) {
+          break;
+        }
+        if (attempt >= MAX_BATCH_WRITE_RETRIES) {
+          throw new Error(
+            `Failed to delete all items from table "${tableName}" after ${MAX_BATCH_WRITE_RETRIES + 1} attempts`
+          );
+        }
+        pendingWrites = unprocessed.map((request) => {
+          var _a2;
+          return (_a2 = request.DeleteRequest) == null ? void 0 : _a2.Key;
+        }).filter((key) => Boolean(key)).map((key) => ({ DeleteRequest: { Key: key } }));
+        yield sleep(getRetryDelayMs(attempt));
+      }
+    }
+  });
+}
+function queryCountAllPages(docClient, input) {
+  return __async(this, null, function* () {
+    var _a;
+    let total = 0;
+    let lastEvaluatedKey;
+    do {
+      const result = yield docClient.send(
+        new QueryCommand(__spreadProps(__spreadValues({}, input), {
+          ExclusiveStartKey: lastEvaluatedKey
+        }))
+      );
+      total += (_a = result.Count) != null ? _a : 0;
+      lastEvaluatedKey = result.LastEvaluatedKey;
+    } while (lastEvaluatedKey);
+    return total;
+  });
+}
+function queryItemsAllPages(docClient, input) {
+  return __async(this, null, function* () {
+    var _a;
+    const items = [];
+    let lastEvaluatedKey;
+    do {
+      const result = yield docClient.send(
+        new QueryCommand(__spreadProps(__spreadValues({}, input), {
+          ExclusiveStartKey: lastEvaluatedKey
+        }))
+      );
+      if ((_a = result.Items) == null ? void 0 : _a.length) {
+        items.push(...result.Items);
+      }
+      lastEvaluatedKey = result.LastEvaluatedKey;
+    } while (lastEvaluatedKey);
+    return items;
+  });
+}
+function queryCountUpTo(docClient, input, maxCount) {
+  return __async(this, null, function* () {
+    var _a;
+    if (maxCount <= 0) {
+      return { count: 0, reachedLimit: true };
+    }
+    let total = 0;
+    let lastEvaluatedKey;
+    do {
+      const remaining = maxCount - total;
+      const result = yield docClient.send(
+        new QueryCommand(__spreadProps(__spreadValues({}, input), {
+          Select: "COUNT",
+          Limit: remaining,
+          ExclusiveStartKey: lastEvaluatedKey
+        }))
+      );
+      total += (_a = result.Count) != null ? _a : 0;
+      if (total >= maxCount) {
+        return { count: maxCount, reachedLimit: true };
+      }
+      lastEvaluatedKey = result.LastEvaluatedKey;
+    } while (lastEvaluatedKey);
+    return { count: total, reachedLimit: false };
+  });
+}
+function isConditionalTransactionFailure(error) {
+  var _a;
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const maybeError = error;
+  if (maybeError.name !== "TransactionCanceledException") {
+    return false;
+  }
+  const cancellationReasons = (_a = maybeError.CancellationReasons) != null ? _a : maybeError.cancellationReasons;
+  if (Array.isArray(cancellationReasons)) {
+    return cancellationReasons.some((reason) => {
+      if (!reason || typeof reason !== "object") {
+        return false;
+      }
+      return "Code" in reason && reason.Code === "ConditionalCheckFailed";
+    });
+  }
+  return typeof maybeError.message === "string" && maybeError.message.includes("ConditionalCheckFailed");
+}
+function assertDynamoKeyPart(value, label, maxBytes = MAX_DYNAMO_KEY_PART_BYTES) {
+  if (value.length === 0) {
+    throw new Error(`${label} must not be empty`);
+  }
+  for (let i = 0; i < value.length; i++) {
+    const charCode = value.charCodeAt(i);
+    if (charCode < 32 || charCode === 127) {
+      throw new Error(`${label} contains unsupported control characters`);
+    }
+  }
+  if (Buffer.byteLength(value, "utf8") > maxBytes) {
+    throw new Error(`${label} exceeds maximum length of ${maxBytes} bytes`);
+  }
+}
+function throwIfDynamoTableMissing(error, tableName) {
+  if (error instanceof ResourceNotFoundException || error && typeof error === "object" && "name" in error && error.name === "ResourceNotFoundException") {
+    throw new Error(
+      `DynamoDB table "${tableName}" was not found. Create the table using your infrastructure before using DynamoDB stores.`
+    );
+  }
+}
+
+// src/table.ts
+var DEFAULT_TABLE_NAME = "http-client-toolkit";
+var TABLE_SCHEMA = {
+  KeySchema: [
+    { AttributeName: "pk", KeyType: "HASH" },
+    { AttributeName: "sk", KeyType: "RANGE" }
+  ],
+  AttributeDefinitions: [
+    { AttributeName: "pk", AttributeType: "S" },
+    { AttributeName: "sk", AttributeType: "S" },
+    { AttributeName: "gsi1pk", AttributeType: "S" },
+    { AttributeName: "gsi1sk", AttributeType: "S" }
+  ],
+  GlobalSecondaryIndexes: [
+    {
+      IndexName: "gsi1",
+      KeySchema: [
+        { AttributeName: "gsi1pk", KeyType: "HASH" },
+        { AttributeName: "gsi1sk", KeyType: "RANGE" }
+      ],
+      Projection: { ProjectionType: "ALL" }
+    }
+  ]
+};
+
+// src/dynamodb-cache-store.ts
+var DynamoDBCacheStore = class {
+  constructor({
+    client,
+    region,
+    tableName = DEFAULT_TABLE_NAME,
+    maxEntrySizeBytes = 390 * 1024
+  } = {}) {
+    this.isDestroyed = false;
+    this.tableName = tableName;
+    this.maxEntrySizeBytes = maxEntrySizeBytes;
+    if (client instanceof DynamoDBDocumentClient) {
+      this.docClient = client;
+      this.isClientManaged = false;
+    } else if (client instanceof DynamoDBClient) {
+      this.docClient = DynamoDBDocumentClient.from(client);
+      this.isClientManaged = false;
+    } else {
+      const config = {};
+      if (region) config.region = region;
+      this.rawClient = new DynamoDBClient(config);
+      this.docClient = DynamoDBDocumentClient.from(this.rawClient);
+      this.isClientManaged = true;
+    }
+  }
+  get(hash) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Cache store has been destroyed");
+      }
+      this.assertValidHash(hash);
+      const pk = `CACHE#${hash}`;
+      let result;
+      try {
+        result = yield this.docClient.send(
+          new GetCommand({
+            TableName: this.tableName,
+            Key: { pk, sk: pk }
+          })
+        );
+      } catch (error) {
+        throwIfDynamoTableMissing(error, this.tableName);
+        throw error;
+      }
+      if (!result.Item) {
+        return void 0;
+      }
+      const now = Math.floor(Date.now() / 1e3);
+      if (result.Item["ttl"] > 0 && now >= result.Item["ttl"]) {
+        yield this.delete(hash);
+        return void 0;
+      }
+      try {
+        const value = result.Item["value"];
+        if (value === "__UNDEFINED__") {
+          return void 0;
+        }
+        return JSON.parse(value);
+      } catch (e) {
+        yield this.delete(hash);
+        return void 0;
+      }
+    });
+  }
+  set(hash, value, ttlSeconds) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Cache store has been destroyed");
+      }
+      this.assertValidHash(hash);
+      const now = Date.now();
+      const nowEpoch = Math.floor(now / 1e3);
+      let ttl;
+      if (ttlSeconds < 0) {
+        ttl = nowEpoch;
+      } else if (ttlSeconds === 0) {
+        ttl = 0;
+      } else {
+        ttl = nowEpoch + ttlSeconds;
+      }
+      let serializedValue;
+      try {
+        if (value === void 0) {
+          serializedValue = "__UNDEFINED__";
+        } else {
+          serializedValue = JSON.stringify(value);
+        }
+      } catch (error) {
+        throw new Error(
+          `Failed to serialize value: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      if (Buffer.byteLength(serializedValue, "utf8") > this.maxEntrySizeBytes) {
+        return;
+      }
+      const pk = `CACHE#${hash}`;
+      try {
+        yield this.docClient.send(
+          new PutCommand({
+            TableName: this.tableName,
+            Item: {
+              pk,
+              sk: pk,
+              value: serializedValue,
+              ttl,
+              createdAt: now
+            }
+          })
+        );
+      } catch (error) {
+        throwIfDynamoTableMissing(error, this.tableName);
+        throw error;
+      }
+    });
+  }
+  delete(hash) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Cache store has been destroyed");
+      }
+      this.assertValidHash(hash);
+      const pk = `CACHE#${hash}`;
+      try {
+        yield this.docClient.send(
+          new DeleteCommand({
+            TableName: this.tableName,
+            Key: { pk, sk: pk }
+          })
+        );
+      } catch (error) {
+        throwIfDynamoTableMissing(error, this.tableName);
+        throw error;
+      }
+    });
+  }
+  clear() {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Cache store has been destroyed");
+      }
+      let lastEvaluatedKey;
+      do {
+        let scanResult;
+        try {
+          scanResult = yield this.docClient.send(
+            new ScanCommand({
+              TableName: this.tableName,
+              FilterExpression: "begins_with(pk, :prefix)",
+              ExpressionAttributeValues: { ":prefix": "CACHE#" },
+              ProjectionExpression: "pk, sk",
+              ExclusiveStartKey: lastEvaluatedKey
+            })
+          );
+        } catch (error) {
+          throwIfDynamoTableMissing(error, this.tableName);
+          throw error;
+        }
+        const items = (_a = scanResult.Items) != null ? _a : [];
+        if (items.length > 0) {
+          try {
+            yield batchDeleteWithRetries(
+              this.docClient,
+              this.tableName,
+              items.map((item) => ({ pk: item["pk"], sk: item["sk"] }))
+            );
+          } catch (error) {
+            throwIfDynamoTableMissing(error, this.tableName);
+            throw error;
+          }
+        }
+        lastEvaluatedKey = scanResult.LastEvaluatedKey;
+      } while (lastEvaluatedKey);
+    });
+  }
+  close() {
+    return __async(this, null, function* () {
+      this.isDestroyed = true;
+      if (this.isClientManaged && this.rawClient) {
+        this.rawClient.destroy();
+      }
+    });
+  }
+  destroy() {
+    this.close();
+  }
+  assertValidHash(hash) {
+    assertDynamoKeyPart(hash, "hash");
+  }
+};
+var DynamoDBDedupeStore = class {
+  constructor({
+    client,
+    region,
+    tableName = DEFAULT_TABLE_NAME,
+    jobTimeoutMs = 3e5,
+    pollIntervalMs = 500
+  } = {}) {
+    this.jobPromises = /* @__PURE__ */ new Map();
+    this.jobSettlers = /* @__PURE__ */ new Map();
+    this.isDestroyed = false;
+    this.tableName = tableName;
+    this.jobTimeoutMs = jobTimeoutMs;
+    this.pollIntervalMs = pollIntervalMs;
+    if (client instanceof DynamoDBDocumentClient) {
+      this.docClient = client;
+      this.isClientManaged = false;
+    } else if (client instanceof DynamoDBClient) {
+      this.docClient = DynamoDBDocumentClient.from(client);
+      this.isClientManaged = false;
+    } else {
+      const config = {};
+      if (region) config.region = region;
+      this.rawClient = new DynamoDBClient(config);
+      this.docClient = DynamoDBDocumentClient.from(this.rawClient);
+      this.isClientManaged = true;
+    }
+  }
+  waitFor(hash) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Dedupe store has been destroyed");
+      }
+      this.assertValidHash(hash);
+      const existingPromise = this.jobPromises.get(hash);
+      if (existingPromise) {
+        return existingPromise;
+      }
+      const pk = `DEDUPE#${hash}`;
+      let item;
+      try {
+        const result = yield this.docClient.send(
+          new GetCommand({
+            TableName: this.tableName,
+            Key: { pk, sk: pk }
+          })
+        );
+        item = result.Item;
+      } catch (error) {
+        throwIfDynamoTableMissing(error, this.tableName);
+        throw error;
+      }
+      if (!item) {
+        return void 0;
+      }
+      if (item["status"] === "completed") {
+        return this.deserializeResult(item["result"]);
+      }
+      if (item["status"] === "failed") {
+        return void 0;
+      }
+      const promise = new Promise((resolve) => {
+        let settled = false;
+        let timeoutHandle;
+        const settle = (value) => {
+          if (settled) return;
+          settled = true;
+          if (timeoutHandle) clearTimeout(timeoutHandle);
+          clearInterval(pollHandle);
+          this.jobSettlers.delete(hash);
+          this.jobPromises.delete(hash);
+          resolve(value);
+        };
+        this.jobSettlers.set(hash, settle);
+        const poll = () => __async(this, null, function* () {
+          if (this.isDestroyed) {
+            settle(void 0);
+            return;
+          }
+          try {
+            const latest = yield this.docClient.send(
+              new GetCommand({
+                TableName: this.tableName,
+                Key: { pk, sk: pk }
+              })
+            );
+            const latestItem = latest.Item;
+            if (!latestItem) {
+              settle(void 0);
+              return;
+            }
+            const isExpired = this.jobTimeoutMs > 0 && Date.now() - latestItem["createdAt"] >= this.jobTimeoutMs;
+            if (isExpired) {
+              try {
+                yield this.docClient.send(
+                  new UpdateCommand({
+                    TableName: this.tableName,
+                    Key: { pk, sk: pk },
+                    UpdateExpression: "SET #status = :failed, #error = :error, updatedAt = :now",
+                    ExpressionAttributeNames: {
+                      "#status": "status",
+                      "#error": "error"
+                    },
+                    ExpressionAttributeValues: {
+                      ":failed": "failed",
+                      ":error": "Job timed out",
+                      ":now": Date.now()
+                    }
+                  })
+                );
+              } catch (e) {
+              }
+              settle(void 0);
+              return;
+            }
+            if (latestItem["status"] === "completed") {
+              settle(this.deserializeResult(latestItem["result"]));
+              return;
+            }
+            if (latestItem["status"] === "failed") {
+              settle(void 0);
+            }
+          } catch (e) {
+            settle(void 0);
+          }
+        });
+        let isPolling = false;
+        const pollHandle = setInterval(() => {
+          if (isPolling) {
+            return;
+          }
+          isPolling = true;
+          void poll().finally(() => {
+            isPolling = false;
+          });
+        }, this.pollIntervalMs);
+        if (typeof pollHandle.unref === "function") {
+          pollHandle.unref();
+        }
+        void poll();
+        if (this.jobTimeoutMs > 0) {
+          timeoutHandle = setTimeout(() => {
+            if (this.isDestroyed) {
+              settle(void 0);
+              return;
+            }
+            void (() => __async(this, null, function* () {
+              try {
+                yield this.docClient.send(
+                  new UpdateCommand({
+                    TableName: this.tableName,
+                    Key: { pk, sk: pk },
+                    UpdateExpression: "SET #status = :failed, #error = :error, updatedAt = :now",
+                    ExpressionAttributeNames: {
+                      "#status": "status",
+                      "#error": "error"
+                    },
+                    ExpressionAttributeValues: {
+                      ":failed": "failed",
+                      ":error": "Job timed out",
+                      ":now": Date.now()
+                    }
+                  })
+                );
+              } catch (e) {
+              } finally {
+                settle(void 0);
+              }
+            }))();
+          }, this.jobTimeoutMs);
+          if (typeof timeoutHandle.unref === "function") {
+            timeoutHandle.unref();
+          }
+        }
+      });
+      this.jobPromises.set(hash, promise);
+      return promise;
+    });
+  }
+  register(hash) {
+    return __async(this, null, function* () {
+      const registration = yield this.registerOrJoin(hash);
+      return registration.jobId;
+    });
+  }
+  registerOrJoin(hash) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Dedupe store has been destroyed");
+      }
+      this.assertValidHash(hash);
+      const pk = `DEDUPE#${hash}`;
+      const maxAttempts = 3;
+      for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        const candidateJobId = randomUUID();
+        const now = Date.now();
+        const ttl = this.jobTimeoutMs > 0 ? Math.floor((now + this.jobTimeoutMs) / 1e3) : 0;
+        try {
+          yield this.docClient.send(
+            new PutCommand({
+              TableName: this.tableName,
+              Item: {
+                pk,
+                sk: pk,
+                jobId: candidateJobId,
+                status: "pending",
+                result: null,
+                error: null,
+                createdAt: now,
+                updatedAt: now,
+                ttl
+              },
+              ConditionExpression: "attribute_not_exists(pk) OR #status <> :pending",
+              ExpressionAttributeNames: { "#status": "status" },
+              ExpressionAttributeValues: { ":pending": "pending" }
+            })
+          );
+          return { jobId: candidateJobId, isOwner: true };
+        } catch (error) {
+          throwIfDynamoTableMissing(error, this.tableName);
+          if (error && typeof error === "object" && "name" in error && error.name === "ConditionalCheckFailedException") {
+            const existing = yield this.docClient.send(
+              new GetCommand({
+                TableName: this.tableName,
+                Key: { pk, sk: pk }
+              })
+            );
+            if (existing.Item) {
+              return {
+                jobId: existing.Item["jobId"],
+                isOwner: false
+              };
+            }
+            continue;
+          }
+          throw error;
+        }
+      }
+      throw new Error(
+        `Failed to register or join job for hash "${hash}" after ${maxAttempts} attempts`
+      );
+    });
+  }
+  complete(hash, value) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Dedupe store has been destroyed");
+      }
+      this.assertValidHash(hash);
+      let serializedResult;
+      if (value === void 0) {
+        serializedResult = "__UNDEFINED__";
+      } else if (value === null) {
+        serializedResult = "__NULL__";
+      } else {
+        try {
+          serializedResult = JSON.stringify(value);
+        } catch (error) {
+          throw new Error(
+            `Failed to serialize result: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      const pk = `DEDUPE#${hash}`;
+      try {
+        yield this.docClient.send(
+          new UpdateCommand({
+            TableName: this.tableName,
+            Key: { pk, sk: pk },
+            UpdateExpression: "SET #status = :completed, #result = :result, updatedAt = :now",
+            ConditionExpression: "attribute_exists(pk) AND #status = :pending",
+            ExpressionAttributeNames: {
+              "#status": "status",
+              "#result": "result"
+            },
+            ExpressionAttributeValues: {
+              ":completed": "completed",
+              ":pending": "pending",
+              ":result": serializedResult,
+              ":now": Date.now()
+            }
+          })
+        );
+      } catch (error) {
+        throwIfDynamoTableMissing(error, this.tableName);
+        if (error && typeof error === "object" && "name" in error && error.name === "ConditionalCheckFailedException") {
+          return;
+        }
+        throw error;
+      }
+      const settle = this.jobSettlers.get(hash);
+      if (settle) {
+        settle(value);
+      }
+    });
+  }
+  fail(hash, _error) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Dedupe store has been destroyed");
+      }
+      this.assertValidHash(hash);
+      const pk = `DEDUPE#${hash}`;
+      try {
+        yield this.docClient.send(
+          new UpdateCommand({
+            TableName: this.tableName,
+            Key: { pk, sk: pk },
+            UpdateExpression: "SET #status = :failed, #error = :error, updatedAt = :now",
+            ExpressionAttributeNames: {
+              "#status": "status",
+              "#error": "error"
+            },
+            ExpressionAttributeValues: {
+              ":failed": "failed",
+              ":error": "Job failed",
+              ":now": Date.now()
+            }
+          })
+        );
+      } catch (dynamoError) {
+        throwIfDynamoTableMissing(dynamoError, this.tableName);
+        throw dynamoError;
+      }
+      const settle = this.jobSettlers.get(hash);
+      if (settle) {
+        settle(void 0);
+      }
+    });
+  }
+  isInProgress(hash) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Dedupe store has been destroyed");
+      }
+      this.assertValidHash(hash);
+      const pk = `DEDUPE#${hash}`;
+      let result;
+      try {
+        result = yield this.docClient.send(
+          new GetCommand({
+            TableName: this.tableName,
+            Key: { pk, sk: pk }
+          })
+        );
+      } catch (error) {
+        throwIfDynamoTableMissing(error, this.tableName);
+        throw error;
+      }
+      if (!result.Item) {
+        return false;
+      }
+      const jobExpired = this.jobTimeoutMs > 0 && Date.now() - result.Item["createdAt"] >= this.jobTimeoutMs;
+      if (jobExpired) {
+        yield this.docClient.send(
+          new DeleteCommand({
+            TableName: this.tableName,
+            Key: { pk, sk: pk }
+          })
+        );
+        return false;
+      }
+      return result.Item["status"] === "pending";
+    });
+  }
+  clear() {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Dedupe store has been destroyed");
+      }
+      let lastEvaluatedKey;
+      do {
+        let scanResult;
+        try {
+          scanResult = yield this.docClient.send(
+            new ScanCommand({
+              TableName: this.tableName,
+              FilterExpression: "begins_with(pk, :prefix)",
+              ExpressionAttributeValues: { ":prefix": "DEDUPE#" },
+              ProjectionExpression: "pk, sk",
+              ExclusiveStartKey: lastEvaluatedKey
+            })
+          );
+        } catch (error) {
+          throwIfDynamoTableMissing(error, this.tableName);
+          throw error;
+        }
+        const items = (_a = scanResult.Items) != null ? _a : [];
+        if (items.length > 0) {
+          try {
+            yield batchDeleteWithRetries(
+              this.docClient,
+              this.tableName,
+              items.map((item) => ({ pk: item["pk"], sk: item["sk"] }))
+            );
+          } catch (error) {
+            throwIfDynamoTableMissing(error, this.tableName);
+            throw error;
+          }
+        }
+        lastEvaluatedKey = scanResult.LastEvaluatedKey;
+      } while (lastEvaluatedKey);
+      for (const settle of this.jobSettlers.values()) {
+        settle(void 0);
+      }
+      this.jobPromises.clear();
+      this.jobSettlers.clear();
+    });
+  }
+  close() {
+    return __async(this, null, function* () {
+      this.isDestroyed = true;
+      for (const settle of this.jobSettlers.values()) {
+        settle(void 0);
+      }
+      this.jobPromises.clear();
+      this.jobSettlers.clear();
+      if (this.isClientManaged && this.rawClient) {
+        this.rawClient.destroy();
+      }
+    });
+  }
+  destroy() {
+    this.close();
+  }
+  deserializeResult(serializedResult) {
+    try {
+      if (serializedResult === "__UNDEFINED__") {
+        return void 0;
+      }
+      if (serializedResult === "__NULL__") {
+        return null;
+      }
+      if (serializedResult) {
+        return JSON.parse(serializedResult);
+      }
+      return void 0;
+    } catch (e) {
+      return void 0;
+    }
+  }
+  assertValidHash(hash) {
+    assertDynamoKeyPart(hash, "hash");
+  }
+};
+var DynamoDBRateLimitStore = class {
+  constructor({
+    client,
+    region,
+    tableName = DEFAULT_TABLE_NAME,
+    defaultConfig = DEFAULT_RATE_LIMIT,
+    resourceConfigs = /* @__PURE__ */ new Map()
+  } = {}) {
+    this.isDestroyed = false;
+    this.tableName = tableName;
+    this.defaultConfig = defaultConfig;
+    this.resourceConfigs = resourceConfigs;
+    if (client instanceof DynamoDBDocumentClient) {
+      this.docClient = client;
+      this.isClientManaged = false;
+    } else if (client instanceof DynamoDBClient) {
+      this.docClient = DynamoDBDocumentClient.from(client);
+      this.isClientManaged = false;
+    } else {
+      const config = {};
+      if (region) config.region = region;
+      this.rawClient = new DynamoDBClient(config);
+      this.docClient = DynamoDBDocumentClient.from(this.rawClient);
+      this.isClientManaged = true;
+    }
+  }
+  canProceed(resource) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      this.assertValidResource(resource);
+      const config = (_a = this.resourceConfigs.get(resource)) != null ? _a : this.defaultConfig;
+      const now = Date.now();
+      const windowStart = now - config.windowMs;
+      const hasCapacity = yield this.hasCapacityInWindow(
+        resource,
+        windowStart,
+        config.limit
+      );
+      return hasCapacity;
+    });
+  }
+  acquire(resource) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      this.assertValidResource(resource);
+      const config = (_a = this.resourceConfigs.get(resource)) != null ? _a : this.defaultConfig;
+      if (config.limit <= 0) {
+        return false;
+      }
+      const now = Date.now();
+      const windowStart = now - config.windowMs;
+      const ttl = Math.floor((now + config.windowMs) / 1e3);
+      const eventId = randomUUID();
+      const slotPrefix = `RATELIMIT_SLOT#${resource}`;
+      const startSlot = Math.floor(Math.random() * config.limit);
+      for (let offset = 0; offset < config.limit; offset++) {
+        const slot = (startSlot + offset) % config.limit;
+        try {
+          yield this.docClient.send(
+            new TransactWriteCommand({
+              TransactItems: [
+                {
+                  Put: {
+                    TableName: this.tableName,
+                    Item: {
+                      pk: slotPrefix,
+                      sk: `SLOT#${slot}`,
+                      timestamp: now,
+                      ttl
+                    },
+                    ConditionExpression: "attribute_not_exists(pk) OR #timestamp < :windowStart",
+                    ExpressionAttributeNames: {
+                      "#timestamp": "timestamp"
+                    },
+                    ExpressionAttributeValues: {
+                      ":windowStart": windowStart
+                    }
+                  }
+                },
+                {
+                  Put: {
+                    TableName: this.tableName,
+                    Item: {
+                      pk: `RATELIMIT#${resource}`,
+                      sk: `TS#${now}#${eventId}`,
+                      ttl,
+                      timestamp: now
+                    }
+                  }
+                }
+              ]
+            })
+          );
+          return true;
+        } catch (error) {
+          throwIfDynamoTableMissing(error, this.tableName);
+          if (isConditionalTransactionFailure(error)) {
+            continue;
+          }
+          throw error;
+        }
+      }
+      return false;
+    });
+  }
+  record(resource) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      this.assertValidResource(resource);
+      const now = Date.now();
+      const config = (_a = this.resourceConfigs.get(resource)) != null ? _a : this.defaultConfig;
+      const ttl = Math.floor((now + config.windowMs) / 1e3);
+      const uuid = randomUUID();
+      try {
+        yield this.docClient.send(
+          new PutCommand({
+            TableName: this.tableName,
+            Item: {
+              pk: `RATELIMIT#${resource}`,
+              sk: `TS#${now}#${uuid}`,
+              ttl,
+              timestamp: now
+            }
+          })
+        );
+      } catch (error) {
+        throwIfDynamoTableMissing(error, this.tableName);
+        throw error;
+      }
+    });
+  }
+  getStatus(resource) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      this.assertValidResource(resource);
+      const config = (_a = this.resourceConfigs.get(resource)) != null ? _a : this.defaultConfig;
+      const now = Date.now();
+      const windowStart = now - config.windowMs;
+      const currentRequests = yield this.countRequestsInWindow(
+        resource,
+        windowStart
+      );
+      const remaining = Math.max(0, config.limit - currentRequests);
+      return {
+        remaining,
+        resetTime: new Date(now + config.windowMs),
+        limit: config.limit
+      };
+    });
+  }
+  reset(resource) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      this.assertValidResource(resource);
+      yield this.deleteResourceItems(resource);
+    });
+  }
+  getWaitTime(resource) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      this.assertValidResource(resource);
+      const config = (_a = this.resourceConfigs.get(resource)) != null ? _a : this.defaultConfig;
+      if (config.limit === 0) {
+        return config.windowMs;
+      }
+      const now = Date.now();
+      const windowStart = now - config.windowMs;
+      const hasCapacity = yield this.hasCapacityInWindow(
+        resource,
+        windowStart,
+        config.limit
+      );
+      if (hasCapacity) {
+        return 0;
+      }
+      let result;
+      try {
+        result = yield this.docClient.send(
+          new QueryCommand({
+            TableName: this.tableName,
+            KeyConditionExpression: "pk = :pk AND sk >= :skStart",
+            ExpressionAttributeValues: {
+              ":pk": `RATELIMIT#${resource}`,
+              ":skStart": `TS#${windowStart}`
+            },
+            Limit: 1,
+            ScanIndexForward: true
+          })
+        );
+      } catch (error) {
+        throwIfDynamoTableMissing(error, this.tableName);
+        throw error;
+      }
+      const oldestItem = (_b = result.Items) == null ? void 0 : _b[0];
+      if (!oldestItem) {
+        return 0;
+      }
+      const oldestTimestamp = oldestItem["timestamp"];
+      if (!oldestTimestamp) {
+        return 0;
+      }
+      const timeUntilOldestExpires = oldestTimestamp + config.windowMs - now;
+      return Math.max(0, timeUntilOldestExpires);
+    });
+  }
+  setResourceConfig(resource, config) {
+    this.assertValidResource(resource);
+    this.resourceConfigs.set(resource, config);
+  }
+  getResourceConfig(resource) {
+    var _a;
+    this.assertValidResource(resource);
+    return (_a = this.resourceConfigs.get(resource)) != null ? _a : this.defaultConfig;
+  }
+  clear() {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      let lastEvaluatedKey;
+      do {
+        let scanResult;
+        try {
+          scanResult = yield this.docClient.send(
+            new ScanCommand({
+              TableName: this.tableName,
+              FilterExpression: "begins_with(pk, :prefix) OR begins_with(pk, :slotPrefix)",
+              ExpressionAttributeValues: {
+                ":prefix": "RATELIMIT#",
+                ":slotPrefix": "RATELIMIT_SLOT#"
+              },
+              ProjectionExpression: "pk, sk",
+              ExclusiveStartKey: lastEvaluatedKey
+            })
+          );
+        } catch (error) {
+          throwIfDynamoTableMissing(error, this.tableName);
+          throw error;
+        }
+        const items = (_a = scanResult.Items) != null ? _a : [];
+        if (items.length > 0) {
+          try {
+            yield batchDeleteWithRetries(
+              this.docClient,
+              this.tableName,
+              items.map((item) => ({ pk: item["pk"], sk: item["sk"] }))
+            );
+          } catch (error) {
+            throwIfDynamoTableMissing(error, this.tableName);
+            throw error;
+          }
+        }
+        lastEvaluatedKey = scanResult.LastEvaluatedKey;
+      } while (lastEvaluatedKey);
+    });
+  }
+  close() {
+    return __async(this, null, function* () {
+      this.isDestroyed = true;
+      if (this.isClientManaged && this.rawClient) {
+        this.rawClient.destroy();
+      }
+    });
+  }
+  destroy() {
+    this.close();
+  }
+  countRequestsInWindow(resource, windowStart) {
+    return __async(this, null, function* () {
+      try {
+        return yield queryCountAllPages(this.docClient, {
+          TableName: this.tableName,
+          KeyConditionExpression: "pk = :pk AND sk >= :skStart",
+          ExpressionAttributeValues: {
+            ":pk": `RATELIMIT#${resource}`,
+            ":skStart": `TS#${windowStart}`
+          },
+          Select: "COUNT"
+        });
+      } catch (error) {
+        throwIfDynamoTableMissing(error, this.tableName);
+        throw error;
+      }
+    });
+  }
+  hasCapacityInWindow(resource, windowStart, limit) {
+    return __async(this, null, function* () {
+      try {
+        const { reachedLimit } = yield queryCountUpTo(
+          this.docClient,
+          {
+            TableName: this.tableName,
+            KeyConditionExpression: "pk = :pk AND sk >= :skStart",
+            ExpressionAttributeValues: {
+              ":pk": `RATELIMIT#${resource}`,
+              ":skStart": `TS#${windowStart}`
+            }
+          },
+          limit
+        );
+        return !reachedLimit;
+      } catch (error) {
+        throwIfDynamoTableMissing(error, this.tableName);
+        throw error;
+      }
+    });
+  }
+  deleteResourceItems(resource) {
+    return __async(this, null, function* () {
+      var _a;
+      const partitionKeys = [
+        `RATELIMIT#${resource}`,
+        `RATELIMIT_SLOT#${resource}`
+      ];
+      for (const pk of partitionKeys) {
+        let lastEvaluatedKey;
+        do {
+          let queryResult;
+          try {
+            queryResult = yield this.docClient.send(
+              new QueryCommand({
+                TableName: this.tableName,
+                KeyConditionExpression: "pk = :pk",
+                ExpressionAttributeValues: { ":pk": pk },
+                ProjectionExpression: "pk, sk",
+                ExclusiveStartKey: lastEvaluatedKey
+              })
+            );
+          } catch (error) {
+            throwIfDynamoTableMissing(error, this.tableName);
+            throw error;
+          }
+          const items = (_a = queryResult.Items) != null ? _a : [];
+          if (items.length > 0) {
+            try {
+              yield batchDeleteWithRetries(
+                this.docClient,
+                this.tableName,
+                items.map((item) => ({ pk: item["pk"], sk: item["sk"] }))
+              );
+            } catch (error) {
+              throwIfDynamoTableMissing(error, this.tableName);
+              throw error;
+            }
+          }
+          lastEvaluatedKey = queryResult.LastEvaluatedKey;
+        } while (lastEvaluatedKey);
+      }
+    });
+  }
+  assertValidResource(resource) {
+    assertDynamoKeyPart(resource, "resource");
+  }
+};
+var DEFAULT_ADAPTIVE_RATE_LIMIT = {
+  limit: 200,
+  windowMs: 36e5
+  // 1 hour
+};
+var DynamoDBAdaptiveRateLimitStore = class {
+  constructor({
+    client,
+    region,
+    tableName = DEFAULT_TABLE_NAME,
+    defaultConfig = DEFAULT_ADAPTIVE_RATE_LIMIT,
+    resourceConfigs = /* @__PURE__ */ new Map(),
+    adaptiveConfig = {}
+  } = {}) {
+    this.isDestroyed = false;
+    this.activityMetrics = /* @__PURE__ */ new Map();
+    this.lastCapacityUpdate = /* @__PURE__ */ new Map();
+    this.cachedCapacity = /* @__PURE__ */ new Map();
+    this.tableName = tableName;
+    this.defaultConfig = defaultConfig;
+    this.resourceConfigs = resourceConfigs;
+    this.capacityCalculator = new AdaptiveCapacityCalculator(adaptiveConfig);
+    this.maxMetricSamples = Math.max(
+      100,
+      this.capacityCalculator.config.highActivityThreshold * 20
+    );
+    if (client instanceof DynamoDBDocumentClient) {
+      this.docClient = client;
+      this.isClientManaged = false;
+    } else if (client instanceof DynamoDBClient) {
+      this.docClient = DynamoDBDocumentClient.from(client);
+      this.isClientManaged = false;
+    } else {
+      const config = {};
+      if (region) config.region = region;
+      this.rawClient = new DynamoDBClient(config);
+      this.docClient = DynamoDBDocumentClient.from(this.rawClient);
+      this.isClientManaged = true;
+    }
+  }
+  canProceed(resource, priority = "background") {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      this.assertValidResource(resource);
+      yield this.ensureActivityMetrics(resource);
+      const metrics = this.getOrCreateActivityMetrics(resource);
+      const capacity = this.calculateCurrentCapacity(resource, metrics);
+      if (priority === "background" && capacity.backgroundPaused) {
+        return false;
+      }
+      if (priority === "user") {
+        if (capacity.userReserved <= 0) {
+          return false;
+        }
+        return this.hasPriorityCapacityInWindow(
+          resource,
+          "user",
+          capacity.userReserved
+        );
+      } else {
+        if (capacity.backgroundMax <= 0) {
+          return false;
+        }
+        return this.hasPriorityCapacityInWindow(
+          resource,
+          "background",
+          capacity.backgroundMax
+        );
+      }
+    });
+  }
+  acquire(resource, priority = "background") {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      this.assertValidResource(resource);
+      yield this.ensureActivityMetrics(resource);
+      const metrics = this.getOrCreateActivityMetrics(resource);
+      const capacity = this.calculateCurrentCapacity(resource, metrics);
+      if (priority === "background" && capacity.backgroundPaused) {
+        return false;
+      }
+      const limitForPriority = priority === "user" ? capacity.userReserved : capacity.backgroundMax;
+      if (limitForPriority <= 0) {
+        return false;
+      }
+      const config = (_a = this.resourceConfigs.get(resource)) != null ? _a : this.defaultConfig;
+      const now = Date.now();
+      const windowStart = now - config.windowMs;
+      const ttl = Math.floor((now + config.windowMs) / 1e3);
+      const uuid = randomUUID();
+      const slotPrefix = `RATELIMIT_SLOT#${resource}#${priority}`;
+      const startSlot = Math.floor(Math.random() * limitForPriority);
+      for (let offset = 0; offset < limitForPriority; offset++) {
+        const slot = (startSlot + offset) % limitForPriority;
+        try {
+          yield this.docClient.send(
+            new TransactWriteCommand({
+              TransactItems: [
+                {
+                  Put: {
+                    TableName: this.tableName,
+                    Item: {
+                      pk: slotPrefix,
+                      sk: `SLOT#${slot}`,
+                      timestamp: now,
+                      ttl
+                    },
+                    ConditionExpression: "attribute_not_exists(pk) OR #timestamp < :windowStart",
+                    ExpressionAttributeNames: {
+                      "#timestamp": "timestamp"
+                    },
+                    ExpressionAttributeValues: {
+                      ":windowStart": windowStart
+                    }
+                  }
+                },
+                {
+                  Put: {
+                    TableName: this.tableName,
+                    Item: {
+                      pk: `RATELIMIT#${resource}`,
+                      sk: `TS#${now}#${uuid}`,
+                      gsi1pk: `RATELIMIT#${resource}#${priority}`,
+                      gsi1sk: `TS#${now}#${uuid}`,
+                      ttl,
+                      timestamp: now,
+                      priority
+                    }
+                  }
+                }
+              ]
+            })
+          );
+          if (priority === "user") {
+            this.pushRecentRequest(metrics.recentUserRequests, now);
+          } else {
+            this.pushRecentRequest(metrics.recentBackgroundRequests, now);
+          }
+          metrics.userActivityTrend = this.capacityCalculator.calculateActivityTrend(
+            metrics.recentUserRequests
+          );
+          return true;
+        } catch (error) {
+          throwIfDynamoTableMissing(error, this.tableName);
+          if (isConditionalTransactionFailure(error)) {
+            continue;
+          }
+          throw error;
+        }
+      }
+      return false;
+    });
+  }
+  record(resource, priority = "background") {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      this.assertValidResource(resource);
+      const now = Date.now();
+      const config = (_a = this.resourceConfigs.get(resource)) != null ? _a : this.defaultConfig;
+      const ttl = Math.floor((now + config.windowMs) / 1e3);
+      const uuid = randomUUID();
+      try {
+        yield this.docClient.send(
+          new PutCommand({
+            TableName: this.tableName,
+            Item: {
+              pk: `RATELIMIT#${resource}`,
+              sk: `TS#${now}#${uuid}`,
+              gsi1pk: `RATELIMIT#${resource}#${priority}`,
+              gsi1sk: `TS#${now}#${uuid}`,
+              ttl,
+              timestamp: now,
+              priority
+            }
+          })
+        );
+      } catch (error) {
+        throwIfDynamoTableMissing(error, this.tableName);
+        throw error;
+      }
+      const metrics = this.getOrCreateActivityMetrics(resource);
+      if (priority === "user") {
+        this.pushRecentRequest(metrics.recentUserRequests, now);
+      } else {
+        this.pushRecentRequest(metrics.recentBackgroundRequests, now);
+      }
+      metrics.userActivityTrend = this.capacityCalculator.calculateActivityTrend(
+        metrics.recentUserRequests
+      );
+    });
+  }
+  getStatus(resource) {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      this.assertValidResource(resource);
+      yield this.ensureActivityMetrics(resource);
+      const metrics = this.getOrCreateActivityMetrics(resource);
+      const capacity = this.calculateCurrentCapacity(resource, metrics);
+      const [currentUserUsage, currentBackgroundUsage] = yield Promise.all([
+        this.getCurrentUsage(resource, "user"),
+        this.getCurrentUsage(resource, "background")
+      ]);
+      const config = (_a = this.resourceConfigs.get(resource)) != null ? _a : this.defaultConfig;
+      return {
+        remaining: capacity.userReserved - currentUserUsage + (capacity.backgroundMax - currentBackgroundUsage),
+        resetTime: new Date(Date.now() + config.windowMs),
+        limit: this.getResourceLimit(resource),
+        adaptive: {
+          userReserved: capacity.userReserved,
+          backgroundMax: capacity.backgroundMax,
+          backgroundPaused: capacity.backgroundPaused,
+          recentUserActivity: this.capacityCalculator.getRecentActivity(
+            metrics.recentUserRequests
+          ),
+          reason: capacity.reason
+        }
+      };
+    });
+  }
+  reset(resource) {
+    return __async(this, null, function* () {
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      this.assertValidResource(resource);
+      yield this.deleteResourceItems(resource);
+      this.activityMetrics.delete(resource);
+      this.cachedCapacity.delete(resource);
+      this.lastCapacityUpdate.delete(resource);
+    });
+  }
+  getWaitTime(resource, priority = "background") {
+    return __async(this, null, function* () {
+      var _a, _b;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      this.assertValidResource(resource);
+      const config = (_a = this.resourceConfigs.get(resource)) != null ? _a : this.defaultConfig;
+      if (config.limit === 0) {
+        return config.windowMs;
+      }
+      const canProceed = yield this.canProceed(resource, priority);
+      if (canProceed) {
+        return 0;
+      }
+      yield this.ensureActivityMetrics(resource);
+      const metrics = this.getOrCreateActivityMetrics(resource);
+      const capacity = this.calculateCurrentCapacity(resource, metrics);
+      if (priority === "background" && capacity.backgroundPaused) {
+        return this.capacityCalculator.config.recalculationIntervalMs;
+      }
+      const now = Date.now();
+      const windowStart = now - config.windowMs;
+      let result;
+      try {
+        result = yield this.docClient.send(
+          new QueryCommand({
+            TableName: this.tableName,
+            IndexName: "gsi1",
+            KeyConditionExpression: "gsi1pk = :gsi1pk AND gsi1sk >= :skStart",
+            ExpressionAttributeValues: {
+              ":gsi1pk": `RATELIMIT#${resource}#${priority}`,
+              ":skStart": `TS#${windowStart}`
+            },
+            Limit: 1,
+            ScanIndexForward: true
+          })
+        );
+      } catch (error) {
+        throwIfDynamoTableMissing(error, this.tableName);
+        throw error;
+      }
+      const oldestItem = (_b = result.Items) == null ? void 0 : _b[0];
+      if (!oldestItem) {
+        return 0;
+      }
+      const oldestTimestamp = oldestItem["timestamp"];
+      if (!oldestTimestamp) {
+        return 0;
+      }
+      const timeUntilOldestExpires = oldestTimestamp + config.windowMs - now;
+      return Math.max(0, timeUntilOldestExpires);
+    });
+  }
+  setResourceConfig(resource, config) {
+    this.assertValidResource(resource);
+    this.resourceConfigs.set(resource, config);
+  }
+  getResourceConfig(resource) {
+    var _a;
+    this.assertValidResource(resource);
+    return (_a = this.resourceConfigs.get(resource)) != null ? _a : this.defaultConfig;
+  }
+  clear() {
+    return __async(this, null, function* () {
+      var _a;
+      if (this.isDestroyed) {
+        throw new Error("Rate limit store has been destroyed");
+      }
+      let lastEvaluatedKey;
+      do {
+        let scanResult;
+        try {
+          scanResult = yield this.docClient.send(
+            new ScanCommand({
+              TableName: this.tableName,
+              FilterExpression: "begins_with(pk, :prefix) OR begins_with(pk, :slotPrefix)",
+              ExpressionAttributeValues: {
+                ":prefix": "RATELIMIT#",
+                ":slotPrefix": "RATELIMIT_SLOT#"
+              },
+              ProjectionExpression: "pk, sk",
+              ExclusiveStartKey: lastEvaluatedKey
+            })
+          );
+        } catch (error) {
+          throwIfDynamoTableMissing(error, this.tableName);
+          throw error;
+        }
+        const items = (_a = scanResult.Items) != null ? _a : [];
+        if (items.length > 0) {
+          try {
+            yield batchDeleteWithRetries(
+              this.docClient,
+              this.tableName,
+              items.map((item) => ({ pk: item["pk"], sk: item["sk"] }))
+            );
+          } catch (error) {
+            throwIfDynamoTableMissing(error, this.tableName);
+            throw error;
+          }
+        }
+        lastEvaluatedKey = scanResult.LastEvaluatedKey;
+      } while (lastEvaluatedKey);
+      this.activityMetrics.clear();
+      this.cachedCapacity.clear();
+      this.lastCapacityUpdate.clear();
+    });
+  }
+  close() {
+    return __async(this, null, function* () {
+      this.isDestroyed = true;
+      if (this.isClientManaged && this.rawClient) {
+        this.rawClient.destroy();
+      }
+    });
+  }
+  destroy() {
+    this.close();
+  }
+  // Private helper methods
+  calculateCurrentCapacity(resource, metrics) {
+    var _a, _b;
+    const lastUpdate = (_a = this.lastCapacityUpdate.get(resource)) != null ? _a : 0;
+    const recalcInterval = this.capacityCalculator.config.recalculationIntervalMs;
+    if (Date.now() - lastUpdate < recalcInterval) {
+      return (_b = this.cachedCapacity.get(resource)) != null ? _b : this.getDefaultCapacity(resource);
+    }
+    const totalLimit = this.getResourceLimit(resource);
+    const capacity = this.capacityCalculator.calculateDynamicCapacity(
+      resource,
+      totalLimit,
+      metrics
+    );
+    this.cachedCapacity.set(resource, capacity);
+    this.lastCapacityUpdate.set(resource, Date.now());
+    return capacity;
+  }
+  getOrCreateActivityMetrics(resource) {
+    if (!this.activityMetrics.has(resource)) {
+      this.activityMetrics.set(resource, {
+        recentUserRequests: [],
+        recentBackgroundRequests: [],
+        userActivityTrend: "none"
+      });
+    }
+    return this.activityMetrics.get(resource);
+  }
+  ensureActivityMetrics(resource) {
+    return __async(this, null, function* () {
+      if (this.activityMetrics.has(resource)) {
+        return;
+      }
+      const now = Date.now();
+      const windowStart = now - this.capacityCalculator.config.monitoringWindowMs;
+      let userItems;
+      let backgroundItems;
+      try {
+        [userItems, backgroundItems] = yield Promise.all([
+          queryItemsAllPages(this.docClient, {
+            TableName: this.tableName,
+            IndexName: "gsi1",
+            KeyConditionExpression: "gsi1pk = :gsi1pk AND gsi1sk >= :skStart",
+            ExpressionAttributeValues: {
+              ":gsi1pk": `RATELIMIT#${resource}#user`,
+              ":skStart": `TS#${windowStart}`
+            },
+            ProjectionExpression: "#ts",
+            ExpressionAttributeNames: { "#ts": "timestamp" }
+          }),
+          queryItemsAllPages(this.docClient, {
+            TableName: this.tableName,
+            IndexName: "gsi1",
+            KeyConditionExpression: "gsi1pk = :gsi1pk AND gsi1sk >= :skStart",
+            ExpressionAttributeValues: {
+              ":gsi1pk": `RATELIMIT#${resource}#background`,
+              ":skStart": `TS#${windowStart}`
+            },
+            ProjectionExpression: "#ts",
+            ExpressionAttributeNames: { "#ts": "timestamp" }
+          })
+        ]);
+      } catch (error) {
+        throwIfDynamoTableMissing(error, this.tableName);
+        throw error;
+      }
+      const metrics = {
+        recentUserRequests: userItems.map((item) => item["timestamp"]).slice(-this.maxMetricSamples),
+        recentBackgroundRequests: backgroundItems.map((item) => item["timestamp"]).slice(-this.maxMetricSamples),
+        userActivityTrend: "none"
+      };
+      this.cleanupOldRequests(metrics.recentUserRequests);
+      this.cleanupOldRequests(metrics.recentBackgroundRequests);
+      metrics.userActivityTrend = this.capacityCalculator.calculateActivityTrend(
+        metrics.recentUserRequests
+      );
+      this.activityMetrics.set(resource, metrics);
+    });
+  }
+  getCurrentUsage(resource, priority) {
+    return __async(this, null, function* () {
+      var _a;
+      const config = (_a = this.resourceConfigs.get(resource)) != null ? _a : this.defaultConfig;
+      const now = Date.now();
+      const windowStart = now - config.windowMs;
+      try {
+        return yield queryCountAllPages(this.docClient, {
+          TableName: this.tableName,
+          IndexName: "gsi1",
+          KeyConditionExpression: "gsi1pk = :gsi1pk AND gsi1sk >= :skStart",
+          ExpressionAttributeValues: {
+            ":gsi1pk": `RATELIMIT#${resource}#${priority}`,
+            ":skStart": `TS#${windowStart}`
+          },
+          Select: "COUNT"
+        });
+      } catch (error) {
+        throwIfDynamoTableMissing(error, this.tableName);
+        throw error;
+      }
+    });
+  }
+  hasPriorityCapacityInWindow(resource, priority, limit) {
+    return __async(this, null, function* () {
+      var _a;
+      const config = (_a = this.resourceConfigs.get(resource)) != null ? _a : this.defaultConfig;
+      const now = Date.now();
+      const windowStart = now - config.windowMs;
+      try {
+        const { reachedLimit } = yield queryCountUpTo(
+          this.docClient,
+          {
+            TableName: this.tableName,
+            IndexName: "gsi1",
+            KeyConditionExpression: "gsi1pk = :gsi1pk AND gsi1sk >= :skStart",
+            ExpressionAttributeValues: {
+              ":gsi1pk": `RATELIMIT#${resource}#${priority}`,
+              ":skStart": `TS#${windowStart}`
+            }
+          },
+          limit
+        );
+        return !reachedLimit;
+      } catch (error) {
+        throwIfDynamoTableMissing(error, this.tableName);
+        throw error;
+      }
+    });
+  }
+  cleanupOldRequests(requests) {
+    const cutoff = Date.now() - this.capacityCalculator.config.monitoringWindowMs;
+    const idx = requests.findIndex((t) => t >= cutoff);
+    if (idx > 0) {
+      requests.splice(0, idx);
+    } else if (idx === -1 && requests.length > 0) {
+      requests.length = 0;
+    }
+  }
+  pushRecentRequest(requests, timestamp) {
+    requests.push(timestamp);
+    this.cleanupOldRequests(requests);
+    const overflow = requests.length - this.maxMetricSamples;
+    if (overflow > 0) {
+      requests.splice(0, overflow);
+    }
+  }
+  getResourceLimit(resource) {
+    var _a;
+    const config = (_a = this.resourceConfigs.get(resource)) != null ? _a : this.defaultConfig;
+    return config.limit;
+  }
+  getDefaultCapacity(resource) {
+    const limit = this.getResourceLimit(resource);
+    const userReserved = Math.floor(limit * 0.3);
+    const backgroundMax = Math.max(0, limit - userReserved);
+    return {
+      userReserved,
+      backgroundMax,
+      backgroundPaused: false,
+      reason: "Default capacity allocation"
+    };
+  }
+  deleteResourceItems(resource) {
+    return __async(this, null, function* () {
+      var _a;
+      const partitionKeys = [
+        `RATELIMIT#${resource}`,
+        `RATELIMIT_SLOT#${resource}#user`,
+        `RATELIMIT_SLOT#${resource}#background`
+      ];
+      for (const pk of partitionKeys) {
+        let lastEvaluatedKey;
+        do {
+          let queryResult;
+          try {
+            queryResult = yield this.docClient.send(
+              new QueryCommand({
+                TableName: this.tableName,
+                KeyConditionExpression: "pk = :pk",
+                ExpressionAttributeValues: { ":pk": pk },
+                ProjectionExpression: "pk, sk",
+                ExclusiveStartKey: lastEvaluatedKey
+              })
+            );
+          } catch (error) {
+            throwIfDynamoTableMissing(error, this.tableName);
+            throw error;
+          }
+          const items = (_a = queryResult.Items) != null ? _a : [];
+          if (items.length > 0) {
+            try {
+              yield batchDeleteWithRetries(
+                this.docClient,
+                this.tableName,
+                items.map((item) => ({ pk: item["pk"], sk: item["sk"] }))
+              );
+            } catch (error) {
+              throwIfDynamoTableMissing(error, this.tableName);
+              throw error;
+            }
+          }
+          lastEvaluatedKey = queryResult.LastEvaluatedKey;
+        } while (lastEvaluatedKey);
+      }
+    });
+  }
+  assertValidResource(resource) {
+    assertDynamoKeyPart(resource, "resource");
+  }
+};
+
+export { DEFAULT_TABLE_NAME, DynamoDBAdaptiveRateLimitStore, DynamoDBCacheStore, DynamoDBDedupeStore, DynamoDBRateLimitStore, TABLE_SCHEMA };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map