chore(release): update package version to 1.0.53

* Update BuildBunTag to append "array" for array types
* Add tests for handling array types in TypeMapper
* Adjust regex in SanitizeStructTagValue to preserve array suffix

linux/arch/PKGBUILD

@@ -1,6 +1,6 @@
 # Maintainer: Hein (Warky Devs) <hein@warky.dev>
 pkgname=relspec
-pkgver=1.0.50
+pkgver=1.0.53
 pkgrel=1
 pkgdesc="RelSpec is a comprehensive database relations management tool that reads, transforms, and writes database table specifications across multiple formats and ORMs."
 arch=('x86_64' 'aarch64')

linux/centos/relspec.spec

@@ -1,5 +1,5 @@
 Name:           relspec
-Version:        1.0.50
+Version:        1.0.53
 Release:        1%{?dist}
 Summary:        RelSpec is a comprehensive database relations management tool that reads, transforms, and writes database table specifications across multiple formats and ORMs.
 

pkg/writers/bun/template_data.go

@@ -26,7 +26,10 @@ type ModelData struct {
 	Fields           []*FieldData
 	Config           *MethodConfig
 	PrimaryKeyField  string // Name of the primary key field
+	PrimaryKeyType   string // Go type of the primary key field
 	PrimaryKeyIsSQL  bool   // Whether PK uses SQL type (needs .Int64() call)
+	PrimaryKeyIsStr  bool   // Whether helper methods should use string IDs
+	PrimaryKeyIDType string // Helper method GetID/SetID/UpdateID type
 	IDColumnName     string // Name of the ID column in database
 	Prefix           string // 3-letter prefix
 }
@@ -140,7 +143,13 @@ func NewModelData(table *models.Table, schema string, typeMapper *TypeMapper, fl
 			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.PrimaryKeyType = goType
 			model.PrimaryKeyIsSQL = strings.Contains(goType, "resolvespec_common") || strings.Contains(goType, "sql_types")
+			model.PrimaryKeyIsStr = isStringLikePrimaryKeyType(goType)
+			model.PrimaryKeyIDType = "int64"
+			if model.PrimaryKeyIsStr {
+				model.PrimaryKeyIDType = "string"
+			}
 			break
 		}
 	}
@@ -192,6 +201,15 @@ func formatComment(description, comment string) string {
 	return comment
 }
 
+func isStringLikePrimaryKeyType(goType string) bool {
+	switch goType {
+	case "string", "sql.NullString", "resolvespec_common.SqlString", "resolvespec_common.SqlUUID":
+		return true
+	default:
+		return false
+	}
+}
+
 // 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 {

pkg/writers/bun/templates.go

