config

type AdminConfig struct {
	Port     string
	Boundary string
}

type AppConfig struct {
	Backend      BackendConfig
	Postgres     PostgresDBConfig
	Sqlite       SqliteConfig
	FoundationDB FoundationDBConfig
	// Boundaries []Boundary `mapstructure:"boundaries"`
	Boundaries string

	Grpc struct {
		Port                         string
		EnableReflection             bool
		ConnectionTimeout            time.Duration
		KeepAliveTime                time.Duration
		KeepAliveTimeout             time.Duration
		MaxConcurrentStreams         uint32
		MaxReceiveMessageSize        int
		MaxSendMessageSize           int
		InitialWindowSize            int32
		InitialConnWindowSize        int32
		WriteBufferSize              int
		ReadBufferSize               int
		KeepaliveMinTime             time.Duration
		KeepalivePermitWithoutStream bool
		TLS                          struct {
			Enabled            bool
			CertFile           string
			KeyFile            string
			CAFile             string
			ClientAuthRequired bool
		}
	}

	PollingPublisher struct {
		BatchSize uint32
	}

	Logging LoggingConfig

	Nats NatsConfig
	// Prod bool
	Auth struct {
		AdminUsername string
		AdminPassword string
	}

	Admin AdminConfig

	Pprof struct {
		Enabled bool
		Port    string
	}

	OpenTelemetry struct {
		Enabled     bool
		Endpoint    string
		ServiceName string
	}
	// contains filtered or unexported fields
}

type BackendConfig struct {
	Type string
}

type Boundary struct {
	Name        string
	Description string
}

type BoundaryToPostgresSchemaMapping struct {
	Schema   string
	Boundary string
}

type FoundationDBConfig struct {
	ClusterFile string
	APIVersion  int
	Root        string
	// TransactionTimeoutMs bounds each FoundationDB transaction including its
	// internal retries. 0 = backend default (10s); negative = no timeout.
	TransactionTimeoutMs int
	// TransactionRetryLimit caps internal retries per transaction. 0 = unlimited
	// (the timeout is the bound).
	TransactionRetryLimit int
}

type LoggingConfig struct {
	Enabled bool
	Level   string // e.g., "debug", "info", "warn", "error"
}

type NatsClusterConfig struct {
	Name     string
	Host     string
	Port     int
	Routes   string
	Username string
	Password string
	Enabled  bool
	Timeout  time.Duration
}

type NatsConfig struct {
	URL                    string
	ServerName             string
	Port                   int
	MaxPayload             int32
	MaxConnections         int
	StoreDir               string
	EventStreamMaxBytes    int64
	EventStreamMaxMsgs     int64
	EventStreamMaxAge      time.Duration
	PublishAsyncMaxPending int
	Cluster                NatsClusterConfig
}

type PostgresDBConfig struct {
	User     string
	Name     string
	Password string
	Host     string
	Port     string
	Schemas  string
	SSLMode  string
	Dialect  string
	// Write pool configuration (optimized for write operations)
	WriteMaxOpenConns    int
	WriteMaxIdleConns    int
	WriteConnMaxIdleTime time.Duration
	WriteConnMaxLifetime time.Duration
	// Read pool configuration (optimized for read operations)
	ReadMaxOpenConns    int
	ReadMaxIdleConns    int
	ReadConnMaxIdleTime time.Duration
	ReadConnMaxLifetime time.Duration
	// AdminConfig pool configuration (optimized for admin operations)
	AdminMaxOpenConns    int
	AdminMaxIdleConns    int
	AdminConnMaxIdleTime time.Duration
	AdminConnMaxLifetime time.Duration
	ListenEnabled        bool
}

type SqliteConfig struct {
	Dir                string
	Synchronous        string
	BusyTimeoutMs      int
	ReadPoolSize       int
	CacheSize          int
	MmapSize           int64
	WalAutoCheckpoint  int
	TempStore          string
	PublisherWakeDelay time.Duration
	GroupCommit        SqliteGroupCommitConfig
}

type SqliteGroupCommitConfig struct {
	// MaxBatchRequests caps requests per flush (savepoint-loop length).
	MaxBatchRequests int
	// MaxBatchEvents caps events per flush (transaction size). A request that
	// would exceed it is carried to the next flush.
	MaxBatchEvents int
	// MaxDelay > 0 makes the worker wait up to this long to fill a batch.
	// 0 (default) = opportunistic batching only: flush whatever is queued.
	MaxDelay time.Duration
	// MaxPending bounds the per-boundary queue; a full queue blocks callers.
	MaxPending int
	// FlushTimeout bounds one whole flush (worker-owned context).
	FlushTimeout time.Duration
}