fix: remove lib from ignored folders

Author: sfelix-martins

.gitignore

@@ -6,8 +6,8 @@ node_modules/
 
 # output
 coverage
-lib
-bin
+/lib
+/bin
 
 # configuration
 /.vscode

package-lock.json

@@ -20,25 +20,20 @@
     "node": ">= 10.13.0",
     "npm": ">= 6.11.0"
   },
+  "main": "bin/fun.js",
+  "preferGlobal": true,
   "bin": {
     "fun": "bin/fun.js"
   },
   "files": [
-    "lib",
-    "bin"
+    "bin",
+    "lib"
   ],
   "scripts": {
     "build": "tsc",
-    "format": "prettier --write \"**/*.ts\"",
     "lint": "eslint 'src/**/*.ts' --fix",
     "start": "node bin/fun.js",
-    "prepublish:next": "npm run build",
-    "publish:next": "npm publish --access public --tag next",
-    "prepublish:npm": "npm run build",
-    "publish:npm": "npm publish --access public",
-    "test": "jest --config jest.config.js",
-    "test:dev": "jest --config jest.config.js --watchAll",
-    "prerelease": "npm run build"
+    "test": "jest --config jest.config.js"
   },
   "repository": {
     "type": "git",

package.json

@@ -0,0 +1,23 @@
+import { Input } from '../commands/command.input';
+
+export abstract class AbstractAction {
+  setup(this: AbstractAction): (...args: any[]) => Promise<void> {
+    return async (...args: any[]) => {
+      const inputs = this.mountInputs(...args);
+
+      try {
+        await this.handle(inputs);
+      } catch (e) {
+        process.exit(1);
+      }
+    };
+  }
+
+  public abstract handle(
+    inputs?: Input[],
+    options?: Input[],
+    extraFlags?: string[],
+  ): Promise<void>;
+
+  public abstract mountInputs(...args: any[]): Input[];
+}

src/lib/actions/abstract.action.ts

@@ -0,0 +1,86 @@
+import chalk from 'chalk';
+import { Command } from 'commander';
+import * as fs from 'fs';
+
+import { Input } from '../commands/command.input';
+import { buildProject } from '../core/project/builder/project.builder';
+import { ProjectRepository } from '../core/project/persistence/repository';
+import {
+  ADD_ACTION_SUCCESS,
+  PROJECT_ALREADY_EXISTS,
+  PROJECT_DETAILS_HELP,
+  RUN_COMMAND_HELP,
+} from '../core/ui/messages';
+import { AbstractAction } from './abstract.action';
+import { createInputsFromAlias, getProjectAlias } from './input.handler';
+
+export class AddAction extends AbstractAction {
+  constructor(private repository: ProjectRepository) {
+    super();
+  }
+
+  public mountInputs(alias: string, command: Command): Input[] {
+    const inputs = createInputsFromAlias(alias);
+    inputs.push({ name: 'path', value: command.path });
+
+    return inputs;
+  }
+
+  public async handle(inputs: Input[]) {
+    const projectAlias = getProjectAlias(inputs);
+    await this._ensureProjectDoesNotExists(projectAlias);
+
+    const projectPath = this._getProjectPath(inputs);
+    const project = await buildProject(projectAlias, projectPath);
+
+    await this.repository.create(project);
+
+    console.log(ADD_ACTION_SUCCESS(project));
+    console.log(RUN_COMMAND_HELP(project));
+  }
+
+  private async _ensureProjectDoesNotExists(
+    projectAlias: string,
+  ): Promise<void> {
+    const project = await this.repository.findOne(projectAlias);
+
+    if (!!project) {
+      const errorMessage = PROJECT_ALREADY_EXISTS(projectAlias);
+
+      console.error(errorMessage);
+      console.info(PROJECT_DETAILS_HELP(projectAlias));
+
+      throw new Error(errorMessage);
+    }
+  }
+
+  private _getProjectPath(inputs: Input[]): string {
+    const pathInput: Input = inputs.find(
+      (input) => input.name === 'path',
+    ) as Input;
+
+    if (!pathInput) {
+      throw new Error('No path found in command input');
+    }
+
+    const path = pathInput.value as string;
+
+    if (!fs.existsSync(path)) {
+      const errorMessage = `\nPath "${path}" not exists or is unacessible\n`;
+
+      console.error(chalk.red(errorMessage));
+
+      throw new Error(errorMessage);
+    }
+
+    if (!fs.lstatSync(path).isDirectory()) {
+      const errorMessage = '\nPath must be a directory\n';
+
+      console.error(chalk.red(errorMessage));
+
+      throw new Error(errorMessage);
+    }
+
+    return path;
+  }
+}

src/lib/actions/add.action.ts

@@ -0,0 +1,51 @@
+import * as inquirer from 'inquirer';
+
+import { Input } from '../commands/command.input';
+import { buildDeleteProjectConfirmationQuestion } from '../core/project/builder/questions.builder';
+import { ProjectRepository } from '../core/project/persistence/repository';
+import { Project } from '../core/project/project.entity';
+import {
+  DELETE_FAIL_JOKE,
+  NOT_CONFIRMED_DELETION,
+  PROJECT_DELETED_WITH_SUCCESS,
+  UNEXPECTED_ERROR,
+} from '../core/ui/messages';
+import { AbstractAction } from './abstract.action';
+import { createInputsFromAlias, getProjectAlias } from './input.handler';
+
+export class DeleteAction extends AbstractAction {
+  constructor(private repository: ProjectRepository) {
+    super();
+  }
+
+  public mountInputs(alias: string): Input[] {
+    return createInputsFromAlias(alias);
+  }
+
+  public async handle(inputs: Input[]) {
+    const project = await this._getProject(inputs);
+
+    const question = buildDeleteProjectConfirmationQuestion(project);
+
+    const answers = await inquirer.prompt(question);
+
+    if (!answers.shouldDelete) {
+      return console.info(NOT_CONFIRMED_DELETION);
+    }
+
+    const deleted = await this.repository.delete(project.getAlias());
+
+    if (deleted) {
+      return console.info(PROJECT_DELETED_WITH_SUCCESS(project));
+    }
+
+    console.error(UNEXPECTED_ERROR);
+    console.info(DELETE_FAIL_JOKE(project));
+  }
+
+  private async _getProject(inputs: Input[]): Promise<Project> {
+    const projectAlias = getProjectAlias(inputs);
+
+    return this.repository.findOneOrFail(projectAlias);
+  }
+}

src/lib/actions/delete.action.ts

@@ -0,0 +1,5 @@
+export * from './abstract.action';
+export * from './add.action';
+export * from './with.action';
+export * from './delete.action';
+export * from './list.action';

src/lib/actions/index.ts

@@ -0,0 +1,20 @@
+import { Input } from '../commands/command.input';
+
+export function getProjectAlias(inputs: Input[]): string {
+  const aliasInput: Input = inputs.find(
+    (input) => input.name === 'alias',
+  ) as Input;
+
+  if (!aliasInput) {
+    throw new Error('No alias found in command input');
+  }
+
+  return aliasInput.value as string;
+}
+
+export function createInputsFromAlias(alias: string): Input[] {
+  const inputs: Input[] = [];
+  inputs.push({ name: 'alias', value: alias });
+
+  return inputs;
+}

src/lib/actions/input.handler.ts

@@ -0,0 +1,32 @@
+import { Input } from '../commands/command.input';
+import { ProjectRepository } from '../core/project/persistence/repository';
+import {
+  ADD_PROJECT_HELP,
+  EMPTY_PROJECTS,
+  LIST_PROJECTS,
+  PROJECT_DETAILS_HELP,
+} from '../core/ui/messages';
+import { AbstractAction } from './abstract.action';
+
+export class ListAction extends AbstractAction {
+  constructor(private repository: ProjectRepository) {
+    super();
+  }
+
+  public mountInputs(): Input[] {
+    return [];
+  }
+
+  public async handle() {
+    const projects = await this.repository.listAll();
+
+    if (projects.length === 0) {
+      console.info(EMPTY_PROJECTS);
+      console.info(ADD_PROJECT_HELP);
+      return;
+    }
+
+    console.info(LIST_PROJECTS(projects));
+    console.info(PROJECT_DETAILS_HELP());
+  }
+}

src/lib/actions/list.action.ts

@@ -0,0 +1,52 @@
+import { Input } from '../commands/command.input';
+import { createProjectRepository } from '../core/project/persistence/repository.factory';
+import { Project } from '../core/project/project.entity';
+import { Task } from '../core/project/tasks/abstract.task';
+import {
+  TASK_EXECUTED_WITH_SUCCESS,
+  TASK_EXECUTION_FAILED,
+  TASK_EXECUTION_STARTED,
+  WITH_ACTION_DONE,
+  WITH_ACTION_STARTED,
+} from '../core/ui/messages';
+import { AbstractAction } from './abstract.action';
+import { createInputsFromAlias, getProjectAlias } from './input.handler';
+
+export class WithAction extends AbstractAction {
+  public mountInputs(alias: string): Input[] {
+    return createInputsFromAlias(alias);
+  }
+
+  public async handle(inputs: Input[]) {
+    const project = await this._getProject(inputs);
+
+    console.info(WITH_ACTION_STARTED);
+
+    const tasksExecution = project
+      .getTasks()
+      .map((task) => this._executeTask(task, project));
+
+    await Promise.all(tasksExecution);
+
+    console.info(WITH_ACTION_DONE(project));
+  }
+
+  private async _getProject(inputs: Input[]): Promise<Project> {
+    const projectAlias = getProjectAlias(inputs);
+
+    const repository = createProjectRepository();
+
+    return repository.findOneOrFail(projectAlias);
+  }
+
+  private async _executeTask(task: Task, project: Project): Promise<void> {
+    process.stdout.write(TASK_EXECUTION_STARTED(task));
+
+    const executed = await task.execute(project);
+    if (executed) {
+      process.stdout.write(TASK_EXECUTED_WITH_SUCCESS(task));
+    } else {
+      process.stdout.write(TASK_EXECUTION_FAILED(task));
+    }
+  }
+}