@celerity-sdk/datastore 0.3.1 → 0.5.0

package/dist/index.cjs

@@ -1,8 +1,18 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 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 });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -11,9 +21,714 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/errors.ts
+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/expressions.ts
+function buildKeyConditionExpression(key, range) {
+  const names = {};
+  const values = {};
+  let counter = 0;
+  const pkName = `#k${counter}`;
+  const pkValue = `:k${counter}`;
+  names[pkName] = key.name;
+  values[pkValue] = key.value;
+  counter++;
+  let expression = `${pkName} = ${pkValue}`;
+  if (range) {
+    const skName = `#k${counter}`;
+    names[skName] = range.name;
+    switch (range.operator) {
+      case "eq":
+      case "lt":
+      case "le":
+      case "gt":
+      case "ge": {
+        const skValue = `:k${counter}`;
+        values[skValue] = range.value;
+        expression += ` AND ${skName} ${COMPARISON_OPERATORS[range.operator]} ${skValue}`;
+        break;
+      }
+      case "between": {
+        const lowVal = `:k${counter}a`;
+        const highVal = `:k${counter}b`;
+        values[lowVal] = range.low;
+        values[highVal] = range.high;
+        expression += ` AND ${skName} BETWEEN ${lowVal} AND ${highVal}`;
+        break;
+      }
+      case "startsWith": {
+        const skValue = `:k${counter}`;
+        values[skValue] = range.value;
+        expression += ` AND begins_with(${skName}, ${skValue})`;
+        break;
+      }
+    }
+  }
+  return {
+    expression,
+    names,
+    values
+  };
+}
+function buildFilterExpression(conditions) {
+  const condArray = Array.isArray(conditions) ? conditions : [
+    conditions
+  ];
+  const names = {};
+  const values = {};
+  const parts = [];
+  let counter = 0;
+  for (const cond of condArray) {
+    const attrName = `#f${counter}`;
+    names[attrName] = cond.name;
+    switch (cond.operator) {
+      case "eq":
+      case "ne":
+      case "lt":
+      case "le":
+      case "gt":
+      case "ge": {
+        const valKey = `:f${counter}`;
+        values[valKey] = cond.value;
+        parts.push(`${attrName} ${COMPARISON_OPERATORS[cond.operator]} ${valKey}`);
+        break;
+      }
+      case "between": {
+        const lowVal = `:f${counter}a`;
+        const highVal = `:f${counter}b`;
+        values[lowVal] = cond.low;
+        values[highVal] = cond.high;
+        parts.push(`${attrName} BETWEEN ${lowVal} AND ${highVal}`);
+        break;
+      }
+      case "startsWith":
+      case "contains": {
+        const valKey = `:f${counter}`;
+        values[valKey] = cond.value;
+        const fnName = cond.operator === "startsWith" ? "begins_with" : "contains";
+        parts.push(`${fnName}(${attrName}, ${valKey})`);
+        break;
+      }
+      case "exists":
+        parts.push(`attribute_exists(${attrName})`);
+        break;
+    }
+    counter++;
+  }
+  return {
+    expression: parts.join(" AND "),
+    names,
+    values
+  };
+}
+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
+function encodeCursor(lastEvaluatedKey) {
+  const state = {
+    lastEvaluatedKey
+  };
+  return Buffer.from(JSON.stringify(state)).toString("base64url");
+}
+function decodeCursor(cursor) {
+  return JSON.parse(Buffer.from(cursor, "base64url").toString("utf-8"));
+}
+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
+        });
+      }
+      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";
+}
+var init_errors2 = __esm({
+  "src/providers/dynamodb/errors.ts"() {
+    "use strict";
+    __name(isConditionalCheckFailedError, "isConditionalCheckFailedError");
+  }
+});
+
+// src/providers/dynamodb/dynamodb-datastore.ts
+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");
+      }
+      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 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
+            });
+          }
+        });
+      }
+      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
+            });
+          }
+        });
+      }
+      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
+            });
+          }
+        });
+      }
+      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 {
+              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);
+      }
+    };
+  }
+});
+
+// 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.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
+  };
+}
+var init_config = __esm({
+  "src/providers/dynamodb/config.ts"() {
+    "use strict";
+    __name(captureDynamoDBConfig, "captureDynamoDBConfig");
+  }
+});
+
+// src/providers/dynamodb/dynamodb-datastore-client.ts
+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;
+      }
+    };
+  }
+});
+
 // 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");
