short-d/short

File `ChangeLogGraphQL.api.ts` has 266 lines of code (exceeds 250 allowed). Consider refactoring.
import { AuthService } from '../Auth.service';
import { EnvService } from '../Env.service';
 
import { GraphQLService, IGraphQLRequestError } from '../GraphQL.service';
import { ChangeLog } from '../../entity/ChangeLog';
import { Change } from '../../entity/Change';
import { getErrorCodes } from '../GraphQLError';
import {
  CaptchaService,
  CREATE_CHANGE,
  DELETE_CHANGE,
  UPDATE_CHANGE,
  VIEW_CHANGE_LOG
} from '../Captcha.service';
import {
  IShortGraphQLChange,
  IShortGraphQLChangeInput,
  IShortGraphQLChangeLog,
  IShortGraphQLMutation,
  IShortGraphQLQuery
} from './schema';
 
export class ChangeLogGraphQLApi {
  private readonly baseURL: string;
 
Similar blocks of code found in 2 locations. Consider refactoring.
  constructor(
    private authService: AuthService,
    private envService: EnvService,
    private captchaService: CaptchaService,
    private graphQLService: GraphQLService
  ) {
    this.baseURL = `${this.envService.getVal('GRAPHQL_API_BASE_URL')}/graphql`;
  }
 
Function `getChangeLog` has 31 lines of code (exceeds 25 allowed). Consider refactoring.
  getChangeLog(): Promise<ChangeLog> {
    const getChangeLogQuery = `
        query params($authToken: String!) {
          authQuery(authToken: $authToken) {
            changeLog {
              changes {
                id
                title
                summaryMarkdown
                releasedAt
              }
              lastViewedAt
            }
          }
        }
      `;
    const variables = { authToken: this.authService.getAuthToken() };
    return new Promise((resolve, reject) => {
      this.graphQLService
        .query<IShortGraphQLQuery>(this.baseURL, {
          query: getChangeLogQuery,
          variables: variables
        })
        .then((res: IShortGraphQLQuery) => {
          const { changeLog } = res.authQuery;
          resolve(this.parseChangeLog(changeLog));
        })
        .catch((err: IGraphQLRequestError) => {
          const errCodes = getErrorCodes(err);
          reject(errCodes[0]);
        });
    });
  }
 
Function `viewChangeLog` has 32 lines of code (exceeds 25 allowed). Consider refactoring.
  viewChangeLog(): Promise<Date> {
    const viewChangeLogMutation = `
      mutation params($authToken: String!, $captchaResponse: String!) {
        authMutation(authToken: $authToken, captchaResponse: $captchaResponse) {
          viewChangeLog
        }
      }
    `;
 
    return new Promise(async (resolve, reject) => {
      let captchaResponse;
      try {
        captchaResponse = await this.captchaService.execute(VIEW_CHANGE_LOG);
      } catch (err) {
        return reject(err);
      }
 
      const variables = {
        authToken: this.authService.getAuthToken(),
        captchaResponse: captchaResponse
      };
 
      try {
        const res: IShortGraphQLMutation = await this.graphQLService.mutate<
          IShortGraphQLMutation
        >(this.baseURL, {
          mutation: viewChangeLogMutation,
          variables: variables
        });
 
        const { viewChangeLog } = res.authMutation;
        resolve(new Date(viewChangeLog));
      } catch (err) {
        const errCodes = getErrorCodes(err);
        reject(errCodes[0]);
      }
    });
  }
 
Function `createChange` has 39 lines of code (exceeds 25 allowed). Consider refactoring.
  async createChange(title: string, summary: string): Promise<Change> {
    let captchaResponse;
Similar blocks of code found in 5 locations. Consider refactoring.
    try {
      captchaResponse = await this.captchaService.execute(CREATE_CHANGE);
    } catch (err) {
      return Promise.reject(err);
    }
 
    const createChangeMutation = `
      mutation params(
        $authToken: String!
        $captchaResponse: String!
        $change: ChangeInput!
      ) {
        authMutation(authToken: $authToken, captchaResponse: $captchaResponse) {
          createChange(change: $change) {
            id
            title
            summaryMarkdown
            releasedAt
          }
        }
      }
    `;
    const variables = {
      captchaResponse,
      authToken: this.authService.getAuthToken(),
      change: { title: title, summaryMarkdown: summary }
    };
 
    return new Promise<Change>((resolve, reject) => {
      this.graphQLService
        .mutate<IShortGraphQLMutation>(this.baseURL, {
          mutation: createChangeMutation,
          variables: variables
        })
        .then(res => resolve(this.parseChange(res.authMutation.createChange)))
        .catch(err => {
          const errCodes = getErrorCodes(err);
          reject(errCodes[0]);
        });
    });
  }
 
Function `updateChange` has 37 lines of code (exceeds 25 allowed). Consider refactoring.
  async updateChange(id: string, change: Change): Promise<void> {
    let captchaResponse;
Similar blocks of code found in 5 locations. Consider refactoring.
    try {
      captchaResponse = await this.captchaService.execute(UPDATE_CHANGE);
    } catch (err) {
      return Promise.reject(err);
    }
 
    const updateChangeMutation = `
      mutation params(
        $authToken: String!
        $captchaResponse: String!
        $id: String!
        $change: ChangeInput!
      ) {
        authMutation(authToken: $authToken, captchaResponse: $captchaResponse) {
          updateChange(id: $id, change: $change) { id }
        }
      }
    `;
    const changeInput = this.toChangeInput(change);
    const variables = {
      captchaResponse,
      id,
      change: changeInput,
      authToken: this.authService.getAuthToken()
    };
 
    return new Promise<void>((resolve, reject) => {
      this.graphQLService
        .mutate<IShortGraphQLMutation>(this.baseURL, {
          mutation: updateChangeMutation,
          variables: variables
        })
        .then(_ => resolve())
        .catch(err => {
          const errCodes = getErrorCodes(err);
          reject(errCodes[0]);
        });
    });
  }
 
Function `deleteChange` has 34 lines of code (exceeds 25 allowed). Consider refactoring.
  async deleteChange(id: string): Promise<string> {
    let captchaResponse;
Similar blocks of code found in 5 locations. Consider refactoring.
    try {
      captchaResponse = await this.captchaService.execute(DELETE_CHANGE);
    } catch (err) {
      return Promise.reject(err);
    }
 
    const deleteChangeMutation = `
      mutation params(
        $authToken: String!
        $captchaResponse: String!
        $id: String!
      ) {
        authMutation(authToken: $authToken, captchaResponse: $captchaResponse) {
          deleteChange(id: $id)
        }
      }
    `;
    const variables = {
      captchaResponse,
      authToken: this.authService.getAuthToken(),
      id
    };
 
    return new Promise<string>((resolve, reject) => {
      this.graphQLService
        .mutate<IShortGraphQLMutation>(this.baseURL, {
          mutation: deleteChangeMutation,
          variables: variables
        })
        .then(res => resolve(res.authMutation.deleteChange))
        .catch(err => {
          const errCodes = getErrorCodes(err);
          reject(errCodes[0]);
        });
    });
  }
 
