factory

Factory

The Factory package implements the Factory design pattern for various components of the Boost framework, facilitating the creation and configuration of complex objects. This package is fundamental to the modular and extensible architecture of the framework.

Overview

Factory provides a standardized approach to instantiate objects, allowing client code to request objects without knowing the specific details of how they are created. This promotes decoupling between components and facilitates system extensibility.

Main Components

Core

The core subpackage contains factory implementations for fundamental system components, organized into categories:

• Database: Factories for database connections and operations
• Net: Components related to networks and communication
• Time: Utilities related to time and scheduling

Contrib

The contrib directory contains factory implementations for integration with third-party libraries and frameworks, including:

• gRPC: For communication between services
• go-chi/chi: net/http router (v5)
• gofiber/fiber: fasthttp web framework (v2)
• valyala/fasthttp: fasthttp client (v1)
• mittwald/vaultgo: Vault client and credential managers for redis, elasticsearch and mongo (v0)
• Azure (azure-sdk-for-go): token credential and Blob Storage client (v1)
• storj/drpc: lightweight drop-in replacement for gRPC, server and client (v1)
• MCP (modelcontextprotocol/go-sdk): Model Context Protocol server and client
• Google Cloud Platform (GCP): Integration with GCP services
• Confluent: For working with Apache Kafka
• segmentio/kafka-go: Apache Kafka in pure Go (no cgo)
• Ollama: Integration with AI models
• Spf13/Cobra: For creating command-line interfaces

Local

The local subpackage provides specific implementations for local use or development environments, facilitating testing and rapid prototyping.

How to Use

To use the Factory package in your application:

1. Import the specific subpackage that contains the desired factory
2. Configure the necessary parameters
3. Use the factory to create instances of the required objects

Plugins

Factories accept plugins as a variadic argument and run them right after building the component. The contract lives in this package:

// Plugin customizes a component T built by a factory.
type Plugin[T any] func(context.Context, T) error

// ApplyPlugins runs plugins in order and stops at the first error.
func ApplyPlugins[T any](ctx context.Context, target T, plugins ...Plugin[T]) error

The per-factory plugin types are aliases of it, so a plugin written against either name is interchangeable:

Factories whose plugins have a different shape (gRPC, NATS, Hystrix, the mongo Plugin pair) keep their own types.

Plugin packages sit under each factory's plugins/ directory: contrib/ integrates a third-party library, native/ wraps the upstream library's own middleware, extra/ is boost-authored and generic, and local/ wires another boost package (health, log, cache).

The gocql health checker (contrib/gocql/gocql/v1/plugins/local/extra/health) runs SELECT now() FROM system.local with the context of the check, a query every cassandra and scylla node answers.

Integration with Other Packages

The Factory integrates with other components of the Boost framework:

• Bootstrap: For application initialization
• Wrapper: For configuration and logging
• Model: For data structure definitions

Extensibility

The Factory package was designed to be easily extensible. To add support for new libraries or frameworks:

1. Create a new subpackage in contrib with the name of the library
2. Implement the necessary factory interfaces
3. Add appropriate tests and documentation

Contribution

Contributions to the Factory package are welcome. When contributing, make sure to follow the code standards and add appropriate tests for new functionalities.