fix: architect review quick wins (rules filter, WASM CI, expanded lint)

Author: Ajit Pratap Singh

.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

@@ -303,9 +303,40 @@ func defaultLinter() *linter.Linter {
 	)
 }
 
+// allRules returns every built-in rule keyed by its ID.
+func allRules() map[string]linter.Rule {
+	all := []linter.Rule{
+		whitespace.NewTrailingWhitespaceRule(),
+		whitespace.NewMixedIndentationRule(),
+		keywords.NewKeywordCaseRule(keywords.CaseUpper),
+		style.NewColumnAlignmentRule(),
+	}
+	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/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,8 +171,7 @@ func hasJoinCondition(expr ast.Expression, tableNames []string) bool {
 		return false
 	}
 
-	switch e := expr.(type) {
-	case *ast.BinaryExpression:
+	if e, ok := expr.(*ast.BinaryExpression); ok {
 		if e.Operator == "AND" || e.Operator == "OR" {
 			return hasJoinCondition(e.Left, tableNames) || hasJoinCondition(e.Right, tableNames)
 		}
@@ -376,8 +375,7 @@ func containsOrCondition(expr ast.Expression) bool {
 		return false
 	}
 
-	switch e := expr.(type) {
-	case *ast.BinaryExpression:
+	if e, ok := expr.(*ast.BinaryExpression); ok {
 		if strings.EqualFold(e.Operator, "OR") {
 			// Check if the OR operates on different columns
 			leftCols := collectColumnNames(e.Left)

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

pkg/sql/ast/value.go

@@ -256,7 +256,7 @@ const (
 	Julian
 	Microsecond
 	Microseconds
-	Millenium
+	Millenium //nolint:misspell // intentional: SQL accepts both spellings
 	Millennium
 	Millisecond
 	Milliseconds
@@ -333,8 +333,8 @@ func (d DateTimeField) String() string {
 		return "MICROSECOND"
 	case Microseconds:
 		return "MICROSECONDS"
-	case Millenium:
-		return "MILLENIUM"
+	case Millenium: //nolint:misspell // intentional: SQL accepts both spellings
+		return "MILLENIUM" //nolint:misspell // intentional: matches SQL keyword
 	case Millennium:
 		return "MILLENNIUM"
 	case Millisecond: