kora

package module
v0.2.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 30, 2026 License: MIT Imports: 19 Imported by: 0

README

Kora

CI Go Reference

Laravel-like developer experience. Idiomatic Go underneath.

Kora is an experimental open-source Go framework focused on productive backend development without hiding the language that powers it.

The goal is simple: keep the clarity, performance, explicitness, and tooling of Go while reducing the repetitive setup work developers usually do when starting a production backend.

Status

Kora v0.2.0 adds the first complete driver-neutral data workflow and supervised development reload on top of the HTTP MVP. The API remains pre-1.0 and is not yet recommended for production systems without careful evaluation.

The release includes the HTTP and application core, developer CLI, configuration-aware starter, route inspection, code generators, migrations, transactions, seeders, and test factories. Production modules remain part of the roadmap.

Philosophy

Kora is built around one rule:

Convenience without hiding Go.

That means:

  • standard Go concepts stay visible: context.Context, error, http.Handler, interfaces, structs, and the standard library;
  • developer experience can be opinionated, but application code should remain understandable to a Go developer who has never used Kora;
  • framework components should be replaceable instead of locking applications into a private ecosystem;
  • runtime magic and reflection should be kept to a minimum;
  • performance and debuggability should not be traded away for syntactic convenience;
  • Kora should provide good defaults while preserving escape hatches to ordinary Go.

Current features

Today Kora intentionally stays small:

  • standard-library net/http foundation;
  • Kora handlers with func(*kora.Context) error;
  • direct access to the underlying http.Request, http.ResponseWriter, and context.Context;
  • GET, POST, PUT, PATCH, and DELETE route helpers;
  • Go 1.22+ ServeMux route patterns and path parameters;
  • nested route groups with group middleware;
  • named routes, URL generation, and a route registry;
  • application-wide standard Go middleware;
  • centralized JSON error rendering;
  • explicit HTTPError helpers for expected failures;
  • JSON request binding with unknown-field rejection;
  • validation through an explicit Validate() error contract;
  • field-level ValidationError responses;
  • typed environment configuration with defaults and required values;
  • optional dependency-free .env loading with exported-variable precedence;
  • standard-library log/slog integration;
  • automatic request IDs and request-scoped loggers;
  • startup and shutdown lifecycle hooks;
  • configurable graceful-shutdown timeout;
  • constructor-based dependency wiring;
  • singleton and transient service lifetimes;
  • interface bindings and startup graph validation;
  • driver-neutral database/sql configuration, lifecycle, and DI registration;
  • transactional, dialect-aware SQL migrations with filesystem and embedded sources;
  • PostgreSQL advisory locking and real-database integration coverage;
  • transaction helper with explicit *sql.Tx;
  • ordered transactional seeders and kora db:seed;
  • generic test factories with sequences, states, and persistence hooks;
  • composed application command handling for migrations and seeders;
  • JSON response helpers;
  • blocking server start with Run;
  • context-aware graceful shutdown with RunContext;
  • native http.Handler escape hatches;
  • kora new, hot-reloading kora dev, kora routes, and application-owned migration commands;
  • controller, middleware, and request generators;
  • a minimal application starter with a health endpoint and test;
  • race-tested core and CLI with an enforced 85% coverage floor;
  • no third-party runtime dependencies.

Quick start

Install the CLI:

go install github.com/LoonY20/Kora/cmd/kora@latest

For reproducible installation, pin the current release:

go install github.com/LoonY20/Kora/cmd/kora@v0.2.0

Create and run an application:

kora new hello-kora
cd hello-kora
go mod tidy
kora dev

Inspect its routes:

kora routes

Or add Kora to an existing module:

Install the module:

go get github.com/LoonY20/Kora@v0.2.0

Create an application:

package main

import (
    "log"
    "net/http"

    "github.com/LoonY20/Kora"
)

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

app.Get("/users/{id}", func(ctx *kora.Context) error {
        ctx.Logger().Info("show user", "user_id", ctx.Param("id"))

        return ctx.JSON(http.StatusOK, map[string]string{
            "id": ctx.Param("id"),
        })
    }).Named("users.show")

    if err := app.Run(":8080"); err != nil {
        log.Fatal(err)
    }
}

Build a URL from its route name:

path, err := app.URL("users.show", map[string]string{"id": "42"})

Every request receives an X-Request-ID response header. The same ID is available through ctx.RequestID() and is automatically attached to ctx.Logger() together with the request method and path.

