Extensions

Forge extensions provide production-ready, plug-and-play functionality for common application requirements. Each extension follows a consistent architecture pattern with unified interfaces, comprehensive configuration options, and built-in observability.

Architecture Overview

Every Forge extension follows a consistent pattern:

type Extension interface {
    Name() string
    Version() string
    Description() string
    Dependencies() []string
    Register(app forge.App) error
    Start(ctx context.Context) error
    Stop(ctx context.Context) error
    Health(ctx context.Context) error
}

Key Features

• Unified Interfaces: Consistent APIs across all extensions
• Multiple Backends: Support for various backend implementations
• Production Ready: Built-in connection pooling, retry logic, and error handling
• Observability: Metrics, tracing, and health checks included
• Configuration: YAML/JSON config files and programmatic configuration
• Security: TLS/mTLS, authentication, rate limiting, and input validation

Extension Categories

Core Extensions

Essential extensions for data management and application infrastructure:

Communication Extensions

Real-time communication, APIs, and streaming capabilities:

Specialized Extensions

Advanced features for specific use cases:

Quick Start

extensions:
  database:
    type: postgres
    dsn: "postgres://user:pass@localhost/db"
    max_open_conns: 25
    max_idle_conns: 5
  
  cache:
    type: redis
    addr: "localhost:6379"
    db: 0
    pool_size: 10
  
  queue:
    type: rabbitmq
    url: "amqp://guest:guest@localhost:5672/"
    exchange: "forge.events"

package main

import (
    "github.com/xraph/forge"
    "github.com/xraph/forge/extensions/database"
    "github.com/xraph/forge/extensions/cache"
    "github.com/xraph/forge/extensions/queue"
)

func main() {
    app := forge.New()

    // Register extensions
    app.RegisterExtension(database.New(database.Config{
        Type: "postgres",
        DSN:  "postgres://user:pass@localhost/db",
    }))

    app.RegisterExtension(cache.New(cache.Config{
        Type: "redis",
        Addr: "localhost:6379",
    }))

    app.RegisterExtension(queue.New(queue.Config{
        Type: "rabbitmq",
        URL:  "amqp://guest:guest@localhost:5672/",
    }))

    app.Run()
}

Extension Status

Performance Targets

All extensions are designed with performance in mind:

• Latency: Sub-millisecond for cache operations, <10ms for database queries
• Throughput: 10,000+ operations/second per extension
• Memory: Efficient memory usage with connection pooling
• CPU: Optimized for multi-core systems
• Scalability: Horizontal scaling support

Security Features

Every extension includes comprehensive security features:

• TLS/mTLS: Encrypted connections with certificate validation
• Authentication: Multiple authentication mechanisms
• Authorization: Role-based access control
• Input Validation: Comprehensive input sanitization
• Rate Limiting: Configurable rate limiting and throttling
• Audit Logging: Detailed security event logging

Next Steps

1. Choose Extensions: Select the extensions you need for your application
2. Configuration: Set up configuration files or programmatic config
3. Integration: Register extensions with your Forge application
4. Monitoring: Set up observability and health checks
5. Production: Deploy with proper security and scaling configuration