@breautek/storm 6.0.5 → 6.1.0-beta.1

package/src/Application.ts

@@ -29,6 +29,7 @@ import {Command} from 'commander';
 import * as Express from 'express';
 import * as BodyParser from 'body-parser';
 import * as http from 'http';
+import * as Path from 'path';
 import { IAuthTokenData } from '@arashi/token';
 import {
     Logger,
@@ -37,6 +38,14 @@ import {
 } from '@arashi/logger';
 import { StormError } from './StormError';
 
+export interface IStormCLIArgs {
+    bind?: string;
+    port?: number;
+    authentication_header?: string;
+    configFile?: string;
+    localConfigFile?: string;
+}
+
 const TAG: string = 'Application';
 
 /**
@@ -52,7 +61,24 @@ export abstract class Application
     extends EventEmitter {
     private $logger: BaseLogger;
     private $name: string;
+
+    /**
+     * Path to the config directory.
+     * This is used as a fallback and it will be expected that
+     * bt-config.json and bt-local-config.json are found.
+     */
+    private $configDir: string;
+
+    /**
+     * Path to a bt-config.json file
+     */
     private $configPath: string;
+
+    /**
+     * Path to a bt-local-config.json file
+     */
+    private $localConfigPath: string;
+
     private $config: TConfig;
     private $tokenManager: TokenManager<TAuthToken>;
     private $server: Express.Application;
@@ -60,17 +86,21 @@ export abstract class Application
     private $socket: http.Server;
     private $program: Command;
 
+    private $usingDeprecatedConfigPath: boolean;
+
     /**
      * 
      * @param name The application name
-     * @param configPath The directory where bt-config.json and bt-local-config.json can be found. Defaults to current working directory.
+     * @param configPath @deprecated The directory where bt-config.json and bt-local-config.json can be found. Defaults to current working directory.
      */
-    public constructor(name: string, configPath: string) {
+    public constructor(name: string, configPath?: string) {
         super();
 
         setInstance(this);
         
         this.$buildArgOptions();
+
+        this.$usingDeprecatedConfigPath = !!configPath;
         
         this.$program.parse(process.argv);
 
@@ -85,7 +115,7 @@ export abstract class Application
             }
         });
 
-        this.$configPath = configPath || process.cwd();
+        this.$configDir = configPath || process.cwd();
     }
 
     public async start(): Promise<void> {
@@ -94,6 +124,10 @@ export abstract class Application
         this.$logger.info(TAG, 'Application is booting...');
         this.$logger.info(TAG, 'Loading Configuration...');
 
+        if (this.$usingDeprecatedConfigPath) {
+            this.$getLogger().warn(TAG, `configPath constructor argument is deprecated. Use --config and --local_config instead.`);
+        }
+
         try {
             await this.$load();
         }
@@ -103,7 +137,7 @@ export abstract class Application
     }
 
     private async $load(): Promise<void> {
-        this.$config = await this.loadConfig(this.$configPath);
+        this.$config = await this.$loadConfig();
         this.$logger = await this._initLogger(this.$config);
 
         this.$getLogger().trace(TAG, 'Configuration loaded.');
@@ -252,24 +286,31 @@ export abstract class Application
         return port;
     }
 
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    private $buildArgOptions() {
-        this.$program = new Command();
+    protected _getVersion(): string {
+        console.warn(TAG, `_getVersion will be an abstract method in the next major release. Override this method and pass a version string.`);
+        return '0.0.0';
+    }
 
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
+    private $getVersionString(): string {
         let pkg: any = require('../package.json');
+        return `${this._getVersion()} (Storm ${pkg.version})`;
+    }
+
+    private $buildArgOptions() {
+        this.$program = new Command();
         
-        this.$program.version(pkg.version, '-v, --version');
+        this.$program.version(this.$getVersionString(), '-v, --version');
         this.$program.allowUnknownOption(true);
         this.$program.allowExcessArguments(true);
         this.$program.option('--port <port>', 'The running port to consume');
         this.$program.option('--bind <ip>', 'The binding IP to listen on');
         this.$program.option('--authentication_header <header>', 'The header name of the authentication token');
+        this.$program.option('--config <path>', 'The path to the bt-config.json file');
+        this.$program.option('--local-config <path>', 'The path to the bt-local-config.json file.');
 
         this._buildArgOptions(this.$program);
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
     protected _buildArgOptions(program: Command): void {}
 
     public getProgram(): Command {
@@ -346,6 +387,7 @@ export abstract class Application
     protected abstract _attachHandlers(): Promise<void>;
 
     /**
+     * @deprecated Supply the configs via --config and --local-config arguments
      * 
      * @param path The directory path that contains bt-config.json and bt-local-config.json
      */
@@ -366,6 +408,38 @@ export abstract class Application
         });
     }
 
