@itgorillaz/configify 1.1.0

package/src/configuration/resolvers/aws/parameter-store-configuration.resolver.ts

@@ -0,0 +1,115 @@
+import { GetParameterCommand, SSMClient } from '@aws-sdk/client-ssm';
+import { ConfigurationResolver } from '../configuration-resolver.interface';
+import { ResolvedValue } from '../resolved-value.interface';
+
+/**
+ * AWS Parameter Store configuration resolver.
+ */
+export class AwsParameterStoreConfigurationResolver
+  implements ConfigurationResolver
+{
+  private readonly AWS_PARAMETER_STORE_YAML_KEY = 'aws-parameter-store';
+  private readonly AWS_PARAMETER_STORE_ENV_PREFIX = 'AWS_PARAMETER_STORE';
+
+  /**
+   * Creates a new instance of parameter store configuration resolver
+   *
+   * @param {SSMClient} ssm systems manager client
+   */
+  constructor(private readonly ssm: SSMClient) {}
+
+  /**
+   * Fetches parameters and assign it to an object representation
+   * of the configuration.
+   *
+   * @param   {Record<string, any>} config the configuration object
+   * @returns {Record<string, any>}        the cofiguration with secret values assigned
+   * @throws  {Error}                      if unable to fetch the secret
+   */
+  async resolve(config: Record<string, any>): Promise<Record<string, any>> {
+    const parameters = this.filterConfiguration(config);
+    const promises = this.buildBulkRequest(parameters);
+
+    const results = await Promise.all(promises);
+
+    const errors = results.filter((r) => !r.success);
+    if (errors && errors.length) {
+      throw new Error(
+        `Unable to resolve parameter:\n${errors
+          .map((e) => `${e.key}: ${e.id} - ${e.error.message}`)
+          .join('\n')}`,
+      );
+    }
+
+    for (const result of results) {
+      config[result.key] = result.value;
+    }
+
+    return config;
+  }
+
+  /**
+   * Filters the configuration object by aws parameters store keys.
+   *
+   * @param   {Record<string, any>} config the configuration object
+   * @returns {Record<string, any>}        the filtered object
+   */
+  private filterConfiguration(
+    config: Record<string, any>,
+  ): Record<string, any> {
+    return Object.fromEntries(
+      Object.entries(config).filter(
+        ([key]) =>
+          key.startsWith(this.AWS_PARAMETER_STORE_YAML_KEY) ||
+          key.startsWith(this.AWS_PARAMETER_STORE_ENV_PREFIX),
+      ),
+    );
+  }
+
+  /**
+   * Resolves parameter values.
+   *
+   * @param {string} key the object key
+   * @param {string} id  the secret id
+   * @returns
+   */
+  private async resolveSecretValue(
+    key: string,
+    id: string,
+  ): Promise<ResolvedValue> {
+    try {
+      const payload = { Name: id, WithDecryption: true };
+      const command = new GetParameterCommand(payload);
+      const response = await this.ssm.send(command);
+      return {
+        id,
+        key,
+        value: response.Parameter?.Value,
+        success: true,
+      };
+    } catch (e) {
+      return {
+        id,
+        key,
+        error: e,
+        success: false,
+      };
+    }
+  }
+
+  /**
+   * Creates a list of promises to get parameter values.
+   *
+   * @param   {Record<string, any>}      config the configuration object
+   * @returns {Promise<ResolvedValue>[]}        the get parameter value promises
+   */
+  private buildBulkRequest(
+    config: Record<string, any>,
+  ): Promise<ResolvedValue>[] {
+    const promises = [];
+    for (const [key, value] of Object.entries(config)) {
+      promises.push(this.resolveSecretValue(key, value));
+    }
+    return promises;
+  }
+}

package/src/configuration/resolvers/aws/secrets-manager-configuration.resolver.ts

