radar/twist-v2

View on GitHub
frontend/src/graphql/types.ts

Summary

Maintainability
F
1 wk
Test Coverage

File types.ts has 1101 lines of code (exceeds 250 allowed). Consider refactoring.
Open

import { gql } from '@apollo/client';
import * as Apollo from '@apollo/client';
export type Maybe<T> = T | null;
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
Severity: Major
Found in frontend/src/graphql/types.ts - About 2 days to fix

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

    export type InvitePayload = {
      readonly __typename: 'InvitePayload';
      readonly bookId?: Maybe<Scalars['ID']>;
      readonly error?: Maybe<Scalars['String']>;
      readonly userId?: Maybe<Scalars['ID']>;
    Severity: Major
    Found in frontend/src/graphql/types.ts and 1 other location - About 2 hrs to fix
    frontend/src/graphql/types.ts on lines 372..377

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 85.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

    export type RemovePayload = {
      readonly __typename: 'RemovePayload';
      readonly bookId?: Maybe<Scalars['ID']>;
      readonly error?: Maybe<Scalars['String']>;
      readonly userId?: Maybe<Scalars['ID']>;
    Severity: Major
    Found in frontend/src/graphql/types.ts and 1 other location - About 2 hrs to fix
    frontend/src/graphql/types.ts on lines 202..207

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 85.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Identical blocks of code found in 2 locations. Consider refactoring.
    Open

    export type CommentFragmentFragment = { readonly __typename: 'Comment', readonly id: string, readonly text: string, readonly createdAt: string, readonly user: { readonly __typename: 'User', readonly id: string, readonly email: string, readonly name: string } };
    Severity: Major
    Found in frontend/src/graphql/types.ts and 1 other location - About 1 hr to fix
    frontend/src/graphql/types.ts on lines 620..620

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 70.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Identical blocks of code found in 2 locations. Consider refactoring.
    Open

    export type NoteFragment = { readonly __typename: 'Note', readonly id: string, readonly number: number, readonly text: string, readonly createdAt: string, readonly state: string, readonly user: { readonly __typename: 'User', readonly id: string, readonly email: string, readonly name: string }, readonly comments: ReadonlyArray<{ readonly __typename: 'Comment', readonly id: string, readonly text: string, readonly createdAt: string, readonly user: { readonly __typename: 'User', readonly id: string, readonly email: string, readonly name: string } }> };
    Severity: Major
    Found in frontend/src/graphql/types.ts and 1 other location - About 1 hr to fix
    frontend/src/graphql/types.ts on lines 555..555

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 70.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

    export type CurrentUserQuery = { readonly __typename: 'Query', readonly currentUser?: Maybe<{ readonly __typename: 'User', readonly id: string, readonly githubLogin?: Maybe<string>, readonly email: string }> };
    Severity: Major
    Found in frontend/src/graphql/types.ts and 1 other location - About 1 hr to fix
    frontend/src/graphql/types.ts on lines 505..505

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 68.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

    export type UsersQuery = { readonly __typename: 'Query', readonly users: ReadonlyArray<{ readonly __typename: 'User', readonly id: string, readonly githubLogin?: Maybe<string>, readonly name: string }> };
    Severity: Major
    Found in frontend/src/graphql/types.ts and 1 other location - About 1 hr to fix
    frontend/src/graphql/types.ts on lines 644..644

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 68.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

    export type RemoveReaderMutation = { readonly __typename: 'Mutations', readonly removeReader: { readonly __typename: 'RemovePayload', readonly bookId?: Maybe<string>, readonly userId?: Maybe<string> } };
    Severity: Major
    Found in frontend/src/graphql/types.ts and 1 other location - About 1 hr to fix
    frontend/src/graphql/types.ts on lines 513..513

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 61.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

    export type InviteUserMutation = { readonly __typename: 'Mutations', readonly inviteUser: { readonly __typename: 'InvitePayload', readonly bookId?: Maybe<string>, readonly userId?: Maybe<string> } };
    Severity: Major
    Found in frontend/src/graphql/types.ts and 1 other location - About 1 hr to fix
    frontend/src/graphql/types.ts on lines 528..528

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 61.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

    export type BookNotesQuery = { readonly __typename: 'Query', readonly elementsWithNotes: ReadonlyArray<(
        { readonly __typename: 'Element', readonly notes: ReadonlyArray<(
          { readonly __typename: 'Note' }
          & NoteFragment
        )> }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 1 other location - About 1 hr to fix
    frontend/src/graphql/types.ts on lines 452..458

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 60.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

    export type ChapterQuery = { readonly __typename: 'Query', readonly book: { readonly __typename: 'Book', readonly title: string, readonly id: string, readonly permalink: string, readonly latestCommit: { readonly __typename: 'Commit', readonly sha: string }, readonly commit: { readonly __typename: 'Commit', readonly id: string, readonly sha: string, readonly createdAt: string, readonly branch: { readonly __typename: 'Branch', readonly name: string }, readonly chapter: { readonly __typename: 'Chapter', readonly id: string, readonly title: string, readonly position: number, readonly permalink: string, readonly part: string, readonly sections: ReadonlyArray<(
              { readonly __typename: 'Section', readonly subsections: ReadonlyArray<(
                { readonly __typename: 'Section' }
                & SectionFragmentFragment
              )> }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 1 other location - About 1 hr to fix
    frontend/src/graphql/types.ts on lines 628..634

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 60.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

    export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
    Severity: Major
    Found in frontend/src/graphql/types.ts and 1 other location - About 1 hr to fix
    frontend/src/graphql/types.ts on lines 5..5

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 55.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 2 locations. Consider refactoring.
    Open

    export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
    Severity: Major
    Found in frontend/src/graphql/types.ts and 1 other location - About 1 hr to fix
    frontend/src/graphql/types.ts on lines 6..6

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 55.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useReadersQuery(baseOptions: Apollo.QueryHookOptions<ReadersQuery, ReadersQueryVariables>) {
            return Apollo.useQuery<ReadersQuery, ReadersQueryVariables>(ReadersDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useCommentsQueryQuery(baseOptions: Apollo.QueryHookOptions<CommentsQueryQuery, CommentsQueryQueryVariables>) {
            return Apollo.useQuery<CommentsQueryQuery, CommentsQueryQueryVariables>(CommentsQueryDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useNoteQuery(baseOptions: Apollo.QueryHookOptions<NoteQuery, NoteQueryVariables>) {
            return Apollo.useQuery<NoteQuery, NoteQueryVariables>(NoteDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useBookIdTitleAndReadersQuery(baseOptions: Apollo.QueryHookOptions<BookIdTitleAndReadersQuery, BookIdTitleAndReadersQueryVariables>) {
            return Apollo.useQuery<BookIdTitleAndReadersQuery, BookIdTitleAndReadersQueryVariables>(BookIdTitleAndReadersDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useRemoveReaderMutation(baseOptions?: Apollo.MutationHookOptions<RemoveReaderMutation, RemoveReaderMutationVariables>) {
            return Apollo.useMutation<RemoveReaderMutation, RemoveReaderMutationVariables>(RemoveReaderDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useBookQuery(baseOptions: Apollo.QueryHookOptions<BookQuery, BookQueryVariables>) {
            return Apollo.useQuery<BookQuery, BookQueryVariables>(BookDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useCloseNoteMutationMutation(baseOptions?: Apollo.MutationHookOptions<CloseNoteMutationMutation, CloseNoteMutationMutationVariables>) {
            return Apollo.useMutation<CloseNoteMutationMutation, CloseNoteMutationMutationVariables>(CloseNoteMutationDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useUpdateBranchMutation(baseOptions?: Apollo.MutationHookOptions<UpdateBranchMutation, UpdateBranchMutationVariables>) {
            return Apollo.useMutation<UpdateBranchMutation, UpdateBranchMutationVariables>(UpdateBranchDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useChapterQuery(baseOptions: Apollo.QueryHookOptions<ChapterQuery, ChapterQueryVariables>) {
            return Apollo.useQuery<ChapterQuery, ChapterQueryVariables>(ChapterDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useCurrentUserQuery(baseOptions?: Apollo.QueryHookOptions<CurrentUserQuery, CurrentUserQueryVariables>) {
            return Apollo.useQuery<CurrentUserQuery, CurrentUserQueryVariables>(CurrentUserDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useLoginMutationMutation(baseOptions?: Apollo.MutationHookOptions<LoginMutationMutation, LoginMutationMutationVariables>) {
            return Apollo.useMutation<LoginMutationMutation, LoginMutationMutationVariables>(LoginMutationDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useChapterNotesQuery(baseOptions: Apollo.QueryHookOptions<ChapterNotesQuery, ChapterNotesQueryVariables>) {
            return Apollo.useQuery<ChapterNotesQuery, ChapterNotesQueryVariables>(ChapterNotesDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useAddCommentMutationMutation(baseOptions?: Apollo.MutationHookOptions<AddCommentMutationMutation, AddCommentMutationMutationVariables>) {
            return Apollo.useMutation<AddCommentMutationMutation, AddCommentMutationMutationVariables>(AddCommentMutationDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useUpdateCommentMutationMutation(baseOptions?: Apollo.MutationHookOptions<UpdateCommentMutationMutation, UpdateCommentMutationMutationVariables>) {
            return Apollo.useMutation<UpdateCommentMutationMutation, UpdateCommentMutationMutationVariables>(UpdateCommentMutationDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useUpdateNoteMutationMutation(baseOptions?: Apollo.MutationHookOptions<UpdateNoteMutationMutation, UpdateNoteMutationMutationVariables>) {
            return Apollo.useMutation<UpdateNoteMutationMutation, UpdateNoteMutationMutationVariables>(UpdateNoteMutationDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useBranchesQuery(baseOptions: Apollo.QueryHookOptions<BranchesQuery, BranchesQueryVariables>) {
            return Apollo.useQuery<BranchesQuery, BranchesQueryVariables>(BranchesDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useInviteUserMutation(baseOptions?: Apollo.MutationHookOptions<InviteUserMutation, InviteUserMutationVariables>) {
            return Apollo.useMutation<InviteUserMutation, InviteUserMutationVariables>(InviteUserDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useOpenNoteMutationMutation(baseOptions?: Apollo.MutationHookOptions<OpenNoteMutationMutation, OpenNoteMutationMutationVariables>) {
            return Apollo.useMutation<OpenNoteMutationMutation, OpenNoteMutationMutationVariables>(OpenNoteMutationDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useNoteMutationMutation(baseOptions?: Apollo.MutationHookOptions<NoteMutationMutation, NoteMutationMutationVariables>) {
            return Apollo.useMutation<NoteMutationMutation, NoteMutationMutationVariables>(NoteMutationDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useBookCurrentUserAuthorQuery(baseOptions: Apollo.QueryHookOptions<BookCurrentUserAuthorQuery, BookCurrentUserAuthorQueryVariables>) {
            return Apollo.useQuery<BookCurrentUserAuthorQuery, BookCurrentUserAuthorQueryVariables>(BookCurrentUserAuthorDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useDeleteCommentMutationMutation(baseOptions?: Apollo.MutationHookOptions<DeleteCommentMutationMutation, DeleteCommentMutationMutationVariables>) {
            return Apollo.useMutation<DeleteCommentMutationMutation, DeleteCommentMutationMutationVariables>(DeleteCommentMutationDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useNoteBookQuery(baseOptions: Apollo.QueryHookOptions<NoteBookQuery, NoteBookQueryVariables>) {
            return Apollo.useQuery<NoteBookQuery, NoteBookQueryVariables>(NoteBookDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useBookNotesQuery(baseOptions: Apollo.QueryHookOptions<BookNotesQuery, BookNotesQueryVariables>) {
            return Apollo.useQuery<BookNotesQuery, BookNotesQueryVariables>(BookNotesDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useBooksQuery(baseOptions?: Apollo.QueryHookOptions<BooksQuery, BooksQueryVariables>) {
            return Apollo.useQuery<BooksQuery, BooksQueryVariables>(BooksDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useBranchQuery(baseOptions: Apollo.QueryHookOptions<BranchQuery, BranchQueryVariables>) {
            return Apollo.useQuery<BranchQuery, BranchQueryVariables>(BranchDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1153..1155
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 26 locations. Consider refactoring.
    Open

    export function useUsersQuery(baseOptions: Apollo.QueryHookOptions<UsersQuery, UsersQueryVariables>) {
            return Apollo.useQuery<UsersQuery, UsersQueryVariables>(UsersDocument, baseOptions);
          }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 25 other locations - About 55 mins to fix
    frontend/src/graphql/types.ts on lines 792..794
    frontend/src/graphql/types.ts on lines 828..830
    frontend/src/graphql/types.ts on lines 872..874
    frontend/src/graphql/types.ts on lines 913..915
    frontend/src/graphql/types.ts on lines 1002..1004
    frontend/src/graphql/types.ts on lines 1039..1041
    frontend/src/graphql/types.ts on lines 1075..1077
    frontend/src/graphql/types.ts on lines 1118..1120
    frontend/src/graphql/types.ts on lines 1190..1192
    frontend/src/graphql/types.ts on lines 1231..1233
    frontend/src/graphql/types.ts on lines 1268..1270
    frontend/src/graphql/types.ts on lines 1303..1305
    frontend/src/graphql/types.ts on lines 1339..1341
    frontend/src/graphql/types.ts on lines 1372..1374
    frontend/src/graphql/types.ts on lines 1402..1404
    frontend/src/graphql/types.ts on lines 1437..1439
    frontend/src/graphql/types.ts on lines 1471..1473
    frontend/src/graphql/types.ts on lines 1506..1508
    frontend/src/graphql/types.ts on lines 1542..1544
    frontend/src/graphql/types.ts on lines 1577..1579
    frontend/src/graphql/types.ts on lines 1611..1613
    frontend/src/graphql/types.ts on lines 1649..1651
    frontend/src/graphql/types.ts on lines 1684..1686
    frontend/src/graphql/types.ts on lines 1719..1721
    frontend/src/graphql/types.ts on lines 1761..1763

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 54.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 15 locations. Consider refactoring.
    Open

    export function useBookLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BookQuery, BookQueryVariables>) {
              return Apollo.useLazyQuery<BookQuery, BookQueryVariables>(BookDocument, baseOptions);
            }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 14 other locations - About 50 mins to fix
    frontend/src/graphql/types.ts on lines 875..877
    frontend/src/graphql/types.ts on lines 916..918
    frontend/src/graphql/types.ts on lines 1005..1007
    frontend/src/graphql/types.ts on lines 1078..1080
    frontend/src/graphql/types.ts on lines 1121..1123
    frontend/src/graphql/types.ts on lines 1156..1158
    frontend/src/graphql/types.ts on lines 1234..1236
    frontend/src/graphql/types.ts on lines 1306..1308
    frontend/src/graphql/types.ts on lines 1405..1407
    frontend/src/graphql/types.ts on lines 1509..1511
    frontend/src/graphql/types.ts on lines 1614..1616
    frontend/src/graphql/types.ts on lines 1652..1654
    frontend/src/graphql/types.ts on lines 1687..1689
    frontend/src/graphql/types.ts on lines 1722..1724

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 52.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 15 locations. Consider refactoring.
    Open

    export function useNoteBookLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<NoteBookQuery, NoteBookQueryVariables>) {
              return Apollo.useLazyQuery<NoteBookQuery, NoteBookQueryVariables>(NoteBookDocument, baseOptions);
            }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 14 other locations - About 50 mins to fix
    frontend/src/graphql/types.ts on lines 795..797
    frontend/src/graphql/types.ts on lines 875..877
    frontend/src/graphql/types.ts on lines 916..918
    frontend/src/graphql/types.ts on lines 1005..1007
    frontend/src/graphql/types.ts on lines 1078..1080
    frontend/src/graphql/types.ts on lines 1121..1123
    frontend/src/graphql/types.ts on lines 1156..1158
    frontend/src/graphql/types.ts on lines 1234..1236
    frontend/src/graphql/types.ts on lines 1306..1308
    frontend/src/graphql/types.ts on lines 1405..1407
    frontend/src/graphql/types.ts on lines 1509..1511
    frontend/src/graphql/types.ts on lines 1652..1654
    frontend/src/graphql/types.ts on lines 1687..1689
    frontend/src/graphql/types.ts on lines 1722..1724

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 52.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 15 locations. Consider refactoring.
    Open

    export function useChapterNotesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ChapterNotesQuery, ChapterNotesQueryVariables>) {
              return Apollo.useLazyQuery<ChapterNotesQuery, ChapterNotesQueryVariables>(ChapterNotesDocument, baseOptions);
            }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 14 other locations - About 50 mins to fix
    frontend/src/graphql/types.ts on lines 795..797
    frontend/src/graphql/types.ts on lines 875..877
    frontend/src/graphql/types.ts on lines 916..918
    frontend/src/graphql/types.ts on lines 1005..1007
    frontend/src/graphql/types.ts on lines 1121..1123
    frontend/src/graphql/types.ts on lines 1156..1158
    frontend/src/graphql/types.ts on lines 1234..1236
    frontend/src/graphql/types.ts on lines 1306..1308
    frontend/src/graphql/types.ts on lines 1405..1407
    frontend/src/graphql/types.ts on lines 1509..1511
    frontend/src/graphql/types.ts on lines 1614..1616
    frontend/src/graphql/types.ts on lines 1652..1654
    frontend/src/graphql/types.ts on lines 1687..1689
    frontend/src/graphql/types.ts on lines 1722..1724

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 52.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 15 locations. Consider refactoring.
    Open

    export function useBookIdTitleAndReadersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BookIdTitleAndReadersQuery, BookIdTitleAndReadersQueryVariables>) {
              return Apollo.useLazyQuery<BookIdTitleAndReadersQuery, BookIdTitleAndReadersQueryVariables>(BookIdTitleAndReadersDocument, baseOptions);
            }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 14 other locations - About 50 mins to fix
    frontend/src/graphql/types.ts on lines 795..797
    frontend/src/graphql/types.ts on lines 875..877
    frontend/src/graphql/types.ts on lines 916..918
    frontend/src/graphql/types.ts on lines 1005..1007
    frontend/src/graphql/types.ts on lines 1078..1080
    frontend/src/graphql/types.ts on lines 1156..1158
    frontend/src/graphql/types.ts on lines 1234..1236
    frontend/src/graphql/types.ts on lines 1306..1308
    frontend/src/graphql/types.ts on lines 1405..1407
    frontend/src/graphql/types.ts on lines 1509..1511
    frontend/src/graphql/types.ts on lines 1614..1616
    frontend/src/graphql/types.ts on lines 1652..1654
    frontend/src/graphql/types.ts on lines 1687..1689
    frontend/src/graphql/types.ts on lines 1722..1724

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 52.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 15 locations. Consider refactoring.
    Open

    export function useNoteLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<NoteQuery, NoteQueryVariables>) {
              return Apollo.useLazyQuery<NoteQuery, NoteQueryVariables>(NoteDocument, baseOptions);
            }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 14 other locations - About 50 mins to fix
    frontend/src/graphql/types.ts on lines 795..797
    frontend/src/graphql/types.ts on lines 875..877
    frontend/src/graphql/types.ts on lines 916..918
    frontend/src/graphql/types.ts on lines 1005..1007
    frontend/src/graphql/types.ts on lines 1078..1080
    frontend/src/graphql/types.ts on lines 1121..1123
    frontend/src/graphql/types.ts on lines 1156..1158
    frontend/src/graphql/types.ts on lines 1234..1236
    frontend/src/graphql/types.ts on lines 1306..1308
    frontend/src/graphql/types.ts on lines 1405..1407
    frontend/src/graphql/types.ts on lines 1614..1616
    frontend/src/graphql/types.ts on lines 1652..1654
    frontend/src/graphql/types.ts on lines 1687..1689
    frontend/src/graphql/types.ts on lines 1722..1724

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 52.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 15 locations. Consider refactoring.
    Open

    export function useCommentsQueryLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CommentsQueryQuery, CommentsQueryQueryVariables>) {
              return Apollo.useLazyQuery<CommentsQueryQuery, CommentsQueryQueryVariables>(CommentsQueryDocument, baseOptions);
            }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 14 other locations - About 50 mins to fix
    frontend/src/graphql/types.ts on lines 795..797
    frontend/src/graphql/types.ts on lines 875..877
    frontend/src/graphql/types.ts on lines 916..918
    frontend/src/graphql/types.ts on lines 1005..1007
    frontend/src/graphql/types.ts on lines 1078..1080
    frontend/src/graphql/types.ts on lines 1121..1123
    frontend/src/graphql/types.ts on lines 1156..1158
    frontend/src/graphql/types.ts on lines 1234..1236
    frontend/src/graphql/types.ts on lines 1306..1308
    frontend/src/graphql/types.ts on lines 1509..1511
    frontend/src/graphql/types.ts on lines 1614..1616
    frontend/src/graphql/types.ts on lines 1652..1654
    frontend/src/graphql/types.ts on lines 1687..1689
    frontend/src/graphql/types.ts on lines 1722..1724

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 52.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 15 locations. Consider refactoring.
    Open

    export function useBooksLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BooksQuery, BooksQueryVariables>) {
              return Apollo.useLazyQuery<BooksQuery, BooksQueryVariables>(BooksDocument, baseOptions);
            }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 14 other locations - About 50 mins to fix
    frontend/src/graphql/types.ts on lines 795..797
    frontend/src/graphql/types.ts on lines 875..877
    frontend/src/graphql/types.ts on lines 916..918
    frontend/src/graphql/types.ts on lines 1005..1007
    frontend/src/graphql/types.ts on lines 1078..1080
    frontend/src/graphql/types.ts on lines 1121..1123
    frontend/src/graphql/types.ts on lines 1156..1158
    frontend/src/graphql/types.ts on lines 1234..1236
    frontend/src/graphql/types.ts on lines 1306..1308
    frontend/src/graphql/types.ts on lines 1405..1407
    frontend/src/graphql/types.ts on lines 1509..1511
    frontend/src/graphql/types.ts on lines 1614..1616
    frontend/src/graphql/types.ts on lines 1652..1654
    frontend/src/graphql/types.ts on lines 1722..1724

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 52.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 15 locations. Consider refactoring.
    Open

    export function useBranchesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BranchesQuery, BranchesQueryVariables>) {
              return Apollo.useLazyQuery<BranchesQuery, BranchesQueryVariables>(BranchesDocument, baseOptions);
            }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 14 other locations - About 50 mins to fix
    frontend/src/graphql/types.ts on lines 795..797
    frontend/src/graphql/types.ts on lines 875..877
    frontend/src/graphql/types.ts on lines 1005..1007
    frontend/src/graphql/types.ts on lines 1078..1080
    frontend/src/graphql/types.ts on lines 1121..1123
    frontend/src/graphql/types.ts on lines 1156..1158
    frontend/src/graphql/types.ts on lines 1234..1236
    frontend/src/graphql/types.ts on lines 1306..1308
    frontend/src/graphql/types.ts on lines 1405..1407
    frontend/src/graphql/types.ts on lines 1509..1511
    frontend/src/graphql/types.ts on lines 1614..1616
    frontend/src/graphql/types.ts on lines 1652..1654
    frontend/src/graphql/types.ts on lines 1687..1689
    frontend/src/graphql/types.ts on lines 1722..1724

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 52.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 15 locations. Consider refactoring.
    Open

    export function useChapterLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ChapterQuery, ChapterQueryVariables>) {
              return Apollo.useLazyQuery<ChapterQuery, ChapterQueryVariables>(ChapterDocument, baseOptions);
            }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 14 other locations - About 50 mins to fix
    frontend/src/graphql/types.ts on lines 795..797
    frontend/src/graphql/types.ts on lines 875..877
    frontend/src/graphql/types.ts on lines 916..918
    frontend/src/graphql/types.ts on lines 1078..1080
    frontend/src/graphql/types.ts on lines 1121..1123
    frontend/src/graphql/types.ts on lines 1156..1158
    frontend/src/graphql/types.ts on lines 1234..1236
    frontend/src/graphql/types.ts on lines 1306..1308
    frontend/src/graphql/types.ts on lines 1405..1407
    frontend/src/graphql/types.ts on lines 1509..1511
    frontend/src/graphql/types.ts on lines 1614..1616
    frontend/src/graphql/types.ts on lines 1652..1654
    frontend/src/graphql/types.ts on lines 1687..1689
    frontend/src/graphql/types.ts on lines 1722..1724

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 52.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 15 locations. Consider refactoring.
    Open

    export function useBranchLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BranchQuery, BranchQueryVariables>) {
              return Apollo.useLazyQuery<BranchQuery, BranchQueryVariables>(BranchDocument, baseOptions);
            }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 14 other locations - About 50 mins to fix
    frontend/src/graphql/types.ts on lines 795..797
    frontend/src/graphql/types.ts on lines 916..918
    frontend/src/graphql/types.ts on lines 1005..1007
    frontend/src/graphql/types.ts on lines 1078..1080
    frontend/src/graphql/types.ts on lines 1121..1123
    frontend/src/graphql/types.ts on lines 1156..1158
    frontend/src/graphql/types.ts on lines 1234..1236
    frontend/src/graphql/types.ts on lines 1306..1308
    frontend/src/graphql/types.ts on lines 1405..1407
    frontend/src/graphql/types.ts on lines 1509..1511
    frontend/src/graphql/types.ts on lines 1614..1616
    frontend/src/graphql/types.ts on lines 1652..1654
    frontend/src/graphql/types.ts on lines 1687..1689
    frontend/src/graphql/types.ts on lines 1722..1724

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 52.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 15 locations. Consider refactoring.
    Open

    export function useBookCurrentUserAuthorLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BookCurrentUserAuthorQuery, BookCurrentUserAuthorQueryVariables>) {
              return Apollo.useLazyQuery<BookCurrentUserAuthorQuery, BookCurrentUserAuthorQueryVariables>(BookCurrentUserAuthorDocument, baseOptions);
            }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 14 other locations - About 50 mins to fix
    frontend/src/graphql/types.ts on lines 795..797
    frontend/src/graphql/types.ts on lines 875..877
    frontend/src/graphql/types.ts on lines 916..918
    frontend/src/graphql/types.ts on lines 1005..1007
    frontend/src/graphql/types.ts on lines 1078..1080
    frontend/src/graphql/types.ts on lines 1121..1123
    frontend/src/graphql/types.ts on lines 1156..1158
    frontend/src/graphql/types.ts on lines 1234..1236
    frontend/src/graphql/types.ts on lines 1405..1407
    frontend/src/graphql/types.ts on lines 1509..1511
    frontend/src/graphql/types.ts on lines 1614..1616
    frontend/src/graphql/types.ts on lines 1652..1654
    frontend/src/graphql/types.ts on lines 1687..1689
    frontend/src/graphql/types.ts on lines 1722..1724

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 52.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 15 locations. Consider refactoring.
    Open

    export function useBookNotesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BookNotesQuery, BookNotesQueryVariables>) {
              return Apollo.useLazyQuery<BookNotesQuery, BookNotesQueryVariables>(BookNotesDocument, baseOptions);
            }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 14 other locations - About 50 mins to fix
    frontend/src/graphql/types.ts on lines 795..797
    frontend/src/graphql/types.ts on lines 875..877
    frontend/src/graphql/types.ts on lines 916..918
    frontend/src/graphql/types.ts on lines 1005..1007
    frontend/src/graphql/types.ts on lines 1078..1080
    frontend/src/graphql/types.ts on lines 1121..1123
    frontend/src/graphql/types.ts on lines 1156..1158
    frontend/src/graphql/types.ts on lines 1234..1236
    frontend/src/graphql/types.ts on lines 1306..1308
    frontend/src/graphql/types.ts on lines 1405..1407
    frontend/src/graphql/types.ts on lines 1509..1511
    frontend/src/graphql/types.ts on lines 1614..1616
    frontend/src/graphql/types.ts on lines 1687..1689
    frontend/src/graphql/types.ts on lines 1722..1724

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 52.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 15 locations. Consider refactoring.
    Open

    export function useCurrentUserLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CurrentUserQuery, CurrentUserQueryVariables>) {
              return Apollo.useLazyQuery<CurrentUserQuery, CurrentUserQueryVariables>(CurrentUserDocument, baseOptions);
            }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 14 other locations - About 50 mins to fix
    frontend/src/graphql/types.ts on lines 795..797
    frontend/src/graphql/types.ts on lines 875..877
    frontend/src/graphql/types.ts on lines 916..918
    frontend/src/graphql/types.ts on lines 1005..1007
    frontend/src/graphql/types.ts on lines 1078..1080
    frontend/src/graphql/types.ts on lines 1121..1123
    frontend/src/graphql/types.ts on lines 1156..1158
    frontend/src/graphql/types.ts on lines 1234..1236
    frontend/src/graphql/types.ts on lines 1306..1308
    frontend/src/graphql/types.ts on lines 1405..1407
    frontend/src/graphql/types.ts on lines 1509..1511
    frontend/src/graphql/types.ts on lines 1614..1616
    frontend/src/graphql/types.ts on lines 1652..1654
    frontend/src/graphql/types.ts on lines 1687..1689

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 52.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 15 locations. Consider refactoring.
    Open

    export function useUsersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<UsersQuery, UsersQueryVariables>) {
              return Apollo.useLazyQuery<UsersQuery, UsersQueryVariables>(UsersDocument, baseOptions);
            }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 14 other locations - About 50 mins to fix
    frontend/src/graphql/types.ts on lines 795..797
    frontend/src/graphql/types.ts on lines 875..877
    frontend/src/graphql/types.ts on lines 916..918
    frontend/src/graphql/types.ts on lines 1005..1007
    frontend/src/graphql/types.ts on lines 1078..1080
    frontend/src/graphql/types.ts on lines 1121..1123
    frontend/src/graphql/types.ts on lines 1234..1236
    frontend/src/graphql/types.ts on lines 1306..1308
    frontend/src/graphql/types.ts on lines 1405..1407
    frontend/src/graphql/types.ts on lines 1509..1511
    frontend/src/graphql/types.ts on lines 1614..1616
    frontend/src/graphql/types.ts on lines 1652..1654
    frontend/src/graphql/types.ts on lines 1687..1689
    frontend/src/graphql/types.ts on lines 1722..1724

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 52.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 15 locations. Consider refactoring.
    Open

    export function useReadersLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ReadersQuery, ReadersQueryVariables>) {
              return Apollo.useLazyQuery<ReadersQuery, ReadersQueryVariables>(ReadersDocument, baseOptions);
            }
    Severity: Major
    Found in frontend/src/graphql/types.ts and 14 other locations - About 50 mins to fix
    frontend/src/graphql/types.ts on lines 795..797
    frontend/src/graphql/types.ts on lines 875..877
    frontend/src/graphql/types.ts on lines 916..918
    frontend/src/graphql/types.ts on lines 1005..1007
    frontend/src/graphql/types.ts on lines 1078..1080
    frontend/src/graphql/types.ts on lines 1121..1123
    frontend/src/graphql/types.ts on lines 1156..1158
    frontend/src/graphql/types.ts on lines 1306..1308
    frontend/src/graphql/types.ts on lines 1405..1407
    frontend/src/graphql/types.ts on lines 1509..1511
    frontend/src/graphql/types.ts on lines 1614..1616
    frontend/src/graphql/types.ts on lines 1652..1654
    frontend/src/graphql/types.ts on lines 1687..1689
    frontend/src/graphql/types.ts on lines 1722..1724

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 52.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 3 locations. Consider refactoring.
    Open

    export type UpdateCommentMutationMutation = { readonly __typename: 'Mutations', readonly updateComment: { readonly __typename: 'Comment', readonly id: string, readonly text: string } };
    Severity: Major
    Found in frontend/src/graphql/types.ts and 2 other locations - About 40 mins to fix
    frontend/src/graphql/types.ts on lines 542..542
    frontend/src/graphql/types.ts on lines 601..601

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 49.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 3 locations. Consider refactoring.
    Open

    export type OpenNoteMutationMutation = { readonly __typename: 'Mutations', readonly openNote: { readonly __typename: 'Note', readonly id: string, readonly state: string } };
    Severity: Major
    Found in frontend/src/graphql/types.ts and 2 other locations - About 40 mins to fix
    frontend/src/graphql/types.ts on lines 542..542
    frontend/src/graphql/types.ts on lines 580..580

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 49.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 3 locations. Consider refactoring.
    Open

    export type CloseNoteMutationMutation = { readonly __typename: 'Mutations', readonly closeNote: { readonly __typename: 'Note', readonly id: string, readonly state: string } };
    Severity: Major
    Found in frontend/src/graphql/types.ts and 2 other locations - About 40 mins to fix
    frontend/src/graphql/types.ts on lines 580..580
    frontend/src/graphql/types.ts on lines 601..601

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 49.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Identical blocks of code found in 2 locations. Consider refactoring.
    Open

    export type MutationsSubmitNoteArgs = {
      bookPermalink: Scalars['ID'];
      elementId: Scalars['ID'];
      text: Scalars['String'];
    };
    Severity: Minor
    Found in frontend/src/graphql/types.ts and 1 other location - About 35 mins to fix
    frontend/src/graphql/types.ts on lines 470..474

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 47.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Identical blocks of code found in 2 locations. Consider refactoring.
    Open

    export type NoteMutationMutationVariables = Exact<{
      bookPermalink: Scalars['ID'];
      elementId: Scalars['ID'];
      text: Scalars['String'];
    }>;
    Severity: Minor
    Found in frontend/src/graphql/types.ts and 1 other location - About 35 mins to fix
    frontend/src/graphql/types.ts on lines 268..272

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 47.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 10 locations. Consider refactoring.
    Open

    export type InviteUserMutationVariables = Exact<{
      bookId: Scalars['ID'];
      userId: Scalars['ID'];
    }>;
    Severity: Major
    Found in frontend/src/graphql/types.ts and 9 other locations - About 30 mins to fix
    frontend/src/graphql/types.ts on lines 422..425
    frontend/src/graphql/types.ts on lines 430..433
    frontend/src/graphql/types.ts on lines 482..485
    frontend/src/graphql/types.ts on lines 522..525
    frontend/src/graphql/types.ts on lines 544..547
    frontend/src/graphql/types.ts on lines 574..577
    frontend/src/graphql/types.ts on lines 582..585
    frontend/src/graphql/types.ts on lines 603..606
    frontend/src/graphql/types.ts on lines 646..649

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 45.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 10 locations. Consider refactoring.
    Open

    export type ChapterNotesQueryVariables = Exact<{
      elementId: Scalars['String'];
      bookPermalink: Scalars['String'];
    }>;
    Severity: Major
    Found in frontend/src/graphql/types.ts and 9 other locations - About 30 mins to fix
    frontend/src/graphql/types.ts on lines 422..425
    frontend/src/graphql/types.ts on lines 430..433
    frontend/src/graphql/types.ts on lines 507..510
    frontend/src/graphql/types.ts on lines 522..525
    frontend/src/graphql/types.ts on lines 544..547
    frontend/src/graphql/types.ts on lines 574..577
    frontend/src/graphql/types.ts on lines 582..585
    frontend/src/graphql/types.ts on lines 603..606
    frontend/src/graphql/types.ts on lines 646..649

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 45.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 10 locations. Consider refactoring.
    Open

    export type UpdateNoteMutationMutationVariables = Exact<{
      id: Scalars['ID'];
      text: Scalars['String'];
    }>;
    Severity: Major
    Found in frontend/src/graphql/types.ts and 9 other locations - About 30 mins to fix
    frontend/src/graphql/types.ts on lines 422..425
    frontend/src/graphql/types.ts on lines 430..433
    frontend/src/graphql/types.ts on lines 482..485
    frontend/src/graphql/types.ts on lines 507..510
    frontend/src/graphql/types.ts on lines 522..525
    frontend/src/graphql/types.ts on lines 544..547
    frontend/src/graphql/types.ts on lines 574..577
    frontend/src/graphql/types.ts on lines 582..585
    frontend/src/graphql/types.ts on lines 646..649

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 45.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 10 locations. Consider refactoring.
    Open

    export type NoteQueryVariables = Exact<{
      bookPermalink: Scalars['String'];
      number: Scalars['Int'];
    }>;
    Severity: Major
    Found in frontend/src/graphql/types.ts and 9 other locations - About 30 mins to fix
    frontend/src/graphql/types.ts on lines 422..425
    frontend/src/graphql/types.ts on lines 430..433
    frontend/src/graphql/types.ts on lines 482..485
    frontend/src/graphql/types.ts on lines 507..510
    frontend/src/graphql/types.ts on lines 522..525
    frontend/src/graphql/types.ts on lines 544..547
    frontend/src/graphql/types.ts on lines 574..577
    frontend/src/graphql/types.ts on lines 603..606
    frontend/src/graphql/types.ts on lines 646..649

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 45.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 10 locations. Consider refactoring.
    Open

    export type BranchQueryVariables = Exact<{
      bookPermalink: Scalars['String'];
      name: Scalars['String'];
    }>;
    Severity: Major
    Found in frontend/src/graphql/types.ts and 9 other locations - About 30 mins to fix
    frontend/src/graphql/types.ts on lines 422..425
    frontend/src/graphql/types.ts on lines 482..485
    frontend/src/graphql/types.ts on lines 507..510
    frontend/src/graphql/types.ts on lines 522..525
    frontend/src/graphql/types.ts on lines 544..547
    frontend/src/graphql/types.ts on lines 574..577
    frontend/src/graphql/types.ts on lines 582..585
    frontend/src/graphql/types.ts on lines 603..606
    frontend/src/graphql/types.ts on lines 646..649

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 45.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 10 locations. Consider refactoring.
    Open

    export type RemoveReaderMutationVariables = Exact<{
      bookId: Scalars['ID'];
      userId: Scalars['ID'];
    }>;
    Severity: Major
    Found in frontend/src/graphql/types.ts and 9 other locations - About 30 mins to fix
    frontend/src/graphql/types.ts on lines 422..425
    frontend/src/graphql/types.ts on lines 430..433
    frontend/src/graphql/types.ts on lines 482..485
    frontend/src/graphql/types.ts on lines 507..510
    frontend/src/graphql/types.ts on lines 544..547
    frontend/src/graphql/types.ts on lines 574..577
    frontend/src/graphql/types.ts on lines 582..585
    frontend/src/graphql/types.ts on lines 603..606
    frontend/src/graphql/types.ts on lines 646..649

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 45.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 10 locations. Consider refactoring.
    Open

    export type LoginMutationMutationVariables = Exact<{
      email: Scalars['String'];
      password: Scalars['String'];
    }>;
    Severity: Major
    Found in frontend/src/graphql/types.ts and 9 other locations - About 30 mins to fix
    frontend/src/graphql/types.ts on lines 422..425
    frontend/src/graphql/types.ts on lines 430..433
    frontend/src/graphql/types.ts on lines 482..485
    frontend/src/graphql/types.ts on lines 507..510
    frontend/src/graphql/types.ts on lines 522..525
    frontend/src/graphql/types.ts on lines 544..547
    frontend/src/graphql/types.ts on lines 574..577
    frontend/src/graphql/types.ts on lines 582..585
    frontend/src/graphql/types.ts on lines 603..606

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 45.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 10 locations. Consider refactoring.
    Open

    export type UpdateBranchMutationVariables = Exact<{
      bookPermalink: Scalars['String'];
      branchName: Scalars['String'];
    }>;
    Severity: Major
    Found in frontend/src/graphql/types.ts and 9 other locations - About 30 mins to fix
    frontend/src/graphql/types.ts on lines 430..433
    frontend/src/graphql/types.ts on lines 482..485
    frontend/src/graphql/types.ts on lines 507..510
    frontend/src/graphql/types.ts on lines 522..525
    frontend/src/graphql/types.ts on lines 544..547
    frontend/src/graphql/types.ts on lines 574..577
    frontend/src/graphql/types.ts on lines 582..585
    frontend/src/graphql/types.ts on lines 603..606
    frontend/src/graphql/types.ts on lines 646..649

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 45.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 10 locations. Consider refactoring.
    Open

    export type AddCommentMutationMutationVariables = Exact<{
      noteId: Scalars['ID'];
      text: Scalars['String'];
    }>;
    Severity: Major
    Found in frontend/src/graphql/types.ts and 9 other locations - About 30 mins to fix
    frontend/src/graphql/types.ts on lines 422..425
    frontend/src/graphql/types.ts on lines 430..433
    frontend/src/graphql/types.ts on lines 482..485
    frontend/src/graphql/types.ts on lines 507..510
    frontend/src/graphql/types.ts on lines 522..525
    frontend/src/graphql/types.ts on lines 574..577
    frontend/src/graphql/types.ts on lines 582..585
    frontend/src/graphql/types.ts on lines 603..606
    frontend/src/graphql/types.ts on lines 646..649

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 45.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    Similar blocks of code found in 10 locations. Consider refactoring.
    Open

    export type UpdateCommentMutationMutationVariables = Exact<{
      id: Scalars['ID'];
      text: Scalars['String'];
    }>;
    Severity: Major
    Found in frontend/src/graphql/types.ts and 9 other locations - About 30 mins to fix
    frontend/src/graphql/types.ts on lines 422..425
    frontend/src/graphql/types.ts on lines 430..433
    frontend/src/graphql/types.ts on lines 482..485
    frontend/src/graphql/types.ts on lines 507..510
    frontend/src/graphql/types.ts on lines 522..525
    frontend/src/graphql/types.ts on lines 544..547
    frontend/src/graphql/types.ts on lines 582..585
    frontend/src/graphql/types.ts on lines 603..606
    frontend/src/graphql/types.ts on lines 646..649

    Duplicated Code

    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

    Tuning

    This issue has a mass of 45.

    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

    Refactorings

    Further Reading

    There are no issues that match your filters.

    Category
    Status