Service container

Kora can wire ordinary Go constructors without field injection or hidden service lookups.

type UserRepository interface {
    Find(ctx context.Context, id int64) (*User, error)
}

type PostgresUserRepository struct{}

type UserService struct {
    users UserRepository
}

func NewPostgresUserRepository() *PostgresUserRepository {
    return &PostgresUserRepository{}
}

func NewUserService(users UserRepository) *UserService {
    return &UserService{users: users}
}

Register the interface binding and dependent service:

if err := kora.ProvideAs[UserRepository](app, NewPostgresUserRepository); err != nil {
    return err
}

if err := app.Provide(NewUserService); err != nil {
    return err
}

Resolve the root service when wiring an application boundary:

users, err := kora.Resolve[*UserService](app)
if err != nil {
    return err
}

Singleton is the default lifetime. Transient services are explicit:

app.Provide(NewRequestHandler, kora.Transient())

Existing values can also be registered:

kora.Instance(app, logger)

App.Start validates the dependency graph before startup hooks run, so missing registrations and circular dependencies fail before the server starts.

Kora uses reflection only at the service-container boundary to inspect constructor signatures and construct registered services. Dependencies remain visible in normal Go function signatures; there is no struct-field injection and no request-time container lookup hidden by the framework.

Configuration

Kora can load a typed configuration struct directly from environment variables:

type Config struct {
    App struct {
        Name  string `env:"APP_NAME" required:"true"`
        Debug bool   `env:"APP_DEBUG" default:"false"`
    }

    HTTP struct {
        Address string `env:"HTTP_ADDRESS" default:":8080"`
    }
}

config, err := kora.LoadConfig[Config]()
if err != nil {
    return err
}

For local development, load an optional .env before parsing the typed configuration:

if err := kora.LoadEnvFileIfExists(".env"); err != nil {
	return err
}
config, err := kora.LoadConfig[Config]()

Already exported environment variables take precedence over .env, which keeps deployment configuration authoritative.

The first configuration layer supports strings, booleans, integers, unsigned integers, floats, and time.Duration. Nested structs are supported. Reflection is limited to configuration loading and is not part of Kora's request runtime.

For tests or custom environment sources, use LoadConfigFromEnv with an explicit lookup function.

Structured logging and request IDs

Kora uses the standard library log/slog instead of defining a custom logging abstraction:

logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))

app := kora.New(
    kora.WithLogger(logger),
)

Inside a Kora handler:

app.Get("/", func(ctx *kora.Context) error {
    ctx.Logger().Info("request handled")
    return ctx.NoContent(http.StatusNoContent)
})

The request-scoped logger automatically includes:

request_id=<id>
method=GET
path=/

Native handlers can access the same values without using a Kora request type:

requestID := kora.RequestIDFromContext(r.Context())
logger := kora.LoggerFromContext(r.Context())

Applications may change the header or request ID format with WithRequestIDHeader and WithRequestIDGenerator.

Lifecycle

Startup hooks run in registration order. Shutdown hooks run in reverse order so resources can be released like a stack:

app.OnStart(func(ctx context.Context) error {
    return database.Ping(ctx)
})

app.OnStop(func(ctx context.Context) error {
    database.Close()
    return nil
})

RunContext executes the lifecycle around the HTTP server and performs graceful shutdown when its context is cancelled. The timeout can be configured with WithShutdownTimeout.

Route groups

Groups share a path prefix and can carry their own middleware:

app.Group("/api", func(api *kora.Router) {
    api.Use(authMiddleware)

    api.Group("/v1", func(v1 *kora.Router) {
        v1.Get("/users/{id}", showUser)
    })
})

Middleware remains ordinary Go middleware.

Errors

Handlers return errors instead of rendering the same failure response repeatedly:

func showUser(ctx *kora.Context) error {
    user, err := findUser(ctx.Context(), ctx.Param("id"))
    if err != nil {
        return kora.NotFound("user_not_found", "User not found")
    }

    return ctx.JSON(http.StatusOK, user)
}

Unexpected errors are logged through the request-scoped logger and rendered as a generic 500 response instead of leaking internal details. Applications can replace the renderer with SetErrorHandler.

Request binding and validation

Kora keeps validation explicit rather than relying on hidden runtime behavior.

type CreateUserRequest struct {
    Name  string `json:"name"`
    Email string `json:"email"`
}

