feat(writer): 🎉 Enhance relationship field naming and uniqueness

* Update relationship field naming conventions for has-one and has-many relationships.
* Implement logic to ensure unique field names by tracking used names.
* Add tests to verify new naming conventions and uniqueness constraints.

pkg/writers/bun/writer.go

@@ -225,6 +225,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 {
@@ -239,7 +242,8 @@ 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)
+		fieldName := w.generateHasOneFieldName(constraint)
+		fieldName = w.ensureUniqueFieldName(fieldName, usedFieldNames)
 		relationTag := w.typeMapper.BuildRelationshipTag(constraint, "has-one")
 
 		modelData.AddRelationshipField(&FieldData{
@@ -267,7 +271,8 @@ func (w *Writer) addRelationshipFields(modelData *ModelData, table *models.Table
 				if constraint.ReferencedTable == table.Name && constraint.ReferencedSchema == schema.Name {
 					// Add has-many relationship
 					otherModelName := w.getModelName(otherTable.Name)
-					fieldName := w.generateRelationshipFieldName(constraint) + "s" // Pluralize
+					fieldName := w.generateHasManyFieldName(constraint, otherTable.Name)
+					fieldName = w.ensureUniqueFieldName(fieldName, usedFieldNames)
 					relationTag := w.typeMapper.BuildRelationshipTag(constraint, "has-many")
 
 					modelData.AddRelationshipField(&FieldData{
@@ -310,14 +315,15 @@ func (w *Writer) getModelName(tableName string) string {
 	return modelName
 }
 
-// generateRelationshipFieldName generates a field name for a relationship based on the foreign key column
-func (w *Writer) generateRelationshipFieldName(constraint *models.Constraint) string {
+// 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" -> "RidFilepointerRequest"
+		// e.g., "rid_filepointer_request" -> "RelRIDFilepointerRequest"
 		return "Rel" + SnakeCaseToPascalCase(columnName)
 	}
 
@@ -325,6 +331,46 @@ func (w *Writer) generateRelationshipFieldName(constraint *models.Constraint) st
 	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, 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(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(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"
 func (w *Writer) getPackageName() string {
 	if w.options.PackageName != "" {