Samber Do

https://pkg.go.dev/github.com/samber/do/v2
Admin
Samber Do is a Go package that provides a dependency injection (DI) framework for managing and...
Tokens:59,044
Snippets:478
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install do v2 and v1

Source: https://pkg.go.dev/github.com/samber/do/v2/index

Installs the 'do' dependency injection package. It shows commands for both the latest v2 and the older v1 versions using 'go get'.

```bash
# v2 (latest)
go get github.com/samber/do@v2

# v1
go get github.com/samber/do
```

--------------------------------

### Example: Creating and Providing a Service

Source: https://pkg.go.dev/github.com/samber/do/v2/index

This example shows how to create a new DI container using `do.New()`, then register a service (`MyService`) using a provider function. The provider is a simple anonymous function that returns a new `MyService` instance.

```go
injector := do.New()
do.Provide(injector, func(i do.Injector) (*MyService, error) {
    return &MyService{}, nil
})


```

--------------------------------

### Example: Registering a Service Provider

Source: https://pkg.go.dev/github.com/samber/do/v2/index

This example demonstrates how to define a provider function for a service and then register it with the dependency injection container. The provider function `NewMyService` takes an `Injector` to resolve its dependencies (`Database` and `Config`) and returns a `MyService` instance.

```go
func NewMyService(i do.Injector) (*MyService, error) {
    db := do.MustInvoke[*Database](i)
    config := do.MustInvoke[*Config](i)
    return &MyService{DB: db, Config: config}, nil
}

// Register the provider
do.Provide(injector, NewMyService)

```

--------------------------------

### Get Service Description - Go

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

Represents metadata about a registered service, including its scope and name.

```go
type ServiceDescription struct {
	ScopeID   string
	ScopeName string
	Service   string
}
```

--------------------------------

### Explain Injector Structure and Contents (Go)

Source: https://pkg.go.dev/github.com/samber/do/v2/index

The ExplainInjector function provides a human-readable description of an injector's structure, including its services and scope tree. It visualizes the hierarchy of scopes and services within the injector. This function is useful for debugging and understanding complex dependency injection setups.

```Go
func ExplainInjector(scope Injector) ExplainInjectorOutput
```

```Go
explanation := do.ExplainInjector(injector)
fmt.Println(explanation.String())
```

--------------------------------

### Go: Analyze Dependency Graph

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

This code defines structures and functions for analyzing the dependency graph of services within the go-dependency-injection framework. It allows for detailed inspection of scopes, services, and their interdependencies, providing insights into the structure and health of the dependency injection setup.

```go
type DAG []ExplainInjectorScopeOutput
type ExplainInjectorOutput struct { ScopeID string; ScopeName string; DAG DAG }
type ExplainInjectorScopeOutput struct { Children []ExplainInjectorScopeOutput; IsAncestor bool; IsChildren bool; Scope Injector; ScopeID string; ScopeName string; Services []ExplainInjectorServiceOutput }
type ExplainInjectorServiceOutput struct { IsHealthchecker bool; IsShutdowner bool; ServiceBuildTime time.Duration; ServiceName string; ServiceType ServiceType; ServiceTypeIcon string }
func ExplainInjector(scope Injector) ExplainInjectorOutput
func (ids *ExplainInjectorScopeOutput) String() string
func (idss *ExplainInjectorServiceOutput) String() string
```

--------------------------------

### Utility Functions in Go

Source: https://pkg.go.dev/github.com/samber/do/v2/index

Provides utility functions such as `NameOf` to get the string name of a type, and `Package` to group multiple provider functions into a single injector configuration function.

```go
func NameOf[T any]() string
func Package(services ...func(i Injector)) func(Injector)
```

--------------------------------

### Get Parent Scopes - Go

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

Retrieves a slice of all ancestor scopes, starting from the immediate parent up to the root scope. Useful for navigating up the hierarchy.

```go
func (s *RootScope) Ancestors() []*Scope
```

```go
func (s *Scope) Ancestors() []*Scope
```

--------------------------------

### Go: RootScope Initialization

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2

Functions for creating new RootScope instances, the entry point for dependency injection. Supports optional initialization packages.

```go
func New(packages ...func(Injector)) *RootScope
func NewWithOpts(opts *InjectorOpts, packages ...func(Injector)) *RootScope
```

--------------------------------

### Format Service Explanation (Go)

Source: https://pkg.go.dev/github.com/samber/do/v2/index

The String method on ExplainServiceOutput provides a formatted, human-readable string representation of the service explanation, including details about its scope, type, build time, and dependencies.

```go
func (sd *ExplainServiceOutput) String() string
```

--------------------------------

### Get Scope Name - Go

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

Retrieves the name of the current scope.

