fix: add check to git repos and add handling errors

#28

Author: MoonW1nd

src/constants/index.ts

@@ -31,3 +31,8 @@ export enum OPTIONS_WEEK_DAY_CODE_MAP {
     Fr = 5,
     Sa = 6,
 }
+
+export enum CommandResultCode {
+    Error = 1,
+    Success = 0,
+}

src/helpers/git/getRepositoryName.ts

@@ -1,13 +1,24 @@
 import {runCommand} from '../runCommand';
+import {CommandResultCode} from 'src/constants';
 
 /**
  * Get git repository name
  */
 const getRepositoryName = async (): Promise<string> => {
     const pathToRepo = await runCommand(`git rev-parse --show-toplevel`);
-    const repoName = await runCommand(`basename ${pathToRepo}`);
 
-    return repoName.trim();
+    if (pathToRepo.code === CommandResultCode.Success) {
+        const repoName = await runCommand(`basename ${pathToRepo.result}`);
+
+        if (repoName.code === CommandResultCode.Success) {
+            return repoName.result.trim();
+        }
+    }
+
+    /**
+     * TODO [MoonW1nd]: add debug loging
+     */
+    return 'Not detected repository name';
 };
 
 export default getRepositoryName;

src/helpers/git/getUserName.ts

@@ -1,12 +1,17 @@
 import {runCommand} from '../runCommand';
+import {CommandResultCode} from 'src/constants';
 
 /**
  * Get git repository user name from config
  */
 const getUserName = async (): Promise<string> => {
     const author = await runCommand(`git config --get user.name`);
 
-    return author.trim();
+    if (author.code === CommandResultCode.Success) {
+        return author.result.trim();
+    }
+
+    return 'Not detected user name';
 };
 
 export default getUserName;

src/helpers/runCommand.ts

@@ -1,26 +1,37 @@
 import {spawn, exec, SpawnOptionsWithoutStdio} from 'child_process';
+import {RunCommandResult} from '@project-types/common';
+import {CommandResultCode} from 'src/constants';
 
 /**
  * Run command with text output in terminal
  */