+async function createDatastoreClient(options) {
+  const resolved = (0, import_config2.resolveConfig)("datastore");
+  const provider = options?.provider ?? resolved.provider;
+  switch (provider) {
+    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:
+      throw new Error(`Unsupported datastore provider: "${provider}"`);
+  }
+}
+__name(createDatastoreClient, "createDatastoreClient");
+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 = {
+        ...captureDynamoDBConfig2(),
+        ...options?.aws
+      };
+      return new DynamoDBDatastoreClient2(localConfig, options?.tracer);
+    }
+    // case "gcloud":
+    // case "gcloud-serverless":
+    //   v1: Firestore emulator
+    // case "azure":
+    // case "azure-serverless":
+    //   v1: Cosmos DB emulator
+    default:
+      throw new Error(`Unsupported local datastore deploy target: "${deployTarget}". Only AWS is supported in v0.`);
+  }
+}
+__name(createLocalClient, "createLocalClient");
+
+// src/decorators.ts
+var import_reflect_metadata = require("reflect-metadata");
+var import_common = require("@celerity-sdk/common");
+function datastoreToken(resourceName) {
+  return /* @__PURE__ */ Symbol.for(`celerity:datastore:${resourceName}`);
+}
+__name(datastoreToken, "datastoreToken");
+var DEFAULT_DATASTORE_TOKEN = /* @__PURE__ */ Symbol.for("celerity:datastore:default");
+function Datastore(resourceName) {
+  return (target, _propertyKey, parameterIndex) => {
+    const token = resourceName ? datastoreToken(resourceName) : DEFAULT_DATASTORE_TOKEN;
+    const existing = Reflect.getOwnMetadata(import_common.INJECT_METADATA, target) ?? /* @__PURE__ */ new Map();
+    existing.set(parameterIndex, token);
+    Reflect.defineMetadata(import_common.INJECT_METADATA, existing, target);
+    if (resourceName) {
+      const resources = Reflect.getOwnMetadata(import_common.USE_RESOURCE_METADATA, target) ?? [];
+      if (!resources.includes(resourceName)) {
+        Reflect.defineMetadata(import_common.USE_RESOURCE_METADATA, [
+          ...resources,
+          resourceName
+        ], target);
+      }
+    }
+  };
+}
+__name(Datastore, "Datastore");
+
+// src/helpers.ts
+function getDatastore(container, resourceName) {
+  const token = resourceName ? datastoreToken(resourceName) : DEFAULT_DATASTORE_TOKEN;
+  return container.resolve(token);
+}
+__name(getDatastore, "getDatastore");
+
+// src/layer.ts
+var import_debug3 = __toESM(require("debug"), 1);
+var import_common2 = require("@celerity-sdk/common");
+var import_config3 = require("@celerity-sdk/config");
+var debug3 = (0, import_debug3.default)("celerity:datastore");
+function captureDatastoreLayerConfig() {
+  return {
+    deployTarget: process.env.CELERITY_DEPLOY_TARGET
+  };
+}
+__name(captureDatastoreLayerConfig, "captureDatastoreLayerConfig");
+var DatastoreLayer = class {
+  static {
+    __name(this, "DatastoreLayer");
+  }
+  initialized = false;
+  config = null;
+  async handle(context, next) {
+    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 = await createDatastoreClient({
+        tracer,
+        deployTarget: this.config.deployTarget
+      });
+      debug3("registering DatastoreClient");
+      context.container.register("DatastoreClient", {
+        useValue: client
+      });
+      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_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);
+          context.container.register(datastoreToken(resourceName), {
+            useValue: client.datastore(actualName)
+          });
+        }
+        if (datastoreLinks.size === 1) {
+          const [, configKey] = [
+            ...datastoreLinks.entries()
+          ][0];
+          const actualName = await resourceConfig.getOrThrow(configKey);
+          debug3("registered default datastore \u2192 %s", actualName);
+          context.container.register(DEFAULT_DATASTORE_TOKEN, {
+            useValue: client.datastore(actualName)
+          });
+        }
+      }
+      this.initialized = true;
+    }
+    return next();
+  }
+};
+
+// src/index.ts
+init_errors();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConditionalCheckFailedError,
+  DEFAULT_DATASTORE_TOKEN,
+  Datastore,
+  DatastoreClient,
+  DatastoreError,
+  DatastoreLayer,
+  createDatastoreClient,
+  datastoreToken,
+  getDatastore
+});
 //# sourceMappingURL=index.cjs.map