func (r *CreateUserRequest) Validate() error {
    validation := kora.NewValidationError()

    if r.Name == "" {
        validation.Add("name", "is required")
    }

    if r.Email == "" {
        validation.Add("email", "is required")
    }

    return validation.OrNil()
}

Binding automatically calls Validate when the target implements kora.Validatable.

Standard Go escape hatch

Kora does not require every endpoint to use a Kora handler. Ordinary net/http handlers remain first-class:

app.HandleHTTPFunc(http.MethodGet, "/native", func(w http.ResponseWriter, r *http.Request) {
    logger := kora.LoggerFromContext(r.Context())
    logger.Info("native handler")
    w.WriteHeader(http.StatusNoContent)
})

The same is available inside route groups.

Who is Kora for?

Kora is especially aimed at developers coming from batteries-included ecosystems such as Laravel, Rails, Django, NestJS, or Spring who like Go but do not want to assemble every backend concern from scratch.

It is not intended to be Laravel reimplemented in Go. The inspiration is Laravel's developer experience, not its internals.

Direction

The core MVP and initial driver-neutral data workflow are complete, including database/sql connection management, dialect-aware migrations, PostgreSQL concurrency protection, seeders, factories, and application-owned data commands.

Next steps include additional database locks and adapters, followed by queues and workers, cache drivers, scheduling, events, mail, testing helpers, OpenAPI generation, observability, and project generators.

See the roadmap for the current direction.

Documentation

Complete example

The repository includes a dependency-free CRUD application that exercises the MVP as a coherent stack:

go run ./examples/crud

It demonstrates interface-based dependency injection, route groups, named routes, request validation, structured errors, typed configuration, graceful shutdown, and full HTTP integration tests.

Design principles

Go remains Go

Kora should compose with standard library APIs instead of creating a separate universe around them.

Explicit over magical

Prefer code that is easy to trace, profile, test, and debug.

Batteries included, parts replaceable

Kora should eventually provide a coherent default stack while allowing applications to replace infrastructure behind clear interfaces.

Great defaults, easy escape hatches

A developer should be productive quickly without losing access to net/http, context, database drivers, logging APIs, or other normal Go packages.

Contributing

Contributions and architectural discussion are welcome. Please read CONTRIBUTING.md and the Code of Conduct before contributing.

Security reports should follow SECURITY.md.

License

Kora is released under the MIT License.

Documentation

Overview

Package kora provides a small, batteries-included foundation for Go HTTP applications while preserving standard library types and conventions.

Applications are built around App: 

app := kora.New()
app.Get("/health", func(ctx *kora.Context) error {
	return ctx.JSON(http.StatusOK, map[string]string{"status": "ok"})
}).Named("health")

Kora includes routing, middleware, typed errors, request binding, validation, environment configuration, structured logging, lifecycle hooks, and explicit constructor-based dependency wiring. The underlying http.Handler, http.Request, http.ResponseWriter, context.Context, error, and slog APIs remain directly accessible.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Instance 

func Instance[T any](app *App, value T) error

Instance registers an existing value under T as a singleton.

func JSON 

func JSON(w http.ResponseWriter, status int, value any) error

JSON writes value as a JSON response with the provided status code. The value is encoded before headers are committed, so serialization errors can still be handled by the caller.

func LoadConfig 

func LoadConfig[T any]() (T, error)

LoadConfig loads a typed configuration struct from environment variables. Fields opt in with `env:"KEY"`. The optional `default` tag supplies a fallback, and `required:"true"` rejects missing or empty values.

func LoadConfigFromEnv 

func LoadConfigFromEnv[T any](lookup EnvLookup) (T, error)

LoadConfigFromEnv is LoadConfig with a replaceable environment lookup function. It is useful for tests and custom environment sources.

func LoadEnvFile added in v0.2.0 

func LoadEnvFile(path string) error

LoadEnvFile loads KEY=VALUE entries into the process environment.

Existing environment variables take precedence over file values. Blank lines and comments are ignored. Values may be unquoted, single-quoted, or double-quoted.

func LoadEnvFileIfExists added in v0.2.0 

func LoadEnvFileIfExists(path string) error

LoadEnvFileIfExists loads an environment file when it exists.

func LoggerFromContext 

func LoggerFromContext(ctx context.Context) *slog.Logger

LoggerFromContext returns the request-scoped logger when available. It falls back to slog.Default for contexts not created by Kora.