```go
func (s *RootScope) Name() string
```

```go
func (s *Scope) Name() string
```

--------------------------------

### Get Scope ID - Go

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

Returns the unique identifier string for the current scope.

```go
func (s *RootScope) ID() string
```

```go
func (s *Scope) ID() string
```

--------------------------------

### Format Injector Explanation as String (Go)

Source: https://pkg.go.dev/github.com/samber/do/v2/index

The String method for ExplainInjectorOutput formats the injector explanation into a human-readable string. It presents the scope hierarchy and all services in a tree-like structure, making it easy to interpret the injector's configuration.

```Go
func (id *ExplainInjectorOutput) String() string
```

--------------------------------

### Format Service Explanation as String (Go)

Source: https://pkg.go.dev/github.com/samber/do/v2/index

The String method for ExplainInjectorServiceOutput returns a formatted string representing a service. It displays the service's type icon and capability indicators, providing a concise summary of the service's properties.

```Go
func (idss *ExplainInjectorServiceOutput) String() string
```

--------------------------------

### Explainability Functions

Source: https://pkg.go.dev/github.com/samber/do/v2/index

Functions for inspecting and explaining the dependency injection graph.

```APIDOC
## Explainability

### `ExplainInjector(scope Injector) ExplainInjectorOutput`

**Description**: Explains the structure and services within an injector scope.

**Method**: Not applicable (function call)

**Endpoint**: Not applicable

### `(id *ExplainInjectorOutput) String() string`

**Description**: Returns a string representation of the injector explanation output.

**Method**: Not applicable (method call)

**Endpoint**: Not applicable

### `(ids *ExplainInjectorScopeOutput) String() string`

**Description**: Returns a string representation of the injector scope explanation output.

**Method**: Not applicable (method call)

**Endpoint**: Not applicable

### `(idss *ExplainInjectorServiceOutput) String() string`

**Description**: Returns a string representation of the injector service explanation output.

**Method**: Not applicable (method call)

**Endpoint**: Not applicable

### `(sdd *ExplainServiceDependencyOutput) String() string`

**Description**: Returns a string representation of the service dependency explanation output.

**Method**: Not applicable (method call)

**Endpoint**: Not applicable

### `ExplainNamedService(scope Injector, name string) (description ExplainServiceOutput, ok bool)`

**Description**: Explains a specific named service within an injector scope.

**Method**: Not applicable (function call)

**Endpoint**: Not applicable

### `ExplainService[T any](i Injector) (description ExplainServiceOutput, ok bool)`

**Description**: Explains a service of type T within an injector.

**Method**: Not applicable (function call)

**Endpoint**: Not applicable

### `(sd *ExplainServiceOutput) String() string`

**Description**: Returns a string representation of the service explanation output.

**Method**: Not applicable (method call)

**Endpoint**: Not applicable

```

--------------------------------

### AddBeforeRegistrationHook - Add Hook

Source: https://pkg.go.dev/github.com/samber/do/v2/index

Adds a hook that will be called before a service is registered. This can be used for validation or setup prior to registration.

```APIDOC
## AddBeforeRegistrationHook

### Description
Adds a hook that executes before a service is registered.

### Method
`AddBeforeRegistrationHook`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **hook** (func(*Scope, string)) - Required - The callback function to execute before registration.

### Request Example
```go
s.AddBeforeRegistrationHook(func(scope *do.Scope, serviceName string) {
    // Handle pre-registration logic
})
```

### Response
#### Success Response (200)
None (operation modifies the injector state)

#### Response Example
None
```

--------------------------------

### Go Scope: Get Scope Name

Source: https://pkg.go.dev/github.com/samber/do/v2/index

Retrieves the human-readable name of the scope. This name is immutable and set during scope creation.

```go
func (s *Scope) Name() string
```

--------------------------------

### List Provided Services - Go

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

Returns a list of descriptions for all services that are provided (i.e., can be injected) by this scope and its children. Each description includes scope and service details.

```go
func (s *RootScope) ListProvidedServices() []ServiceDescription
```

```go
func (s *Scope) ListProvidedServices() []ServiceDescription
```

--------------------------------

### Create New Dependency Injection Container with Options

Source: https://pkg.go.dev/github.com/samber/do/v2/index

Initializes a new dependency injection container with customizable options such as logging, hooks, and health check configurations. It accepts optional package functions to be executed during initialization.

```go
func NewWithOpts(opts *InjectorOpts, packages ...func(Injector)) *RootScope
```

```go
opts := &do.InjectorOpts{
    Logf: func(format string, args ...any) {
        log.Printf(format, args...)
    },
    HealthCheckParallelism: 10,
}
injector := do.NewWithOpts(opts)
```

--------------------------------

### Get Root Scope - Go

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

Returns the top-level RootScope from any given scope. This allows access to global configurations or services.

```go
func (s *RootScope) RootScope() *RootScope
```

```go
func (s *Scope) RootScope() *RootScope
```

--------------------------------

### NewWithOpts - Initialize Injector

Source: https://pkg.go.dev/github.com/samber/do/v2/index

Creates a new dependency injection container with custom options. This allows for configuration of logging, hooks, health check settings, and other options.

```APIDOC
## NewWithOpts

### Description
Creates a new dependency injection container with custom options, allowing configuration of logging, hooks, health checks, and more.

### Method
`NewWithOpts`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **opts** (*InjectorOpts) - Required - Configuration options for the injector.
* **packages** (...func(Injector)) - Optional - Package functions to execute during initialization.

### Request Example
```go
opts := &do.InjectorOpts{
    Logf: func(format string, args ...any) {
        log.Printf(format, args...)
    },
    HealthCheckParallelism: 10,
}
injector := do.NewWithOpts(opts)
```

### Response
#### Success Response (200)
* **RootScope** (*RootScope) - A new instance of the dependency injection container.

#### Response Example
(Instance of *RootScope)
```

--------------------------------

### Get Scope by ID - Go

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

Retrieves a child scope by its unique identifier. Returns the scope and a boolean indicating if it was found.

```go
func (s *RootScope) ChildByID(id string) (*Scope, bool)
```

```go
func (s *Scope) ChildByID(id string) (*Scope, bool)
```

--------------------------------

### Run tests and watch tests with make

Source: https://pkg.go.dev/github.com/samber/do/v2/index

Commands to run tests for the project using 'make'. It includes a command to continuously run tests as files change ('watch-test').

```bash
# Run tests
make test
# or
make watch-test
```

--------------------------------

### Get Scope by Name (RootScope) - Go

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

Retrieves a child scope from the root scope by its name. This is a convenient way to access specific sub-containers.

```go
func Scope(string, ...func(Injector)) *Scope
```

--------------------------------

### Go: Explain Individual Service Dependencies

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

This section provides functions to explain the dependencies and dependents of a specific service within the go-dependency-injection system. It allows for detailed information retrieval about a service's position in the dependency graph, including its build time and type.

```go
type ExplainServiceDependencyOutput struct { Recursive []ExplainServiceDependencyOutput; ScopeID string; ScopeName string; Service string }
type ExplainServiceOutput struct { Dependencies []ExplainServiceDependencyOutput; Dependents []ExplainServiceDependencyOutput; Invoked *stacktrace.Frame; ServiceBuildTime time.Duration; ServiceName string; ServiceType ServiceType; ScopeID string; ScopeName string }
func ExplainService[T any](i Injector) (description ExplainServiceOutput, ok bool)
func ExplainNamedService(scope Injector, name string) (description ExplainServiceOutput, ok bool)
func (sdd *ExplainServiceDependencyOutput) String() string
func (sd *ExplainServiceOutput) String() string
```

--------------------------------

### Get Scope by Name - Go

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

Finds and returns a child scope using its registered name. It returns the scope and a boolean indicating success.

```go
func (s *RootScope) ChildByName(name string) (*Scope, bool)
```

```go
func (s *Scope) ChildByName(name string) (*Scope, bool)
```

--------------------------------

### Go: Dependency Injection Graph Explanation

Source: https://pkg.go.dev/github.com/samber/do/v2/index_tab=versions

Provides structures and functions to explain and visualize the dependency injection graph. This includes detailed output for scopes, services, and their dependencies, aiding in debugging and understanding complex DI structures.

