|
|
| from __future__ import annotations |
|
|
| from string import Template |
|
|
| ENTITIES = [ |
| dict( |
| entity="Patient", |
| table="patients", |
| entity_lower="patient", |
| entity_plural="patients", |
| fields='''\tOrganizationID uuid.UUID `gorm:"type:uuid;not null;index" json:"organization_id"` |
| \tName string `gorm:"type:varchar(255);not null" json:"name" validate:"required"` |
| \tContact string `gorm:"type:varchar(50);not null" json:"contact" validate:"required"` |
| \tCPF string `gorm:"type:varchar(14);uniqueIndex" json:"cpf,omitempty"` |
| \tSSN string `gorm:"type:varchar(11);uniqueIndex" json:"ssn,omitempty"` |
| \tDOB time.Time `gorm:"type:date" json:"dob"` |
| \tGender string `gorm:"type:varchar(20)" json:"gender,omitempty"` |
| \tAddress string `gorm:"type:text" json:"address,omitempty"`''', |
| lookup_field="CPF", |
| lookup_column="cpf", |
| ), |
| dict( |
| entity="Doctor", |
| table="doctors", |
| entity_lower="doctor", |
| entity_plural="doctors", |
| fields='''\tOrganizationID uuid.UUID `gorm:"type:uuid;not null;index" json:"organization_id"` |
| \tFullName string `gorm:"type:varchar(255);not null" json:"full_name" validate:"required"` |
| \tCPF string `gorm:"type:varchar(14);uniqueIndex" json:"cpf"` |
| \tCRM string `gorm:"type:varchar(20);uniqueIndex" json:"crm"` |
| \tSpecialty string `gorm:"type:varchar(100);not null" json:"specialty" validate:"required"` |
| \tEmail string `gorm:"type:varchar(255);uniqueIndex" json:"email" validate:"required,email"` |
| \tPhone string `gorm:"type:varchar(20)" json:"phone,omitempty"`''', |
| lookup_field="CRM", |
| lookup_column="crm", |
| ), |
| dict( |
| entity="Appointment", |
| table="appointments", |
| entity_lower="appointment", |
| entity_plural="appointments", |
| fields='''\tOrganizationID uuid.UUID `gorm:"type:uuid;not null;index" json:"organization_id"` |
| \tPatientID uuid.UUID `gorm:"type:uuid;not null;index" json:"patient_id"` |
| \tDoctorID uuid.UUID `gorm:"type:uuid;not null;index" json:"doctor_id"` |
| \tUserID uuid.UUID `gorm:"type:uuid;not null" json:"user_id"` |
| \tSpecialization string `gorm:"type:varchar(100);not null" json:"specialization"` |
| \tDateTime time.Time `gorm:"type:timestamptz;not null" json:"date_time"` |
| \tStatus string `gorm:"type:varchar(50);default:scheduled" json:"status"` |
| \tNotes string `gorm:"type:text" json:"notes,omitempty"`''', |
| lookup_field="Status", |
| lookup_column="status", |
| ), |
| dict( |
| entity="User", |
| table="users", |
| entity_lower="user", |
| entity_plural="users", |
| fields='''\tOrganizationID uuid.UUID `gorm:"type:uuid;not null;index" json:"organization_id"` |
| \tName string `gorm:"type:varchar(255);not null" json:"name" validate:"required"` |
| \tEmail string `gorm:"type:varchar(255);uniqueIndex;not null" json:"email" validate:"required,email"` |
| \tPassword string `gorm:"type:varchar(255);not null" json:"-"` // never serialised |
| \tRole string `gorm:"type:varchar(50);not null;default:user" json:"role" validate:"required,oneof=admin user doctor nurse"`''', |
| lookup_field="Email", |
| lookup_column="email", |
| ), |
| ] |
|
|
| GO_VERSIONS = ["1.21", "1.22", "1.23", "1.24"] |
|
|
| |
| |
| |
|
|
| _ENTITY_TEMPLATE = Template("""\ |
| <go_file> |
| <go_version> go$go_version |
| <go_pkg> entities |
| |
| // domain/entities/${entity_lower}.go |
| // Pattern: GORM entity with UUID PK + soft delete + JSON/validate tags |
| // Observed in: Medical-App-Core/domain/entities/ |
| package entities |
| |
| import ( |
| \t"time" |
| |
| \t"github.com/google/uuid" |
| \t"gorm.io/gorm" |
| ) |
| |
| // ${entity} represents the ${table} database table. |
| type ${entity} struct { |
| \tID uuid.UUID `gorm:"type:uuid;primaryKey;default:gen_random_uuid()" json:"id"` |
| \tCreatedAt time.Time `gorm:"autoCreateTime" json:"created_at"` |
| \tUpdatedAt time.Time `gorm:"autoUpdateTime" json:"updated_at"` |
| \tDeletedAt gorm.DeletedAt `gorm:"index" json:"-"` // soft delete |
| $fields |
| } |
| |
| // TableName overrides GORM's convention-based table name. |
| func (${entity}) TableName() string { return "${table}" } |
| |
| // BeforeCreate sets a UUID before the record is inserted. |
| func (e *${entity}) BeforeCreate(tx *gorm.DB) error { |
| \tif e.ID == uuid.Nil { |
| \t\te.ID = uuid.New() |
| \t} |
| \treturn nil |
| } |
| </go_file> |
| """) |
|
|
| _REPO_INTERFACE_TEMPLATE = Template("""\ |
| <go_file> |
| <go_version> go$go_version |
| <go_pkg> contracts |
| |
| // domain/repositories/contracts/${entity_lower}Repository.go |
| // Pattern: repository interface (contract) — domain layer knows nothing about GORM |
| // Observed in: Medical-App-Core/domain/repositories/contracts/ |
| package contracts |
| |
| import ( |
| \t"$module/domain/dtos" |
| \t"github.com/google/uuid" |
| ) |
| |
| // ${entity}Repository defines the persistence contract for ${entity} entities. |
| // Implementations live in infra/repositories/ and depend on GORM or any other ORM. |
| type ${entity}Repository interface { |
| \tCreate(dto dtos.${entity}DTO) (uuid.UUID, error) |
| \tFindByID(id uuid.UUID) (*dtos.${entity}DTO, error) |
| \tFindBy${lookup_field}(${lookup_column} string) (*dtos.${entity}DTO, error) |
| \tList(page, limit int) ([]dtos.${entity}DTO, error) |
| \tUpdate(id uuid.UUID, dto dtos.${entity}DTO) error |
| \tDelete(id uuid.UUID) error // soft delete |
| } |
| </go_file> |
| """) |
|
|
| _REPO_IMPL_TEMPLATE = Template("""\ |
| <go_file> |
| <go_version> go$go_version |
| <go_pkg> repositories |
| |
| // infra/repositories/${entity_lower}Repository.go |
| // Pattern: GORM implementation of the repository interface |
| // Observed in: Medical-App-Core/infra/repositories/ |
| package repositories |
| |
| import ( |
| \t"fmt" |
| |
| \t"$module/domain/dtos" |
| \t"$module/domain/entities" |
| \t"github.com/google/uuid" |
| \t"gorm.io/gorm" |
| ) |
| |
| // ${entity}RepositoryImpl implements contracts.${entity}Repository using GORM. |
| type ${entity}RepositoryImpl struct { |
| \tdb *gorm.DB |
| } |
| |
| // New${entity}Repository constructs a new ${entity}RepositoryImpl. |
| func New${entity}Repository(db *gorm.DB) *${entity}RepositoryImpl { |
| \treturn &${entity}RepositoryImpl{db: db} |
| } |
| |
| func (r *${entity}RepositoryImpl) Create(dto dtos.${entity}DTO) (uuid.UUID, error) { |
| \tentity := entities.${entity}{} // map DTO → entity fields |
| \t// (field mapping omitted for brevity — use a mapper or manual assignment) |
| \tif err := r.db.Create(&entity).Error; err != nil { |
| \t\treturn uuid.Nil, fmt.Errorf("${entity_lower} create: %w", err) |
| \t} |
| \treturn entity.ID, nil |
| } |
| |
| func (r *${entity}RepositoryImpl) FindByID(id uuid.UUID) (*dtos.${entity}DTO, error) { |
| \tvar entity entities.${entity} |
| \tif err := r.db.First(&entity, "id = ?", id).Error; err != nil { |
| \t\tif err == gorm.ErrRecordNotFound { |
| \t\t\treturn nil, fmt.Errorf("${entity_lower} not found: %s", id) |
| \t\t} |
| \t\treturn nil, fmt.Errorf("${entity_lower} find: %w", err) |
| \t} |
| \tdto := dtos.${entity}DTO{} // map entity → DTO |
| \treturn &dto, nil |
| } |
| |
| func (r *${entity}RepositoryImpl) FindBy${lookup_field}(${lookup_column} string) (*dtos.${entity}DTO, error) { |
| \tvar entity entities.${entity} |
| \tif err := r.db.Where("${lookup_column} = ?", ${lookup_column}).First(&entity).Error; err != nil { |
| \t\tif err == gorm.ErrRecordNotFound { |
| \t\t\treturn nil, fmt.Errorf("${entity_lower} with ${lookup_column}=%s not found", ${lookup_column}) |
| \t\t} |
| \t\treturn nil, fmt.Errorf("${entity_lower} find by ${lookup_column}: %w", err) |
| \t} |
| \tdto := dtos.${entity}DTO{} |
| \treturn &dto, nil |
| } |
| |
| func (r *${entity}RepositoryImpl) List(page, limit int) ([]dtos.${entity}DTO, error) { |
| \tvar entities []entities.${entity} |
| \toffset := (page - 1) * limit |
| \tif err := r.db.Offset(offset).Limit(limit).Find(&entities).Error; err != nil { |
| \t\treturn nil, fmt.Errorf("${entity_lower} list: %w", err) |
| \t} |
| \tdtos := make([]dtos.${entity}DTO, 0, len(entities)) |
| \t// map each entity to DTO |
| \treturn dtos, nil |
| } |
| |
| func (r *${entity}RepositoryImpl) Update(id uuid.UUID, dto dtos.${entity}DTO) error { |
| \tresult := r.db.Model(&entities.${entity}{}).Where("id = ?", id).Updates(dto) |
| \tif result.Error != nil { |
| \t\treturn fmt.Errorf("${entity_lower} update: %w", result.Error) |
| \t} |
| \tif result.RowsAffected == 0 { |
| \t\treturn fmt.Errorf("${entity_lower} not found: %s", id) |
| \t} |
| \treturn nil |
| } |
| |
| func (r *${entity}RepositoryImpl) Delete(id uuid.UUID) error { |
| \t// GORM soft delete: sets deleted_at instead of removing the row |
| \tresult := r.db.Delete(&entities.${entity}{}, "id = ?", id) |
| \tif result.Error != nil { |
| \t\treturn fmt.Errorf("${entity_lower} delete: %w", result.Error) |
| \t} |
| \tif result.RowsAffected == 0 { |
| \t\treturn fmt.Errorf("${entity_lower} not found: %s", id) |
| \t} |
| \treturn nil |
| } |
| </go_file> |
| """) |
|
|
| _DB_INIT_TEMPLATE = Template("""\ |
| <go_file> |
| <go_version> go$go_version |
| <go_pkg> initializers |
| |
| // initializers/database.go |
| // Pattern: GORM + PostgreSQL connection with pool config + env-based DSN |
| // Observed in: Medical-App-Core/initializers/database.go |
| package initializers |
| |
| import ( |
| \t"fmt" |
| \t"log" |
| \t"os" |
| \t"strings" |
| \t"time" |
| |
| \t"gorm.io/driver/postgres" |
| \t"gorm.io/gorm" |
| \t"gorm.io/gorm/logger" |
| ) |
| |
| // InitialDB opens a PostgreSQL connection using environment variables. |
| // Panics on failure — the app cannot run without a database. |
| func InitialDB() *gorm.DB { |
| \tdsn := buildDSN() |
| |
| \tdb, err := gorm.Open(postgres.Open(dsn), &gorm.Config{ |
| \t\tLogger: logger.Default.LogMode(logger.Info), |
| \t}) |
| \tif err != nil { |
| \t\tlog.Fatalf("database connection failed: %v", err) |
| \t} |
| |
| \tsqlDB, err := db.DB() |
| \tif err != nil { |
| \t\tlog.Fatalf("failed to get underlying sql.DB: %v", err) |
| \t} |
| \tsqlDB.SetMaxOpenConns(25) |
| \tsqlDB.SetMaxIdleConns(10) |
| \tsqlDB.SetConnMaxLifetime(5 * time.Minute) |
| |
| \tlog.Println("database connected:", maskDSN(dsn)) |
| \treturn db |
| } |
| |
| func buildDSN() string { |
| \treturn fmt.Sprintf( |
| \t\t"host=%s port=%s user=%s password=%s dbname=%s sslmode=%s TimeZone=%s", |
| \t\tgetEnv("DB_HOST", "localhost"), |
| \t\tgetEnv("DB_PORT", "5432"), |
| \t\tgetEnv("DB_USER", "postgres"), |
| \t\tos.Getenv("DB_PASSWORD"), |
| \t\tgetEnv("DB_NAME", "appdb"), |
| \t\tgetEnv("DB_SSLMODE", "disable"), |
| \t\tgetEnv("DB_TIMEZONE", "UTC"), |
| \t) |
| } |
| |
| func getEnv(key, fallback string) string { |
| \tif v := os.Getenv(key); v != "" { |
| \t\treturn v |
| \t} |
| \treturn fallback |
| } |
| |
| func maskDSN(dsn string) string { |
| \tpassword := os.Getenv("DB_PASSWORD") |
| \tif password == "" { |
| \t\treturn dsn |
| \t} |
| \treturn strings.ReplaceAll(dsn, password, "*****") |
| } |
| </go_file> |
| """) |
|
|
|
|
| class GormPatternGenerator: |
| """Generate GORM + PostgreSQL training examples.""" |
|
|
| def all_examples(self) -> list[str]: |
| examples: list[str] = [] |
| module = "medical-sas-api" |
| for ent in ENTITIES: |
| for ver in GO_VERSIONS: |
| examples.append(_ENTITY_TEMPLATE.substitute(go_version=ver, module=module, **ent)) |
| examples.append(_REPO_INTERFACE_TEMPLATE.substitute(go_version=ver, module=module, **ent)) |
| examples.append(_REPO_IMPL_TEMPLATE.substitute(go_version=ver, module=module, **ent)) |
| for ver in GO_VERSIONS: |
| examples.append(_DB_INIT_TEMPLATE.substitute(go_version=ver)) |
| return examples |
|
|
