solanum

Solanum — A Modular Gin-Based Framework with Built-In Dependency Injection

Solanum is designed to help Go developers ship clean, maintainable HTTP services and micro-APIs by combining:

• A clear module/controller structure
• First-class dependency injection (no global state, minimal reflection)
• Pluggable middleware (CORS, logging, auth, etc.)
• Testable, decoupled components

Why Solanum?

When you build a typical Gin application, it’s easy to end up with:

• One giant main.go wiring routes, middleware, and handlers inline
• Hard-to-test handlers that call global singletons or package-level variables
• Tight coupling between controllers, services, and data stores
• Boilerplate to register dependencies and then invoke them manually

Solanum solves these pain points by:

1. Inversion of Control & DI container
   Register your services, repositories, and clients once. Solanum will resolve and inject them for you.
2. Modular structure
   Group routes, middleware, and handlers into self-contained Modules. Each module declares its own dependencies.
3. Minimal reflection, maximal clarity
   Define constructor functions with explicit parameters; Solanum uses simple reflection only to wire them up.
4. Test-driven development
   Because your handlers request only the dependencies they need, you can swap in mocks or stubs without spinning up a server.

What Can You Build?

• RESTful APIs
• Microservices
• GraphQL or gRPC gateways
• CLI tools or batch workers (reuse DI container in non-web context)
• Web Server for Applications; Health checks, admin dashboards, metrics endpoints, etc.

Whether you need a single /ping health check or a complex set of user, order, and payment services, Solanum keeps your code organized and your dependencies explicit.

Key Features

1. Modular Architecture

// Define a /users module
userModule := solanum.NewModule("/users")
userModule.SetControllers(myUserController)
userModule.SetDependencies(solanum.Dep[UserService]("userSvc"))

2. Controller & Service Layer

type SolaService struct {
    Uri     string
    Method  string
    Handler gin.HandlerFunc
}

3. Dependency Injection Container

solanum.Register("db", ProvideDB, solanum.WithSingleton())
solanum.Register(
  "userSvc",
  ProvideUserService,
  solanum.WithTransient(),
  solanum.As((*UserService)(nil)),
)

4. Flexible CORS & Middleware

app.Cors(
  solanum.WithOrigins("https://example.com"),
  solanum.WithMethods("GET", "POST"),
  solanum.WithAllowCredentials(true),
)

Getting Started

Get Solanum

go get github.com/annuums/solanum

Easy Start

package main

import "github.com/annuums/solanum"

func main() {

   pingModule := solanum.NewModule(
      solanum.WithUri("/ping"),
   )

   ctrl := solanum.NewController()
   ctrl.SetHandlers(
      &solanum.SolaService{
         Uri:    "",
         Method: http.MethodGet,
         Handler: func(c *gin.Context) {
            c.String(http.StatusOK, "pong")
         },
      },
   )
   pingModule.SetControllers(ctrl)

   server := solanum.NewSolanum(
      solanum.WithPort(5050),
   )

   server.SetModules(pingModule)
   server.Run()
}

Examples & More

👉 Learn by Examples

Who Is This For?

• Go backend teams building REST or microservices
• Developers who want clear separation between controllers, services, and data layers
• Projects that require testable, maintainable code without manual wiring in every main.go
• Engineers seeking a lightweight alternative to heavier frameworks with reflection-heavy DI