  getAllChanges(): Promise<Change[]> {
    const getAllChangesQuery = `
      query params($authToken: String!) {
        authQuery(authToken: $authToken) {
          allChanges {
            id
            title
            summaryMarkdown
            releasedAt
          }
        }
      }
    `;
    const variables = { authToken: this.authService.getAuthToken() };
 
    return new Promise<Change[]>((resolve, reject) => {
      this.graphQLService
        .query<IShortGraphQLQuery>(this.baseURL, {
          query: getAllChangesQuery,
          variables: variables
        })
        .then(res => resolve(res.authQuery.allChanges.map(this.parseChange)))
        .catch(err => {
          const errCodes = getErrorCodes(err);
          reject(errCodes[0]);
        });
    });
  }
 
  private parseChangeLog(changeLog: IShortGraphQLChangeLog): ChangeLog {
    if (changeLog.lastViewedAt) {
      return {
        changes: changeLog.changes.map(this.parseChange),
        lastViewedAt: new Date(changeLog.lastViewedAt)
      };
    }
 
    return {
      changes: changeLog.changes.map(this.parseChange)
    };
  }
 
  private parseChange(change: IShortGraphQLChange): Change {
    return {
      id: change.id,
      title: change.title,
      summaryMarkdown: change.summaryMarkdown,
      releasedAt: new Date(change.releasedAt)
    };
  }
 
  private toChangeInput(change: Change): IShortGraphQLChangeInput {
    return {
      title: change.title,
      summaryMarkdown: change.summaryMarkdown
    };
  }
}