Fixed preload and id fields with GetPrimaryKeyName

Author: Hein

.golangci.bck.yml

@@ -0,0 +1,110 @@
+run:
+  timeout: 5m
+  tests: true
+  skip-dirs:
+    - vendor
+    - .github
+
+linters:
+  enable:
+    - errcheck
+    - gosimple
+    - govet
+    - ineffassign
+    - staticcheck
+    - unused
+    - gofmt
+    - goimports
+    - misspell
+    - gocritic
+    - revive
+    - stylecheck
+  disable:
+    - typecheck # Can cause issues with generics in some cases
+
+linters-settings:
+  errcheck:
+    check-type-assertions: false
+    check-blank: false
+
+  govet:
+    check-shadowing: false
+
+  gofmt:
+    simplify: true
+
+  goimports:
+    local-prefixes: github.com/bitechdev/ResolveSpec
+
+  gocritic:
+    enabled-checks:
+      - appendAssign
+      - assignOp
+      - boolExprSimplify
+      - builtinShadow
+      - captLocal
+      - caseOrder
+      - defaultCaseOrder
+      - dupArg
+      - dupBranchBody
+      - dupCase
+      - dupSubExpr
+      - elseif
+      - emptyFallthrough
+      - equalFold
+      - flagName
+      - ifElseChain
+      - indexAlloc
+      - initClause
+      - methodExprCall
+      - nilValReturn
+      - rangeExprCopy
+      - rangeValCopy
+      - regexpMust
+      - singleCaseSwitch
+      - sloppyLen
+      - stringXbytes
+      - switchTrue
+      - typeAssertChain
+      - typeSwitchVar
+      - underef
+      - unlabelStmt
+      - unnamedResult
+      - unnecessaryBlock
+      - weakCond
+      - yodaStyleExpr
+
+  revive:
+    rules:
+      - name: exported
+        disabled: true
+      - name: package-comments
+        disabled: true
+
+issues:
+  exclude-use-default: false
+  max-issues-per-linter: 0
+  max-same-issues: 0
+
+  # Exclude some linters from running on tests files
+  exclude-rules:
+    - path: _test\.go
+      linters:
+        - errcheck
+        - dupl
+        - gosec
+        - gocritic
+
+    # Ignore "error return value not checked" for defer statements
+    - linters:
+        - errcheck
+      text: "Error return value of .((os\\.)?std(out|err)\\..*|.*Close|.*Flush|os\\.Remove(All)?|.*print(f|ln)?|os\\.(Un)?Setenv). is not checked"
+
+    # Ignore complexity in test files
+    - path: _test\.go
+      text: "cognitive complexity|cyclomatic complexity"
+
+output:
+  format: colored-line-number
+  print-issued-lines: true
+  print-linter-name: true

pkg/common/adapters/database/bun.go

@@ -215,6 +215,40 @@ func (b *BunSelectQuery) Preload(relation string, conditions ...interface{}) com
 	return b
 }
 
+func (b *BunSelectQuery) PreloadRelation(relation string, apply ...func(common.SelectQuery) common.SelectQuery) common.SelectQuery {
+	b.query = b.query.Relation(relation, func(sq *bun.SelectQuery) *bun.SelectQuery {
+		if len(apply) == 0 {
+			return sq
+		}
+
+		// Wrap the incoming *bun.SelectQuery in our adapter
+		wrapper := &BunSelectQuery{
+			query: sq,
+			db:    b.db,
+		}
+
+		// Start with the interface value (not pointer)
+		current := common.SelectQuery(wrapper)
+
+		// Apply each function in sequence
+		for _, fn := range apply {
+			if fn != nil {
+				// Pass &current (pointer to interface variable), fn modifies and returns new interface value
+				modified := fn(current)
+				current = modified
+			}
+		}
+
+		// Extract the final *bun.SelectQuery
+		if finalBun, ok := current.(*BunSelectQuery); ok {
+			return finalBun.query
+		}
+
+		return sq // fallback
+	})
+	return b
+}
+
 func (b *BunSelectQuery) Order(order string) common.SelectQuery {
 	b.query = b.query.Order(order)
 	return b

pkg/common/adapters/database/gorm.go

@@ -197,6 +197,36 @@ func (g *GormSelectQuery) Preload(relation string, conditions ...interface{}) co
 	return g
 }
 
