@celerity-sdk/datastore 0.4.0 → 0.6.0

package/dist/index.cjs

@@ -6,6 +6,9 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -28,67 +31,34 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ConditionalCheckFailedError: () => ConditionalCheckFailedError,
-  DEFAULT_DATASTORE_TOKEN: () => DEFAULT_DATASTORE_TOKEN,
-  Datastore: () => Datastore,
-  DatastoreClient: () => DatastoreClient,
-  DatastoreError: () => DatastoreError,
-  DatastoreLayer: () => DatastoreLayer,
-  DynamoDBDatastoreClient: () => DynamoDBDatastoreClient,
-  createDatastoreClient: () => createDatastoreClient,
-  datastoreToken: () => datastoreToken,
-  getDatastore: () => getDatastore
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/types.ts
-var DatastoreClient = /* @__PURE__ */ Symbol.for("DatastoreClient");
-
-// src/providers/dynamodb/dynamodb-datastore-client.ts
-var import_client_dynamodb = require("@aws-sdk/client-dynamodb");
-var import_lib_dynamodb3 = require("@aws-sdk/lib-dynamodb");
-
-// src/providers/dynamodb/dynamodb-datastore.ts
-var import_debug2 = __toESM(require("debug"), 1);
-var import_lib_dynamodb2 = require("@aws-sdk/lib-dynamodb");
-
 // src/errors.ts
-var DatastoreError = class extends Error {
-  static {
-    __name(this, "DatastoreError");
-  }
-  table;
-  constructor(message, table, options) {
-    super(message, options), this.table = table;
-    this.name = "DatastoreError";
-  }
-};
-var ConditionalCheckFailedError = class extends DatastoreError {
-  static {
-    __name(this, "ConditionalCheckFailedError");
-  }
-  constructor(table, options) {
-    super(`Conditional check failed on table "${table}"`, table, options);
-    this.name = "ConditionalCheckFailedError";
+var DatastoreError, ConditionalCheckFailedError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    DatastoreError = class extends Error {
+      static {
+        __name(this, "DatastoreError");
+      }
+      table;
+      constructor(message, table, options) {
+        super(message, options), this.table = table;
+        this.name = "DatastoreError";
+      }
+    };
+    ConditionalCheckFailedError = class extends DatastoreError {
+      static {
+        __name(this, "ConditionalCheckFailedError");
+      }
+      constructor(table, options) {
+        super(`Conditional check failed on table "${table}"`, table, options);
+        this.name = "ConditionalCheckFailedError";
+      }
+    };
   }
-};
-
-// src/providers/dynamodb/dynamodb-item-listing.ts
-var import_debug = __toESM(require("debug"), 1);
-var import_lib_dynamodb = require("@aws-sdk/lib-dynamodb");
+});
 
 // src/providers/dynamodb/expressions.ts
-var COMPARISON_OPERATORS = {
-  eq: "=",
-  ne: "<>",
-  lt: "<",
-  le: "<=",
-  gt: ">",
-  ge: ">="
-};
 function buildKeyConditionExpression(key, range) {
   const names = {};
   const values = {};
@@ -135,7 +105,6 @@ function buildKeyConditionExpression(key, range) {
     values
   };
 }
