plug-sdk/README.md

# Anthrove Plug SDK

Anthrove Plug SDK is a Golang-based Software Development Kit (SDK) that provides a gRPC server implementation for the Anthrove system. This SDK enables users to easily set up a server, establish a database connection, and set a task execution function.

## Installation

To install the Anthrove Plug SDK, you will need to have Go installed on your system. You can then use the go get command to fetch the SDK:

```bash
go get git.anthrove.art/Anthrove/plug-sdk/v5
```
## Usage

Below is a basic example of how to use the SDK:

### proposed Plug structure

````
your-project/
│
├── cmd
│   └── your-plug
│       └── main.go
├── config
├── internal
│   ├── service
│   └── utils
└── go.mod
````

### config.go

````go

package config

import (
	"fmt"

	"github.com/caarlos0/env/v10"
	"github.com/go-playground/validator/v10"
)

type CoreConfig struct {
	LogLevel  string `env:"LOG_LEVEL" envDefault:"INFO" validate:"eq_ignore_case=FATAL|eq_ignore_case=ERROR|eq_ignore_case=WARN|eq_ignore_case=INFO|eq_ignore_case=DEBUG|eq_ignore_case=TRACE"`
	LogFormat string `env:"LOG_FORMAT" envDefault:"PLAIN" validate:"eq_ignore_case=PLAIN|eq_ignore_case=JSON"`
}

type PlugConfig struct {
	PlugDomain      string `env:"PLUG_DOMAIN" envDefault:"e621.net"`
	PlugIcon        string `env:"PLUG_ICON" envDefault:"https://e621.net/safari-pinned-tab.svg"`
	PlugDisplayName string `env:"PLUG_DISPLAY_NAME" envDefault:"e621.net"`
	PlugAPIKey      string `env:"PLUG_API_KEY,required"`
	PlugUsername    string `env:"PLUG_USERNAME,required"`
}

// LoadConfig loads the configuration from environment variables and validates it.
func LoadConfig[T any](cfg T) (T, error) {

	if err := env.Parse(&cfg); err != nil {
		return cfg, fmt.Errorf("config: error parsing configuration: %w", err)
	}

	validate := validator.New()
	if err := validate.Struct(cfg); err != nil {
		return cfg, fmt.Errorf("config: validation error: %w", err)
	}

	return cfg, nil
}

````

### main.go

````go
package main

import (
	"context"

	log "github.com/sirupsen/logrus"
	"your-repo-path/config"
	"your-repo-path/internal/service"
	"your-repo-path/internal/utils"
	"your-repo-path/pkg/database"
	"your-repo-path/pkg/models"
	"your-repo-path/pkg/plug"
)

// plugConfig holds the orchestrator configuration
var coreConfig config.CoreConfig
var plugConfig config.PlugConfig
var databaseConfig models.DatabaseConfig

// init is used to load the orchestrator configuration
func init() {
	// Load the orchestrator configuration
	localCoreConfig, err := config.LoadConfig[config.CoreConfig](coreConfig)
	if err != nil {
		log.Panic(err)
	}
	coreConfig = localCoreConfig

	// Load the plug configuration
	localPlugConfig, err := config.LoadConfig[config.PlugConfig](plugConfig)
	if err != nil {
		log.Panic(err)
	}
	plugConfig = localPlugConfig

	// Load the database configuration
	localDatabaseConfig, err := config.LoadConfig[models.DatabaseConfig](databaseConfig)
	if err != nil {
		log.Panic(err)
	}
	databaseConfig = localDatabaseConfig
}

func main() {
	var err error
	var ctx = context.Background()
	// Initiate logging setup
	utils.SetupLogger(coreConfig.LogLevel, coreConfig.LogFormat)

	// Initiate database connection
	err = database.Connect(ctx, databaseConfig)
	if err != nil {
		log.Fatal(err)
	}

	// Setup Source
	source := models.Source{
		DisplayName: plugConfig.DisplayName,
		Domain:      models.SourceDomain(plugConfig.Domain),
		Icon:        plugConfig.Icon,
	}

	err = plug.SetupOpenTelemetry(ctx, "your-plug")
	if err != nil {
		log.Fatal(err)
	}

	plug.SetTaskExecutionFunction(service.plugInterface)
	plug.SetGetMessageExecutionFunction(service.YourMessageFunction)
	err = plug.Listen(ctx, ":8080", source)
	if err != nil {
		panic(err)
	}
}


````