func ProvideAs 

func ProvideAs[T any](app *App, constructor any, options ...ServiceOption) error

ProvideAs registers a constructor under T, commonly an interface implemented by the constructor's concrete return type.

func RequestIDFromContext 

func RequestIDFromContext(ctx context.Context) string

RequestIDFromContext returns the Kora request ID stored in a standard context.Context. It is useful from native net/http handlers and lower-level application code.

func Resolve 

func Resolve[T any](app *App) (T, error)

Resolve builds or returns the service registered for T.

Types

type App 

type App struct {
	// contains filtered or unexported fields
}

App is the root Kora application.

func New 

func New(options ...Option) *App

New creates a new Kora application backed by the standard library ServeMux.

func (*App) Delete 

func (a *App) Delete(pattern string, handler HandlerFunc) *Route

Delete registers a DELETE route.

func (*App) Get 

func (a *App) Get(pattern string, handler HandlerFunc) *Route

Get registers a GET route.

func (*App) Group 

func (a *App) Group(prefix string, configure func(*Router))

Group creates a route group rooted at prefix.

func (*App) Handle 

func (a *App) Handle(method, pattern string, handler HandlerFunc) *Route

Handle registers a Kora handler for an HTTP method and route pattern. Route patterns use the Go standard library ServeMux syntax.

func (*App) HandleHTTP 

func (a *App) HandleHTTP(method, pattern string, handler http.Handler) *Route

HandleHTTP registers an ordinary http.Handler without wrapping it in a Kora Context. Application-wide middleware still applies.

func (*App) HandleHTTPFunc 

func (a *App) HandleHTTPFunc(method, pattern string, handler http.HandlerFunc) *Route

HandleHTTPFunc registers an ordinary http.HandlerFunc.

func (*App) Handler 

func (a *App) Handler() http.Handler

Handler returns the final HTTP handler including Kora request context and application middleware.

func (*App) Logger 

func (a *App) Logger() *slog.Logger

Logger returns the application's base structured logger.

func (*App) NamedRoute 

func (a *App) NamedRoute(name string) (Route, bool)

NamedRoute returns a copy of the route registered with name.

func (*App) OnStart 

func (a *App) OnStart(hooks ...LifecycleHook)

OnStart registers startup hooks. Hooks run in registration order.

func (*App) OnStop 

func (a *App) OnStop(hooks ...LifecycleHook)

OnStop registers shutdown hooks. Hooks run in reverse registration order.

func (*App) Patch 

func (a *App) Patch(pattern string, handler HandlerFunc) *Route

Patch registers a PATCH route.

func (*App) Post 

func (a *App) Post(pattern string, handler HandlerFunc) *Route

Post registers a POST route.

func (*App) Provide 

func (a *App) Provide(constructor any, options ...ServiceOption) error

Provide registers a constructor in the application's service container.

func (*App) Put 

func (a *App) Put(pattern string, handler HandlerFunc) *Route

Put registers a PUT route.

func (*App) Routes 

func (a *App) Routes() []Route

Routes returns a stable snapshot of registered routes in declaration order.

func (*App) Run 

func (a *App) Run(address string) error

Run starts an HTTP server and blocks until it stops.

func (*App) RunContext 

func (a *App) RunContext(ctx context.Context, address string) error

RunContext starts an HTTP server and gracefully shuts it down when ctx is cancelled.

func (*App) ServeHTTP 

func (a *App) ServeHTTP(w http.ResponseWriter, r *http.Request)

ServeHTTP lets App satisfy http.Handler.

func (*App) Services 

func (a *App) Services() *Container

Services returns the application's service container.

func (*App) SetErrorHandler 

func (a *App) SetErrorHandler(handler ErrorHandler)

SetErrorHandler replaces the application error handler. Passing nil restores Kora's default JSON error handler.

func (*App) SortedRoutes 

func (a *App) SortedRoutes() []Route

SortedRoutes returns routes sorted by pattern and method for deterministic output.

func (*App) Start 

func (a *App) Start(ctx context.Context) error

Start validates the service graph, then runs all registered startup hooks.

func (*App) Stop 

func (a *App) Stop(ctx context.Context) error

Stop runs all registered shutdown hooks in reverse order. All hooks are attempted and their errors are joined.

func (*App) URL 

func (a *App) URL(name string, params map[string]string) (string, error)

