feat(core): initial checkin of core code

Author: codeandcats

package-lock.json

@@ -7,11 +7,16 @@
     "build": "tsc -p ./",
     "clean": "rimraf ./dist",
     "commit": "commit",
+    "preexample": "npm run package",
+    "example": "ts-node ./example/cli.ts",
     "lint": "tslint -p ./tsconfig.json",
     "lint:fix": "npm run lint -- --fix",
     "prebuild": "npm run clean",
+    "prepackage": "npm run build",
+    "package": "ts-node ./support/package.ts",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
+  "private": true,
   "author": "Ben <codeandcats@gmail.com>",
   "license": "ISC",
   "husky": {
@@ -23,8 +28,18 @@
     "@commitlint/cli": "^7.1.2",
     "@commitlint/config-conventional": "^7.1.2",
     "@commitlint/prompt-cli": "^7.1.2",
+    "@types/app-root-path": "^1.2.4",
+    "@types/fs-extra": "^5.0.4",
     "rimraf": "^2.6.2",
+    "ts-loader": "^5.0.0",
+    "ts-node": "^7.0.1",
     "tslint": "^5.11.0",
     "typescript": "^3.0.3"
+  },
+  "dependencies": {
+    "app-root-path": "^2.1.0",
+    "chalk": "^2.4.1",
+    "fs-extra": "^7.0.0",
+    "reflect-metadata": "^0.1.12"
   }
 }

package.json

@@ -0,0 +1,176 @@
+// tslint:disable:no-console
+import * as root from 'app-root-path';
+import chalk from 'chalk';
+import * as cli from 'commander';
+import * as fs from 'fs-extra';
+import { getCommandOptions, getCommands, getCommandValues } from './metadata';
+import { Command, CommandDefinition, CommandOptionDefinition, CommandValueDefinition, IocContainer } from './types';
+
+export class Commander {
+  private iocContainer?: IocContainer;
+  private _version?: string;
+  private isCommanderInitialised = false;
+
+  public ioc(iocContainer: IocContainer): this {
+    this.iocContainer = iocContainer;
+    return this;
+  }
+
+  public version(version: string): this {
+    this._version = version;
+    return this;
+  }
+
+  public async execute(argv?: string[]): Promise<void> {
+    await this.initialiseCommander();
+
+    const args = argv || process.argv;
+
+    if (args.length <= 2) {
+      cli.help();
+    }
+
+    cli.parse(args);
+  }
+
+  private async initialiseCommander() {
+    if (this.isCommanderInitialised) {
+      return;
+    }
+    await this.setVersion();
+    this.registerCommands();
+    this.isCommanderInitialised = true;
+  }
+
+  private async getPackageVersion(): Promise<string | undefined> {
+    const packageFileName = root.resolve('package.json');
+    if (!await fs.pathExists(packageFileName)) {
+      return undefined;
+    }
+
+    const packageObject = await fs.readJSON(packageFileName);
+
+    return packageObject && packageObject.version;
+  }
+
+  private async setVersion() {
+    const version =
+      this._version !== undefined ?
+        this._version :
+        await this.getPackageVersion();
+
+    if (version) {
+      cli.version(version);
+    }
+  }
+
+  private getValuesUsage(values: CommandValueDefinition[]) {
+    return values
+      .map((param) => param.optional ? `[${param.name}]` : `<${param.name}>`)
+      .join(' ');
+  }
+
+  private getOptionUsage(option: CommandOptionDefinition): string {
+    let result = '';
+
+    if (option.shortName) {
+      result = `-${option.shortName}`;
+    }
+
+    result += ` --${option.name.toString()}`;
+
+    if (option.valueName) {
+      result += ` <${option.valueName}>`;
+    }
+
+    return result.trim();
+  }
+
+  private registerCommandOption(cliCommand: cli.Command, paramsClass: { new(...args: any[]): any }, option: CommandOptionDefinition) {
+    const optionUsage = this.getOptionUsage(option);
+    const coerceValue = !option.valueName ? undefined : ((value: string) => {
+      if (option.valueName && option.type === Number) {
+        return +value;
+      } else {
+        return value;
+      }
+    });
+
+    const params = new paramsClass();
+    const defaultValue = params[option.name];
+
+    cliCommand.option(
+      optionUsage,
+      option.description,
+      coerceValue,
+      defaultValue
+    );
+  }
+
+  private getParams(
+    command: CommandDefinition<any>,
+    args: any[]
+  ) {
+    const values = getCommandValues(command.paramsClass.prototype);
+    const options = getCommandOptions(command.paramsClass.prototype);
+
+    const params: { [paramName: string]: any } = new command.paramsClass();
+    let paramIndex = 0;
+
+    for (const value of values) {
+      params[value.name] = args[paramIndex++];
+    }
+
+    const optionValues = args[paramIndex];
+    for (const option of options) {
+      params[option.name.toString()] = optionValues[option.name];
+      if (option.shortName) {
+        params[option.shortName] = optionValues[option.shortName];
+      }
+    }
+
+    return params;
+  }
+
+  private instantiateCommand(command: CommandDefinition<any>) {
+    const constructor = command.type as { new(...args: any[]): Command<any> };
+    const instance = this.iocContainer ? this.iocContainer.get(constructor) : new constructor();
+    return instance;
+  }
+
+  private registerCommand(command: CommandDefinition<any>) {
+    const values = getCommandValues(command.paramsClass.prototype);
+    const usage = `${command.name} ${this.getValuesUsage(values)}`;
+    const cliCommand = cli.command(usage);
+
+    if (command.description) {
+      cliCommand.description(command.description);
+    }
+
+    const options = getCommandOptions(command.paramsClass.prototype);
+    for (const option of options) {
+      this.registerCommandOption(cliCommand, command.paramsClass, option);
+    }
+
+    cliCommand.action(async (...args: any[]) => {
+      try {
+        const commandInstance = this.instantiateCommand(command);
+        const params = this.getParams(command, args);
+        await commandInstance.execute(params);
+      } catch (err) {
+        console.error();
+        console.error(chalk.red(err.stack || err.message || err));
+        console.error();
+        process.exit(1);
+      }
+    });
+  }
+
+  private registerCommands() {
+    const commands = getCommands();
+
+    for (const command of commands) {
+      this.registerCommand(command);
+    }
+  }
+}

