Skip to main content

Ecosystem Packages

Kuetix Engine is built on a set of lightweight, reusable Go modules. They are split into two groups:

  • Core modules — required by the engine; pulled in automatically via go.mod when you depend on github.com/kuetix/engine.
  • Standard library modules (std-*) — optional building blocks shipping .wsl workflows + Go transitions for common concerns (authentication, HTTP serving, CLI registration, …). Install one when you need it.
ModuleGroupPurpose
github.com/kuetix/containerCoreThread-safe DI container
github.com/kuetix/helpersCoreShared helper functions
github.com/kuetix/loggerCoreStructured logging
github.com/kuetix/uuidCoreDeterministic UUIDv5 helpers
github.com/kuetix/std-coreStdlibCommon transitions (responses, assertions, entities, datetime, pagination, …)
github.com/kuetix/std-cliStdlibCLI command-registration transitions used by kue
github.com/kuetix/std-authStdlibJWT and password-auth transitions + workflows
github.com/kuetix/std-httpStdlibHTTP server / workflow router

Core Modules​

kuetix/container​

A tiny, thread-safe dependency injection container for Go.

Module: github.com/kuetix/container

Install:

go get github.com/kuetix/container

Features​

  • Simple singleton storage (ToFetch / Fetch)
  • Factory-based resolution (ToResolve / Resolve)
  • Lightweight parameters store (ToParameter / Parameter)
  • Thread-safe with sync.RWMutex protection
  • Combined lookup via Get

Quick Start​

import c "github.com/kuetix/container"

// Register a singleton
c.ToFetch("app.name", "demo-app")

// Register a factory (called on each Resolve)
c.ToResolve("time.now", func() interface{} {
    return time.Now().String()
})

// Register a parameter
c.ToParameter("http.port", 8080)

// Read values
name := c.Fetch("app.name")         // "demo-app"
now := c.Resolve("time.now")        // calls factory each time
port := c.Parameter("http.port")    // 8080
value := c.Get("app.name")          // checks singletons, then factories

API Reference​

FunctionDescription
ToFetch(key, value)Register a singleton
ToFetchFunc(key, factory)Register a singleton from a factory (eager)
Fetch(key)Retrieve a singleton (panics if missing)
ToResolve(key, factory)Register a factory
Resolve(key)Call a factory (panics if missing)
Get(key)Lookup singletons first, then factories
ToParameter(key, value)Register a parameter
Parameter(key)Retrieve a parameter (panics if missing)
Has(key)Check if key exists in any registry
CanFetch(key)Check if singleton exists
CanResolve(key)Check if factory exists
HasParameter(key)Check if parameter exists
Reset()Clear all registries (for testing)

Usage in Kuetix Engine​

The engine uses kuetix/container as its core DI framework. Module transitions, services, and configurations are all registered and resolved through this container. The generated modules/di.go file registers all module transitions using ToResolve.

kuetix/helpers​

Shared helper functions used internally by the engine and exposed for reuse.

Module: github.com/kuetix/helpers

Install:

go get github.com/kuetix/helpers

Used by the engine for string/map/file utilities and by generated modules/di.go / modules/meta.go files.

kuetix/logger​

Structured logger used throughout the engine and ecosystem packages.

Module: github.com/kuetix/logger

Install:

go get github.com/kuetix/logger

Usage​

import "github.com/kuetix/logger"

logger.Debug("Debug message")
logger.Info("Info message")
logger.Warn("Warning message")
logger.Error("Error message")
logger.Fatalf("Fatal: %v", err)

kuetix/uuid​

Small utilities around UUID generation and formatting, built on top of github.com/google/uuid.

Module: github.com/kuetix/uuid

Install:

go get github.com/kuetix/uuid

API Reference​

import kuuid "github.com/kuetix/uuid"

// Deterministic UUIDv5 derived from an identity string
u := kuuid.IdV5("example")

// Canonical UUID string (XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX)
canonical := kuuid.UUId("example")

// Dashless hex (32 chars)
hex := kuuid.Id("example")

// Base64 encoding of the 16-byte UUID
b64 := kuuid.Base64Id("example")

// Remove dashes from a canonical UUID string
clean := kuuid.UId(u.String())
FunctionDescriptionOutput Format
IdV5(identity)Deterministic UUIDv5 from stringuuid.UUID
UUId(identity)Canonical UUID stringxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
Id(identity)Dashless hex stringxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Base64Id(identity)Base64-encoded UUID bytesBase64 string
UId(uuidString)Remove dashes from UUIDxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Usage in Kuetix Engine​

The engine uses kuetix/uuid for generating deterministic identifiers from entity keys, used in workflow context resolution and the helpers.Id() template function.

Standard Library Modules​

These are optional plug-in packages distributed alongside the engine. Each is its own Go module, ships its own WSL workflows under workflows/, and registers Go transitions under modules/.

kuetix/std-core​

Common transitions used by virtually every project: responses, assertions, entity helpers, datetime utilities, pagination, context manipulation.

Module: github.com/kuetix/std-core

Install:

kue package install std-core

Or via Go directly when consuming the package as a library:

go get github.com/kuetix/std-core

kuetix/std-cli​

CLI command-registration transitions used by kue and any other CLI app built on the engine.

Module: github.com/kuetix/std-cli

Install:

kue package install std-cli

kuetix/std-auth​

JWT generation/validation/refresh and password hashing transitions with companion .wsl workflows (login, register, reset_password, …).

Module: github.com/kuetix/std-auth

Install:

kue package install std-auth

Environment variables consumed:

  • JWT_SECRET (required — the package refuses to start without it)
  • JWT_ISSUER, JWT_AUDIENCE (optional)

kuetix/std-http​

HTTP server, CORS handling, route registration, and a transition that maps HTTP requests to WSL workflows.

Module: github.com/kuetix/std-http

Install:

kue package install std-http