@celerity-sdk/sql-database 0.3.0 → 0.4.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,633 @@ 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/rds-token-provider.ts
+var rds_token_provider_exports = {};
+__export(rds_token_provider_exports, {
+  RdsTokenProvider: () => RdsTokenProvider,
+  createRdsTokenProviderFactory: () => createRdsTokenProviderFactory
+});
+function createRdsTokenProviderFactory(region) {
+  return (hostname, port, username) => new RdsTokenProvider(hostname, port, username, region);
+}
+var TOKEN_CACHE_MS, RdsTokenProvider;
+var init_rds_token_provider = __esm({
+  "src/rds-token-provider.ts"() {
+    "use strict";
+    TOKEN_CACHE_MS = 14 * 60 * 1e3;
+    RdsTokenProvider = class {
+      static {
+        __name(this, "RdsTokenProvider");
+      }
+      hostname;
+      port;
+      username;
+      region;
+      cached = null;
+      constructor(hostname, port, username, region) {
+        this.hostname = hostname;
+        this.port = port;
+        this.username = username;
+        this.region = region;
+      }
+      async getToken() {
+        const now = Date.now();
+        if (this.cached && now < this.cached.expiresAt) return this.cached.token;
+        const pkg = "@aws-sdk/rds-signer";
+        const { Signer } = await import(pkg);
+        const signer = new Signer({
+          hostname: this.hostname,
+          port: this.port,
+          username: this.username,
+          region: this.region
+        });
+        const token = await signer.getAuthToken();
+        this.cached = {
+          token,
+          expiresAt: now + TOKEN_CACHE_MS
+        };
+        return token;
+      }
+    };
+    __name(createRdsTokenProviderFactory, "createRdsTokenProviderFactory");
+  }
+});
+
 // src/index.ts
 var index_exports = {};