URL builds a path for a named route. Parameters replace ServeMux wildcards.

func (*App) Use 

func (a *App) Use(middleware ...Middleware)

Use registers application-wide middleware. Middleware executes in the same order it is registered.

type Container 

type Container struct {
	// contains filtered or unexported fields
}

Container stores application service providers and resolves their dependency graph.

func NewContainer 

func NewContainer() *Container

NewContainer creates an empty service container.

func (*Container) Provide 

func (c *Container) Provide(constructor any, options ...ServiceOption) error

Provide registers a constructor under its concrete output type. Constructors may return either T or (T, error).

func (*Container) Validate 

func (c *Container) Validate() error

Validate checks the full dependency graph without invoking constructors.

type Context 

type Context struct {
	Response http.ResponseWriter
	Request  *http.Request
}

Context exposes Kora conveniences while keeping the underlying net/http types available.

func NewContext 

func NewContext(w http.ResponseWriter, r *http.Request) *Context

NewContext creates a Kora request context around standard library HTTP types.

func (*Context) BindJSON 

func (c *Context) BindJSON(target any) error

BindJSON decodes a JSON request body into target. Unknown JSON fields are rejected. If target implements Validatable, validation runs automatically after a successful decode.

func (*Context) Context 

func (c *Context) Context() context.Context

Context returns the request's standard context.Context.

func (*Context) JSON 

func (c *Context) JSON(status int, value any) error

JSON writes a JSON response.

func (*Context) Logger 

func (c *Context) Logger() *slog.Logger

Logger returns the request-scoped slog logger. The logger includes request_id, method, and path attributes.

func (*Context) NoContent 

func (c *Context) NoContent(status int) error

NoContent writes a status code without a response body.

func (*Context) Param 

func (c *Context) Param(name string) string

Param returns a path parameter captured by the standard library ServeMux.

func (*Context) RequestID 

func (c *Context) RequestID() string

RequestID returns the request ID assigned by Kora.

type EnvLookup 

type EnvLookup func(string) (string, bool)

EnvLookup resolves an environment variable by key.

type ErrorHandler 

type ErrorHandler func(*Context, error)

ErrorHandler converts handler errors into HTTP responses.

type HTTPError 

type HTTPError struct {
	Status  int
	Code    string
	Message string
	Cause   error
}

HTTPError represents an expected HTTP failure.

func BadRequest 

func BadRequest(code, message string) *HTTPError

BadRequest creates a 400 HTTP error.

func Conflict 

func Conflict(code, message string) *HTTPError

Conflict creates a 409 HTTP error.

func Forbidden 

func Forbidden(code, message string) *HTTPError

Forbidden creates a 403 HTTP error.

func NewHTTPError 

func NewHTTPError(status int, code, message string) *HTTPError

NewHTTPError creates an expected HTTP error.

func NotFound 

func NotFound(code, message string) *HTTPError

NotFound creates a 404 HTTP error.

func Unauthorized 

func Unauthorized(code, message string) *HTTPError

Unauthorized creates a 401 HTTP error.

func (*HTTPError) Error 

func (e *HTTPError) Error() string

Error implements the error interface.

func (*HTTPError) Unwrap 

func (e *HTTPError) Unwrap() error

Unwrap exposes the underlying cause for errors.Is/errors.As.

func (*HTTPError) WithCause 

func (e *HTTPError) WithCause(err error) *HTTPError

WithCause attaches an internal cause while preserving the public HTTP response.

type HandlerFunc 

type HandlerFunc func(*Context) error

HandlerFunc is a Kora handler. Returning an error delegates response handling to the application's ErrorHandler.

type LifecycleHook 

type LifecycleHook func(context.Context) error

LifecycleHook runs during application startup or shutdown.

type Lifetime 

type Lifetime uint8

Lifetime controls how often a service constructor is invoked. 

const (
	// SingletonLifetime creates a service once and reuses it for subsequent resolutions.
	SingletonLifetime Lifetime = iota
	// TransientLifetime creates a new service for every resolution.
	TransientLifetime
)

type Middleware 

type Middleware func(http.Handler) http.Handler

Middleware wraps an HTTP handler with additional behavior.

type Option 

type Option func(*App)

Option configures an App during construction.

func WithLogger 

func WithLogger(logger *slog.Logger) Option

WithLogger configures the application's base slog logger.

func WithRequestIDGenerator 