```go
package main

import (
	"context"
	"time"
	"github.com/samber/do/v2"
	"github.com/samber/do/v2/stacktrace"
)

// ServiceType represents the type of a service.
type ServiceType string

// ExplainServiceDependencyOutput describes a service dependency.
type ExplainServiceDependencyOutput struct {
	Recursive  []ExplainServiceDependencyOutput
	ScopeID    string
	ScopeName  string
	Service    string
}

func (sdd *ExplainServiceDependencyOutput) String() string {
	return ""
}

// ExplainInjectorServiceOutput describes a service within an injector scope.
type ExplainInjectorServiceOutput struct {
	IsHealthchecker  bool
	IsShutdowner     bool
	ServiceBuildTime time.Duration
	ServiceName      string
	ServiceType      ServiceType
	ServiceTypeIcon  string
}

func (idss *ExplainInjectorServiceOutput) String() string {
	return ""
}

// ExplainInjectorScopeOutput describes a scope within the injector graph.
type ExplainInjectorScopeOutput struct {
	Children   []ExplainInjectorScopeOutput
	IsAncestor bool
	IsChildren bool
	Scope      do.Injector
	ScopeID    string
	ScopeName  string
	Services   []ExplainInjectorServiceOutput
}

func (ids *ExplainInjectorScopeOutput) String() string {
	return ""
}

// ExplainServiceOutput provides a detailed description of a service.
type ExplainServiceOutput struct {
	Dependencies   []ExplainServiceDependencyOutput
	Dependents     []ExplainServiceDependencyOutput
	Invoked        *stacktrace.Frame
	ScopeID        string
	ScopeName      string
	ServiceBuildTime time.Duration
	ServiceName      string
	ServiceType      ServiceType
}

func (sd *ExplainServiceOutput) String() string {
	return ""
}

// ExplainInjectorOutput represents the entire injector graph explanation.
type ExplainInjectorOutput struct {
	DAG []ExplainInjectorScopeOutput
}

func (id *ExplainInjectorOutput) String() string {
	return ""
}

// ExplainInjector explains the dependency graph of a given injector.
func ExplainInjector(scope do.Injector) ExplainInjectorOutput {
	return ExplainInjectorOutput{} // Placeholder
}

// ExplainService explains a specific service of a generic type within an injector.
func ExplainService[T any](i do.Injector) (description ExplainServiceOutput, ok bool) {
	return ExplainServiceOutput{}, false // Placeholder
}

// ExplainNamedService explains a specific named service within an injector.
func ExplainNamedService(scope do.Injector, name string) (description ExplainServiceOutput, ok bool) {
	return ExplainServiceOutput{}, false // Placeholder
}

```

--------------------------------

### Go Scope: Get Root Scope

Source: https://pkg.go.dev/github.com/samber/do/v2/index

Returns the root scope of the current scope hierarchy. All scopes within a hierarchy share the same root scope, irrespective of their depth.

```go
func (s *Scope) RootScope() *RootScope
```

--------------------------------

### Get Scope by Name with Packages - Go

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

Creates or retrieves a child scope by name, optionally applying additional package configurations. Allows for scoped dependency injection.

```go
func (s *RootScope) Scope(name string, p ...func(Injector)) *Scope
```

```go
func (s *Scope) Scope(name string, packages ...func(Injector)) *Scope
```

--------------------------------

### IndexHTML

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0.0-beta.3/http

Generates an HTML string representing the index of available services and scopes.

```APIDOC
## GET /index.html

### Description
Generates an HTML string representing the index of available services and scopes.

### Method
GET

### Endpoint
/index.html

### Parameters
#### Query Parameters
- **basePath** (string) - Required - The base path for generating URLs.

### Response
#### Success Response (200)
- **html_content** (string) - The generated HTML content.
- **error** (string) - An error message if the generation failed.
```

--------------------------------

### Generate Index HTML Page for do Debugging Interface

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0.0/http

Generates the main HTML page for the do library's web-based debugging interface. This function creates a welcome page that provides navigation to various debugging features and links to external resources like documentation and the GitHub repository. It takes a basePath for the web interface as input and returns the HTML content as a string along with any potential error.

```go
func IndexHTML(basePath string) (string, error)

// Example:
// html, err := http.IndexHTML("/debug/di")
// if err != nil {
//     log.Fatal(err)
// }
// fmt.Fprint(w, html)
```

--------------------------------

### Package do/v2 Documentation

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0.0-beta.6/tests/fixtures

This section provides documentation for the functions and types within the do/v2 package.

```APIDOC
## Package do/v2

### Index

* func GetPackage() (do.Injector, do.Injector, do.Injector)
* type Driver
*     * func (d *Driver) Shutdown()
* type Engine
*     * func (e *Engine) Shutdown()
* type Passenger
*     * func (p *Passenger) Shutdown()
* type Seat
*     * func (s *Seat) Shutdown()
* type Wheel
*     * func (w *Wheel) Shutdown()

### Constants

This section is empty.

### Variables

This section is empty.

### Functions

#### func GetPackage

```go
func GetPackage() (do.Injector, do.Injector, do.Injector)
```

### Types

#### type Driver

```go
type Driver struct {
	// contains filtered or unexported fields
}
```

#### func (*Driver) Shutdown

```go
func (d *Driver) Shutdown()
```

#### type Engine

```go
type Engine struct {
	// contains filtered or unexported fields
}
```

#### func (*Engine) Shutdown

```go
func (e *Engine) Shutdown()
```

#### type Passenger

```go
type Passenger struct {
	// contains filtered or unexported fields
}
```

#### func (*Passenger) Shutdown

```go
func (p *Passenger) Shutdown()
```

#### type Seat

```go
type Seat struct {
	// contains filtered or unexported fields
}
```

* 
  * Seat

#### func (*Seat) Shutdown

```go
func (s *Seat) Shutdown()
```

#### type Wheel

```go
type Wheel struct {
	// contains filtered or unexported fields
}
```

* 
  * Wheel

#### func (*Wheel) Shutdown

```go
func (w *Wheel) Shutdown()
```
```

