gRPC Integration

import (
    "google.golang.org/grpc"
    "github.com/ch-hash-lab/rue"
    pb "your/proto/package"
)

func main() {
    // Create Rue engine
    engine := rue.New()
    
    // Create gRPC server with Rue
    gs := rue.NewGRPCServer(engine)
    
    // Add Rue middleware as interceptors
    gs.Use(func(c *rue.Context) {
        c.Set("request_id", generateID())
        c.Next()
    })
    
    // Add native gRPC interceptors
    gs.UseUnary(rue.GRPCLogger())
    gs.UseUnary(rue.GRPCRecovery())
    
    // Build and register services
    server := gs.Build()
    pb.RegisterMyServiceServer(server, &myService{})
    
    // Run server
    gs.Run(":50051")
}

// Logger - logs gRPC calls
gs.UseUnary(rue.GRPCLogger())

// Recovery - recovers from panics
gs.UseUnary(rue.GRPCRecovery())

// Authentication
authFunc := func(ctx context.Context) (context.Context, error) {
    md, ok := metadata.FromIncomingContext(ctx)
    if !ok {
        return nil, status.Error(codes.Unauthenticated, "no metadata")
    }
    
    tokens := md.Get("authorization")
    if len(tokens) == 0 {
        return nil, status.Error(codes.Unauthenticated, "no token")
    }
    
    user, err := validateToken(tokens[0])
    if err != nil {
        return nil, status.Error(codes.Unauthenticated, "invalid token")
    }
    
    return context.WithValue(ctx, "user", user), nil
}

gs.UseUnary(rue.GRPCAuth(authFunc))
gs.UseStream(rue.GRPCStreamAuth(authFunc))

func (s *myService) MyMethod(ctx context.Context, req *pb.Request) (*pb.Response, error) {
    // Get Rue's GRPCContext
    gc := rue.GetGRPCContext(ctx)
    if gc != nil {
        // Access values set by middleware
        requestID, _ := gc.Get("request_id")
        
        // Access metadata
        auth := gc.GetMetadata("authorization")
        
        // Set values for later middleware
        gc.Set("processed", true)
    }
    
    return &pb.Response{}, nil
}

// Add stream interceptors
gs.UseStream(rue.GRPCStreamLogger())
gs.UseStream(rue.GRPCStreamRecovery())

// Custom stream interceptor
gs.UseStream(func(srv any, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) error {
    log.Printf("Stream started: %s", info.FullMethod)
    err := handler(srv, ss)
    log.Printf("Stream ended: %s", info.FullMethod)
    return err
})