fields

func (*BelongsToField) AutoOptions ¶

func (b *BelongsToField) AutoOptions(displayField string) *BelongsToField

AutoOptions, ilgili tablodan otomatik seçenek oluşturmayı etkinleştirir.

Bu metod, backend'in veritabanından otomatik olarak tüm kayıtları çekip form elemanları (Combobox/Select) için seçenekler oluşturmasını sağlar. Manuel olarak Options callback'i tanımlamaya gerek kalmaz.

Parametreler ¶

- **displayField**: Seçenek etiketi için kullanılacak sütun adı (örn. "name", "title", "email")

Kullanım Örneği ¶

field := fields.BelongsTo("Author", "author_id", "authors").
    AutoOptions("name")
// Backend otomatik olarak authors tablosundan tüm kayıtları çeker
// ve "name" sütununu etiket olarak kullanır

Önemli Notlar ¶

- AutoOptions kullanıldığında, backend otomatik olarak ilgili tablodan tüm kayıtları çeker - Büyük tablolar için performans sorunu olabilir, bu durumda Query() ile filtreleme yapılmalıdır - displayField, ilgili tabloda mevcut bir sütun olmalıdır

Döndürür:

• BelongsToField pointer'ı (method chaining için)

Daha fazla bilgi için docs/Relationships.md dosyasına bakın.

func (*BelongsToField) DisplayUsing ¶

func (b *BelongsToField) DisplayUsing(key string) *BelongsToField

DisplayUsing, ilişkili resource'u göstermek için kullanılacak key'i ayarlar.

Bu metod, ilişkili kaydın hangi field'ının görüntüleneceğini belirler. Varsayılan olarak "name" field'ı kullanılır.

Parametreler ¶

- **key**: Görüntüleme için kullanılacak field adı (örn. "name", "title", "email", "username")

Kullanım Örneği ¶

field := fields.BelongsTo("Author", "author_id", "authors").
    DisplayUsing("email")
// Author'un email'i görüntülenir

Yaygın Kullanım Senaryoları ¶

- **name**: Genel amaçlı görüntüleme (varsayılan) - **title**: Başlık alanları için - **email**: E-posta adresi görüntüleme - **username**: Kullanıcı adı görüntüleme - **full_name**: Tam ad görüntüleme

Döndürür:

• BelongsToField pointer'ı (method chaining için)

func (*BelongsToField) Extract ¶

func (b *BelongsToField) Extract(record any)

Extract, BelongsTo ilişkisini minimal formatta serialize eder.

Bu metod, ilişkili kaydı {"id": ..., "title": ...} formatında döndürür. Record title pattern'ini takip eder.

Çalışma Mantığı ¶

1. Schema.Extract ile foreign key değerini alır 2. İlişki eager loaded ise ve RelatedResource varsa:

• İlişkili kaydın ID'sini alır
• RelatedResource.RecordTitle ile başlığı alır
• {"id": foreignKey, "title": recordTitle} formatında döndürür

3. İlişki yüklenmemişse veya nil ise null döndürür

Önemli Notlar ¶

- İlişki eager loaded olmalı (WithEagerLoad veya Preload kullanılmalı) - RelatedResource nil ise sadece foreign key değeri döner - DisplayUsing callback'i varsa öncelik verilir

Kullanım Örneği ¶

// Post -> Author ilişkisi
post := &Post{
    ID: 1,
    AuthorID: 5,
    Author: &User{ID: 5, Name: "John Doe"},
}
field.Extract(&post)
// field.Data = {"id": 5, "title": "John Doe"}

// İlişki yüklenmemiş
post := &Post{ID: 1, AuthorID: 5, Author: nil}
field.Extract(&post)
// field.Data = nil

Parametreler:

• record: Kayıt instance'ı (pointer olmalı)

func (*BelongsToField) GetDisplayKey ¶

func (b *BelongsToField) GetDisplayKey() string

GetDisplayKey returns the display key

func (*BelongsToField) GetForeignKey ¶

func (b *BelongsToField) GetForeignKey() string

GetForeignKey, foreign key sütun adını döndürür.

Bu metod, BelongsTo ilişkisinde kullanılan foreign key sütununun adını döndürür. GormRelationConfig'den foreign key bilgisini alır.

Dönüş Değeri ¶

- Foreign key sütun adı (örn. "author_id", "user_id") - GormRelationConfig nil ise boş string döner

Kullanım Örneği ¶

field := fields.BelongsTo("Author", "author_id", "authors")
foreignKey := field.GetForeignKey() // "author_id"

Döndürür:

• Foreign key sütun adı

func (*BelongsToField) GetHoverCard ¶

func (b *BelongsToField) GetHoverCard() *HoverCardConfig

GetHoverCard, hover card konfigürasyonunu döndürür.

Bu metod, hover card konfigürasyonunu alır.

Döndürür:

• HoverCardConfig pointer'ı (nil olabilir)

func (*BelongsToField) GetLoadingStrategy ¶

func (b *BelongsToField) GetLoadingStrategy() LoadingStrategy

GetLoadingStrategy returns the loading strategy

func (*BelongsToField) GetOwnerKeyColumn ¶

func (b *BelongsToField) GetOwnerKeyColumn() string

GetOwnerKeyColumn, owner key sütun adını döndürür.

Bu metod, BelongsTo ilişkisinde kullanılan owner key (references) sütununun adını döndürür. Owner key, ilişkili tablodaki referans sütunudur (genellikle primary key).

Dönüş Değeri ¶

- Owner key sütun adı (örn. "id", "uuid") - GormRelationConfig nil ise varsayılan olarak "id" döner

Kullanım Örneği ¶

field := fields.BelongsTo("Author", "author_id", "authors")
ownerKey := field.GetOwnerKeyColumn() // "id"

Döndürür:

• Owner key sütun adı

func (*BelongsToField) GetQueryCallback ¶

func (b *BelongsToField) GetQueryCallback() func(interface{}) interface{}

GetQueryCallback returns the query callback

func (*BelongsToField) GetRelatedResource ¶

func (b *BelongsToField) GetRelatedResource() string

GetRelatedResource returns the related resource slug

func (*BelongsToField) GetRelatedResourceSlug ¶

func (b *BelongsToField) GetRelatedResourceSlug() string

GetRelatedResourceSlug, ilişkili resource'un slug'ını döndürür.

Bu metod, BelongsTo ilişkisinde kullanılan ilişkili resource'un slug'ını döndürür.

Dönüş Değeri ¶

- İlişkili resource slug'ı (örn. "authors", "users", "categories")

Kullanım Örneği ¶

field := fields.BelongsTo("Author", "author_id", "authors")
slug := field.GetRelatedResourceSlug() // "authors"

Döndürür:

• İlişkili resource slug'ı

func (*BelongsToField) GetRelatedTableName ¶

func (b *BelongsToField) GetRelatedTableName() string

GetRelatedTableName, ilişkili tablo adını döndürür.

Bu metod, BelongsTo ilişkisinde kullanılan ilişkili tablonun adını döndürür. Raw SQL sorguları için kullanılır.

Dönüş Değeri ¶

- İlişkili tablo adı (örn. "authors", "users", "categories")

Kullanım Örneği ¶

field := fields.BelongsTo("Author", "author_id", "authors")
tableName := field.GetRelatedTableName() // "authors"

Döndürür:

• İlişkili tablo adı

func (*BelongsToField) GetRelationshipName ¶

func (b *BelongsToField) GetRelationshipName() string

GetRelationshipName returns the relationship name

func (*BelongsToField) GetRelationshipType ¶

func (b *BelongsToField) GetRelationshipType() string

GetRelationshipType returns the relationship type

func (*BelongsToField) GetSearchableColumns ¶

func (b *BelongsToField) GetSearchableColumns() []string

GetSearchableColumns returns the searchable columns

func (*BelongsToField) GetTypes ¶

func (b *BelongsToField) GetTypes() map[string]string

GetTypes returns the type mappings (not used for BelongsTo)

func (*BelongsToField) HoverCard ¶

func (b *BelongsToField) HoverCard(hoverStruct interface{}) *BelongsToField

HoverCard, hover card struct'ını ayarlar ve hover card'ı etkinleştirir.

Bu metod, hover card için kullanılacak struct'ı belirler ve hover card özelliğini aktif eder.

Parametreler ¶

- **hoverStruct**: Hover card verisi için kullanılacak struct (örn. &AuthorHoverCard{})

Kullanım Örneği ¶

type AuthorHoverCard struct {
    Avatar string `json:"avatar"`
    Name   string `json:"name"`
    Email  string `json:"email"`
    Phone  string `json:"phone"`
}

field := fields.BelongsTo("Author", "author_id", "authors").
    DisplayUsing("name").
    HoverCard(&AuthorHoverCard{})

Döndürür:

• BelongsToField pointer'ı (method chaining için)

func (*BelongsToField) IsRequired ¶

func (b *BelongsToField) IsRequired() bool

IsRequired returns whether the field is required

func (*BelongsToField) Query ¶

func (b *BelongsToField) Query(fn func(interface{}) interface{}) *BelongsToField

Query sets the query callback for customizing relationship query

func (*BelongsToField) ResolveHoverCard ¶

func (b *BelongsToField) ResolveHoverCard(resolver HoverCardResolver) *BelongsToField

ResolveHoverCard, hover card verilerini çözmek için callback fonksiyonunu ayarlar.

Bu metod, hover card açıldığında çağrılacak resolver fonksiyonunu belirler. Resolver, ilişkili kaydın hover card verilerini döndürür.

Parametreler ¶

- **resolver**: Hover card resolver callback fonksiyonu

Kullanım Örneği ¶

field := fields.BelongsTo("Author", "author_id", "authors").
    DisplayUsing("name").
    HoverCard(&AuthorHoverCard{}).
    ResolveHoverCard(func(ctx context.Context, record interface{}, relatedID interface{}, field fields.Field) (interface{}, error) {
        // İlişkili kaydı veritabanından al
        author := &Author{}
        if err := db.First(author, relatedID).Error; err != nil {
            return nil, err
        }

        // Hover card verisini döndür
        return &AuthorHoverCard{
            Avatar: author.Avatar,
            Name:   author.Name,
            Email:  author.Email,
            Phone:  author.Phone,
        }, nil
    })

API Endpoint ¶

Frontend, hover card açıldığında şu endpoint'e istek atar:

GET /api/resource/{resource}/resolver/{field_name}?id={related_id}
POST /api/resource/{resource}/resolver/{field_name} (body: {id: related_id})

Döndürür:

• BelongsToField pointer'ı (method chaining için)

func (*BelongsToField) ResolveRelationship ¶

func (b *BelongsToField) ResolveRelationship(item interface{}) (interface{}, error)

ResolveRelationship resolves the relationship value using reflection

func (*BelongsToField) Searchable ¶

func (b *BelongsToField) Searchable() Element

