feat(tool): Custom scalars mapping support

Author: pablor21

README.md

@@ -1,6 +1,7 @@
 [![GoDoc](https://godoc.org/github.com/pablor21/gqlschemagen?status.svg)](https://godoc.org/github.com/pablor21/gqlschemagen)
-[![GitHub release](https://img.shields.io/github/release/pablor21/gqlschemagen.svg?v0.1.0)](https://img.shields.io/github/release/pablor21/gqlschemagen.svg?v0.1.0)
+[![GitHub release](https://img.shields.io/github/release/pablor21/gqlschemagen.svg)](https://github.com/pablor21/gqlschemagen/releases)
 [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/pablor21/gqlschemagen/master/LICENSE)
+[![Go Report Card](https://goreportcard.com/badge/github.com/pablor21/gqlschemagen)](https://goreportcard.com/report/github.com/pablor21/gqlschemagen)
 
 # GQLSchemaGen
 

generator/config.go

@@ -124,6 +124,11 @@ type Config struct {
 	// These types are always considered "in scope" and won't trigger out-of-scope warnings
 	KnownScalars []string `yaml:"known_scalars"`
 
+	// Scalars maps GraphQL scalar names to Go package types
+	// Example: Scalars["ID"] = ScalarMapping{Model: ["github.com/google/uuid.UUID"]}
+	// This allows mapping Go types like uuid.UUID to GraphQL scalars like ID
+	Scalars map[string]ScalarMapping `yaml:"scalars"`
+
 	// Auto-generation configuration
 	AutoGenerate AutoGenerateConfig `yaml:"auto_generate"`
 
@@ -200,6 +205,13 @@ type AutoGenerateConfig struct {
 	SuppressGenericTypeWarnings bool `yaml:"suppress_generic_type_warnings"`
 }
 
+// ScalarMapping maps Go types to GraphQL scalars
+type ScalarMapping struct {
+	// Model is a list of Go package paths that map to this scalar
+	// Example: ["github.com/google/uuid.UUID", "github.com/gofrs/uuid.UUID"]
+	Model []string `yaml:"model"`
+}
+
 // CLIConfig contains CLI-specific configuration
 type CLIConfig struct {
 	Watcher WatcherConfig `yaml:"watcher"`
@@ -563,3 +575,57 @@ func (c *Config) Validate() error {
 
 	return nil
 }
+
+// GetScalarForGoType returns the GraphQL scalar name for a given Go type package path
+// Returns empty string if no mapping exists
+func (c *Config) GetScalarForGoType(goTypePath string) string {
+	if c.Scalars == nil {
+		return ""
+	}
+
+	for scalarName, mapping := range c.Scalars {
+		for _, modelPath := range mapping.Model {
+			if modelPath == goTypePath {
+				return scalarName
+			}
+		}
+	}
+
+	return ""
+}
+
+// IsBuiltInScalar returns true if the scalar is a built-in GraphQL scalar
+func IsBuiltInScalar(scalarName string) bool {
+	builtIns := map[string]bool{
+		"Int":     true,
+		"Float":   true,
+		"String":  true,
+		"Boolean": true,
+		"ID":      true,
+	}
+	return builtIns[scalarName]
+}
+
+// GetUsedCustomScalars returns all custom scalar names used in scalar mappings
+// Excludes built-in GraphQL scalars (Int, Float, String, Boolean, ID) and known_scalars
+func (c *Config) GetUsedCustomScalars() []string {
+	if c.Scalars == nil {
+		return nil
+	}
+
+	// Build a set of known scalars for fast lookup
+	knownScalarSet := make(map[string]bool)
+	for _, scalar := range c.KnownScalars {
+		knownScalarSet[scalar] = true
+	}
+
+	customScalars := make([]string, 0)
+	for scalarName := range c.Scalars {
+		// Skip built-in scalars and known scalars (assumed to be defined elsewhere)
+		if !IsBuiltInScalar(scalarName) && !knownScalarSet[scalarName] {
+			customScalars = append(customScalars, scalarName)
+		}
+	}
+
+	return customScalars
+}

generator/generator.go

@@ -907,7 +907,6 @@ func (g *Generator) generateSingleFile(orders []string) (map[string]string, erro
 
 	if g.Config.SkipExisting && FileExists(outFile) {
 		slog.Info("Skipping existing file", "file", outFile)
-		fmt.Println("skip", outFile)
 		return map[string]string{}, nil
 	}
 
@@ -925,6 +924,15 @@ func (g *Generator) generateSingleFile(orders []string) (map[string]string, erro
 		Namespace:  "",
 	}
 
+	// Generate custom scalar declarations first (from scalar mappings)
+	customScalars := g.Config.GetUsedCustomScalars()
+	if len(customScalars) > 0 {
+		slog.Debug("Generating custom scalar declarations", "count", len(customScalars))
+		for _, scalarName := range customScalars {
+			fmt.Fprintf(buf, "scalar %s\n\n", scalarName)
+		}
+	}
+
 	// Generate enums first
 	slog.Debug("Generating enums", "count", len(g.P.EnumNames))
 	for _, enumName := range g.P.EnumNames {
@@ -1028,6 +1036,19 @@ func (g *Generator) generatePackageFiles(orders []string) (map[string]string, er
 		return packages[pkgPath]
 	}
 
+	// Generate custom scalar declarations that will be added to the first package file
+	var scalarDeclarations string
+	customScalars := g.Config.GetUsedCustomScalars()
+	if len(customScalars) > 0 {
+		slog.Debug("Generating custom scalar declarations", "count", len(customScalars))
+		scalarBuf := &strings.Builder{}
+		for _, scalarName := range customScalars {
+			fmt.Fprintf(scalarBuf, "scalar %s\n", scalarName)
+		}
+		scalarBuf.WriteString("\n")
+		scalarDeclarations = scalarBuf.String()
+	}
+
 	// Group enums by package
 	for _, enumName := range g.P.EnumNames {
 		enumType := g.P.EnumTypes[enumName]
@@ -1120,6 +1141,12 @@ func (g *Generator) generatePackageFiles(orders []string) (map[string]string, er
 			buf = &strings.Builder{}
 			fileContents[outFile] = buf
 			slog.Debug("Creating buffer for package file", "file", outFile, "package", pkgPath)
+
+			// Add scalar declarations to the first file created
+			if scalarDeclarations != "" {
+				buf.WriteString(scalarDeclarations)
+				scalarDeclarations = "" // Only add once
+			}
 		}
 
 		// Create generation context for this package file
@@ -1200,6 +1227,19 @@ func (g *Generator) generateMultipleFiles(orders []string) (map[string]string, e
 	// Collect all content in memory first (map of file path -> content)
 	fileContents := make(map[string]*strings.Builder)
 
+	// Generate custom scalar declarations in a dedicated file
+	customScalars := g.Config.GetUsedCustomScalars()
+	if len(customScalars) > 0 {
+		slog.Debug("Generating custom scalar declarations", "count", len(customScalars))
+		scalarFile := filepath.Join(g.Config.Output, "_scalars"+g.Config.OutputFileExtension)
+		scalarBuf := &strings.Builder{}
+		for _, scalarName := range customScalars {
+			fmt.Fprintf(scalarBuf, "scalar %s\n", scalarName)
+		}
+		scalarBuf.WriteString("\n")
+		fileContents[scalarFile] = scalarBuf
+	}
+
 	// Generate enums first
 	slog.Debug("Generating enum files", "count", len(g.P.EnumNames))
 	for _, enumName := range g.P.EnumNames {

generator/parser.go

@@ -65,6 +65,9 @@ type Parser struct {
 	pkgCache map[string]*packages.Package // dir path -> package info
 	// External types loaded on-demand (not from scanned packages)
 	ExternalTypes map[string]bool // type name -> true if loaded on-demand from external package
+	// Import paths for package aliases (e.g., "uuid" -> "github.com/google/uuid")
+	// This is per-file and gets updated during parsing
+	fileImports map[string]string // package alias/name -> import path
 }
 
 // ScannedTypeInfo stores metadata about a scanned type
@@ -95,6 +98,7 @@ func NewParser() *Parser {
 		ScannedTypes:    make(map[string]*ScannedTypeInfo),
 		pkgCache:        make(map[string]*packages.Package),
 		ExternalTypes:   make(map[string]bool),
+		fileImports:     make(map[string]string),
 	}
 }
 
@@ -159,6 +163,9 @@ func (p *Parser) parseFile(path string) error {
 	// Extract file-level namespace from comments after package declaration
 	fileNamespace := extractFileNamespace(f)
 
+	// Parse import statements to track package aliases
+	p.parseImports(f)
+
 	// First pass: collect type declarations (structs and potential enums)
 	for _, decl := range f.Decls {
 		genDecl, ok := decl.(*ast.GenDecl)
@@ -463,6 +470,39 @@ func (p *Parser) GetPackageImportPathFromFile(filePath string, pkgName string, m
 	return pkg.PkgPath
 }
 
+// parseImports extracts import statements and maps package aliases to import paths
+// Accumulates imports from all files to handle types used across different files
+func (p *Parser) parseImports(f *ast.File) {
+	for _, importSpec := range f.Imports {
+		if importSpec.Path == nil {
+			continue
+		}
+
+		// Get the import path (remove quotes)
+		importPath := strings.Trim(importSpec.Path.Value, "\"")
+
+		// Determine the package alias
+		var pkgAlias string
+		if importSpec.Name != nil {
+			// Explicit alias: import foo "github.com/bar/baz"
+			pkgAlias = importSpec.Name.Name
+			if pkgAlias == "_" || pkgAlias == "." {
+				// Skip blank imports and dot imports
+				continue
+			}
+		} else {
+			// No alias, use the last segment of the import path
+			// "github.com/google/uuid" -> "uuid"
+			parts := strings.Split(importPath, "/")
+			pkgAlias = parts[len(parts)-1]
+		}
+
+		// Store the mapping (overwrites if same alias used in different files with different imports,
+		// but that would be a package name collision anyway)
+		p.fileImports[pkgAlias] = importPath
+	}
+}
+
 // hasGqlEnumDirective checks if a GenDecl has @gqlEnum or @GqlEnum directive in its doc comments
 func hasGqlEnumDirective(decl *ast.GenDecl) bool {
 	if decl.Doc == nil {

generator/scalar_mapping_test.go

@@ -0,0 +1,140 @@
+package generator
+
+import (
+	"testing"
+)
+
+func TestScalarMapping(t *testing.T) {
+	config := &Config{
+		Scalars: map[string]ScalarMapping{
+			"ID": {
+				Model: []string{
+					"github.com/google/uuid.UUID",
+					"github.com/gofrs/uuid.UUID",
+				},
+			},
+			"DateTime": {
+				Model: []string{
+					"time.Time",
+				},
+			},
+		},
+	}
+
+	tests := []struct {
+		name         string
+		goTypePath   string
+		expectedName string
+	}{
+		{
+			name:         "Google UUID maps to ID",
+			goTypePath:   "github.com/google/uuid.UUID",
+			expectedName: "ID",
+		},
+		{
+			name:         "Gofrs UUID maps to ID",
+			goTypePath:   "github.com/gofrs/uuid.UUID",
+			expectedName: "ID",
+		},
+		{
+			name:         "time.Time maps to DateTime",
+			goTypePath:   "time.Time",
+			expectedName: "DateTime",
+		},
+		{
+			name:         "Unmapped type returns empty",
+			goTypePath:   "github.com/example/CustomType",
+			expectedName: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := config.GetScalarForGoType(tt.goTypePath)
+			if result != tt.expectedName {
+				t.Errorf("GetScalarForGoType(%q) = %q, want %q", tt.goTypePath, result, tt.expectedName)
+			}
+		})
+	}
+}
+
+func TestIsBuiltInScalar(t *testing.T) {
+	tests := []struct {
+		name       string
+		scalarName string
+		expected   bool
+	}{
+		{"Int is built-in", "Int", true},
+		{"Float is built-in", "Float", true},
+		{"String is built-in", "String", true},
+		{"Boolean is built-in", "Boolean", true},
+		{"ID is built-in", "ID", true},
+		{"DateTime is custom", "DateTime", false},
+		{"UUID is custom", "UUID", false},
+		{"JSON is custom", "JSON", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := IsBuiltInScalar(tt.scalarName)
+			if result != tt.expected {
+				t.Errorf("IsBuiltInScalar(%q) = %v, want %v", tt.scalarName, result, tt.expected)
+			}
+		})
+	}
+}
+
+func TestGetUsedCustomScalars(t *testing.T) {
+	config := &Config{
+		KnownScalars: []string{"DateTime", "Upload"},
+		Scalars: map[string]ScalarMapping{
+			"ID": {
+				Model: []string{"github.com/google/uuid.UUID"},
+			},
+			"DateTime": {
+				Model: []string{"time.Time"},
+			},
+			"Upload": {
+				Model: []string{"github.com/99designs/gqlgen/graphql.Upload"},
+			},
+			"CustomScalar": {
+				Model: []string{"github.com/example/pkg.CustomType"},
+			},
+			"Int": {
+				Model: []string{"int64"},
+			},
+		},
+	}
+
+	customScalars := config.GetUsedCustomScalars()
+
+	// Should only return CustomScalar
+	// - ID and Int are built-in GraphQL scalars
+	// - DateTime and Upload are in known_scalars
+	expectedCount := 1 // Only CustomScalar
+	if len(customScalars) != expectedCount {
+		t.Errorf("GetUsedCustomScalars() returned %d scalars, want %d. Got: %v", len(customScalars), expectedCount, customScalars)
+	}
+
+	// Check that CustomScalar is in the list
+	found := false
+	for _, scalar := range customScalars {
+		if scalar == "CustomScalar" {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Errorf("GetUsedCustomScalars() did not include 'CustomScalar'")
+	}
+
+	// Check that built-in scalars and known_scalars are not included
+	for _, scalar := range customScalars {
+		if scalar == "ID" || scalar == "Int" {
+			t.Errorf("GetUsedCustomScalars() should not include built-in scalar %q", scalar)
+		}
+		if scalar == "DateTime" || scalar == "Upload" {
+			t.Errorf("GetUsedCustomScalars() should not include known_scalar %q", scalar)
+		}
+	}
+}