@@ -0,0 +1,117 @@
+import {
+  GetSecretValueCommand,
+  SecretsManagerClient,
+} from '@aws-sdk/client-secrets-manager';
+import { ConfigurationResolver } from '../configuration-resolver.interface';
+import { ResolvedValue } from '../resolved-value.interface';
+
+/**
+ * AWS Secrets Manager configuration resolver.
+ */
+export class AwsSecretsManagerConfigurationResolver
+  implements ConfigurationResolver
+{
+  private readonly AWS_SECRETS_AMANGER_YAML_KEY = 'aws-secrets-manager';
+  private readonly AWS_SECRETS_MANAGER_ENV_PREFIX = 'AWS_SECRETS_MANAGER';
+
+  /**
+   * Creates a new instance of secrets manager configuration resolver
+   *
+   * @param {SecretsManagerClient} secretsManager secrets manager client
+   */
+  constructor(private readonly secretsManager: SecretsManagerClient) {}
+
+  /**
+   * Fetches secrets and assign it to an object representation
+   * of the configuration.
+   *
+   * @param   {Record<string, any>} config the configuration object
+   * @returns {Record<string, any>}        the cofiguration with secret values assigned
+   * @throws  {Error}                      if unable to fetch the secret
+   */
+  async resolve(config: Record<string, any>): Promise<Record<string, any>> {
+    const secrets = this.filterConfiguration(config);
+    const promises = this.buildBulkRequest(secrets);
+
+    const results = await Promise.all(promises);
+
+    const errors = results.filter((r) => !r.success);
+    if (errors && errors.length) {
+      throw new Error(
+        `Unable to resolve secrets:\n${errors
+          .map((e) => `${e.key}: ${e.id} - ${e.error.message}`)
+          .join('\n')}`,
+      );
+    }
+
+    for (const result of results) {
+      config[result.key] = result.value;
+    }
+
+    return config;
+  }
+
+  /**
+   * Filters the configuration object by aws secrets manager keys.
+   *
+   * @param   {Record<string, any>} config the configuration object
+   * @returns {Record<string, any>}        the filtered object
+   */
+  private filterConfiguration(
+    config: Record<string, any>,
+  ): Record<string, any> {
+    return Object.fromEntries(
+      Object.entries(config).filter(
+        ([key]) =>
+          key.startsWith(this.AWS_SECRETS_AMANGER_YAML_KEY) ||
+          key.startsWith(this.AWS_SECRETS_MANAGER_ENV_PREFIX),
+      ),
+    );
+  }
+
+  /**
+   * Resolves secret values.
+   *
+   * @param {string} key the object key
+   * @param {string} id  the secret id
+   * @returns
+   */
+  private async resolveSecretValue(
+    key: string,
+    id: string,
+  ): Promise<ResolvedValue> {
+    try {
+      const command = new GetSecretValueCommand({ SecretId: id });
+      const response = await this.secretsManager.send(command);
+      return {
+        id,
+        key,
+        value: response.SecretString,
+        success: true,
+      };
+    } catch (e) {
+      return {
+        id,
+        key,
+        error: e,
+        success: false,
+      };
+    }
+  }
+
+  /**
+   * Creates a list of promises to get secret values.
+   *
+   * @param   {Record<string, any>}      config the configuration object
+   * @returns {Promise<ResolvedValue>[]}        the get secret value promises
+   */
+  private buildBulkRequest(
+    config: Record<string, any>,
+  ): Promise<ResolvedValue>[] {
+    const promises = [];
+    for (const [key, value] of Object.entries(config)) {
+      promises.push(this.resolveSecretValue(key, value));
+    }
+    return promises;
+  }
+}

package/src/configuration/resolvers/configuration-resolver.interface.ts

@@ -0,0 +1,11 @@
+/**
+ * The configuration resolver interface
+ */
+export interface ConfigurationResolver {
+  /**
+   * Resolves a remote configuration
+   *
+   * @param {Record<string, any>} configuration the configuration obejct
+   */
+  resolve(configuration: Record<string, any>): Promise<Record<string, any>>;
+}

package/src/configuration/resolvers/index.ts

@@ -0,0 +1,3 @@
+export * from './aws';
+export * from './configuration-resolver.interface';
+export * from './resolved-value.interface';

package/src/configuration/resolvers/resolved-value.interface.ts

@@ -0,0 +1,10 @@
+/**
+ * The resolved value interface
+ */
+export interface ResolvedValue {
+  id: string;
+  success: boolean;
+  key: string;
+  value?: string;
+  error?: Error;
+}

package/src/decorators/configuration.decorator.ts

@@ -0,0 +1,26 @@
+import { ConfigurationRegistry } from '../configuration/configuration.registry';
+
+/**
+ * The configuration metadata
+ */
+export const CONFIGURATION_METADATA = Symbol.for('__configuration__');
+
+/**
+ * The configuration decorator.
+ *
+ * Decorating a class with this decorator will make it
+ * visible for the module to manage its instance and assign
+ * values to the class attributes based on configuration files.
+ *
+ * @returns {ClassDecorator} the class decorator
+ */
+export const Configuration = (): ClassDecorator => {
+  return (target: object) => {
+    ConfigurationRegistry.registerTarget(target);
+    Reflect.defineMetadata(
+      CONFIGURATION_METADATA,
+      target.constructor.name,
+      target,
+    );
+  };
+};

package/src/decorators/index.ts

