sdk

type AttachmentRequest struct {
	Payload          Configuration
	RegistrationInfo *RegistrationResponse
}

type AttachmentResponse struct {
	// JSON serializable configuration to be persisted
	Configuration
}

type AvailableExtensions []FanOut

type ChainloopMetadata struct {
	WorkflowID      string
	WorkflowName    string
	WorkflowProject string

	WorkflowRunID string
}

type Configuration []byte

type Core interface {
	fmt.Stringer
	// Return information about the integration
	Describe() *IntegrationInfo
	ValidateRegistrationRequest(jsonPayload []byte) error
	ValidateAttachmentRequest(jsonPayload []byte) error
}

type Credentials struct {
	URL, Username, Password string
}

type ExecuteAttestation struct {
	Envelope  *dsse.Envelope
	Statement *in_toto.Statement
	Predicate chainloop.NormalizablePredicate
}

type ExecuteInput struct {
	Attestation *ExecuteAttestation
	Material    *ExecuteMaterial
}

type ExecuteMaterial struct {
	*chainloop.NormalizedMaterial
	// Content of the material already downloaded
	Content []byte
}

type ExecutionRequest struct {
	*ChainloopMetadata
	Input            *ExecuteInput
	RegistrationInfo *RegistrationResponse
	AttachmentInfo   *AttachmentResponse
}

type FanOut interface {
	// Implemented by the fanout base
	Core
	// To be implemented per integration
	FanOutExtension
}

type FanOutExtension interface {
	// Validate, marshall and return the configuration that needs to be persisted
	Register(ctx context.Context, req *RegistrationRequest) (*RegistrationResponse, error)
	// Validate that the attachment configuration is valid in the context of the provided registration
	Attach(ctx context.Context, req *AttachmentRequest) (*AttachmentResponse, error)
	// Execute the integration
	Execute(ctx context.Context, req *ExecutionRequest) error
}

type FanOutFactory = func(l log.Logger) (FanOut, error)

type FanOutIntegration struct {
	Logger *log.Helper
	// contains filtered or unexported fields
}

type InputMaterial struct {
	// Name of the material kind that the integration expects
	Type schemaapi.CraftingSchema_Material_MaterialType
}

type InputSchema struct {
	// Structs defining the registration and attachment schemas
	Registration, Attachment any
}

type Inputs struct {
	DSSEnvelope bool
	Materials   []*InputMaterial
}

type IntegrationInfo struct {
	// Identifier of the integration
	ID string
	// Integration version
	Version string
	// Integration description
	Description string
	// Kind of inputs does the integration expect as part of the execution
	SubscribedInputs *Inputs
	// Schemas in JSON schema format
	RegistrationJSONSchema, AttachmentJSONSchema []byte
}

type NewOpt func(*FanOutIntegration)

type NewParams struct {
	ID, Version, Description string
	Logger                   log.Logger
	InputSchema              *InputSchema
}

type RegistrationRequest struct {
	// Custom Payload to be used by the integration
	Payload Configuration
}

type RegistrationResponse struct {
	// Credentials to be persisted in Credentials Manager
	// JSON serializable
	Credentials *Credentials
	// Configuration to be persisted in DB
	Configuration
}