Sign upLogin

Fs02/rel

View on GitHub
Star

Showing 34 of 45 total issues

File repository.go has 794 lines of code (exceeds 500 allowed). Consider refactoring.
Open

package rel
 
import (
    "context"
    "errors"
Severity: Major
Found in repository.go - About 1 day to fix

    Function convertAssign has 136 lines of code (exceeds 50 allowed). Consider refactoring.
    Open

    func convertAssign(dest, src interface{}) error {
        // Common cases, without reflect.
        switch s := src.(type) {
        case string:
            switch d := dest.(type) {
    Severity: Major
    Found in convert.go - About 4 hrs to fix

      FilterQuery has 32 methods (exceeds 20 allowed). Consider refactoring.
      Open

      type FilterQuery struct {
          Type  FilterOp
          Field string
          Value interface{}
          Inner []FilterQuery
      Severity: Minor
      Found in filter_query.go - About 4 hrs to fix

        Function convertAssign has a Cognitive Complexity of 39 (exceeds 20 allowed). Consider refactoring.
        Open

        func convertAssign(dest, src interface{}) error {
            // Common cases, without reflect.
            switch s := src.(type) {
            case string:
                switch d := dest.(type) {
        Severity: Minor
        Found in convert.go - About 3 hrs to fix

        Builder has 28 methods (exceeds 20 allowed). Consider refactoring.
        Open

        type Builder struct {
            config      Config
            returnField string
            count       int
        }
        Severity: Minor
        Found in adapter/sql/builder.go - About 3 hrs to fix

          Query has 25 methods (exceeds 20 allowed). Consider refactoring.
          Open

          type Query struct {
              empty         bool // TODO: use bitmask to mark what is updated and use it when merging two queries
              Table         string
              SelectQuery   SelectQuery
              JoinQuery     []JoinQuery
          Severity: Minor
          Found in query.go - About 2 hrs to fix

            Function preload has a Cognitive Complexity of 34 (exceeds 20 allowed). Consider refactoring.
            Open

            func preload(target slice, result slice, path []string) {
                type frame struct {
                    index int
                    doc   *rel.Document
                }
            Severity: Minor
            Found in reltest/preload.go - About 2 hrs to fix

            Function convertAssign has 28 return statements (exceeds 4 allowed).
            Open

            func convertAssign(dest, src interface{}) error {
                // Common cases, without reflect.
                switch s := src.(type) {
                case string:
                    switch d := dest.(type) {
            Severity: Major
            Found in convert.go - About 2 hrs to fix

              Document has 22 methods (exceeds 20 allowed). Consider refactoring.
              Open

              type Document struct {
                  v    interface{}
                  rv   reflect.Value
                  rt   reflect.Type
                  data documentData
              Severity: Minor
              Found in document.go - About 2 hrs to fix

                Method repository.saveHasMany has 77 lines of code (exceeds 50 allowed). Consider refactoring.
                Open

                func (r repository) saveHasMany(cw contextWrapper, doc *Document, mutation *Mutation, insertion bool) error {
                    for _, field := range doc.HasMany() {
                        assocMuts, changed := mutation.Assoc[field]
                        if !changed {
                            continue
                Severity: Major
                Found in repository.go - About 2 hrs to fix

                  Method repository.mapPreloadTargets has 77 lines of code (exceeds 50 allowed). Consider refactoring.
                  Open

                  func (r repository) mapPreloadTargets(sl slice, path []string) (map[interface{}][]slice, string, string, reflect.Type, documentData, bool) {
                      type frame struct {
                          index int
                          doc   *Document
                      }
                  Severity: Major
                  Found in repository.go - About 2 hrs to fix

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

                    func (a *Adapter) Rollback(ctx context.Context) error {
                        var err error
                     
                        finish := a.Instrumenter.Observe(ctx, "adapter-rollback", "rollback transaction")
                     
                     
                    Severity: Major
                    Found in adapter/sql/adapter.go and 1 other location - About 2 hrs to fix
                    adapter/sql/adapter.go on lines 201..217

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

                    func (a *Adapter) Commit(ctx context.Context) error {
                        var err error
                     
                        finish := a.Instrumenter.Observe(ctx, "adapter-commit", "commit transaction")
                     
                     
                    Severity: Major
                    Found in adapter/sql/adapter.go and 1 other location - About 2 hrs to fix
                    adapter/sql/adapter.go on lines 220..236

                    Function preload has 65 lines of code (exceeds 50 allowed). Consider refactoring.
                    Open

                    func preload(target slice, result slice, path []string) {
                        type frame struct {
                            index int
                            doc   *rel.Document
                        }
                    Severity: Minor
                    Found in reltest/preload.go - About 1 hr to fix

                      Function extractAssociationData has 59 lines of code (exceeds 50 allowed). Consider refactoring.
                      Open

                      func extractAssociationData(rt reflect.Type, index int) associationData {
                          var (
                              key = associationKey{
                                  rt:    rt,
                                  index: index,
                      Severity: Minor
                      Found in association.go - About 1 hr to fix

                        Method Map.Apply has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.
                        Open

                        func (m Map) Apply(doc *Document, mutation *Mutation) {
                            var (
                                pField = doc.PrimaryField()
                                pValue = doc.PrimaryValue()
                            )
                        Severity: Minor
                        Found in map.go - About 55 mins to fix

                        Method Changeset.applyAssocMany has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.
                        Open

                        func (c Changeset) applyAssocMany(field string, mut *Mutation) {
                            if chs, ok := c.assocMany[field]; ok {
                                var (
                                    assoc      = c.doc.Association(field)
                                    col, _     = assoc.Collection()
                        Severity: Minor
                        Found in changeset.go - About 55 mins to fix

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

                                case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
                                    u64, err := strconv.ParseUint(s, 10, dv.Type().Bits())
                                    if err != nil {
                                        // The errors that ParseUint returns have concrete type *NumError
                                        err = err.(*strconv.NumError).Err
                        Severity: Minor
                        Found in convert.go and 1 other location - About 50 mins to fix
                        convert.go on lines 141..149

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

                                case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                                    i64, err := strconv.ParseInt(s, 10, dv.Type().Bits())
                                    if err != nil {
                                        // The errors that ParseInt returns have concrete type *NumError
                                        err = err.(*strconv.NumError).Err
                        Severity: Minor
                        Found in convert.go and 1 other location - About 50 mins to fix
                        convert.go on lines 150..158

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

                                    if assocs.Type() == rel.HasMany {
                                        var (
                                            col, loaded = assocs.Collection()
                                        )
                         
                         
                        Severity: Minor
                        Found in reltest/preload.go and 1 other location - About 50 mins to fix
                        repository.go on lines 932..955
                        Severity
                        Category
                        Status
                        Source
                        Language