@@ -0,0 +1,2 @@
+export * from './configuration.decorator';
+export * from './value.decorator';

package/src/decorators/value.decorator.ts

@@ -0,0 +1,47 @@
+import { ConfigurationRegistry } from '../configuration/configuration.registry';
+
+/**
+ * The value metadata.
+ */
+export const VALUE_METADATA = Symbol.for('__value__');
+
+/**
+ * The value properties metadata.
+ */
+export const VALUE_PROPERTIES_METADATA = Symbol.for('__properties__');
+
+/**
+ * The value options.
+ * Allows custom parsing to configuration values
+ */
+export interface ValueOptions {
+  parse: (value: any) => any;
+}
+
+/**
+ * The value decorated key interface.
+ */
+export interface ValueDecoratedKey {
+  key: string;
+  options?: ValueOptions;
+}
+
+/**
+ * The value decorator.
+ *
+ * This decorator defines which configuration key should
+ * be assined to the class attribute.
+ *
+ * @param   {string}            key     the configuration key
+ * @param   {ValueOptions}      options custom options
+ * @returns {PropertyDecorator}         the property decorator
+ */
+export const Value = (
+  key: string,
+  options?: ValueOptions,
+): PropertyDecorator => {
+  return (target: object, property: string) => {
+    ConfigurationRegistry.registerAttribute(target, property);
+    Reflect.defineMetadata(VALUE_METADATA, { key, options }, target, property);
+  };
+};

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from './configify.module';
+export * from './decorators';

package/src/interpolation/variables.ts

@@ -0,0 +1,101 @@
+/**
+ * The variables expansion class.
+ *
+ * This is a slightly modified version of the dotenv-expand lib
+ * due to the lack of support to variables containing '.' and '-'.
+ *
+ * Once the dotev-expand lib adds support to '.' and '-' this class can be removed.
+ */
+export class Variables {
+  /**
+   * Escaped \$ matcher
+   */
+  private static readonly ESCAPE_PATTERN: RegExp = /\\\$/g;
+
+  /**
+   * Unescaped $ matcher
+   */
+  private static readonly UNESCAPED_PATTERN: RegExp = /(?!(?<=\\))\$/g;
+
+  /**
+   * (
+   *   (?!(?<=\\))\$        // only match dollar signs that are not escaped
+   *   {?                   // optional opening curly brace
+   *     ([\w]+)            // match the variable name
+   *     ([\w-.]+)          // match the variable name
+   *     (?::-([^}\\]*))?   // match an optional default value
+   *   }?                   // optional closing curly brace
+   * )
+   */
+  private static readonly EXPANSION_GROUP_PATTERN: RegExp =
+    /((?!(?<=\\))\${?([\w-.]+)(?::-([^}\\]*))?}?)/;
+
+  /**
+   * Expands the variables of the given object.
+   *
+   * @param   {Record<string, any>} record The object
+   * @returns {Record<string, any>}        The expanded object
+   */
+  static expand(record: Record<string, any>): Record<string, any> {
+    const expanded = {};
+    for (const key in record) {
+      const value = record[key];
+      expanded[key] = this.escapeSequences(this.interpolate(value, record));
+    }
+    return expanded;
+  }
+
+  /**
+   * Replaces ${variable} with actual values recursively.
+   *
+   * @param value
+   * @param record
+   * @returns
+   */
+  private static interpolate(
+    value: string,
+    record: Record<string, any>,
+  ): string {
+    const lastUnescapedDollarSignIndex = this.lastIndexOf(
+      value,
+      this.UNESCAPED_PATTERN,
+    );
+
+    if (lastUnescapedDollarSignIndex === -1) return value;
+
+    const rightMostGroup = value.slice(lastUnescapedDollarSignIndex);
+    const match = rightMostGroup.match(this.EXPANSION_GROUP_PATTERN);
+
+    if (match != null) {
+      const [, group, variableName, defaultValue] = match;
+      return this.interpolate(
+        value.replace(group, defaultValue || record[variableName] || ''),
+        record,
+      );
+    }
+
+    return value;
+  }
+
+  /**
+   * Replaces escaped \$ signs with $
+   *
+   * @param value
+   * @returns
+   */
+  private static escapeSequences(value: string): string {
+    return value.replace(this.ESCAPE_PATTERN, '$');
+  }
+
+  /**
+   * Finds the last index of the matching regex.
+   *
+   * @param value
+   * @param regex
+   * @returns
+   */
+  private static lastIndexOf(value: string, regex: RegExp): number {
+    const matches = Array.from(value.matchAll(regex));
+    return matches.length > 0 ? matches.slice(-1)[0].index : -1;
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "es2017",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": false,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false
+  }
+}