TypeScript Dependency Injection with CLI App.

CreateScriptController.ts

import { IBaseController } from "./IBaseController";
import { CreateScriptCtrlRequest } from "./CreateScriptCtrlRequest";
import {
  CreateScriptCtrlResponse,
  CreateScriptResponseCtrlDetail
} from "./CreateScriptCtrlResponse";
import { ICreateScriptUseCase } from "../usecase/UseCaseInterface";
import { CreateScriptRequest } from "../usecase/CreateScriptRequest";
import { injectable, inject } from "inversify";
import { TYPE } from "../common/Types";

/**
 * テストケーススクリプトを生成するユースケースのコントローラークラス
 */
@injectable()
export class CreateScriptController implements IBaseController {
  private readonly _usecase: ICreateScriptUseCase;

  constructor(@inject(TYPE.CreateScriptUseCase) usecase: ICreateScriptUseCase) {
    this._usecase = usecase;
  }

  /**
   * テストケーススクリプトを生成する
   * @param request リクエスト
   */
  run(ctrlRequest: CreateScriptCtrlRequest): CreateScriptCtrlResponse {
    // Convert Request DTO
    const request = new CreateScriptRequest();
    request.setInputFilePath(ctrlRequest.getInputFilePath());
    request.setOutputFilePath(ctrlRequest.getOutputFilePath());
    request.setSheetNames(ctrlRequest.getSheetNames());

    // Act Logic
    const response = this._usecase.generate(request);
    const responseDetail = response.getDetailList();

    // Convert Response DTO
    const ctrlResponseDetailList = responseDetail.map(detail => {
      let ctrlDetail = new CreateScriptResponseCtrlDetail();
      ctrlDetail.setCaseName(detail.getCaseName());
      ctrlDetail.setCaseNum(detail.getCaseNum());
      return ctrlDetail;
    });
    const ctrlResponse = new CreateScriptCtrlResponse();
    ctrlResponse.setStatus(response.getStatus());
    ctrlResponse.setDetailList(ctrlResponseDetailList);

    return ctrlResponse;
  }
}

CreateScriptInteractor.ts

import { ICreateScriptUseCase } from "./UseCaseInterface";
import { CreateScriptRequest } from "./CreateScriptRequest";
import {
  CreateScriptResponse,
  CreateScriptResponseDetail
} from "./CreateScriptResponse";
import { CaseScriptListBlg } from "../business/CaseScriptListBlg";
import { CaseScriptBlg } from "../business/CaseScriptBlg";
import { injectable, inject } from "inversify";
import { TYPE } from "../common/Types";

/**
 * スクリプト生成ユースケースの実装クラス
 */
@injectable()
export class CreateScriptInteractor implements ICreateScriptUseCase {
  private readonly _listBlg: CaseScriptListBlg;
  private readonly _scriptBlg: CaseScriptBlg;

  constructor(
    @inject(TYPE.CaseScriptListBlg) listBlg: CaseScriptListBlg,
    @inject(TYPE.CaseScriptBlg) scriptBlg: CaseScriptBlg
  ) {
    this._listBlg = listBlg;
    this._scriptBlg = scriptBlg;
  }

  /**
   * スクリプト生成を実行する.
   */
  generate(request: CreateScriptRequest): CreateScriptResponse {
    // テストケースのリストを生成
    const caseList = this._listBlg.createCaseList(request);
    // ケース名を元にテストケーススクリプトを生成
    this._scriptBlg.generate(request, caseList);

    // レスポンス生成
    return this._createResponse(request.getOutputFilePath(), caseList.length);
  }

  private _createResponse(path: string, num: number): CreateScriptResponse {
    let detail = new CreateScriptResponseDetail();
    detail.setCaseName(path);
    detail.setCaseNum(num);
    return new CreateScriptResponse("OK.", [detail]);
  }
}

generator.ts

import { IBaseController } from "./controller/IBaseController";
import { CreateScriptCtrlRequest } from "./controller/CreateScriptCtrlRequest";
import { list } from "./common/Helper";
import { logger } from "./common/LogUtil";
import { TYPE } from "./common/Types";
import { container } from "./common/inversify.config";

// Setup CLI settings.
declare function require(x: string): any;
const program = require("commander");
program
  .version("1.0.0")
  .option(
    "-i, --input <inputFilePath>",
    "target input I/F file name",
    (fileName: string) => "data/in/" + fileName
  )
  .option(
    "-o, --output <outputDirectoryPath>",
    "target output directory path",
    "data/out"
  )
  .option("-s, --sheets [sheetNames]", "select list of sheet names", list, [])
  .parse(process.argv);

// Resolve Dependency
const controller = container.get<IBaseController>(TYPE.CreateScriptCtrl);

// Convert UI Input --> DTO
const request = new CreateScriptCtrlRequest();
request.setInputFilePath(program.input);
request.setOutputFilePath(program.output);
request.setSheetNames(program.sheets);

// Run!!
logger.info("Start Process!");
controller.run(request);
logger.info("Finish Process!");

inversify.config.ts

import "reflect-metadata";
import { Container } from "inversify";
import { TYPE } from "./Types";
import { IBaseController } from "../controller/IBaseController";
import { CreateScriptController } from "../controller/CreateScriptController";
import { ICreateScriptUseCase } from "../usecase/UseCaseInterface";
import { CreateScriptInteractor } from "../usecase/CreateScriptInteractor";
import { CaseScriptBlg } from "../business/CaseScriptBlg";
import { CaseScriptListBlg } from "../business/CaseScriptListBlg";
import {
  ICaseListRepository,
  IScriptRepository
} from "../repository/RepositoryInterface";
import { CaseListRepository } from "../repository/CaseListRepository";
import { ScriptRepository } from "../repository/ScriptRepository";

const container = new Container();

// Controller
container
  .bind<IBaseController>(TYPE.CreateScriptCtrl)
  .to(CreateScriptController);

// UseCase
container
  .bind<ICreateScriptUseCase>(TYPE.CreateScriptUseCase)
  .to(CreateScriptInteractor);

// Business Logic
container.bind<CaseScriptListBlg>(TYPE.CaseScriptListBlg).to(CaseScriptListBlg);
container.bind<CaseScriptBlg>(TYPE.CaseScriptBlg).to(CaseScriptBlg);

// Repository
container.bind<ICaseListRepository>(TYPE.CaseListRepo).to(CaseListRepository);
container.bind<IScriptRepository>(TYPE.ScriptRepo).to(ScriptRepository);

export { container };

Types.ts

const TYPE = {
  CreateScriptUseCase: Symbol.for("CreateScriptUseCase")
};
export { TYPE };

UseCaseInterface.ts

import { CreateScriptRequest } from "./CreateScriptRequest";
import { CreateScriptResponse } from "./CreateScriptResponse";

export interface ICreateScriptUseCase {
  generate(request: CreateScriptRequest): CreateScriptResponse;
}