+func (g *GormSelectQuery) PreloadRelation(relation string, apply ...func(common.SelectQuery) common.SelectQuery) common.SelectQuery {
+	g.db = g.db.Preload(relation, func(db *gorm.DB) *gorm.DB {
+		if len(apply) == 0 {
+			return db
+		}
+
+		wrapper := &GormSelectQuery{
+			db: g.db,
+		}
+
+		current := common.SelectQuery(wrapper)
+
+		for _, fn := range apply {
+			if fn != nil {
+
+				modified := fn(current)
+				current = modified
+			}
+		}
+
+		if finalBun, ok := current.(*GormSelectQuery); ok {
+			return finalBun.db
+		}
+
+		return db // fallback
+	})
+
+	return g
+}
+
 func (g *GormSelectQuery) Order(order string) common.SelectQuery {
 	g.db = g.db.Order(order)
 	return g

pkg/common/interfaces.go

@@ -32,6 +32,7 @@ type SelectQuery interface {
 	Join(query string, args ...interface{}) SelectQuery
 	LeftJoin(query string, args ...interface{}) SelectQuery
 	Preload(relation string, conditions ...interface{}) SelectQuery
+	PreloadRelation(relation string, apply ...func(SelectQuery) SelectQuery) SelectQuery
 	Order(order string) SelectQuery
 	Limit(n int) SelectQuery
 	Offset(n int) SelectQuery

pkg/common/recursive_crud.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 
 	"github.com/bitechdev/ResolveSpec/pkg/logger"
+	"github.com/bitechdev/ResolveSpec/pkg/reflection"
 )
 
 // CRUDRequestProvider interface for models that provide CRUD request strings
@@ -248,7 +249,7 @@ func (p *NestedCUDProcessor) processUpdate(
 
 	logger.Debug("Updating %s with ID %v, data: %+v", tableName, id, data)
 
-	query := p.db.NewUpdate().Table(tableName).SetMap(data).Where("id = ?", id)
+	query := p.db.NewUpdate().Table(tableName).SetMap(data).Where(fmt.Sprintf("%s = ?", QuoteIdent(reflection.GetPrimaryKeyName(tableName))), id)
 
 	result, err := query.Exec(ctx)
 	if err != nil {
@@ -268,7 +269,7 @@ func (p *NestedCUDProcessor) processDelete(ctx context.Context, tableName string
 
 	logger.Debug("Deleting from %s with ID %v", tableName, id)
 
-	query := p.db.NewDelete().Table(tableName).Where("id = ?", id)
+	query := p.db.NewDelete().Table(tableName).Where(fmt.Sprintf("%s = ?", QuoteIdent(reflection.GetPrimaryKeyName(tableName))), id)
 
 	result, err := query.Exec(ctx)
 	if err != nil {

pkg/common/types.go

@@ -35,7 +35,9 @@ type PreloadOption struct {
 	Relation    string         `json:"relation"`
 	Columns     []string       `json:"columns"`
 	OmitColumns []string       `json:"omit_columns"`
+	Sort        []SortOption   `json:"sort"`
 	Filters     []FilterOption `json:"filters"`
+	Where       string         `json:"where"`
 	Limit       *int           `json:"limit"`
 	Offset      *int           `json:"offset"`
 	Updatable   *bool          `json:"updateable"` // if true, the relation can be updated

pkg/common/validation.go

@@ -270,3 +270,11 @@ func (v *ColumnValidator) GetValidColumns() []string {
 	}
 	return columns
 }
+
+func QuoteIdent(qualifier string) string {
+	return `"` + strings.ReplaceAll(qualifier, `"`, `""`) + `"`
+}
+
+func QuoteLiteral(value string) string {
+	return `'` + strings.ReplaceAll(value, `'`, `''`) + `'`
+}

pkg/reflection/model_utils.go

@@ -4,15 +4,31 @@ import (
 	"reflect"
 	"strings"
 
-	"github.com/bitechdev/ResolveSpec/pkg/common"
+	"github.com/bitechdev/ResolveSpec/pkg/modelregistry"
 )
 
+type PrimaryKeyNameProvider interface {
+	GetIDName() string
+}
+
 // GetPrimaryKeyName extracts the primary key column name from a model
 // It first checks if the model implements PrimaryKeyNameProvider (GetIDName method)
 // Falls back to reflection to find bun:",pk" tag, then gorm:"primaryKey" tag
 func GetPrimaryKeyName(model any) string {
+	if reflect.TypeOf(model) == nil {
+		return ""
+	}
+	//If we are given a string model name, look up the model
+	if reflect.TypeOf(model).Kind() == reflect.String {
+		name := model.(string)
+		m, err := modelregistry.GetModelByName(name)
+		if err == nil {
+			model = m
+		}
+	}
+
 	// Check if model implements PrimaryKeyNameProvider
-	if provider, ok := model.(common.PrimaryKeyNameProvider); ok {
+	if provider, ok := model.(PrimaryKeyNameProvider); ok {
 		return provider.GetIDName()
 	}
 
@@ -22,7 +38,11 @@ func GetPrimaryKeyName(model any) string {
 	}
 
 	// Fall back to GORM tag
-	return getPrimaryKeyFromReflection(model, "gorm")
+	if pkName := getPrimaryKeyFromReflection(model, "gorm"); pkName != "" {
+		return pkName
+	}
+
+	return ""
 }
 
 // GetModelColumns extracts all column names from a model using reflection