Korm ORM and Framework for Go

Korm supports composability via a network websocket PubSub system using WithBus. This allows you to synchronize data between multiple Korm instances.

Workflow:

1. Initialize Korm.
2. Call korm.WithBus(opts) to create a ksbus.Server.
3. Use serverBus.SendToServer(address, data) to push data to another instance.
4. Use korm.BeforeServersData(fn) to handle incoming data from other servers.
5. Use korm.BeforeDataWS(fn) to handle authentication for websocket data.

Example (Server 1):

serverBus := korm.WithBus(ksbus.ServerOpts{...})
serverBus.App.Get("/", func(c *ksmux.Context) {
    serverBus.SendToServer("localhost:9314", map[string]any{"msg": "hello"})
})
serverBus.Run("localhost:9313")

serverBus := korm.WithBus(ksbus.ServerOpts{
    // ... configuration
})
serverBus.Run("localhost:9313")

Korm uses struct tags to define primary keys and foreign key relationships. You can define nested structs to represent one-to-many or many-to-one relationships.

• Use `korm:"pk"` to mark a field as a primary key.
• Use `korm:"fk:table.column:options"` to define a foreign key. Options like cascade can be appended to the tag (e.g., `korm:"fk:classes.id:cascade:cascade"`).

type Class struct {
	Id       uint `korm:"pk"` 
	Name     string
	Students []Student
}

type Student struct {
	Id      uint `korm:"pk"` 
	Name    string
	Class   uint `korm:"fk:classes.id:cascade:cascade"` 
	Classes Class
}

To compare Korm's performance against GORM on your local machine, follow these steps:

1. Clone the repository:

   git clone https://github.com/kamalshkeir/korm.git
   cd korm

2. Prepare the benchmark file: Open benchmarks/bench-test.go and uncomment the relevant code sections.
3. Initialize dependencies:

   go mod tidy

4. Execute the benchmarks:

   go test -bench ^ .\benchmarks\ -benchmem

Korm can provide a built-in Admin Dashboard and a CLI shell for managing data.

Important Ordering Rule: If you are using the Dashboard, you must call korm.WithShell() after korm.WithDashboard().

Basic Setup:

serverBus := korm.WithDashboard(":9313")
korm.WithShell() // Must be after WithDashboard

// To create a superuser, run your app with the 'shell' command:
// go run main.go shell

serverBus.Run()

Customizing the Dashboard: You can overwrite default settings like korm.PaginationPer, korm.DocsUrl, or the admin path via korm.SetAdminPath("/another").

You can also customize the Auth and Admin middleware used by the dashboard by assigning new functions to korm.Auth and korm.Admin.

Korm drivers are located outside the main package to keep go.mod clean. Install the driver for your specific database using the following commands:

SQLite: go get -u github.com/kamalshkeir/sqlitedriver@latest

PostgreSQL / CockroachDB: go get -u github.com/kamalshkeir/pgdriver@latest

MySQL / MariaDB: go get -u github.com/kamalshkeir/mysqldriver@latest

Korm uses ksmux for routing. You can initialize a server with an Admin Dashboard using korm.WithDashboard(address). If you use the dashboard, you can also enable an interactive shell using korm.WithShell(), but ensure WithShell() is called after WithDashboard(). The dashboard provides a serverBus.App which is an http.Handler (the mux) where you can register global middlewares.

func main() {
	err := korm.New(korm.SQLITE, "db", sqlitedriver.Use())
	if err != nil {
		log.Fatal(err)
	}

	serverBus := korm.WithDashboard("localhost:9313")
	korm.WithShell() // Call after WithDashboard
	mux := serverBus.App

	// add global middlewares
	mux.Use((midws ...func(http.Handler) http.Handler))
}

Install the latest version of Korm using the Go toolchain:

go get -u github.com/kamalshkeir/korm@latest

Korm provides an Admin Dashboard and a CLI Shell for database management.

Important Ordering Rule: If you use both WithDashboard and WithShell, you must call WithShell() after WithDashboard().

1. korm.WithDashboard(address): Starts the admin dashboard at the specified address.
2. korm.WithShell(): Enables the CLI shell.

To create a superuser for the dashboard, run your application with the shell command: go run main.go shell.

server := korm.WithDashboard("localhost:9313")
korm.WithShell() // Must be after WithDashboard

// ... later
server.Run()

Korm works well with kenv to map environment variables directly to Go structs using struct tags. Use the kenv:"ENV_VAR|default_value" tag format.

• kenv.Load(".env") loads an environment file.
• kenv.Fill(&configStruct) populates the struct with the loaded values.

type GlobalConfig struct {
	Host string `kenv:"HOST|localhost"` 
	Db   struct {
		Name string `kenv:"DB_NAME|db"` 
		Type string `kenv:"DB_TYPE"` // Required
	}
}

kenv.Load(".env")
config := &GlobalConfig{}
err := kenv.Fill(config)