src/commander.ts

@@ -0,0 +1,17 @@
+import * as meta from './metadata';
+import { CommandOptionDefinitionOptions } from './types';
+
+export const command = (name: string, paramsClass: { new(): {} }, description?: string) => (target: any) => {
+  meta.addCommand({ name, type: target, paramsClass, description });
+};
+
+export const option = (options?: CommandOptionDefinitionOptions) => ((target: any, name: string) => {
+  meta.addCommandOption(target, name, options);
+});
+
+export const value = (options?: { optional?: boolean }) => ((target: any, name: string) => {
+  meta.addCommandValue(target, {
+    name,
+    optional: !!(options && options.optional)
+  });
+});

src/decorators.ts

@@ -0,0 +1,20 @@
+import { Commander } from './commander';
+import { IocContainer } from './types';
+
+export { command, option, value } from './decorators';
+export { Command, CommandValueDefinition, CommandOptionDefinition, CommandOptionDefinitionOptions, IocContainer } from './types';
+
+const commander = new Commander();
+
+// tslint:disable-next-line:no-shadowed-variable
+export function version(version: string): Commander {
+  return commander.version(version);
+}
+
+export function ioc(container: IocContainer): Commander {
+  return commander.ioc(container);
+}
+
+export async function execute(argv?: string[]): Promise<void> {
+  return commander.execute(argv);
+}

src/index.ts

@@ -0,0 +1,46 @@
+import 'reflect-metadata';
+
+import { CommandDefinition, CommandOptionDefinition, CommandOptionDefinitionOptions, CommandValueDefinition } from './types';
+
+const metadataKeys = Object.freeze({
+  command: Symbol('command'),
+  options: Symbol('options'),
+  values: Symbol('values')
+});
+
+const commandDefinitions: Array<CommandDefinition<any>> = [];
+
+export function getCommandValues(paramsClassPrototype: any): CommandValueDefinition[] {
+  return [...(Reflect.getOwnMetadata(metadataKeys.values, paramsClassPrototype) || [])];
+}
+
+export function addCommandValue(paramsClassPrototype: any, options: Pick<CommandValueDefinition, 'name' | 'optional'>) {
+  const type = Reflect.getMetadata('design:type', paramsClassPrototype, options.name);
+  const values = getCommandValues(paramsClassPrototype);
+  values.push({ ...options, type });
+  Reflect.defineMetadata(metadataKeys.values, values, paramsClassPrototype);
+}
+
+export function getCommandOptions(paramsClassPrototype: any): CommandOptionDefinition[] {
+  return [...(Reflect.getOwnMetadata(metadataKeys.options, paramsClassPrototype) || [])];
+}
+
+export function addCommandOption(paramsClassPrototype: any, name: string, options: CommandOptionDefinitionOptions | undefined) {
+  const type = Reflect.getMetadata('design:type', paramsClassPrototype, name);
+
+  const allOptions = getCommandOptions(paramsClassPrototype);
+  allOptions.push({
+    name,
+    type,
+    ...options
+  });
+  Reflect.defineMetadata(metadataKeys.options, allOptions, paramsClassPrototype);
+}
+
+export function addCommand(command: CommandDefinition<any>) {
+  commandDefinitions.push(command);
+}
+
+export function getCommands(): Array<CommandDefinition<any>> {
+  return [...commandDefinitions];
+}

src/metadata.ts

@@ -0,0 +1,34 @@
+export interface CommandValueDefinition {
+  name: string;
+  type: typeof String | typeof Number | typeof Boolean;
+  optional: boolean;
+}
+
+export interface CommandOptionDefinition {
+  name: string;
+  shortName?: string;
+  description?: string;
+  type: typeof String | typeof Number;
+  valueName?: string;
+}
+
+export interface CommandOptionDefinitionOptions {
+  shortName?: string;
+  description?: string;
+  valueName?: string;
+}
+
+export interface CommandDefinition<TCommand> {
+  name: string;
+  type: { new(...args: any[]): TCommand };
+  paramsClass: { new(): any };
+  description?: string;
+}
+
+export interface Command<TParams> {
+  execute(params: TParams): Promise<void>;
+}
+
+export interface IocContainer {
+  get: <T>(Class: { new(...args: any[]): T }) => T;
+}

src/types.ts

@@ -1,12 +1,21 @@
 {
   "compilerOptions": {
     "declaration": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "lib": [
+      "es2015"
+    ],
     "module": "commonjs",
+    "moduleResolution": "node",
     "outDir": "./dist",
     "skipLibCheck": true,
     "strict": true
   },
   "files": [
     "./src/index.ts"
+  ],
+  "exclude": [
+    "./node_modules"
   ]
-}
+}