@@ -44,33 +44,55 @@ func (m {{.Name}}) SchemaName() string {
 {{end}}
 {{if and .Config.GenerateGetID .PrimaryKeyField}}
 // GetID returns the primary key value
-func (m {{.Name}}) GetID() int64 {
+func (m {{.Name}}) GetID() {{.PrimaryKeyIDType}} {
 	{{if .PrimaryKeyIsSQL -}}
+	{{if .PrimaryKeyIsStr -}}
+	return m.{{.PrimaryKeyField}}.String()
+	{{- else -}}
 	return m.{{.PrimaryKeyField}}.Int64()
+	{{- end}}
+	{{- else -}}
+	{{if .PrimaryKeyIsStr -}}
+	return m.{{.PrimaryKeyField}}
 	{{- else -}}
 	return int64(m.{{.PrimaryKeyField}})
 	{{- end}}
+	{{- end}}
 }
 {{end}}
 {{if and .Config.GenerateGetIDStr .PrimaryKeyField}}
 // GetIDStr returns the primary key as a string
 func (m {{.Name}}) GetIDStr() string {
+	{{if .PrimaryKeyIsSQL -}}
+	return m.{{.PrimaryKeyField}}.String()
+	{{- else if .PrimaryKeyIsStr -}}
+	return m.{{.PrimaryKeyField}}
+	{{- else -}}
 	return fmt.Sprintf("%d", m.{{.PrimaryKeyField}})
+	{{- end}}
 }
 {{end}}
 {{if and .Config.GenerateSetID .PrimaryKeyField}}
 // SetID sets the primary key value
-func (m {{.Name}}) SetID(newid int64) {
+func (m {{.Name}}) SetID(newid {{.PrimaryKeyIDType}}) {
 	m.UpdateID(newid)
 }
 {{end}}
 {{if and .Config.GenerateUpdateID .PrimaryKeyField}}
 // UpdateID updates the primary key value
-func (m *{{.Name}}) UpdateID(newid int64) {
+func (m *{{.Name}}) UpdateID(newid {{.PrimaryKeyIDType}}) {
 	{{if .PrimaryKeyIsSQL -}}
-	m.{{.PrimaryKeyField}}.FromString(fmt.Sprintf("%d", newid))
+	{{if .PrimaryKeyIsStr -}}
+	m.{{.PrimaryKeyField}}.FromString(newid)
 	{{- else -}}
-	m.{{.PrimaryKeyField}} = int32(newid)
+	m.{{.PrimaryKeyField}}.FromString(fmt.Sprintf("%d", newid))
+	{{- end}}
+	{{- else -}}
+	{{if .PrimaryKeyIsStr -}}
+	m.{{.PrimaryKeyField}} = newid
+	{{- else -}}
+	m.{{.PrimaryKeyField}} = {{.PrimaryKeyType}}(newid)
+	{{- end}}
 	{{- end}}
 }
 {{end}}

pkg/writers/bun/type_mapper.go

@@ -311,10 +311,11 @@ func (tm *TypeMapper) BuildBunTag(column *models.Column, table *models.Table) st
 	if column.Type != "" {
 		// Sanitize type to remove backticks
 		typeStr := writers.SanitizeStructTagValue(column.Type)
+		isArray := pgsql.IsArrayType(typeStr)
 		hasExplicitTypeModifier := pgsql.HasExplicitTypeModifier(typeStr)
-		if !hasExplicitTypeModifier && column.Length > 0 {
+		if !hasExplicitTypeModifier && !isArray && column.Length > 0 {
 			typeStr = fmt.Sprintf("%s(%d)", typeStr, column.Length)
-		} else if !hasExplicitTypeModifier && column.Precision > 0 {
+		} else if !hasExplicitTypeModifier && !isArray && column.Precision > 0 {
 			if column.Scale > 0 {
 				typeStr = fmt.Sprintf("%s(%d,%d)", typeStr, column.Precision, column.Scale)
 			} else {
@@ -322,6 +323,9 @@ func (tm *TypeMapper) BuildBunTag(column *models.Column, table *models.Table) st
 			}
 		}
 		parts = append(parts, fmt.Sprintf("type:%s", typeStr))
+		if isArray && tm.typeStyle == writers.NullableTypeStdlib {
+			parts = append(parts, "array")
+		}
 	}
 
 	// Primary key

pkg/writers/bun/writer.go

@@ -102,8 +102,8 @@ func (w *Writer) writeSingleFile(db *models.Database) error {
 		}
 	}
 
-	// Add fmt import if GetIDStr is enabled
+	// Add fmt import when generated helper methods need string formatting.
-	if w.config.GenerateGetIDStr {
+	if w.needsFmtImport(templateData.Models) {
 		templateData.AddImport("\"fmt\"")
 	}
 
@@ -195,8 +195,8 @@ func (w *Writer) writeMultiFile(db *models.Database) error {
 				}
 			}
 
-			// Add fmt import if GetIDStr is enabled
+			// Add fmt import when generated helper methods need string formatting.
-			if w.config.GenerateGetIDStr {
+			if w.needsFmtImport(templateData.Models) {
 				templateData.AddImport("\"fmt\"")
 			}
 
@@ -301,6 +301,26 @@ func (w *Writer) addRelationshipFields(modelData *ModelData, table *models.Table
 	}
 }
 
+func (w *Writer) needsFmtImport(models []*ModelData) bool {
+	if w.config.GenerateGetIDStr {
+		for _, model := range models {
+			if model.PrimaryKeyField != "" && !model.PrimaryKeyIsSQL && !model.PrimaryKeyIsStr {
+				return true
+			}
+		}
+	}
+
+	if w.config.GenerateUpdateID {
+		for _, model := range models {
+			if model.PrimaryKeyField != "" && model.PrimaryKeyIsSQL && !model.PrimaryKeyIsStr {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
 // findTable finds a table by schema and name in the database
 func (w *Writer) findTable(schemaName, tableName string, db *models.Database) *models.Table {
 	for _, schema := range db.Schemas {

pkg/writers/bun/writer_test.go

@@ -574,6 +574,10 @@ func TestTypeMapper_SQLTypeToGoType_Bun(t *testing.T) {
 		{"boolean", false, "resolvespec_common.SqlBool"},
 		{"uuid", false, "resolvespec_common.SqlUUID"},
 		{"jsonb", false, "resolvespec_common.SqlJSONB"},
+		{"text[]", true, "resolvespec_common.SqlStringArray"},
+		{"text[]", false, "resolvespec_common.SqlStringArray"},
+		{"integer[]", true, "resolvespec_common.SqlInt32Array"},
+		{"bigint[]", false, "resolvespec_common.SqlInt64Array"},
 	}
 
 	for _, tt := range tests {
@@ -586,6 +590,116 @@ func TestTypeMapper_SQLTypeToGoType_Bun(t *testing.T) {
 	}
 }
 
+func TestWriter_UpdateIDTypeSafety_Bun(t *testing.T) {
+	tests := []struct {
+		name         string
+		pkType       string
+		expectedPK   string
+		expectedLine string
+		forbidInt32  bool
+	}{
+		{"int32_pk", "int", "int32", "m.ID = int32(newid)", false},
+		{"sql_int16_pk", "smallint", "resolvespec_common.SqlInt16", "m.ID.FromString(fmt.Sprintf(\"%d\", newid))", true},
+		{"int64_pk", "bigint", "int64", "m.ID = int64(newid)", true},
+	}
+
+	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)
+
+			if !strings.Contains(generated, tt.expectedLine) {
+				t.Errorf("Expected UpdateID to include %s\nGenerated:\n%s", tt.expectedLine, generated)
+			}
+
+			if !strings.Contains(generated, "ID            "+tt.expectedPK) {
+				t.Errorf("Expected generated primary key field type %s\nGenerated:\n%s", tt.expectedPK, generated)
+			}
+
+			if tt.forbidInt32 && strings.Contains(generated, "int32(newid)") {
+				t.Errorf("UpdateID should not cast to int32 for %s type\nGenerated:\n%s", tt.pkType, generated)
+			}
+
+			if !strings.Contains(generated, "UpdateID(newid int64)") {
+				t.Errorf("UpdateID should accept int64 parameter\nGenerated:\n%s", generated)
+			}
+		})
+	}
+}
+
+func TestWriter_StringPrimaryKeyHelpers_Bun(t *testing.T) {
+	table := models.InitTable("accounts", "public")
+	table.Columns["id"] = &models.Column{
+		Name:         "id",
+		Type:         "uuid",
+		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)
+
+	expectations := []string{
+		"resolvespec_common.SqlUUID",
+		"func (m ModelPublicAccounts) GetID() string",
+		"return m.ID.String()",
+		"func (m ModelPublicAccounts) GetIDStr() string",
+		"func (m ModelPublicAccounts) SetID(newid string)",
+		"func (m *ModelPublicAccounts) UpdateID(newid string)",
+		"m.ID.FromString(newid)",
+	}
+
+	for _, expected := range expectations {
+		if !strings.Contains(generated, expected) {
+			t.Errorf("Generated code missing expected content: %q\nGenerated:\n%s", expected, generated)
+		}
+	}
+
+	if strings.Contains(generated, "GetID() int64") || strings.Contains(generated, "UpdateID(newid int64)") {
+		t.Errorf("String primary keys should not use int64 helper signatures\nGenerated:\n%s", generated)
+	}
+}
+
 func TestTypeMapper_BuildBunTag(t *testing.T) {
 	mapper := NewTypeMapper("")
 
@@ -685,6 +799,24 @@ func TestTypeMapper_BuildBunTag(t *testing.T) {
 			},
 			want: []string{"id,", "type:bigserial,", "pk,", "autoincrement,"},
 		},
+		{
+			name: "text array type",
+			column: &models.Column{
+				Name:    "tags",
+				Type:    "text[]",
+				NotNull: false,
+			},
+			want: []string{"tags,", "type:text[],"},
+		},
+		{
+			name: "integer array type",
+			column: &models.Column{
+				Name:    "scores",
+				Type:    "integer[]",
+				NotNull: true,
+			},
+			want: []string{"scores,", "type:integer[],"},
+		},
 	}
 
 	for _, tt := range tests {
@@ -695,6 +827,30 @@ func TestTypeMapper_BuildBunTag(t *testing.T) {
 					t.Errorf("BuildBunTag() = %q, missing %q", result, part)
 				}
 			}
+			// resolvespec mode must NOT add "array" — SqlXxxArray uses sql.Scanner
+			if strings.Contains(result, ",array,") || strings.HasSuffix(result, ",array,") {
+				t.Errorf("BuildBunTag() = %q, must not contain 'array' in resolvespec mode", result)
+			}
+		})
+	}
+}
+
+func TestTypeMapper_BuildBunTag_StdlibArrayHasArrayTag(t *testing.T) {
+	mapper := NewTypeMapper(writers.NullableTypeStdlib)
+
+	cases := []struct {
+		name   string
+		column *models.Column
+	}{
+		{name: "text array", column: &models.Column{Name: "tags", Type: "text[]"}},
+		{name: "integer array", column: &models.Column{Name: "scores", Type: "integer[]", NotNull: true}},
+	}
+	for _, tt := range cases {
+		t.Run(tt.name, func(t *testing.T) {
+			result := mapper.BuildBunTag(tt.column, nil)
+			if !strings.Contains(result, "array") {
+				t.Errorf("BuildBunTag() = %q, expected 'array' in stdlib mode", result)
+			}
 		})
 	}
 }

pkg/writers/gorm/template_data.go

@@ -2,6 +2,7 @@ package gorm
 
 import (
 	"sort"
+	"strings"
 
 	"git.warky.dev/wdevs/relspecgo/pkg/models"
 	"git.warky.dev/wdevs/relspecgo/pkg/writers"
@@ -26,6 +27,9 @@ type ModelData struct {
 	Config           *MethodConfig
 	PrimaryKeyField  string // Name of the primary key field
 	PrimaryKeyType   string // Go type of the primary key field
+	PrimaryKeyIsSQL  bool   // Whether PK uses a SQL wrapper type
+	PrimaryKeyIsStr  bool   // Whether helper methods should use string IDs
+	PrimaryKeyIDType string // Helper method GetID/SetID/UpdateID type
 	IDColumnName     string // Name of the ID column in database
 	Prefix           string // 3-letter prefix
 }
@@ -136,7 +140,14 @@ func NewModelData(table *models.Table, schema string, typeMapper *TypeMapper, fl
 			// Sanitize column name to remove backticks
 			safeName := writers.SanitizeStructTagValue(col.Name)
 			model.PrimaryKeyField = SnakeCaseToPascalCase(safeName)
-			model.PrimaryKeyType = typeMapper.SQLTypeToGoType(col.Type, col.NotNull)
+			goType := typeMapper.SQLTypeToGoType(col.Type, col.NotNull)
+			model.PrimaryKeyType = goType
+			model.PrimaryKeyIsSQL = strings.Contains(goType, "sql_types.") || strings.Contains(goType, "sql.")
+			model.PrimaryKeyIsStr = isStringLikePrimaryKeyType(goType)
+			model.PrimaryKeyIDType = "int64"
+			if model.PrimaryKeyIsStr {
+				model.PrimaryKeyIDType = "string"
+			}
 			model.IDColumnName = safeName
 			break
 		}
@@ -189,6 +200,15 @@ func formatComment(description, comment string) string {
 	return comment
 }
 
+func isStringLikePrimaryKeyType(goType string) bool {
+	switch goType {
+	case "string", "sql.NullString", "sql_types.SqlString", "sql_types.SqlUUID":
+		return true
+	default:
+		return false
+	}
+}
+
 // 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 {

pkg/writers/gorm/templates.go

@@ -43,26 +43,56 @@ func (m {{.Name}}) SchemaName() string {
 {{end}}
 {{if and .Config.GenerateGetID .PrimaryKeyField}}
 // GetID returns the primary key value
-func (m {{.Name}}) GetID() int64 {
+func (m {{.Name}}) GetID() {{.PrimaryKeyIDType}} {
+	{{if .PrimaryKeyIsSQL -}}
+	{{if .PrimaryKeyIsStr -}}
+	return m.{{.PrimaryKeyField}}.String()
+	{{- else -}}
+	return m.{{.PrimaryKeyField}}.Int64()
+	{{- end}}
+	{{- else -}}
+	{{if .PrimaryKeyIsStr -}}
+	return m.{{.PrimaryKeyField}}
+	{{- else -}}
 	return int64(m.{{.PrimaryKeyField}})
+	{{- end}}
+	{{- end}}
 }
 {{end}}
 {{if and .Config.GenerateGetIDStr .PrimaryKeyField}}
 // GetIDStr returns the primary key as a string
 func (m {{.Name}}) GetIDStr() string {
+	{{if .PrimaryKeyIsSQL -}}
+	return m.{{.PrimaryKeyField}}.String()
+	{{- else if .PrimaryKeyIsStr -}}
+	return m.{{.PrimaryKeyField}}
+	{{- else -}}
 	return fmt.Sprintf("%d", m.{{.PrimaryKeyField}})
+	{{- end}}
 }
 {{end}}
 {{if and .Config.GenerateSetID .PrimaryKeyField}}
 // SetID sets the primary key value
-func (m {{.Name}}) SetID(newid int64) {
+func (m {{.Name}}) SetID(newid {{.PrimaryKeyIDType}}) {
 	m.UpdateID(newid)
 }
 {{end}}
 {{if and .Config.GenerateUpdateID .PrimaryKeyField}}
 // UpdateID updates the primary key value
-func (m *{{.Name}}) UpdateID(newid int64) {
+func (m *{{.Name}}) UpdateID(newid {{.PrimaryKeyIDType}}) {
+	{{if .PrimaryKeyIsSQL -}}
+	{{if .PrimaryKeyIsStr -}}
+	m.{{.PrimaryKeyField}}.FromString(newid)
+	{{- else -}}
+	m.{{.PrimaryKeyField}}.FromString(fmt.Sprintf("%d", newid))
+	{{- end}}
+	{{- else -}}
+	{{if .PrimaryKeyIsStr -}}
+	m.{{.PrimaryKeyField}} = newid
+	{{- else -}}
 	m.{{.PrimaryKeyField}} = {{.PrimaryKeyType}}(newid)
+	{{- end}}
+	{{- end}}
 }
 {{end}}
 {{if and .Config.GenerateGetIDName .IDColumnName}}

pkg/writers/gorm/writer.go

@@ -99,8 +99,8 @@ func (w *Writer) writeSingleFile(db *models.Database) error {
 		}
 	}
 
-	// Add fmt import if GetIDStr is enabled
+	// Add fmt import when generated helper methods need string formatting.
-	if w.config.GenerateGetIDStr {
+	if w.needsFmtImport(templateData.Models) {
 		templateData.AddImport("\"fmt\"")
 	}
 
@@ -189,8 +189,8 @@ func (w *Writer) writeMultiFile(db *models.Database) error {
 				}
 			}
 
-			// Add fmt import if GetIDStr is enabled
+			// Add fmt import when generated helper methods need string formatting.
-			if w.config.GenerateGetIDStr {
+			if w.needsFmtImport(templateData.Models) {
 				templateData.AddImport("\"fmt\"")
 			}
 
@@ -295,6 +295,26 @@ func (w *Writer) addRelationshipFields(modelData *ModelData, table *models.Table
 	}
 }
 
+func (w *Writer) needsFmtImport(models []*ModelData) bool {
+	if w.config.GenerateGetIDStr {
+		for _, model := range models {
+			if model.PrimaryKeyField != "" && !model.PrimaryKeyIsSQL && !model.PrimaryKeyIsStr {
+				return true
+			}
+		}
+	}
+
+	if w.config.GenerateUpdateID {
+		for _, model := range models {
+			if model.PrimaryKeyField != "" && model.PrimaryKeyIsSQL && !model.PrimaryKeyIsStr {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
 // findTable finds a table by schema and name in the database
 func (w *Writer) findTable(schemaName, tableName string, db *models.Database) *models.Table {
 	for _, schema := range db.Schemas {

pkg/writers/gorm/writer_test.go

@@ -598,6 +598,55 @@ func TestWriter_UpdateIDTypeSafety(t *testing.T) {
 	}
 }
 
+func TestWriter_StringPrimaryKeyHelpers_Gorm(t *testing.T) {
+	table := models.InitTable("accounts", "public")
+	table.Columns["id"] = &models.Column{
+		Name:         "id",
+		Type:         "uuid",
+		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)
+
+	expectations := []string{
+		"ID string",
+		"func (m ModelPublicAccounts) GetID() string",
+		"return m.ID",
+		"func (m ModelPublicAccounts) GetIDStr() string",
+		"func (m ModelPublicAccounts) SetID(newid string)",
+		"func (m *ModelPublicAccounts) UpdateID(newid string)",
+		"m.ID = newid",
+	}
+
+	for _, expected := range expectations {
+		if !strings.Contains(generated, expected) {
+			t.Errorf("Generated code missing expected content: %q\nGenerated:\n%s", expected, generated)
+		}
+	}
+
+	if strings.Contains(generated, "GetID() int64") || strings.Contains(generated, "UpdateID(newid int64)") {
+		t.Errorf("String primary keys should not use int64 helper signatures\nGenerated:\n%s", generated)
+	}
+}
+
 func TestNameConverter_SnakeCaseToPascalCase(t *testing.T) {
 	tests := []struct {
 		input    string
@@ -658,6 +707,10 @@ func TestTypeMapper_SQLTypeToGoType(t *testing.T) {
 		{"timestamp", false, "sql_types.SqlTimeStamp"},
 		{"boolean", true, "bool"},
 		{"boolean", false, "sql_types.SqlBool"},
+		{"text[]", true, "sql_types.SqlStringArray"},
+		{"text[]", false, "sql_types.SqlStringArray"},
+		{"integer[]", true, "sql_types.SqlInt32Array"},
+		{"bigint[]", false, "sql_types.SqlInt64Array"},
 	}
 
 	for _, tt := range tests {
@@ -670,6 +723,21 @@ func TestTypeMapper_SQLTypeToGoType(t *testing.T) {
 	}
 }
 
+func TestTypeMapper_BuildGormTag_ArrayType(t *testing.T) {
+	mapper := NewTypeMapper("")
+
+	col := &models.Column{
+		Name:    "tags",
+		Type:    "text[]",
+		NotNull: false,
+	}
+
+	tag := mapper.BuildGormTag(col, nil)
+	if !strings.Contains(tag, "type:text[]") {
+		t.Fatalf("expected array type to be preserved, got %q", tag)
+	}
+}
+
 func TestTypeMapper_BuildGormTag_PreservesExplicitTypeModifiers(t *testing.T) {
 	mapper := NewTypeMapper("")
 

pkg/writers/pgsql/writer.go

@@ -1251,6 +1251,9 @@ func isIntegerType(colType string) bool {
 func isTextType(colType string) bool {
 	textTypes := []string{"text", "varchar", "character varying", "char", "character", "string"}
 	lowerType := strings.ToLower(colType)
+	if strings.HasSuffix(lowerType, "[]") {
+		return false
+	}
 	for _, t := range textTypes {
 		if strings.HasPrefix(lowerType, t) {
 			return true

pkg/writers/pgsql/writer_test.go

@@ -87,6 +87,43 @@ func TestWriteDatabase(t *testing.T) {
 	}
 }
 
+func TestWriteDatabase_GinIndexOnTextArrayDoesNotUseTrigramOperatorClass(t *testing.T) {
+	db := models.InitDatabase("testdb")
+	schema := models.InitSchema("public")
+
+	table := models.InitTable("plans", "public")
+
+	tagsCol := models.InitColumn("tags", "plans", "public")
+	tagsCol.Type = "text[]"
+	table.Columns["tags"] = tagsCol
+
+	index := &models.Index{
+		Name:    "idx_plans_tags",
+		Type:    "gin",
+		Columns: []string{"tags"},
+	}
+	table.Indexes[index.Name] = index
+
+	schema.Tables = append(schema.Tables, table)
+	db.Schemas = append(db.Schemas, schema)
+
+	var buf bytes.Buffer
+	writer := NewWriter(&writers.WriterOptions{})
+	writer.writer = &buf
+
+	if err := writer.WriteDatabase(db); err != nil {
+		t.Fatalf("WriteDatabase failed: %v", err)
+	}
+
+	output := buf.String()
+	if !strings.Contains(output, `USING gin (tags)`) {
+		t.Fatalf("expected GIN index on array column without explicit trigram opclass, got:\n%s", output)
+	}
+	if strings.Contains(output, "gin_trgm_ops") {
+		t.Fatalf("did not expect gin_trgm_ops for text[] column, got:\n%s", output)
+	}
+}
+
 func TestWriteForeignKeys(t *testing.T) {
 	// Create a test database with two related tables
 	db := models.InitDatabase("testdb")

pkg/writers/writer.go

@@ -207,7 +207,8 @@ func quoteSQLLiteral(value string) string {
 // - 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*`)
+	// Require at least one character inside brackets to avoid stripping PostgreSQL array suffix "[]"
+	commentRegex := regexp.MustCompile(`\s*\[[^\]]+\]\s*`)
 	value = commentRegex.ReplaceAllString(value, "")
 
 	// Trim whitespace