satanTime/ngrx-entity-relationship

View on GitHub

Showing 26 of 44 total issues

Function resolveGraphQL has a Cognitive Complexity of 59 (exceeds 10 allowed). Consider refactoring.
Open

const resolveGraphQL = (
    selector: ENTITY_SELECTOR,
    options: {
        include: Array<keyof any>;
        prefix: string;
Severity: Minor
Found in libs/ngrx-entity-relationship/graphql/src/lib/toGraphQL.ts - About 1 day to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Function relatedEntity has a Cognitive Complexity of 51 (exceeds 10 allowed). Consider refactoring.
Open

export function relatedEntity<
    STORE,
    PARENT_ENTITY,
    RELATED_ENTITY,
    RELATED_KEY_IDS extends ID_FILTER_PROPS<PARENT_ENTITY, ID_TYPES>,
Severity: Minor
Found in libs/ngrx-entity-relationship/src/lib/relatedEntity.ts - About 7 hrs to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Function childrenEntities has a Cognitive Complexity of 45 (exceeds 10 allowed). Consider refactoring.
Open

export function childrenEntities<
    STORE,
    PARENT_ENTITY,
    RELATED_ENTITY,
    RELATED_KEY_IDS extends ID_FILTER_PROPS<RELATED_ENTITY, ID_TYPES>,
Severity: Minor
Found in libs/ngrx-entity-relationship/src/lib/childrenEntities.ts - About 6 hrs to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Function toGraphQL has a Cognitive Complexity of 45 (exceeds 10 allowed). Consider refactoring.
Open

export function toGraphQL(...queries: Array<any>): string {
    const prefix = (window as any).ngrxGraphqlPrefix || '';
    let query: string | undefined = '';
    let selector: ENTITY_SELECTOR | undefined;
    let params: Record<string, any> | null | string | undefined;
Severity: Minor
Found in libs/ngrx-entity-relationship/graphql/src/lib/toGraphQL.ts - About 6 hrs to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Function childrenEntities has 119 lines of code (exceeds 25 allowed). Consider refactoring.
Open

export function childrenEntities<
    STORE,
    PARENT_ENTITY,
    RELATED_ENTITY,
    RELATED_KEY_IDS extends ID_FILTER_PROPS<RELATED_ENTITY, ID_TYPES>,
Severity: Major
Found in libs/ngrx-entity-relationship/src/lib/childrenEntities.ts - About 4 hrs to fix

    Function relatedEntity has 110 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    export function relatedEntity<
        STORE,
        PARENT_ENTITY,
        RELATED_ENTITY,
        RELATED_KEY_IDS extends ID_FILTER_PROPS<PARENT_ENTITY, ID_TYPES>,
    Severity: Major
    Found in libs/ngrx-entity-relationship/src/lib/relatedEntity.ts - About 4 hrs to fix

      Function childEntity has 89 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      export function childEntity<
          STORE,
          PARENT_ENTITY,
          RELATED_ENTITY,
          RELATED_KEY_IDS extends ID_FILTER_PROPS<RELATED_ENTITY, ID_TYPES>,
      Severity: Major
      Found in libs/ngrx-entity-relationship/src/lib/childEntity.ts - About 3 hrs to fix

        Function callback has 88 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            const callback = (
                cacheLevel: string,
                state: STORE,
                cache: CACHE<STORE>,
                source: PARENT_ENTITY,
        Severity: Major
        Found in libs/ngrx-entity-relationship/src/lib/childrenEntities.ts - About 3 hrs to fix

          Function callback has 85 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              const callback = (cacheLevel: string, state: STORE, cache: CACHE<STORE>, source: PARENT_ENTITY) => {
                  // a bit magic to relax generic types.
                  const sourceKeyIdValue = source[keyId];
                  if (!sourceKeyIdValue) {
                      return;
          Severity: Major
          Found in libs/ngrx-entity-relationship/src/lib/relatedEntity.ts - About 3 hrs to fix

            Function rootEntity has 80 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            export function rootEntity<STORE, ENTITY, TRANSFORMED>(
                featureSelector: FEATURE_SELECTOR<STORE, ENTITY>,
                guess1?: TRANSFORMER<ENTITY, TRANSFORMED> | SELECTOR_META | HANDLER_RELATED_ENTITY<STORE, ENTITY>,
                guess2?: SELECTOR_META | HANDLER_RELATED_ENTITY<STORE, ENTITY>,
            ): HANDLER_ROOT_ENTITY<STORE, ENTITY, ENTITY | TRANSFORMED, ID_TYPES> {
            Severity: Major
            Found in libs/ngrx-entity-relationship/src/lib/rootEntity.ts - About 3 hrs to fix

              Function rootEntity has a Cognitive Complexity of 27 (exceeds 10 allowed). Consider refactoring.
              Open

              export function rootEntity<STORE, ENTITY, TRANSFORMED>(
                  featureSelector: FEATURE_SELECTOR<STORE, ENTITY>,
                  guess1?: TRANSFORMER<ENTITY, TRANSFORMED> | SELECTOR_META | HANDLER_RELATED_ENTITY<STORE, ENTITY>,
                  guess2?: SELECTOR_META | HANDLER_RELATED_ENTITY<STORE, ENTITY>,
              ): HANDLER_ROOT_ENTITY<STORE, ENTITY, ENTITY | TRANSFORMED, ID_TYPES> {
              Severity: Minor
              Found in libs/ngrx-entity-relationship/src/lib/rootEntity.ts - About 3 hrs to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Function childEntity has a Cognitive Complexity of 25 (exceeds 10 allowed). Consider refactoring.
              Open

              export function childEntity<
                  STORE,
                  PARENT_ENTITY,
                  RELATED_ENTITY,
                  RELATED_KEY_IDS extends ID_FILTER_PROPS<RELATED_ENTITY, ID_TYPES>,
              Severity: Minor
              Found in libs/ngrx-entity-relationship/src/lib/childEntity.ts - About 2 hrs to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Function resolveGraphQL has 66 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              const resolveGraphQL = (
                  selector: ENTITY_SELECTOR,
                  options: {
                      include: Array<keyof any>;
                      prefix: string;
              Severity: Major
              Found in libs/ngrx-entity-relationship/graphql/src/lib/toGraphQL.ts - About 2 hrs to fix

                Function toGraphQL has 61 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                export function toGraphQL(...queries: Array<any>): string {
                    const prefix = (window as any).ngrxGraphqlPrefix || '';
                    let query: string | undefined = '';
                    let selector: ENTITY_SELECTOR | undefined;
                    let params: Record<string, any> | null | string | undefined;
                Severity: Major
                Found in libs/ngrx-entity-relationship/graphql/src/lib/toGraphQL.ts - About 2 hrs to fix

                  Function callback has 60 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      const callback = (
                          cacheLevel: string,
                          state: STORE,
                          cache: CACHE<STORE>,
                          source: PARENT_ENTITY,
                  Severity: Major
                  Found in libs/ngrx-entity-relationship/src/lib/childEntity.ts - About 2 hrs to fix

                    Function func has 51 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    export const func = (state: any, selector: ENTITY_SELECTOR, entity: any, meta?: {skipFields?: Array<keyof any>}) => {
                        if (typeof entity !== 'object') {
                            throw new Error('Entity is not an object');
                        }
                        const id = selector.idSelector(entity);
                    Severity: Major
                    Found in libs/ngrx-entity-relationship/src/lib/store/injectEntity.ts - About 2 hrs to fix

                      Function rootEntities has 48 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      export function rootEntities<STORE, ENTITY, TRANSFORMED>(
                          rootSelector: HANDLER_ROOT_ENTITY<STORE, ENTITY, TRANSFORMED, ID_TYPES>,
                      ): HANDLER_ROOT_ENTITIES<STORE, ENTITY, ENTITY | TRANSFORMED, ID_TYPES> {
                          const cacheMap = new Map<string, Array<ENTITY | TRANSFORMED>>();
                          const emptyResult: Array<ENTITY | TRANSFORMED> = [];
                      Severity: Minor
                      Found in libs/ngrx-entity-relationship/src/lib/rootEntities.ts - About 1 hr to fix

                        Function rootEntities has a Cognitive Complexity of 20 (exceeds 10 allowed). Consider refactoring.
                        Open

                        export function rootEntities<STORE, ENTITY, TRANSFORMED>(
                            rootSelector: HANDLER_ROOT_ENTITY<STORE, ENTITY, TRANSFORMED, ID_TYPES>,
                        ): HANDLER_ROOT_ENTITIES<STORE, ENTITY, ENTITY | TRANSFORMED, ID_TYPES> {
                            const cacheMap = new Map<string, Array<ENTITY | TRANSFORMED>>();
                            const emptyResult: Array<ENTITY | TRANSFORMED> = [];
                        Severity: Minor
                        Found in libs/ngrx-entity-relationship/src/lib/rootEntities.ts - About 1 hr to fix

                        Cognitive Complexity

                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                        A method's cognitive complexity is based on a few simple rules:

                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                        • Code is considered more complex for each "break in the linear flow of the code"
                        • Code is considered more complex when "flow breaking structures are nested"

                        Further reading

                        Function callback has 44 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                            const callback = (
                                state: STORE,
                                idOrSelector: undefined | null | ID_TYPES | STORE_SELECTOR<STORE, undefined | null | ID_TYPES>,
                            ) => {
                                const id = typeof idOrSelector === 'function' ? idOrSelector(state) : idOrSelector;
                        Severity: Minor
                        Found in libs/ngrx-entity-relationship/src/lib/rootEntity.ts - About 1 hr to fix

                          Function func has a Cognitive Complexity of 19 (exceeds 10 allowed). Consider refactoring.
                          Open

                          export const func = (state: any, selector: ENTITY_SELECTOR, entity: any, meta?: {skipFields?: Array<keyof any>}) => {
                              if (typeof entity !== 'object') {
                                  throw new Error('Entity is not an object');
                              }
                              const id = selector.idSelector(entity);
                          Severity: Minor
                          Found in libs/ngrx-entity-relationship/src/lib/store/injectEntity.ts - About 1 hr to fix

                          Cognitive Complexity

                          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                          A method's cognitive complexity is based on a few simple rules:

                          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                          • Code is considered more complex for each "break in the linear flow of the code"
                          • Code is considered more complex when "flow breaking structures are nested"

                          Further reading

                          Severity
                          Category
                          Status
                          Source
                          Language