-__name(buildKeyConditionExpression, "buildKeyConditionExpression");
 function buildFilterExpression(conditions) {
   const condArray = Array.isArray(conditions) ? conditions : [
     conditions
@@ -187,357 +156,442 @@ function buildFilterExpression(conditions) {
     values
   };
 }
-__name(buildFilterExpression, "buildFilterExpression");
+var COMPARISON_OPERATORS;
+var init_expressions = __esm({
+  "src/providers/dynamodb/expressions.ts"() {
+    "use strict";
+    COMPARISON_OPERATORS = {
+      eq: "=",
+      ne: "<>",
+      lt: "<",
+      le: "<=",
+      gt: ">",
+      ge: ">="
+    };
+    __name(buildKeyConditionExpression, "buildKeyConditionExpression");
+    __name(buildFilterExpression, "buildFilterExpression");
+  }
+});
 
 // src/providers/dynamodb/dynamodb-item-listing.ts
-var debug = (0, import_debug.default)("celerity:datastore:dynamodb");
 function encodeCursor(lastEvaluatedKey) {
   const state = {
     lastEvaluatedKey
   };
   return Buffer.from(JSON.stringify(state)).toString("base64url");
 }
-__name(encodeCursor, "encodeCursor");
 function decodeCursor(cursor) {
   return JSON.parse(Buffer.from(cursor, "base64url").toString("utf-8"));
 }
-__name(decodeCursor, "decodeCursor");
-var DynamoDBItemListing = class {
-  static {
-    __name(this, "DynamoDBItemListing");
-  }
-  client;
-  tableName;
-  mode;
-  options;
-  tracer;
-  _cursor;
-  constructor(client, tableName, mode, options, tracer) {
-    this.client = client;
-    this.tableName = tableName;
-    this.mode = mode;
-    this.options = options;
-    this.tracer = tracer;
-    this._cursor = options.cursor;
-  }
-  get cursor() {
-    return this._cursor;
-  }
-  async *[Symbol.asyncIterator]() {
-    const cursorState = this._cursor ? decodeCursor(this._cursor) : void 0;
-    let exclusiveStartKey = cursorState?.lastEvaluatedKey;
-    do {
-      debug("%s page %s key=%o", this.mode, this.tableName, exclusiveStartKey ?? "(start)");
-      const response = await this.fetchPage(exclusiveStartKey);
-      for (const item of response.Items ?? []) {
-        yield item;
-      }
-      exclusiveStartKey = response.LastEvaluatedKey;
-      if (exclusiveStartKey) {
-        this._cursor = encodeCursor(exclusiveStartKey);
-      } else {
-        this._cursor = void 0;
-      }
-    } while (exclusiveStartKey);
-  }
-  async fetchPage(exclusiveStartKey) {
-    const command = this.mode === "query" ? this.buildQueryCommand(exclusiveStartKey) : this.buildScanCommand(exclusiveStartKey);
-    const doFetch = /* @__PURE__ */ __name(async () => {
-      try {
-        return await this.client.send(command);
-      } catch (error) {
-        throw new DatastoreError(`Failed to ${this.mode} table "${this.tableName}"`, this.tableName, {
-          cause: error
+var import_debug, import_lib_dynamodb, debug, DynamoDBItemListing;
+var init_dynamodb_item_listing = __esm({
+  "src/providers/dynamodb/dynamodb-item-listing.ts"() {
+    "use strict";
+    import_debug = __toESM(require("debug"), 1);
+    import_lib_dynamodb = require("@aws-sdk/lib-dynamodb");
+    init_errors();
+    init_expressions();
+    debug = (0, import_debug.default)("celerity:datastore:dynamodb");
+    __name(encodeCursor, "encodeCursor");
+    __name(decodeCursor, "decodeCursor");
+    DynamoDBItemListing = class {
+      static {
+        __name(this, "DynamoDBItemListing");
+      }
+      client;
+      tableName;
+      mode;
+      options;
+      tracer;
+      _cursor;
+      constructor(client, tableName, mode, options, tracer) {
+        this.client = client;
+        this.tableName = tableName;
+        this.mode = mode;
+        this.options = options;
+        this.tracer = tracer;
+        this._cursor = options.cursor;
+      }
+      get cursor() {
+        return this._cursor;
+      }
+      async *[Symbol.asyncIterator]() {
+        const cursorState = this._cursor ? decodeCursor(this._cursor) : void 0;
+        let exclusiveStartKey = cursorState?.lastEvaluatedKey;
+        do {
+          debug("%s page %s key=%o", this.mode, this.tableName, exclusiveStartKey ?? "(start)");
+          const response = await this.fetchPage(exclusiveStartKey);
+          for (const item of response.Items ?? []) {
+            yield item;
+          }
+          exclusiveStartKey = response.LastEvaluatedKey;
+          if (exclusiveStartKey) {
+            this._cursor = encodeCursor(exclusiveStartKey);
+          } else {
+            this._cursor = void 0;
+          }
+        } while (exclusiveStartKey);
+      }
+      async fetchPage(exclusiveStartKey) {
+        const command = this.mode === "query" ? this.buildQueryCommand(exclusiveStartKey) : this.buildScanCommand(exclusiveStartKey);
+        const doFetch = /* @__PURE__ */ __name(async () => {
+          try {
+            return await this.client.send(command);
+          } catch (error) {
+            throw new DatastoreError(`Failed to ${this.mode} table "${this.tableName}"`, this.tableName, {
+              cause: error
+            });
+          }
+        }, "doFetch");
+        if (!this.tracer) return doFetch();
+        return this.tracer.withSpan(`celerity.datastore.${this.mode}_page`, () => doFetch(), {
+          "datastore.table": this.tableName
         });
       }
-    }, "doFetch");
-    if (!this.tracer) return doFetch();
-    return this.tracer.withSpan(`celerity.datastore.${this.mode}_page`, () => doFetch(), {
-      "datastore.table": this.tableName
-    });
-  }
-  buildQueryCommand(exclusiveStartKey) {
-    const opts = this.options;
-    const keyExpr = buildKeyConditionExpression(opts.key, opts.range);
-    const filterExpr = opts.filter ? buildFilterExpression(opts.filter) : void 0;
-    return new import_lib_dynamodb.QueryCommand({
-      TableName: this.tableName,
-      IndexName: opts.indexName,
-      KeyConditionExpression: keyExpr.expression,
-      FilterExpression: filterExpr?.expression,
-      ExpressionAttributeNames: {
-        ...keyExpr.names,
-        ...filterExpr?.names
-      },
-      ExpressionAttributeValues: {
-        ...keyExpr.values,
-        ...filterExpr?.values
-      },
-      ScanIndexForward: opts.sortAscending,
-      Limit: opts.maxResults,
-      ExclusiveStartKey: exclusiveStartKey,
-      ConsistentRead: opts.consistentRead
-    });
-  }
-  buildScanCommand(exclusiveStartKey) {
-    const opts = this.options;
-    const filterExpr = opts.filter ? buildFilterExpression(opts.filter) : void 0;
-    return new import_lib_dynamodb.ScanCommand({
-      TableName: this.tableName,
-      IndexName: opts.indexName,
-      FilterExpression: filterExpr?.expression,
-      ExpressionAttributeNames: filterExpr?.names && Object.keys(filterExpr.names).length > 0 ? filterExpr.names : void 0,
-      ExpressionAttributeValues: filterExpr?.values && Object.keys(filterExpr.values).length > 0 ? filterExpr.values : void 0,
-      Limit: opts.maxResults,
-      ExclusiveStartKey: exclusiveStartKey,
-      ConsistentRead: opts.consistentRead
-    });
+      buildQueryCommand(exclusiveStartKey) {
+        const opts = this.options;
+        const keyExpr = buildKeyConditionExpression(opts.key, opts.range);
+        const filterExpr = opts.filter ? buildFilterExpression(opts.filter) : void 0;
+        return new import_lib_dynamodb.QueryCommand({
+          TableName: this.tableName,
+          IndexName: opts.indexName,
+          KeyConditionExpression: keyExpr.expression,
+          FilterExpression: filterExpr?.expression,
+          ExpressionAttributeNames: {
+            ...keyExpr.names,
+            ...filterExpr?.names
+          },
+          ExpressionAttributeValues: {
+            ...keyExpr.values,
+            ...filterExpr?.values
+          },
+          ScanIndexForward: opts.sortAscending,
+          Limit: opts.maxResults,
+          ExclusiveStartKey: exclusiveStartKey,
+          ConsistentRead: opts.consistentRead
+        });
+      }
+      buildScanCommand(exclusiveStartKey) {
+        const opts = this.options;
+        const filterExpr = opts.filter ? buildFilterExpression(opts.filter) : void 0;
+        return new import_lib_dynamodb.ScanCommand({
+          TableName: this.tableName,
+          IndexName: opts.indexName,
+          FilterExpression: filterExpr?.expression,
+          ExpressionAttributeNames: filterExpr?.names && Object.keys(filterExpr.names).length > 0 ? filterExpr.names : void 0,
+          ExpressionAttributeValues: filterExpr?.values && Object.keys(filterExpr.values).length > 0 ? filterExpr.values : void 0,
+          Limit: opts.maxResults,
+          ExclusiveStartKey: exclusiveStartKey,
+          ConsistentRead: opts.consistentRead
+        });
+      }
+    };
   }
-};
+});
 
 // src/providers/dynamodb/errors.ts
 function isConditionalCheckFailedError(error) {
   if (!(error instanceof Error)) return false;
   return error.name === "ConditionalCheckFailedException";
 }
-__name(isConditionalCheckFailedError, "isConditionalCheckFailedError");
+var init_errors2 = __esm({
+  "src/providers/dynamodb/errors.ts"() {
+    "use strict";
+    __name(isConditionalCheckFailedError, "isConditionalCheckFailedError");
+  }
+});
 
 // src/providers/dynamodb/dynamodb-datastore.ts
-var debug2 = (0, import_debug2.default)("celerity:datastore:dynamodb");
-var DynamoDBDatastore = class {
-  static {
-    __name(this, "DynamoDBDatastore");
-  }
-  tableName;
-  client;
-  tracer;
-  constructor(tableName, client, tracer) {
-    this.tableName = tableName;
-    this.client = client;
-    this.tracer = tracer;
-  }
-  async getItem(key, options) {
-    debug2("getItem %s %o", this.tableName, key);
-    return this.traced("celerity.datastore.get_item", {
-      "datastore.table": this.tableName
-    }, async () => {
-      try {
-        const response = await this.client.send(new import_lib_dynamodb2.GetCommand({
-          TableName: this.tableName,
-          Key: key,
-          ConsistentRead: options?.consistentRead
-        }));
-        return response.Item ?? null;
-      } catch (error) {
-        throw new DatastoreError(`Failed to get item from table "${this.tableName}"`, this.tableName, {
-          cause: error
-        });
+var import_debug2, import_lib_dynamodb2, debug2, DynamoDBDatastore;
+var init_dynamodb_datastore = __esm({
+  "src/providers/dynamodb/dynamodb-datastore.ts"() {
+    "use strict";
+    import_debug2 = __toESM(require("debug"), 1);
+    import_lib_dynamodb2 = require("@aws-sdk/lib-dynamodb");
+    init_errors();
+    init_dynamodb_item_listing();
+    init_expressions();
+    init_errors2();
+    debug2 = (0, import_debug2.default)("celerity:datastore:dynamodb");
+    DynamoDBDatastore = class {
+      static {
+        __name(this, "DynamoDBDatastore");
       }
-    });
-  }
-  async putItem(item, options) {
-    debug2("putItem %s", this.tableName);
-    return this.traced("celerity.datastore.put_item", {
-      "datastore.table": this.tableName
-    }, async () => {
-      try {
-        const conditionParams = options?.condition ? buildFilterExpression(options.condition) : void 0;
-        await this.client.send(new import_lib_dynamodb2.PutCommand({
-          TableName: this.tableName,
-          Item: item,
-          ConditionExpression: conditionParams?.expression,
-          ExpressionAttributeNames: conditionParams?.names,
-          ExpressionAttributeValues: conditionParams?.values
-        }));
-      } catch (error) {
-        if (isConditionalCheckFailedError(error)) {
-          throw new ConditionalCheckFailedError(this.tableName, {
-            cause: error
-          });
-        }
-        throw new DatastoreError(`Failed to put item in table "${this.tableName}"`, this.tableName, {
-          cause: error
+      tableName;
+      client;
+      tracer;
+      constructor(tableName, client, tracer) {
+        this.tableName = tableName;
+        this.client = client;
+        this.tracer = tracer;
+      }
+      async getItem(key, options) {
+        debug2("getItem %s %o", this.tableName, key);
+        return this.traced("celerity.datastore.get_item", {
+          "datastore.table": this.tableName
+        }, async () => {
+          try {
+            const response = await this.client.send(new import_lib_dynamodb2.GetCommand({
+              TableName: this.tableName,
+              Key: key,
+              ConsistentRead: options?.consistentRead
+            }));
+            return response.Item ?? null;
+          } catch (error) {
+            throw new DatastoreError(`Failed to get item from table "${this.tableName}"`, this.tableName, {
+              cause: error
+            });
+          }
         });
       }
-    });
-  }
-  async deleteItem(key, options) {
-    debug2("deleteItem %s %o", this.tableName, key);
-    return this.traced("celerity.datastore.delete_item", {
-      "datastore.table": this.tableName
-    }, async () => {
-      try {
-        const conditionParams = options?.condition ? buildFilterExpression(options.condition) : void 0;
-        await this.client.send(new import_lib_dynamodb2.DeleteCommand({
-          TableName: this.tableName,
-          Key: key,
-          ConditionExpression: conditionParams?.expression,
-          ExpressionAttributeNames: conditionParams?.names,
-          ExpressionAttributeValues: conditionParams?.values
-        }));
-      } catch (error) {
-        if (isConditionalCheckFailedError(error)) {
-          throw new ConditionalCheckFailedError(this.tableName, {
-            cause: error
-          });
-        }
-        throw new DatastoreError(`Failed to delete item from table "${this.tableName}"`, this.tableName, {
-          cause: error
+      async putItem(item, options) {
+        debug2("putItem %s", this.tableName);
+        return this.traced("celerity.datastore.put_item", {
+          "datastore.table": this.tableName
+        }, async () => {
+          try {
+            const conditionParams = options?.condition ? buildFilterExpression(options.condition) : void 0;
+            await this.client.send(new import_lib_dynamodb2.PutCommand({
+              TableName: this.tableName,
+              Item: item,
+              ConditionExpression: conditionParams?.expression,
+              ExpressionAttributeNames: conditionParams?.names,
+              ExpressionAttributeValues: conditionParams?.values
+            }));
+          } catch (error) {
+            if (isConditionalCheckFailedError(error)) {
+              throw new ConditionalCheckFailedError(this.tableName, {
+                cause: error
+              });
+            }
+            throw new DatastoreError(`Failed to put item in table "${this.tableName}"`, this.tableName, {
+              cause: error
+            });
+          }
         });
       }
-    });
-  }
-  query(options) {
-    debug2("query %s pk=%s", this.tableName, options.key.name);
-    return new DynamoDBItemListing(this.client, this.tableName, "query", options, this.tracer);
-  }
-  scan(options) {
-    debug2("scan %s", this.tableName);
-    return new DynamoDBItemListing(this.client, this.tableName, "scan", options ?? {}, this.tracer);
-  }
-  async batchGetItems(keys, options) {
-    debug2("batchGetItems %s count=%d", this.tableName, keys.length);
-    return this.traced("celerity.datastore.batch_get_items", {
-      "datastore.table": this.tableName,
-      "datastore.batch_size": keys.length
-    }, async () => {
-      try {
-        const response = await this.client.send(new import_lib_dynamodb2.BatchGetCommand({
-          RequestItems: {
-            [this.tableName]: {
-              Keys: keys,
-              ConsistentRead: options?.consistentRead
+      async deleteItem(key, options) {
+        debug2("deleteItem %s %o", this.tableName, key);
+        return this.traced("celerity.datastore.delete_item", {
+          "datastore.table": this.tableName
+        }, async () => {
+          try {
+            const conditionParams = options?.condition ? buildFilterExpression(options.condition) : void 0;
+            await this.client.send(new import_lib_dynamodb2.DeleteCommand({
+              TableName: this.tableName,
+              Key: key,
+              ConditionExpression: conditionParams?.expression,
+              ExpressionAttributeNames: conditionParams?.names,
+              ExpressionAttributeValues: conditionParams?.values
+            }));
+          } catch (error) {
+            if (isConditionalCheckFailedError(error)) {
+              throw new ConditionalCheckFailedError(this.tableName, {
+                cause: error
+              });
             }
+            throw new DatastoreError(`Failed to delete item from table "${this.tableName}"`, this.tableName, {
+              cause: error
+            });
           }
-        }));
-        const items = response.Responses?.[this.tableName] ?? [];
-        const unprocessedKeys = response.UnprocessedKeys?.[this.tableName]?.Keys ?? [];
-        return {
-          items,
-          unprocessedKeys
-        };
-      } catch (error) {
-        throw new DatastoreError(`Failed to batch get items from table "${this.tableName}"`, this.tableName, {
-          cause: error
         });
       }
-    });
-  }
-  async batchWriteItems(operations) {
-    debug2("batchWriteItems %s count=%d", this.tableName, operations.length);
-    return this.traced("celerity.datastore.batch_write_items", {
-      "datastore.table": this.tableName,
-      "datastore.batch_size": operations.length
-    }, async () => {
-      try {
-        const writeRequests = operations.map((op) => {
-          if (op.type === "put") {
-            return {
-              PutRequest: {
-                Item: op.item
+      query(options) {
+        debug2("query %s pk=%s", this.tableName, options.key.name);
+        return new DynamoDBItemListing(this.client, this.tableName, "query", options, this.tracer);
+      }
+      scan(options) {
+        debug2("scan %s", this.tableName);
+        return new DynamoDBItemListing(this.client, this.tableName, "scan", options ?? {}, this.tracer);
+      }
+      async batchGetItems(keys, options) {
+        debug2("batchGetItems %s count=%d", this.tableName, keys.length);
+        return this.traced("celerity.datastore.batch_get_items", {
+          "datastore.table": this.tableName,
+          "datastore.batch_size": keys.length
+        }, async () => {
+          try {
+            const response = await this.client.send(new import_lib_dynamodb2.BatchGetCommand({
+              RequestItems: {
+                [this.tableName]: {
+                  Keys: keys,
+                  ConsistentRead: options?.consistentRead
+                }
               }
+            }));
+            const items = response.Responses?.[this.tableName] ?? [];
+            const unprocessedKeys = response.UnprocessedKeys?.[this.tableName]?.Keys ?? [];
+            return {
+              items,
+              unprocessedKeys
             };
+          } catch (error) {
+            throw new DatastoreError(`Failed to batch get items from table "${this.tableName}"`, this.tableName, {
+              cause: error
+            });
           }
-          return {
-            DeleteRequest: {
-              Key: op.key
-            }
-          };
         });
-        const response = await this.client.send(new import_lib_dynamodb2.BatchWriteCommand({
-          RequestItems: {
-            [this.tableName]: writeRequests
-          }
-        }));
-        const unprocessedRequests = response.UnprocessedItems?.[this.tableName] ?? [];
-        const unprocessedOperations = unprocessedRequests.map((req) => {
-          if (req.PutRequest) {
+      }
+      async batchWriteItems(operations) {
+        debug2("batchWriteItems %s count=%d", this.tableName, operations.length);
+        return this.traced("celerity.datastore.batch_write_items", {
+          "datastore.table": this.tableName,
+          "datastore.batch_size": operations.length
+        }, async () => {
+          try {
+            const writeRequests = operations.map((op) => {
+              if (op.type === "put") {
+                return {
+                  PutRequest: {
+                    Item: op.item
+                  }
+                };
+              }
+              return {
+                DeleteRequest: {
+                  Key: op.key
+                }
+              };
+            });
+            const response = await this.client.send(new import_lib_dynamodb2.BatchWriteCommand({
+              RequestItems: {
+                [this.tableName]: writeRequests
+              }
+            }));
+            const unprocessedRequests = response.UnprocessedItems?.[this.tableName] ?? [];
+            const unprocessedOperations = unprocessedRequests.map((req) => {
+              if (req.PutRequest) {
+                return {
+                  type: "put",
+                  item: req.PutRequest.Item
+                };
+              }
+              return {
+                type: "delete",
+                key: req.DeleteRequest.Key
+              };
+            });
             return {
-              type: "put",
-              item: req.PutRequest.Item
+              unprocessedOperations
             };
+          } catch (error) {
+            throw new DatastoreError(`Failed to batch write items to table "${this.tableName}"`, this.tableName, {
+              cause: error
+            });
           }
-          return {
-            type: "delete",
-            key: req.DeleteRequest.Key
-          };
-        });
-        return {
-          unprocessedOperations
-        };
-      } catch (error) {
-        throw new DatastoreError(`Failed to batch write items to table "${this.tableName}"`, this.tableName, {
-          cause: error
         });
       }
-    });
-  }
-  traced(name, attributes, fn) {
-    if (!this.tracer) return fn();
-    return this.tracer.withSpan(name, (span) => fn(span), attributes);
+      traced(name, attributes, fn) {
+        if (!this.tracer) return fn();
+        return this.tracer.withSpan(name, (span) => fn(span), attributes);
+      }
+    };
   }
-};
+});
 
 // src/providers/dynamodb/config.ts
+var config_exports = {};
+__export(config_exports, {
+  captureDynamoDBConfig: () => captureDynamoDBConfig
+});
 function captureDynamoDBConfig() {
   return {
     region: process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION,
-    endpoint: process.env.AWS_ENDPOINT_URL,
+    endpoint: process.env.CELERITY_AWS_DYNAMODB_ENDPOINT ?? process.env.AWS_ENDPOINT_URL,
     credentials: process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY ? {
       accessKeyId: process.env.AWS_ACCESS_KEY_ID,
       secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
     } : void 0
   };
 }
-__name(captureDynamoDBConfig, "captureDynamoDBConfig");
+var init_config = __esm({
+  "src/providers/dynamodb/config.ts"() {
+    "use strict";
+    __name(captureDynamoDBConfig, "captureDynamoDBConfig");
+  }
+});
 
 // src/providers/dynamodb/dynamodb-datastore-client.ts
-var DynamoDBDatastoreClient = class {
-  static {
-    __name(this, "DynamoDBDatastoreClient");
-  }
-  tracer;
-  client = null;
-  docClient = null;
-  config;
-  constructor(config, tracer) {
-    this.tracer = tracer;
-    this.config = config ?? captureDynamoDBConfig();
-  }
-  datastore(name) {
-    return new DynamoDBDatastore(name, this.getDocClient(), this.tracer);
-  }
-  close() {
-    this.docClient?.destroy();
-    this.client?.destroy();
-    this.docClient = null;
-    this.client = null;
-  }
-  getDocClient() {
-    if (!this.docClient) {
-      this.client = new import_client_dynamodb.DynamoDBClient({
-        region: this.config.region,
-        endpoint: this.config.endpoint,
-        credentials: this.config.credentials
-      });
-      this.docClient = import_lib_dynamodb3.DynamoDBDocumentClient.from(this.client, {
-        marshallOptions: {
-          removeUndefinedValues: true
+var dynamodb_datastore_client_exports = {};
+__export(dynamodb_datastore_client_exports, {
+  DynamoDBDatastoreClient: () => DynamoDBDatastoreClient
+});
+var import_client_dynamodb, import_lib_dynamodb3, DynamoDBDatastoreClient;
+var init_dynamodb_datastore_client = __esm({
+  "src/providers/dynamodb/dynamodb-datastore-client.ts"() {
+    "use strict";
+    import_client_dynamodb = require("@aws-sdk/client-dynamodb");
+    import_lib_dynamodb3 = require("@aws-sdk/lib-dynamodb");
+    init_dynamodb_datastore();
+    init_config();
+    DynamoDBDatastoreClient = class {
+      static {
+        __name(this, "DynamoDBDatastoreClient");
+      }
+      tracer;
+      client = null;
+      docClient = null;
+      config;
+      constructor(config, tracer) {
+        this.tracer = tracer;
+        this.config = config ?? captureDynamoDBConfig();
+      }
+      datastore(name) {
+        return new DynamoDBDatastore(name, this.getDocClient(), this.tracer);
+      }
+      close() {
+        this.docClient?.destroy();
+        this.client?.destroy();
+        this.docClient = null;
+        this.client = null;
+      }
+      getDocClient() {
+        if (!this.docClient) {
+          this.client = new import_client_dynamodb.DynamoDBClient({
+            region: this.config.region,
+            endpoint: this.config.endpoint,
+            credentials: this.config.credentials
+          });
+          this.docClient = import_lib_dynamodb3.DynamoDBDocumentClient.from(this.client, {
+            marshallOptions: {
+              removeUndefinedValues: true
+            }
+          });
         }
-      });
-    }
-    return this.docClient;
+        return this.docClient;
+      }
+    };
   }
-};
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConditionalCheckFailedError: () => ConditionalCheckFailedError,
+  DEFAULT_DATASTORE_TOKEN: () => DEFAULT_DATASTORE_TOKEN,
+  Datastore: () => Datastore,
+  DatastoreClient: () => DatastoreClient,
+  DatastoreError: () => DatastoreError,
+  DatastoreLayer: () => DatastoreLayer,
+  createDatastoreClient: () => createDatastoreClient,
+  datastoreToken: () => datastoreToken,
+  getDatastore: () => getDatastore
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var DatastoreClient = /* @__PURE__ */ Symbol.for("DatastoreClient");
 
 // src/factory.ts
 var import_config2 = require("@celerity-sdk/config");
-function createDatastoreClient(options) {
+async function createDatastoreClient(options) {
   const resolved = (0, import_config2.resolveConfig)("datastore");
   const provider = options?.provider ?? resolved.provider;
   switch (provider) {
-    case "aws":
-      return new DynamoDBDatastoreClient(options?.aws, options?.tracer);
+    case "aws": {
+      const { DynamoDBDatastoreClient: DynamoDBDatastoreClient2 } = await Promise.resolve().then(() => (init_dynamodb_datastore_client(), dynamodb_datastore_client_exports));
+      return new DynamoDBDatastoreClient2(options?.aws, options?.tracer);
+    }
     case "local":
       return createLocalClient(options);
     default:
@@ -545,17 +599,19 @@ function createDatastoreClient(options) {
   }
 }
 __name(createDatastoreClient, "createDatastoreClient");
-function createLocalClient(options) {
+async function createLocalClient(options) {
   const deployTarget = options?.deployTarget?.toLowerCase();
   switch (deployTarget) {
     case "aws":
     case "aws-serverless":
     case void 0: {
+      const { captureDynamoDBConfig: captureDynamoDBConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+      const { DynamoDBDatastoreClient: DynamoDBDatastoreClient2 } = await Promise.resolve().then(() => (init_dynamodb_datastore_client(), dynamodb_datastore_client_exports));
       const localConfig = {
-        ...captureDynamoDBConfig(),
+        ...captureDynamoDBConfig2(),
         ...options?.aws
       };
-      return new DynamoDBDatastoreClient(localConfig, options?.tracer);
+      return new DynamoDBDatastoreClient2(localConfig, options?.tracer);
     }
     // case "gcloud":
     // case "gcloud-serverless":
@@ -606,7 +662,7 @@ __name(getDatastore, "getDatastore");
 // src/layer.ts
 var import_debug3 = __toESM(require("debug"), 1);
 var import_common2 = require("@celerity-sdk/common");
-var import_config4 = require("@celerity-sdk/config");
+var import_config3 = require("@celerity-sdk/config");
 var debug3 = (0, import_debug3.default)("celerity:datastore");
 function captureDatastoreLayerConfig() {
   return {
@@ -624,7 +680,7 @@ var DatastoreLayer = class {
     if (!this.initialized) {
       this.config = captureDatastoreLayerConfig();
       const tracer = context.container.has(import_common2.TRACER_TOKEN) ? await context.container.resolve(import_common2.TRACER_TOKEN) : void 0;
-      const client = createDatastoreClient({
+      const client = await createDatastoreClient({
         tracer,
         deployTarget: this.config.deployTarget
       });
@@ -632,11 +688,11 @@ var DatastoreLayer = class {
       context.container.register("DatastoreClient", {
         useValue: client
       });
-      const links = (0, import_config4.captureResourceLinks)();
-      const datastoreLinks = (0, import_config4.getLinksOfType)(links, "datastore");
+      const links = (0, import_config3.captureResourceLinks)();
+      const datastoreLinks = (0, import_config3.getLinksOfType)(links, "datastore");
       if (datastoreLinks.size > 0) {
         const configService = await context.container.resolve(import_common2.CONFIG_SERVICE_TOKEN);
-        const resourceConfig = configService.namespace(import_config4.RESOURCE_CONFIG_NAMESPACE);
+        const resourceConfig = configService.namespace(import_config3.RESOURCE_CONFIG_NAMESPACE);
         for (const [resourceName, configKey] of datastoreLinks) {
           const actualName = await resourceConfig.getOrThrow(configKey);
           debug3("registered datastore resource %s \u2192 %s", resourceName, actualName);
@@ -660,6 +716,9 @@ var DatastoreLayer = class {
     return next();
   }
 };
+
+// src/index.ts
+init_errors();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ConditionalCheckFailedError,
@@ -668,7 +727,6 @@ var DatastoreLayer = class {
   DatastoreClient,
   DatastoreError,
   DatastoreLayer,
-  DynamoDBDatastoreClient,
   createDatastoreClient,
   datastoreToken,
   getDatastore