Searchable, alanı aranabilir olarak işaretler (Element interface'ini implement eder).

Bu metod, alanın global arama işlemlerine dahil edilmesini sağlar. Global arama yapıldığında, bu alan da arama sonuçlarına dahil edilir.

Kullanım Örneği ¶

field := fields.BelongsTo("Author", "author_id", "authors").
    Searchable()
// Bu alan global arama işlemlerine dahil edilir

Önemli Notlar ¶

- Global arama, tüm aranabilir alanlarda arama yapar - WithSearchableColumns() ile birlikte kullanılmalıdır - Performans için dikkatli kullanılmalıdır

Döndürür:

• Element interface'i (method chaining için)

func (*BelongsToField) ValidateRelationship ¶

func (b *BelongsToField) ValidateRelationship(value interface{}) error

ValidateRelationship validates the relationship

func (*BelongsToField) WithEagerLoad ¶

func (b *BelongsToField) WithEagerLoad() *BelongsToField

WithEagerLoad sets the loading strategy to eager loading

func (*BelongsToField) WithHoverCard ¶

func (b *BelongsToField) WithHoverCard(config HoverCardConfig) *BelongsToField

WithHoverCard, hover card konfigürasyonunu ayarlar.

Bu metod, index ve detail sayfalarında ilişkili kaydın hover card ile nasıl görüntüleneceğini belirler.

Parametreler ¶

- **config**: Hover card konfigürasyonu

Kullanım Örneği (Deprecated - Yeni API kullanın) ¶

field := fields.BelongsTo("Author", "author_id", "authors").
    WithHoverCard(*fields.NewHoverCardConfig())

Yeni API (Önerilen) ¶

field := fields.BelongsTo("Author", "author_id", "authors").
    HoverCard(&AuthorHoverCard{}).
    ResolveHoverCard(func(ctx context.Context, record interface{}, relatedID interface{}, field fields.Field) (interface{}, error) {
        // Custom logic
        return &AuthorHoverCard{...}, nil
    })

Döndürür:

• BelongsToField pointer'ı (method chaining için)

func (*BelongsToField) WithLazyLoad ¶

func (b *BelongsToField) WithLazyLoad() *BelongsToField

WithLazyLoad sets the loading strategy to lazy loading

func (*BelongsToField) WithSearchableColumns ¶

func (b *BelongsToField) WithSearchableColumns(columns ...string) *BelongsToField

WithSearchableColumns, BelongsTo için aranabilir sütunları ayarlar.

Bu metod, ilişkili kayıtlarda arama yapılabilecek sütunları belirler. Bu sütunlar, combobox'ta arama yaparken kullanılır.

Parametreler ¶

- **columns**: Aranabilir sütun adlarının listesi (örn. "name", "email", "username")

Kullanım Örneği ¶

field := fields.BelongsTo("Author", "author_id", "authors").
    WithSearchableColumns("name", "email", "username")
// Kullanıcı combobox'ta arama yaptığında name, email ve username sütunlarında arama yapılır

Önemli Notlar ¶

- Aranabilir sütunlar, ilgili tabloda mevcut olmalıdır - Çok fazla sütun eklemek performans sorunlarına neden olabilir - Genellikle 2-4 sütun yeterlidir

Döndürür:

• BelongsToField pointer'ı (method chaining için)

func (*BelongsToManyField) AutoOptions ¶

func (b *BelongsToManyField) AutoOptions(displayField string) *BelongsToManyField

AutoOptions enables automatic options generation from the related table. displayField is the column name to use for the option label.

func (*BelongsToManyField) Count ¶

func (b *BelongsToManyField) Count() int64

Count returns the count of related resources

func (*BelongsToManyField) Extract ¶

func (b *BelongsToManyField) Extract(resource interface{})

Extract, BelongsToMany ilişkisini minimal formatta serialize eder.

Bu metod, ilişkili kayıtları [{"id": ..., "title": ...}, ...] formatında döndürür. Record title pattern'ini takip eder.

Çalışma Mantığı ¶

1. Schema.Extract ile ilişki verilerini alır 2. Data nil ise boş array döndürür 3. RelatedResource varsa her kayıt için:

• ID field'ını alır
• RelatedResource.RecordTitle ile başlığı alır
• {"id": ..., "title": ...} formatında ekler

4. İlişki yüklenmemişse boş array döndürür

Önemli Notlar ¶

- İlişki eager loaded olmalı (WithEagerLoad veya Preload kullanılmalı) - RelatedResource nil ise mevcut veri döner - HasMany ile aynı mantıkta çalışır

Kullanım Örneği ¶

// User -> Roles ilişkisi
user := &User{
    ID: 1,
    Roles: []Role{
        {ID: 1, Name: "Admin"},
        {ID: 2, Name: "Editor"},
    },
}
field.Extract(&user)
// field.Data = [{"id": 1, "title": "Admin"}, {"id": 2, "title": "Editor"}]

// İlişki yüklenmemiş
user := &User{ID: 1, Roles: nil}
field.Extract(&user)
// field.Data = []

Parametreler:

• record: Kayıt instance'ı (pointer olmalı)

func (*BelongsToManyField) ForeignKey ¶

func (b *BelongsToManyField) ForeignKey(key string) *BelongsToManyField

ForeignKey sets the foreign key in pivot table

func (*BelongsToManyField) GetDisplayKey ¶

func (b *BelongsToManyField) GetDisplayKey() string

GetDisplayKey returns the display key (not used for BelongsToMany)

func (*BelongsToManyField) GetLoadingStrategy ¶

func (b *BelongsToManyField) GetLoadingStrategy() LoadingStrategy

GetLoadingStrategy returns the loading strategy

func (*BelongsToManyField) GetQueryCallback ¶

func (b *BelongsToManyField) GetQueryCallback() func(interface{}) interface{}

GetQueryCallback returns the query callback

func (*BelongsToManyField) GetRelatedResourceSlug ¶

func (b *BelongsToManyField) GetRelatedResourceSlug() string

GetRelatedResource returns the related resource slug

func (*BelongsToManyField) GetRelationshipName ¶

func (b *BelongsToManyField) GetRelationshipName() string

GetRelationshipName returns the relationship name

func (*BelongsToManyField) GetRelationshipType ¶

func (b *BelongsToManyField) GetRelationshipType() string

GetRelationshipType returns the relationship type

func (*BelongsToManyField) GetSearchableColumns ¶

func (b *BelongsToManyField) GetSearchableColumns() []string

GetSearchableColumns returns the searchable columns (not used for BelongsToMany)

func (*BelongsToManyField) GetTypes ¶

func (b *BelongsToManyField) GetTypes() map[string]string

GetTypes returns the type mappings (not used for BelongsToMany)

func (*BelongsToManyField) IsRequired ¶

func (b *BelongsToManyField) IsRequired() bool

IsRequired returns whether the field is required

func (*BelongsToManyField) PivotTable ¶

func (b *BelongsToManyField) PivotTable(table string) *BelongsToManyField

PivotTable sets the pivot table name

func (*BelongsToManyField) Query ¶

func (b *BelongsToManyField) Query(fn func(interface{}) interface{}) *BelongsToManyField

Query sets the query callback for customizing relationship query

func (*BelongsToManyField) RelatedKey ¶

func (b *BelongsToManyField) RelatedKey(key string) *BelongsToManyField

RelatedKey sets the related key in pivot table

func (*BelongsToManyField) ResolveRelationship ¶

func (b *BelongsToManyField) ResolveRelationship(item interface{}) (interface{}, error)

ResolveRelationship resolves the relationship by loading through pivot table

func (*BelongsToManyField) Searchable ¶

func (b *BelongsToManyField) Searchable() Element

Searchable marks the element as searchable (implements Element interface)

func (*BelongsToManyField) ValidateRelationship ¶

func (b *BelongsToManyField) ValidateRelationship(value interface{}) error

ValidateRelationship validates the relationship

func (*BelongsToManyField) WithEagerLoad ¶

func (b *BelongsToManyField) WithEagerLoad() *BelongsToManyField

WithEagerLoad sets the loading strategy to eager loading

func (*BelongsToManyField) WithLazyLoad ¶

func (b *BelongsToManyField) WithLazyLoad() *BelongsToManyField

WithLazyLoad sets the loading strategy to lazy loading

func (*CustomValidatorRegistry) Apply ¶

func (r *CustomValidatorRegistry) Apply(name string, value interface{}, context interface{}) error

Apply applies a custom validator

func (*CustomValidatorRegistry) Get ¶

func (r *CustomValidatorRegistry) Get(name string) (ValidatorFunc, bool)

Get retrieves a custom validator

func (*CustomValidatorRegistry) Register ¶

func (r *CustomValidatorRegistry) Register(name string, validator ValidatorFunc)

Register registers a custom validator

func (*DependencyResolver) DetectCircularDependencies ¶

func (r *DependencyResolver) DetectCircularDependencies() error

DetectCircularDependencies ¶

Alan bağımlılıkları arasında döngüsel (circular) bağımlılık olup olmadığını tespit eder.

## Amaç

Bağımlılık grafiğinde döngü (cycle) olup olmadığını kontrol eder. Döngüsel bağımlılıklar sonsuz döngülere ve stack overflow hatalarına neden olabileceği için, sistem başlatılırken veya alan tanımları değiştiğinde bu kontrolün yapılması kritik önem taşır.

## Dönüş Değeri

- `nil`: Döngüsel bağımlılık yok, sistem güvenli - `error`: Döngüsel bağımlılık tespit edildi, hata mesajında ilgili alan belirtilir

## Döngüsel Bağımlılık Nedir?

Döngüsel bağımlılık, alanların birbirine doğrudan veya dolaylı olarak bağımlı olduğu ve bir döngü oluşturduğu durumdur.

### Örnekler

**Doğrudan Döngü:** ``` Alan A -> Alan B -> Alan A ```

**Dolaylı Döngü:** ``` Alan A -> Alan B -> Alan C -> Alan A ```

**Karmaşık Döngü:** ``` Alan A -> Alan B -> Alan C

  ↓         ↓
Alan D -> Alan E -> Alan A

```

## Kullanım Örneği

```go // Alan tanımları

fields := []*Schema{
    {Key: "country", DependsOnFields: []string{"city"}},  // Hatalı!
    {Key: "city", DependsOnFields: []string{"country"}},  // Döngü!
}

resolver := NewDependencyResolver(fields, "form")

// Döngüsel bağımlılık kontrolü

if err := resolver.DetectCircularDependencies(); err != nil {
    log.Fatal(err) // "circular dependency detected involving field: country"
}

```

## Doğru Kullanım

```go // Doğru alan tanımları (tek yönlü bağımlılık)

fields := []*Schema{
    {Key: "country", DependsOnFields: []string{}},
    {Key: "city", DependsOnFields: []string{"country"}},
    {Key: "district", DependsOnFields: []string{"city"}},
}

resolver := NewDependencyResolver(fields, "form")

// Kontrol başarılı

if err := resolver.DetectCircularDependencies(); err != nil {
    log.Fatal(err)
}

// Hata yok, sistem güvenli ```

## Algoritma: DFS (Depth-First Search)

1. Her alan için DFS başlat (henüz ziyaret edilmemişse) 2. Alanı ziyaret edildi olarak işaretle 3. Alanı recursion stack'e ekle 4. Alanın bağımlılarını kontrol et:

• Bağımlı henüz ziyaret edilmemişse, recursive DFS çağrısı yap
• Bağımlı recursion stack'te varsa, döngü tespit edildi

5. Alanı recursion stack'ten çıkar

## Performans

- **Zaman Karmaşıklığı**: O(V + E)

• V: Toplam alan sayısı
• E: Toplam bağımlılık sayısı

- **Alan Karmaşıklığı**: O(V)

• visited ve recStack map'leri için

## Ne Zaman Çağrılmalı?

1. **Sistem Başlatma**: Uygulama başlarken tüm alanlar için kontrol 2. **Alan Tanımı Değişikliği**: Yeni alan eklendiğinde veya bağımlılık değiştiğinde 3. **Geliştirme Aşaması**: Unit testlerde otomatik kontrol 4. **Deployment Öncesi**: CI/CD pipeline'da validasyon

## Önemli Notlar

**UYARI**: Bu fonksiyon mutlaka çağrılmalıdır. Döngüsel bağımlılıklar runtime'da sonsuz döngüye ve sistem çökmesine neden olabilir.

**NOT**: Hata mesajı sadece döngüye dahil olan alanlardan birini gösterir. Tüm döngüyü görmek için ek analiz gerekebilir.

**İPUCU**: Geliştirme ortamında panic kullanarak erken tespit yapılabilir: ```go

if err := resolver.DetectCircularDependencies(); err != nil {
    panic(err) // Geliştirme ortamında hemen fark edilir
}

```

## Test Örneği

```go

func TestCircularDependency(t *testing.T) {
    fields := []*Schema{
        {Key: "a", DependsOnFields: []string{"b"}},
        {Key: "b", DependsOnFields: []string{"c"}},
        {Key: "c", DependsOnFields: []string{"a"}}, // Döngü!
    }

    resolver := NewDependencyResolver(fields, "test")
    err := resolver.DetectCircularDependencies()

    assert.Error(t, err)
    assert.Contains(t, err.Error(), "circular dependency")
}

```

func (*DependencyResolver) ResolveDependencies ¶

func (r *DependencyResolver) ResolveDependencies(
	formData map[string]interface{},
	changedFields []string,
	ctx *fiber.Ctx,
) (map[string]*FieldUpdate, error)

ResolveDependencies ¶

Değişen alanlara bağlı tüm alanları tespit eder ve güncelleme bilgilerini döner.

## Amaç

Form verilerinde değişiklik olan alanları tespit edip, bu alanlara bağımlı olan diğer tüm alanları bulur ve her biri için ilgili callback fonksiyonlarını çalıştırarak güncellenmiş alan bilgilerini döner.

## Parametreler

- `formData`: Güncel form verilerini içeren map (alan adı -> değer) - `changedFields`: Değişiklik yapılan alan anahtarlarının listesi - `ctx`: Fiber context nesnesi (HTTP request/response bilgileri için)

## Dönüş Değerleri

- `map[string]*FieldUpdate`: Alan anahtarı -> güncelleme bilgisi map'i - `error`: Hata durumunda hata mesajı

## Çalışma Algoritması

1. **Graf Oluşturma**: Tüm alanlar arası bağımlılık grafiği oluşturulur 2. **BFS Traversal**: Değişen alanlardan başlayarak BFS ile etkilenen alanlar bulunur 3. **Callback Çalıştırma**: Her etkilenen alan için context'e uygun callback çalıştırılır 4. **Sonuç Toplama**: Tüm güncellemeler bir map'te toplanır

## Kullanım Örneği

```go // Form verisi

formData := map[string]interface{}{
    "country": "TR",
    "city": "Istanbul",
}

// Değişen alanlar changedFields := []string{"country"}

// Bağımlılıkları çöz updates, err := resolver.ResolveDependencies(formData, changedFields, ctx)

if err != nil {
    return err
}

// Güncellemeleri uygula

for fieldKey, update := range updates {
    fmt.Printf("Alan %s güncellendi: %+v\n", fieldKey, update)
}

```

## Performans

- **Zaman Karmaşıklığı**: O(V + E) - V: alan sayısı, E: bağımlılık sayısı - **Alan Karmaşıklığı**: O(V) - Visited ve affected map'leri için

## Önemli Notlar

⚠️ **Uyarı**: Callback fonksiyonları içinde hata oluşursa, bu alan için güncelleme döndürülmez ancak diğer alanlar işlenmeye devam eder.

💡 **İpucu**: Context parametresi sayesinde aynı alan farklı bağlamlarda (form, filter, detail) farklı callback'ler kullanabilir.

📌 **Not**: Döngüsel bağımlılıklar varsa sonsuz döngüye girmez, visited map'i sayesinde her alan sadece bir kez işlenir.

func (*DialogField) Content ¶

func (f *DialogField) Content(fields []core.Element) *DialogField

Content, basit form içeriğini ayarlar

Parametreler:

• fields: Form field'ları

Dönüş Değeri:

• *DialogField: Method chaining için

Örnek Kullanım:

Dialog("Profil", "profile").Content([]core.Element{
    Text("Ad", "name").Required(),
    Email("Email", "email").Required(),
})

func (*DialogField) DefaultOpen ¶

func (f *DialogField) DefaultOpen(open bool) *DialogField

DefaultOpen, dialog'un varsayılan olarak açık olup olmayacağını ayarlar

Parametreler:

• open: true ise dialog sayfa yüklendiğinde otomatik açılır

Dönüş Değeri:

• *DialogField: Method chaining için

Örnek Kullanım:

Dialog("Profil", "profile").DefaultOpen(true)

func (*DialogField) DialogDesc ¶

func (f *DialogField) DialogDesc(desc string) *DialogField

DialogDesc, dialog açıklamasını ayarlar

Parametreler:

• desc: Dialog açıklaması

Dönüş Değeri:

• *DialogField: Method chaining için

Örnek Kullanım:

Dialog("Profil", "profile").DialogDesc("Lütfen bilgilerinizi güncelleyin")

func (*DialogField) DialogSize ¶

func (f *DialogField) DialogSize(size string) *DialogField

DialogSize, dialog boyutunu ayarlar

Parametreler:

• size: Dialog boyutu ("sm", "md", "lg", "xl", "full")

Dönüş Değeri:

• *DialogField: Method chaining için

Örnek Kullanım:

Dialog("Profil", "profile").DialogSize("lg")

func (*DialogField) DialogTitle ¶

func (f *DialogField) DialogTitle(title string) *DialogField

DialogTitle, dialog başlığını ayarlar

Parametreler:

• title: Dialog başlığı

Dönüş Değeri:

• *DialogField: Method chaining için

Örnek Kullanım:

Dialog("Profil", "profile").DialogTitle("Profilinizi Düzenleyin")

func (*DialogField) Extract ¶

func (f *DialogField) Extract(resource interface{})

Extract, DialogField için veri çıkarır (core.Element interface implementasyonu)

func (*DialogField) GetContext ¶

func (f *DialogField) GetContext() ElementContext

GetContext, DialogField'ın context'ini döndürür (core.Element interface implementasyonu)

func (*DialogField) GetKey ¶

func (f *DialogField) GetKey() string

GetKey, DialogField'ın key'ini döndürür (core.Element interface implementasyonu)

func (*DialogField) GetView ¶

func (f *DialogField) GetView() string

GetView, DialogField'ın view tipini döndürür (core.Element interface implementasyonu)

func (*DialogField) JsonSerialize ¶

func (f *DialogField) JsonSerialize() map[string]any

JsonSerialize, DialogField'ı JSON uyumlu bir map'e serileştirir

Bu metod, DialogField'ın tüm özelliklerini frontend'e göndermek için JSON formatına dönüştürür.

Dönüş Değeri:

• map[string]any: JSON uyumlu map

Örnek Kullanım:

field := Dialog("Profil", "profile").DefaultOpen(true)
json := field.JsonSerialize()
// json["view"] == "dialog"
// json["defaultOpen"] == true

func (*DialogField) OnComplete ¶

func (f *DialogField) OnComplete(fn func(ctx *fiber.Ctx, data map[string]any) error) *DialogField

OnComplete, dialog tamamlandığında çağrılacak callback'i ayarlar

Parametreler:

• fn: Callback fonksiyonu

Dönüş Değeri:

• *DialogField: Method chaining için

Örnek Kullanım:

Dialog("Profil", "profile").OnComplete(func(ctx *fiber.Ctx, data map[string]any) error {
    // Veriyi kaydet
    return nil
})

func (*DialogField) OnSkip ¶

func (f *DialogField) OnSkip(fn func(ctx *fiber.Ctx) error) *DialogField

OnSkip, dialog atlandığında çağrılacak callback'i ayarlar (wizard için)

Parametreler:

• fn: Callback fonksiyonu

Dönüş Değeri:

• *DialogField: Method chaining için

Örnek Kullanım:

Dialog("Onboarding", "onboarding").OnSkip(func(ctx *fiber.Ctx) error {
    // Atlandı işaretini kaydet
    return nil
})

func (*DialogField) TriggerButton ¶

func (f *DialogField) TriggerButton(text string) *DialogField

TriggerButton, dialog'u açacak butonun metnini ayarlar

Parametreler:

• text: Buton metni

Dönüş Değeri:

• *DialogField: Method chaining için

Örnek Kullanım:

Dialog("Profil", "profile").TriggerButton("Profili Düzenle")

func (*DialogField) TriggerIcon ¶

func (f *DialogField) TriggerIcon(icon string) *DialogField

TriggerIcon, dialog butonunun ikonunu ayarlar

Parametreler:

• icon: İkon (emoji veya icon class)

Dönüş Değeri:

• *DialogField: Method chaining için

Örnek Kullanım:

Dialog("Profil", "profile").TriggerIcon("✏️")

func (*DialogField) Wizard ¶

func (f *DialogField) Wizard(steps []DialogStep) *DialogField

Wizard, multi-step wizard içeriğini ayarlar

Parametreler:

• steps: Wizard adımları

Dönüş Değeri:

• *DialogField: Method chaining için

Örnek Kullanım:

Dialog("Onboarding", "onboarding").Wizard([]DialogStep{
    {
        Index:   0,
        Title:   "Adım 1",
        Fields:  []core.Element{Text("Ad", "name")},
        CanSkip: false,
    },
})

func (*Displayable) GetDisplayCallback ¶

func (d *Displayable) GetDisplayCallback() func(*context.Context, any) string

GetDisplayCallback, görüntüleme callback fonksiyonunu döndürür. Hiçbir callback ayarlanmamışsa nil döndürür.

Döndürür:

• Görüntüleme callback fonksiyonu veya ayarlanmamışsa nil

func (*Displayable) GetDisplayFormat ¶

func (d *Displayable) GetDisplayFormat() string

GetDisplayFormat, görüntüleme format string'ini döndürür. Hiçbir format ayarlanmamışsa boş string döndürür.

Döndürür:

• Görüntüleme format tanımlayıcısı

func (*Displayable) SetDisplayCallback ¶

func (d *Displayable) SetDisplayCallback(cb func(*context.Context, any) string)

SetDisplayCallback, özel bir görüntüleme callback fonksiyonu ayarlar.

Callback, context ve alan değerini alır, ve görüntüleme için değerin formatlanmış string temsilini döndürmelidir.

Parametreler:

• cb: Alan değerini görüntüleme için formatlayan fonksiyon

Örnek:

field.SetDisplayCallback(func(ctx *context.Context, value any) string {
    timestamp, ok := value.(time.Time)
    if !ok {
        return ""
    }
    return timestamp.Format("2006-01-02 15:04:05")
})

func (*Displayable) SetDisplayFormat ¶

func (d *Displayable) SetDisplayFormat(format string)

SetDisplayFormat, görüntüleme format string'ini ayarlar.

Format string'i, frontend'e değerin nasıl görüntüleneceği hakkında bir ipucudur (örn. "uppercase", "lowercase", "currency", "date").

Parametreler:

• format: Görüntüleme format tanımlayıcısı

Örnek:

field.SetDisplayFormat("currency")

func (*FieldUpdate) AddRule ¶

func (u *FieldUpdate) AddRule(rule ValidationRule) *FieldUpdate

AddRule, mevcut validasyon kurallarına yeni bir kural ekler.

Genel Bakış ¶

Bu metod, bir form alanının mevcut validasyon kurallarına yeni bir kural ekler. Mevcut kuralları korur ve sonuna yeni kuralı ekler. Method chaining desteği için *FieldUpdate döndürür. Kademeli kural ekleme senaryoları için idealdir.

Kullanım Senaryoları ¶

- **Kademeli Kural Ekleme**: Koşullara göre adım adım kural ekle - **Ek Validasyon**: Mevcut kurallara ek kontroller ekle - **Koşullu Kural Ekleme**: Belirli durumlarda ekstra kurallar ekle - **Dinamik Kural Biriktirme**: Birden fazla koşula göre kuralları biriktir - **Modüler Validasyon**: Her koşul için ayrı kural ekle

Parametreler ¶

- `rule`: Eklenecek ValidationRule - Tek bir validasyon kuralı

Dönüş Değeri ¶

`*FieldUpdate`: Method chaining için güncellenmiş FieldUpdate pointer'ı

Kullanım Örneği ¶

```go // Basit kullanım update := NewFieldUpdate().

AddRule(ValidationRule{Type: "required", Message: "Bu alan zorunludur"}).
AddRule(ValidationRule{Type: "min", Value: 3, Message: "En az 3 karakter"})

// Koşullu kural ekleme

passwordField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    update := NewFieldUpdate().
        AddRule(ValidationRule{Type: "required", Message: "Şifre zorunludur"}).
        AddRule(ValidationRule{Type: "min", Value: 8, Message: "En az 8 karakter"})

    // Güvenlik seviyesine göre ek kurallar
    securityLevel := formData["security_level"].(string)
    if securityLevel == "high" {
        update.
            AddRule(ValidationRule{Type: "uppercase", Message: "En az 1 büyük harf"}).
            AddRule(ValidationRule{Type: "lowercase", Message: "En az 1 küçük harf"}).
            AddRule(ValidationRule{Type: "number", Message: "En az 1 rakam"}).
            AddRule(ValidationRule{Type: "special", Message: "En az 1 özel karakter"})
    } else if securityLevel == "medium" {
        update.
            AddRule(ValidationRule{Type: "uppercase", Message: "En az 1 büyük harf"}).
            AddRule(ValidationRule{Type: "number", Message: "En az 1 rakam"})
    }

    return update
})

// Kademeli kural ekleme

emailField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    update := NewFieldUpdate().
        AddRule(ValidationRule{Type: "required", Message: "E-posta zorunludur"}).
        AddRule(ValidationRule{Type: "email", Message: "Geçerli bir e-posta girin"})

    // Kurumsal hesap kontrolü
    accountType := formData["account_type"].(string)
    if accountType == "corporate" {
        update.AddRule(ValidationRule{
            Type:    "domain_whitelist",
            Value:   []string{"company.com", "partner.com"},
            Message: "Sadece şirket e-postaları kabul edilir",
        })
    }

    // Benzersizlik kontrolü
    checkUnique := formData["check_unique"].(bool)
    if checkUnique {
        update.AddRule(ValidationRule{
            Type:    "unique",
            Table:   "users",
            Column:  "email",
            Message: "Bu e-posta zaten kullanılıyor",
        })
    }

    return update
})

// Çoklu koşullu kural ekleme

priceField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    update := NewFieldUpdate().
        AddRule(ValidationRule{Type: "required", Message: "Fiyat zorunludur"}).
        AddRule(ValidationRule{Type: "numeric", Message: "Geçerli bir sayı girin"}).
        AddRule(ValidationRule{Type: "min", Value: 0, Message: "Fiyat negatif olamaz"})

    // Ürün tipine göre
    productType := formData["product_type"].(string)
    if productType == "premium" {
        update.AddRule(ValidationRule{
            Type:    "min",
            Value:   1000,
            Message: "Premium ürünler minimum 1000 TL olmalıdır",
        })
    }

    // Kullanıcı rolüne göre
    userRole := ctx.Locals("user_role").(string)
    if userRole != "admin" {
        update.AddRule(ValidationRule{
            Type:    "max",
            Value:   10000,
            Message: "Maksimum 10.000 TL girebilirsiniz",
        })
    }

    // İndirim varsa
    hasDiscount := formData["has_discount"].(bool)
    if hasDiscount {
        update.AddRule(ValidationRule{
            Type:    "custom",
            Value:   "validate_discount_price",
            Message: "İndirimli fiyat normal fiyattan düşük olmalıdır",
        })
    }

    return update
})

// Method chaining ile zincirleme ekleme update := NewFieldUpdate().

MakeRequired().
AddRule(ValidationRule{Type: "min", Value: 3, Message: "En az 3 karakter"}).
AddRule(ValidationRule{Type: "max", Value: 50, Message: "En fazla 50 karakter"}).
AddRule(ValidationRule{Type: "alphanumeric", Message: "Sadece harf ve rakam"}).
SetHelpText("Kullanıcı adı 3-50 karakter, harf ve rakam içermelidir")

// Dinamik kural biriktirme

ageField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    update := NewFieldUpdate().
        AddRule(ValidationRule{Type: "required", Message: "Yaş zorunludur"}).
        AddRule(ValidationRule{Type: "numeric", Message: "Geçerli bir sayı girin"})

    // Yaş aralığı kontrolü
    serviceType := formData["service_type"].(string)
    switch serviceType {
    case "child":
        update.
            AddRule(ValidationRule{Type: "min", Value: 0, Message: "Yaş 0'dan küçük olamaz"}).
            AddRule(ValidationRule{Type: "max", Value: 12, Message: "Çocuk servisi 0-12 yaş arası"})
    case "teen":
        update.
            AddRule(ValidationRule{Type: "min", Value: 13, Message: "Genç servisi 13 yaşından başlar"}).
            AddRule(ValidationRule{Type: "max", Value: 17, Message: "Genç servisi 13-17 yaş arası"})
    case "adult":
        update.
            AddRule(ValidationRule{Type: "min", Value: 18, Message: "Yetişkin servisi 18 yaşından başlar"}).
            AddRule(ValidationRule{Type: "max", Value: 65, Message: "Yetişkin servisi 18-65 yaş arası"})
    case "senior":
        update.
            AddRule(ValidationRule{Type: "min", Value: 65, Message: "Yaşlı servisi 65 yaşından başlar"}).
            AddRule(ValidationRule{Type: "max", Value: 120, Message: "Geçerli bir yaş girin"})
    }

    return update
})

```

Önemli Notlar ¶

- **Mevcut Kuralları Korur**: AddRule() mevcut kuralları korur ve sonuna ekler - **Sıralama**: Kurallar eklenme sırasına göre uygulanır - **Çoklu Çağrı**: Birden fazla kez çağrılabilir (method chaining) - **Performans**: Her çağrı slice'a append yapar - **Nil Kontrol**: Rules nil ise otomatik olarak initialize edilir

Best Practices ¶

- Temel kuralları önce ekleyin (required, type checks) - Detaylı kuralları sonra ekleyin (min, max, pattern) - Pahalı kuralları en sona ekleyin (unique, custom validators) - Method chaining kullanarak okunabilir kod yazın - Koşullu ekleme için if blokları kullanın - Kullanıcı dostu hata mesajları yazın

Avantajlar ¶

- Mevcut kuralları korur - Esnek ve modüler kural ekleme - Method chaining desteği - Koşullu kural ekleme için ideal - Okunabilir kod yazımı

Dezavantajlar ¶

- Çok fazla çağrı performansı etkileyebilir - Kural sırası önemlidir (dikkatli olunmalı) - Duplicate kural kontrolü yoktur

AddRule vs SetRules Karşılaştırması ¶

| Özellik | AddRule | SetRules | |---------|---------|----------| | Mevcut Kurallar | Korur ve ekler | Siler ve değiştirir | | Kullanım | Tekli ekleme | Toplu güncelleme | | Method Chaining | Evet | Evet | | Esneklik | Yüksek | Düşük | | Performans | Her çağrıda append | Tek seferde | | Kullanım Amacı | Kademeli ekleme | Tüm kuralları değiştir |

Performans İpuçları ¶

- Çok fazla AddRule çağrısı yerine SetRules kullanmayı düşünün - Pahalı validasyonları (DB sorguları) en sona ekleyin - Gereksiz kural eklemekten kaçının - Kural sayısını makul seviyede tutun (ideal: 3-7 kural)

func (*FieldUpdate) Disable ¶

func (u *FieldUpdate) Disable() *FieldUpdate

Disable, alanı devre dışı bırakır (pasif hale getirir).

Genel Bakış ¶

Bu metod, bir form alanını devre dışı bırakır. Disabled özelliğini true olarak ayarlar ve method chaining desteği için *FieldUpdate döndürür. Devre dışı alanlar kullanıcı tarafından düzenlenemez ve form submit edildiğinde değerleri gönderilmez.

Kullanım Senaryoları ¶

- **Koşullu Devre Dışı Bırakma**: Belirli koşullarda alanları pasif hale getir - **Bağımlılık Kontrolü**: Bağımlı alanları koşul sağlanmadığında devre dışı bırak - **Yetki Kısıtlaması**: Yetkisiz kullanıcılar için alanları kapat - **İş Kuralları**: İş mantığına göre alanları devre dışı bırak - **Geçici Kilitleme**: Belirli durumlarda alanları geçici olarak kilitle

Dönüş Değeri ¶

`*FieldUpdate`: Method chaining için güncellenmiş FieldUpdate pointer'ı

Kullanım Örneği ¶

```go // Basit kullanım update := NewFieldUpdate().Disable()

// Bağımlılık kontrolü

countryField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    country := formData["country"]
    if country == "" {
        // Ülke seçilmediğinde şehir alanını devre dışı bırak
        return NewFieldUpdate().
            Disable().
            SetHelpText("Önce ülke seçin").
            SetValue(nil)
    }
    return NewFieldUpdate().Enable()
})

// Yetki kısıtlaması userRole := ctx.Locals("user_role").(string)

if userRole == "viewer" {
    return NewFieldUpdate().
        Disable().
        SetHelpText("Bu alanı düzenleme yetkiniz yok")
}

// İş kuralı bazlı devre dışı bırakma

statusField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    status := formData["status"]
    if status == "completed" {
        // Tamamlanmış kayıtlar düzenlenemez
        return NewFieldUpdate().
            Disable().
            MakeReadOnly().
            SetHelpText("Tamamlanmış kayıtlar düzenlenemez")
    }
    return NewFieldUpdate().Enable().MakeEditable()
})

// Koşullu form akışı

paymentMethodField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    paymentMethod := formData["payment_method"]
    if paymentMethod == "cash" {
        // Nakit ödeme için kredi kartı alanlarını devre dışı bırak
        return NewFieldUpdate().
            Disable().
            Hide().
            SetValue(nil)
    }
    return NewFieldUpdate().Enable().Show()
})

// Geçici kilitleme

processingField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    isProcessing := formData["is_processing"].(bool)
    if isProcessing {
        return NewFieldUpdate().
            Disable().
            SetHelpText("İşlem devam ediyor, lütfen bekleyin...")
    }
    return NewFieldUpdate().Enable()
})

```

Önemli Notlar ¶

- **Form Submit**: Disabled alanların değerleri form submit edildiğinde gönderilmez - **Validasyon**: Disabled alanlar için validasyon kuralları uygulanmaz - **Görünürlük**: Disable() sadece disabled durumunu değiştirir, görünürlüğü etkilemez - **Değer Temizleme**: Devre dışı bırakılan alanların değerlerini SetValue(nil) ile temizlemeyi düşünün - **Kullanıcı Deneyimi**: Neden devre dışı olduğunu açıklayan yardım metni ekleyin

Best Practices ¶

- Disable() ile birlikte SetHelpText() kullanarak kullanıcıyı bilgilendirin - Devre dışı bırakılan alanların değerlerini temizlemeyi düşünün - Hide() ile birlikte kullanarak gereksiz alanları tamamen gizleyin - Koşullu devre dışı bırakmada her iki durumu da (Enable/Disable) ele alın - Sunucu tarafında da aynı kontrolü uygulayın (güvenlik)

Avantajlar ¶

- Kullanıcı hatalarını önler - Form akışını kontrol eder - Bağımlılık yönetimini kolaylaştırır - Kullanıcı deneyimini iyileştirir

Dezavantajlar ¶

- Disabled alanların değerleri form submit'e dahil edilmez (veri kaybı riski) - Aşırı kullanımda kullanıcı deneyimini olumsuz etkiler

func (*FieldUpdate) Enable ¶

func (u *FieldUpdate) Enable() *FieldUpdate

Enable, alanı etkinleştirir (aktif hale getirir).

Genel Bakış ¶

Bu metod, devre dışı bırakılmış bir alanı tekrar etkinleştirir. Disabled özelliğini false olarak ayarlar ve method chaining desteği için *FieldUpdate döndürür. Etkin alanlar kullanıcı tarafından düzenlenebilir ve form submit edildiğinde değerleri gönderilir.

Kullanım Senaryoları ¶

- **Koşullu Aktivasyon**: Belirli koşullarda alanları aktif hale getir - **Adım Bazlı Formlar**: Form adımlarına göre alanları etkinleştir - **Yetki Bazlı Erişim**: Kullanıcı yetkisine göre alanları aktif et - **Dinamik Form Akışı**: Kullanıcı seçimlerine göre alanları etkinleştir - **Bağımlılık Çözümü**: Bağımlı alanları koşul sağlandığında aktif et

Dönüş Değeri ¶

`*FieldUpdate`: Method chaining için güncellenmiş FieldUpdate pointer'ı

Kullanım Örneği ¶

```go // Basit kullanım update := NewFieldUpdate().Enable()

// Koşullu aktivasyon

agreementField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    agreed := formData["terms_agreed"].(bool)
    if agreed {
        // Sözleşme kabul edildiğinde devam butonu aktif
        return NewFieldUpdate().
            Enable().
            SetHelpText("Devam edebilirsiniz")
    }
    return NewFieldUpdate().
        Disable().
        SetHelpText("Devam etmek için sözleşmeyi kabul edin")
})

// Bağımlılık çözümü

countryField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    country := formData["country"]
    if country != "" {
        // Ülke seçildiğinde şehir alanını aktif et
        return NewFieldUpdate().
            Enable().
            Show().
            SetHelpText("Lütfen şehir seçin")
    }
    return NewFieldUpdate().Disable().Hide()
})

// Adım bazlı form

stepField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    step := formData["current_step"].(int)
    if step >= 2 {
        // 2. adımda ödeme alanlarını aktif et
        return NewFieldUpdate().
            Enable().
            Show().
            MakeRequired()
    }
    return NewFieldUpdate().Disable().Hide()
})

// Yetki bazlı erişim userRole := ctx.Locals("user_role").(string)

if userRole == "admin" || userRole == "editor" {
    return NewFieldUpdate().
        Enable().
        MakeEditable().
        SetHelpText("Düzenleme yetkisine sahipsiniz")
}

```

Önemli Notlar ¶

- **Disabled vs ReadOnly**: Disabled alanlar form submit'e dahil edilmez, ReadOnly alanlar dahil edilir - **Görünürlük**: Enable() sadece disabled durumunu değiştirir, görünürlüğü etkilemez - **Validasyon**: Etkin alanlar için validasyon kuralları uygulanır - **Form Submit**: Etkin alanların değerleri form submit edildiğinde gönderilir - **Method Chaining**: Diğer metodlarla zincirleme kullanılabilir

Best Practices ¶

- Enable() ile birlikte Show() kullanarak tam erişim sağlayın - Etkinleştirilen alanlar için uygun yardım metni ekleyin - MakeEditable() ile birlikte kullanarak düzenleme izni verin - Koşullu aktivasyonda her iki durumu da (Enable/Disable) ele alın

Avantajlar ¶

- Dinamik form davranışı sağlar - Kullanıcı deneyimini iyileştirir - Bağımlılık yönetimini kolaylaştırır - Koşullu erişim kontrolü sağlar

Disabled vs ReadOnly Karşılaştırması ¶

| Özellik | Disabled | ReadOnly | |---------|----------|----------| | Görünürlük | Görünür (genelde soluk) | Görünür (normal) | | Düzenlenebilirlik | Hayır | Hayır | | Form Submit | Dahil edilmez | Dahil edilir | | Validasyon | Uygulanmaz | Uygulanmaz | | Kullanım Amacı | Geçici devre dışı | Kalıcı koruma |

func (*FieldUpdate) Hide ¶

func (u *FieldUpdate) Hide() *FieldUpdate

Hide, alanı gizler.

Genel Bakış ¶

Bu metod, bir form alanının kullanıcı arayüzünde gizlenmesini sağlar. Visible özelliğini false olarak ayarlar ve method chaining desteği için *FieldUpdate döndürür.

Kullanım Senaryoları ¶

- Koşullu alan gizleme: Belirli bir değer seçildiğinde ilgisiz alanları gizle - Dinamik form yapısı: Kullanıcı seçimlerine göre gereksiz alanları gizle - Basitleştirilmiş form: Kullanıcıya sadece ilgili alanları göster - Validasyon atlama: Gizli alanlar için validasyon uygulanmaz

Dönüş Değeri ¶

`*FieldUpdate`: Method chaining için güncellenmiş FieldUpdate pointer'ı

Kullanım Örneği ¶

```go // Basit kullanım update := NewFieldUpdate().Hide()

// Koşullu gizleme

if formData["payment_method"] == "cash" {
    // Nakit ödeme seçildiğinde kredi kartı alanlarını gizle
    return NewFieldUpdate().Hide().MakeOptional()
}

// Karmaşık koşullu mantık

productTypeField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    productType := formData["product_type"]
    if productType == "digital" {
        // Dijital ürünler için fiziksel ürün alanlarını gizle
        return NewFieldUpdate().Hide().MakeOptional().SetValue(nil)
    }
    return NewFieldUpdate().Show().MakeRequired()
})

// Method chaining ile birlikte kullanım update := NewFieldUpdate().

Hide().
MakeOptional().
SetValue(nil) // Gizli alan için değeri temizle

```

Önemli Notlar ¶

- Hide() çağrıldığında alan gizlenir ve validasyon kuralları uygulanmaz - Gizli alanların değerleri form submit edildiğinde gönderilmeyebilir - Güvenlik açısından hassas alanlar için Hide() yeterli değildir, sunucu tarafı kontrolü gereklidir - Method chaining desteklenir, zincirleme çağrılar yapılabilir - Gizlenen alanları MakeOptional() ile birlikte kullanmak önerilir

Best Practices ¶

- Hide() ile birlikte MakeOptional() kullanarak validasyon hatalarını önleyin - Gizlenen alanların değerlerini SetValue(nil) ile temizlemeyi düşünün - Koşullu gizlemede her iki durumu da (Show/Hide) ele alın - Güvenlik kritik alanlar için sunucu tarafı kontrolü yapın

func (*FieldUpdate) MakeEditable ¶

func (u *FieldUpdate) MakeEditable() *FieldUpdate

MakeEditable, alanı düzenlenebilir hale getirir.

Genel Bakış ¶

Bu metod, daha önce salt okunur yapılmış bir alanı tekrar düzenlenebilir hale getirir. ReadOnly özelliğini false olarak ayarlar ve method chaining desteği için *FieldUpdate döndürür.

Kullanım Senaryoları ¶

- **Koşullu Düzenleme**: Belirli koşullarda alanları düzenlenebilir yap - **Rol Bazlı Erişim**: Yetki seviyesine göre alanları aç/kapat - **Durum Bazlı Kontrol**: Kayıt durumuna göre düzenleme izni ver - **Dinamik Form**: Kullanıcı seçimlerine göre alanları aktif et

Dönüş Değeri ¶

`*FieldUpdate`: Method chaining için güncellenmiş FieldUpdate pointer'ı

Kullanım Örneği ¶

```go // Basit kullanım update := NewFieldUpdate().MakeEditable()

// Durum bazlı düzenleme

statusField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    status := formData["status"]
    if status == "draft" {
        // Taslak durumunda tüm alanlar düzenlenebilir
        return NewFieldUpdate().
            MakeEditable().
            SetHelpText("Taslak durumunda düzenleyebilirsiniz")
    }
    return NewFieldUpdate().
        MakeReadOnly().
        SetHelpText("Sadece taslak durumunda düzenlenebilir")
})

// Rol bazlı erişim

if ctx.Locals("user_role") == "admin" {
    return NewFieldUpdate().
        MakeEditable().
        SetHelpText("Admin olarak düzenleme yetkisine sahipsiniz")
}

// Koşullu düzenleme

editModeField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    editMode := formData["edit_mode"].(bool)
    if editMode {
        return NewFieldUpdate().MakeEditable().Enable()
    }
    return NewFieldUpdate().MakeReadOnly().Disable()
})

```

Önemli Notlar ¶

- MakeEditable() çağrıldığında alan düzenlenebilir olur ancak disabled durumu değişmez - Düzenlenebilir alanlar için validasyon kuralları uygulanır - Sunucu tarafında da aynı yetki kontrolü yapılmalıdır - Method chaining desteklenir

Best Practices ¶

- Düzenleme izni verirken uygun yardım metni ekleyin - Sunucu tarafında yetki kontrolü yapın (güvenlik) - Enable() ile birlikte kullanarak tam erişim sağlayın - Koşullu düzenlemede her iki durumu da (Editable/ReadOnly) ele alın

func (*FieldUpdate) MakeOptional ¶

func (u *FieldUpdate) MakeOptional() *FieldUpdate

MakeOptional, alanı opsiyonel (zorunlu olmayan) hale getirir.

Genel Bakış ¶

Bu metod, daha önce zorunlu yapılmış bir alanı opsiyonel hale getirir. Required özelliğini false olarak ayarlar ve method chaining desteği için *FieldUpdate döndürür.

Kullanım Senaryoları ¶

- **Koşullu Opsiyonellik**: Belirli durumlarda alanları opsiyonel yap - **Basitleştirilmiş Form**: Kullanıcı deneyimini iyileştirmek için gereksiz zorunlulukları kaldır - **Dinamik İş Kuralları**: Koşullara göre zorunluluk durumunu değiştir - **Adım Bazlı Formlar**: Farklı adımlarda farklı zorunluluk seviyeleri

Dönüş Değeri ¶

`*FieldUpdate`: Method chaining için güncellenmiş FieldUpdate pointer'ı

Kullanım Örneği ¶

```go // Basit kullanım update := NewFieldUpdate().MakeOptional()

// Koşullu opsiyonellik

accountTypeField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    accountType := formData["account_type"]
    if accountType == "personal" {
        // Bireysel hesaplar için şirket adı opsiyonel
        return NewFieldUpdate().
            MakeOptional().
            SetHelpText("Bireysel hesaplar için opsiyonel")
    }
    return NewFieldUpdate().
        MakeRequired().
        SetHelpText("Kurumsal hesaplar için zorunlu")
})

// Gizli alanlar için

visibilityField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    visible := formData["show_field"].(bool)
    if !visible {
        // Gizli alanlar opsiyonel olmalı
        return NewFieldUpdate().Hide().MakeOptional()
    }
    return NewFieldUpdate().Show().MakeRequired()
})

// Basitleştirilmiş form akışı

quickModeField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    quickMode := formData["quick_mode"].(bool)
    if quickMode {
        // Hızlı mod: detaylı alanlar opsiyonel
        return NewFieldUpdate().
            MakeOptional().
            SetHelpText("Hızlı modda bu alan opsiyoneldir")
    }
    return NewFieldUpdate().
        MakeRequired().
        SetHelpText("Detaylı modda bu alan zorunludur")
})

```

Önemli Notlar ¶

- MakeOptional() çağrıldığında alan için validasyon zorunluluğu kaldırılır - Opsiyonel alanlar boş bırakılabilir - Gizli alanlar her zaman opsiyonel yapılmalıdır - Method chaining desteklenir

Best Practices ¶

- Hide() ile birlikte kullanarak tutarlılık sağlayın - Opsiyonel alanlar için açıklayıcı yardım metni ekleyin - Koşullu zorunlulukta her iki durumu da (Required/Optional) ele alın - Kullanıcı deneyimini önceliklendirin

Avantajlar ¶

- Kullanıcı deneyimini iyileştirir - Form doldurma süresini kısaltır - Esnek form yapısı sağlar - Gereksiz zorunlulukları kaldırır

func (*FieldUpdate) MakeReadOnly ¶

func (u *FieldUpdate) MakeReadOnly() *FieldUpdate

MakeReadOnly, alanı salt okunur (read-only) hale getirir.

Genel Bakış ¶

Bu metod, bir form alanının kullanıcı tarafından düzenlenemez ancak görüntülenebilir olmasını sağlar. ReadOnly özelliğini true olarak ayarlar ve method chaining desteği için *FieldUpdate döndürür.

Kullanım Senaryoları ¶

- **Hesaplanan Değerler**: Otomatik hesaplanan alanları göster ancak düzenlemeye izin verme - **Sistem Alanları**: Sistem tarafından yönetilen alanları koruma altına al - **Onay Sonrası Kilitleme**: Onaylanmış kayıtların belirli alanlarını kilitle - **Referans Bilgileri**: Referans amaçlı gösterilen ancak değiştirilmemesi gereken bilgiler - **Audit Trail**: Değişiklik geçmişi için orijinal değerleri koruma

Dönüş Değeri ¶

`*FieldUpdate`: Method chaining için güncellenmiş FieldUpdate pointer'ı

Kullanım Örneği ¶

```go // Basit kullanım update := NewFieldUpdate().MakeReadOnly()

// Hesaplanan toplam alanı

quantityField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    quantity := formData["quantity"].(float64)
    price := formData["price"].(float64)
    total := quantity * price

    // Toplam alanını hesapla ve salt okunur yap
    return NewFieldUpdate().
        SetValue(total).
        MakeReadOnly().
        SetHelpText(fmt.Sprintf("Otomatik hesaplanan: %.2f TL", total))
})

// Onaylanmış kayıtlar için

statusField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    status := formData["status"]
    if status == "approved" {
        // Onaylandıktan sonra fiyat alanını kilitle
        return NewFieldUpdate().
            MakeReadOnly().
            SetHelpText("Onaylanmış kayıtlarda fiyat değiştirilemez")
    }
    return NewFieldUpdate().MakeEditable()
})

// Sistem alanları createdAtField := NewFieldUpdate().

MakeReadOnly().
SetHelpText("Sistem tarafından otomatik oluşturuldu")

```

Önemli Notlar ¶

- **Görünürlük**: ReadOnly alanlar görünür kalır ancak düzenlenemez - **Validasyon**: ReadOnly alanlar için validasyon kuralları uygulanmaz (değer değişmediği için) - **Form Submit**: ReadOnly alanların değerleri form submit edildiğinde gönderilir - **Güvenlik**: Sunucu tarafında da kontrol yapılmalıdır, sadece client-side koruma yeterli değildir - **Disabled vs ReadOnly**: Disabled alanlar form submit'e dahil edilmez, ReadOnly alanlar dahil edilir

Best Practices ¶

- Hesaplanan değerler için SetValue() ile birlikte kullanın - Kullanıcıya neden düzenleyemediğini açıklayan yardım metni ekleyin - Sunucu tarafında da aynı kontrolü uygulayın (güvenlik) - Geçici kilitleme durumları için koşullu kullanın

func (*FieldUpdate) MakeRequired ¶

func (u *FieldUpdate) MakeRequired() *FieldUpdate

MakeRequired, alanı zorunlu hale getirir.

Genel Bakış ¶

Bu metod, bir form alanının doldurulmasını zorunlu kılar. Required özelliğini true olarak ayarlar ve method chaining desteği için *FieldUpdate döndürür. Zorunlu alanlar için validasyon kuralları otomatik olarak uygulanır.

Kullanım Senaryoları ¶

- **Koşullu Zorunluluk**: Belirli bir seçim yapıldığında ilgili alanları zorunlu yap - **Dinamik Validasyon**: Kullanıcı akışına göre zorunlu alanları değiştir - **İş Kuralları**: İş mantığına göre alanları zorunlu hale getir - **Adım Bazlı Formlar**: Her adımda farklı alanları zorunlu yap - **Rol Bazlı Zorunluluk**: Kullanıcı rolüne göre zorunlu alanları belirle

Dönüş Değeri ¶

`*FieldUpdate`: Method chaining için güncellenmiş FieldUpdate pointer'ı

Kullanım Örneği ¶

```go // Basit kullanım update := NewFieldUpdate().MakeRequired()

// Koşullu zorunluluk

shippingTypeField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    shippingType := formData["shipping_type"]
    if shippingType == "express" {
        // Ekspres kargo için telefon numarası zorunlu
        return NewFieldUpdate().
            Show().
            MakeRequired().
            SetHelpText("Ekspres kargo için telefon numarası zorunludur")
    }
    return NewFieldUpdate().MakeOptional()
})

// İş kuralı bazlı zorunluluk

companyField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    hasCompany := formData["has_company"].(bool)
    if hasCompany {
        // Şirket varsa vergi numarası zorunlu
        return NewFieldUpdate().
            Show().
            MakeRequired().
            SetHelpText("Kurumsal müşteriler için vergi numarası zorunludur").
            SetPlaceholder("10 haneli vergi numarası")
    }
    return NewFieldUpdate().Hide().MakeOptional()
})

// Çoklu alan kontrolü

paymentMethodField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    paymentMethod := formData["payment_method"]
    if paymentMethod == "credit_card" {
        // Kredi kartı seçildiğinde kart bilgileri zorunlu
        return NewFieldUpdate().
            Show().
            MakeRequired().
            AddRule(ValidationRule{Type: "credit_card"})
    }
    return NewFieldUpdate().Hide().MakeOptional()
})

// Rol bazlı zorunluluk userRole := ctx.Locals("user_role").(string)

if userRole == "premium" {
    return NewFieldUpdate().
        MakeRequired().
        SetHelpText("Premium üyeler için bu alan zorunludur")
}

```

Önemli Notlar ¶

- **Validasyon**: Zorunlu alanlar boş bırakıldığında validasyon hatası verir - **Görünürlük**: Gizli alanlar zorunlu yapılsa bile validasyon uygulanmaz - **Kullanıcı Deneyimi**: Zorunlu alanlar için açıklayıcı yardım metni ekleyin - **Form Submit**: Zorunlu alanlar doldurulmadan form submit edilemez - **API Validasyonu**: Sunucu tarafında da aynı zorunluluk kontrolü yapılmalıdır

Best Practices ¶

- Zorunlu alanlar için SetHelpText() ile açıklama ekleyin - Show() ile birlikte kullanarak görünürlüğü sağlayın - Kullanıcıya neden zorunlu olduğunu açıklayın - Sunucu tarafında da validasyon yapın (güvenlik) - Gereksiz zorunluluktan kaçının (kullanıcı deneyimi için)

Avantajlar ¶

- Veri bütünlüğünü sağlar - İş kurallarını zorlar - Kullanıcı hatalarını önler - Dinamik form davranışı sağlar

Dezavantajlar ¶

- Aşırı kullanımda kullanıcı deneyimini olumsuz etkiler - Karmaşık koşullu mantıkta hata yapma riski artar

func (*FieldUpdate) SetHelpText ¶

func (u *FieldUpdate) SetHelpText(text string) *FieldUpdate

SetHelpText, alanın yardım metnini ayarlar.

Genel Bakış ¶

Bu metod, bir form alanının altında veya yanında gösterilen yardım metnini dinamik olarak günceller. HelpText özelliğini verilen string ile ayarlar ve method chaining desteği için *FieldUpdate döndürür. Yardım metinleri kullanıcıya alan hakkında ek bilgi, format gereksinimleri veya örnekler sağlar.

Kullanım Senaryoları ¶

- **Bağlamsal Yardım**: Kullanıcı seçimlerine göre ilgili yardım metni göster - **Format Açıklaması**: Beklenen veri formatını açıkla (örn: "DD/MM/YYYY formatında") - **Validasyon Rehberi**: Validasyon kurallarını kullanıcıya açıkla - **Durum Bildirimi**: Alan durumu hakkında bilgi ver (örn: "Hesaplanıyor...") - **Hata Önleme**: Yaygın hataları önlemek için uyarılar ver - **Örnek Gösterme**: Geçerli değer örnekleri göster

Parametreler ¶

- `text`: Gösterilecek yardım metni (string)

Dönüş Değeri ¶

`*FieldUpdate`: Method chaining için güncellenmiş FieldUpdate pointer'ı

Kullanım Örneği ¶

```go // Basit kullanım update := NewFieldUpdate().SetHelpText("Bu alan zorunludur")

// Bağlamsal yardım

countryField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    country := formData["country"]
    if country == "TR" {
        return NewFieldUpdate().
            SetHelpText("11 haneli TC Kimlik Numaranızı girin (örn: 12345678901)")
    } else if country == "US" {
        return NewFieldUpdate().
            SetHelpText("9 haneli SSN numaranızı girin (örn: 123-45-6789)")
    }
    return NewFieldUpdate().SetHelpText("Kimlik numaranızı girin")
})

// Format açıklaması

dateField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    return NewFieldUpdate().
        SetHelpText("Tarih formatı: GG/AA/YYYY (örn: 15/03/2024)")
})

// Validasyon rehberi

passwordField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    return NewFieldUpdate().
        SetHelpText("En az 8 karakter, 1 büyük harf, 1 küçük harf ve 1 rakam içermelidir")
})

// Durum bildirimi

calculatingField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    isCalculating := formData["is_calculating"].(bool)
    if isCalculating {
        return NewFieldUpdate().
            SetHelpText("⏳ Hesaplama yapılıyor, lütfen bekleyin...").
            Disable()
    }
    return NewFieldUpdate().
        SetHelpText("Toplam tutar otomatik hesaplanmıştır").
        Enable()
})

// Koşullu uyarı

amountField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    amount := formData["amount"].(float64)
    if amount > 10000 {
        return NewFieldUpdate().
            SetHelpText("⚠️ Yüksek tutar: Ek onay gerekebilir")
    }
    return NewFieldUpdate().SetHelpText("Tutar giriniz")
})

// Çoklu dil desteği language := ctx.Locals("language").(string)

if language == "tr" {
    return NewFieldUpdate().SetHelpText("E-posta adresinizi girin")
} else {

    return NewFieldUpdate().SetHelpText("Enter your email address")
}

```

Önemli Notlar ¶

- **Markdown Desteği**: Bazı UI framework'leri markdown formatını destekleyebilir - **Uzunluk**: Yardım metinleri kısa ve öz olmalıdır (ideal: 1-2 cümle) - **Emoji Kullanımı**: Dikkat çekmek için emoji kullanılabilir ancak aşırıya kaçılmamalı - **Dinamik Güncelleme**: Yardım metni form durumuna göre dinamik olarak güncellenebilir - **Erişilebilirlik**: Screen reader'lar için anlamlı metinler yazın

Best Practices ¶

- Kısa, açık ve anlaşılır metinler yazın - Örnekler vererek kullanıcıyı yönlendirin - Hata mesajları yerine önleyici bilgiler verin - Teknik jargondan kaçının, sade dil kullanın - Çoklu dil desteği için i18n kullanmayı düşünün - Kullanıcının mevcut bağlamına uygun metinler gösterin

Avantajlar ¶

- Kullanıcı deneyimini iyileştirir - Hata oranını azaltır - Form doldurma süresini kısaltır - Kullanıcı güvenini artırır - Destek taleplerini azaltır

func (*FieldUpdate) SetOptions ¶

func (u *FieldUpdate) SetOptions(options map[string]interface{}) *FieldUpdate

SetOptions, alanın seçeneklerini ayarlar (select, radio, checkbox gibi alanlar için).

Genel Bakış ¶

Bu metod, select, radio button, checkbox gibi seçim alanlarının seçeneklerini dinamik olarak günceller. Options özelliğini verilen map ile ayarlar ve method chaining desteği için *FieldUpdate döndürür. Bu özellik, cascade dropdown'lar ve dinamik seçim listeleri için kritik öneme sahiptir.

Kullanım Senaryoları ¶

- **Cascade Dropdown**: Üst seçime göre alt dropdown seçeneklerini filtrele - **Dinamik Seçenekler**: Kullanıcı seçimlerine göre seçenekleri değiştir - **Veritabanı Sorguları**: Context üzerinden veritabanından seçenekleri çek - **Koşullu Seçenekler**: İş kurallarına göre farklı seçenekler göster - **Filtrelenmiş Listeler**: Belirli kriterlere göre seçenekleri filtrele - **Rol Bazlı Seçenekler**: Kullanıcı rolüne göre farklı seçenekler sun

Parametreler ¶

- `options`: Seçenekleri içeren map[string]interface{}

• Key: Seçeneğin değeri (value)
• Value: Seçeneğin görünen metni (label) veya karmaşık nesne

Dönüş Değeri ¶

`*FieldUpdate`: Method chaining için güncellenmiş FieldUpdate pointer'ı

Kullanım Örneği ¶

```go // Basit kullanım

cities := map[string]interface{}{
    "istanbul": "İstanbul",
    "ankara": "Ankara",
    "izmir": "İzmir",
}

update := NewFieldUpdate().SetOptions(cities)

// Cascade dropdown - Ülkeye göre şehirler

countryField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    country := formData["country"].(string)

    var cities map[string]interface{}
    switch country {
    case "TR":
        cities = map[string]interface{}{
            "istanbul": "İstanbul",
            "ankara": "Ankara",
            "izmir": "İzmir",
            "bursa": "Bursa",
        }
    case "US":
        cities = map[string]interface{}{
            "new_york": "New York",
            "los_angeles": "Los Angeles",
            "chicago": "Chicago",
        }
    default:
        cities = map[string]interface{}{}
    }

    return NewFieldUpdate().
        SetOptions(cities).
        Show().
        Enable().
        SetValue(nil) // Önceki seçimi temizle
})

// Veritabanından dinamik seçenekler

categoryField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    categoryID := formData["category_id"].(int)

    // Veritabanından alt kategorileri çek
    var subcategories []Subcategory
    db := ctx.Locals("db").(*gorm.DB)
    db.Where("category_id = ?", categoryID).Find(&subcategories)

    // Map'e dönüştür
    options := make(map[string]interface{})
    for _, sub := range subcategories {
        options[fmt.Sprintf("%d", sub.ID)] = sub.Name
    }

    return NewFieldUpdate().
        SetOptions(options).
        Show().
        MakeRequired().
        SetHelpText(fmt.Sprintf("%d alt kategori bulundu", len(options)))
})

// Karmaşık seçenek nesneleri

productField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    options := map[string]interface{}{
        "1": map[string]interface{}{
            "label": "Premium Paket",
            "price": 1000,
            "description": "Tüm özellikler dahil",
            "icon": "star",
        },
        "2": map[string]interface{}{
            "label": "Standart Paket",
            "price": 500,
            "description": "Temel özellikler",
            "icon": "check",
        },
    }

    return NewFieldUpdate().SetOptions(options)
})

// Filtrelenmiş seçenekler

priceRangeField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    priceRange := formData["price_range"].(string)

    var products []Product
    db := ctx.Locals("db").(*gorm.DB)

    switch priceRange {
    case "low":
        db.Where("price < ?", 100).Find(&products)
    case "medium":
        db.Where("price BETWEEN ? AND ?", 100, 500).Find(&products)
    case "high":
        db.Where("price > ?", 500).Find(&products)
    }

    options := make(map[string]interface{})
    for _, p := range products {
        options[fmt.Sprintf("%d", p.ID)] = fmt.Sprintf("%s - %.2f TL", p.Name, p.Price)
    }

    return NewFieldUpdate().SetOptions(options)
})

// Rol bazlı seçenekler userRole := ctx.Locals("user_role").(string) var statusOptions map[string]interface{}

if userRole == "admin" {
    statusOptions = map[string]interface{}{
        "draft": "Taslak",
        "pending": "Beklemede",
        "approved": "Onaylandı",
        "rejected": "Reddedildi",
        "archived": "Arşivlendi",
    }
} else {

    statusOptions = map[string]interface{}{
        "draft": "Taslak",
        "pending": "Beklemede",
    }
}

return NewFieldUpdate().SetOptions(statusOptions) ```

Önemli Notlar ¶

- **Map Formatı**: Key-value çiftleri şeklinde olmalıdır - **Değer Temizleme**: Seçenekler değiştiğinde mevcut değeri SetValue(nil) ile temizleyin - **Performans**: Büyük seçenek listeleri için pagination veya lazy loading düşünün - **Veritabanı Sorguları**: Context üzerinden DB erişimi yapılabilir ancak performans etkileri göz önünde bulundurulmalıdır - **Boş Seçenekler**: Boş map göndermek seçenekleri temizler

Best Practices ¶

- Cascade dropdown'larda üst seçim değiştiğinde alt seçimi temizleyin - Veritabanı sorgularını optimize edin (index, limit kullanın) - Büyük listelerde arama/filtreleme özelliği ekleyin - Seçenek sayısını kullanıcıya bildirin (yardım metni ile) - Hata durumlarını ele alın (veritabanı hatası, boş sonuç vb.) - Cache mekanizması kullanarak performansı artırın

Avantajlar ¶

- Dinamik ve esnek seçim listeleri sağlar - Cascade dropdown'ları kolayca uygular - Kullanıcı deneyimini iyileştirir - İş kurallarını kolayca uygular - Veritabanı entegrasyonu kolaydır

Dezavantajlar ¶

- Büyük seçenek listeleri performans sorunlarına yol açabilir - Veritabanı sorguları her değişiklikte çalışabilir (performans) - Karmaşık bağımlılık zincirleri debug edilmesi zor olabilir

Performans İpuçları ¶

- Veritabanı sorgularını cache'leyin - Lazy loading kullanın (büyük listeler için) - Pagination ekleyin (1000+ seçenek için) - Debounce mekanizması kullanın (arama için) - Index'leri optimize edin

func (*FieldUpdate) SetPlaceholder ¶

func (u *FieldUpdate) SetPlaceholder(text string) *FieldUpdate

SetPlaceholder, alanın placeholder (yer tutucu) metnini ayarlar.

Genel Bakış ¶

Bu metod, bir form alanının içinde gösterilen placeholder metnini dinamik olarak günceller. Placeholder özelliğini verilen string ile ayarlar ve method chaining desteği için *FieldUpdate döndürür. Placeholder metinleri, alan boşken kullanıcıya ne girmesi gerektiği hakkında ipucu verir.

Kullanım Senaryoları ¶

- **Format Örneği**: Beklenen format için örnek göster (örn: "ö[email protected]") - **Değer Önerisi**: Tipik değer örnekleri göster (örn: "Ahmet Yılmaz") - **Arama İpucu**: Arama alanlarında ne aranabileceğini göster - **Dinamik İpuçları**: Kullanıcı seçimlerine göre farklı örnekler göster - **Birim Belirtme**: Sayısal alanlar için birim göster (örn: "0.00 TL")

Parametreler ¶

- `text`: Gösterilecek placeholder metni (string)

Dönüş Değeri ¶

`*FieldUpdate`: Method chaining için güncellenmiş FieldUpdate pointer'ı

Kullanım Örneği ¶

```go // Basit kullanım update := NewFieldUpdate().SetPlaceholder("Adınızı girin")

// Format örneği emailField := NewFieldUpdate().

SetPlaceholder("[email protected]").
SetHelpText("Geçerli bir e-posta adresi girin")

// Dinamik placeholder

searchTypeField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    searchType := formData["search_type"]
    switch searchType {
    case "name":
        return NewFieldUpdate().SetPlaceholder("Örn: Ahmet Yılmaz")
    case "email":
        return NewFieldUpdate().SetPlaceholder("Örn: [email protected]")
    case "phone":
        return NewFieldUpdate().SetPlaceholder("Örn: 0532 123 45 67")
    default:
        return NewFieldUpdate().SetPlaceholder("Arama...")
    }
})

// Birim belirtme priceField := NewFieldUpdate().

SetPlaceholder("0.00 TL").
SetHelpText("Ürün fiyatını girin")

// Bağlamsal örnek

countryField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    country := formData["country"]
    if country == "TR" {
        return NewFieldUpdate().
            SetPlaceholder("İstanbul, Ankara, İzmir...").
            SetHelpText("Türkiye'deki bir şehir seçin")
    } else if country == "US" {
        return NewFieldUpdate().
            SetPlaceholder("New York, Los Angeles, Chicago...").
            SetHelpText("Select a US city")
    }
    return NewFieldUpdate().SetPlaceholder("Şehir seçin...")
})

// Arama alanı searchField := NewFieldUpdate().

SetPlaceholder("Ürün adı, kategori veya marka ara...").
SetHelpText("En az 3 karakter girin")

// Sayısal alan quantityField := NewFieldUpdate().

SetPlaceholder("1").
SetHelpText("Sipariş miktarını girin (minimum: 1)")

// Tarih alanı dateField := NewFieldUpdate().

SetPlaceholder("GG/AA/YYYY").
SetHelpText("Doğum tarihinizi girin")

// Çoklu dil desteği language := ctx.Locals("language").(string)

if language == "tr" {
    return NewFieldUpdate().SetPlaceholder("Mesajınızı yazın...")
} else {

    return NewFieldUpdate().SetPlaceholder("Type your message...")
}

```

Önemli Notlar ¶

- **Görünürlük**: Placeholder sadece alan boşken görünür, değer girildiğinde kaybolur - **Erişilebilirlik**: Placeholder, label'ın yerini tutmamalıdır (her ikisi de olmalı) - **Uzunluk**: Kısa ve öz olmalıdır (ideal: 2-5 kelime) - **Renk**: Genelde soluk renkte gösterilir, asıl değerle karıştırılmamalı - **Validasyon**: Placeholder metni validasyon kuralı değildir, sadece ipucudur

Best Practices ¶

- Gerçekçi ve anlamlı örnekler kullanın - "Örn:" veya "..." gibi önekler ekleyerek placeholder olduğunu belirtin - Label ile tekrar etmeyin, ek bilgi verin - Kısa ve öz tutun (uzun metinler kesilir) - Birim veya format bilgisi içeren örnekler verin - Çoklu dil desteği için i18n kullanın

Placeholder vs HelpText Karşılaştırması ¶

| Özellik | Placeholder | HelpText | |---------|-------------|----------| | Konum | Alan içinde | Alan dışında (altında/yanında) | | Görünürlük | Sadece boşken | Her zaman | | Uzunluk | Kısa (2-5 kelime) | Orta (1-2 cümle) | | Amaç | Örnek göster | Açıklama yap | | Erişilebilirlik | Düşük | Yüksek |

Avantajlar ¶

- Kullanıcıya hızlı ipucu verir - Form alanını temiz tutar - Örnek göstererek anlaşılırlığı artırır - Kullanıcı hatalarını azaltır

func (*FieldUpdate) SetRules ¶

func (u *FieldUpdate) SetRules(rules []ValidationRule) *FieldUpdate

SetRules, alanın validasyon kurallarını ayarlar.

Genel Bakış ¶

Bu metod, bir form alanının tüm validasyon kurallarını tek seferde ayarlar. Mevcut kuralları tamamen değiştirir. Rules özelliğini verilen slice ile günceller ve method chaining desteği için *FieldUpdate döndürür. Dinamik validasyon senaryoları için kritik öneme sahiptir.

Kullanım Senaryoları ¶

- **Koşullu Validasyon**: Kullanıcı seçimlerine göre farklı validasyon kuralları uygula - **Dinamik Kural Setleri**: İş kurallarına göre validasyon kurallarını değiştir - **Rol Bazlı Validasyon**: Kullanıcı rolüne göre farklı validasyon seviyeleri - **Adım Bazlı Validasyon**: Form adımlarına göre farklı kurallar uygula - **Toplu Kural Güncelleme**: Birden fazla kuralı aynı anda güncelle

Parametreler ¶

- `rules`: ValidationRule slice'ı - Uygulanacak tüm validasyon kuralları

Dönüş Değeri ¶

`*FieldUpdate`: Method chaining için güncellenmiş FieldUpdate pointer'ı

Kullanım Örneği ¶

```go // Basit kullanım

rules := []ValidationRule{
    {Type: "required", Message: "Bu alan zorunludur"},
    {Type: "min", Value: 3, Message: "En az 3 karakter olmalıdır"},
    {Type: "max", Value: 50, Message: "En fazla 50 karakter olabilir"},
}

update := NewFieldUpdate().SetRules(rules)

// Koşullu validasyon - Kullanıcı tipine göre

userTypeField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    userType := formData["user_type"].(string)

    var rules []ValidationRule
    if userType == "corporate" {
        // Kurumsal kullanıcılar için sıkı kurallar
        rules = []ValidationRule{
            {Type: "required", Message: "Vergi numarası zorunludur"},
            {Type: "length", Value: 10, Message: "Vergi numarası 10 haneli olmalıdır"},
            {Type: "numeric", Message: "Sadece rakam içermelidir"},
            {Type: "tax_number", Message: "Geçerli bir vergi numarası değil"},
        }
    } else {
        // Bireysel kullanıcılar için esnek kurallar
        rules = []ValidationRule{
            {Type: "length", Value: 11, Message: "TC Kimlik No 11 haneli olmalıdır"},
            {Type: "numeric", Message: "Sadece rakam içermelidir"},
        }
    }

    return NewFieldUpdate().
        SetRules(rules).
        MakeRequired().
        SetHelpText(fmt.Sprintf("%s için kimlik bilgisi", userType))
})

// Adım bazlı validasyon

stepField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    step := formData["current_step"].(int)

    var emailRules []ValidationRule
    if step == 1 {
        // İlk adımda basit validasyon
        emailRules = []ValidationRule{
            {Type: "required", Message: "E-posta zorunludur"},
            {Type: "email", Message: "Geçerli bir e-posta adresi girin"},
        }
    } else if step == 2 {
        // İkinci adımda detaylı validasyon
        emailRules = []ValidationRule{
            {Type: "required", Message: "E-posta zorunludur"},
            {Type: "email", Message: "Geçerli bir e-posta adresi girin"},
            {Type: "unique", Table: "users", Column: "email", Message: "Bu e-posta zaten kullanılıyor"},
            {Type: "domain_whitelist", Value: []string{"company.com", "partner.com"}, Message: "Sadece şirket e-postaları kabul edilir"},
        }
    }

    return NewFieldUpdate().SetRules(emailRules)
})

// Rol bazlı validasyon userRole := ctx.Locals("user_role").(string) var priceRules []ValidationRule

if userRole == "admin" {
    // Admin için sınırsız
    priceRules = []ValidationRule{
        {Type: "required", Message: "Fiyat zorunludur"},
        {Type: "numeric", Message: "Geçerli bir sayı girin"},
        {Type: "min", Value: 0, Message: "Fiyat negatif olamaz"},
    }
} else if userRole == "manager" {

    // Manager için sınırlı
    priceRules = []ValidationRule{
        {Type: "required", Message: "Fiyat zorunludur"},
        {Type: "numeric", Message: "Geçerli bir sayı girin"},
        {Type: "min", Value: 0, Message: "Fiyat negatif olamaz"},
        {Type: "max", Value: 10000, Message: "Maksimum 10.000 TL girebilirsiniz"},
    }
} else {

    // Normal kullanıcı için çok sınırlı
    priceRules = []ValidationRule{
        {Type: "required", Message: "Fiyat zorunludur"},
        {Type: "numeric", Message: "Geçerli bir sayı girin"},
        {Type: "min", Value: 0, Message: "Fiyat negatif olamaz"},
        {Type: "max", Value: 1000, Message: "Maksimum 1.000 TL girebilirsiniz"},
    }
}

return NewFieldUpdate().

SetRules(priceRules).
SetHelpText(fmt.Sprintf("Rol: %s - Fiyat limitleri uygulanıyor", userRole))

// Ürün tipine göre validasyon

productTypeField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    productType := formData["product_type"].(string)

    var descriptionRules []ValidationRule
    if productType == "premium" {
        // Premium ürünler için detaylı açıklama zorunlu
        descriptionRules = []ValidationRule{
            {Type: "required", Message: "Premium ürünler için açıklama zorunludur"},
            {Type: "min", Value: 100, Message: "En az 100 karakter olmalıdır"},
            {Type: "max", Value: 5000, Message: "En fazla 5000 karakter olabilir"},
            {Type: "rich_text", Message: "Zengin metin formatı gereklidir"},
        }
    } else {
        // Standart ürünler için basit açıklama
        descriptionRules = []ValidationRule{
            {Type: "min", Value: 20, Message: "En az 20 karakter olmalıdır"},
            {Type: "max", Value: 500, Message: "En fazla 500 karakter olabilir"},
        }
    }

    return NewFieldUpdate().SetRules(descriptionRules)
})

// Boş kural seti (tüm validasyonları kaldır) update := NewFieldUpdate().SetRules([]ValidationRule{}) ```

Önemli Notlar ¶

- **Mevcut Kuralları Değiştirir**: SetRules() mevcut tüm kuralları siler ve yenileriyle değiştirir - **Boş Slice**: Boş slice göndermek tüm validasyon kurallarını kaldırır - **Kural Sırası**: Kurallar verilen sırada uygulanır - **Performans**: Çok fazla kural performansı etkileyebilir - **Sunucu Tarafı**: Client-side validasyon yeterli değildir, sunucu tarafında da validasyon yapın

ValidationRule Yapısı ¶

```go

type ValidationRule struct {
    Type    string      // Kural tipi: "required", "min", "max", "email", "numeric" vb.
    Value   interface{} // Kural değeri (min/max için sayı, pattern için regex vb.)
    Message string      // Hata mesajı
    Table   string      // Unique kontrolü için tablo adı
    Column  string      // Unique kontrolü için kolon adı
}

```

Yaygın Kural Tipleri ¶

- `required`: Alan zorunludur - `min`: Minimum değer/uzunluk - `max`: Maximum değer/uzunluk - `email`: E-posta formatı - `numeric`: Sayısal değer - `alpha`: Sadece harf - `alphanumeric`: Harf ve rakam - `url`: URL formatı - `regex`: Regex pattern - `unique`: Veritabanında benzersiz - `length`: Sabit uzunluk - `in`: Belirli değerlerden biri - `not_in`: Belirli değerlerden hiçbiri

Best Practices ¶

- Kullanıcı dostu hata mesajları yazın - Gereksiz kurallardan kaçının (performans) - Kuralları mantıksal sıraya göre düzenleyin (required önce, detaylı kurallar sonra) - Sunucu tarafında da aynı kuralları uygulayın - Karmaşık kurallar için custom validator yazın - Hata mesajlarında örnek verin

Avantajlar ¶

- Dinamik ve esnek validasyon sağlar - İş kurallarını kolayca uygular - Kullanıcı deneyimini iyileştirir - Veri bütünlüğünü sağlar - Toplu kural güncellemesi yapar

Dezavantajlar ¶

- Mevcut kuralları tamamen değiştirir (dikkatli kullanılmalı) - Çok fazla kural performansı etkileyebilir - Karmaşık kural setleri yönetimi zorlaştırabilir

SetRules vs AddRule Karşılaştırması ¶

| Özellik | SetRules | AddRule | |---------|----------|---------| | Mevcut Kurallar | Siler ve değiştirir | Korur ve ekler | | Kullanım | Toplu güncelleme | Tekli ekleme | | Performans | Tek seferde | Her çağrıda | | Esneklik | Düşük | Yüksek | | Kullanım Amacı | Tüm kuralları değiştir | Kural ekle |

func (*FieldUpdate) SetValue ¶

func (u *FieldUpdate) SetValue(value interface{}) *FieldUpdate

SetValue, alanın değerini programatik olarak ayarlar.

Genel Bakış ¶

Bu metod, bir form alanının değerini programatik olarak ayarlar. Value özelliğini verilen değer ile günceller ve method chaining desteği için *FieldUpdate döndürür. Bu özellik, hesaplanan değerler, otomatik doldurma ve değer senkronizasyonu için kullanılır.

Kullanım Senaryoları ¶

- **Hesaplanan Değerler**: Diğer alanların değerlerine göre otomatik hesaplama yap - **Otomatik Doldurma**: Kullanıcı seçimlerine göre alanları otomatik doldur - **Değer Senkronizasyonu**: Bir alanın değerini diğer alanlara kopyala - **Varsayılan Değerler**: Koşullara göre varsayılan değerler ata - **Değer Temizleme**: Belirli koşullarda alanları temizle (nil) - **Format Dönüşümü**: Bir formattan diğerine dönüştür

Parametreler ¶

- `value`: Atanacak değer (interface{} - herhangi bir tip olabilir)

• string, int, float64, bool, nil, map, slice vb.

Dönüş Değeri ¶

`*FieldUpdate`: Method chaining için güncellenmiş FieldUpdate pointer'ı

Kullanım Örneği ¶

```go // Basit kullanım update := NewFieldUpdate().SetValue("Yeni değer")

// Değer temizleme update := NewFieldUpdate().SetValue(nil)

// Hesaplanan değer - Toplam hesaplama

quantityField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    quantity := formData["quantity"].(float64)
    price := formData["price"].(float64)
    total := quantity * price

    // Toplam alanını güncelle
    return NewFieldUpdate().
        SetValue(total).
        MakeReadOnly().
        SetHelpText(fmt.Sprintf("Toplam: %.2f TL", total))
})

// Otomatik doldurma - Şehir seçimine göre posta kodu

cityField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    city := formData["city"].(string)

    // Şehir kodlarını map'ten al
    cityCodes := map[string]string{
        "istanbul": "34",
        "ankara": "06",
        "izmir": "35",
    }

    postalCode := cityCodes[city]
    return NewFieldUpdate().
        SetValue(postalCode).
        SetHelpText(fmt.Sprintf("%s için posta kodu: %s", city, postalCode))
})

// Değer senkronizasyonu - E-posta'yı kullanıcı adına kopyala

emailField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    email := formData["email"].(string)
    autoFillUsername := formData["auto_fill_username"].(bool)

    if autoFillUsername {
        // E-posta'nın @ öncesi kısmını kullanıcı adı olarak ata
        username := strings.Split(email, "@")[0]
        return NewFieldUpdate().
            SetValue(username).
            SetHelpText("E-posta adresinizden otomatik oluşturuldu")
    }
    return nil
})

// Cascade seçim temizleme

countryField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    // Ülke değiştiğinde şehir seçimini temizle
    return NewFieldUpdate().
        SetValue(nil).
        SetHelpText("Lütfen yeni ülkeye göre şehir seçin")
})

// Format dönüşümü - Telefon numarası formatlama

phoneField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    phone := formData["phone"].(string)

    // Sadece rakamları al
    digits := regexp.MustCompile(`\D`).ReplaceAllString(phone, "")

    // Formatla: (0532) 123 45 67
    if len(digits) == 11 {
        formatted := fmt.Sprintf("(%s) %s %s %s",
            digits[0:4], digits[4:7], digits[7:9], digits[9:11])
        return NewFieldUpdate().
            SetValue(formatted).
            SetHelpText("Telefon numarası formatlandı")
    }
    return nil
})

// Koşullu varsayılan değer

paymentMethodField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    paymentMethod := formData["payment_method"].(string)

    if paymentMethod == "installment" {
        // Taksitli ödeme seçildiğinde varsayılan taksit sayısı
        return NewFieldUpdate().
            SetValue(3).
            SetHelpText("Varsayılan: 3 taksit")
    }
    return NewFieldUpdate().SetValue(nil)
})

// Veritabanından değer çekme

productField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    productID := formData["product_id"].(int)

    // Ürün fiyatını veritabanından çek
    var product Product
    db := ctx.Locals("db").(*gorm.DB)
    db.First(&product, productID)

    // Fiyat alanını otomatik doldur
    return NewFieldUpdate().
        SetValue(product.Price).
        MakeReadOnly().
        SetHelpText(fmt.Sprintf("Ürün fiyatı: %.2f TL", product.Price))
})

// Karmaşık nesne değeri

addressField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    addressData := map[string]interface{}{
        "street": "Atatürk Caddesi",
        "city": "İstanbul",
        "postal_code": "34000",
        "country": "TR",
    }

    return NewFieldUpdate().SetValue(addressData)
})

```

Önemli Notlar ¶

- **Tip Güvenliği**: interface{} kullanıldığı için tip dönüşümlerine dikkat edin - **Nil Değer**: nil göndermek alanı temizler - **Validasyon**: SetValue ile atanan değerler de validasyon kurallarına tabidir - **Kullanıcı Girişi**: Programatik değer ataması kullanıcı girişini ezer - **ReadOnly ile Kullanım**: Hesaplanan değerler için MakeReadOnly() ile birlikte kullanın

Best Practices ¶

- Hesaplanan değerler için MakeReadOnly() kullanın - Tip dönüşümlerinde hata kontrolü yapın - Cascade seçimlerde önceki değeri temizleyin (nil) - Kullanıcıya değerin nereden geldiğini açıklayın (yardım metni) - Veritabanı sorgularında hata kontrolü yapın - Format dönüşümlerinde validasyon yapın

Avantajlar ¶

- Otomatik hesaplama sağlar - Kullanıcı deneyimini iyileştirir - Veri tutarlılığını sağlar - Form doldurma süresini kısaltır - Hata oranını azaltır

Dezavantajlar ¶

- Yanlış kullanımda kullanıcı girişini ezebilir - Tip güvenliği yoktur (interface{}) - Karmaşık hesaplamalarda performans sorunları olabilir

Güvenlik Notları ¶

- Kullanıcı girişini doğrudan kullanmadan önce sanitize edin - Veritabanı sorgularında SQL injection'a dikkat edin - Hassas bilgileri (şifre, kredi kartı) SetValue ile atamayın - Sunucu tarafında da aynı hesaplamaları yapın (güvenlik)

func (*FieldUpdate) Show ¶

func (u *FieldUpdate) Show() *FieldUpdate

Show, alanı görünür hale getirir.

Genel Bakış ¶

Bu metod, bir form alanının kullanıcı arayüzünde görünür olmasını sağlar. Visible özelliğini true olarak ayarlar ve method chaining desteği için *FieldUpdate döndürür.

Kullanım Senaryoları ¶

- Koşullu alan görünürlüğü: Belirli bir değer seçildiğinde ilgili alanları göster - Dinamik form yapısı: Kullanıcı seçimlerine göre form alanlarını göster/gizle - Wizard formlar: Adım adım form akışında ilgili alanları göster - Koşullu validasyon: Görünür olan alanlar için validasyon uygula

Dönüş Değeri ¶

`*FieldUpdate`: Method chaining için güncellenmiş FieldUpdate pointer'ı

Kullanım Örneği ¶

```go // Basit kullanım update := NewFieldUpdate().Show()

// Koşullu görünürlük

if formData["has_company"] == true {
    return NewFieldUpdate().Show().MakeRequired()
}

// Çoklu alan kontrolü

countryField.OnChange(func(field *Schema, formData map[string]interface{}, ctx *fiber.Ctx) *FieldUpdate {
    country := formData["country"]
    if country == "TR" {
        // Türkiye seçildiğinde TC Kimlik No alanını göster
        return NewFieldUpdate().Show().MakeRequired().SetHelpText("11 haneli TC Kimlik No")
    }
    return NewFieldUpdate().Hide()
})

// Method chaining ile birlikte kullanım update := NewFieldUpdate().

Show().
MakeRequired().
Enable().
SetHelpText("Bu alan artık görünür ve zorunlu")

```

Önemli Notlar ¶

- Show() çağrıldığında alan görünür olur ancak disabled durumu değişmez - Görünür olan alanlar için validasyon kuralları uygulanır - Hide() ile gizlenen alanlar için validasyon atlanır - Method chaining desteklenir, zincirleme çağrılar yapılabilir

Best Practices ¶

- Show() ile birlikte MakeRequired() veya MakeOptional() kullanarak validasyon durumunu belirtin - Görünür hale getirilen alanlara uygun yardım metni ekleyin - Koşullu görünürlükte her iki durumu da (Show/Hide) ele alın

func (*Filterable) GetFilterCallback ¶

func (f *Filterable) GetFilterCallback() func(*gorm.DB, any) *gorm.DB

GetFilterCallback, filtre callback fonksiyonunu döndürür. Hiçbir callback ayarlanmamışsa nil döndürür.

Döndürür:

• Filtre callback fonksiyonu veya ayarlanmamışsa nil

func (*Filterable) GetFilterOptions ¶

func (f *Filterable) GetFilterOptions() map[string]string

GetFilterOptions, filtre seçeneklerini döndürür. Hiçbir seçenek yapılandırılmamışsa boş bir map döndürür.

Döndürür:

• Filtre seçenekleri için değer-etiket eşlemesi

func (*Filterable) IsFilterable ¶

func (f *Filterable) IsFilterable() bool

IsFilterable, alanın filtrelenebilir olup olmadığını döndürür.

Döndürür:

• Alan filtrelenebilirse true, değilse false

func (*Filterable) SetFilterCallback ¶

func (f *Filterable) SetFilterCallback(cb func(*gorm.DB, any) *gorm.DB)

SetFilterCallback, özel bir filtre callback fonksiyonu ayarlar.

Callback, GORM veritabanı örneğini ve filtre değerini alır, ve filtre sorgusu uygulanmış değiştirilmiş bir veritabanı örneği döndürmelidir.

Parametreler:

• cb: Özel filtre mantığı için veritabanı sorgusunu değiştiren fonksiyon

Örnek:

field.SetFilterCallback(func(db *gorm.DB, value any) *gorm.DB {
    status, ok := value.(string)
    if !ok {
        return db
    }
    return db.Where("status = ?", status)
})

func (*Filterable) SetFilterOptions ¶

func (f *Filterable) SetFilterOptions(options map[string]string)

SetFilterOptions, kullanılabilir filtre seçeneklerini ayarlar.

Seçenekler, kullanıcıların önceden tanımlanmış değerlere göre filtreleme yapmasına izin veren bir açılır liste veya onay kutusu listesi olarak UI'da gösterilir.

Parametreler:

• options: Filtre seçenekleri için değer-etiket eşlemesi

Örnek:

field.SetFilterOptions(map[string]string{
    "draft": "Taslak",
    "published": "Yayınlandı",
    "archived": "Arşivlendi",
})

func (*Filterable) SetFilterable ¶

func (f *Filterable) SetFilterable(filterable bool)

SetFilterable, alanın filtrelenebilir olup olmadığını ayarlar.

Parametreler:

• filterable: Filtrelemeyi etkinleştirmek için true, devre dışı bırakmak için false

Örnek:

field.SetFilterable(true)

func (*GormConfig) ToGormTag ¶

func (g *GormConfig) ToGormTag() string

ToGormTag, GormConfig'i GORM struct tag string'ine dönüştürür.

func (*GormConfig) WithAutoIncrement ¶

func (g *GormConfig) WithAutoIncrement() *GormConfig

WithAutoIncrement, otomatik artış olarak işaretler.

func (*GormConfig) WithColumn ¶

func (g *GormConfig) WithColumn(name string) *GormConfig

WithColumn, özel sütun adı belirler.

func (*GormConfig) WithComment ¶

func (g *GormConfig) WithComment(comment string) *GormConfig

WithComment, sütun yorumu ekler.

func (*GormConfig) WithDefault ¶

func (g *GormConfig) WithDefault(value interface{}) *GormConfig

WithDefault, varsayılan değer belirler.

func (*GormConfig) WithForeignKey ¶

func (g *GormConfig) WithForeignKey(fk, references string) *GormConfig

WithForeignKey, foreign key ilişkisi tanımlar.

func (*GormConfig) WithFullTextIndex ¶

func (g *GormConfig) WithFullTextIndex(name ...string) *GormConfig

WithFullTextIndex, fulltext indeks oluşturur.

func (*GormConfig) WithIDType ¶

func (g *GormConfig) WithIDType(idType string) *GormConfig

WithIDType, ID tipini belirler (uuid, snowflake, ulid).

func (*GormConfig) WithIndex ¶

func (g *GormConfig) WithIndex(name ...string) *GormConfig

WithIndex, normal indeks oluşturur.

func (*GormConfig) WithManyToMany ¶

func (g *GormConfig) WithManyToMany(tableName string) *GormConfig

WithManyToMany, many-to-many ilişki için ara tablo tanımlar.

func (*GormConfig) WithNotNull ¶

func (g *GormConfig) WithNotNull() *GormConfig

WithNotNull, NOT NULL kısıtlaması ekler.

func (*GormConfig) WithOnDelete ¶

func (g *GormConfig) WithOnDelete(action string) *GormConfig

WithOnDelete, ON DELETE davranışını belirler.

func (*GormConfig) WithOnUpdate ¶

func (g *GormConfig) WithOnUpdate(action string) *GormConfig

WithOnUpdate, ON UPDATE davranışını belirler.

func (*GormConfig) WithPrecision ¶

func (g *GormConfig) WithPrecision(precision, scale int) *GormConfig

WithPrecision, ondalık hassasiyeti belirler.

func (*GormConfig) WithPrimaryKey ¶

func (g *GormConfig) WithPrimaryKey() *GormConfig

WithPrimaryKey, birincil anahtar olarak işaretler.

func (*GormConfig) WithSize ¶

func (g *GormConfig) WithSize(size int) *GormConfig

WithSize, sütun boyutunu belirler.

func (*GormConfig) WithSnowflake ¶

func (g *GormConfig) WithSnowflake() *GormConfig

WithSnowflake, Snowflake tipinde ID kullanır.

func (*GormConfig) WithSoftDelete ¶

func (g *GormConfig) WithSoftDelete() *GormConfig

WithSoftDelete, soft delete desteği ekler.

func (*GormConfig) WithType ¶

func (g *GormConfig) WithType(sqlType string) *GormConfig

WithType, SQL tipini belirler.

func (*GormConfig) WithULID ¶

func (g *GormConfig) WithULID() *GormConfig

WithULID, ULID tipinde ID kullanır.

func (*GormConfig) WithUUID ¶

func (g *GormConfig) WithUUID() *GormConfig

WithUUID, UUID tipinde ID kullanır.

func (*GormConfig) WithUniqueIndex ¶

func (g *GormConfig) WithUniqueIndex(name ...string) *GormConfig

WithUniqueIndex, benzersiz indeks oluşturur.

func (*HasManyField) AutoOptions ¶

func (h *HasManyField) AutoOptions(displayField string) *HasManyField

AutoOptions, ilişkili tablodan otomatik options oluşturmayı etkinleştirir.

Bu metod, HasMany ilişkisinde ilişkili kayıtların otomatik olarak yüklenmesini ve frontend'de multi-select combobox'ta gösterilmesini sağlar.

Parametreler ¶

- **displayField**: Option label'ı için kullanılacak sütun adı (örn. "title", "name")

Kullanım Örneği ¶

// Author resource'unda Posts ilişkisi
field := fields.HasMany("Posts", "posts", "posts").
    AutoOptions("title").  // Post'ların "title" sütunu label olarak kullanılır
    ForeignKey("author_id").
    WithEagerLoad()

Backend Response Formatı ¶

AutoOptions etkinleştirildiğinde, backend response'unda options otomatik olarak eklenir:

{
  "posts": {
    "key": "posts",
    "type": "relationship",
    "view": "has-many-field",
    "data": [1, 2, 3],
    "props": {
      "related_resource": "posts",
      "options": {
        "1": "First Post",
        "2": "Second Post",
        "3": "Third Post"
      }
    }
  }
}

Frontend Rendering ¶

Frontend'de HasManyField componenti otomatik olarak: - Pre-loaded options'ları multi-select combobox'ta gösterir - Search fonksiyonu ile filtreleme yapar - Seçili değerleri chips olarak gösterir - Kullanıcı yeni kayıtlar seçebilir veya mevcut seçimleri kaldırabilir

Önemli Notlar ¶

- displayField sütunu, ilişkili tabloda mevcut olmalıdır - Büyük veri setleri için (10,000+ kayıt) performans sorunları olabilir - Best practice: AutoOptions sadece küçük-orta veri setleri için kullanın - Null değerler için otomatik fallback kontrolü yapılır

Döndürür:

• HasManyField pointer'ı (method chaining için)

func (*HasManyField) Count ¶

func (h *HasManyField) Count() int64

Count returns the count of related resources

func (*HasManyField) Extract ¶

func (h *HasManyField) Extract(resource interface{})

Extract, HasMany ilişkisi için özel veri çıkarma metodudur.

Bu metod, Schema'nın genel Extract metodunu override eder ve HasMany ilişkisi için özel işlem yapar. İlişkili kayıtları JSON tag'lere göre serialize eder.

İşleyiş ¶

1. Schema'nın Extract metodunu çağırır (mevcut davranışı korumak için)
2. Eğer Data nil ise, boş array olarak ayarlar
3. Eğer Data bir slice ise: a. Her kayıt için JSON marshaling yapar (JSON tag'ler otomatik kullanılır) b. JSON'dan map[string]interface{}'e unmarshal eder c. Bu map'leri data array'ine ekler

JSON Tag Kullanımı ¶

Model'de tanımlı JSON tag'ler otomatik olarak kullanılır:

type Address struct {
    ID             uint   `json:"id"`
    OrganizationID uint   `json:"organization_id"`
    Name           string `json:"name"`
}

Sonuç: {"id": 1, "organization_id": 16, "name": "Adres"}

Parametreler ¶

- resource: Veri çıkarılacak kaynak (struct veya map)

Kullanım Örneği ¶

// Organization model'inde Addresses field'ı var
type Organization struct {
    ID        uint
    Name      string
    Addresses []Address
}

// HasMany field Extract çağrıldığında
field := fields.HasMany("Addresses", "addresses", "addresses")
field.Extract(&organization)
// field.Data artık [{"id": 1, "organization_id": 16, ...}] gibi JSON tag'lere göre serialize edilmiş kayıtlar içerir

func (*HasManyField) ForeignKey ¶

func (h *HasManyField) ForeignKey(key string) *HasManyField

ForeignKey, foreign key sütun adını ayarlar.

Bu metod, ilişkili tablodaki foreign key sütununun adını özelleştirir. Varsayılan olarak slug + "_id" kullanılır.

Parametreler ¶

- **key**: Foreign key sütun adı (örn. "author_id", "user_id", "category_id")

Kullanım Örneği ¶

field := fields.HasMany("Posts", "posts", "posts").
    ForeignKey("author_id")
// Posts tablosunda "author_id" sütunu foreign key olarak kullanılır

Önemli Notlar ¶

- Foreign key sütunu, ilişkili tabloda mevcut olmalıdır - Genellikle "parent_table_id" formatında olur (örn. "author_id", "category_id") - GORM tarafından otomatik olarak ilişki kurulumu için kullanılır

Döndürür:

• HasManyField pointer'ı (method chaining için)

func (*HasManyField) GetDisplayKey ¶

func (h *HasManyField) GetDisplayKey() string

GetDisplayKey returns the display key (not used for HasMany)

func (*HasManyField) GetForeignKeyColumn ¶

func (h *HasManyField) GetForeignKeyColumn() string

GetForeignKeyColumn, foreign key sütun adını döndürür.

Bu metod, HasMany ilişkisinde kullanılan foreign key sütununun adını döndürür. Foreign key, ilişkili tablodaki referans sütunudur.

Dönüş Değeri ¶

- Foreign key sütun adı (örn. "author_id", "user_id", "category_id")

Kullanım Örneği ¶

field := fields.HasMany("Posts", "posts", "posts").ForeignKey("author_id")
foreignKey := field.GetForeignKeyColumn() // "author_id"

Döndürür:

• Foreign key sütun adı

func (*HasManyField) GetLoadingStrategy ¶

func (h *HasManyField) GetLoadingStrategy() LoadingStrategy

GetLoadingStrategy returns the loading strategy

func (*HasManyField) GetOwnerKeyColumn ¶

func (h *HasManyField) GetOwnerKeyColumn() string

GetOwnerKeyColumn, owner key sütun adını döndürür.

Bu metod, HasMany ilişkisinde kullanılan owner key sütununun adını döndürür. Owner key, ana tablodaki referans sütunudur (genellikle primary key).

Dönüş Değeri ¶

- Owner key sütun adı (örn. "id", "uuid")

Kullanım Örneği ¶

field := fields.HasMany("Posts", "posts", "posts").OwnerKey("id")
ownerKey := field.GetOwnerKeyColumn() // "id"

Döndürür:

• Owner key sütun adı

func (*HasManyField) GetQueryCallback ¶

func (h *HasManyField) GetQueryCallback() func(interface{}) interface{}

GetQueryCallback returns the query callback

func (*HasManyField) GetRelatedResource ¶

func (h *HasManyField) GetRelatedResource() interface{}

GetRelatedResource, ilişkili resource instance'ını döndürür.

Bu metod, RelatedResource'a erişim sağlar.

Dönüş Değeri ¶

- interface{}: Resource instance'ı (resource.Resource interface) - nil: RelatedResource set edilmemişse

Kullanım Örneği ¶

// Extract metodunda
if h.GetRelatedResource() == nil {
    // RelatedResource set edilmemiş, minimal format kullan
    return
}

Döndürür:

• Resource instance'ı veya nil

func (*HasManyField) GetRelatedResourceSlug ¶

func (h *HasManyField) GetRelatedResourceSlug() string

GetRelatedResourceSlug, ilişkili resource'un slug'ını döndürür.

Bu metod, RelatedResourceSlug'a erişim sağlar. Genellikle field_handler.go'da resource registry'den resource instance'ı almak için kullanılır.

Dönüş Değeri ¶

- string: Resource slug'ı (örn. "users", "posts", "addresses")

Kullanım Örneği ¶

// field_handler.go'da
if relField, ok := element.(*fields.HasManyField); ok {
    slug := relField.GetRelatedResourceSlug()
    relatedResource := resource.Get(slug)
    relField.SetRelatedResource(relatedResource)
}

Döndürür:

• Resource slug'ı

func (*HasManyField) GetRelatedTableName ¶

func (h *HasManyField) GetRelatedTableName() string

GetRelatedTableName, ilişkili tablo adını döndürür.

Bu metod, HasMany ilişkisinde kullanılan ilişkili tablonun adını döndürür. Raw SQL sorguları için kullanılır.

Dönüş Değeri ¶

- İlişkili tablo adı (örn. "posts", "comments", "orders")

Kullanım Örneği ¶

field := fields.HasMany("Posts", "posts", "posts")
tableName := field.GetRelatedTableName() // "posts"

Döndürür:

• İlişkili tablo adı

func (*HasManyField) GetRelationshipName ¶

func (h *HasManyField) GetRelationshipName() string

GetRelationshipName returns the relationship name

func (*HasManyField) GetRelationshipType ¶

func (h *HasManyField) GetRelationshipType() string

GetRelationshipType returns the relationship type

func (*HasManyField) GetSearchableColumns ¶

func (h *HasManyField) GetSearchableColumns() []string

GetSearchableColumns returns the searchable columns (not used for HasMany)

func (*HasManyField) GetTypes ¶

func (h *HasManyField) GetTypes() map[string]string

GetTypes returns the type mappings (not used for HasMany)

func (*HasManyField) IsRequired ¶

func (h *HasManyField) IsRequired() bool

IsRequired returns whether the field is required

func (*HasManyField) Label ¶

func (h *HasManyField) Label(label string) Element

Label sets the field label while preserving HasMany concrete type in fluent chains.

func (*HasManyField) OwnerKey ¶

func (h *HasManyField) OwnerKey(key string) *HasManyField

OwnerKey, owner key sütun adını ayarlar.

Bu metod, ana tablodaki referans sütununun adını özelleştirir. Varsayılan olarak "id" (primary key) kullanılır.

Parametreler ¶

- **key**: Owner key sütun adı (örn. "id", "uuid", "author_id")

Kullanım Örneği ¶

field := fields.HasMany("Posts", "posts", "posts").
    ForeignKey("author_id").
    OwnerKey("id")
// Authors tablosundaki "id" sütunu ile Posts tablosundaki "author_id" sütunu eşleştirilir

Önemli Notlar ¶

- Owner key sütunu, ana tabloda mevcut olmalıdır - Genellikle primary key kullanılır ("id") - Özel durumlar için farklı sütunlar kullanılabilir (örn. "uuid")

Döndürür:

• HasManyField pointer'ı (method chaining için)

func (*HasManyField) Placeholder ¶

func (h *HasManyField) Placeholder(placeholder string) Element

Placeholder sets the field placeholder while preserving HasMany concrete type in fluent chains.

func (*HasManyField) Query ¶

func (h *HasManyField) Query(fn func(interface{}) interface{}) *HasManyField

Query sets the query callback for customizing relationship query

func (*HasManyField) ResolveRelationship ¶

func (h *HasManyField) ResolveRelationship(item interface{}) (interface{}, error)

ResolveRelationship resolves the relationship by loading all related resources

func (*HasManyField) Searchable ¶

func (h *HasManyField) Searchable() Element

Searchable marks the element as searchable (implements Element interface)

func (*HasManyField) SetRelatedResource ¶

func (h *HasManyField) SetRelatedResource(res interface{}) *HasManyField

SetRelatedResource, ilişkili resource instance'ını set eder.

Bu metod, RelatedResource'u runtime'da set etmek için kullanılır. Genellikle field_handler.go'da Extract çağrılmadan önce kullanılır.

Kullanım Senaryoları ¶

- Circular dependency önlemek için string slug kullanıldığında - Runtime'da resource registry'den resource instance'ı alındığında - Field handler'da Extract öncesi RelatedResource'u set etmek

Parametreler ¶

- res: Resource instance'ı (resource.Resource interface)

Kullanım Örneği ¶

// field_handler.go'da Extract öncesi
if relField, ok := element.(*fields.HasManyField); ok {
    if relField.RelatedResource == nil {
        relatedResource := resource.Get(relField.RelatedResourceSlug)
        relField.SetRelatedResource(relatedResource)
    }
}
element.Extract(item)

Döndürür:

• HasManyField pointer'ı (method chaining için)

func (*HasManyField) ValidateRelationship ¶

func (h *HasManyField) ValidateRelationship(value interface{}) error

ValidateRelationship validates the relationship

func (*HasManyField) WithEagerLoad ¶

func (h *HasManyField) WithEagerLoad() *HasManyField

WithEagerLoad sets the loading strategy to eager loading

func (*HasManyField) WithFullData ¶

func (h *HasManyField) WithFullData() *HasManyField

WithFullData, ilişkili kayıtların tam verilerini (raw data + title) döndürmesini sağlar.

Bu metod, Extract metodunun davranışını değiştirir: - Varsayılan (FullDataMode=false): Minimal format (sadece id + title) - WithFullData() çağrıldığında (FullDataMode=true): Full format (tüm raw data + title)

Kullanım Senaryoları ¶

- Frontend'de ilişkili kayıtların detaylı bilgilerini göstermek - Relationship field'larında tüm veriyi kullanmak - Custom rendering için ek field'lara ihtiyaç duymak

Kullanım Örneği ¶

// Minimal format (varsayılan): {"id": 1, "title": "Adres 1"}
fields.HasMany("Addresses", "addresses", "addresses")

// Full format: {"ID": 1, "Name": "Adres 1", "City": "İstanbul", ..., "title": "Adres 1"}
fields.HasMany("Addresses", "addresses", "addresses").
    WithFullData()

Döndürür:

• HasManyField pointer'ı (method chaining için)

func (*HasManyField) WithLazyLoad ¶

func (h *HasManyField) WithLazyLoad() *HasManyField

WithLazyLoad sets the loading strategy to lazy loading

func (*HasOneField) AutoOptions ¶

func (h *HasOneField) AutoOptions(displayField string) *HasOneField

AutoOptions, ilişkili tablodan otomatik seçenek üretimini etkinleştirir.

Bu method, HasOne ilişkisinde ilişkili kayıtların otomatik olarak seçenek listesi olarak sunulmasını sağlar. Frontend'de dropdown veya select bileşenlerinde kullanılır.

Parametreler ¶

- **displayField**: Seçenek etiketinde gösterilecek sütun adı (örn. "name", "title")

Kullanım Senaryoları ¶

- **Profil Seçimi**: Kullanıcı profili seçerken profil adlarını gösterme - **Başkent Seçimi**: Ülke başkentlerini dropdown'da listeleme - **Fatura Seçimi**: Sipariş için fatura seçerken fatura numaralarını gösterme

Kullanım Örneği ¶

field := fields.HasOne("Profile", "profile", "profiles").
    AutoOptions("full_name").
    ForeignKey("user_id")

Önemli Notlar ¶

- displayField, ilişkili tabloda mevcut bir sütun olmalıdır - Büyük veri setlerinde performans sorunlarına neden olabilir - Sayfalama ve arama özellikleri ile birlikte kullanılması önerilir

Döndürür:

• Yapılandırılmış HasOneField pointer'ı (method chaining için)

func (*HasOneField) Extract ¶

func (h *HasOneField) Extract(resource interface{})

Extract, resource'dan değeri çıkarır ve işler.

Bu method, HasOne ilişkisinde ilişkili resource'un ID değerini çıkarır. Eğer ilişkili veri bir struct ise, struct'ın ID alanını bulup değer olarak ayarlar. Bu, frontend'e gönderilecek veriyi hazırlar ve sadece ID'yi döndürür.

Çalışma Mantığı ¶

1. Schema.Extract() ile temel extraction yapılır 2. Eğer veri nil ise, işlem sonlandırılır 3. Eğer veri pointer ise, dereference edilir 4. Eğer veri struct ise, ID veya Id alanı aranır 5. Bulunan ID değeri Data alanına atanır

Kullanım Senaryoları ¶

- **API Response**: Frontend'e sadece ilişkili kaydın ID'sini gönderme - **Form Data**: Edit formlarında mevcut ilişkili kaydın ID'sini gösterme - **Serialization**: JSON response'da nested struct yerine ID kullanma - **Data Transformation**: Struct'tan primitive değere dönüşüm

Örnek Veri Dönüşümü ¶

**Giriş (Struct):**

user := User{
    ID: 1,
    Profile: Profile{
        ID: 42,
        FullName: "John Doe",
        Avatar: "avatar.jpg",
    },
}

**Çıkış (ID):**

field.Data = 42  // Sadece Profile ID'si

Desteklenen Veri Tipleri ¶

**Struct:**

Profile{ID: 42, FullName: "John"} → 42

**Pointer to Struct:**

&Profile{ID: 42, FullName: "John"} → 42

**Nil Pointer:**

var profile *Profile = nil → nil

**Primitive (ID zaten var):**

42 → 42 (değişmez)

ID Alan İsimleri ¶

Method, aşağıdaki alan isimlerini sırayla arar: 1. "ID" (büyük harf, Go convention) 2. "Id" (camelCase, alternatif)

Kullanım Örneği ¶

// Resource tanımı
type User struct {
    ID      uint
    Profile Profile
}

type Profile struct {
    ID       uint
    FullName string
}

// Field tanımı
field := fields.HasOne("Profile", "profile", "profiles")

// Extract çağrısı
user := User{
    ID: 1,
    Profile: Profile{ID: 42, FullName: "John"},
}
field.Extract(user)

// Sonuç
fmt.Println(field.Data) // Output: 42

JSON Serialization ¶

Extract sonrası JSON response:

{
    "id": 1,
    "profile": 42  // Struct yerine sadece ID
}

Reflection Kullanımı ¶

Bu method, Go'nun reflection paketini kullanır: - reflect.ValueOf(): Değeri reflection value'ya çevirir - v.Kind(): Değerin tipini kontrol eder (Ptr, Struct) - v.Elem(): Pointer'ı dereference eder - v.FieldByName(): Struct alanını isimle bulur - idField.Interface(): Reflection value'yu interface{}'e çevirir

Önemli Notlar ¶

- ID alanı bulunamazsa, Data değişmeden kalır - ID alanı private ise (küçük harfle başlıyorsa) erişilemez - ID alanı exported olmalıdır (büyük harfle başlamalı) - Nil pointer'lar güvenli şekilde işlenir

Performans ¶

- Reflection kullanımı nedeniyle normal field access'ten yavaştır - Ancak, serialization için gereklidir - Büyük veri setlerinde dikkat edilmeli - Cache mekanizması ile optimize edilebilir

Hata Durumları ¶

Method, aşağıdaki durumlarda sessizce başarısız olur: - ID alanı bulunamazsa (Data değişmez) - ID alanı private ise (erişilemez) - Veri tipi desteklenmiyorsa (Data değişmez)

Alternatif Yaklaşımlar ¶

**Manuel ID Extraction:**

if user.Profile.ID != 0 {
    field.Data = user.Profile.ID
}

**Interface Method:**

type IDGetter interface {
    GetID() uint
}

**Struct Tag:**

Profile Profile `json:"profile_id,omitempty"`

Uyarılar ¶

- Reflection kullanımı runtime overhead ekler - Type assertion başarısız olabilir - ID alanı yoksa sessizce başarısız olur - Panic riski düşük ama mevcut (invalid reflection operations)

Parametreler:

• resource: Extract edilecek resource (struct veya pointer)

func (*HasOneField) ForeignKey ¶

func (h *HasOneField) ForeignKey(key string) *HasOneField

ForeignKey, foreign key sütun adını ayarlar.

Bu method, ilişkili tablodaki foreign key sütununun adını özelleştirmenizi sağlar. Varsayılan olarak, foreign key "{slug}_id" formatında oluşturulur.

Parametreler ¶

- **key**: Foreign key sütun adı (örn. "user_id", "owner_id", "parent_id")

Kullanım Senaryoları ¶

- **Özel İsimlendirme**: Standart dışı foreign key isimleri kullanma - **Legacy Veritabanları**: Mevcut veritabanı şemalarına uyum sağlama - **Çoklu İlişkiler**: Aynı tabloya birden fazla ilişki tanımlama

Kullanım Örneği ¶

// Standart kullanım
field := fields.HasOne("Profile", "profile", "profiles").
    ForeignKey("user_id")

// Özel isimlendirme
field := fields.HasOne("Manager", "manager", "users").
    ForeignKey("manager_user_id")

// Legacy veritabanı
field := fields.HasOne("Invoice", "invoice", "invoices").
    ForeignKey("order_fk")

GORM Entegrasyonu ¶

Bu ayar, GORM'un `foreignKey` tag'i ile senkronize edilir:

type User struct {
    ID      uint
    Profile Profile `gorm:"foreignKey:user_id"`
}

Önemli Notlar ¶

- Foreign key sütunu ilişkili tabloda mevcut olmalıdır - Sütun tipi, owner key ile uyumlu olmalıdır (genellikle uint veya int) - Index eklenmesi performans için önerilir - Foreign key constraint'leri veritabanı seviyesinde tanımlanmalıdır

Döndürür:

• Yapılandırılmış HasOneField pointer'ı (method chaining için)

func (*HasOneField) GetDisplayKey ¶

func (h *HasOneField) GetDisplayKey() string

GetDisplayKey, display key'i döndürür (HasOne için kullanılmaz).

Bu method, HasOne ilişkisinde kullanılmaz ve boş string döndürür. Display key, genellikle HasMany ve BelongsToMany gibi çoklu kayıt ilişkilerinde hangi alanın gösterileceğini belirtmek için kullanılır.

Dönüş Değeri ¶

- Boş string ("") - HasOne için display key kavramı geçerli değildir

Neden Kullanılmaz? ¶

HasOne ilişkisi tek bir kayıt döndürdüğü için, display key'e ihtiyaç yoktur. Display key, çoklu kayıtların listesinde hangi alanın gösterileceğini belirlemek için kullanılır.

Display Key Kullanılan İlişkiler ¶

**HasMany:** - Birden fazla kayıt döndürür - Her kayıt için display key ile gösterim yapılır - Örnek: User -> Posts (post.title gösterilir)

**BelongsToMany:** - Çok-çok ilişkide birden fazla kayıt - Pivot tablo üzerinden display key kullanılır - Örnek: User -> Roles (role.name gösterilir)

**MorphMany:** - Polimorfik bir-çok ilişki - Display key ile kayıtlar listelenir - Örnek: Post -> Comments (comment.body gösterilir)

HasOne vs HasMany Karşılaştırması ¶

**HasOne (Bu Method):**

field := fields.HasOne("Profile", "profile", "profiles")
displayKey := field.GetDisplayKey() // "" (boş)
// Tek kayıt döndürür, display key gerekmez

**HasMany:**

field := fields.HasMany("Posts", "posts", "posts").
    DisplayKey("title")
displayKey := field.GetDisplayKey() // "title"
// Birden fazla kayıt, her biri title ile gösterilir

Interface Implementation ¶

Bu method, Relationship interface'ini implement eder:

type Relationship interface {
    GetDisplayKey() string  // Bu method
    GetSearchableColumns() []string
    // ... diğer method'lar
}

Kullanım Örneği ¶

field := fields.HasOne("Profile", "profile", "profiles")
displayKey := field.GetDisplayKey()
fmt.Println(displayKey) // Output: "" (boş string)

// Tip kontrolü
if displayKey == "" {
    fmt.Println("Display key not used for HasOne")
}

JSON Serialization ¶

API response'da bu alan genellikle dahil edilmez:

{
    "name": "Profile",
    "key": "profile",
    "type": "relationship",
    "relationship_type": "hasOne",
    "related_resource": "profiles"
    // display_key yok (boş olduğu için)
}

Alternatif Yaklaşımlar ¶

HasOne için display key yerine, ilişkili kaydın tamamı döndürülür:

// API Response
{
    "id": 1,
    "name": "John",
    "profile": {
        "id": 42,
        "full_name": "John Doe",
        "avatar": "avatar.jpg"
    }
}

Önemli Notlar ¶

- Her zaman boş string döndürür - HasOne için display key kavramı geçerli değildir - Çoklu kayıt ilişkilerinde (HasMany, BelongsToMany) kullanılır - Interface uyumluluğu için implement edilmiştir

Best Practices ¶

HasOne ilişkisinde display key kullanmayın:

// Yanlış (etkisiz)
field := fields.HasOne("Profile", "profile", "profiles").
    DisplayKey("full_name") // HasOne'da DisplayKey method'u yok

// Doğru
field := fields.HasOne("Profile", "profile", "profiles")
// Display key gerekmez, tüm profile objesi döndürülür

Performans ¶

- O(1) kompleksitesi (sabit string dönüşü) - Bellek allocation yok - Çok hızlı çalışır

Döndürür:

• Boş string ("") - HasOne için kullanılmaz

func (*HasOneField) GetForeignKeyColumn ¶

func (h *HasOneField) GetForeignKeyColumn() string

GetForeignKeyColumn, foreign key sütun adını döndürür.

Bu metod, HasOne ilişkisinde kullanılan foreign key sütununun adını döndürür. Foreign key, ilişkili tablodaki referans sütunudur.

Dönüş Değeri ¶

- Foreign key sütun adı (örn. "user_id", "order_id", "country_id")

Kullanım Örneği ¶

field := fields.HasOne("Profile", "profile", "profiles").ForeignKey("user_id")
foreignKey := field.GetForeignKeyColumn() // "user_id"

Döndürür:

• Foreign key sütun adı

func (*HasOneField) GetHoverCard ¶

func (h *HasOneField) GetHoverCard() *HoverCardConfig

GetHoverCard, hover card konfigürasyonunu döndürür.

Bu metod, hover card konfigürasyonunu alır.

Döndürür:

• HoverCardConfig pointer'ı (nil olabilir)

func (*HasOneField) GetLoadingStrategy ¶

func (h *HasOneField) GetLoadingStrategy() LoadingStrategy

GetLoadingStrategy, yükleme stratejisini döndürür.

Bu method, HasOne ilişkisinin yükleme stratejisini (eager veya lazy loading) döndürür. Eğer strateji ayarlanmamışsa, varsayılan olarak EAGER_LOADING döndürür.

Dönüş Değeri ¶

- LoadingStrategy: EAGER_LOADING veya LAZY_LOADING - Varsayılan: EAGER_LOADING (N+1 sorgu problemini önlemek için)

Loading Strategy Tipleri ¶

**EAGER_LOADING:** - İlişkili kayıtlar ana kayıtlarla birlikte yüklenir - N+1 sorgu problemini önler - Liste görünümlerinde önerilir - Performanslı toplu yükleme

**LAZY_LOADING:** - İlişkili kayıtlar sadece gerektiğinde yüklenir - İsteğe bağlı yükleme - Tek kayıt görünümlerinde kullanılabilir - N+1 problem riski vardır

Kullanım Senaryoları ¶

- **Query Optimization**: Sorgu stratejisini belirleme - **Preload Decision**: Preload yapılıp yapılmayacağına karar verme - **Performance Tuning**: Performans optimizasyonu için strateji seçimi - **Dynamic Loading**: Runtime'da yükleme stratejisini kontrol etme - **Debugging**: Yükleme stratejisini loglama ve debug etme

Kullanım Örneği ¶

// Eager loading ile field
field := fields.HasOne("Profile", "profile", "profiles").
    WithEagerLoad()
strategy := field.GetLoadingStrategy()
fmt.Println(strategy) // Output: EAGER_LOADING

// Lazy loading ile field
field := fields.HasOne("Profile", "profile", "profiles").
    WithLazyLoad()
strategy := field.GetLoadingStrategy()
fmt.Println(strategy) // Output: LAZY_LOADING

// Varsayılan (strateji ayarlanmamış)
field := fields.HasOne("Profile", "profile", "profiles")
strategy := field.GetLoadingStrategy()
fmt.Println(strategy) // Output: EAGER_LOADING (varsayılan)

Strateji Bazlı Query Execution ¶

func loadRelationships(fields []*HasOneField, items []interface{}) {
    for _, field := range fields {
        strategy := field.GetLoadingStrategy()

        switch strategy {
        case EAGER_LOADING:
            // Tüm kayıtları tek sorguda yükle
            preloadRelationships(field, items)

        case LAZY_LOADING:
            // Her kayıt için ayrı ayrı yükle (gerektiğinde)
            // Hiçbir şey yapma, isteğe bağlı yükleme
        }
    }
}

Eager Loading Implementation ¶

if field.GetLoadingStrategy() == EAGER_LOADING {
    // GORM Preload kullan
    db.Preload(field.Key).Find(&users)

    // Veya manuel batch loading
    ownerIDs := extractOwnerIDs(users)
    profiles := loadProfilesByOwnerIDs(ownerIDs)
    mapProfilesToUsers(users, profiles)
}

Lazy Loading Implementation ¶

if field.GetLoadingStrategy() == LAZY_LOADING {
    // İlişki sadece erişildiğinde yüklenir
    // Hiçbir şey yapma, manuel yükleme gerekir
    for _, user := range users {
        if needsProfile(user) {
            profile, _ := field.ResolveRelationship(user)
            user.Profile = profile
        }
    }
}

Varsayılan Davranış ¶

Strateji ayarlanmamışsa (boş string), varsayılan olarak EAGER_LOADING döndürülür:

field := fields.HasOne("Profile", "profile", "profiles")
// LoadingStrategy field'ı boş string

strategy := field.GetLoadingStrategy()
// EAGER_LOADING döndürür (varsayılan)

Bu, N+1 sorgu problemini önlemek için güvenli bir varsayılandır.

Performans Karşılaştırması ¶

**100 Kullanıcı + Profilleri:**

**Eager Loading:** - Sorgu sayısı: 2 (users + profiles) - Süre: ~50ms - Bellek: Yüksek (tüm veriler)

**Lazy Loading:** - Sorgu sayısı: 101 (users + 100 profile sorgusu) - Süre: ~500ms (10x yavaş) - Bellek: Düşük (sadece gerekli veriler)

Strateji Seçim Rehberi ¶

**Eager Loading Kullan:** - Liste görünümlerinde (index, table) - İlişkili veri kesinlikle gerekli - Birden fazla kayıt işlenirken - API response'larında - Export/raporlama işlemlerinde

**Lazy Loading Kullan:** - Tek kayıt görünümlerinde (show, detail) - İlişkili veri nadiren gerekli - Bellek kısıtlı ortamlarda - Çok büyük ilişkili veri setlerinde - Koşullu veri yükleme senaryolarında

Dynamic Strategy Selection ¶

Runtime'da strateji değiştirilebilir:

func getLoadingStrategy(context Context) LoadingStrategy {
    if context.IsBulkOperation() {
        return EAGER_LOADING
    }
    if context.IsSingleRecord() {
        return LAZY_LOADING
    }
    return EAGER_LOADING // Varsayılan
}

Monitoring ve Logging ¶

strategy := field.GetLoadingStrategy()
log.Info("Loading relationship",
    "field", field.Name,
    "strategy", strategy,
    "record_count", len(items))

if strategy == LAZY_LOADING {
    log.Warn("Lazy loading may cause N+1 queries",
        "field", field.Name)
}

Testing ¶

// Test eager loading
field := fields.HasOne("Profile", "profile", "profiles").
    WithEagerLoad()
assert.Equal(t, EAGER_LOADING, field.GetLoadingStrategy())

// Test lazy loading
field = fields.HasOne("Profile", "profile", "profiles").
    WithLazyLoad()
assert.Equal(t, LAZY_LOADING, field.GetLoadingStrategy())

// Test default
field = fields.HasOne("Profile", "profile", "profiles")
assert.Equal(t, EAGER_LOADING, field.GetLoadingStrategy())

Önemli Notlar ¶

- Varsayılan strateji EAGER_LOADING'dir (güvenli seçim) - Boş string kontrolü yapılır ve varsayılan döndürülür - Strateji WithEagerLoad() veya WithLazyLoad() ile ayarlanır - Liste görünümlerinde mutlaka eager loading kullanın - N+1 problemini önlemek için varsayılan eager'dır

Best Practices ¶

**Liste Görünümlerinde:**

field := fields.HasOne("Profile", "profile", "profiles").
    WithEagerLoad() // Açıkça belirt

**Tek Kayıt Görünümlerinde:**

field := fields.HasOne("Profile", "profile", "profiles").
    WithLazyLoad() // Gerektiğinde yükle

**Varsayılana Güvenme:**

// Kötü: Strateji belirsiz
field := fields.HasOne("Profile", "profile", "profiles")

// İyi: Strateji açıkça belirtilmiş
field := fields.HasOne("Profile", "profile", "profiles").
    WithEagerLoad()

Performans İpuçları ¶

- Production'da eager loading tercih edin - Lazy loading sadece gerektiğinde kullanın - Sorgu sayısını monitor edin - N+1 problemini tespit edin ve düzeltin - Cache mekanizması ile optimize edin

Uyarılar ¶

- Lazy loading N+1 sorgu problemine yol açar - Liste görünümlerinde lazy loading kullanmayın - Varsayılan eager olsa da açıkça belirtmek daha iyidir - Strateji değişikliği tüm sorguları etkiler

Döndürür:

• LoadingStrategy: EAGER_LOADING veya LAZY_LOADING (varsayılan: EAGER_LOADING)

func (*HasOneField) GetOwnerKeyColumn ¶

func (h *HasOneField) GetOwnerKeyColumn() string

GetOwnerKeyColumn, owner key sütun adını döndürür.

Bu metod, HasOne ilişkisinde kullanılan owner key sütununun adını döndürür. Owner key, ana tablodaki referans sütunudur (genellikle primary key).

Dönüş Değeri ¶

- Owner key sütun adı (örn. "id", "uuid")

Kullanım Örneği ¶

field := fields.HasOne("Profile", "profile", "profiles").OwnerKey("id")
ownerKey := field.GetOwnerKeyColumn() // "id"

Döndürür:

• Owner key sütun adı

func (*HasOneField) GetQueryCallback ¶

func (h *HasOneField) GetQueryCallback() func(interface{}) interface{}

GetQueryCallback, query callback fonksiyonunu döndürür.

Bu method, ilişki sorgusunu özelleştirmek için tanımlanmış callback fonksiyonunu döndürür. Eğer callback tanımlanmamışsa, varsayılan olarak sorguyu değiştirmeyen bir fonksiyon döndürür.

Dönüş Değeri ¶

- Query callback fonksiyonu: func(interface{}) interface{} - Callback yoksa: Sorguyu olduğu gibi döndüren varsayılan fonksiyon

Çalışma Mantığı ¶

1. QueryCallback field'ını kontrol eder 2. Eğer nil ise, varsayılan pass-through fonksiyon döndürür 3. Eğer tanımlıysa, kullanıcı tarafından ayarlanan callback'i döndürür

Kullanım Senaryoları ¶

- **Query Execution**: İlişki yüklenirken callback'i uygulama - **Dynamic Filtering**: Runtime'da sorgu özelleştirme - **Middleware**: Sorgu pipeline'ına ekleme - **Logging**: Sorgu loglaması için callback kullanma - **Testing**: Mock callback'ler ile test etme

Kullanım Örneği ¶

// Callback tanımlı field
field := fields.HasOne("Profile", "profile", "profiles").
    Query(func(q interface{}) interface{} {
        return q.(*gorm.DB).Where("status = ?", "active")
    })

// Callback'i al ve kullan
callback := field.GetQueryCallback()
query := db.Model(&Profile{})
query = callback(query).(*gorm.DB)
query.Find(&profiles)

Varsayılan Callback ¶

Callback tanımlanmamışsa, varsayılan fonksiyon döndürülür:

func(q interface{}) interface{} {
    return q  // Sorguyu olduğu gibi döndür
}

Bu, callback kontrolü yapmadan güvenle kullanılabilir:

// Her zaman çalışır (nil check gerekmez)
callback := field.GetQueryCallback()
query = callback(query)

Callback Tanımlama ¶

Query method'u ile callback tanımlanır:

field.Query(func(q interface{}) interface{} {
    db := q.(*gorm.DB)
    return db.Where("verified = ?", true).
        Order("created_at DESC")
})

Callback Uygulama ¶

**Eager Loading'de:**

func loadRelationship(field *HasOneField, ownerID uint) interface{} {
    query := db.Model(&Profile{}).
        Where("user_id = ?", ownerID)

    // Callback uygula
    callback := field.GetQueryCallback()
    query = callback(query).(*gorm.DB)

    var profile Profile
    query.First(&profile)
    return profile
}

**Lazy Loading'de:**

func (h *HasOneField) ResolveRelationship(item interface{}) (interface{}, error) {
    ownerValue := extractFieldValue(item, h.OwnerKeyColumn)

    query := db.Model(relatedModel).
        Where(fmt.Sprintf("%s = ?", h.ForeignKeyColumn), ownerValue)

    // Callback uygula
    callback := h.GetQueryCallback()
    query = callback(query).(*gorm.DB)

    var result interface{}
    err := query.First(&result).Error
    return result, err
}

Callback Chaining ¶

Birden fazla callback zincirleme yapılabilir:

baseCallback := field.GetQueryCallback()
enhancedCallback := func(q interface{}) interface{} {
    // Önce base callback uygula
    q = baseCallback(q)
    // Sonra ek işlemler
    return q.(*gorm.DB).Limit(10)
}

Type Safety ¶

Callback içinde type assertion kullanılır:

callback := func(q interface{}) interface{} {
    db, ok := q.(*gorm.DB)
    if !ok {
        return q  // Type assertion başarısız, olduğu gibi döndür
    }
    return db.Where("active = ?", true)
}

Testing ¶

Test'lerde mock callback kullanılabilir:

// Test setup
mockCallback := func(q interface{}) interface{} {
    // Mock davranış
    return q
}

field := fields.HasOne("Profile", "profile", "profiles").
    Query(mockCallback)

// Test
callback := field.GetQueryCallback()
assert.NotNil(t, callback)

Önemli Notlar ¶

- Method her zaman nil olmayan bir fonksiyon döndürür - Varsayılan callback sorguyu değiştirmez (pass-through) - Callback nil kontrolü yapmanıza gerek yoktur - Type assertion başarısız olursa panic riski vardır - Callback içinde error handling yapılmalıdır

Best Practices ¶

**Güvenli Type Assertion:**

callback := func(q interface{}) interface{} {
    db, ok := q.(*gorm.DB)
    if !ok {
        log.Warn("Type assertion failed")
        return q
    }
    return db.Where("active = ?", true)
}

**Error Handling:**

callback := func(q interface{}) interface{} {
    defer func() {
        if r := recover(); r != nil {
            log.Error("Callback panic:", r)
        }
    }()
    return q.(*gorm.DB).Where("active = ?", true)
}

**Logging:**

callback := func(q interface{}) interface{} {
    log.Debug("Applying query callback")
    db := q.(*gorm.DB)
    return db.Where("active = ?", true)
}

Performans ¶

- O(1) kompleksitesi (field access veya varsayılan fonksiyon dönüşü) - Minimal bellek allocation - Callback execution overhead callback içeriğine bağlıdır

Uyarılar ¶

- Callback içinde panic oluşursa uygulama çökebilir - Type assertion başarısız olursa runtime error oluşur - Callback'te yapılan değişiklikler tüm sorguları etkiler - Thread-safety callback implementasyonuna bağlıdır

Döndürür:

• Query callback fonksiyonu (her zaman nil olmayan)

func (*HasOneField) GetRelatedResourceSlug ¶

func (h *HasOneField) GetRelatedResourceSlug() string

GetRelatedResource, ilişkili resource'un slug'ını döndürür.

Bu method, HasOne ilişkisinde ilişkili resource'un slug değerini döndürür. Slug, resource'u sistem içinde tanımlayan benzersiz string identifier'dır.

Dönüş Değeri ¶

- İlişkili resource'un slug'ı (örn. "profiles", "invoices", "capitals")

Kullanım Senaryoları ¶

- **Resource Lookup**: İlişkili resource'u slug ile bulma - **API Routing**: İlişkili resource'un endpoint'ini oluşturma - **Dynamic Loading**: Runtime'da ilişkili resource'u yükleme - **Validation**: İlişki tanımının doğruluğunu kontrol etme - **Metadata**: İlişki bilgilerini metadata olarak saklama

Kullanım Örneği ¶

field := fields.HasOne("Profile", "profile", "profiles")
slug := field.GetRelatedResource()
fmt.Println(slug) // Output: "profiles"

// Resource lookup
relatedResource := resourceRegistry.Get(field.GetRelatedResource())

// API endpoint oluşturma
endpoint := fmt.Sprintf("/api/%s", field.GetRelatedResource())
// Output: "/api/profiles"

// Dynamic query
tableName := field.GetRelatedResource()
db.Table(tableName).Where("user_id = ?", userID).First(&profile)

Slug Formatı ¶

Slug genellikle aşağıdaki formatlarda olur: - **Plural Form**: "profiles", "invoices", "users" - **Kebab Case**: "user-profiles", "order-items" - **Snake Case**: "user_profiles", "order_items"

Resource Instance vs String Slug ¶

HasOne oluşturulurken iki yöntem kullanılabilir:

**String Slug:**

field := fields.HasOne("Profile", "profile", "profiles")
field.GetRelatedResource() // "profiles"

**Resource Instance:**

field := fields.HasOne("Profile", "profile", user.NewProfileResource())
field.GetRelatedResource() // "profiles" (resource'un Slug() method'undan)

JSON Serialization ¶

API response'da kullanımı:

{
    "name": "Profile",
    "key": "profile",
    "type": "relationship",
    "relationship_type": "hasOne",
    "related_resource": "profiles"  // Bu method'un dönüş değeri
}

Interface Implementation ¶

Bu method, Relationship interface'ini implement eder:

type Relationship interface {
    GetRelationshipType() string
    GetRelatedResource() string  // Bu method
    GetRelationshipName() string
}

Resource Registry Entegrasyonu ¶

// Resource registry'den ilişkili resource'u al
type ResourceRegistry struct {
    resources map[string]Resource
}

func (r *ResourceRegistry) Get(slug string) Resource {
    return r.resources[slug]
}

// Kullanım
relatedResource := registry.Get(field.GetRelatedResource())

Önemli Notlar ¶

- Slug değeri HasOne oluşturulurken ayarlanır - Değer değiştirilemez (immutable) - Boş string olabilir (fallback durumunda) - Case-sensitive: "profiles" ≠ "Profiles"

Hata Durumları ¶

Eğer HasOne oluşturulurken geçersiz bir değer verilirse: - String değilse ve Slug() method'u yoksa: boş string döner - Nil değer: boş string döner

Performans ¶

- O(1) kompleksitesi (field access) - Bellek allocation yok - Çok hızlı çalışır

Döndürür:

• İlişkili resource'un slug'ı (string)

func (*HasOneField) GetRelatedTableName ¶

func (h *HasOneField) GetRelatedTableName() string

GetRelatedTableName, ilişkili tablo adını döndürür.

Bu metod, HasOne ilişkisinde kullanılan ilişkili tablonun adını döndürür. Raw SQL sorguları için kullanılır.

Dönüş Değeri ¶

- İlişkili tablo adı (örn. "profiles", "invoices", "capitals")

Kullanım Örneği ¶

field := fields.HasOne("Profile", "profile", "profiles")
tableName := field.GetRelatedTableName() // "profiles"

Döndürür:

• İlişkili tablo adı

func (*HasOneField) GetRelationshipName ¶

func (h *HasOneField) GetRelationshipName() string

GetRelationshipName, ilişkinin adını döndürür.

Bu method, HasOne ilişkisinin görünen adını (display name) döndürür. Bu ad, kullanıcı arayüzünde gösterilir ve ilişkiyi tanımlar.

Dönüş Değeri ¶

- İlişkinin görünen adı (örn. "Profile", "Invoice", "Capital")

Kullanım Senaryoları ¶

- **UI Rendering**: Form etiketlerinde ve tablo başlıklarında gösterme - **Validation Messages**: Hata mesajlarında ilişki adını kullanma - **Logging**: Log mesajlarında ilişkiyi tanımlama - **API Documentation**: API dokümantasyonunda ilişki açıklaması - **Debugging**: Debug çıktılarında ilişkiyi belirleme

Kullanım Örneği ¶

field := fields.HasOne("Profile", "profile", "profiles")
name := field.GetRelationshipName()
fmt.Println(name) // Output: "Profile"

// UI rendering
label := fmt.Sprintf("%s:", field.GetRelationshipName())
// Output: "Profile:"

// Validation message
errMsg := fmt.Sprintf("%s is required", field.GetRelationshipName())
// Output: "Profile is required"

// Form field
<label>{field.GetRelationshipName()}</label>
<select name="profile_id">...</select>

Name vs Key vs Slug ¶

HasOne ilişkisinde üç farklı identifier vardır:

**Name (GetRelationshipName):** - Görünen ad, kullanıcı dostu - Örnek: "Profile", "User Profile", "Kullanıcı Profili" - Kullanım: UI, mesajlar, dokümantasyon

**Key:** - Programatik identifier, struct field adı - Örnek: "profile", "userProfile", "user_profile" - Kullanım: Kod içinde, JSON keys, form names

**Slug (GetRelatedResource):** - Resource identifier, tablo/endpoint adı - Örnek: "profiles", "user-profiles", "user_profiles" - Kullanım: Routing, database, API endpoints

Çoklu Dil Desteği (i18n) ¶

Name değeri, çoklu dil desteği için kullanılabilir:

// İngilizce
field := fields.HasOne("Profile", "profile", "profiles")

// Türkçe
field := fields.HasOne("Profil", "profile", "profiles")

// Runtime çeviri
name := i18n.Translate(field.GetRelationshipName())

JSON Serialization ¶

API response'da kullanımı:

{
    "name": "Profile",  // Bu method'un dönüş değeri
    "key": "profile",
    "type": "relationship",
    "relationship_type": "hasOne",
    "related_resource": "profiles"
}

Interface Implementation ¶

Bu method, Relationship interface'ini implement eder:

type Relationship interface {
    GetRelationshipType() string
    GetRelatedResource() string
    GetRelationshipName() string  // Bu method
}

UI Kullanım Örnekleri ¶

**Form Label:**

<div class="form-group">
    <label>{field.GetRelationshipName()}</label>
    <select name="profile_id">
        <option value="">Select {field.GetRelationshipName()}</option>
    </select>
</div>

**Table Header:**

<th>{field.GetRelationshipName()}</th>

**Validation Error:**

errors := map[string]string{
    "profile": fmt.Sprintf("%s is required", field.GetRelationshipName()),
}

Önemli Notlar ¶

- Name değeri HasOne oluşturulurken ayarlanır - Değer değiştirilemez (immutable) - Boş string olabilir (ancak önerilmez) - Kullanıcı dostu olmalıdır (başlık formatında)

Best Practices ¶

**İyi Örnekler:** - "Profile" (kısa, açık) - "User Profile" (açıklayıcı) - "Invoice Details" (detaylı) - "Kullanıcı Profili" (yerelleştirilmiş)

**Kötü Örnekler:** - "profile" (küçük harf, programatik) - "PROFILE" (tamamı büyük harf) - "prof" (kısaltma, belirsiz) - "user_profile" (snake_case, programatik)

Performans ¶

- O(1) kompleksitesi (field access) - Bellek allocation yok - Çok hızlı çalışır

Döndürür:

• İlişkinin görünen adı (string)

func (*HasOneField) GetRelationshipType ¶

func (h *HasOneField) GetRelationshipType() string

GetRelationshipType, ilişki tipini döndürür.

Bu method, HasOne ilişkisinin tipini string olarak döndürür. İlişki tipi, sistem içinde ilişki türünü tanımlamak ve işlemek için kullanılır.

Dönüş Değeri ¶

- "hasOne": HasOne ilişki tipini belirten sabit string

Kullanım Senaryoları ¶

- **Tip Kontrolü**: İlişki tipini runtime'da kontrol etme - **Routing**: İlişki tipine göre farklı işlemler yapma - **Serialization**: JSON/XML çıktısında ilişki tipini belirtme - **Validation**: İlişki tipine özel validasyon kuralları uygulama - **Logging**: Log mesajlarında ilişki tipini gösterme

Kullanım Örneği ¶

field := fields.HasOne("Profile", "profile", "profiles")
relType := field.GetRelationshipType()
fmt.Println(relType) // Output: "hasOne"

// Tip kontrolü
if field.GetRelationshipType() == "hasOne" {
    // HasOne'a özel işlemler
}

// Switch case ile routing
switch field.GetRelationshipType() {
case "hasOne":
    // HasOne işlemleri
case "hasMany":
    // HasMany işlemleri
case "belongsTo":
    // BelongsTo işlemleri
}

İlişki Tipleri ¶

Sistemdeki diğer ilişki tipleri: - "hasOne": Bir-bir ilişki (bu method) - "hasMany": Bir-çok ilişki - "belongsTo": Ters bir-bir veya ters bir-çok ilişki - "belongsToMany": Çok-çok ilişki - "morphTo": Polimorfik ilişki - "morphOne": Polimorfik bir-bir ilişki - "morphMany": Polimorfik bir-çok ilişki

JSON Serialization ¶

API response'da kullanımı:

{
    "name": "Profile",
    "key": "profile",
    "type": "relationship",
    "relationship_type": "hasOne",
    "related_resource": "profiles"
}

Interface Implementation ¶

Bu method, Relationship interface'ini implement eder:

type Relationship interface {
    GetRelationshipType() string
    GetRelatedResource() string
    GetRelationshipName() string
}

Önemli Notlar ¶

- Dönüş değeri her zaman "hasOne" string'idir - Değer değiştirilemez (immutable) - Case-sensitive: "hasOne" (camelCase) - Boş string döndürmez

Performans ¶

- O(1) kompleksitesi (sabit string dönüşü) - Bellek allocation yok - Çok hızlı çalışır

Döndürür:

• "hasOne" string sabiti

func (*HasOneField) GetSearchableColumns ¶

func (h *HasOneField) GetSearchableColumns() []string

GetSearchableColumns, aranabilir sütunları döndürür (HasOne için kullanılmaz).

Bu method, HasOne ilişkisinde kullanılmaz ve boş slice döndürür. Searchable columns, genellikle HasMany ve BelongsToMany gibi çoklu kayıt ilişkilerinde hangi sütunlarda arama yapılacağını belirtmek için kullanılır.

Dönüş Değeri ¶

- Boş string slice ([]string{}) - HasOne için searchable columns kavramı geçerli değildir

Neden Kullanılmaz? ¶

HasOne ilişkisi tek bir kayıt döndürdüğü için, searchable columns'a ihtiyaç yoktur. Searchable columns, çoklu kayıtların listesinde arama yapmak için kullanılır.

Searchable Columns Kullanılan İlişkiler ¶

**HasMany:** - Birden fazla kayıt döndürür - Kayıtlar arasında arama yapılabilir - Örnek: User -> Posts (title, body sütunlarında ara)

**BelongsToMany:** - Çok-çok ilişkide birden fazla kayıt - İlişkili kayıtlarda arama yapılabilir - Örnek: User -> Roles (name, description sütunlarında ara)

**MorphMany:** - Polimorfik bir-çok ilişki - Searchable columns ile kayıtlar filtrelenir - Örnek: Post -> Comments (body, author sütunlarında ara)

HasOne vs HasMany Karşılaştırması ¶

**HasOne (Bu Method):**

field := fields.HasOne("Profile", "profile", "profiles")
columns := field.GetSearchableColumns() // [] (boş)
// Tek kayıt döndürür, arama gerekmez

**HasMany:**

field := fields.HasMany("Posts", "posts", "posts").
    SearchableColumns("title", "body", "excerpt")
columns := field.GetSearchableColumns() // ["title", "body", "excerpt"]
// Birden fazla kayıt, arama yapılabilir

Interface Implementation ¶

Bu method, Relationship interface'ini implement eder:

type Relationship interface {
    GetDisplayKey() string
    GetSearchableColumns() []string  // Bu method
    // ... diğer method'lar
}

Kullanım Örneği ¶

field := fields.HasOne("Profile", "profile", "profiles")
columns := field.GetSearchableColumns()
fmt.Println(len(columns)) // Output: 0 (boş slice)

// Tip kontrolü
if len(columns) == 0 {
    fmt.Println("Searchable columns not used for HasOne")
}

JSON Serialization ¶

API response'da bu alan genellikle dahil edilmez:

{
    "name": "Profile",
    "key": "profile",
    "type": "relationship",
    "relationship_type": "hasOne",
    "related_resource": "profiles"
    // searchable_columns yok (boş olduğu için)
}

Alternatif Yaklaşımlar ¶

HasOne için arama yerine, ilişkili kaydın tamamı döndürülür ve frontend'de filtreleme yapılabilir:

// API Response
{
    "id": 1,
    "name": "John",
    "profile": {
        "id": 42,
        "full_name": "John Doe",
        "bio": "Software Developer"
    }
}

// Frontend'de filtreleme
if (user.profile.full_name.includes(searchTerm)) {
    // Göster
}

Global Search ¶

HasOne ilişkisi global search'e dahil edilebilir:

field := fields.HasOne("Profile", "profile", "profiles").
    Searchable() // Global search'e dahil et

// Ancak bu, ilişkili kaydın kendisini değil,
// ilişkinin varlığını aranabilir yapar

Önemli Notlar ¶

- Her zaman boş slice döndürür - HasOne için searchable columns kavramı geçerli değildir - Çoklu kayıt ilişkilerinde (HasMany, BelongsToMany) kullanılır - Interface uyumluluğu için implement edilmiştir - Nil değil, boş slice döndürür ([]string{})

Best Practices ¶

HasOne ilişkisinde searchable columns kullanmayın:

// Yanlış (etkisiz)
field := fields.HasOne("Profile", "profile", "profiles").
    SearchableColumns("full_name", "bio") // HasOne'da bu method yok

// Doğru
field := fields.HasOne("Profile", "profile", "profiles")
// Searchable columns gerekmez, tek kayıt döndürülür

Performans ¶

- O(1) kompleksitesi (sabit slice dönüşü) - Minimal bellek allocation (boş slice) - Çok hızlı çalışır

Döndürür:

• Boş string slice ([]string{}) - HasOne için kullanılmaz

func (*HasOneField) GetTypes ¶

func (h *HasOneField) GetTypes() map[string]string

GetTypes, tip eşlemelerini döndürür (HasOne için kullanılmaz).

Bu method, HasOne ilişkisinde kullanılmaz ve boş map döndürür. Type mappings, genellikle form field'larında input tiplerini ve validasyon kurallarını tanımlamak için kullanılır.

Dönüş Değeri ¶

- Boş map (map[string]string{}) - HasOne için type mappings kavramı geçerli değildir

Neden Kullanılmaz? ¶

HasOne ilişkisi bir relationship field'dır ve primitive tip mapping'e ihtiyaç duymaz. Type mappings, genellikle Text, Number, Email gibi primitive field'larda input tipini ve validasyon kurallarını belirtmek için kullanılır.

Type Mappings Kullanılan Field'lar ¶

**Text Field:**

field := fields.Text("Name", "name")
types := field.GetTypes()
// {"input": "text", "validation": "string"}

**Number Field:**

field := fields.Number("Age", "age")
types := field.GetTypes()
// {"input": "number", "validation": "integer"}

**Email Field:**

field := fields.Email("Email", "email")
types := field.GetTypes()
// {"input": "email", "validation": "email"}

**Date Field:**

field := fields.Date("Birth Date", "birth_date")
types := field.GetTypes()
// {"input": "date", "validation": "date"}

HasOne vs Primitive Fields Karşılaştırması ¶

**HasOne (Bu Method):**

field := fields.HasOne("Profile", "profile", "profiles")
types := field.GetTypes() // {} (boş map)
// İlişki field'ı, tip mapping gerekmez

**Text Field:**

field := fields.Text("Name", "name")
types := field.GetTypes() // {"input": "text", "validation": "string"}
// Primitive field, tip mapping gerekir

Interface Implementation ¶

Bu method, Field interface'ini implement eder:

type Field interface {
    GetTypes() map[string]string
    // ... diğer method'lar
}

Kullanım Örneği ¶

field := fields.HasOne("Profile", "profile", "profiles")
types := field.GetTypes()
fmt.Println(len(types)) // Output: 0 (boş map)

// Tip kontrolü
if len(types) == 0 {
    fmt.Println("Type mappings not used for HasOne")
}

JSON Serialization ¶

API response'da bu alan genellikle dahil edilmez:

{
    "name": "Profile",
    "key": "profile",
    "type": "relationship",
    "relationship_type": "hasOne",
    "related_resource": "profiles"
    // types yok (boş olduğu için)
}

Type Mappings Kullanım Alanları ¶

Type mappings, aşağıdaki alanlarda kullanılır:

**Frontend Rendering:** - HTML input type belirleme - Form validation kuralları - Input maskeleme (telefon, kredi kartı vb.)

**Backend Validation:** - Veri tipi kontrolü - Format validasyonu - Type casting

**Database Schema:** - Sütun tipi belirleme - Migration oluşturma - Index stratejisi

HasOne İçin Alternatif ¶

HasOne ilişkisinde tip bilgisi farklı şekilde saklanır:

// İlişki tipi
field.GetRelationshipType() // "hasOne"

// Field tipi
field.Type // TYPE_RELATIONSHIP

// View component
field.View // "has-one-field"

Frontend Component Selection ¶

Frontend'de component seçimi View field'ına göre yapılır:

// HasOne için
switch field.View {
case "has-one-field":
    return <HasOneSelect field={field} />
case "text-field":
    return <TextInput field={field} />
case "number-field":
    return <NumberInput field={field} />
}

Type Mappings Örneği (Diğer Field'lar) ¶

**Text Field:**

{
    "input": "text",
    "validation": "string",
    "html_type": "text",
    "db_type": "VARCHAR"
}

**Number Field:**

{
    "input": "number",
    "validation": "integer",
    "html_type": "number",
    "db_type": "INT"
}

**Email Field:**

{
    "input": "email",
    "validation": "email",
    "html_type": "email",
    "db_type": "VARCHAR"
}

Önemli Notlar ¶

- Her zaman boş map döndürür - HasOne için type mappings kavramı geçerli değildir - Primitive field'larda (Text, Number, Email) kullanılır - Interface uyumluluğu için implement edilmiştir - Nil değil, boş map döndürür (map[string]string{})

Best Practices ¶

HasOne ilişkisinde type mappings kullanmayın:

// Yanlış (etkisiz)
types := field.GetTypes()
if types["input"] == "text" {
    // HasOne için bu kontrol anlamsız
}

// Doğru
if field.GetRelationshipType() == "hasOne" {
    // HasOne'a özel işlemler
}

Field Type Kontrolü ¶

Field tipini kontrol etmek için doğru method'ları kullanın:

// HasOne için
if field.Type == TYPE_RELATIONSHIP {
    relType := field.GetRelationshipType() // "hasOne"
}

// Primitive field için
if field.Type == TYPE_TEXT {
    types := field.GetTypes() // {"input": "text", ...}
}

Migration ve Schema ¶

HasOne için database schema bilgisi farklı şekilde alınır:

// Foreign key bilgisi
foreignKey := field.ForeignKeyColumn // "user_id"
ownerKey := field.OwnerKeyColumn     // "id"

// Migration
ALTER TABLE profiles
ADD CONSTRAINT fk_profiles_user_id
FOREIGN KEY (user_id) REFERENCES users(id);

Performans ¶

- O(1) kompleksitesi (boş map dönüşü) - Minimal bellek allocation (boş map) - Çok hızlı çalışır

Interface Uyumluluğu ¶

Bu method, Field interface'ini implement etmek için gereklidir:

type Field interface {
    GetTypes() map[string]string  // Tüm field'lar implement etmeli
    GetName() string
    GetKey() string
    // ... diğer method'lar
}

HasOne bir Field olduğu için bu method'u implement etmelidir, ancak relationship field'lar için type mappings kullanılmaz.

Debugging ¶

Field tipini debug ederken:

fmt.Printf("Field: %s\n", field.Name)
fmt.Printf("Type: %s\n", field.Type)
fmt.Printf("View: %s\n", field.View)

if field.Type == TYPE_RELATIONSHIP {
    fmt.Printf("Relationship Type: %s\n", field.GetRelationshipType())
    fmt.Printf("Related Resource: %s\n", field.GetRelatedResource())
} else {
    fmt.Printf("Types: %+v\n", field.GetTypes())
}

Uyarılar ¶

- HasOne için GetTypes() kullanmayın (her zaman boş) - Tip bilgisi için GetRelationshipType() kullanın - Frontend component seçimi için View field'ını kullanın - Database schema için ForeignKeyColumn ve OwnerKeyColumn kullanın

Döndürür:

• Boş map (map[string]string{}) - HasOne için kullanılmaz

func (*HasOneField) HoverCard ¶

func (h *HasOneField) HoverCard(hoverStruct interface{}) *HasOneField

HoverCard, hover card struct'ını ayarlar ve hover card'ı etkinleştirir.

Bu metod, hover card için kullanılacak struct'ı belirler ve hover card özelliğini aktif eder.

Parametreler ¶

- **hoverStruct**: Hover card verisi için kullanılacak struct (örn. &ProfileHoverCard{})

Kullanım Örneği ¶

type ProfileHoverCard struct {
    Avatar string `json:"avatar"`
    Bio    string `json:"bio"`
    Location string `json:"location"`
}

field := fields.HasOne("Profile", "profile", "profiles").
    ForeignKey("user_id").
    HoverCard(&ProfileHoverCard{})

Döndürür:

• HasOneField pointer'ı (method chaining için)

func (*HasOneField) IsRequired ¶

func (h *HasOneField) IsRequired() bool

IsRequired, alanın zorunlu olup olmadığını döndürür.

Bu method, HasOne ilişkisinin zorunlu (required) olarak işaretlenip işaretlenmediğini kontrol eder. Zorunlu alan, form validasyonunda ve veri kaydında mutlaka doldurulması gereken alandır.

Dönüş Değeri ¶

- true: Alan zorunludur, mutlaka doldurulmalıdır - false: Alan opsiyoneldir, boş bırakılabilir

Kullanım Senaryoları ¶

- **Form Validation**: Form gönderilmeden önce zorunlu alan kontrolü - **API Validation**: Request payload validasyonu - **Database Constraints**: NOT NULL constraint kontrolü - **UI Rendering**: Zorunlu alanları görsel olarak işaretleme (*) - **Error Messages**: Zorunlu alan hata mesajları

Kullanım Örneği ¶

// Zorunlu HasOne field
field := fields.HasOne("Profile", "profile", "profiles").
    Required()

// Zorunluluk kontrolü
if field.IsRequired() {
    fmt.Println("Profile is required")
}

// Form validation
if field.IsRequired() && profileID == 0 {
    return errors.New("Profile is required")
}

Required Method ile Kullanım ¶

Alanı zorunlu yapmak için Required() method'u kullanılır:

field := fields.HasOne("Profile", "profile", "profiles").
    Required() // IsRequired field'ını true yapar

fmt.Println(field.IsRequired()) // Output: true

Validation Implementation ¶

func validateField(field *HasOneField, value interface{}) error {
    if field.IsRequired() {
        if value == nil {
            return fmt.Errorf("%s is required", field.Name)
        }

        // ID kontrolü
        if id, ok := value.(uint); ok && id == 0 {
            return fmt.Errorf("%s is required", field.Name)
        }
    }
    return nil
}

Frontend Integration ¶

Frontend'de zorunlu alanlar otomatik olarak işaretlenir:

// API Response
{
    "name": "Profile",
    "key": "profile",
    "type": "relationship",
    "required": true  // Bu method'un dönüş değeri
}

// Frontend Rendering
<label>
    Profile {field.required && <span className="text-red-500">*</span>}
</label>
<select name="profile_id" required={field.required}>
    <option value="">Select Profile</option>
</select>

Form Validation Örneği ¶

// Backend validation
func validateUserForm(data map[string]interface{}, fields []*HasOneField) error {
    for _, field := range fields {
        if field.IsRequired() {
            value, exists := data[field.Key]
            if !exists || value == nil {
                return fmt.Errorf("%s is required", field.Name)
            }
        }
    }
    return nil
}

// Kullanım
err := validateUserForm(formData, userFields)
if err != nil {
    return err
}

Database Constraints ¶

Zorunlu alan, veritabanında NOT NULL constraint ile eşleşir:

// Migration
if field.IsRequired() {
    // Foreign key NOT NULL olmalı
    ALTER TABLE profiles
    ADD CONSTRAINT fk_profiles_user_id
    FOREIGN KEY (user_id) REFERENCES users(id)
    NOT NULL;
}

Error Messages ¶

Zorunlu alan için hata mesajları:

if field.IsRequired() && value == nil {
    return map[string]string{
        field.Key: fmt.Sprintf("%s is required", field.Name),
    }
}

// Örnek çıktı
{
    "profile": "Profile is required"
}

UI Rendering ¶

**Form Label:**

<label htmlFor="profile_id">
    {field.Name}
    {field.IsRequired() && <span className="text-red-500">*</span>}
</label>

**Input Field:**

<select
    id="profile_id"
    name="profile_id"
    required={field.IsRequired()}
    className={field.IsRequired() ? "required" : ""}
>
    <option value="">Select {field.Name}</option>
</select>

**Validation Message:**

{errors.profile && (
    <span className="error">
        {field.Name} is required
    </span>
)}

API Validation ¶

// Request handler
func createUser(c *gin.Context) {
    var data map[string]interface{}
    c.BindJSON(&data)

    // Validate required fields
    for _, field := range userResource.Fields() {
        if hasOneField, ok := field.(*HasOneField); ok {
            if hasOneField.IsRequired() {
                value, exists := data[hasOneField.Key]
                if !exists || value == nil {
                    c.JSON(400, gin.H{
                        "error": fmt.Sprintf("%s is required", hasOneField.Name),
                    })
                    return
                }
            }
        }
    }

    // Create user
    // ...
}

Testing ¶

// Test required field
func TestHasOneRequired(t *testing.T) {
    field := fields.HasOne("Profile", "profile", "profiles").
        Required()

    assert.True(t, field.IsRequired())
}

// Test optional field
func TestHasOneOptional(t *testing.T) {
    field := fields.HasOne("Profile", "profile", "profiles")

    assert.False(t, field.IsRequired())
}

Önemli Notlar ¶

- Schema.IsRequired field'ından değer okunur - Varsayılan olarak false'dur (opsiyonel) - Required() method'u ile true yapılır - Frontend ve backend validasyonunda kullanılır - Database constraint'leri ile senkronize olmalıdır

Best Practices ¶

**Zorunlu İlişkiler:**

// İyi: Açıkça required olarak işaretle
field := fields.HasOne("Profile", "profile", "profiles").
    Required()

// Kötü: Varsayılana güvenme
field := fields.HasOne("Profile", "profile", "profiles")
// IsRequired() false döner

**Validation:**

// İyi: Hem frontend hem backend validation
// Frontend: HTML5 required attribute
// Backend: IsRequired() kontrolü

// Kötü: Sadece frontend validation
// Güvenlik riski, bypass edilebilir

**Error Messages:**

// İyi: Kullanıcı dostu mesaj
if field.IsRequired() && value == nil {
    return fmt.Errorf("%s is required", field.Name)
}

// Kötü: Teknik mesaj
if field.IsRequired() && value == nil {
    return errors.New("validation failed: nil value")
}

Database Migration ¶

// Required field için migration
if field.IsRequired() {
    sql := fmt.Sprintf(`
        ALTER TABLE %s
        MODIFY COLUMN %s INT NOT NULL
    `, tableName, field.ForeignKeyColumn)
    db.Exec(sql)
}

Conditional Required ¶

Bazı durumlarda koşullu zorunluluk gerekebilir:

// Örnek: Profil sadece verified kullanıcılar için zorunlu
func validateProfile(user User, profileID uint) error {
    field := fields.HasOne("Profile", "profile", "profiles")

    if user.Verified && field.IsRequired() {
        if profileID == 0 {
            return errors.New("Profile is required for verified users")
        }
    }
    return nil
}

Performans ¶

- O(1) kompleksitesi (field access) - Bellek allocation yok - Çok hızlı çalışır

Uyarılar ¶

- Required field'lar mutlaka doldurulmalıdır - Frontend validation bypass edilebilir, backend validation şarttır - Database constraint'leri ile senkronize olmalıdır - Migration'larda NOT NULL constraint eklenmelidir - Mevcut verilerde NULL değer varsa migration başarısız olur

Döndürür:

• true: Alan zorunludur
• false: Alan opsiyoneldir

func (*HasOneField) OwnerKey ¶

func (h *HasOneField) OwnerKey(key string) *HasOneField

OwnerKey, owner key sütun adını ayarlar.

Bu method, ana tablodaki (parent table) referans sütununun adını özelleştirmenizi sağlar. Varsayılan olarak, owner key "id" (primary key) olarak ayarlanır.

Parametreler ¶

- **key**: Owner key sütun adı (örn. "id", "uuid", "code")

Kullanım Senaryoları ¶

- **UUID Primary Key**: UUID kullanan tablolarda - **Composite Keys**: Birleşik anahtar kullanımında - **Custom Primary Keys**: Özel primary key isimlendirmelerinde - **Legacy Sistemler**: Standart dışı primary key yapılarında

Kullanım Örneği ¶

// UUID primary key
field := fields.HasOne("Profile", "profile", "profiles").
    ForeignKey("user_uuid").
    OwnerKey("uuid")

// Özel primary key
field := fields.HasOne("Invoice", "invoice", "invoices").
    ForeignKey("order_code").
    OwnerKey("order_code")

// Composite key senaryosu
field := fields.HasOne("Detail", "detail", "details").
    ForeignKey("parent_id").
    OwnerKey("custom_id")

GORM Entegrasyonu ¶

Bu ayar, GORM'un `references` tag'i ile senkronize edilir:

type User struct {
    UUID    string  `gorm:"primaryKey"`
    Profile Profile `gorm:"foreignKey:user_uuid;references:uuid"`
}

Önemli Notlar ¶

- Owner key sütunu ana tabloda mevcut olmalıdır - Genellikle primary key veya unique key olmalıdır - Foreign key ile aynı veri tipinde olmalıdır - Index'lenmiş olması performans için kritiktir

Uyarılar ¶

- Owner key değiştirilirse, foreign key ile uyumlu olduğundan emin olun - Non-unique owner key kullanımı veri tutarsızlığına yol açabilir - Migration'larda bu ilişkiyi doğru tanımladığınızdan emin olun

Döndürür:

• Yapılandırılmış HasOneField pointer'ı (method chaining için)

func (*HasOneField) Query ¶

func (h *HasOneField) Query(fn func(interface{}) interface{}) *HasOneField

Query, ilişki sorgusunu özelleştirmek için callback fonksiyonu ayarlar.

Bu method, ilişkili kayıtlar yüklenirken uygulanacak özel sorgu koşullarını tanımlamanızı sağlar. Filtreleme, sıralama, eager loading gibi işlemler için kullanılır.

Parametreler ¶

- **fn**: Sorgu callback fonksiyonu - GORM query nesnesini alır ve değiştirilmiş query döndürür

Kullanım Senaryoları ¶

- **Filtreleme**: Sadece aktif kayıtları yükleme - **Sıralama**: İlişkili kayıtları belirli bir sıraya göre getirme - **Eager Loading**: İlişkili kayıtların alt ilişkilerini de yükleme - **Soft Delete**: Silinmiş kayıtları dahil etme veya hariç tutma - **Performans**: Select ile sadece gerekli sütunları çekme

Kullanım Örnekleri ¶

// Sadece aktif profilleri yükle
field := fields.HasOne("Profile", "profile", "profiles").
    Query(func(q interface{}) interface{} {
        return q.(*gorm.DB).Where("status = ?", "active")
    })

// Profili ülke bilgisi ile birlikte yükle
field := fields.HasOne("Profile", "profile", "profiles").
    Query(func(q interface{}) interface{} {
        return q.(*gorm.DB).Preload("Country")
    })

// Sadece belirli sütunları çek (performans optimizasyonu)
field := fields.HasOne("Profile", "profile", "profiles").
    Query(func(q interface{}) interface{} {
        return q.(*gorm.DB).Select("id", "full_name", "avatar")
    })

// Sıralama ekle
field := fields.HasOne("Invoice", "invoice", "invoices").
    Query(func(q interface{}) interface{} {
        return q.(*gorm.DB).Order("created_at DESC")
    })

// Birden fazla koşul
field := fields.HasOne("Profile", "profile", "profiles").
    Query(func(q interface{}) interface{} {
        db := q.(*gorm.DB)
        return db.Where("verified = ?", true).
            Where("status = ?", "active").
            Order("updated_at DESC")
    })

GORM Entegrasyonu ¶

Callback fonksiyonu, GORM'un *gorm.DB tipini alır ve değiştirir:

func(q interface{}) interface{} {
    db := q.(*gorm.DB)
    // GORM query chain'i burada
    return db.Where(...).Order(...)
}

Önemli Notlar ¶

- Callback fonksiyonu her ilişki yüklemesinde çalışır - Type assertion kullanırken dikkatli olun (panic riski) - Performans için sadece gerekli sütunları Select ile çekin - N+1 sorgu problemini önlemek için Preload kullanın

Performans İpuçları ¶

- **Select**: Sadece gerekli sütunları çekin - **Index**: Where koşullarında kullanılan sütunları index'leyin - **Preload**: Alt ilişkileri tek sorguda yükleyin - **Omit**: Gereksiz büyük sütunları (BLOB, TEXT) hariç tutun

Uyarılar ¶

- Callback içinde panic oluşursa uygulama çökebilir - Type assertion başarısız olursa runtime error oluşur - Karmaşık sorgular performansı etkileyebilir - Callback'te yapılan değişiklikler tüm yüklemeleri etkiler

Döndürür:

• Yapılandırılmış HasOneField pointer'ı (method chaining için)

func (*HasOneField) ResolveHoverCard ¶

func (h *HasOneField) ResolveHoverCard(resolver HoverCardResolver) *HasOneField

ResolveHoverCard, hover card verilerini çözmek için callback fonksiyonunu ayarlar.

Bu metod, hover card açıldığında çağrılacak resolver fonksiyonunu belirler. Resolver, ilişkili kaydın hover card verilerini döndürür.

Parametreler ¶

- **resolver**: Hover card resolver callback fonksiyonu

Kullanım Örneği ¶

field := fields.HasOne("Profile", "profile", "profiles").
    ForeignKey("user_id").
    HoverCard(&ProfileHoverCard{}).
    ResolveHoverCard(func(ctx context.Context, record interface{}, relatedID interface{}, field fields.Field) (interface{}, error) {
        // İlişkili kaydı veritabanından al
        profile := &Profile{}
        if err := db.First(profile, relatedID).Error; err != nil {
            return nil, err
        }

        // Hover card verisini döndür
        return &ProfileHoverCard{
            Avatar: profile.Avatar,
            Bio: profile.Bio,
            Location: profile.Location,
        }, nil
    })

API Endpoint ¶

Frontend, hover card açıldığında şu endpoint'e istek atar:

GET /api/resource/{resource}/resolver/{field_name}?id={related_id}
POST /api/resource/{resource}/resolver/{field_name} (body: {id: related_id})

Döndürür:

• HasOneField pointer'ı (method chaining için)

func (*HasOneField) ResolveRelationship ¶

func (h *HasOneField) ResolveRelationship(item interface{}) (interface{}, error)

ResolveRelationship, ilişkiyi çözerek ilişkili kaydı yükler.

Bu method, HasOne ilişkisinde tek bir ilişkili kaydı veritabanından yükler. Gerçek implementasyonda, bu method veritabanı sorgusunu çalıştırır ve ilişkili resource'u döndürür.

Çalışma Mantığı ¶

1. Item parametresini kontrol eder (nil kontrolü) 2. Item'dan owner key değerini çıkarır (örn. user.ID) 3. İlişkili tabloda foreign key ile sorgu yapar 4. Tek bir ilişkili kaydı bulur ve döndürür 5. Hata durumunda error döndürür

Parametreler ¶

- **item**: Ana kayıt (owner record) - ilişkinin sahibi olan kayıt

Dönüş Değerleri ¶

- **interface{}**: İlişkili kayıt (tek bir record) veya nil - **error**: Hata durumunda error, başarılı ise nil

Kullanım Senaryoları ¶

- **Lazy Loading**: İlişkili kaydı isteğe bağlı yükleme - **Dynamic Resolution**: Runtime'da ilişki çözümleme - **API Endpoints**: İlişkili veriyi ayrı endpoint'te sunma - **Conditional Loading**: Belirli koşullarda ilişki yükleme - **Manual Preloading**: Özel preload stratejileri

Kullanım Örneği (Teorik) ¶

// Field tanımı
field := fields.HasOne("Profile", "profile", "profiles").
    ForeignKey("user_id").
    OwnerKey("id")

// Ana kayıt
user := User{ID: 1, Name: "John"}

// İlişkiyi çözümle
profile, err := field.ResolveRelationship(user)
if err != nil {
    log.Fatal(err)
}

// Sonuç
fmt.Printf("Profile: %+v\n", profile)
// Output: Profile: &Profile{ID: 42, UserID: 1, FullName: "John Doe"}

Gerçek Implementasyon (Örnek) ¶

func (h *HasOneField) ResolveRelationship(item interface{}) (interface{}, error) {
    if item == nil {
        return nil, nil
    }

    // Owner key değerini çıkar
    ownerValue := extractFieldValue(item, h.OwnerKeyColumn)
    if ownerValue == nil {
        return nil, nil
    }

    // İlişkili resource'u bul
    relatedResource := resourceRegistry.Get(h.RelatedResourceSlug)
    if relatedResource == nil {
        return nil, fmt.Errorf("related resource not found: %s", h.RelatedResourceSlug)
    }

    // Veritabanı sorgusu
    var result interface{}
    query := db.Model(relatedResource.Model()).
        Where(fmt.Sprintf("%s = ?", h.ForeignKeyColumn), ownerValue)

    // Query callback uygula
    if h.QueryCallback != nil {
        query = h.QueryCallback(query).(*gorm.DB)
    }

    // Tek kayıt bul
    err := query.First(&result).Error
    if err != nil {
        if errors.Is(err, gorm.ErrRecordNotFound) {
            return nil, nil // İlişkili kayıt yok
        }
        return nil, err
    }

    return result, nil
}

SQL Sorgusu ¶

Method, aşağıdaki gibi bir SQL sorgusu oluşturur:

SELECT * FROM profiles
WHERE user_id = 1
LIMIT 1

Hata Durumları ¶

**Nil Item:** - Input: nil - Output: (nil, nil)

**Kayıt Bulunamadı:** - Input: User{ID: 999} - Output: (nil, nil) // Error değil, sadece nil

**Veritabanı Hatası:** - Input: User{ID: 1} - Output: (nil, error) // Bağlantı hatası, syntax error vb.

**Birden Fazla Kayıt:** - Input: User{ID: 1} - Output: İlk kaydı döndürür (LIMIT 1)

Performans Optimizasyonu ¶

**Select Specific Columns:**

field.Query(func(q interface{}) interface{} {
    return q.(*gorm.DB).Select("id", "full_name", "avatar")
})

**Index Kullanımı:**

CREATE INDEX idx_profiles_user_id ON profiles(user_id);

**Cache Stratejisi:**

// Cache'den kontrol et
if cached := cache.Get(cacheKey); cached != nil {
    return cached, nil
}

// Veritabanından yükle
result, err := field.ResolveRelationship(item)
if err == nil && result != nil {
    cache.Set(cacheKey, result, 5*time.Minute)
}

Eager Loading vs Lazy Loading ¶

**Lazy Loading (Bu Method):** - Her kayıt için ayrı sorgu - N+1 problem riski - İsteğe bağlı yükleme

**Eager Loading (Preload):** - Tek sorguda tüm ilişkiler - Performanslı - Toplu yükleme

Önemli Notlar ¶

- Şu anki implementasyon placeholder'dır (nil, nil döndürür) - Gerçek implementasyon veritabanı erişimi gerektirir - Query callback uygulanmalıdır - Error handling kritiktir - Nil item güvenli şekilde işlenir

Best Practices ¶

- Eager loading tercih edin (liste görünümlerinde) - Lazy loading sadece gerektiğinde kullanın - Query callback ile filtreleme yapın - Index'leri doğru tanımlayın - Cache mekanizması kullanın - Error'ları loglamayı unutmayın

Uyarılar ¶

- N+1 sorgu problemine dikkat edin - Nil pointer dereference riskine karşı kontrol yapın - Veritabanı bağlantı havuzunu yönetin - Timeout ayarlarını yapılandırın - Transaction içinde çalışırken dikkatli olun

Döndürür:

• İlişkili kayıt (interface{}) veya nil
• Hata durumunda error, başarılı ise nil

func (*HasOneField) Searchable ¶

func (h *HasOneField) Searchable() Element

Searchable, alanı aranabilir olarak işaretler (Element interface'ini implement eder).

Bu method, HasOne ilişkisini global search (genel arama) özelliğine dahil eder. Global search, kullanıcıların tüm kayıtlar arasında arama yapmasını sağlar.

Çalışma Mantığı ¶

Method, GlobalSearch field'ını true olarak ayarlar ve Element interface'ini döndürür. Bu, field'ın global search sorgularına dahil edilmesini sağlar.

Dönüş Değeri ¶

- Element interface'i (method chaining için)

Kullanım Senaryoları ¶

- **Global Search**: Tüm kayıtlarda arama yapılabilir hale getirme - **Quick Search**: Hızlı arama özelliğine dahil etme - **Search Bar**: Arama çubuğunda ilişki araması - **Filter Integration**: Filtreleme sistemine entegrasyon - **Admin Panel**: Yönetim panelinde arama özelliği

Kullanım Örneği ¶

// Searchable HasOne field
field := fields.HasOne("Profile", "profile", "profiles").
    Searchable()

// Method chaining ile diğer özellikler
field := fields.HasOne("Profile", "profile", "profiles").
    Searchable().
    WithEagerLoad().
    ForeignKey("user_id")

Global Search Davranışı ¶

HasOne ilişkisi searchable olarak işaretlendiğinde:

**İlişki Varlığı Aranır:** - İlişkili kayıt var mı yok mu kontrol edilir - İlişkili kaydın ID'si aranabilir

**İlişkili Kayıt İçeriği Aranmaz:** - HasOne için ilişkili kaydın içeriği (örn. profile.full_name) aranmaz - Sadece ilişkinin varlığı aranabilir

HasOne vs HasMany Searchable Karşılaştırması ¶

**HasOne (Bu Method):**

field := fields.HasOne("Profile", "profile", "profiles").
    Searchable()
// İlişki varlığı aranır (profile var mı?)

**HasMany:**

field := fields.HasMany("Posts", "posts", "posts").
    Searchable().
    SearchableColumns("title", "body")
// İlişkili kayıtların içeriği aranır (post title, body)

Search Query Implementation (Örnek) ¶

func buildSearchQuery(fields []Field, searchTerm string) *gorm.DB {
    query := db.Model(&User{})

    for _, field := range fields {
        if !field.IsSearchable() {
            continue
        }

        if hasOneField, ok := field.(*HasOneField); ok {
            // HasOne için ilişki varlığı kontrolü
            query = query.Or(
                db.Joins(hasOneField.Key).
                    Where(fmt.Sprintf("%s.id IS NOT NULL", hasOneField.Key)),
            )
        }
    }

    return query
}

Frontend Integration ¶

Frontend'de searchable field'lar otomatik olarak arama formuna eklenir:

// API Response
{
    "fields": [
        {
            "name": "Profile",
            "key": "profile",
            "type": "relationship",
            "searchable": true  // Bu method ile ayarlanır
        }
    ]
}

// Frontend Search Form
<SearchBar>
    <input placeholder="Search users with profile..." />
</SearchBar>

Element Interface Implementation ¶

Bu method, Element interface'ini implement eder:

type Element interface {
    Searchable() Element
    IsSearchable() bool
    // ... diğer method'lar
}

IsSearchable Kontrolü ¶

Searchable olup olmadığını kontrol etmek için:

if field.GlobalSearch {
    // Field searchable
    includeInSearch(field)
}

Kullanım Örnekleri ¶

**Basit Kullanım:**

field := fields.HasOne("Profile", "profile", "profiles").
    Searchable()

**Diğer Özelliklerle Birlikte:**

field := fields.HasOne("Profile", "profile", "profiles").
    Searchable().
    WithEagerLoad().
    ForeignKey("user_id").
    Required()

**Koşullu Searchable:**

field := fields.HasOne("Profile", "profile", "profiles")
if config.EnableProfileSearch {
    field.Searchable()
}

Search Query Örnekleri ¶

**İlişki Varlığı Araması:**

// Profili olan kullanıcıları bul
db.Joins("Profile").
    Where("profiles.id IS NOT NULL").
    Find(&users)

**İlişki Yokluğu Araması:**

// Profili olmayan kullanıcıları bul
db.Joins("LEFT JOIN profiles ON profiles.user_id = users.id").
    Where("profiles.id IS NULL").
    Find(&users)

Performans Considerations ¶

**Index Kullanımı:**

CREATE INDEX idx_profiles_user_id ON profiles(user_id);

**Join Optimizasyonu:**

// Efficient join
db.Joins("Profile").Find(&users)

// Inefficient (N+1)
for _, user := range users {
    db.Model(&user).Association("Profile").Find(&user.Profile)
}

Önemli Notlar ¶

- GlobalSearch field'ı true olarak ayarlanır - Element interface'i döndürülür (method chaining için) - HasOne için sadece ilişki varlığı aranır, içerik aranmaz - Frontend'de otomatik olarak arama formuna eklenir - Search query'lerde JOIN kullanılır

Best Practices ¶

**Searchable Kullanımı:**

// İyi: İlişki varlığı önemli
field := fields.HasOne("Profile", "profile", "profiles").
    Searchable() // Profili olan/olmayan kullanıcıları bul

// Kötü: İlişki içeriği aranmak isteniyorsa
// HasOne searchable ile içerik aranamaz
// İlişkili resource'da ayrı field'lar tanımlayın

**Index Tanımlama:**

// Migration'da index ekle
CREATE INDEX idx_profiles_user_id ON profiles(user_id);

**Query Optimization:**

// Eager loading ile birlikte kullan
field := fields.HasOne("Profile", "profile", "profiles").
    Searchable().
    WithEagerLoad()

Alternatif Yaklaşımlar ¶

İlişkili kayıt içeriğinde arama yapmak için:

// Profile resource'da searchable field'lar tanımla
profileResource := resource.New("profiles").
    Fields(
        fields.Text("Full Name", "full_name").Searchable(),
        fields.Text("Bio", "bio").Searchable(),
    )

// User resource'da HasOne tanımla
userResource := resource.New("users").
    Fields(
        fields.HasOne("Profile", "profile", profileResource).
            WithEagerLoad(),
    )

Uyarılar ¶

- HasOne searchable ile sadece ilişki varlığı aranır - İlişkili kayıt içeriği aranmaz (full_name, bio vb.) - Search query'lerde JOIN kullanılır (performans etkisi) - Index'lerin doğru tanımlandığından emin olun - Büyük veri setlerinde performans test edin

Döndürür:

• Element interface'i (method chaining için)

func (*HasOneField) ValidateRelationship ¶

func (h *HasOneField) ValidateRelationship(value interface{}) error

ValidateRelationship, ilişkinin geçerliliğini doğrular.

Bu method, HasOne ilişkisinde en fazla bir ilişkili kaydın var olduğunu doğrular. Gerçek implementasyonda, veritabanı constraint'lerini ve iş kurallarını kontrol eder.

Çalışma Mantığı ¶

1. Value parametresini kontrol eder (nil, tip, format) 2. İlişkili kayıt sayısını kontrol eder (en fazla 1 olmalı) 3. Foreign key constraint'lerini doğrular 4. İş kurallarını uygular (required, unique, vb.) 5. Hata durumunda error döndürür

Parametreler ¶

- **value**: Doğrulanacak değer (genellikle ilişkili kaydın ID'si)

Dönüş Değeri ¶

- **error**: Validasyon hatası varsa error, geçerli ise nil

Kullanım Senaryoları ¶

- **Form Validation**: Kullanıcı input'unu doğrulama - **API Validation**: Request payload'unu kontrol etme - **Data Integrity**: Veri tutarlılığını sağlama - **Business Rules**: İş kurallarını uygulama - **Constraint Checking**: Veritabanı constraint'lerini kontrol etme

Kullanım Örneği (Teorik) ¶

field := fields.HasOne("Profile", "profile", "profiles").
    ForeignKey("user_id").
    Required()

// Validasyon
err := field.ValidateRelationship(profileID)
if err != nil {
    return fmt.Errorf("validation failed: %w", err)
}

Gerçek Implementasyon (Örnek) ¶

func (h *HasOneField) ValidateRelationship(value interface{}) error {
    // Nil kontrolü
    if value == nil {
        if h.IsRequired() {
            return fmt.Errorf("%s is required", h.Name)
        }
        return nil
    }

    // Tip kontrolü
    id, ok := value.(uint)
    if !ok {
        return fmt.Errorf("%s must be a valid ID", h.Name)
    }

    // ID geçerliliği
    if id == 0 {
        return fmt.Errorf("%s ID cannot be zero", h.Name)
    }

    // İlişkili kayıt var mı?
    var count int64
    err := db.Model(relatedModel).
        Where("id = ?", id).
        Count(&count).Error
    if err != nil {
        return fmt.Errorf("failed to validate %s: %w", h.Name, err)
    }

    if count == 0 {
        return fmt.Errorf("%s with ID %d does not exist", h.Name, id)
    }

    // Birden fazla kayıt kontrolü (HasOne için)
    if count > 1 {
        return fmt.Errorf("%s has multiple records (expected one)", h.Name)
    }

    // Foreign key constraint kontrolü
    if h.ForeignKeyColumn != "" {
        // Foreign key'in başka bir kayıt tarafından kullanılıp kullanılmadığını kontrol et
        var existingCount int64
        err := db.Model(relatedModel).
            Where(fmt.Sprintf("%s = ?", h.ForeignKeyColumn), ownerID).
            Where("id != ?", id).
            Count(&existingCount).Error
        if err != nil {
            return err
        }

        if existingCount > 0 {
            return fmt.Errorf("%s already has a related record", h.Name)
        }
    }

    return nil
}

Validasyon Kuralları ¶

**Required Kontrolü:**

if value == nil && field.IsRequired() {
    return errors.New("field is required")
}

**Tip Kontrolü:**

if _, ok := value.(uint); !ok {
    return errors.New("invalid type")
}

**Existence Kontrolü:**

var count int64
db.Model(&Profile{}).Where("id = ?", value).Count(&count)
if count == 0 {
    return errors.New("record not found")
}

**Uniqueness Kontrolü:**

var count int64
db.Model(&Profile{}).Where("user_id = ?", userID).Count(&count)
if count > 1 {
    return errors.New("multiple records found")
}

Hata Mesajları ¶

**Required Error:** - "Profile is required" - "Profile cannot be empty"

**Type Error:** - "Profile must be a valid ID" - "Profile has invalid type"

**Not Found Error:** - "Profile with ID 42 does not exist" - "Profile not found"

**Duplicate Error:** - "Profile already exists for this user" - "User already has a profile"

Custom Validation ¶

Özel validasyon kuralları eklenebilir:

field := fields.HasOne("Profile", "profile", "profiles").
    Validate(func(value interface{}) error {
        id := value.(uint)
        // Özel validasyon mantığı
        if id < 100 {
            return errors.New("profile ID must be >= 100")
        }
        return nil
    })

Veritabanı Constraint'leri ¶

**Foreign Key Constraint:**

ALTER TABLE profiles
ADD CONSTRAINT fk_profiles_user_id
FOREIGN KEY (user_id) REFERENCES users(id)
ON DELETE CASCADE;

**Unique Constraint:**

ALTER TABLE profiles
ADD CONSTRAINT uk_profiles_user_id
UNIQUE (user_id);

Performans Optimizasyonu ¶

**Cache Kullanımı:**

// Validation sonuçlarını cache'le
cacheKey := fmt.Sprintf("validation:%s:%v", h.Key, value)
if cached := cache.Get(cacheKey); cached != nil {
    return cached.(error)
}

**Batch Validation:**

// Birden fazla değeri tek sorguda doğrula
ids := []uint{1, 2, 3}
var count int64
db.Model(&Profile{}).Where("id IN ?", ids).Count(&count)

Önemli Notlar ¶

- Şu anki implementasyon placeholder'dır (nil döndürür) - Gerçek implementasyon veritabanı erişimi gerektirir - Validasyon kuralları field konfigürasyonuna bağlıdır - Error mesajları kullanıcı dostu olmalıdır - Performans için cache kullanılabilir

Best Practices ¶

- Validasyon kurallarını açık ve anlaşılır yapın - Error mesajlarını kullanıcı dostu yazın - Veritabanı constraint'lerini kullanın - Validasyonu hem client hem server tarafında yapın - Batch validation ile performansı artırın

Uyarılar ¶

- Validasyon atlanmamalıdır (güvenlik riski) - Error mesajları hassas bilgi içermemelidir - Veritabanı hatalarını yakalayın ve loglamayı unutmayın - Race condition'lara dikkat edin (concurrent updates) - Transaction içinde validasyon yapın

Döndürür:

• Validasyon hatası varsa error, geçerli ise nil

func (*HasOneField) WithEagerLoad ¶

func (h *HasOneField) WithEagerLoad() *HasOneField

WithEagerLoad, yükleme stratejisini eager loading olarak ayarlar.

Eager loading, ilişkili kayıtların ana kayıtlarla birlikte tek sorguda yüklenmesini sağlar. Bu, N+1 sorgu problemini önler ve performansı önemli ölçüde artırır.

Eager Loading Nedir? ¶

Eager loading, ilişkili verilerin önceden (eager) yüklenmesi anlamına gelir. Ana kayıtlar sorgulanırken, ilişkili kayıtlar da aynı anda JOIN veya ayrı bir sorgu ile yüklenir ve cache'lenir.

Kullanım Senaryoları ¶

- **Liste Görünümleri**: Birden fazla kaydın ilişkileriyle birlikte gösterilmesi - **API Responses**: İlişkili verilerin tek response'da dönülmesi - **Raporlama**: Toplu veri çekimlerinde performans optimizasyonu - **Dashboard**: Özet bilgilerin hızlı yüklenmesi - **Export İşlemleri**: Büyük veri setlerinin verimli işlenmesi

Kullanım Örneği ¶

// Eager loading ile (önerilen)
field := fields.HasOne("Profile", "profile", "profiles").
    WithEagerLoad()

// Kullanıcıları profilleriyle birlikte yükle
// SQL: SELECT * FROM users; SELECT * FROM profiles WHERE user_id IN (1,2,3,...)
users := []User{}
db.Preload("Profile").Find(&users)

Performans Karşılaştırması ¶

**Lazy Loading (N+1 Problem):**

// 1 sorgu: Kullanıcıları getir
users := []User{} // 100 kullanıcı
db.Find(&users)

// 100 sorgu: Her kullanıcı için profil getir
for _, user := range users {
    db.Model(&user).Association("Profile").Find(&user.Profile)
}
// Toplam: 101 sorgu

**Eager Loading:**

// 2 sorgu: Kullanıcıları ve tüm profilleri getir
users := []User{}
db.Preload("Profile").Find(&users)
// Toplam: 2 sorgu (veya JOIN ile 1 sorgu)

GORM Entegrasyonu ¶

Eager loading, GORM'un Preload fonksiyonu ile çalışır:

db.Preload("Profile").Find(&users)
db.Preload("Profile.Country").Find(&users) // İç içe ilişkiler

Avantajlar ¶

- **Performans**: N+1 sorgu problemini önler - **Hız**: Tek seferde tüm veriler yüklenir - **Verimlilik**: Veritabanı bağlantı sayısını azaltır - **Öngörülebilirlik**: Sorgu sayısı sabittir - **Cache Dostu**: Tüm veriler bellekte hazır

Dezavantajlar ¶

- **Bellek Kullanımı**: Tüm ilişkili veriler belleğe yüklenir - **Gereksiz Veri**: Kullanılmayacak veriler de yüklenebilir - **İlk Yükleme**: İlk sorgu daha yavaş olabilir - **Karmaşık Sorgular**: Çok sayıda ilişki JOIN karmaşıklığı artırır

Ne Zaman Kullanılmalı? ¶

**Eager Loading Kullan:** - Liste görünümlerinde (index, table) - İlişkili veri kesinlikle gerekli olduğunda - Birden fazla kayıt işlenirken - API response'larında - Export/raporlama işlemlerinde

**Lazy Loading Kullan:** - Tek kayıt görünümlerinde (show, detail) - İlişkili veri nadiren gerekli olduğunda - Bellek kısıtlı ortamlarda - Çok büyük ilişkili veri setlerinde

Önemli Notlar ¶

- Varsayılan strateji EAGER_LOADING'dir (N+1 problemini önlemek için) - Çok sayıda ilişki için selective preloading kullanın - İç içe ilişkiler için nokta notasyonu kullanın: "Profile.Country" - Conditional preloading için Query callback kullanın

İleri Seviye Kullanım ¶

// Koşullu eager loading
field := fields.HasOne("Profile", "profile", "profiles").
    WithEagerLoad().
    Query(func(q interface{}) interface{} {
        return q.(*gorm.DB).Where("verified = ?", true)
    })

// İç içe ilişkiler
db.Preload("Profile.Country").
   Preload("Profile.Avatar").
   Find(&users)

Döndürür:

• Yapılandırılmış HasOneField pointer'ı (method chaining için)

func (*HasOneField) WithHoverCard ¶

func (h *HasOneField) WithHoverCard(config HoverCardConfig) *HasOneField

WithHoverCard, hover card konfigürasyonunu ayarlar.

Bu metod, index ve detail sayfalarında ilişkili kaydın hover card ile nasıl görüntüleneceğini belirler.

Parametreler ¶

- **config**: Hover card konfigürasyonu

Kullanım Örneği (Deprecated - Yeni API kullanın) ¶

field := fields.HasOne("Profile", "profile", "profiles").
    WithHoverCard(*fields.NewHoverCardConfig())

Yeni API (Önerilen) ¶

field := fields.HasOne("Profile", "profile", "profiles").
    HoverCard(&ProfileHoverCard{}).
    ResolveHoverCard(func(ctx context.Context, record interface{}, relatedID interface{}, field fields.Field) (interface{}, error) {
        // Custom logic
        return &ProfileHoverCard{...}, nil
    })

Döndürür:

• HasOneField pointer'ı (method chaining için)

func (*HasOneField) WithLazyLoad ¶

func (h *HasOneField) WithLazyLoad() *HasOneField

WithLazyLoad, yükleme stratejisini lazy loading olarak ayarlar.

Lazy loading, ilişkili kayıtların sadece gerektiğinde (on-demand) yüklenmesini sağlar. Bu, ilk sorgu performansını artırır ancak N+1 sorgu problemine yol açabilir.

Lazy Loading Nedir? ¶

Lazy loading, ilişkili verilerin geç (lazy) yüklenmesi anlamına gelir. Ana kayıtlar sorgulanırken ilişkili kayıtlar yüklenmez, sadece ilişkiye erişildiğinde ayrı bir sorgu ile yüklenir.

Kullanım Senaryoları ¶

- **Detay Görünümleri**: Tek kaydın detaylı gösteriminde - **Koşullu Yükleme**: İlişkili veri sadece belirli durumlarda gerekli - **Bellek Optimizasyonu**: Büyük ilişkili veri setlerinde - **API Pagination**: Sayfalanmış sonuçlarda gereksiz veri yüklemesini önleme - **Selective Loading**: Kullanıcı tercihine göre veri yükleme

Kullanım Örneği ¶

// Lazy loading ile
field := fields.HasOne("Profile", "profile", "profiles").
    WithLazyLoad()

// Kullanıcıyı yükle (profil yüklenmez)
user := User{}
db.First(&user, 1)

// Profil sadece erişildiğinde yüklenir
db.Model(&user).Association("Profile").Find(&user.Profile)

N+1 Sorgu Problemi ¶

Lazy loading'in en büyük dezavantajı N+1 sorgu problemidir:

// 1 sorgu: 100 kullanıcı getir
users := []User{}
db.Find(&users)

// 100 sorgu: Her kullanıcı için ayrı profil sorgusu
for _, user := range users {
    db.Model(&user).Association("Profile").Find(&user.Profile)
    // Her iterasyonda yeni bir sorgu!
}
// Toplam: 101 sorgu (çok yavaş!)

Performans Karşılaştırması ¶

**Lazy Loading:** - İlk yükleme: Hızlı (sadece ana kayıtlar) - İlişki erişimi: Yavaş (her erişimde yeni sorgu) - Toplam sorgu: N+1 (N = kayıt sayısı) - Bellek: Az (sadece gerekli veriler)

**Eager Loading:** - İlk yükleme: Yavaş (tüm veriler) - İlişki erişimi: Hızlı (zaten yüklü) - Toplam sorgu: 1-2 (sabit) - Bellek: Fazla (tüm veriler)

Avantajlar ¶

- **İlk Yükleme Hızı**: Ana kayıtlar hızlı yüklenir - **Bellek Verimliliği**: Sadece gerekli veriler yüklenir - **Esneklik**: İlişki isteğe bağlı yüklenir - **Basitlik**: Otomatik çalışır, ekstra kod gerekmez - **Koşullu Yükleme**: Sadece gerektiğinde yükleme

Dezavantajlar ¶

- **N+1 Problem**: Çok sayıda ek sorgu oluşur - **Performans**: Liste görünümlerinde çok yavaş - **Öngörülemezlik**: Sorgu sayısı değişkendir - **Veritabanı Yükü**: Çok sayıda bağlantı açılır - **Debugging**: Sorgu sayısını takip etmek zor

Ne Zaman Kullanılmalı? ¶

**Lazy Loading Kullan:** - Tek kayıt görünümlerinde (show, detail, edit) - İlişkili veri nadiren gerekli olduğunda - Çok büyük ilişkili veri setlerinde - Bellek kısıtlı ortamlarda - Koşullu veri yükleme senaryolarında

**Eager Loading Kullan:** - Liste görünümlerinde (index, table, grid) - İlişkili veri kesinlikle gerekli olduğunda - Birden fazla kayıt işlenirken - API response'larında - Export/raporlama işlemlerinde

N+1 Problemini Önleme ¶

Lazy loading kullanırken N+1 problemini önlemek için:

// 1. Manuel Preload kullan
db.Preload("Profile").Find(&users)

// 2. Batch loading kullan
db.Model(&users).Association("Profile").Find(&profiles)

// 3. Eager loading'e geç
field.WithEagerLoad()

Önemli Notlar ¶

- Liste görünümlerinde lazy loading kullanmayın (N+1 riski) - Tek kayıt görünümlerinde lazy loading tercih edilebilir - Production'da sorgu sayısını mutlaka monitor edin - GORM'un Debug() modu ile sorguları kontrol edin

İleri Seviye Kullanım ¶

// Koşullu lazy loading
field := fields.HasOne("Profile", "profile", "profiles").
    WithLazyLoad()

// Runtime'da eager loading'e geç
if needsProfile {
    db.Preload("Profile").Find(&users)
} else {
    db.Find(&users)
}

Debugging İpuçları ¶

// Sorgu sayısını kontrol et
db.Debug().Find(&users) // SQL loglarını gösterir

// N+1 tespiti için
// Her iterasyonda "SELECT * FROM profiles" görüyorsanız N+1 var!

Uyarılar ¶

- Production'da lazy loading kullanırken dikkatli olun - N+1 problemi ciddi performans sorunlarına yol açar - Büyük veri setlerinde veritabanını aşırı yükleyebilir - Liste görünümlerinde kesinlikle eager loading kullanın

Döndürür:

• Yapılandırılmış HasOneField pointer'ı (method chaining için)

func (*Hideable) GetHideCallback ¶

func (h *Hideable) GetHideCallback() func(*context.Context) bool

GetHideCallback, gizleme callback fonksiyonunu döndürür. Hiçbir callback ayarlanmamışsa nil döndürür.

Döndürür:

• Gizleme callback fonksiyonu veya ayarlanmamışsa nil

func (*Hideable) IsHidden ¶

func (h *Hideable) IsHidden() bool

IsHidden, alanın gizli olup olmadığını döndürür.

Döndürür:

• Alan gizliyse true, değilse false

func (*Hideable) SetHidden ¶

func (h *Hideable) SetHidden(hidden bool)

SetHidden, alanın gizli olup olmadığını ayarlar.

Parametreler:

• hidden: Alanı gizlemek için true, göstermek için false

Örnek:

field.SetHidden(true)

func (*Hideable) SetHideCallback ¶

func (h *Hideable) SetHideCallback(cb func(*context.Context) bool)

SetHideCallback, özel bir gizleme callback fonksiyonu ayarlar.

Callback, context'i alır ve alan gizlenmeli ise true, gösterilmeli ise false döndürmelidir.

Parametreler:

• cb: Alanın gizlenip gizlenmeyeceğini belirleyen fonksiyon

Örnek:

field.SetHideCallback(func(ctx *context.Context) bool {
    user := ctx.User()
    return user == nil || !user.IsAdmin
})

func (*Hideable) SetShowOnCreate ¶

func (h *Hideable) SetShowOnCreate(show bool)

SetShowOnCreate, alanın oluşturma formunda gösterilip gösterilmeyeceğini ayarlar.

func (*Hideable) SetShowOnDetail ¶

func (h *Hideable) SetShowOnDetail(show bool)

SetShowOnDetail, alanın detay görünümünde gösterilip gösterilmeyeceğini ayarlar.

func (*Hideable) SetShowOnIndex ¶

func (h *Hideable) SetShowOnIndex(show bool)

SetShowOnIndex, alanın liste görünümünde gösterilip gösterilmeyeceğini ayarlar.

func (*Hideable) SetShowOnUpdate ¶

func (h *Hideable) SetShowOnUpdate(show bool)

SetShowOnUpdate, alanın güncelleme formunda gösterilip gösterilmeyeceğini ayarlar.

func (*Hideable) ShowOnCreate ¶

func (h *Hideable) ShowOnCreate() bool

ShowOnCreate, alanın oluşturma formunda gösterilip gösterilmeyeceğini döner.

func (*Hideable) ShowOnDetail ¶

func (h *Hideable) ShowOnDetail() bool

ShowOnDetail, alanın detay görünümünde gösterilip gösterilmeyeceğini döner.

func (*Hideable) ShowOnIndex ¶

func (h *Hideable) ShowOnIndex() bool

ShowOnIndex, alanın liste görünümünde gösterilip gösterilmeyeceğini döner.

func (*Hideable) ShowOnUpdate ¶

func (h *Hideable) ShowOnUpdate() bool

ShowOnUpdate, alanın güncelleme formunda gösterilip gösterilmeyeceğini döner.

func (*HoverCardConfig) Disable ¶

func (h *HoverCardConfig) Disable() *HoverCardConfig

Disable, hover card'ı devre dışı bırakır.

Bu metod, hover card gösterimini tamamen kapatır.

Kullanım Örneği ¶

config := fields.NewHoverCardConfig()
config.Disable()

Döndürür:

• HoverCardConfig pointer'ı (method chaining için)

func (*HoverCardConfig) SetDelays ¶

func (h *HoverCardConfig) SetDelays(openDelay, closeDelay int) *HoverCardConfig

SetDelays, hover card açılma ve kapanma gecikmelerini ayarlar.

Bu metod, hover card'ın açılma ve kapanma gecikmelerini belirler.

Parametreler ¶

- **openDelay**: Açılma gecikmesi (ms) - **closeDelay**: Kapanma gecikmesi (ms)

Kullanım Örneği ¶

config := fields.NewHoverCardConfig()
config.SetDelays(300, 500)

Döndürür:

• HoverCardConfig pointer'ı (method chaining için)

func (*HoverCardConfig) SetResolver ¶

func (h *HoverCardConfig) SetResolver(resolver HoverCardResolver) *HoverCardConfig

SetResolver, hover card verilerini çözmek için callback fonksiyonunu ayarlar.

Bu metod, hover card verilerini almak için kullanılacak resolver'ı belirler.

Parametreler ¶

- **resolver**: Hover card resolver callback fonksiyonu

Kullanım Örneği ¶

config := fields.NewHoverCardConfig()
config.SetResolver(func(ctx context.Context, record interface{}, relatedID interface{}, field fields.Field) (interface{}, error) {
    // Custom logic
    return &AuthorHoverCard{...}, nil
})

Döndürür:

• HoverCardConfig pointer'ı (method chaining için)

func (*HoverCardConfig) SetStruct ¶

func (h *HoverCardConfig) SetStruct(s interface{}) *HoverCardConfig

SetStruct, hover card verisi için kullanılacak struct'ı ayarlar.

Bu metod, hover card verisi için tip bilgisini belirler.

Parametreler ¶

- **s**: Hover card struct'ı (örn. &AuthorHoverCard{})

Kullanım Örneği ¶

config := fields.NewHoverCardConfig()
config.SetStruct(&AuthorHoverCard{})

Döndürür:

• HoverCardConfig pointer'ı (method chaining için)

func (*HoverCardConfig) SetWidth ¶

func (h *HoverCardConfig) SetWidth(width string) *HoverCardConfig

SetWidth, hover card genişliğini ayarlar.

Bu metod, hover card'ın genişliğini belirler.

Parametreler ¶

- **width**: Genişlik değeri ("sm", "md", "lg", "xl")

Kullanım Örneği ¶

config := fields.NewHoverCardConfig()
config.SetWidth("lg")

Döndürür:

• HoverCardConfig pointer'ı (method chaining için)

func (*MorphTo) Displays ¶

func (m *MorphTo) Displays(displays map[string]string) *MorphTo

Displays, her tip için görüntüleme alanını ayarlar.

Bu metod, her polimorfik tip için hangi alanın görüntüleneceğini belirler. Farklı tipler farklı görüntüleme alanlarına sahip olabilir.

Parametreler ¶

- **displays**: Tip değeri -> görüntüleme alanı eşlemesi (örn. {"post": "title", "video": "name"})

Kullanım Örneği ¶

field := fields.NewMorphTo("Commentable", "commentable").
    Types(map[string]string{
        "post":  "posts",
        "video": "videos",
    }).
    Displays(map[string]string{
        "post":  "title",    // Post'lar için title alanı görüntülenir
        "video": "name",     // Video'lar için name alanı görüntülenir
    })

Önemli Notlar ¶

- Her tip için görüntüleme alanı belirtilmelidir - Görüntüleme alanları, ilgili resource'larda mevcut olmalıdır - Frontend'de ilişkili kaydı gösterirken bu alanlar kullanılır

Döndürür:

• MorphTo pointer'ı (method chaining için)

func (*MorphTo) Extract ¶

func (m *MorphTo) Extract(resource interface{})

Extract, MorphTo'ya özgü veri çıkarma işlemini gerçekleştirir.

Bu metod, Schema.Extract'ı override eder çünkü MorphTo struct'ta doğrudan bir field'a sahip değildir. Bunun yerine, morph_type ve morph_id field'larından polimorfik ilişkiyi çözümler.

Parametreler ¶

- **resource**: Veri çıkarılacak kaynak

Önemli Notlar ¶

- Schema.Extract çağrılmaz çünkü MorphTo doğrudan bir field'a sahip değildir - ResolveRelationship kullanılarak polimorfik ilişki çözümlenir - Çözümlenen veriler m.Data'ya atanır

Kullanım Örneği ¶

field.Extract(comment)
// m.Data = {"type": "post", "id": 123, "morphToType": "post", "morphToId": 123}

func (*MorphTo) GetDisplayKey ¶

func (m *MorphTo) GetDisplayKey() string

GetDisplayKey, görüntüleme key'ini döndürür.

MorphTo için kullanılmaz çünkü her tip farklı görüntüleme alanına sahip olabilir. Her zaman boş string döndürür.

Döndürür:

• Boş string (MorphTo için uygulanamaz)

func (*MorphTo) GetHoverCard ¶

func (m *MorphTo) GetHoverCard() *HoverCardConfig

GetHoverCard, hover card konfigürasyonunu döndürür.

Bu metod, hover card konfigürasyonunu alır.

Döndürür:

• HoverCardConfig pointer'ı (nil olabilir)

func (*MorphTo) GetLoadingStrategy ¶

func (m *MorphTo) GetLoadingStrategy() LoadingStrategy

GetLoadingStrategy, yükleme stratejisini döndürür.

Yükleme stratejisi tanımlanmışsa onu döndürür, aksi takdirde varsayılan EAGER_LOADING döndürür.

Döndürür:

• EAGER_LOADING veya LAZY_LOADING

func (*MorphTo) GetQueryCallback ¶

func (m *MorphTo) GetQueryCallback() func(interface{}) interface{}

GetQueryCallback, sorgu callback'ini döndürür.

Sorgu özelleştirme callback'i tanımlanmışsa onu döndürür, aksi takdirde varsayılan (no-op) callback döndürür.

Döndürür:

• Sorgu özelleştirme callback fonksiyonu

func (*MorphTo) GetRelatedResourceSlug ¶

func (m *MorphTo) GetRelatedResourceSlug() string

GetRelatedResource, ilgili resource slug'ını döndürür.

MorphTo için uygulanamaz çünkü birden fazla resource'a ait olabilir. Her zaman boş string döndürür.

Döndürür:

• Boş string (MorphTo için uygulanamaz)

func (*MorphTo) GetRelationshipName ¶

func (m *MorphTo) GetRelationshipName() string

GetRelationshipName, ilişkinin adını döndürür.

Döndürür:

• İlişkinin adı (örn. "Commentable", "Imageable")

func (*MorphTo) GetRelationshipType ¶

func (m *MorphTo) GetRelationshipType() string

GetRelationshipType, ilişki türünü döndürür.

MorphTo için her zaman "morphTo" döndürür.

Döndürür:

• "morphTo" string değeri

func (*MorphTo) GetResourceForType ¶

func (m *MorphTo) GetResourceForType(morphType string) (string, error)

GetResourceForType, verilen tip için resource slug'ını döndürür.

Bu metod, morph type değerine karşılık gelen resource slug'ını bulur. Tip kayıtlı değilse hata döndürür.

Parametreler ¶

- **morphType**: Morph type değeri (örn. "post", "video")

Kullanım Örneği ¶

resource, err := field.GetResourceForType("post")
// resource = "posts"

resource, err := field.GetResourceForType("unknown")
// err = "morph type 'unknown' is not registered"

Döndürür:

• Resource slug'ı (tip kayıtlıysa)
• Hata (tip kayıtlı değilse)

func (*MorphTo) GetSearchableColumns ¶

func (m *MorphTo) GetSearchableColumns() []string

GetSearchableColumns, aranabilir sütunları döndürür.

MorphTo için kullanılmaz çünkü polimorfik ilişkilerde doğrudan arama yapılmaz. Her zaman boş slice döndürür.

Döndürür:

• Boş string slice (MorphTo için uygulanamaz)

func (*MorphTo) GetTypes ¶

func (m *MorphTo) GetTypes() map[string]string

GetTypes, tip eşlemelerini döndürür.

Bu metod, polimorfik ilişki için tanımlanmış tüm tip eşlemelerini döndürür. Tip eşlemeleri, veritabanı tip değerleri ile resource slug'ları arasındaki ilişkiyi belirtir.

Döndürür:

• Tip değeri -> resource slug eşlemesi (örn. {"post": "posts", "video": "videos"})
• Boş map (tip eşlemeleri tanımlanmamışsa)

func (*MorphTo) HoverCard ¶

func (m *MorphTo) HoverCard(hoverStruct interface{}) *MorphTo

HoverCard, hover card struct'ını ayarlar ve hover card'ı etkinleştirir.

Bu metod, hover card için kullanılacak struct'ı belirler ve hover card özelliğini aktif eder.

Parametreler ¶

- **hoverStruct**: Hover card verisi için kullanılacak struct (örn. &CommentableHoverCard{})

Kullanım Örneği ¶

type CommentableHoverCard struct {
    Thumbnail string `json:"thumbnail"`
    Title     string `json:"title"`
    Type      string `json:"type"`
}

field := fields.NewMorphTo("Commentable", "commentable").
    Types(map[string]string{
        "post":  "posts",
        "video": "videos",
    }).
    HoverCard(&CommentableHoverCard{})

Döndürür:

• MorphTo pointer'ı (method chaining için)

func (*MorphTo) IsRequired ¶

func (m *MorphTo) IsRequired() bool

IsRequired, alanın zorunlu olup olmadığını döndürür.

Döndürür:

• true ise alan zorunludur

func (*MorphTo) Query ¶

func (m *MorphTo) Query(fn func(interface{}) interface{}) *MorphTo

Query, ilişki sorgusunu özelleştirmek için callback ayarlar.

Bu metod, polimorfik ilişki sorgularını özelleştirmek için kullanılır. Filtreleme, sıralama veya diğer sorgu modifikasyonları yapılabilir.

Parametreler ¶

- **fn**: Sorgu özelleştirme callback fonksiyonu

Kullanım Örneği ¶

field := fields.NewMorphTo("Commentable", "commentable").
    Query(func(q interface{}) interface{} {
        // Sadece aktif kayıtları getir
        return q.(*gorm.DB).Where("status = ?", "active")
    })

Döndürür:

• MorphTo pointer'ı (method chaining için)

func (*MorphTo) ResolveHoverCard ¶

func (m *MorphTo) ResolveHoverCard(resolver HoverCardResolver) *MorphTo

ResolveHoverCard, hover card verilerini çözmek için callback fonksiyonunu ayarlar.

Bu metod, hover card açıldığında çağrılacak resolver fonksiyonunu belirler. Resolver, ilişkili kaydın hover card verilerini döndürür.

Parametreler ¶

- **resolver**: Hover card resolver callback fonksiyonu

Kullanım Örneği ¶

field := fields.NewMorphTo("Commentable", "commentable").
    Types(map[string]string{
        "post":  "posts",
        "video": "videos",
    }).
    HoverCard(&CommentableHoverCard{}).
    ResolveHoverCard(func(ctx context.Context, record interface{}, relatedID interface{}, field fields.Field) (interface{}, error) {
        // MorphTo için tip bilgisini al
        morphType := record.(*Comment).CommentableType

        // Tip'e göre ilişkili kaydı al
        var data interface{}
        switch morphType {
        case "post":
            post := &Post{}
            if err := db.First(post, relatedID).Error; err != nil {
                return nil, err
            }
            data = post
        case "video":
            video := &Video{}
            if err := db.First(video, relatedID).Error; err != nil {
                return nil, err
            }
            data = video
        }

        // Hover card verisini döndür
        return &CommentableHoverCard{
            Thumbnail: data.Thumbnail,
            Title: data.Title,
            Type: morphType,
        }, nil
    })

API Endpoint ¶

Frontend, hover card açıldığında şu endpoint'e istek atar:

GET /api/resource/{resource}/resolver/{field_name}?id={related_id}&type={morph_type}
POST /api/resource/{resource}/resolver/{field_name} (body: {id: related_id, type: morph_type})

Döndürür:

• MorphTo pointer'ı (method chaining için)

func (*MorphTo) ResolveRelationship ¶

func (m *MorphTo) ResolveRelationship(item interface{}) (interface{}, error)

ResolveRelationship, polimorfik ilişkiyi morph type'a göre çözümler.

Bu metod, reflection kullanarak struct'tan morph_type ve morph_id değerlerini çıkarır. Farklı field adı varyasyonlarını (CamelCase, snake_case) destekler.

Parametreler ¶

- **item**: İlişkili verileri çözümlenecek kaynak

Döndürür ¶

Polimorfik ilişki bilgilerini içeren map:

• **type**: Morph type değeri (örn. "post", "video")
• **id**: Morph ID değeri (ilgili kaydın ID'si)
• **morphToType**: Morph type değeri (alias)
• **morphToId**: Morph ID değeri (alias)

Desteklenen Field Adları ¶

- Type için: "CommentableType", "Commentable_Type" - ID için: "CommentableID", "CommentableId", "Commentable_ID", "Commentable_Id"

Kullanım Örneği ¶

type Comment struct {
    ID              int
    CommentableType string  // "post" veya "video"
    CommentableID   int     // İlgili kaydın ID'si
    Content         string
}

resolved, err := field.ResolveRelationship(comment)
// resolved = {"type": "post", "id": 123, "morphToType": "post", "morphToId": 123}

Döndürür:

• İlişki bilgileri map'i veya nil
• Hata (çözümleme başarısız olursa)

func (*MorphTo) Searchable ¶

func (m *MorphTo) Searchable() Element

Searchable, alanı aranabilir olarak işaretler.

Bu metod, alanın global arama işlemlerine dahil edilmesini sağlar. Element interface'ini implement eder.

Kullanım Örneği ¶

field := fields.NewMorphTo("Commentable", "commentable").
    Searchable()
// Bu alan global arama işlemlerine dahil edilir

Döndürür:

• Element interface'i (method chaining için)

func (*MorphTo) Types ¶

func (m *MorphTo) Types(types map[string]string) *MorphTo

Types, polimorfik ilişki için tip eşlemelerini ayarlar.

Bu metod, veritabanındaki tip değerleri ile resource slug'ları arasında eşleme oluşturur. Her tip değeri, hangi resource'a karşılık geldiğini belirtir.

Parametreler ¶

- **types**: Tip değeri -> resource slug eşlemesi (örn. {"post": "posts", "video": "videos"})

Kullanım Örneği ¶

field := fields.NewMorphTo("Commentable", "commentable").
    Types(map[string]string{
        "post":  "posts",
        "video": "videos",
        "article": "articles",
    })
// commentable_type = "post" ise posts resource'u kullanılır
// commentable_type = "video" ise videos resource'u kullanılır

Önemli Notlar ¶

- Tip değerleri veritabanında commentable_type sütununda saklanır - Resource slug'ları, ilgili resource'ların benzersiz tanımlayıcılarıdır - Tüm olası tip değerleri bu map'te tanımlanmalıdır - Frontend'de select dropdown olarak görüntülenir

Döndürür:

• MorphTo pointer'ı (method chaining için)

func (*MorphTo) ValidateRelationship ¶

func (m *MorphTo) ValidateRelationship(value interface{}) error

ValidateRelationship, ilişkiyi doğrular.

Bu metod, polimorfik ilişkinin geçerli olup olmadığını kontrol eder. Gerçek implementasyonda, morph type'ın tip eşlemelerinde kayıtlı olup olmadığını kontrol eder.

Parametreler ¶

- **value**: Doğrulanacak değer

Döndürür ¶

- Hata (doğrulama başarısız olursa)

Önemli Notlar ¶

- Morph type, TypeMappings'te tanımlanmış olmalıdır - Gerçek implementasyonda veritabanı kısıtlamaları kontrol edilir

func (*MorphTo) WithEagerLoad ¶

func (m *MorphTo) WithEagerLoad() *MorphTo

WithEagerLoad, yükleme stratejisini eager loading olarak ayarlar.

Eager loading, ilişkili verileri önceden yükler ve N+1 sorgu problemini önler. Polimorfik ilişkiler için önerilir.

Kullanım Örneği ¶

field := fields.NewMorphTo("Commentable", "commentable").
    WithEagerLoad()
// İlişkili veriler önceden yüklenir

Döndürür:

• MorphTo pointer'ı (method chaining için)

func (*MorphTo) WithHoverCard ¶

func (m *MorphTo) WithHoverCard(config HoverCardConfig) *MorphTo

WithHoverCard, hover card konfigürasyonunu ayarlar.

Bu metod, index ve detail sayfalarında ilişkili kaydın hover card ile nasıl görüntüleneceğini belirler.

Parametreler ¶

- **config**: Hover card konfigürasyonu

Kullanım Örneği (Deprecated - Yeni API kullanın) ¶

field := fields.NewMorphTo("Commentable", "commentable").
    WithHoverCard(*fields.NewHoverCardConfig())

Yeni API (Önerilen) ¶

field := fields.NewMorphTo("Commentable", "commentable").
    HoverCard(&CommentableHoverCard{}).
    ResolveHoverCard(func(ctx context.Context, record interface{}, relatedID interface{}, field fields.Field) (interface{}, error) {
        // Custom logic
        return &CommentableHoverCard{...}, nil
    })

Döndürür:

• MorphTo pointer'ı (method chaining için)

func (*MorphTo) WithLazyLoad ¶

func (m *MorphTo) WithLazyLoad() *MorphTo

WithLazyLoad, yükleme stratejisini lazy loading olarak ayarlar.

Lazy loading, ilişkili verileri ihtiyaç anında yükler. Bellek tasarrufu sağlar ancak N+1 sorgu problemine neden olabilir.

Kullanım Örneği ¶

field := fields.NewMorphTo("Commentable", "commentable").
    WithLazyLoad()
// İlişkili veriler ihtiyaç anında yüklenir

Döndürür:

• MorphTo pointer'ı (method chaining için)

func (*MorphToMany) AutoOptions ¶

func (m *MorphToMany) AutoOptions(displayField string) *MorphToMany

AutoOptions, ilişkili tablodan otomatik options oluşturmayı etkinleştirir.

Bu metod, MorphToMany ilişkisinde ilişkili kayıtların otomatik olarak yüklenmesini ve frontend'de multi-select combobox'ta gösterilmesini sağlar.

Parametreler ¶

- **displayField**: Option label'ı için kullanılacak sütun adı (örn. "name", "title")

Kullanım Örneği ¶

field := fields.NewMorphToMany("Taggable", "taggable").
    Types(map[string]string{
        "post":  "posts",
        "video": "videos",
    }).
    AutoOptions("name")  // Ana tablodaki "name" sütunu label olarak kullanılır

Döndürür:

• MorphToMany pointer'ı (method chaining için)

func (*MorphToMany) Displays ¶

func (m *MorphToMany) Displays(displays map[string]string) *MorphToMany

Displays, her tip için görüntüleme alanını ayarlar.

Parametreler ¶

- **displays**: Tip değeri -> görüntüleme alanı eşlemesi (örn. {"post": "title", "video": "name"})

Kullanım Örneği ¶

field := fields.NewMorphToMany("Taggable", "taggable").
    Displays(map[string]string{
        "post":  "title",
        "video": "name",
    })

Döndürür:

• MorphToMany pointer'ı (method chaining için)

func (*MorphToMany) ForeignKey ¶

func (m *MorphToMany) ForeignKey(key string) *MorphToMany

ForeignKey, ana tablonun foreign key sütun adını ayarlar.

Parametreler ¶

- **key**: Foreign key sütun adı (örn. "tag_id")

Döndürür:

• MorphToMany pointer'ı (method chaining için)

func (*MorphToMany) GetDisplayKey ¶

func (m *MorphToMany) GetDisplayKey() string

GetDisplayKey, görüntüleme key'ini döndürür.

func (*MorphToMany) GetLoadingStrategy ¶

func (m *MorphToMany) GetLoadingStrategy() LoadingStrategy

GetLoadingStrategy, yükleme stratejisini döndürür.

func (*MorphToMany) GetQueryCallback ¶

func (m *MorphToMany) GetQueryCallback() func(interface{}) interface{}

GetQueryCallback, sorgu callback'ini döndürür.

func (*MorphToMany) GetRelatedResource ¶

func (m *MorphToMany) GetRelatedResource() string

GetRelatedResource, ilgili resource slug'ını döndürür. MorphToMany için uygulanamaz çünkü birden fazla resource'a ait olabilir.

func (*MorphToMany) GetRelationshipName ¶

func (m *MorphToMany) GetRelationshipName() string

GetRelationshipName, ilişkinin adını döndürür.

func (*MorphToMany) GetRelationshipType ¶

func (m *MorphToMany) GetRelationshipType() string

GetRelationshipType, ilişki türünü döndürür.

func (*MorphToMany) GetSearchableColumns ¶

func (m *MorphToMany) GetSearchableColumns() []string

GetSearchableColumns, aranabilir sütunları döndürür.

func (*MorphToMany) GetTypes ¶

func (m *MorphToMany) GetTypes() map[string]string

GetTypes, tip eşlemelerini döndürür.

func (*MorphToMany) IsRequired ¶

func (m *MorphToMany) IsRequired() bool

IsRequired, alanın zorunlu olup olmadığını döndürür.

func (*MorphToMany) MorphType ¶

func (m *MorphToMany) MorphType(column string) *MorphToMany

MorphType, polimorfik tip sütun adını ayarlar.

Parametreler ¶

- **column**: Polimorfik tip sütun adı (örn. "taggable_type")

Döndürür:

• MorphToMany pointer'ı (method chaining için)

func (*MorphToMany) PivotTable ¶

func (m *MorphToMany) PivotTable(tableName string) *MorphToMany

PivotTable, pivot tablo adını özelleştirir.

Parametreler ¶

- **tableName**: Pivot tablo adı (örn. "taggables", "imageables")

Döndürür:

• MorphToMany pointer'ı (method chaining için)

func (*MorphToMany) Query ¶

func (m *MorphToMany) Query(fn func(interface{}) interface{}) *MorphToMany

Query, ilişki sorgusunu özelleştirmek için callback ayarlar.

func (*MorphToMany) RelatedKey ¶

func (m *MorphToMany) RelatedKey(key string) *MorphToMany

RelatedKey, polimorfik ID sütun adını ayarlar.

Parametreler ¶

- **key**: Polimorfik ID sütun adı (örn. "taggable_id")

Döndürür:

• MorphToMany pointer'ı (method chaining için)

func (*MorphToMany) ResolveRelationship ¶