func WithRequestIDGenerator(generator func() string) Option

WithRequestIDGenerator replaces the request ID generator. This is useful when applications need a specific ID format.

func WithRequestIDHeader 

func WithRequestIDHeader(header string) Option

WithRequestIDHeader changes the HTTP header used for request IDs.

func WithShutdownTimeout 

func WithShutdownTimeout(timeout time.Duration) Option

WithShutdownTimeout configures the timeout used for graceful HTTP shutdown and lifecycle stop hooks.

type Route 

type Route struct {
	Method  string
	Pattern string
	Name    string
	// contains filtered or unexported fields
}

Route describes a registered HTTP route.

func (*Route) Named 

func (r *Route) Named(name string) *Route

Named assigns a unique name to a route and returns it for fluent setup.

type Router 

type Router struct {
	// contains filtered or unexported fields
}

Router represents a route group with a shared prefix and middleware stack.

func (*Router) Delete 

func (r *Router) Delete(pattern string, handler HandlerFunc) *Route

func (*Router) Get 

func (r *Router) Get(pattern string, handler HandlerFunc) *Route

func (*Router) Group 

func (r *Router) Group(prefix string, configure func(*Router))

Group creates a nested route group.

func (*Router) Handle 

func (r *Router) Handle(method, pattern string, handler HandlerFunc) *Route

Handle registers a Kora handler on the group.

func (*Router) HandleHTTP 

func (r *Router) HandleHTTP(method, pattern string, handler http.Handler) *Route

HandleHTTP registers an ordinary http.Handler on the group.

func (*Router) HandleHTTPFunc 

func (r *Router) HandleHTTPFunc(method, pattern string, handler http.HandlerFunc) *Route

HandleHTTPFunc registers an ordinary http.HandlerFunc on the group.

func (*Router) Patch 

func (r *Router) Patch(pattern string, handler HandlerFunc) *Route

func (*Router) Post 

func (r *Router) Post(pattern string, handler HandlerFunc) *Route

func (*Router) Put 

func (r *Router) Put(pattern string, handler HandlerFunc) *Route

func (*Router) Use 

func (r *Router) Use(middleware ...Middleware)

Use registers middleware for routes declared on this group and its child groups.

type ServiceOption 

type ServiceOption func(*serviceOptions)

ServiceOption configures a service registration.

func Singleton 

func Singleton() ServiceOption

Singleton explicitly configures a provider as a singleton. Singleton is also the default lifetime.

func Transient 

func Transient() ServiceOption

Transient configures a provider to build a new value on every resolution.

type Validatable 

type Validatable interface {
	Validate() error
}

Validatable can be implemented by request DTOs that want BindJSON to run explicit application validation after decoding.

type ValidationError 

type ValidationError struct {
	Fields map[string][]string `json:"fields"`
}

ValidationError contains field-level validation messages.

func NewValidationError 

func NewValidationError() *ValidationError

NewValidationError creates an empty validation error collection.

func (*ValidationError) Add 

func (e *ValidationError) Add(field, message string) *ValidationError

Add appends a validation message for field and returns the same collection.

func (*ValidationError) Error 

func (e *ValidationError) Error() string

Error implements the error interface.

func (*ValidationError) OrNil 

func (e *ValidationError) OrNil() error

OrNil returns nil when no validation messages were added.

Source Files

View all Source files

Directories

Path Synopsis
cmd
kora command
Package data composes Kora's database application commands.
 Package data composes Kora's database application commands.
Package database integrates standard library database/sql connections with Kora configuration, dependency injection, and application lifecycle.
 Package database integrates standard library database/sql connections with Kora configuration, dependency injection, and application lifecycle.
examples
basic command
Command basic demonstrates a minimal Kora HTTP application.
 Command basic demonstrates a minimal Kora HTTP application.
crud command
Command crud runs the complete in-memory Kora CRUD example.
 Command crud runs the complete in-memory Kora CRUD example.
Package factory builds deterministic test data without requiring an ORM.
 Package factory builds deterministic test data without requiring an ORM.
internal
cli
Package cli implements the Kora developer command.
 Package cli implements the Kora developer command.
Package migrate provides dialect-aware, transactional SQL migrations on top of database/sql.
 Package migrate provides dialect-aware, transactional SQL migrations on top of database/sql.
Package seed executes ordered, transactional database seeders.
 Package seed executes ordered, transactional database seeders.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.