Merge branch 'main' into fix/coverage-errors

Author: ajitpratap0

.github/workflows/test.yml

@@ -24,6 +24,9 @@ jobs:
     - name: Build
       run: go build -v ./...
 
+    - name: Build WASM
+      run: GOOS=js GOARCH=wasm go build -o /dev/null ./wasm/
+
   test:
     name: Test
     runs-on: ${{ matrix.os }}

.golangci.yml

@@ -11,6 +11,8 @@ linters:
     - errcheck
     - govet
     - staticcheck
+    - misspell
+    - gocritic
   settings:
     errcheck:
       exclude-functions:
@@ -25,6 +27,9 @@ linters:
         - "all"
         - "-QF*"
         - "-ST*"
+    gocritic:
+      disabled-checks:
+        - ifElseChain
 
 issues:
   max-issues-per-linter: 0

cmd/gosqlx/cmd/action.go

@@ -18,6 +18,23 @@ import (
 	"github.com/ajitpratap0/GoSQLX/pkg/sql/parser"
 )
 
+// builtinRules returns all built-in lint rules. This is the single source of
+// truth — both defaultLinter() and allRules() derive from it.
+func builtinRules() []linter.Rule {
+	return []linter.Rule{
+		whitespace.NewTrailingWhitespaceRule(),           // L001
+		whitespace.NewMixedIndentationRule(),             // L002
+		whitespace.NewConsecutiveBlankLinesRule(2),       // L003
+		whitespace.NewIndentationDepthRule(10, 4),        // L004
+		whitespace.NewLongLinesRule(120),                 // L005
+		style.NewColumnAlignmentRule(),                   // L006
+		keywords.NewKeywordCaseRule(keywords.CaseUpper),  // L007
+		style.NewCommaPlacementRule(style.CommaTrailing), // L008
+		style.NewAliasingConsistencyRule(true),           // L009
+		whitespace.NewRedundantWhitespaceRule(),          // L010
+	}
+}
+
 var (
 	actionFiles    string
 	actionRules    string
@@ -293,19 +310,40 @@ type lintViolation struct {
 	Message  string
 }
 
-// defaultLinter creates a linter with standard rules.
+// defaultLinter creates a linter with all built-in rules.
 func defaultLinter() *linter.Linter {
-	return linter.New(
-		whitespace.NewTrailingWhitespaceRule(),
-		whitespace.NewMixedIndentationRule(),
-		keywords.NewKeywordCaseRule(keywords.CaseUpper),
-		style.NewColumnAlignmentRule(),
-	)
+	return linter.New(builtinRules()...)
+}
+
+// allRules returns every built-in rule keyed by its ID.
+func allRules() map[string]linter.Rule {
+	all := builtinRules()
+	m := make(map[string]linter.Rule, len(all))
+	for _, r := range all {
+		m[r.ID()] = r
+	}
+	return m
 }
 
 // lintFile runs the linter on a file and returns violations.
-func lintFile(filePath string, _ []string) []lintViolation {
-	l := defaultLinter()
+// When ruleList is non-empty only the rules whose IDs match are executed.
+func lintFile(filePath string, ruleList []string) []lintViolation {
+	var l *linter.Linter
+	if len(ruleList) == 0 {
+		l = defaultLinter()
+	} else {
+		available := allRules()
+		var selected []linter.Rule
+		for _, id := range ruleList {
+			if r, ok := available[id]; ok {
+				selected = append(selected, r)
+			}
+		}
+		if len(selected) == 0 {
+			return nil
+		}
+		l = linter.New(selected...)
+	}
 	result := l.LintFile(filePath)
 
 	if result.Error != nil {

cmd/gosqlx/cmd/action_test.go

@@ -0,0 +1,59 @@
+package cmd
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func writeTempSQL(t *testing.T, content string) string {
+	t.Helper()
+	p := filepath.Join(t.TempDir(), "test.sql")
+	if err := os.WriteFile(p, []byte(content), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	return p
+}
+
+func TestLintFile_FilterSpecificRule(t *testing.T) {
+	// Trailing whitespace triggers L001; lowercase keyword triggers L007.
+	path := writeTempSQL(t, "select 1; \n")
+
+	violations := lintFile(path, []string{"L001"})
+	if len(violations) == 0 {
+		t.Fatal("expected at least one L001 violation for trailing whitespace")
+	}
+	for _, v := range violations {
+		if !strings.Contains(v.Message, "L001") {
+			t.Errorf("expected only L001 violations, got: %s", v.Message)
+		}
+	}
+}
+
+func TestLintFile_EmptyRulesRunsAll(t *testing.T) {
+	// Trailing whitespace (L001) + lowercase keyword (L007).
+	path := writeTempSQL(t, "select 1; \n")
+
+	violations := lintFile(path, nil)
+	ruleIDs := make(map[string]bool)
+	for _, v := range violations {
+		if i := strings.Index(v.Message, "["); i >= 0 {
+			if j := strings.Index(v.Message[i:], "]"); j > 0 {
+				ruleIDs[v.Message[i+1:i+j]] = true
+			}
+		}
+	}
+	if len(ruleIDs) < 2 {
+		t.Errorf("expected violations from multiple rules, got: %v", ruleIDs)
+	}
+}
+
+func TestLintFile_InvalidRuleIgnored(t *testing.T) {
+	path := writeTempSQL(t, "SELECT 1;\n")
+
+	violations := lintFile(path, []string{"INVALID_RULE"})
+	if len(violations) != 0 {
+		t.Errorf("expected no violations for invalid rule, got %d", len(violations))
+	}
+}

cmd/gosqlx/cmd/parser_cmd.go

@@ -257,9 +257,8 @@ func (p *Parser) displayTree(astObj *ast.AST) error {
 
 		fmt.Fprintf(p.Out, "%s %s\n", prefix, stmtType)
 
-		// Add basic tree structure for different statement types
-		switch s := stmt.(type) {
-		case *ast.SelectStatement:
+		// Add basic tree structure for SELECT statements
+		if s, ok := stmt.(*ast.SelectStatement); ok {
 			if len(s.Columns) > 0 {
 				fmt.Fprintf(p.Out, "%s├── Columns (%d items)\n", childPrefix, len(s.Columns))
 			}

examples/distinct_on_example.go

@@ -82,21 +82,29 @@ func main() {
 
 func parseAndDisplay(tokens []token.Token) {
 	p := parser.NewParser()
-	defer p.Release()
 
 	astObj, err := p.Parse(tokens)
 	if err != nil {
+		p.Release()
 		log.Fatalf("Parse error: %v", err)
 	}
+
+	displayAST(p, astObj)
+}
+
+func displayAST(p *parser.Parser, astObj *ast.AST) {
+	defer p.Release()
 	defer ast.ReleaseAST(astObj)
 
 	if len(astObj.Statements) == 0 {
-		log.Fatal("No statements parsed")
+		fmt.Println("No statements parsed")
+		return
 	}
 
 	stmt, ok := astObj.Statements[0].(*ast.SelectStatement)
 	if !ok {
-		log.Fatalf("Expected SelectStatement, got %T", astObj.Statements[0])
+		fmt.Printf("Expected SelectStatement, got %T\n", astObj.Statements[0])
+		return
 	}
 
 	fmt.Println("Parsed Successfully!")

pkg/advisor/rules.go

@@ -171,7 +171,7 @@ func hasJoinCondition(expr ast.Expression, tableNames []string) bool {
 		return false
 	}
 
-	switch e := expr.(type) {
+	switch e := expr.(type) { //nolint:gocritic // singleCaseSwitch: intentional — may grow to handle more expression types
 	case *ast.BinaryExpression:
 		if e.Operator == "AND" || e.Operator == "OR" {
 			return hasJoinCondition(e.Left, tableNames) || hasJoinCondition(e.Right, tableNames)
@@ -376,7 +376,7 @@ func containsOrCondition(expr ast.Expression) bool {
 		return false
 	}
 
-	switch e := expr.(type) {
+	switch e := expr.(type) { //nolint:gocritic // singleCaseSwitch: intentional — may grow to handle more expression types
 	case *ast.BinaryExpression:
 		if strings.EqualFold(e.Operator, "OR") {
 			// Check if the OR operates on different columns

pkg/config/lsp.go

@@ -392,8 +392,7 @@ func ValidateLSPValue(section, key string, value interface{}) error {
 		}
 
 	case "gosqlx.server":
-		switch key {
-		case "logLevel":
+		if key == "logLevel" {
 			if v, ok := value.(string); ok {
 				config.Server.LogLevel = v
 			} else {

pkg/linter/rules/keywords/keyword_case.go

@@ -206,15 +206,13 @@ func tokenizeLine(line string) []wordToken {
 				wordStart = i
 			}
 			currentWord.WriteRune(ch)
-		} else {
-			if wordStart >= 0 {
-				words = append(words, wordToken{
-					text:   currentWord.String(),
-					column: wordStart + 1, // 1-indexed
-				})
-				currentWord.Reset()
-				wordStart = -1
-			}
+		} else if wordStart >= 0 {
+			words = append(words, wordToken{
+				text:   currentWord.String(),
+				column: wordStart + 1, // 1-indexed
+			})
+			currentWord.Reset()
+			wordStart = -1
 		}
 	}
 

pkg/sql/ast/ast.go

@@ -1207,6 +1207,7 @@ type UpdateStatement struct {
 }
 
 // GetUpdates returns Assignments for backward compatibility.
+//
 // Deprecated: Use Assignments directly instead.
 func (u *UpdateStatement) GetUpdates() []UpdateExpression {
 	return u.Assignments