triggers

type App struct {
	// contains filtered or unexported fields
}

type Config interface {
	Filter(event any) (bool, error)
}

type CreateParams struct {
	OrganizationID string
	ProjectID      uuid.UUID
	DefinitionSlug string
	Name           string
	EnvironmentID  uuid.NullUUID
	TargetKind     string
	TargetRef      string
	TargetDisplay  string
	Config         map[string]any
	Status         string
}

type CreateWakeInstanceParams struct {
	OrganizationID string
	ProjectID      uuid.UUID
	Name           string
	AssistantID    uuid.UUID
	TargetDisplay  string
	FireAt         time.Time
	Note           *string
	CorrelationID  string
}

type Definition struct {
	Slug                 string
	Title                string
	Description          string
	Kind                 Kind
	ConfigSchema         []byte
	CompiledConfigSchema *jsonschema.Schema
	EnvRequirements      []EnvRequirement
	EventType            reflect.Type
	DecodeConfig         func(raw map[string]any) (Config, error)
	AuthenticateWebhook  func(body []byte, headers http.Header, env map[string]string, config Config) error
	HandleWebhook        func(body []byte, headers http.Header, config Config) (*WebhookIngressResult, error)
	BuildScheduledEvent  func(instance triggerrepo.TriggerInstance, config Config, firedAt time.Time) (*EventEnvelope, error)
	BuildDirectEvent     func(instance triggerrepo.TriggerInstance, config Config, payload []byte, receivedAt time.Time) (*EventEnvelope, error)
	ExtractSchedule      func(config Config) (string, error)
}

type DeliveryLogger interface {
	LogTriggerDelivery(triggerrepo.TriggerInstance, EventEnvelope, DeliveryStatus, string, error)
}

type DeliveryStatus string

type Dispatcher interface {
	Kind() string
	Dispatch(context.Context, Task) error
}

type EnvRequirement struct {
	Name        string
	Description string
	Required    bool
}

type EnvironmentLoader interface {
	Load(context.Context, uuid.UUID, toolconfig.SlugOrID) (map[string]string, error)
}

type EventEnvelope struct {
	EventID           string
	CorrelationID     string
	TriggerInstanceID string
	DefinitionSlug    string
	Event             any
	RawPayload        []byte
	ReceivedAt        time.Time
}

type HMACScheme struct {
	// NewHash returns a fresh HMAC writer keyed by the signing secret. Nil
	// disables signature verification.
	NewHash func(key []byte) hash.Hash
	// Header names the request header carrying the signature.
	Header string
	// Encoding renders the computed MAC: "hex" (default) or "base64".
	Encoding string
	// Prefix is prepended to the encoded MAC before constant-time compare
	// (e.g. "sha256=" for GitHub, "v0=" for Slack).
	Prefix string
	// Template shapes the bytes fed to the MAC. Placeholders: {body}, {timestamp}.
	// Defaults to "{body}".
	Template string
	// TimestampHeader names a request header carrying a unix timestamp
	// substituted into Template and bounded for replay protection. Empty
	// disables timestamp checking.
	TimestampHeader string
	// TimestampSkew caps how far the timestamp may drift from now. Defaults
	// to 300s when TimestampHeader is set.
	TimestampSkew time.Duration
}

type InstanceDBHook func(ctx context.Context, dbtx pgx.Tx, instance triggerrepo.TriggerInstance) error

type Kind string

type NoopDispatcher struct {
	// contains filtered or unexported fields
}

type ProcessScheduledInput struct {
	TriggerInstanceID string
	FiredAt           string
}

type ScheduleTriggerCronWorkflowOptions struct {
	InstanceID     uuid.UUID
	InstanceStatus string
	Schedule       string
}

type ScheduleWorkflowInput struct {
	TriggerInstanceID string `json:"trigger_instance_id"`
	FiredAt           string `json:"fired_at,omitempty"`
}

type Task struct {
	TriggerInstanceID string
	DefinitionSlug    string
	TargetKind        string
	TargetRef         string
	TargetDisplay     string
	EventID           string
	CorrelationID     string
	EventJSON         []byte
	RawPayload        []byte
}

type TriggerCronWorkflowInput struct {
	TriggerInstanceID string `json:"trigger_instance_id"`
}

type TriggerDeliveryLog struct {
	Timestamp  time.Time
	Instance   triggerrepo.TriggerInstance
	Attributes map[attr.Key]any
}

type TriggerDispatchWorkflowInput struct {
	Task Task
}

type UpdateParams struct {
	ID             uuid.UUID
	ProjectID      uuid.UUID
	DefinitionSlug string
	Name           string
	EnvironmentID  uuid.NullUUID
	TargetKind     string
	TargetRef      string
	TargetDisplay  string
	Config         map[string]any
	Status         string
}

type WebhookIngest struct {
	Response      *WebhookResponse
	Event         any
	EventID       string
	CorrelationID string
}

type WebhookIngressResult struct {
	Response *WebhookResponse
	Event    *EventEnvelope
	Task     *Task
}

type WebhookResponse struct {
	Status      int
	ContentType string
	Body        []byte
}

type WebhookVendor struct {
	Slug                string
	Title               string
	Description         string
	EventType           reflect.Type
	EnvRequirements     []EnvRequirement
	SecretEnv           string
	Signature           HMACScheme
	SupportedEventTypes []string
	// PreVerify inspects the request before signature verification. Return
	// skipSignature=true to authorize the request without checking the HMAC
	// (e.g. Slack's url_verification handshake, which must echo a challenge
	// before any signing secret is necessarily configured). Return an error
	// to reject. May be nil, in which case signature verification always runs.
	PreVerify func(body []byte, headers http.Header) (skipSignature bool, err error)
	// Ingest decodes body + headers into a normalized event for downstream
	// consumers, the vendor's delivery id (used for dedup; falls back to a
	// content hash when empty), and the correlation id that routes the event
	// to an assistant conversation. A nil Response with a nil Event acks
	// without dispatching (e.g. an unsupported Slack interaction envelope).
	Ingest func(body []byte, headers http.Header) (*WebhookIngest, error)
}