--------------------------------

### Get Service Name by Type (Go)

Source: https://pkg.go.dev/github.com/samber/do/v2/index

NameOf returns the registered name of a service in the DI container using type inference. While functional, its use is discouraged as code should ideally not be aware of service names.

```go
func NameOf[T any]() string

// Example:
serviceName := do.NameOf[*Database]()
```

--------------------------------

### Explain Service by Type (Go)

Source: https://pkg.go.dev/github.com/samber/do/v2/index

The ExplainService function provides a human-readable description of a service based on its type. The service must be registered within the injector before calling this function.

```go
func ExplainService[T any](i Injector) (description ExplainServiceOutput, ok bool)
```

```go
// First invoke the service to ensure it's registered
	db := do.MustInvoke[*Database](injector)

// Then explain it
	explanation, found := do.ExplainService[*Database](injector)
	if found {
		fmt.Println(explanation.String())
	}
```

--------------------------------

### Injector Options

Source: https://pkg.go.dev/github.com/samber/do/v2/index_tab=versions

Options for configuring the Injector.

```APIDOC
## Injector Options

### `HealthCheckGlobalTimeout time.Duration`

**Description**: Global timeout for health checks.

### `HealthCheckParallelism uint`

**Description**: Number of health checks to run in parallel.

### `HealthCheckTimeout time.Duration`

**Description**: Timeout for individual health checks.

### `HookAfterInvocation []func(scope *Scope, serviceName string, err error)`

**Description**: Hooks to be executed after service invocation.

### `HookAfterRegistration []func(scope *Scope, serviceName string)`

**Description**: Hooks to be executed after service registration.

### `HookAfterShutdown []func(scope *Scope, serviceName string, err error)`

**Description**: Hooks to be executed after service shutdown.

### `HookBeforeInvocation []func(scope *Scope, serviceName string)`

**Description**: Hooks to be executed before service invocation.

### `HookBeforeRegistration []func(scope *Scope, serviceName string)`

**Description**: Hooks to be executed before service registration.

### `HookBeforeShutdown []func(scope *Scope, serviceName string)`

**Description**: Hooks to be executed before service shutdown.

### `Logf func(format string, args ...any)`

**Description**: Function for logging.

### `StructTagKey string`

**Description**: Struct tag key to use for dependency injection.
```

--------------------------------

### Format Scope Explanation as String (Go)

Source: https://pkg.go.dev/github.com/samber/do/v2/index

The String method for ExplainInjectorScopeOutput provides a formatted string representation of a scope. This includes details about the scope's services and its child scopes, offering a clear textual overview.

```Go
func (ids *ExplainInjectorScopeOutput) String() string
```

--------------------------------

### Configuration Options

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

Defines configuration options for the dependency injection container.

```APIDOC
## InjectorOpts Struct

### Description
Defines configuration options for the dependency injection container.

### Fields

- **HealthCheckGlobalTimeout** (`time.Duration`)
  - Sets a global timeout for all health checks.

- **HealthCheckParallelism** (`uint`)
  - Specifies the number of health checks to run in parallel.

- **HealthCheckTimeout** (`time.Duration`)
  - Sets a timeout for individual health check operations.

- **StructTagKey** (`string`)
  - The struct tag key used for dependency injection configuration.

- **HookAfterInvocation** (`[]func(*Scope, string, error)`)
  - A slice of functions to execute after a service invocation.

- **HookAfterRegistration** (`[]func(*Scope, string)`)
  - A slice of functions to execute after a service registration.

- **HookAfterShutdown** (`[]func(*Scope, string, error)`)
  - A slice of functions to execute after a service shutdown.

- **HookBeforeInvocation** (`[]func(*Scope, string)`)
  - A slice of functions to execute before a service invocation.

- **HookBeforeRegistration** (`[]func(*Scope, string)`)
  - A slice of functions to execute before a service registration.

- **HookBeforeShutdown** (`[]func(*Scope, string)`)
  - A slice of functions to execute before a service shutdown.

### Usage
This struct is used with the `NewWithOpts` function to customize the behavior of the dependency injection container.
```

--------------------------------

### Go: Define and Bind Dependencies

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

This snippet demonstrates how to define and bind dependencies within the go-dependency-injection framework. It covers binding services that are directly provided or lazily instantiated, including options for named services. This is crucial for setting up the dependency graph.

