Lazy Parameter from AWS SSM

app.ts

import { getDbConnection } from 'dbConnection.service';

getDbConnection().then(connection => { // do something });

aws-ssm.sdk.ts

import { warn } from 'lib/logger';
import * as AWS from 'aws-sdk';

const ssm = new AWS.SSM();

function getParameterPath(name: string, environment: string) {
  return `/my-app/${environment}/${name}`;
}

export function getParameterFromSsm(name: string, environment: string, defaultValue: string): Promise<string> {
  return new Promise<string>((resolve) => {
    ssm.getParameter(
      {
        Name: getParameterPath(name, environment),
        WithDecryption: true,
      },
      (err, data) => {
        if (err || !data || !data.Parameter.Value) {
          warn(`Unable to read ${name} parameter from AWS SSM`, err);
          return resolve(defaultValue);
        }
        return resolve(data.Parameter.Value);
      });
  });
}

config.ts

export const dbUsername = new LazyParameter('DB_USERNAME');
export const dbPassword = new LazyParameter('DB_PASSWORD');

dbConnection.service.ts

import { dbUsername, dbPassword } from 'config';

export async function getDbConnection() {
  return new DbConnection(await dbUsername.get(), await dbPassword.get())
}

LazyParameter.ts

import { getParameterFromSsm } from 'aws-ssm.sdk'

function getParameterValue(name: string, defaultValue: string) {
  return process.env[name] || getParameterFromSsm(name, defaultValue);
}

export class LazyParameter extends LazyValue<string> {
  constructor(name: string, defaultValue?: string) {
    super(async () => {
      return getParameterValue(name, defaultValue);
    });
  }
}

LazyValue.ts

export class LazyValue<T> {
  private value: T;

  constructor(private init: () => Promise<T>) {}

  async get(): Promise<T> {
    if (!this.value) {
      this.value = await this.init();
    }
    return this.value;
  }
}