+    private async $loadConfig(): Promise<TConfig> {
+        let loader: ConfigLoader<TConfig> = new ConfigLoader<TConfig>(this);
+        return await loader.load(this.$getConfigFilePath(), this.$getLocalConfigFilePath());
+    }
+
+    private $getLocalConfigFilePath(): string {
+        if (!this.$localConfigPath) {
+            let filePath: string = this.getCmdLineArgs().localConfigFile;
+            if (!filePath) {
+                filePath = Path.resolve(this.$configDir, 'bt-local-config.json');
+            }
+
+            this.$localConfigPath = Path.resolve(filePath);
+        }
+
+        return this.$localConfigPath;
+    }
+
+    private $getConfigFilePath(): string {
+        if (!this.$configPath) {
+            let filePath: string = this.getCmdLineArgs().configFile;
+
+            if (!filePath) {
+                filePath = Path.resolve(this.$configDir, 'bt-config.json');
+            }
+
+            this.$configPath = Path.resolve(filePath);
+        }
+
+        return this.$configPath;
+    }
+
     /**
      * @returns the application name
      */
@@ -423,16 +497,16 @@ export abstract class Application
     /**
      * @returns command line arguments
      */
-    public getCmdLineArgs(): TConfig {
+    public getCmdLineArgs(): IStormCLIArgs {
         let program: Command = this.$program;
-        let o: any = {};
-
-        let opts: any = program.opts();
+        let o: IStormCLIArgs = {};
 
         if (!program) {
             return o;
         }
 
+        let opts: any = program.opts();
+
         if (opts.bind !== undefined) {
             o.bind = opts.bind;
         }
@@ -445,6 +519,14 @@ export abstract class Application
             o.authentication_header = opts.authentication_header;
         }
 
+        if (opts.config !== undefined) {
+            o.configFile = opts.config;
+        }
+
+        if (opts.localConfig !== undefined) {
+            o.localConfigFile = opts.localConfig;
+        }
+
         return o;
     }
 

package/src/CORSMiddleware.ts