```go
func Bind[Initial any, Alias any]() func(Injector)
func BindNamed[Initial any, Alias any](initial string, alias string) func(Injector)
func Eager[T any](value T) func(Injector)
func EagerNamed[T any](serviceName string, value T) func(Injector)
func Lazy[T any](p Provider[T]) func(Injector)
func LazyNamed[T any](serviceName string, p Provider[T]) func(Injector)
func Transient[T any](p Provider[T]) func(Injector)
func TransientNamed[T any](serviceName string, p Provider[T]) func(Injector)
func Provide[T any](i Injector, provider Provider[T])
func ProvideValue[T any](i Injector, value T)
func ProvideNamed[T any](i Injector, name string, provider Provider[T])
func ProvideNamedValue[T any](i Injector, name string, value T)
func ProvideTransient[T any](i Injector, provider Provider[T])
func ProvideNamedTransient[T any](i Injector, name string, provider Provider[T])
```

--------------------------------

### Explain Service by Name (Go)

Source: https://pkg.go.dev/github.com/samber/do/v2/index

The ExplainNamedService function returns a human-readable description of a service identified by its name within a given scope. It requires the service to be registered prior to invocation.

```go
func ExplainNamedService(scope Injector, name string) (description ExplainServiceOutput, ok bool)
```

```go
// First invoke the service to ensure it's registered
	db := do.MustInvokeNamed[*Database](injector, "main-db")

// Then explain it
	explanation, found := do.ExplainNamedService(injector, "main-db")
	if found {
	    fmt.Println(explanation.String())
	}
```

--------------------------------

### Project Versions

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0.0-beta.4/stacktrace_tab=versions

Lists the available versions for the project /websites/pkg_go_dev_github_com_samber_do_v2, along with their release dates and changes.

```APIDOC
## Project: /websites/pkg_go_dev_github_com_samber_do_v2

### Description
This section details the versions available for the specified Go module, including release dates and a summary of changes for each version.

### Versions

**v2**

*   **v2.0.0** (Sep 21, 2025)
    *   Changes:
        *   Added type Frame struct
        *   Added Frame.File string
        *   Added Frame.Function string
        *   Added Frame.Line int
        *   Added Frame.PC uintptr
        *   Added func NewFrameFromCaller() (Frame, bool)
        *   Added func NewFrameFromPC(pc uintptr) (Frame, bool)
        *   Added func (f Frame) String() string
*   **v2.0.0-rc1** (Aug 22, 2025)
*   **v2.0.0-beta.7** (May 13, 2024)
*   **v2.0.0-beta.6** (May 9, 2024)
*   **v2.0.0-beta.5** (Feb 11, 2024)
*   **v2.0.0-beta.4** (Feb 11, 2024)
*   **v2.0.0-beta.3** (Jan 15, 2024)
*   **v2.0.0-beta.2** (Dec 31, 2023)
*   **v2.0.0-beta.1** (Dec 4, 2023)

### Navigation

*   **Main Page**: Navigate to the main page of the project.
*   **Versions**: View available module versions.
*   **Licenses**: View project licenses.
*   **Imports**: View project imports.
*   **Imported By**: View projects that import this module.
```

--------------------------------

### Go: Dependency Injection Explain Service Functions

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2

These Go functions provide detailed diagnostic information about services within a dependency injector. `ExplainService` describes a generic service, while `ExplainNamedService` focuses on a specifically named service. They return a structured output detailing dependencies, dependents, and invocation context.

```go
func ExplainNamedService(scope Injector, name string) (description ExplainServiceOutput, ok bool)
func ExplainService[T any](i Injector) (description ExplainServiceOutput, ok bool)
```

--------------------------------

### Define Service Explanation Structure (Go)

Source: https://pkg.go.dev/github.com/samber/do/v2/index

Defines the ExplainServiceOutput struct, which holds detailed information about a service for debugging and analysis. It includes scope, name, type, build time, and dependency information.

```go
type ExplainServiceOutput struct {
	ScopeID          string                           `json:"scope_id"`
	ScopeName        string                           `json:"scope_name"`
	ServiceName      string                           `json:"service_name"`
	ServiceType      ServiceType                      `json:"service_type"`
	ServiceBuildTime time.Duration                    `json:"service_build_time,omitempty"`
	Invoked          *stacktrace.Frame                `json:"invoked"`
	Dependencies     []ExplainServiceDependencyOutput `json:"dependencies"`
	Dependents       []ExplainServiceDependencyOutput `json:"dependents"`
}
```

--------------------------------

### ServiceListHTML API

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0.0-beta.4/http

Generates HTML listing all services available within the injector.

