Merge pull request #45 from leapfrogtechnology/env-vars

Support resolving connections from the environment directly as a fallback option

Author: kabirbaidhya

src/config.ts

@@ -9,7 +9,7 @@ import DbConfig from './domain/DbConfig';
 import SyncConfig from './domain/SyncConfig';
 import ConnectionConfig from './domain/ConnectionConfig';
 import { prepareInjectionConfigVars } from './services/configInjection';
-import { DEFAULT_CONFIG, CONFIG_FILENAME, CONNECTIONS_FILENAME, ENV_KEYS } from './constants';
+import { DEFAULT_CONFIG, CONFIG_FILENAME, CONNECTIONS_FILENAME, REQUIRED_ENV_KEYS } from './constants';
 
 /**
  * Load config yaml file.
@@ -63,13 +63,19 @@ export async function resolveConnections(): Promise<ConnectionConfig[]> {
   log('Resolving database connections.');
 
   const filename = path.resolve(process.cwd(), CONNECTIONS_FILENAME);
+  const connectionsFileExists = await fs.exists(filename);
 
-  log('Resolving file: %s', filename);
+  let connections;
 
-  const loaded = await fs.read(filename);
-  const { connections } = JSON.parse(loaded) as DbConfig;
+  // If connections file exists, resolve connections from that.
+  // otherwise fallback to getting the connection from the env vars.
+  if (connectionsFileExists) {
+    connections = await resolveConnectionsFromFile(filename);
+  } else {
+    log('Connections file not provided.');
 
-  // TODO: Validate the connections received from file.
+    connections = resolveConnectionsFromEnv();
+  }
 
   log(
     'Resolved connections: %O',
@@ -109,10 +115,13 @@ function validateConnections(keys: string[]): void {
  * @returns {ConnectionConfig[]}
  */
 export function resolveConnectionsFromEnv(): ConnectionConfig[] {
-  validateConnections(ENV_KEYS);
+  log('Resolving connections from the environment variables.');
+
+  validateConnections(REQUIRED_ENV_KEYS);
 
   const connection = {
     client: process.env.DB_CLIENT,
+    id: process.env.DB_ID,
     host: process.env.DB_HOST,
     port: process.env.DB_PORT ? +process.env.DB_PORT : null,
     user: process.env.DB_USERNAME,
@@ -125,3 +134,20 @@ export function resolveConnectionsFromEnv(): ConnectionConfig[] {
 
   return [connection];
 }
+
+/**
+ * Resolve connections from the file.
+ *
+ * @param {string} filename
+ * @returns {Promise<ConnectionConfig[]>}
+ */
+async function resolveConnectionsFromFile(filename: string): Promise<ConnectionConfig[]> {
+  log('Resolving file: %s', filename);
+
+  const loaded = await fs.read(filename);
+  const { connections } = JSON.parse(loaded) as DbConfig;
+
+  // TODO: Validate the connections received from file.
+
+  return connections;
+}

src/constants.ts

@@ -32,4 +32,4 @@ export const DEFAULT_SYNC_PARAMS: SyncParams = {
   onFailed: (context: ExecutionContext) => Promise.resolve()
 };
 
-export const ENV_KEYS = ['DB_HOST', 'DB_PASSWORD', 'DB_NAME', 'DB_USERNAME', 'DB_PORT', 'DB_CLIENT', 'DB_ENCRYPTION'];
+export const REQUIRED_ENV_KEYS = ['DB_HOST', 'DB_PASSWORD', 'DB_NAME', 'DB_USERNAME', 'DB_PORT', 'DB_CLIENT'];

test/config.test.ts

@@ -1,10 +1,52 @@
 import { expect } from 'chai';
 import { it, describe } from 'mocha';
 
-import { validate, getConnectionId } from '../src/config';
 import ConnectionConfig from '../src/domain/ConnectionConfig';
+import { validate, getConnectionId, resolveConnectionsFromEnv } from '../src/config';
 
 describe('config:', () => {
+  describe('resolveConnectionsFromEnv', () => {
+    it('should return the connection using the env vars.', () => {
+      process.env.DB_CLIENT = 'mssql';
+      process.env.DB_ID = 'mydb';
+      process.env.DB_HOST = 'localhost';
+      process.env.DB_PORT = '1234';
+      process.env.DB_USERNAME = 'user';
+      process.env.DB_PASSWORD = 'password';
+      process.env.DB_NAME = 'database';
+
+      const connections = resolveConnectionsFromEnv();
+
+      expect(connections[0]).to.deep.equal({
+        client: 'mssql',
+        id: 'mydb',
+        host: 'localhost',
+        port: 1234,
+        user: 'user',
+        password: 'password',
+        database: 'database',
+        options: {
+          encrypt: false
+        }
+      });
+
+      // Cleanup
+      process.env.DB_CLIENT = '';
+      process.env.DB_ID = '';
+      process.env.DB_HOST = '';
+      process.env.DB_PORT = '';
+      process.env.DB_USERNAME = '';
+      process.env.DB_PASSWORD = '';
+      process.env.DB_NAME = '';
+    });
+
+    it('should throw an error if the required env vars are not provided.', () => {
+      expect(() => resolveConnectionsFromEnv()).to.throw(
+        'Following environment variables were not set: DB_HOST, DB_PASSWORD, DB_NAME, DB_USERNAME, DB_PORT, DB_CLIENT'
+      );
+    });
+  });
+
   describe('validate', () => {
     it('throws error if injectedConfig.vars is not found or is invalid in the config.', () => {
       expect(() => validate({ injectedConfig: { vars: 'foobar' } } as any)).to.throw(