@@ -27,8 +27,8 @@ import {getInstance} from './instance';
  */
 export class CORSMiddleware extends Middleware {
     private $allowedOrigin: string;
-    private $allowedHeaders: Array<string>;
-    private $allowedMethods: Array<string>;
+    private $allowedHeaders: string[];
+    private $allowedMethods: string[];
 
     /**
      * @constructor
@@ -36,7 +36,7 @@ export class CORSMiddleware extends Middleware {
      * @param allowedHeaders    Array of allowed headers. 
      * @param allowedMethods    Array of allowed HTTP methods.
      */
-    public constructor(allowedOrigin?: string, allowedHeaders?: Array<string>, allowedMethods?: Array<string>) {
+    public constructor(allowedOrigin?: string, allowedHeaders?: string[], allowedMethods?: string[]) {
         super();
         
         this.$allowedOrigin = (!allowedOrigin) ? this.getDefaultAllowedOrigin() : allowedOrigin;
@@ -51,7 +51,7 @@ export class CORSMiddleware extends Middleware {
         return null;
     }
 
-    public getDefaultAllowedHeaders(): Array<string> {
+    public getDefaultAllowedHeaders(): string[] {
         return [
             'Accept',
             getInstance().getConfig().authentication_header,
@@ -61,7 +61,7 @@ export class CORSMiddleware extends Middleware {
         ];
     }
 
-    public getDefaultAllowedMethods(): Array<string> {
+    public getDefaultAllowedMethods(): string[] {
         return [
             'GET',
             'POST',

package/src/ConfigLoader.ts

@@ -17,9 +17,9 @@
 */
 
 import {getInstance} from './instance';
-import {Logger} from '@arashi/logger';
+import {BaseLogger} from '@arashi/logger';
 import * as Path from 'path';
-import {Application} from './Application';
+import {Application, IStormCLIArgs} from './Application';
 import {IConfig} from './IConfig';
 import Ajv from 'ajv';
 import * as MergeChange from '@breautek/merge-change';
@@ -28,18 +28,24 @@ import { MissingConfigError } from './MissingConfigError';
 
 const TAG: string = 'ConfigLoader';
 
-export class ConfigLoader {
-    private constructor() {}
+export class ConfigLoader<TConfig extends IConfig = IConfig> {
+    private $logger: BaseLogger;
+    private $app: Application;
 
-    public static async load(path: string): Promise<IConfig> {
-        let logger: Logger = ConfigLoader.$getLogger();
+    public constructor(app: Application) {
+        this.$app = app;
+        this.$logger = app.getLogger();
+    }
+
+    public async load(configFile: string, localConfigFile: string): Promise<TConfig> {
+        let logger: BaseLogger = this.$logger;
 
         logger.trace(TAG, 'Configuration loaded.');
         
-        let config: IConfig = {};
+        let config: Partial<TConfig> = {};
 
-        let cPath: string = Path.resolve(path, 'bt-config.json');
-        let lPath: string = Path.resolve(path, 'bt-local-config.json');
+        let cPath: string = configFile;
+        let lPath: string = localConfigFile;
         
         let c: IConfig;
         let l: IConfig;
@@ -59,7 +65,7 @@ export class ConfigLoader {
         }
 
         logger.trace(TAG, 'Reading command line arguments...');
-        config = MergeChange.merge(config, ConfigLoader.$getCmdLineArgs());
+        config = MergeChange.merge(config, this.$getCmdLineArgs());
 
         if (config.log.level === null) {
             config.log.level = defaults.log.level;
@@ -68,31 +74,81 @@ export class ConfigLoader {
         logger.trace(TAG, 'Configurations merged.');
         logger.trace(TAG, config);
 
-        await ConfigLoader.$validateSchema(config);
+        await this.$validateSchema(config);
 
-        return config;
+        return <TConfig>config;
     }
 
-    private static $getLocalConfig(path: string): IConfig {
+    /**
+     * @deprecated Instantiate ConfigLoader with the proper params
+     * @param path 
+     * @returns 
+     */
+    public static async load(path: string): Promise<IConfig> {
+        let loader: ConfigLoader = new ConfigLoader<IConfig>(getInstance());
+        return await loader.load(Path.resolve(path, 'bt-config.json'), Path.resolve('bt-local-config.json'));
+
+        // let logger: Logger = ConfigLoader.$getLogger();
+
+        // logger.trace(TAG, 'Configuration loaded.');
+        
+        // let config: IConfig = {};
+
+        // let cPath: string = Path.resolve(path, 'bt-config.json');
+        // let lPath: string = Path.resolve(path, 'bt-local-config.json');
+        
+        // let c: IConfig;
+        // let l: IConfig;
+        // let defaults: IConfig = this.$getDefaults();
+
+        // logger.trace(TAG, `Main Config Path:\t ${cPath}`);
+        // logger.trace(TAG, `Local Config Path:\t ${lPath}`);
+
+        // c = this.$getMainConfig(cPath);
+        // l = this.$getLocalConfig(lPath);
+
+        // if (l) {
+        //     config = MergeChange.merge(defaults, c, l);
+        // }
+        // else {
+        //     config = MergeChange.merge(defaults, c);
+        // }
+
+        // logger.trace(TAG, 'Reading command line arguments...');
+        // config = MergeChange.merge(config, ConfigLoader.$getCmdLineArgs());
+
+        // if (config.log.level === null) {
+        //     config.log.level = defaults.log.level;
+        // }
+
+        // logger.trace(TAG, 'Configurations merged.');
+        // logger.trace(TAG, config);
+
+        // await ConfigLoader.$validateSchema(config);
+
+        // return config;
+    }
+
+    private $getLocalConfig(path: string): IConfig {
         let config: IConfig = null;
-        this.$getLogger().trace(TAG, 'Loading optional local config.');
+        this.$logger.trace(TAG, 'Loading optional local config.');
         try {
             config = require(path);
-            this.$getLogger().trace(TAG, 'Local config loaded.');
+            this.$logger.trace(TAG, 'Local config loaded.');
         }
         catch (ex) {
-            this.$getLogger().trace(TAG, 'Local config could not be loaded.');
-            this.$getLogger().trace(TAG, ex);
+            this.$logger.trace(TAG, 'Local config could not be loaded.');
+            this.$logger.trace(TAG, ex);
         }
         return config;
     }
 
-    private static $getMainConfig(path: string): IConfig {
-        this.$getLogger().trace(TAG, 'Loading main confing...');
+    private $getMainConfig(path: string): IConfig {
+        this.$logger.trace(TAG, 'Loading main confing...');
         let c: IConfig = null;
         try {
             c = require(path);
-            this.$getLogger().trace(TAG, 'Main config loaded.');
+            this.$logger.trace(TAG, 'Main config loaded.');
         }
         catch (ex) {
             throw new MissingConfigError(path);
@@ -101,12 +157,12 @@ export class ConfigLoader {
         return c;
     }
 
-    private static $getDefaults(): IConfig {
-        this.$getLogger().trace(TAG, 'Loading configuration defaults.');
+    private $getDefaults(): IConfig {
+        this.$logger.trace(TAG, 'Loading configuration defaults.');
         return require(Path.resolve(__dirname, '../bt-config-defaults.json'));
     }
 
-    private static async $validateSchema(config: IConfig): Promise<void> {
+    private async $validateSchema(config: IConfig): Promise<void> {
         let ajv: Ajv = new Ajv({
             allErrors: true
         });
@@ -215,22 +271,7 @@ export class ConfigLoader {
         }
     }
 
-    private static $getCmdLineArgs(): any {
-        let app: Application = getInstance();
-        if (!app) {
-            return {};
-        }
-
-        return app.getCmdLineArgs();
-    }
-
-    private static $getLogger(): Logger {
-        let logger: Logger;
-        
-        if (!logger) {
-            logger = new Logger('ConfigLoader');
-        }
-
-        return logger;
+    private $getCmdLineArgs(): IStormCLIArgs {
+        return this.$app.getCmdLineArgs();
     }
 }

package/src/DatabaseConnection.ts

@@ -37,7 +37,7 @@ export abstract class DatabaseConnection<TAPI> implements IDatabaseConnection {
     private $api: any;
     private $readOnly: boolean;
     private $timeout: number;
-    private $lingerTimer: NodeJS.Timer;
+    private $lingerTimer: NodeJS.Timeout;
     private $instantiationStack: string;
     private $open: boolean;
 

package/src/Handler.ts

@@ -66,7 +66,7 @@ export class Handler<
     >  {
         
     private $app: TApplication;
-    private $middlewares: Array<Middleware>;
+    private $middlewares: Middleware[];
 
     constructor(app: TApplication) {
         this.$app = app;
@@ -77,7 +77,7 @@ export class Handler<
         return this.$app;
     }
 
-    protected _initMiddlewares(): Array<Middleware> {
+    protected _initMiddlewares(): Middleware[] {
         return [];
     }
 

package/src/IConfig.ts

@@ -46,7 +46,7 @@ export interface IConfig {
     // Logging
     log?: {
         level?: LogLevel;
-        filters?: Array<string>;
+        filters?: string[];
         cloudwatch?: ICloudwatchConfig;
     },
 
@@ -54,7 +54,7 @@ export interface IConfig {
     database?: {
         query_timeout?: number;
         main?: IDatabaseConfig<"MASTER">;
-        replicationNodes?: Array<IDatabaseConfig>;
+        replicationNodes?: IDatabaseConfig[];
     };
     
 

package/src/InvalidConfigError.ts

@@ -23,11 +23,11 @@ import { ExitCode } from './ExitCode';
 
 interface IInvalidConfigErrorDetails<TConfig extends IConfig> {
     config: TConfig;
-    errors: Array<ErrorObject>;
+    errors: ErrorObject[];
 }
 
 export class InvalidConfigError<TConfig extends IConfig> extends StormError<IInvalidConfigErrorDetails<TConfig>> {
-    public constructor(config: TConfig, errors: Array<ErrorObject>) {
+    public constructor(config: TConfig, errors: ErrorObject[]) {
         super({
             config,
             errors

package/src/LineString.ts

@@ -18,9 +18,9 @@ import {DatabaseCastObject} from './DatabaseCastObject';
 import {TCoordinate} from './TCoordinate';
 
 export class LineString extends DatabaseCastObject {
-    private $coords: Array<TCoordinate>;
+    private $coords: TCoordinate[];
 
-    public constructor(coordinates?: Array<TCoordinate>) {
+    public constructor(coordinates?: TCoordinate[]) {
         super();
 
         this.$coords = coordinates || [];

package/src/MySQLConnection.ts

@@ -38,14 +38,13 @@ const TAG: string = 'MySQLConnection';
 const SQL_FORMATTING_OPTIONS: SQLFormatter.FormatOptions = {
     tabWidth: 4,
     keywordCase: 'upper',
+    identifierCase: 'preserve',
     useTabs: false,
     indentStyle: 'standard',
     logicalOperatorNewline: 'after',
-    commaPosition: 'before',
     linesBetweenQueries: 1,
     denseOperators: false,
     newlineBeforeSemicolon: false,
-    tabulateAlias: true,
     expressionWidth: 4
 };
 

package/src/Polygon.ts

@@ -18,9 +18,9 @@ import {DatabaseCastObject} from './DatabaseCastObject';
 import {TCoordinate} from './TCoordinate';
 
 export class Polygon extends DatabaseCastObject {
-    private $rings: Array<Array<TCoordinate>>;
+    private $rings: TCoordinate[][];
 
-    public constructor(coordinates?: Array<Array<TCoordinate>>) {
+    public constructor(coordinates?: TCoordinate[][]) {
         super();
 
         this.$rings = coordinates || [];
@@ -30,7 +30,7 @@ export class Polygon extends DatabaseCastObject {
         let str: string = 'POLYGON(';
 
         for (let i: number = 0; i < this.$rings.length; i++) {
-            let ring: Array<TCoordinate> = this.$rings[i];
+            let ring: TCoordinate[] = this.$rings[i];
             let strRing: string = '(';
 
             for (let y: number = 0; y < ring.length; y++) {

package/src/Request.ts

@@ -72,7 +72,7 @@ export class Request<TBody = any, TAuthToken extends IAuthTokenData = IAuthToken
     }
 
     public getHeader(name: string): string {
-        let value: string | Array<string> = this.$request.headers[name.toLowerCase()];
+        let value: string | string[] = this.$request.headers[name.toLowerCase()];
         if (typeof value === 'string') {
             return value;
         }

package/tsconfig.json

@@ -10,8 +10,7 @@
         "noImplicitThis": true,
         "alwaysStrict": true,
         "noImplicitReturns": true,
-        "moduleResolution": "node",
-        "incremental": true
+        "moduleResolution": "node"
     },
     "exclude": [
         "./spec",

package/tsconfig-tests.json

@@ -1,15 +0,0 @@
-{
-    "extends" : "./tsconfig.json",
-    "compilerOptions": {
-        "outDir": "./spec",
-        "declaration": false,
-        "sourceMap": true
-    },
-    "include": [
-        "**/*.ts"
-    ],
-    "exclude": [
-        "lib",
-        "node_modules"
-    ]
-}