```APIDOC
## GET /services.html

### Description
Generates HTML listing all services available within the injector.

### Method
GET

### Endpoint
/services.html

### Parameters
#### Query Parameters
- **basePath** (string) - Required - The base path for the generated HTML.
- **injector** (do.Injector) - Required - The dependency injector instance.

### Request Example
```
GET /services.html?basePath=/
```

### Response
#### Success Response (200)
- **string** (string) - The generated HTML content listing all services.
- **error** (error) - An error if the HTML generation fails.

#### Response Example
```html
<!DOCTYPE html>
<html>
<head>
    <title>Service List</title>
</head>
<body>
    <h1>Available Services</h1>
    <ul>
        <li>ServiceA</li>
        <li>ServiceB</li>
        <!-- List of services -->
    </ul>
</body>
</html>
```
```

--------------------------------

### RootScope Initialization

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

Functions for creating and initializing the root scope of the dependency injection container.

```APIDOC
## New

### Description
Creates a new root scope with default options.

### Method
`func New(packages ...func(Injector)) *RootScope`

### Parameters
- `packages` (*func(Injector)*) - Optional variadic function to configure the injector.

### Response
- `*RootScope` - A pointer to the newly created root scope.

## NewWithOpts

### Description
Creates a new root scope with custom options.

### Method
`func NewWithOpts(opts *InjectorOpts, packages ...func(Injector)) *RootScope`

### Parameters
- `opts` (*InjectorOpts*) - Configuration options for the injector.
- `packages` (*func(Injector)*) - Optional variadic function to configure the injector.

### Response
- `*RootScope` - A pointer to the newly created root scope.
```

--------------------------------

### Explain Injector Service Output Structure (Go)

Source: https://pkg.go.dev/github.com/samber/do/v2/index

The ExplainInjectorServiceOutput struct contains details about a specific service within a scope explanation. It includes the service's name, type, build time, and indicators for health checking and shutdown capabilities.

```Go
type ExplainInjectorServiceOutput struct {
	ServiceName      string        `json:"service_name"`
	ServiceType      ServiceType   `json:"service_type"`
	ServiceTypeIcon  string        `json:"service_type_icon"`
	ServiceBuildTime time.Duration `json:"service_build_time,omitempty"`
	IsHealthchecker  bool          `json:"is_healthchecker"`
	IsShutdowner     bool          `json:"is_shutdowner"`
}
```

--------------------------------

### Create New RootScope with Options - Go

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

Constructs a new RootScope with optional configurations. It accepts variadic functions to customize the injector. Dependencies include context and potentially other injector functions.

```go
func NewWithOpts(opts *InjectorOpts, packages ...func(Injector)) *RootScope
```

--------------------------------

### Service Explanation Utilities

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2

Utilities for explaining the structure, dependencies, and details of services within the DI container.

```APIDOC
## Service Explanation Utilities

### Description
These functions provide insights into the dependency graph and service configurations within the DI container, aiding in debugging and understanding service relationships.

### Explain Service

#### `ExplainService[T any](i Injector) (description ExplainServiceOutput, ok bool)`
Explains a service of type T, returning its details and whether it was found.

#### `ExplainNamedService(scope Injector, name string) (description ExplainServiceOutput, ok bool)`
Explains a named service, returning its details and whether it was found.

### Injector Explanation

#### `ExplainInjector(scope Injector) ExplainInjectorOutput`
Explains the entire injector, providing a detailed breakdown of scopes and services.

### Data Structures

#### `ExplainInjectorOutput`
Represents the output of explaining an injector, including scopes and their services.

#### `ExplainInjectorScopeOutput`
Represents a scope within the injector explanation, including its ID, name, children, and services.

#### `ExplainInjectorServiceOutput`
Represents a service within the injector explanation, including its name, type, build time, and health/shutdown status.

#### `ExplainServiceDependencyOutput`
Represents a dependency or dependent service in the explanation.

```

--------------------------------

### Service Provisioning

Source: https://pkg.go.dev/github.com/samber/do/v2/index_tab=versions

Functions for providing services to the dependency injection container.

```APIDOC
## Service Provisioning

### Provide

- **Provide[T any](i Injector, provider Provider[T])**: Provides a service.
- **ProvideValue[T any](i Injector, value T)**: Provides a service with a specific value.
- **ProvideTransient[T any](i Injector, provider Provider[T])**: Provides a service as transient.
- **ProvideNamed[T any](i Injector, name string, provider Provider[T])**: Provides a named service.
- **ProvideNamedValue[T any](i Injector, name string, value T)**: Provides a named service with a specific value.
- **ProvideNamedTransient[T any](i Injector, name string, provider Provider[T])**: Provides a named service as transient.
```

--------------------------------

### Go: Service Description and Types

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2