-export const runCommand = (command: string, options?: SpawnOptionsWithoutStdio): Promise<string> => {
+export const runCommand = (command: string, options?: SpawnOptionsWithoutStdio): Promise<RunCommandResult> => {
     const [commandName, ...args] = command.split(' ');
 
     return new Promise((resolve, reject) => {
         const spawnCommand = spawn(commandName, args, options);
         let result = '';
+        let errorMessage = '';
 
         spawnCommand.stdout.on('data', (data) => {
             result += data.toString();
         });
 
+        spawnCommand.stderr.on('data', (data) => {
+            errorMessage += data.toString();
+        });
+
         spawnCommand.on('error', (error) => {
             console.log('error', error);
-            reject(error);
+            reject({code: CommandResultCode.Error, error: error.message});
         });
 
         spawnCommand.on('close', (code) => {
-            resolve(result);
+            if (code) {
+                resolve({code: CommandResultCode.Error, error: errorMessage});
+            } else {
+                resolve({code: CommandResultCode.Success, result});
+            }
 
             return code;
         });

src/index.ts

@@ -4,23 +4,31 @@
  */
 import 'module-alias/register';
 
+import {yellow} from 'chalk';
+import render from 'src/services/renderData/helpers/render';
 import clear from 'clear';
 
 import resolveGitData from './services/resolveGitData';
-import {resolveOptions} from 'src/services';
+import {resolveGitRepos, resolveOptions} from 'src/services';
 import renderData from './services/renderData';
 
 const getLog = async (): Promise<void> => {
-    const options = await resolveOptions();
-    const {clearConsole} = options;
+    const isGitRepo = await resolveGitRepos();
 
-    if (clearConsole) {
-        clear();
-    }
+    if (isGitRepo) {
+        const options = await resolveOptions();
+        const {clearConsole} = options;
+
+        if (clearConsole) {
+            clear();
+        }
 
-    const gitData = await resolveGitData(options);
+        const gitData = await resolveGitData(options);
 
-    renderData(gitData, options);
+        renderData(gitData, options);
+    } else {
+        render('Not found git repository', {chalk: yellow});
+    }
 };
 
 getLog();

src/services/index.ts

@@ -1,2 +1,3 @@
 export {default as resolveGitData} from './resolveGitData';
 export {default as resolveOptions} from './resolveOptions';
+export {default as resolveGitRepos} from './resolveGitRepos';

src/services/resolveGitData/helpers/ensureBranchesCollection.ts

@@ -1,6 +1,7 @@
 import {Url} from '@project-types/aliases';
 import {BranchCollection, BranchRefType} from '@project-types/entities';
 import {runCommand} from 'src/helpers';
+import {CommandResultCode} from 'src/constants';
 
 interface ConstructRepositoryUrlParams {
     branchName: string;
@@ -33,10 +34,18 @@ const ensureBranchesCollection = async (
     repositoryUrl: Url,
 ): Promise<BranchCollection> => {
     const branchNames = Object.keys(branchCollection);
-    const remoteNames = await Promise.all(
+    const remoteNamesResults = await Promise.all(
         branchNames.map((branchName) => runCommand(`git config --get branch.${branchName}.merge`)),
     );
 
+    const remoteNames = remoteNamesResults.map((remoteNameData) => {
+        if (remoteNameData.code === CommandResultCode.Success) {
+            return remoteNameData.result;
+        }
+
+        return 'Not detected remoteName';
+    });
+
     branchNames.map((branchName, i) => {
         const {refType} = branchCollection[branchName];
         const remoteBranchName = refType === 'tag' ? branchName : remoteNames[i].replace(/^refs\/heads\//gi, '').trim();

src/services/resolveGitData/helpers/ensureCommits.ts

@@ -1,7 +1,8 @@
-import {Commit} from '@project-types/entities';
+import {Commit, BranchInfo} from '@project-types/entities';
 import {GitLogCommit} from '@project-types/gitlog';
 import {getBranchInfoByCommitHash, runCommand, getDateRangeGitLogOptions, getCommitReflog} from 'src/helpers';
 import {Options} from '@project-types/options';
+import {CommandResultCode} from 'src/constants';
 
 const ensureCommits = async (commits: GitLogCommit[], options: Options): Promise<Commit[]> => {
     const gitLogDataWithSource = await runCommand(
@@ -13,12 +14,16 @@ const ensureCommits = async (commits: GitLogCommit[], options: Options): Promise
      */
     // const reflogData = await runCommand(`git log -g --all --pretty=oneline ${getDateRangeGitLogOptions(options)}`);
 
-    const branchNames = commits.map((commit) => getBranchInfoByCommitHash(commit.hash, gitLogDataWithSource));
+    let branchNames: BranchInfo[] = [];
+
+    if (gitLogDataWithSource.code === CommandResultCode.Success) {
+        branchNames = commits.map((commit) => getBranchInfoByCommitHash(commit.hash, gitLogDataWithSource.result));
+    }
 
     return commits.map((commit, i) => ({
         ...commit,
         reflog: getCommitReflog(commit.abbrevHash, ''),
-        branchInfo: branchNames[i],
+        branchInfo: branchNames[i] || {name: 'Not detected branch name'},
     }));
 };
 

src/services/resolveGitRepos/index.ts

@@ -0,0 +1,28 @@
+import {runCommand} from 'src/helpers';
+import {red} from 'chalk';
+import {CommandResultCode} from 'src/constants';
+import render from 'src/services/renderData/helpers/render';
+
+const isNotGitRepositoryError = (message: string): boolean => /not a git repository/.test(message);
+
+const resolveGitRepos = async (): Promise<boolean> => {
+    const gitRepoResult = await runCommand('git rev-parse --git-dir');
+
+    if (gitRepoResult.code === CommandResultCode.Success) {
+        return true;
+    } else {
+        if (!isNotGitRepositoryError(gitRepoResult.error)) {
+            /**
+             * TODO [MoonW1nd]: сreate serveis for print errors ans warns
+             */
+            render(
+                `[Error]: Somthing went wrong, please contact with develpers: https://github.com/MoonW1nd/codestory/issues`,
+                {chalk: red},
+            );
+        }
+
+        return false;
+    }
+};
+
+export default resolveGitRepos;

src/types/common.ts

@@ -1,7 +1,19 @@
-import {OPTIONS_WEEK_DAY_CODE_MAP} from 'src/constants';
+import {OPTIONS_WEEK_DAY_CODE_MAP, CommandResultCode} from 'src/constants';
 
 export type WeekDayCode = '0' | '1' | '2' | '3' | '4' | '5' | '6';
 
 export type OptionsWeekDay = keyof typeof OPTIONS_WEEK_DAY_CODE_MAP;
 
 export type WorkingDayMap = Record<WeekDayCode, boolean | null>;
+
+type SuccessResult = {
+    code: CommandResultCode.Success;
+    result: string;
+};
+
+type ErrorResult = {
+    code: CommandResultCode.Error;
+    error: string;
+};
+
+export type RunCommandResult = SuccessResult | ErrorResult;