sdk

type AttachmentRequest struct {
	Payload          Configuration
	RegistrationInfo *RegistrationResponse
}

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

type AvailablePlugins []*FanOutP

type ChainloopMetadata struct {
	Workflow    *ChainloopMetadataWorkflow
	WorkflowRun *ChainloopMetadataWorkflowRun
}

type ChainloopMetadataWorkflow struct {
	ID, Name, Team, Project string
}

type ChainloopMetadataWorkflowRun struct {
	ID                string
	State             string
	StartedAt         time.Time
	FinishedAt        time.Time
	RunnerType        string
	RunURL            string
	AttestationDigest string
}

type Configuration []byte

type Core interface {
	fmt.Stringer
	// Return information about the integration
	Describe() *IntegrationInfo
	ValidateRegistrationRequest(jsonPayload []byte) error
	ValidateAttachmentRequest(jsonPayload []byte) error
	// Return if the integration is subscribed to the material type
	IsSubscribedTo(materialType string) bool
}

type Credentials struct {
	URL, Username, Password string
}

type ExecuteAttestation struct {
	Envelope *dsse.Envelope
	// Hash of the envelope
	Hash      crv1.Hash
	Statement *intoto.Statement
	Predicate chainloop.NormalizablePredicate
}

type ExecuteInput struct {
	Attestation *ExecuteAttestation
	Materials   []*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
	FanOutPlugin
}

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

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

type FanOutP struct {
	FanOut
	DisposeFunc func()
}

type FanOutPlugin 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 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 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
	SubscribedMaterials []*InputMaterial
	// 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
}

type RenderOpt func(r *renderer) error

type SchemaPropertiesMap map[string]*SchemaProperty

type SchemaProperty struct {
	// Name of the property
	Name string
	// optional description
	Description string
	// Type of the property (string, boolean, number)
	Type string
	// If the property is required
	Required bool
	// Optional format (email, host)
	Format  string
	Default string
}