feat(writer): 🎉 Enhance model name generation and formatting

* Update model name generation to include schema name.
* Add gofmt execution after writing output files.
* Refactor relationship field naming to include schema.
* Update tests to reflect changes in model names and relationships.

pkg/writers/bun/template_data.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
+	"git.warky.dev/wdevs/relspecgo/pkg/writers"
 )
 
 // TemplateData represents the data passed to the template for code generation
@@ -111,13 +112,17 @@ func NewModelData(table *models.Table, schema string, typeMapper *TypeMapper) *M
 		tableName = schema + "." + table.Name
 	}
 
-	// Generate model name: singularize and convert to PascalCase
+	// Generate model name: Model + Schema + Table (all PascalCase)
 	singularTable := Singularize(table.Name)
-	modelName := SnakeCaseToPascalCase(singularTable)
+	tablePart := SnakeCaseToPascalCase(singularTable)
 
-	// Add "Model" prefix if not already present
-	if !hasModelPrefix(modelName) {
-		modelName = "Model" + modelName
+	// Include schema name in model name
+	var modelName string
+	if schema != "" {
+		schemaPart := SnakeCaseToPascalCase(schema)
+		modelName = "Model" + schemaPart + tablePart
+	} else {
+		modelName = "Model" + tablePart
 	}
 
 	model := &ModelData{
@@ -133,8 +138,10 @@ func NewModelData(table *models.Table, schema string, typeMapper *TypeMapper) *M
 	// Find primary key
 	for _, col := range table.Columns {
 		if col.IsPrimaryKey {
-			model.PrimaryKeyField = SnakeCaseToPascalCase(col.Name)
-			model.IDColumnName = col.Name
+			// Sanitize column name to remove backticks
+			safeName := writers.SanitizeStructTagValue(col.Name)
+			model.PrimaryKeyField = SnakeCaseToPascalCase(safeName)
+			model.IDColumnName = safeName
 			// Check if PK type is a SQL type (contains resolvespec_common or sql_types)
 			goType := typeMapper.SQLTypeToGoType(col.Type, col.NotNull)
 			model.PrimaryKeyIsSQL = strings.Contains(goType, "resolvespec_common") || strings.Contains(goType, "sql_types")
@@ -146,6 +153,8 @@ func NewModelData(table *models.Table, schema string, typeMapper *TypeMapper) *M
 	columns := sortColumns(table.Columns)
 	for _, col := range columns {
 		field := columnToField(col, table, typeMapper)
+		// Check for name collision with generated methods and rename if needed
+		field.Name = resolveFieldNameCollision(field.Name)
 		model.Fields = append(model.Fields, field)
 	}
 
@@ -154,10 +163,13 @@ func NewModelData(table *models.Table, schema string, typeMapper *TypeMapper) *M
 
 // columnToField converts a models.Column to FieldData
 func columnToField(col *models.Column, table *models.Table, typeMapper *TypeMapper) *FieldData {
-	fieldName := SnakeCaseToPascalCase(col.Name)
+	// Sanitize column name first to remove backticks before generating field name
+	safeName := writers.SanitizeStructTagValue(col.Name)
+	fieldName := SnakeCaseToPascalCase(safeName)
 	goType := typeMapper.SQLTypeToGoType(col.Type, col.NotNull)
 	bunTag := typeMapper.BuildBunTag(col, table)
-	jsonTag := col.Name // Use column name for JSON tag
+	// Use same sanitized name for JSON tag
+	jsonTag := safeName
 
 	return &FieldData{
 		Name:    fieldName,
@@ -184,9 +196,28 @@ func formatComment(description, comment string) string {
 	return comment
 }
 
-// hasModelPrefix checks if a name already has "Model" prefix
-func hasModelPrefix(name string) bool {
-	return len(name) >= 5 && name[:5] == "Model"
+// resolveFieldNameCollision checks if a field name conflicts with generated method names
+// and adds an underscore suffix if there's a collision
+func resolveFieldNameCollision(fieldName string) string {
+	// List of method names that are generated by the template
+	reservedNames := map[string]bool{
+		"TableName":     true,
+		"TableNameOnly": true,
+		"SchemaName":    true,
+		"GetID":         true,
+		"GetIDStr":      true,
+		"SetID":         true,
+		"UpdateID":      true,
+		"GetIDName":     true,
+		"GetPrefix":     true,
+	}
+
+	// Check if field name conflicts with a reserved method name
+	if reservedNames[fieldName] {
+		return fieldName + "_"
+	}
+
+	return fieldName
 }
 
 // sortColumns sorts columns by sequence, then by name

pkg/writers/bun/type_mapper.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
+	"git.warky.dev/wdevs/relspecgo/pkg/writers"
 )
 
 // TypeMapper handles type conversions between SQL and Go types for Bun
@@ -164,11 +165,14 @@ func (tm *TypeMapper) BuildBunTag(column *models.Column, table *models.Table) st
 	var parts []string
 
 	// Column name comes first (no prefix)
-	parts = append(parts, column.Name)
+	// Sanitize to remove backticks which would break struct tag syntax
+	safeName := writers.SanitizeStructTagValue(column.Name)
+	parts = append(parts, safeName)
 
 	// Add type if specified
 	if column.Type != "" {
-		typeStr := column.Type
+		// Sanitize type to remove backticks
+		typeStr := writers.SanitizeStructTagValue(column.Type)
 		if column.Length > 0 {
 			typeStr = fmt.Sprintf("%s(%d)", typeStr, column.Length)
 		} else if column.Precision > 0 {
@@ -188,7 +192,9 @@ func (tm *TypeMapper) BuildBunTag(column *models.Column, table *models.Table) st
 
 	// Default value
 	if column.Default != nil {
-		parts = append(parts, fmt.Sprintf("default:%v", column.Default))
+		// Sanitize default value to remove backticks
+		safeDefault := writers.SanitizeStructTagValue(fmt.Sprintf("%v", column.Default))
+		parts = append(parts, fmt.Sprintf("default:%s", safeDefault))
 	}
 
 	// Nullable (Bun uses nullzero for nullable fields)
@@ -263,7 +269,7 @@ func (tm *TypeMapper) NeedsFmtImport(generateGetIDStr bool) bool {
 
 // GetSQLTypesImport returns the import path for sql_types (ResolveSpec common)
 func (tm *TypeMapper) GetSQLTypesImport() string {
-	return "github.com/bitechdev/ResolveSpec/pkg/common"
+	return "github.com/bitechdev/ResolveSpec/pkg/spectypes"
 }
 
 // GetBunImport returns the import path for Bun

pkg/writers/bun/writer.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"go/format"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 
@@ -124,7 +125,16 @@ func (w *Writer) writeSingleFile(db *models.Database) error {
 	}
 
 	// Write output
-	return w.writeOutput(formatted)
+	if err := w.writeOutput(formatted); err != nil {
+		return err
+	}
+
+	// Run go fmt on the output file
+	if w.options.OutputPath != "" {
+		w.runGoFmt(w.options.OutputPath)
+	}
+
+	return nil
 }
 
 // writeMultiFile writes each table to a separate file
@@ -217,6 +227,9 @@ func (w *Writer) writeMultiFile(db *models.Database) error {
 			if err := os.WriteFile(filepath, []byte(formatted), 0644); err != nil {
 				return fmt.Errorf("failed to write file %s: %w", filename, err)
 			}
+
+			// Run go fmt on the generated file
+			w.runGoFmt(filepath)
 		}
 	}
 
@@ -225,6 +238,9 @@ func (w *Writer) writeMultiFile(db *models.Database) error {
 
 // addRelationshipFields adds relationship fields to the model based on foreign keys
 func (w *Writer) addRelationshipFields(modelData *ModelData, table *models.Table, schema *models.Schema, db *models.Database) {
+	// Track used field names to detect duplicates
+	usedFieldNames := make(map[string]int)
+
 	// For each foreign key in this table, add a belongs-to/has-one relationship
 	for _, constraint := range table.Constraints {
 		if constraint.Type != models.ForeignKeyConstraint {
@@ -238,8 +254,9 @@ func (w *Writer) addRelationshipFields(modelData *ModelData, table *models.Table
 		}
 
 		// Create relationship field (has-one in Bun, similar to belongs-to in GORM)
-		refModelName := w.getModelName(constraint.ReferencedTable)
-		fieldName := w.generateRelationshipFieldName(constraint.ReferencedTable)
+		refModelName := w.getModelName(constraint.ReferencedSchema, constraint.ReferencedTable)
+		fieldName := w.generateHasOneFieldName(constraint)
+		fieldName = w.ensureUniqueFieldName(fieldName, usedFieldNames)
 		relationTag := w.typeMapper.BuildRelationshipTag(constraint, "has-one")
 
 		modelData.AddRelationshipField(&FieldData{
@@ -266,8 +283,9 @@ func (w *Writer) addRelationshipFields(modelData *ModelData, table *models.Table
 				// Check if this constraint references our table
 				if constraint.ReferencedTable == table.Name && constraint.ReferencedSchema == schema.Name {
 					// Add has-many relationship
-					otherModelName := w.getModelName(otherTable.Name)
-					fieldName := w.generateRelationshipFieldName(otherTable.Name) + "s" // Pluralize
+					otherModelName := w.getModelName(otherSchema.Name, otherTable.Name)
+					fieldName := w.generateHasManyFieldName(constraint, otherSchema.Name, otherTable.Name)
+					fieldName = w.ensureUniqueFieldName(fieldName, usedFieldNames)
 					relationTag := w.typeMapper.BuildRelationshipTag(constraint, "has-many")
 
 					modelData.AddRelationshipField(&FieldData{
@@ -298,22 +316,77 @@ func (w *Writer) findTable(schemaName, tableName string, db *models.Database) *m
 	return nil
 }
 
-// getModelName generates the model name from a table name
-func (w *Writer) getModelName(tableName string) string {
+// getModelName generates the model name from schema and table name
+func (w *Writer) getModelName(schemaName, tableName string) string {
 	singular := Singularize(tableName)
-	modelName := SnakeCaseToPascalCase(singular)
+	tablePart := SnakeCaseToPascalCase(singular)
 
-	if !hasModelPrefix(modelName) {
-		modelName = "Model" + modelName
+	// Include schema name in model name
+	var modelName string
+	if schemaName != "" {
+		schemaPart := SnakeCaseToPascalCase(schemaName)
+		modelName = "Model" + schemaPart + tablePart
+	} else {
+		modelName = "Model" + tablePart
 	}
 
 	return modelName
 }
 
-// generateRelationshipFieldName generates a field name for a relationship
-func (w *Writer) generateRelationshipFieldName(tableName string) string {
-	// Use just the prefix (3 letters) for relationship fields
-	return GeneratePrefix(tableName)
+// generateHasOneFieldName generates a field name for has-one relationships
+// Uses the foreign key column name for uniqueness
+func (w *Writer) generateHasOneFieldName(constraint *models.Constraint) string {
+	// Use the foreign key column name to ensure uniqueness
+	// If there are multiple columns, use the first one
+	if len(constraint.Columns) > 0 {
+		columnName := constraint.Columns[0]
+		// Convert to PascalCase for proper Go field naming
+		// e.g., "rid_filepointer_request" -> "RelRIDFilepointerRequest"
+		return "Rel" + SnakeCaseToPascalCase(columnName)
+	}
+
+	// Fallback to table-based prefix if no columns defined
+	return "Rel" + GeneratePrefix(constraint.ReferencedTable)
+}
+
+// generateHasManyFieldName generates a field name for has-many relationships
+// Uses the foreign key column name + source table name to avoid duplicates
+func (w *Writer) generateHasManyFieldName(constraint *models.Constraint, sourceSchemaName, sourceTableName string) string {
+	// For has-many, we need to include the source table name to avoid duplicates
+	// e.g., multiple tables referencing the same column on this table
+	if len(constraint.Columns) > 0 {
+		columnName := constraint.Columns[0]
+		// Get the model name for the source table (pluralized)
+		sourceModelName := w.getModelName(sourceSchemaName, sourceTableName)
+		// Remove "Model" prefix if present
+		sourceModelName = strings.TrimPrefix(sourceModelName, "Model")
+
+		// Convert column to PascalCase and combine with source table
+		// e.g., "rid_api_provider" + "Login" -> "RelRIDAPIProviderLogins"
+		columnPart := SnakeCaseToPascalCase(columnName)
+		return "Rel" + columnPart + Pluralize(sourceModelName)
+	}
+
+	// Fallback to table-based naming
+	sourceModelName := w.getModelName(sourceSchemaName, sourceTableName)
+	sourceModelName = strings.TrimPrefix(sourceModelName, "Model")
+	return "Rel" + Pluralize(sourceModelName)
+}
+
+// ensureUniqueFieldName ensures a field name is unique by adding numeric suffixes if needed
+func (w *Writer) ensureUniqueFieldName(fieldName string, usedNames map[string]int) string {
+	originalName := fieldName
+	count := usedNames[originalName]
+
+	if count > 0 {
+		// Name is already used, add numeric suffix
+		fieldName = fmt.Sprintf("%s%d", originalName, count+1)
+	}
+
+	// Increment the counter for this base name
+	usedNames[originalName]++
+
+	return fieldName
 }
 
 // getPackageName returns the package name from options or defaults to "models"
@@ -344,6 +417,15 @@ func (w *Writer) writeOutput(content string) error {
 	return nil
 }
 
+// runGoFmt runs go fmt on the specified file
+func (w *Writer) runGoFmt(filepath string) {
+	cmd := exec.Command("gofmt", "-w", filepath)
+	if err := cmd.Run(); err != nil {
+		// Don't fail the whole operation if gofmt fails, just warn
+		fmt.Fprintf(os.Stderr, "Warning: failed to run gofmt on %s: %v\n", filepath, err)
+	}
+}
+
 // shouldUseMultiFile determines whether to use multi-file mode based on metadata or output path
 func (w *Writer) shouldUseMultiFile() bool {
 	// Check if multi_file is explicitly set in metadata

pkg/writers/bun/writer_test.go

@@ -66,7 +66,7 @@ func TestWriter_WriteTable(t *testing.T) {
 	// Verify key elements are present
 	expectations := []string{
 		"package models",
-		"type ModelUser struct",
+		"type ModelPublicUser struct",
 		"bun.BaseModel",
 		"table:public.users",
 		"alias:users",
@@ -78,9 +78,9 @@ func TestWriter_WriteTable(t *testing.T) {
 		"resolvespec_common.SqlTime",
 		"bun:\"id",
 		"bun:\"email",
-		"func (m ModelUser) TableName() string",
+		"func (m ModelPublicUser) TableName() string",
 		"return \"public.users\"",
-		"func (m ModelUser) GetID() int64",
+		"func (m ModelPublicUser) GetID() int64",
 	}
 
 	for _, expected := range expectations {
@@ -175,12 +175,378 @@ func TestWriter_WriteDatabase_MultiFile(t *testing.T) {
 	postsStr := string(postsContent)
 
 	// Verify relationship is present with Bun format
-	if !strings.Contains(postsStr, "USE") {
-		t.Errorf("Missing relationship field USE")
+	// Should now be RelUserID (has-one) instead of USE
+	if !strings.Contains(postsStr, "RelUserID") {
+		t.Errorf("Missing relationship field RelUserID (new naming convention)")
 	}
 	if !strings.Contains(postsStr, "rel:has-one") {
 		t.Errorf("Missing Bun relationship tag: %s", postsStr)
 	}
+
+	// Check users file contains has-many relationship
+	usersContent, err := os.ReadFile(filepath.Join(tmpDir, "sql_public_users.go"))
+	if err != nil {
+		t.Fatalf("Failed to read users file: %v", err)
+	}
+
+	usersStr := string(usersContent)
+
+	// Should have RelUserIDPublicPosts (has-many) field - includes schema prefix
+	if !strings.Contains(usersStr, "RelUserIDPublicPosts") {
+		t.Errorf("Missing has-many relationship field RelUserIDPublicPosts")
+	}
+}
+
+func TestWriter_MultipleReferencesToSameTable(t *testing.T) {
+	// Test scenario: api_event table with multiple foreign keys to filepointer table
+	db := models.InitDatabase("testdb")
+	schema := models.InitSchema("org")
+
+	// Filepointer table
+	filepointer := models.InitTable("filepointer", "org")
+	filepointer.Columns["id_filepointer"] = &models.Column{
+		Name:         "id_filepointer",
+		Type:         "bigserial",
+		NotNull:      true,
+		IsPrimaryKey: true,
+	}
+	schema.Tables = append(schema.Tables, filepointer)
+
+	// API event table with two foreign keys to filepointer
+	apiEvent := models.InitTable("api_event", "org")
+	apiEvent.Columns["id_api_event"] = &models.Column{
+		Name:         "id_api_event",
+		Type:         "bigserial",
+		NotNull:      true,
+		IsPrimaryKey: true,
+	}
+	apiEvent.Columns["rid_filepointer_request"] = &models.Column{
+		Name:    "rid_filepointer_request",
+		Type:    "bigint",
+		NotNull: false,
+	}
+	apiEvent.Columns["rid_filepointer_response"] = &models.Column{
+		Name:    "rid_filepointer_response",
+		Type:    "bigint",
+		NotNull: false,
+	}
+
+	// Add constraints
+	apiEvent.Constraints["fk_request"] = &models.Constraint{
+		Name:              "fk_request",
+		Type:              models.ForeignKeyConstraint,
+		Columns:           []string{"rid_filepointer_request"},
+		ReferencedTable:   "filepointer",
+		ReferencedSchema:  "org",
+		ReferencedColumns: []string{"id_filepointer"},
+	}
+	apiEvent.Constraints["fk_response"] = &models.Constraint{
+		Name:              "fk_response",
+		Type:              models.ForeignKeyConstraint,
+		Columns:           []string{"rid_filepointer_response"},
+		ReferencedTable:   "filepointer",
+		ReferencedSchema:  "org",
+		ReferencedColumns: []string{"id_filepointer"},
+	}
+
+	schema.Tables = append(schema.Tables, apiEvent)
+	db.Schemas = append(db.Schemas, schema)
+
+	// Create writer
+	tmpDir := t.TempDir()
+	opts := &writers.WriterOptions{
+		PackageName: "models",
+		OutputPath:  tmpDir,
+		Metadata: map[string]interface{}{
+			"multi_file": true,
+		},
+	}
+
+	writer := NewWriter(opts)
+	err := writer.WriteDatabase(db)
+	if err != nil {
+		t.Fatalf("WriteDatabase failed: %v", err)
+	}
+
+	// Read the api_event file
+	apiEventContent, err := os.ReadFile(filepath.Join(tmpDir, "sql_org_api_event.go"))
+	if err != nil {
+		t.Fatalf("Failed to read api_event file: %v", err)
+	}
+
+	contentStr := string(apiEventContent)
+
+	// Verify both relationships have unique names based on column names
+	expectations := []struct {
+		fieldName string
+		tag       string
+	}{
+		{"RelRIDFilepointerRequest", "join:rid_filepointer_request=id_filepointer"},
+		{"RelRIDFilepointerResponse", "join:rid_filepointer_response=id_filepointer"},
+	}
+
+	for _, exp := range expectations {
+		if !strings.Contains(contentStr, exp.fieldName) {
+			t.Errorf("Missing relationship field: %s\nGenerated:\n%s", exp.fieldName, contentStr)
+		}
+		if !strings.Contains(contentStr, exp.tag) {
+			t.Errorf("Missing relationship tag: %s\nGenerated:\n%s", exp.tag, contentStr)
+		}
+	}
+
+	// Verify NO duplicate field names (old behavior would create duplicate "FIL" fields)
+	if strings.Contains(contentStr, "FIL *ModelFilepointer") {
+		t.Errorf("Found old prefix-based naming (FIL), should use column-based naming")
+	}
+
+	// Also verify has-many relationships on filepointer table
+	filepointerContent, err := os.ReadFile(filepath.Join(tmpDir, "sql_org_filepointer.go"))
+	if err != nil {
+		t.Fatalf("Failed to read filepointer file: %v", err)
+	}
+
+	filepointerStr := string(filepointerContent)
+
+	// Should have two different has-many relationships with unique names
+	hasManyExpectations := []string{
+		"RelRIDFilepointerRequestOrgAPIEvents",  // Has many via rid_filepointer_request
+		"RelRIDFilepointerResponseOrgAPIEvents", // Has many via rid_filepointer_response
+	}
+
+	for _, exp := range hasManyExpectations {
+		if !strings.Contains(filepointerStr, exp) {
+			t.Errorf("Missing has-many relationship field: %s\nGenerated:\n%s", exp, filepointerStr)
+		}
+	}
+}
+
+func TestWriter_MultipleHasManyRelationships(t *testing.T) {
+	// Test scenario: api_provider table referenced by multiple tables via rid_api_provider
+	db := models.InitDatabase("testdb")
+	schema := models.InitSchema("org")
+
+	// Owner table
+	owner := models.InitTable("owner", "org")
+	owner.Columns["id_owner"] = &models.Column{
+		Name:         "id_owner",
+		Type:         "bigserial",
+		NotNull:      true,
+		IsPrimaryKey: true,
+	}
+	schema.Tables = append(schema.Tables, owner)
+
+	// API Provider table
+	apiProvider := models.InitTable("api_provider", "org")
+	apiProvider.Columns["id_api_provider"] = &models.Column{
+		Name:         "id_api_provider",
+		Type:         "bigserial",
+		NotNull:      true,
+		IsPrimaryKey: true,
+	}
+	apiProvider.Columns["rid_owner"] = &models.Column{
+		Name:    "rid_owner",
+		Type:    "bigint",
+		NotNull: true,
+	}
+	apiProvider.Constraints["fk_owner"] = &models.Constraint{
+		Name:              "fk_owner",
+		Type:              models.ForeignKeyConstraint,
+		Columns:           []string{"rid_owner"},
+		ReferencedTable:   "owner",
+		ReferencedSchema:  "org",
+		ReferencedColumns: []string{"id_owner"},
+	}
+	schema.Tables = append(schema.Tables, apiProvider)
+
+	// Login table
+	login := models.InitTable("login", "org")
+	login.Columns["id_login"] = &models.Column{
+		Name:         "id_login",
+		Type:         "bigserial",
+		NotNull:      true,
+		IsPrimaryKey: true,
+	}
+	login.Columns["rid_api_provider"] = &models.Column{
+		Name:    "rid_api_provider",
+		Type:    "bigint",
+		NotNull: true,
+	}
+	login.Constraints["fk_api_provider"] = &models.Constraint{
+		Name:              "fk_api_provider",
+		Type:              models.ForeignKeyConstraint,
+		Columns:           []string{"rid_api_provider"},
+		ReferencedTable:   "api_provider",
+		ReferencedSchema:  "org",
+		ReferencedColumns: []string{"id_api_provider"},
+	}
+	schema.Tables = append(schema.Tables, login)
+
+	// Filepointer table
+	filepointer := models.InitTable("filepointer", "org")
+	filepointer.Columns["id_filepointer"] = &models.Column{
+		Name:         "id_filepointer",
+		Type:         "bigserial",
+		NotNull:      true,
+		IsPrimaryKey: true,
+	}
+	filepointer.Columns["rid_api_provider"] = &models.Column{
+		Name:    "rid_api_provider",
+		Type:    "bigint",
+		NotNull: true,
+	}
+	filepointer.Constraints["fk_api_provider"] = &models.Constraint{
+		Name:              "fk_api_provider",
+		Type:              models.ForeignKeyConstraint,
+		Columns:           []string{"rid_api_provider"},
+		ReferencedTable:   "api_provider",
+		ReferencedSchema:  "org",
+		ReferencedColumns: []string{"id_api_provider"},
+	}
+	schema.Tables = append(schema.Tables, filepointer)
+
+	// API Event table
+	apiEvent := models.InitTable("api_event", "org")
+	apiEvent.Columns["id_api_event"] = &models.Column{
+		Name:         "id_api_event",
+		Type:         "bigserial",
+		NotNull:      true,
+		IsPrimaryKey: true,
+	}
+	apiEvent.Columns["rid_api_provider"] = &models.Column{
+		Name:    "rid_api_provider",
+		Type:    "bigint",
+		NotNull: true,
+	}
+	apiEvent.Constraints["fk_api_provider"] = &models.Constraint{
+		Name:              "fk_api_provider",
+		Type:              models.ForeignKeyConstraint,
+		Columns:           []string{"rid_api_provider"},
+		ReferencedTable:   "api_provider",
+		ReferencedSchema:  "org",
+		ReferencedColumns: []string{"id_api_provider"},
+	}
+	schema.Tables = append(schema.Tables, apiEvent)
+
+	db.Schemas = append(db.Schemas, schema)
+
+	// Create writer
+	tmpDir := t.TempDir()
+	opts := &writers.WriterOptions{
+		PackageName: "models",
+		OutputPath:  tmpDir,
+		Metadata: map[string]interface{}{
+			"multi_file": true,
+		},
+	}
+
+	writer := NewWriter(opts)
+	err := writer.WriteDatabase(db)
+	if err != nil {
+		t.Fatalf("WriteDatabase failed: %v", err)
+	}
+
+	// Read the api_provider file
+	apiProviderContent, err := os.ReadFile(filepath.Join(tmpDir, "sql_org_api_provider.go"))
+	if err != nil {
+		t.Fatalf("Failed to read api_provider file: %v", err)
+	}
+
+	contentStr := string(apiProviderContent)
+
+	// Verify all has-many relationships have unique names
+	hasManyExpectations := []string{
+		"RelRIDAPIProviderOrgLogins",      // Has many via Login
+		"RelRIDAPIProviderOrgFilepointers", // Has many via Filepointer
+		"RelRIDAPIProviderOrgAPIEvents",   // Has many via APIEvent
+		"RelRIDOwner",                     // Has one via rid_owner
+	}
+
+	for _, exp := range hasManyExpectations {
+		if !strings.Contains(contentStr, exp) {
+			t.Errorf("Missing relationship field: %s\nGenerated:\n%s", exp, contentStr)
+		}
+	}
+
+	// Verify NO duplicate field names
+	// Count occurrences of "RelRIDAPIProvider" fields - should have 3 unique ones
+	count := strings.Count(contentStr, "RelRIDAPIProvider")
+	if count != 3 {
+		t.Errorf("Expected 3 RelRIDAPIProvider* fields, found %d\nGenerated:\n%s", count, contentStr)
+	}
+
+	// Verify no duplicate declarations (would cause compilation error)
+	duplicatePattern := "RelRIDAPIProviders []*Model"
+	if strings.Contains(contentStr, duplicatePattern) {
+		t.Errorf("Found duplicate field declaration pattern, fields should be unique")
+	}
+}
+
+func TestWriter_FieldNameCollision(t *testing.T) {
+	// Test scenario: table with columns that would conflict with generated method names
+	table := models.InitTable("audit_table", "audit")
+	table.Columns["id_audit_table"] = &models.Column{
+		Name:         "id_audit_table",
+		Type:         "smallint",
+		NotNull:      true,
+		IsPrimaryKey: true,
+		Sequence:     1,
+	}
+	table.Columns["table_name"] = &models.Column{
+		Name:     "table_name",
+		Type:     "varchar",
+		Length:   100,
+		NotNull:  true,
+		Sequence: 2,
+	}
+	table.Columns["table_schema"] = &models.Column{
+		Name:     "table_schema",
+		Type:     "varchar",
+		Length:   100,
+		NotNull:  true,
+		Sequence: 3,
+	}
+
+	// Create writer
+	tmpDir := t.TempDir()
+	opts := &writers.WriterOptions{
+		PackageName: "models",
+		OutputPath:  filepath.Join(tmpDir, "test.go"),
+	}
+
+	writer := NewWriter(opts)
+
+	err := writer.WriteTable(table)
+	if err != nil {
+		t.Fatalf("WriteTable failed: %v", err)
+	}
+
+	// Read the generated file
+	content, err := os.ReadFile(opts.OutputPath)
+	if err != nil {
+		t.Fatalf("Failed to read generated file: %v", err)
+	}
+
+	generated := string(content)
+
+	// Verify that TableName field was renamed to TableName_ to avoid collision
+	if !strings.Contains(generated, "TableName_") {
+		t.Errorf("Expected field 'TableName_' (with underscore) but not found\nGenerated:\n%s", generated)
+	}
+
+	// Verify the struct tag still references the correct database column
+	if !strings.Contains(generated, `bun:"table_name,`) {
+		t.Errorf("Expected bun tag to reference 'table_name' column\nGenerated:\n%s", generated)
+	}
+
+	// Verify the TableName() method still exists and doesn't conflict
+	if !strings.Contains(generated, "func (m ModelAuditAuditTable) TableName() string") {
+		t.Errorf("TableName() method should still be generated\nGenerated:\n%s", generated)
+	}
+
+	// Verify NO field named just "TableName" (without underscore)
+	if strings.Contains(generated, "TableName resolvespec_common") || strings.Contains(generated, "TableName string") {
+		t.Errorf("Field 'TableName' without underscore should not exist (would conflict with method)\nGenerated:\n%s", generated)
+	}
 }
 
 func TestTypeMapper_SQLTypeToGoType_Bun(t *testing.T) {

pkg/writers/gorm/template_data.go

@@ -4,6 +4,7 @@ import (
 	"sort"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
+	"git.warky.dev/wdevs/relspecgo/pkg/writers"
 )
 
 // TemplateData represents the data passed to the template for code generation
@@ -24,6 +25,7 @@ type ModelData struct {
 	Fields          []*FieldData
 	Config          *MethodConfig
 	PrimaryKeyField string // Name of the primary key field
+	PrimaryKeyType  string // Go type of the primary key field
 	IDColumnName    string // Name of the ID column in database
 	Prefix          string // 3-letter prefix
 }
@@ -109,13 +111,17 @@ func NewModelData(table *models.Table, schema string, typeMapper *TypeMapper) *M
 		tableName = schema + "." + table.Name
 	}
 
-	// Generate model name: singularize and convert to PascalCase
+	// Generate model name: Model + Schema + Table (all PascalCase)
 	singularTable := Singularize(table.Name)
-	modelName := SnakeCaseToPascalCase(singularTable)
+	tablePart := SnakeCaseToPascalCase(singularTable)
 
-	// Add "Model" prefix if not already present
-	if !hasModelPrefix(modelName) {
-		modelName = "Model" + modelName
+	// Include schema name in model name
+	var modelName string
+	if schema != "" {
+		schemaPart := SnakeCaseToPascalCase(schema)
+		modelName = "Model" + schemaPart + tablePart
+	} else {
+		modelName = "Model" + tablePart
 	}
 
 	model := &ModelData{
@@ -131,8 +137,11 @@ func NewModelData(table *models.Table, schema string, typeMapper *TypeMapper) *M
 	// Find primary key
 	for _, col := range table.Columns {
 		if col.IsPrimaryKey {
-			model.PrimaryKeyField = SnakeCaseToPascalCase(col.Name)
-			model.IDColumnName = col.Name
+			// Sanitize column name to remove backticks
+			safeName := writers.SanitizeStructTagValue(col.Name)
+			model.PrimaryKeyField = SnakeCaseToPascalCase(safeName)
+			model.PrimaryKeyType = typeMapper.SQLTypeToGoType(col.Type, col.NotNull)
+			model.IDColumnName = safeName
 			break
 		}
 	}
@@ -141,6 +150,8 @@ func NewModelData(table *models.Table, schema string, typeMapper *TypeMapper) *M
 	columns := sortColumns(table.Columns)
 	for _, col := range columns {
 		field := columnToField(col, table, typeMapper)
+		// Check for name collision with generated methods and rename if needed
+		field.Name = resolveFieldNameCollision(field.Name)
 		model.Fields = append(model.Fields, field)
 	}
 
@@ -149,10 +160,13 @@ func NewModelData(table *models.Table, schema string, typeMapper *TypeMapper) *M
 
 // columnToField converts a models.Column to FieldData
 func columnToField(col *models.Column, table *models.Table, typeMapper *TypeMapper) *FieldData {
-	fieldName := SnakeCaseToPascalCase(col.Name)
+	// Sanitize column name first to remove backticks before generating field name
+	safeName := writers.SanitizeStructTagValue(col.Name)
+	fieldName := SnakeCaseToPascalCase(safeName)
 	goType := typeMapper.SQLTypeToGoType(col.Type, col.NotNull)
 	gormTag := typeMapper.BuildGormTag(col, table)
-	jsonTag := col.Name // Use column name for JSON tag
+	// Use same sanitized name for JSON tag
+	jsonTag := safeName
 
 	return &FieldData{
 		Name:    fieldName,
@@ -179,9 +193,28 @@ func formatComment(description, comment string) string {
 	return comment
 }
 
-// hasModelPrefix checks if a name already has "Model" prefix
-func hasModelPrefix(name string) bool {
-	return len(name) >= 5 && name[:5] == "Model"
+// resolveFieldNameCollision checks if a field name conflicts with generated method names
+// and adds an underscore suffix if there's a collision
+func resolveFieldNameCollision(fieldName string) string {
+	// List of method names that are generated by the template
+	reservedNames := map[string]bool{
+		"TableName":     true,
+		"TableNameOnly": true,
+		"SchemaName":    true,
+		"GetID":         true,
+		"GetIDStr":      true,
+		"SetID":         true,
+		"UpdateID":      true,
+		"GetIDName":     true,
+		"GetPrefix":     true,
+	}
+
+	// Check if field name conflicts with a reserved method name
+	if reservedNames[fieldName] {
+		return fieldName + "_"
+	}
+
+	return fieldName
 }
 
 // sortColumns sorts columns by sequence, then by name

pkg/writers/gorm/templates.go

@@ -62,7 +62,7 @@ func (m {{.Name}}) SetID(newid int64) {
 {{if and .Config.GenerateUpdateID .PrimaryKeyField}}
 // UpdateID updates the primary key value
 func (m *{{.Name}}) UpdateID(newid int64) {
-	m.{{.PrimaryKeyField}} = int32(newid)
+	m.{{.PrimaryKeyField}} = {{.PrimaryKeyType}}(newid)
 }
 {{end}}
 {{if and .Config.GenerateGetIDName .IDColumnName}}

pkg/writers/gorm/type_mapper.go

@@ -5,6 +5,7 @@ import (
 	"strings"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
+	"git.warky.dev/wdevs/relspecgo/pkg/writers"
 )
 
 // TypeMapper handles type conversions between SQL and Go types
@@ -199,12 +200,15 @@ func (tm *TypeMapper) BuildGormTag(column *models.Column, table *models.Table) s
 	var parts []string
 
 	// Always include column name (lowercase as per user requirement)
-	parts = append(parts, fmt.Sprintf("column:%s", column.Name))
+	// Sanitize to remove backticks which would break struct tag syntax
+	safeName := writers.SanitizeStructTagValue(column.Name)
+	parts = append(parts, fmt.Sprintf("column:%s", safeName))
 
 	// Add type if specified
 	if column.Type != "" {
 		// Include length, precision, scale if present
-		typeStr := column.Type
+		// Sanitize type to remove backticks
+		typeStr := writers.SanitizeStructTagValue(column.Type)
 		if column.Length > 0 {
 			typeStr = fmt.Sprintf("%s(%d)", typeStr, column.Length)
 		} else if column.Precision > 0 {
@@ -234,7 +238,9 @@ func (tm *TypeMapper) BuildGormTag(column *models.Column, table *models.Table) s
 
 	// Default value
 	if column.Default != nil {
-		parts = append(parts, fmt.Sprintf("default:%v", column.Default))
+		// Sanitize default value to remove backticks
+		safeDefault := writers.SanitizeStructTagValue(fmt.Sprintf("%v", column.Default))
+		parts = append(parts, fmt.Sprintf("default:%s", safeDefault))
 	}
 
 	// Check for unique constraint
@@ -331,5 +337,5 @@ func (tm *TypeMapper) NeedsFmtImport(generateGetIDStr bool) bool {
 
 // GetSQLTypesImport returns the import path for sql_types
 func (tm *TypeMapper) GetSQLTypesImport() string {
-	return "github.com/bitechdev/ResolveSpec/pkg/common/sql_types"
+	return "github.com/bitechdev/ResolveSpec/pkg/spectypes"
 }

pkg/writers/gorm/writer.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"go/format"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 
@@ -121,7 +122,16 @@ func (w *Writer) writeSingleFile(db *models.Database) error {
 	}
 
 	// Write output
-	return w.writeOutput(formatted)
+	if err := w.writeOutput(formatted); err != nil {
+		return err
+	}
+
+	// Run go fmt on the output file
+	if w.options.OutputPath != "" {
+		w.runGoFmt(w.options.OutputPath)
+	}
+
+	return nil
 }
 
 // writeMultiFile writes each table to a separate file
@@ -211,6 +221,9 @@ func (w *Writer) writeMultiFile(db *models.Database) error {
 			if err := os.WriteFile(filepath, []byte(formatted), 0644); err != nil {
 				return fmt.Errorf("failed to write file %s: %w", filename, err)
 			}
+
+			// Run go fmt on the generated file
+			w.runGoFmt(filepath)
 		}
 	}
 
@@ -219,6 +232,9 @@ func (w *Writer) writeMultiFile(db *models.Database) error {
 
 // addRelationshipFields adds relationship fields to the model based on foreign keys
 func (w *Writer) addRelationshipFields(modelData *ModelData, table *models.Table, schema *models.Schema, db *models.Database) {
+	// Track used field names to detect duplicates
+	usedFieldNames := make(map[string]int)
+
 	// For each foreign key in this table, add a belongs-to relationship
 	for _, constraint := range table.Constraints {
 		if constraint.Type != models.ForeignKeyConstraint {
@@ -232,8 +248,9 @@ func (w *Writer) addRelationshipFields(modelData *ModelData, table *models.Table
 		}
 
 		// Create relationship field (belongs-to)
-		refModelName := w.getModelName(constraint.ReferencedTable)
-		fieldName := w.generateRelationshipFieldName(constraint.ReferencedTable)
+		refModelName := w.getModelName(constraint.ReferencedSchema, constraint.ReferencedTable)
+		fieldName := w.generateBelongsToFieldName(constraint)
+		fieldName = w.ensureUniqueFieldName(fieldName, usedFieldNames)
 		relationTag := w.typeMapper.BuildRelationshipTag(constraint, false)
 
 		modelData.AddRelationshipField(&FieldData{
@@ -260,8 +277,9 @@ func (w *Writer) addRelationshipFields(modelData *ModelData, table *models.Table
 				// Check if this constraint references our table
 				if constraint.ReferencedTable == table.Name && constraint.ReferencedSchema == schema.Name {
 					// Add has-many relationship
-					otherModelName := w.getModelName(otherTable.Name)
-					fieldName := w.generateRelationshipFieldName(otherTable.Name) + "s" // Pluralize
+					otherModelName := w.getModelName(otherSchema.Name, otherTable.Name)
+					fieldName := w.generateHasManyFieldName(constraint, otherSchema.Name, otherTable.Name)
+					fieldName = w.ensureUniqueFieldName(fieldName, usedFieldNames)
 					relationTag := w.typeMapper.BuildRelationshipTag(constraint, true)
 
 					modelData.AddRelationshipField(&FieldData{
@@ -292,22 +310,77 @@ func (w *Writer) findTable(schemaName, tableName string, db *models.Database) *m
 	return nil
 }
 
-// getModelName generates the model name from a table name
-func (w *Writer) getModelName(tableName string) string {
+// getModelName generates the model name from schema and table name
+func (w *Writer) getModelName(schemaName, tableName string) string {
 	singular := Singularize(tableName)
-	modelName := SnakeCaseToPascalCase(singular)
+	tablePart := SnakeCaseToPascalCase(singular)
 
-	if !hasModelPrefix(modelName) {
-		modelName = "Model" + modelName
+	// Include schema name in model name
+	var modelName string
+	if schemaName != "" {
+		schemaPart := SnakeCaseToPascalCase(schemaName)
+		modelName = "Model" + schemaPart + tablePart
+	} else {
+		modelName = "Model" + tablePart
 	}
 
 	return modelName
 }
 
-// generateRelationshipFieldName generates a field name for a relationship
-func (w *Writer) generateRelationshipFieldName(tableName string) string {
-	// Use just the prefix (3 letters) for relationship fields
-	return GeneratePrefix(tableName)
+// generateBelongsToFieldName generates a field name for belongs-to relationships
+// Uses the foreign key column name for uniqueness
+func (w *Writer) generateBelongsToFieldName(constraint *models.Constraint) string {
+	// Use the foreign key column name to ensure uniqueness
+	// If there are multiple columns, use the first one
+	if len(constraint.Columns) > 0 {
+		columnName := constraint.Columns[0]
+		// Convert to PascalCase for proper Go field naming
+		// e.g., "rid_filepointer_request" -> "RelRIDFilepointerRequest"
+		return "Rel" + SnakeCaseToPascalCase(columnName)
+	}
+
+	// Fallback to table-based prefix if no columns defined
+	return "Rel" + GeneratePrefix(constraint.ReferencedTable)
+}
+
+// generateHasManyFieldName generates a field name for has-many relationships
+// Uses the foreign key column name + source table name to avoid duplicates
+func (w *Writer) generateHasManyFieldName(constraint *models.Constraint, sourceSchemaName, sourceTableName string) string {
+	// For has-many, we need to include the source table name to avoid duplicates
+	// e.g., multiple tables referencing the same column on this table
+	if len(constraint.Columns) > 0 {
+		columnName := constraint.Columns[0]
+		// Get the model name for the source table (pluralized)
+		sourceModelName := w.getModelName(sourceSchemaName, sourceTableName)
+		// Remove "Model" prefix if present
+		sourceModelName = strings.TrimPrefix(sourceModelName, "Model")
+
+		// Convert column to PascalCase and combine with source table
+		// e.g., "rid_api_provider" + "Login" -> "RelRIDAPIProviderLogins"
+		columnPart := SnakeCaseToPascalCase(columnName)
+		return "Rel" + columnPart + Pluralize(sourceModelName)
+	}
+
+	// Fallback to table-based naming
+	sourceModelName := w.getModelName(sourceSchemaName, sourceTableName)
+	sourceModelName = strings.TrimPrefix(sourceModelName, "Model")
+	return "Rel" + Pluralize(sourceModelName)
+}
+
+// ensureUniqueFieldName ensures a field name is unique by adding numeric suffixes if needed
+func (w *Writer) ensureUniqueFieldName(fieldName string, usedNames map[string]int) string {
+	originalName := fieldName
+	count := usedNames[originalName]
+
+	if count > 0 {
+		// Name is already used, add numeric suffix
+		fieldName = fmt.Sprintf("%s%d", originalName, count+1)
+	}
+
+	// Increment the counter for this base name
+	usedNames[originalName]++
+
+	return fieldName
 }
 
 // getPackageName returns the package name from options or defaults to "models"
@@ -338,6 +411,15 @@ func (w *Writer) writeOutput(content string) error {
 	return nil
 }
 
+// runGoFmt runs go fmt on the specified file
+func (w *Writer) runGoFmt(filepath string) {
+	cmd := exec.Command("gofmt", "-w", filepath)
+	if err := cmd.Run(); err != nil {
+		// Don't fail the whole operation if gofmt fails, just warn
+		fmt.Fprintf(os.Stderr, "Warning: failed to run gofmt on %s: %v\n", filepath, err)
+	}
+}
+
 // shouldUseMultiFile determines whether to use multi-file mode based on metadata or output path
 func (w *Writer) shouldUseMultiFile() bool {
 	// Check if multi_file is explicitly set in metadata

pkg/writers/gorm/writer_test.go

@@ -66,7 +66,7 @@ func TestWriter_WriteTable(t *testing.T) {
 	// Verify key elements are present
 	expectations := []string{
 		"package models",
-		"type ModelUser struct",
+		"type ModelPublicUser struct",
 		"ID",
 		"int64",
 		"Email",
@@ -75,9 +75,9 @@ func TestWriter_WriteTable(t *testing.T) {
 		"time.Time",
 		"gorm:\"column:id",
 		"gorm:\"column:email",
-		"func (m ModelUser) TableName() string",
+		"func (m ModelPublicUser) TableName() string",
 		"return \"public.users\"",
-		"func (m ModelUser) GetID() int64",
+		"func (m ModelPublicUser) GetID() int64",
 	}
 
 	for _, expected := range expectations {
@@ -164,9 +164,437 @@ func TestWriter_WriteDatabase_MultiFile(t *testing.T) {
 		t.Fatalf("Failed to read posts file: %v", err)
 	}
 
-	if !strings.Contains(string(postsContent), "USE *ModelUser") {
-		// Relationship field should be present
-		t.Logf("Posts content:\n%s", string(postsContent))
+	postsStr := string(postsContent)
+
+	// Verify relationship is present with new naming convention
+	// Should now be RelUserID (belongs-to) instead of USE
+	if !strings.Contains(postsStr, "RelUserID") {
+		t.Errorf("Missing relationship field RelUserID (new naming convention)")
+	}
+
+	// Check users file contains has-many relationship
+	usersContent, err := os.ReadFile(filepath.Join(tmpDir, "sql_public_users.go"))
+	if err != nil {
+		t.Fatalf("Failed to read users file: %v", err)
+	}
+
+	usersStr := string(usersContent)
+
+	// Should have RelUserIDPublicPosts (has-many) field - includes schema prefix
+	if !strings.Contains(usersStr, "RelUserIDPublicPosts") {
+		t.Errorf("Missing has-many relationship field RelUserIDPublicPosts")
+	}
+}
+
+func TestWriter_MultipleReferencesToSameTable(t *testing.T) {
+	// Test scenario: api_event table with multiple foreign keys to filepointer table
+	db := models.InitDatabase("testdb")
+	schema := models.InitSchema("org")
+
+	// Filepointer table
+	filepointer := models.InitTable("filepointer", "org")
+	filepointer.Columns["id_filepointer"] = &models.Column{
+		Name:         "id_filepointer",
+		Type:         "bigserial",
+		NotNull:      true,
+		IsPrimaryKey: true,
+	}
+	schema.Tables = append(schema.Tables, filepointer)
+
+	// API event table with two foreign keys to filepointer
+	apiEvent := models.InitTable("api_event", "org")
+	apiEvent.Columns["id_api_event"] = &models.Column{
+		Name:         "id_api_event",
+		Type:         "bigserial",
+		NotNull:      true,
+		IsPrimaryKey: true,
+	}
+	apiEvent.Columns["rid_filepointer_request"] = &models.Column{
+		Name:    "rid_filepointer_request",
+		Type:    "bigint",
+		NotNull: false,
+	}
+	apiEvent.Columns["rid_filepointer_response"] = &models.Column{
+		Name:    "rid_filepointer_response",
+		Type:    "bigint",
+		NotNull: false,
+	}
+
+	// Add constraints
+	apiEvent.Constraints["fk_request"] = &models.Constraint{
+		Name:              "fk_request",
+		Type:              models.ForeignKeyConstraint,
+		Columns:           []string{"rid_filepointer_request"},
+		ReferencedTable:   "filepointer",
+		ReferencedSchema:  "org",
+		ReferencedColumns: []string{"id_filepointer"},
+	}
+	apiEvent.Constraints["fk_response"] = &models.Constraint{
+		Name:              "fk_response",
+		Type:              models.ForeignKeyConstraint,
+		Columns:           []string{"rid_filepointer_response"},
+		ReferencedTable:   "filepointer",
+		ReferencedSchema:  "org",
+		ReferencedColumns: []string{"id_filepointer"},
+	}
+
+	schema.Tables = append(schema.Tables, apiEvent)
+	db.Schemas = append(db.Schemas, schema)
+
+	// Create writer
+	tmpDir := t.TempDir()
+	opts := &writers.WriterOptions{
+		PackageName: "models",
+		OutputPath:  tmpDir,
+		Metadata: map[string]interface{}{
+			"multi_file": true,
+		},
+	}
+
+	writer := NewWriter(opts)
+	err := writer.WriteDatabase(db)
+	if err != nil {
+		t.Fatalf("WriteDatabase failed: %v", err)
+	}
+
+	// Read the api_event file
+	apiEventContent, err := os.ReadFile(filepath.Join(tmpDir, "sql_org_api_event.go"))
+	if err != nil {
+		t.Fatalf("Failed to read api_event file: %v", err)
+	}
+
+	contentStr := string(apiEventContent)
+
+	// Verify both relationships have unique names based on column names
+	expectations := []struct {
+		fieldName string
+		tag       string
+	}{
+		{"RelRIDFilepointerRequest", "foreignKey:RIDFilepointerRequest"},
+		{"RelRIDFilepointerResponse", "foreignKey:RIDFilepointerResponse"},
+	}
+
+	for _, exp := range expectations {
+		if !strings.Contains(contentStr, exp.fieldName) {
+			t.Errorf("Missing relationship field: %s\nGenerated:\n%s", exp.fieldName, contentStr)
+		}
+		if !strings.Contains(contentStr, exp.tag) {
+			t.Errorf("Missing relationship tag: %s\nGenerated:\n%s", exp.tag, contentStr)
+		}
+	}
+
+	// Verify NO duplicate field names (old behavior would create duplicate "FIL" fields)
+	if strings.Contains(contentStr, "FIL *ModelFilepointer") {
+		t.Errorf("Found old prefix-based naming (FIL), should use column-based naming")
+	}
+
+	// Also verify has-many relationships on filepointer table
+	filepointerContent, err := os.ReadFile(filepath.Join(tmpDir, "sql_org_filepointer.go"))
+	if err != nil {
+		t.Fatalf("Failed to read filepointer file: %v", err)
+	}
+
+	filepointerStr := string(filepointerContent)
+
+	// Should have two different has-many relationships with unique names
+	hasManyExpectations := []string{
+		"RelRIDFilepointerRequestOrgAPIEvents",  // Has many via rid_filepointer_request
+		"RelRIDFilepointerResponseOrgAPIEvents", // Has many via rid_filepointer_response
+	}
+
+	for _, exp := range hasManyExpectations {
+		if !strings.Contains(filepointerStr, exp) {
+			t.Errorf("Missing has-many relationship field: %s\nGenerated:\n%s", exp, filepointerStr)
+		}
+	}
+}
+
+func TestWriter_MultipleHasManyRelationships(t *testing.T) {
+	// Test scenario: api_provider table referenced by multiple tables via rid_api_provider
+	db := models.InitDatabase("testdb")
+	schema := models.InitSchema("org")
+
+	// Owner table
+	owner := models.InitTable("owner", "org")
+	owner.Columns["id_owner"] = &models.Column{
+		Name:         "id_owner",
+		Type:         "bigserial",
+		NotNull:      true,
+		IsPrimaryKey: true,
+	}
+	schema.Tables = append(schema.Tables, owner)
+
+	// API Provider table
+	apiProvider := models.InitTable("api_provider", "org")
+	apiProvider.Columns["id_api_provider"] = &models.Column{
+		Name:         "id_api_provider",
+		Type:         "bigserial",
+		NotNull:      true,
+		IsPrimaryKey: true,
+	}
+	apiProvider.Columns["rid_owner"] = &models.Column{
+		Name:    "rid_owner",
+		Type:    "bigint",
+		NotNull: true,
+	}
+	apiProvider.Constraints["fk_owner"] = &models.Constraint{
+		Name:              "fk_owner",
+		Type:              models.ForeignKeyConstraint,
+		Columns:           []string{"rid_owner"},
+		ReferencedTable:   "owner",
+		ReferencedSchema:  "org",
+		ReferencedColumns: []string{"id_owner"},
+	}
+	schema.Tables = append(schema.Tables, apiProvider)
+
+	// Login table
+	login := models.InitTable("login", "org")
+	login.Columns["id_login"] = &models.Column{
+		Name:         "id_login",
+		Type:         "bigserial",
+		NotNull:      true,
+		IsPrimaryKey: true,
+	}
+	login.Columns["rid_api_provider"] = &models.Column{
+		Name:    "rid_api_provider",
+		Type:    "bigint",
+		NotNull: true,
+	}
+	login.Constraints["fk_api_provider"] = &models.Constraint{
+		Name:              "fk_api_provider",
+		Type:              models.ForeignKeyConstraint,
+		Columns:           []string{"rid_api_provider"},
+		ReferencedTable:   "api_provider",
+		ReferencedSchema:  "org",
+		ReferencedColumns: []string{"id_api_provider"},
+	}
+	schema.Tables = append(schema.Tables, login)
+
+	// Filepointer table
+	filepointer := models.InitTable("filepointer", "org")
+	filepointer.Columns["id_filepointer"] = &models.Column{
+		Name:         "id_filepointer",
+		Type:         "bigserial",
+		NotNull:      true,
+		IsPrimaryKey: true,
+	}
+	filepointer.Columns["rid_api_provider"] = &models.Column{
+		Name:    "rid_api_provider",
+		Type:    "bigint",
+		NotNull: true,
+	}
+	filepointer.Constraints["fk_api_provider"] = &models.Constraint{
+		Name:              "fk_api_provider",
+		Type:              models.ForeignKeyConstraint,
+		Columns:           []string{"rid_api_provider"},
+		ReferencedTable:   "api_provider",
+		ReferencedSchema:  "org",
+		ReferencedColumns: []string{"id_api_provider"},
+	}
+	schema.Tables = append(schema.Tables, filepointer)
+
+	// API Event table
+	apiEvent := models.InitTable("api_event", "org")
+	apiEvent.Columns["id_api_event"] = &models.Column{
+		Name:         "id_api_event",
+		Type:         "bigserial",
+		NotNull:      true,
+		IsPrimaryKey: true,
+	}
+	apiEvent.Columns["rid_api_provider"] = &models.Column{
+		Name:    "rid_api_provider",
+		Type:    "bigint",
+		NotNull: true,
+	}
+	apiEvent.Constraints["fk_api_provider"] = &models.Constraint{
+		Name:              "fk_api_provider",
+		Type:              models.ForeignKeyConstraint,
+		Columns:           []string{"rid_api_provider"},
+		ReferencedTable:   "api_provider",
+		ReferencedSchema:  "org",
+		ReferencedColumns: []string{"id_api_provider"},
+	}
+	schema.Tables = append(schema.Tables, apiEvent)
+
+	db.Schemas = append(db.Schemas, schema)
+
+	// Create writer
+	tmpDir := t.TempDir()
+	opts := &writers.WriterOptions{
+		PackageName: "models",
+		OutputPath:  tmpDir,
+		Metadata: map[string]interface{}{
+			"multi_file": true,
+		},
+	}
+
+	writer := NewWriter(opts)
+	err := writer.WriteDatabase(db)
+	if err != nil {
+		t.Fatalf("WriteDatabase failed: %v", err)
+	}
+
+	// Read the api_provider file
+	apiProviderContent, err := os.ReadFile(filepath.Join(tmpDir, "sql_org_api_provider.go"))
+	if err != nil {
+		t.Fatalf("Failed to read api_provider file: %v", err)
+	}
+
+	contentStr := string(apiProviderContent)
+
+	// Verify all has-many relationships have unique names
+	hasManyExpectations := []string{
+		"RelRIDAPIProviderOrgLogins",      // Has many via Login
+		"RelRIDAPIProviderOrgFilepointers", // Has many via Filepointer
+		"RelRIDAPIProviderOrgAPIEvents",   // Has many via APIEvent
+		"RelRIDOwner",                     // Belongs to via rid_owner
+	}
+
+	for _, exp := range hasManyExpectations {
+		if !strings.Contains(contentStr, exp) {
+			t.Errorf("Missing relationship field: %s\nGenerated:\n%s", exp, contentStr)
+		}
+	}
+
+	// Verify NO duplicate field names
+	// Count occurrences of "RelRIDAPIProvider" fields - should have 3 unique ones
+	count := strings.Count(contentStr, "RelRIDAPIProvider")
+	if count != 3 {
+		t.Errorf("Expected 3 RelRIDAPIProvider* fields, found %d\nGenerated:\n%s", count, contentStr)
+	}
+
+	// Verify no duplicate declarations (would cause compilation error)
+	duplicatePattern := "RelRIDAPIProviders []*Model"
+	if strings.Contains(contentStr, duplicatePattern) {
+		t.Errorf("Found duplicate field declaration pattern, fields should be unique")
+	}
+}
+
+func TestWriter_FieldNameCollision(t *testing.T) {
+	// Test scenario: table with columns that would conflict with generated method names
+	table := models.InitTable("audit_table", "audit")
+	table.Columns["id_audit_table"] = &models.Column{
+		Name:         "id_audit_table",
+		Type:         "smallint",
+		NotNull:      true,
+		IsPrimaryKey: true,
+		Sequence:     1,
+	}
+	table.Columns["table_name"] = &models.Column{
+		Name:     "table_name",
+		Type:     "varchar",
+		Length:   100,
+		NotNull:  true,
+		Sequence: 2,
+	}
+	table.Columns["table_schema"] = &models.Column{
+		Name:     "table_schema",
+		Type:     "varchar",
+		Length:   100,
+		NotNull:  true,
+		Sequence: 3,
+	}
+
+	// Create writer
+	tmpDir := t.TempDir()
+	opts := &writers.WriterOptions{
+		PackageName: "models",
+		OutputPath:  filepath.Join(tmpDir, "test.go"),
+	}
+
+	writer := NewWriter(opts)
+
+	err := writer.WriteTable(table)
+	if err != nil {
+		t.Fatalf("WriteTable failed: %v", err)
+	}
+
+	// Read the generated file
+	content, err := os.ReadFile(opts.OutputPath)
+	if err != nil {
+		t.Fatalf("Failed to read generated file: %v", err)
+	}
+
+	generated := string(content)
+
+	// Verify that TableName field was renamed to TableName_ to avoid collision
+	if !strings.Contains(generated, "TableName_") {
+		t.Errorf("Expected field 'TableName_' (with underscore) but not found\nGenerated:\n%s", generated)
+	}
+
+	// Verify the struct tag still references the correct database column
+	if !strings.Contains(generated, `gorm:"column:table_name;`) {
+		t.Errorf("Expected gorm tag to reference 'table_name' column\nGenerated:\n%s", generated)
+	}
+
+	// Verify the TableName() method still exists and doesn't conflict
+	if !strings.Contains(generated, "func (m ModelAuditAuditTable) TableName() string") {
+		t.Errorf("TableName() method should still be generated\nGenerated:\n%s", generated)
+	}
+
+	// Verify NO field named just "TableName" (without underscore)
+	if strings.Contains(generated, "TableName sql_types") || strings.Contains(generated, "TableName string") {
+		t.Errorf("Field 'TableName' without underscore should not exist (would conflict with method)\nGenerated:\n%s", generated)
+	}
+}
+
+func TestWriter_UpdateIDTypeSafety(t *testing.T) {
+	// Test scenario: tables with different primary key types
+	tests := []struct {
+		name       string
+		pkType     string
+		expectedPK string
+		castType   string
+	}{
+		{"int32_pk", "int", "int32", "int32(newid)"},
+		{"int16_pk", "smallint", "int16", "int16(newid)"},
+		{"int64_pk", "bigint", "int64", "int64(newid)"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			table := models.InitTable("test_table", "public")
+			table.Columns["id"] = &models.Column{
+				Name:         "id",
+				Type:         tt.pkType,
+				NotNull:      true,
+				IsPrimaryKey: true,
+			}
+
+			tmpDir := t.TempDir()
+			opts := &writers.WriterOptions{
+				PackageName: "models",
+				OutputPath:  filepath.Join(tmpDir, "test.go"),
+			}
+
+			writer := NewWriter(opts)
+			err := writer.WriteTable(table)
+			if err != nil {
+				t.Fatalf("WriteTable failed: %v", err)
+			}
+
+			content, err := os.ReadFile(opts.OutputPath)
+			if err != nil {
+				t.Fatalf("Failed to read generated file: %v", err)
+			}
+
+			generated := string(content)
+
+			// Verify UpdateID method has correct type cast
+			if !strings.Contains(generated, tt.castType) {
+				t.Errorf("Expected UpdateID to cast to %s\nGenerated:\n%s", tt.castType, generated)
+			}
+
+			// Verify no invalid int32(newid) for non-int32 types
+			if tt.expectedPK != "int32" && strings.Contains(generated, "int32(newid)") {
+				t.Errorf("UpdateID should not cast to int32 for %s type\nGenerated:\n%s", tt.pkType, generated)
+			}
+
+			// Verify UpdateID parameter is int64 (for consistency)
+			if !strings.Contains(generated, "UpdateID(newid int64)") {
+				t.Errorf("UpdateID should accept int64 parameter\nGenerated:\n%s", generated)
+			}
+		})
 	}
 }
 

pkg/writers/writer.go

@@ -61,3 +61,26 @@ func SanitizeFilename(name string) string {
 
 	return name
 }
+
+// SanitizeStructTagValue sanitizes a value to be safely used inside Go struct tags.
+// Go struct tags are delimited by backticks, so any backtick in the value would break the syntax.
+// This function:
+// - Removes DBML/DCTX comments in brackets
+// - Removes all quotes (double, single, and backticks)
+// - Returns a clean identifier safe for use in struct tags and field names
+func SanitizeStructTagValue(value string) string {
+	// Remove DBML/DCTX style comments in brackets (e.g., [note: 'description'])
+	commentRegex := regexp.MustCompile(`\s*\[.*?\]\s*`)
+	value = commentRegex.ReplaceAllString(value, "")
+
+	// Trim whitespace
+	value = strings.TrimSpace(value)
+
+	// Remove all quotes: backticks, double quotes, and single quotes
+	// This ensures the value is clean for use as Go identifiers and struct tag values
+	value = strings.ReplaceAll(value, "`", "")
+	value = strings.ReplaceAll(value, `"`, "")
+	value = strings.ReplaceAll(value, `'`, "")
+
+	return value
+}