gimbap

README

GIMBAP - Go Injection Management for Better Application Programming

Go Injection Management for Better Application Programming

Why GIMBAP?

Gimbap is a Korean-style sea-weed roll with various ingredients insid. It is a simple and easy to make dish that is popular in Korea. The name GIMBAP is chosen as the acronym because it's one of my favourite dishes!.

Gimbap is a food where vegetables, fish and meat are rolled in a seaweed sheet with cooked rice. The seaweed sheet connects all the ingredients together and makes it easy to eat.

Like this GIMBAP aims to provide a simple solution to build web application in Go, connecting all components together in a simple and easy way.

Disclaimer

GIMBAP is still in its early stage of development. It is not recommended to use this in production environment yet, and I am still working on to handle some of the key features that are missing or need improvement.

Key Features

GIMBAP currently supports the following key features:

• Automatic Dependency Injection management
• API Endpoint management by code
• Flexible Server engine switching
• Containerized instance managing

Automatic Dependency Injection Management

This is an example of adding a new dependency struct B to the constructor of A

AS-IS

package example

import "github.com/jhseong7/gimbap"

type A struct {}

func CreateA() *A {
  return &A{}
}

var ProviderA = gimbap.DefineProvider(
  gimbap.ProviderOption{Name: "A", Instantiator: CreateA},
)

var Module = gimbap.DefineModule(
  gimbap.ModuleOption{
    Name: "ExampleModule",
    Providers: []*gimbap.Provider{ProviderA}
  }
)

TO-BE

package example

import "github.com/jhseong7/gimbap"

type A struct {B *B}


func CreateA(B *B) *A {
  return &A{B: B}
}

var ProviderA = gimbap.DefineProvider(
  gimbap.ProviderOption{Name: "A", Instantiator: CreateA},
)

// ==== Add defs for B START =====
type B struct {}

func CreateB() *B {
  return &B{}
}

var ProviderB = gimbap.DefineProvider(
  gimbap.ProviderOption{Name: "B", Instantiator: CreateB},
)
// ==== Add defs for B END =====

var Module = gimbap.DefineModule(
  gimbap.ModuleOption{
    Name: "ExampleModule",
    Providers: []*gimbap.Provider{ProviderA, ProviderB} // Add the provider for B here
  }
)

Don't worry about changing the intialization process by hand for the new struct. GIMBAP will handle it for you.

API Endpoint management by code

WIP

Flexible Server engine switching

GIMBAP has an modularized server core that can be switched easily by preference

import "github.com/jhseong7/gimbap"
import "github.com/jhseong7/gimbap/internal/engine/fiber_engine"
import "github.com/jhseong7/gimbap/internal/engine/echo_engine"

func main() {
  // Using GIN as http server
  a := gimbap.CreateApp(gimbap.AppOption{
    AppName:   "SampleApp",
		AppModule: SampleModule,
  })

  // Using fiber
  a = gimbap.CreateApp(gimbap.AppOption{
    AppName:   "SampleApp",
		AppModule: SampleModule,
    ServerEngine: fiber_engine.NewFiberHttpEngine()
  })

  // Using Echo
  a = gimbap.CreateApp(gimbap.AppOption{
    AppName:   "SampleApp",
		AppModule: SampleModule,
    ServerEngine: echo_engine.NewEchoHttpEngine()
  })
}

You can choose whatever web server you prefer as the core server easily.

Documentation

Check for the documentation here.

Documentation

Related Projects

Sample Repo Config Provider

Goals

This framework provides the following features in the future

• Interceptor, Guard support
• Template engine support
• More to be added...

Third-Party Libraries

This project uses the following third-party libraries:

• Library Name: uber-go/fx
  • Purpose: Used managing dependency management in the FxDependencyManager
  • License: MIT License. Link
  • Link: https://github.com/uber-go/fx
• Library Name: gin-gonic/gin
  • Purpose: Used the internal server engine GinHttpEngine
  • License: MIT License. Link
  • Link: https://github.com/gin-gonic/gin
• Library Name: gofiber/fiber
  • Purpose: Used the internal server engine FiberHttpEngine
  • License: MIT License. Link
  • Link: https://github.com/gofiber
• Library Name: labstack/echo
  • Purpose: Used the internal server engine EchoHttpEngine
  • License: MIT License. Link
  • Link: https://github.com/labstack/echo

License

This project is licensed under the MIT License - see the LICENSE file for details.

Documentation

Overview

Alias public types and functions for the package gimbap.

Index

• func GetProvider[T interface{}](a GimbapApp, prov T) (ret T)
• type AppOption
• type Controller
  • func DefineController(option ControllerOption) *Controller
• type ControllerOption
• type GimbapApp
  • func CreateApp(option AppOption) *GimbapApp
• type IController
• type IMicroService
• type IServerEngine
• type MicroServiceProvider
  • func DefineMicroService(option MicroServiceProviderOption) *MicroServiceProvider
• type MicroServiceProviderOption
• type Module
  • func DefineModule(option ModuleOption) *Module
• type ModuleOption
• type Provider
  • func DefineProvider(option ProviderOption) *Provider
• type ProviderOption
• type RouteSpec
• type RuntimeOptions
• type ServerEngineOption
• type TLSOption

Functions

func GetProvider

func GetProvider[T interface{}](a GimbapApp, prov T) (ret T)

Function to get a provider from the app.

Provide the app and the provider type to get the provider instance. If the provider is not found, it will panic.

Types

type AppOption

type AppOption = app.AppOption

App related

type Controller

type Controller = controller.Controller

type aliases for public apis

func DefineController

func DefineController(option ControllerOption) *Controller

Define a controller.

Defines a special provider that is used to handle RESTful requests. The controller will be registered to the app and can be injected to the other controllers.

type ControllerOption

type ControllerOption = controller.ControllerOption

type aliases for public apis

type GimbapApp

type GimbapApp = app.GimbapApp

type aliases for public apis

func CreateApp

func CreateApp(option AppOption) *GimbapApp

Create a Gimbap instance.

This is the entry point to create a Gimbap application.

type IController

type IController = controller.IController

Controller related

type IMicroService

type IMicroService = microservice.IMicroService

Microservice related

type IServerEngine

type IServerEngine = engine.IServerEngine

Engine related

type MicroServiceProvider

type MicroServiceProvider = microservice.MicroServiceProvider

type aliases for public apis

func DefineMicroService

func DefineMicroService(option MicroServiceProviderOption) *MicroServiceProvider

Define a microservice

Define a special provider for microservices

type MicroServiceProviderOption

type MicroServiceProviderOption = microservice.MicroServiceProviderOption

type aliases for public apis

type Module

type Module = module.Module

type aliases for public apis

func DefineModule

func DefineModule(option ModuleOption) *Module

Define a module.

This defines a module with the given option. The module is used to determine the dependencies of the providers.

type ModuleOption

type ModuleOption = module.ModuleOption

Module related

type Provider

type Provider = provider.Provider

Provider related

func DefineProvider

func DefineProvider(option ProviderOption) *Provider

Define a provider.

This defines a provider with the given option. The provider will be registered to the app and can be injected to the controllers.

type ProviderOption

type ProviderOption = provider.ProviderOption

type aliases for public apis

type RouteSpec

type RouteSpec = controller.RouteSpec

type aliases for public apis

type RuntimeOptions

type RuntimeOptions = app.RuntimeOptions

type aliases for public apis

type ServerEngineOption

type ServerEngineOption = engine.ServerEngineOption

type aliases for public apis

type TLSOption

type TLSOption = engine.TLSOption

type aliases for public apis