middy-rds/clients/knex.mjs

Simple RDS manager for the middy framework

// clients/knex.js
import { canPrefetch, getInternal, processCache } from "@middy/util";

// lib/iam-token.js
import { Signer } from "@aws-sdk/rds-signer";
var iam_token_default = async (config) => {
  const params = {
    region: process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION,
    hostname: config.host ?? config.hostname ?? process.env.DBHOST ?? process.env.PGHOST,
    port: Number.parseInt(
      config.port ?? process.env.DBPORT ?? process.env.PGPORT
    ),
    username: config.user ?? config.username ?? process.env.DBUSER ?? process.env.PGUSER
  };
  const client = new Signer(params);
  return client.getAuthToken().then((token) => {
    if (!token.includes("X-Amz-Security-Token=")) {
      throw new Error("X-Amz-Security-Token Missing", {
        cause: { package: "middy-rds", data: params }
      });
    }
    return token;
  });
};

// lib/ssl.js
import { checkServerIdentity } from "tls";
var ssl_default = {
  rejectUnauthorized: true,
  ca: void 0,
  checkServerIdentity: (host, cert) => {
    const error = checkServerIdentity(host, cert);
    if (error && !cert.subject.CN.endsWith(".rds.amazonaws.com")) {
      return error;
    }
  }
};

// clients/knex.js
var defaults = {
  client: void 0,
  config: {},
  forceConnection: false,
  internalData: void 0,
  contextKey: "rds",
  disablePrefetch: false,
  cacheKey: "rds",
  cacheExpiry: 15 * 60 * 1e3 - 1
  // IAM token lasts for 15min
};
var defaultConnection = { ssl: ssl_default };
var rdsMiddleware = (opts = {}) => {
  const options = { ...defaults, ...opts };
  if (!options.client) throw new Error("client option missing");
  const fetch = async (request) => {
    var _a;
    const values = await getInternal(options.internalData, request);
    options.config.connection = {
      ...defaultConnection,
      ...options.config.connection,
      ...values,
      ssl: {
        ...defaultConnection.ssl,
        ...options.config.connection.ssl
      }
    };
    if (!options.config.connection.port) {
      throw new Error("port missing");
    }
    (_a = options.config.connection).password ?? (_a.password = await iam_token_default(options.config));
    const knex = options.client(options.config);
    options.config.password = void 0;
    if (options.forceConnection) {
      await knex.raw("SELECT 1");
    }
    return knex;
  };
  let prefetch;
  if (canPrefetch(options)) {
    prefetch = processCache(options, fetch);
  }
  const rdsMiddlewareBefore = async (request) => {
    const { value } = prefetch ?? processCache(options, fetch, request);
    Object.assign(request.context, { [options.contextKey]: await value });
  };
  const rdsMiddlewareAfter = async (request) => {
    if (options.cacheExpiry === 0) {
      await request.context[options.contextKey].destroy();
    }
  };
  const rdsMiddlewareOnError = rdsMiddlewareAfter;
  return {
    before: rdsMiddlewareBefore,
    after: rdsMiddlewareAfter,
    onError: rdsMiddlewareOnError
  };
};
var knex_default = rdsMiddleware;
export {
  knex_default as default
};