+__export(index_exports, {
+  DEFAULT_SQL_CREDENTIALS_TOKEN: () => DEFAULT_SQL_CREDENTIALS_TOKEN,
+  DEFAULT_SQL_DATABASE_INSTANCE_TOKEN: () => DEFAULT_SQL_DATABASE_INSTANCE_TOKEN,
+  DEFAULT_SQL_READER_TOKEN: () => DEFAULT_SQL_READER_TOKEN,
+  DEFAULT_SQL_WRITER_TOKEN: () => DEFAULT_SQL_WRITER_TOKEN,
+  POOL_PRESETS: () => POOL_PRESETS,
+  RdsTokenProvider: () => RdsTokenProvider,
+  SqlCredentials: () => SqlCredentials,
+  SqlDatabase: () => SqlDatabase,
+  SqlDatabaseError: () => SqlDatabaseError,
+  SqlDatabaseInstance: () => SqlDatabaseInstance,
+  SqlDatabaseLayer: () => SqlDatabaseLayer,
+  SqlReader: () => SqlReader,
+  SqlWriter: () => SqlWriter,
+  buildConnectionUrl: () => buildConnectionUrl,
+  captureSqlDatabaseLayerConfig: () => captureSqlDatabaseLayerConfig,
+  createKnexInstance: () => createKnexInstance,
+  createRdsTokenProviderFactory: () => createRdsTokenProviderFactory,
+  getSqlCredentials: () => getSqlCredentials,
+  getSqlReader: () => getSqlReader,
+  getSqlWriter: () => getSqlWriter,
+  resolveDatabaseCredentials: () => resolveDatabaseCredentials,
+  resolvePoolConfig: () => resolvePoolConfig,
+  resolvePoolOverrides: () => resolvePoolOverrides,
+  sqlDatabaseCredentialsToken: () => sqlDatabaseCredentialsToken,
+  sqlDatabaseInstanceToken: () => sqlDatabaseInstanceToken,
+  sqlReaderToken: () => sqlReaderToken,
+  sqlWriterToken: () => sqlWriterToken
+});
 module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var SqlDatabaseError = class extends Error {
+  static {
+    __name(this, "SqlDatabaseError");
+  }
+  database;
+  constructor(message, database, options) {
+    super(message, options), this.database = database;
+    this.name = "SqlDatabaseError";
+  }
+};
+
+// src/config.ts
+var import_config = require("@celerity-sdk/config");
+function captureSqlDatabaseLayerConfig() {
+  return {
+    deployTarget: process.env.CELERITY_RUNTIME ? "runtime" : "functions",
+    platform: import_config.CelerityConfig.getPlatform()
+  };
+}
+__name(captureSqlDatabaseLayerConfig, "captureSqlDatabaseLayerConfig");
+async function resolveTokenProviderFactory(platform) {
+  if (platform !== "aws") return void 0;
+  const mod = await Promise.resolve().then(() => (init_rds_token_provider(), rds_token_provider_exports));
+  return mod.createRdsTokenProviderFactory();
+}
+__name(resolveTokenProviderFactory, "resolveTokenProviderFactory");
+var FUNCTIONS_POOL = {
+  min: 0,
+  max: 2,
+  idleTimeoutMillis: 1e3,
+  acquireTimeoutMillis: 1e4,
+  createTimeoutMillis: 1e4,
+  reapIntervalMillis: 500
+};
+var RUNTIME_POOL = {
+  min: 2,
+  max: 10,
+  idleTimeoutMillis: 3e4,
+  acquireTimeoutMillis: 1e4,
+  createTimeoutMillis: 1e4,
+  reapIntervalMillis: 1e3
+};
+var POOL_PRESETS = {
+  functions: FUNCTIONS_POOL,
+  runtime: RUNTIME_POOL
+};
+var POOL_CONFIG_KEYS = [
+  [
+    "poolMin",
+    "min"
+  ],
+  [
+    "poolMax",
+    "max"
+  ],
+  [
+    "poolIdleTimeoutMs",
+    "idleTimeoutMillis"
+  ],
+  [
+    "poolAcquireTimeoutMs",
+    "acquireTimeoutMillis"
+  ],
+  [
+    "poolCreateTimeoutMs",
+    "createTimeoutMillis"
+  ],
+  [
+    "poolReapIntervalMs",
+    "reapIntervalMillis"
+  ]
+];
+async function resolvePoolOverrides(configKey, resourceConfig) {
+  const overrides = {};
+  for (const [suffix, field] of POOL_CONFIG_KEYS) {
+    const value = await resourceConfig.get(`${configKey}_${suffix}`);
+    if (value !== void 0) {
+      overrides[field] = Number.parseInt(value, 10);
+    }
+  }
+  return overrides;
+}
+__name(resolvePoolOverrides, "resolvePoolOverrides");
+function resolvePoolConfig(deployTarget, configOverrides, programmaticOverrides) {
+  return {
+    ...POOL_PRESETS[deployTarget],
+    ...configOverrides,
+    ...programmaticOverrides
+  };
+}
+__name(resolvePoolConfig, "resolvePoolConfig");
+
+// src/credentials.ts
+var DEFAULT_PORTS = {
+  postgres: 5432,
+  mysql: 3306
+};
+function buildConnectionUrl(params) {
+  const { engine, user, password, host, port, database, ssl } = params;
+  const encodedPassword = encodeURIComponent(password);
+  const protocol = engine === "postgres" ? "postgresql" : "mysql";
+  const sslParam = ssl ? engine === "postgres" ? "?sslmode=require" : "?ssl=true" : "";
+  return `${protocol}://${user}:${encodedPassword}@${host}:${port}/${database}${sslParam}`;
+}
+__name(buildConnectionUrl, "buildConnectionUrl");
+async function resolveDatabaseCredentials(configKey, resourceConfig, tokenProviderFactory) {
+  const host = await resourceConfig.get(`${configKey}_host`);
+  if (!host) {
+    throw new SqlDatabaseError(`Missing required config key "${configKey}_host"`, configKey);
+  }
+  const user = await resourceConfig.get(`${configKey}_user`);
+  if (!user) {
+    throw new SqlDatabaseError(`Missing required config key "${configKey}_user"`, configKey);
+  }
+  const engineRaw = await resourceConfig.get(`${configKey}_engine`);
+  const engine = engineRaw === "mysql" ? "mysql" : "postgres";
+  const portRaw = await resourceConfig.get(`${configKey}_port`);
+  const port = portRaw ? Number.parseInt(portRaw, 10) : DEFAULT_PORTS[engine];
+  const databaseName = await resourceConfig.get(`${configKey}_database`) ?? configKey;
+  const authModeRaw = await resourceConfig.get(`${configKey}_authMode`);
+  const authMode = authModeRaw === "iam" ? "iam" : "password";
+  const sslRaw = await resourceConfig.get(`${configKey}_ssl`);
+  const ssl = authMode === "iam" ? true : sslRaw !== "false";
+  const readHost = await resourceConfig.get(`${configKey}_readHost`);
+  const connectionInfo = {
+    host,
+    port,
+    database: databaseName,
+    user,
+    engine,
+    ssl,
+    authMode,
+    ...readHost ? {
+      readHost
+    } : {}
+  };
+  if (authMode === "password") {
+    const password = await resourceConfig.get(`${configKey}_password`);
+    if (!password) {
+      throw new SqlDatabaseError(`Missing required config key "${configKey}_password" for password auth`, configKey);
+    }
+    return new PasswordCredentials(connectionInfo, password);
+  }
+  if (!tokenProviderFactory) {
+    throw new SqlDatabaseError(`IAM auth requires a tokenProviderFactory for config key "${configKey}"`, configKey);
+  }
+  return new IamCredentials(connectionInfo, tokenProviderFactory);
+}
+__name(resolveDatabaseCredentials, "resolveDatabaseCredentials");
+var PasswordCredentials = class PasswordCredentials2 {
+  static {
+    __name(this, "PasswordCredentials");
+  }
+  info;
+  password;
+  constructor(info, password) {
+    this.info = info;
+    this.password = password;
+  }
+  async getConnectionInfo() {
+    return this.info;
+  }
+  async getPasswordAuth() {
+    const { engine, user, host, port, database, ssl } = this.info;
+    const url = buildConnectionUrl({
+      engine,
+      user,
+      password: this.password,
+      host,
+      port,
+      database,
+      ssl
+    });
+    const readUrl = this.info.readHost ? buildConnectionUrl({
+      engine,
+      user,
+      password: this.password,
+      host: this.info.readHost,
+      port,
+      database,
+      ssl
+    }) : void 0;
+    return {
+      password: this.password,
+      url,
+      ...readUrl ? {
+        readUrl
+      } : {}
+    };
+  }
+  async getIamAuth() {
+    throw new SqlDatabaseError('Cannot call getIamAuth() when authMode is "password"', this.info.database);
+  }
+};
+var IamCredentials = class IamCredentials2 {
+  static {
+    __name(this, "IamCredentials");
+  }
+  info;
+  factory;
+  tokenProvider = null;
+  readTokenProvider = null;
+  constructor(info, factory) {
+    this.info = info;
+    this.factory = factory;
+  }
+  async getConnectionInfo() {
+    return this.info;
+  }
+  async getPasswordAuth() {
+    throw new SqlDatabaseError('Cannot call getPasswordAuth() when authMode is "iam"', this.info.database);
+  }
+  async getIamAuth() {
+    const provider = this.getOrCreateTokenProvider();
+    const token = await provider.getToken();
+    const { engine, user, host, port, database, ssl } = this.info;
+    const url = buildConnectionUrl({
+      engine,
+      user,
+      password: token,
+      host,
+      port,
+      database,
+      ssl
+    });
+    let readUrl;
+    if (this.info.readHost) {
+      const readProvider = this.getOrCreateReadTokenProvider();
+      const readToken = await readProvider.getToken();
+      readUrl = buildConnectionUrl({
+        engine,
+        user,
+        password: readToken,
+        host: this.info.readHost,
+        port,
+        database,
+        ssl
+      });
+    }
+    return {
+      token,
+      url,
+      ...readUrl ? {
+        readUrl
+      } : {}
+    };
+  }
+  getOrCreateTokenProvider() {
+    if (!this.tokenProvider) {
+      this.tokenProvider = this.factory(this.info.host, this.info.port, this.info.user);
+    }
+    return this.tokenProvider;
+  }
+  getOrCreateReadTokenProvider() {
+    if (!this.readTokenProvider) {
+      this.readTokenProvider = this.factory(this.info.readHost, this.info.port, this.info.user);
+    }
+    return this.readTokenProvider;
+  }
+};
+
+// src/index.ts
+init_rds_token_provider();
+
+// src/factory.ts
+var ENGINE_CLIENT = {
+  postgres: "pg",
+  mysql: "mysql2"
+};
+async function createKnexInstance(options) {
+  const { credentials, deployTarget, pool: poolOverrides, useReadHost } = options;
+  const pkg = "knex";
+  const { default: createKnex } = await import(pkg);
+  const info = await credentials.getConnectionInfo();
+  const client = ENGINE_CLIENT[info.engine];
+  if (!client) {
+    throw new Error(`Unsupported SQL engine: "${info.engine}"`);
+  }
+  const poolConfig = resolvePoolConfig(deployTarget, poolOverrides);
+  const host = useReadHost && info.readHost ? info.readHost : info.host;
+  const sslConfig = info.ssl ? {
+    rejectUnauthorized: true
+  } : false;
+  const knexPool = {
+    min: poolConfig.min,
+    max: poolConfig.max,
+    idleTimeoutMillis: poolConfig.idleTimeoutMillis,
+    acquireTimeoutMillis: poolConfig.acquireTimeoutMillis,
+    createTimeoutMillis: poolConfig.createTimeoutMillis,
+    reapIntervalMillis: poolConfig.reapIntervalMillis
+  };
+  if (info.authMode === "iam") {
+    return createKnex({
+      client,
+      connection: /* @__PURE__ */ __name(async () => {
+        const auth2 = await credentials.getIamAuth();
+        return {
+          host,
+          port: info.port,
+          user: info.user,
+          database: info.database,
+          password: auth2.token,
+          ssl: sslConfig
+        };
+      }, "connection"),
+      pool: knexPool
+    });
+  }
+  const auth = await credentials.getPasswordAuth();
+  return createKnex({
+    client,
+    connection: {
+      host,
+      port: info.port,
+      user: info.user,
+      database: info.database,
+      password: auth.password,
+      ssl: sslConfig
+    },
+    pool: knexPool
+  });
+}
+__name(createKnexInstance, "createKnexInstance");
+
+// src/sql-database.ts
+var SqlDatabaseInstance = class {
+  static {
+    __name(this, "SqlDatabaseInstance");
+  }
+  _writer;
+  _reader;
+  constructor(writer, reader) {
+    this._writer = writer;
+    this._reader = reader ?? writer;
+  }
+  writer() {
+    return this._writer;
+  }
+  reader() {
+    return this._reader;
+  }
+  async close() {
+    await this._writer.destroy();
+    if (this._reader !== this._writer) {
+      await this._reader.destroy();
+    }
+  }
+};
+
+// src/decorators.ts
+var import_reflect_metadata = require("reflect-metadata");
+var import_common = require("@celerity-sdk/common");
+function sqlWriterToken(resourceName) {
+  return /* @__PURE__ */ Symbol.for(`celerity:sqlDatabase:writer:${resourceName}`);
+}
+__name(sqlWriterToken, "sqlWriterToken");
+function sqlReaderToken(resourceName) {
+  return /* @__PURE__ */ Symbol.for(`celerity:sqlDatabase:reader:${resourceName}`);
+}
+__name(sqlReaderToken, "sqlReaderToken");
+function sqlDatabaseCredentialsToken(resourceName) {
+  return /* @__PURE__ */ Symbol.for(`celerity:sqlDatabase:credentials:${resourceName}`);
+}
+__name(sqlDatabaseCredentialsToken, "sqlDatabaseCredentialsToken");
+function sqlDatabaseInstanceToken(resourceName) {
+  return /* @__PURE__ */ Symbol.for(`celerity:sqlDatabase:instance:${resourceName}`);
+}
+__name(sqlDatabaseInstanceToken, "sqlDatabaseInstanceToken");
+var DEFAULT_SQL_WRITER_TOKEN = /* @__PURE__ */ Symbol.for("celerity:sqlDatabase:writer:default");
+var DEFAULT_SQL_READER_TOKEN = /* @__PURE__ */ Symbol.for("celerity:sqlDatabase:reader:default");
+var DEFAULT_SQL_CREDENTIALS_TOKEN = /* @__PURE__ */ Symbol.for("celerity:sqlDatabase:credentials:default");
+var DEFAULT_SQL_DATABASE_INSTANCE_TOKEN = /* @__PURE__ */ Symbol.for("celerity:sqlDatabase:instance:default");
+function createResourceDecorator(tokenFn, defaultToken) {
+  return (resourceName) => {
+    return (target, _propertyKey, parameterIndex) => {
+      const token = resourceName ? tokenFn(resourceName) : defaultToken;
+      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(createResourceDecorator, "createResourceDecorator");
+var SqlDatabase = createResourceDecorator(sqlWriterToken, DEFAULT_SQL_WRITER_TOKEN);
+var SqlWriter = createResourceDecorator(sqlWriterToken, DEFAULT_SQL_WRITER_TOKEN);
+var SqlReader = createResourceDecorator(sqlReaderToken, DEFAULT_SQL_READER_TOKEN);
+var SqlCredentials = createResourceDecorator(sqlDatabaseCredentialsToken, DEFAULT_SQL_CREDENTIALS_TOKEN);
+
+// src/helpers.ts
+function getSqlWriter(container, resourceName) {
+  const token = resourceName ? sqlWriterToken(resourceName) : DEFAULT_SQL_WRITER_TOKEN;
+  return container.resolve(token);
+}
+__name(getSqlWriter, "getSqlWriter");
+function getSqlReader(container, resourceName) {
+  const token = resourceName ? sqlReaderToken(resourceName) : DEFAULT_SQL_READER_TOKEN;
+  return container.resolve(token);
+}
+__name(getSqlReader, "getSqlReader");
+function getSqlCredentials(container, resourceName) {
+  const token = resourceName ? sqlDatabaseCredentialsToken(resourceName) : DEFAULT_SQL_CREDENTIALS_TOKEN;
+  return container.resolve(token);
+}
+__name(getSqlCredentials, "getSqlCredentials");
+
+// src/layer.ts
+var import_debug = __toESM(require("debug"), 1);
+var import_common2 = require("@celerity-sdk/common");
+var import_config3 = require("@celerity-sdk/config");
+var debug = (0, import_debug.default)("celerity:sql-database");
+var SqlDatabaseLayer = class {
+  static {
+    __name(this, "SqlDatabaseLayer");
+  }
+  initialized = false;
+  config = null;
+  async handle(context, next) {
+    if (!this.initialized) {
+      this.config = captureSqlDatabaseLayerConfig();
+      const links = (0, import_config3.captureResourceLinks)();
+      const sqlLinks = (0, import_config3.getLinksOfType)(links, "sqlDatabase");
+      if (sqlLinks.size > 0) {
+        const configService = await context.container.resolve(import_common2.CONFIG_SERVICE_TOKEN);
+        const resourceConfig = configService.namespace(import_config3.RESOURCE_CONFIG_NAMESPACE);
+        const tokenProviderFactory = await resolveTokenProviderFactory(this.config.platform);
+        for (const [resourceName, configKey] of sqlLinks) {
+          await this.initializeResource(context.container, resourceName, configKey, resourceConfig, tokenProviderFactory);
+        }
+        if (sqlLinks.size === 1) {
+          const [resourceName] = [
+            ...sqlLinks.keys()
+          ];
+          await this.registerDefaultTokens(context.container, resourceName);
+        }
+      }
+      this.initialized = true;
+    }
+    return next();
+  }
+  async initializeResource(container, resourceName, configKey, resourceConfig, tokenProviderFactory) {
+    debug("resolving sql database resource %s (configKey=%s)", resourceName, configKey);
+    const credentials = await resolveDatabaseCredentials(configKey, resourceConfig, tokenProviderFactory);
+    const poolOverrides = await resolvePoolOverrides(configKey, resourceConfig);
+    const info = await credentials.getConnectionInfo();
+    const writerKnex = await createKnexInstance({
+      credentials,
+      deployTarget: this.config.deployTarget,
+      pool: poolOverrides
+    });
+    let readerKnex = writerKnex;
+    if (info.readHost) {
+      readerKnex = await createKnexInstance({
+        credentials,
+        deployTarget: this.config.deployTarget,
+        pool: poolOverrides,
+        useReadHost: true
+      });
+    }
+    const instance = new SqlDatabaseInstance(writerKnex, readerKnex);
+    container.register(sqlDatabaseInstanceToken(resourceName), {
+      useValue: instance,
+      onClose: /* @__PURE__ */ __name(() => instance.close(), "onClose")
+    });
+    container.register(sqlWriterToken(resourceName), {
+      useValue: writerKnex
+    });
+    container.register(sqlReaderToken(resourceName), {
+      useValue: readerKnex
+    });
+    container.register(sqlDatabaseCredentialsToken(resourceName), {
+      useValue: credentials
+    });
+    debug("registered sql database resource %s", resourceName);
+  }
+  async registerDefaultTokens(container, resourceName) {
+    const instance = await container.resolve(sqlDatabaseInstanceToken(resourceName));
+    const writer = await container.resolve(sqlWriterToken(resourceName));
+    const reader = await container.resolve(sqlReaderToken(resourceName));
+    const creds = await container.resolve(sqlDatabaseCredentialsToken(resourceName));
+    container.register(DEFAULT_SQL_DATABASE_INSTANCE_TOKEN, {
+      useValue: instance
+    });
+    container.register(DEFAULT_SQL_WRITER_TOKEN, {
+      useValue: writer
+    });
+    container.register(DEFAULT_SQL_READER_TOKEN, {
+      useValue: reader
+    });
+    container.register(DEFAULT_SQL_CREDENTIALS_TOKEN, {
+      useValue: creds
+    });
+    debug("registered default sql database tokens \u2192 %s", resourceName);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_SQL_CREDENTIALS_TOKEN,
+  DEFAULT_SQL_DATABASE_INSTANCE_TOKEN,
+  DEFAULT_SQL_READER_TOKEN,
+  DEFAULT_SQL_WRITER_TOKEN,
+  POOL_PRESETS,
+  RdsTokenProvider,
+  SqlCredentials,
+  SqlDatabase,
+  SqlDatabaseError,
+  SqlDatabaseInstance,
+  SqlDatabaseLayer,
+  SqlReader,
+  SqlWriter,
+  buildConnectionUrl,
+  captureSqlDatabaseLayerConfig,
+  createKnexInstance,
+  createRdsTokenProviderFactory,
+  getSqlCredentials,
+  getSqlReader,
+  getSqlWriter,
+  resolveDatabaseCredentials,
+  resolvePoolConfig,
+  resolvePoolOverrides,
+  sqlDatabaseCredentialsToken,
+  sqlDatabaseInstanceToken,
+  sqlReaderToken,
+  sqlWriterToken
+});
 //# sourceMappingURL=index.cjs.map