Defines the structure for describing services and enumerates different service types (Alias, Eager, Lazy, Transient).

```go
type ServiceDescription struct {
	ScopeID string
	ScopeName string
	Service string
}
type ServiceType string
const ServiceTypeAlias
const ServiceTypeEager
const ServiceTypeLazy
const ServiceTypeTransient
```

--------------------------------

### Go Stack Trace Frame Definition and Creation

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0.0/stacktrace_tab=versions

Defines the `Frame` struct for capturing stack trace information, including file, function, line number, and program counter. Provides functions to create a `Frame` from the current caller or a program counter address. The `String()` method formats the frame for display.

```go
package stacktrace

type Frame struct {
	File     string
	Function string
	Line     int
	PC       uintptr
}

func NewFrameFromCaller() (Frame, bool)
func NewFrameFromPC(pc uintptr) (Frame, bool)
func (f Frame) String() string
```

--------------------------------

### Go: Dependency Injection Stringer Methods

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2

These Go methods implement the `Stringer` interface for diagnostic output structs, providing human-readable string representations of `ExplainInjectorOutput`, `ExplainInjectorScopeOutput`, `ExplainInjectorServiceOutput`, and `ExplainServiceOutput`. This aids in logging and debugging.

```go
func (id *ExplainInjectorOutput) String() string
func (ids *ExplainInjectorScopeOutput) String() string
func (idss *ExplainInjectorServiceOutput) String() string
func (sdd *ExplainServiceDependencyOutput) String() string
func (sd *ExplainServiceOutput) String() string
```

--------------------------------

### Format Service Dependency as String (Go)

Source: https://pkg.go.dev/github.com/samber/do/v2/index

The String method for ExplainServiceDependencyOutput formats the dependency relationship into a readable string. It includes nested recursive dependencies with appropriate indentation, illustrating the flow of dependencies.

```Go
func (sdd *ExplainServiceDependencyOutput) String() string
```

--------------------------------

### IndexHTML API

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0.0-beta.4/http

Generates HTML for the index page, likely displaying a list of services or components.

```APIDOC
## GET /index.html

### Description
Generates HTML for the index page, likely displaying a list of services or components.

### Method
GET

### Endpoint
/index.html

### Parameters
#### Query Parameters
- **basePath** (string) - Required - The base path for the generated HTML.

### Request Example
```
GET /index.html?basePath=/
```

### Response
#### Success Response (200)
- **string** (string) - The generated HTML content.
- **error** (error) - An error if the HTML generation fails.

#### Response Example
```html
<!DOCTYPE html>
<html>
<head>
    <title>Index</title>
</head>
<body>
    <h1>Service Index</h1>
    <!-- Service list will be rendered here -->
</body>
</html>
```
```

--------------------------------

### Hooks and Callbacks

Source: https://pkg.go.dev/github.com/samber/do/v2/%40v2.0

Allows registration of callbacks for various stages of service lifecycle management.

```APIDOC
## Hooks

### Description
Functions to register callback hooks for service lifecycle events within the dependency injection container.

### Hook Types
- `HookBeforeRegistration`
- `HookAfterRegistration`
- `HookBeforeInvocation`
- `HookAfterInvocation`
- `HookBeforeShutdown`
- `HookAfterShutdown`

### Registration Methods on `*RootScope`

- **AddBeforeRegistrationHook**
  - `func (s *RootScope) AddBeforeRegistrationHook(hook func(*Scope, string))`
  - Registers a hook to be called before a service is registered.

- **AddAfterRegistrationHook**
  - `func (s *RootScope) AddAfterRegistrationHook(hook func(*Scope, string))`
  - Registers a hook to be called after a service is registered.

- **AddBeforeInvocationHook**
  - `func (s *RootScope) AddBeforeInvocationHook(hook func(*Scope, string))`
  - Registers a hook to be called before a service is invoked.

- **AddAfterInvocationHook**
  - `func (s *RootScope) AddAfterInvocationHook(hook func(*Scope, string, error))`
  - Registers a hook to be called after a service is invoked.

- **AddBeforeShutdownHook**
  - `func (s *RootScope) AddBeforeShutdownHook(hook func(*Scope, string))`
  - Registers a hook to be called before a service is shut down.

- **AddAfterShutdownHook**
  - `func (s *RootScope) AddAfterShutdownHook(hook func(*Scope, string, error))`
  - Registers a hook to be called after a service is shut down.

### Parameters
- `hook` (func(*Scope, string) or func(*Scope, string, error)) - The callback function to execute.

### Usage
Hooks provide a mechanism to observe and react to service lifecycle events, enabling custom logic for logging, metrics, or other cross-cutting concerns.
```
Tokens:
Raw