activity

type AccessPolicyOption func(*DefaultAccessPolicy)

type ActivityAccessPolicy interface {
	Apply(actor *auth.ActorContext, role string, req types.ActivityFilter) (types.ActivityFilter, error)
	Sanitize(actor *auth.ActorContext, role string, records []types.ActivityRecord) []types.ActivityRecord
}

type ActivityCursor struct {
	OccurredAt time.Time
	ID         uuid.UUID
}

type ActivityEnricher interface {
	Enrich(ctx context.Context, record types.ActivityRecord) (types.ActivityRecord, error)
}

type ActivityEnrichmentFilter struct {
	Scope          types.ScopeFilter
	MissingKeys    []string
	EnrichedBefore *time.Time
	Cursor         *ActivityCursor
	Limit          int
}

type ActivityEnrichmentPage struct {
	Records    []types.ActivityRecord
	NextCursor *ActivityCursor
}

type ActivityEnrichmentQuery interface {
	ListActivityForEnrichment(ctx context.Context, filter ActivityEnrichmentFilter) (ActivityEnrichmentPage, error)
}

type ActivityEnrichmentStore interface {
	UpdateActivityData(ctx context.Context, id uuid.UUID, data map[string]any) error
}

type ActivityEnrichmentStoreWithOptions interface {
	UpdateActivityDataWithOptions(ctx context.Context, id uuid.UUID, data map[string]any, opts ActivityEnrichmentUpdateOptions) error
}

type ActivityEnrichmentUpdateOptions struct {
	// ForceKeys allows overwriting specific keys (e.g., enriched_at) when needed.
	ForceKeys []string
}

type ActivityEnvelope struct {
	Channel    string
	Verb       string
	ObjectType string
	ObjectID   string
	ActorID    string
	TenantID   string
	OccurredAt time.Time
	Metadata   map[string]any
}

type ActivityEnvelopeCarrier interface {
	ActivityChannel() string
	ActivityVerb() string
	ActivityObjectType() string
	ActivityObjectID() string
	ActivityActorID() string
	ActivityTenantID() string
	ActivityOccurredAt() time.Time
	ActivityMetadata() map[string]any
}

type ActivityEventMapper interface {
	Map(ctx context.Context, evt any) (types.ActivityRecord, error)
}

type ActivityEventMapperFunc func(ctx context.Context, evt any) (types.ActivityRecord, error)

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

type ActivityStatsPolicy interface {
	ApplyStats(actor *auth.ActorContext, role string, req types.ActivityStatsFilter) (types.ActivityStatsFilter, error)
}

type ActorInfo struct {
	ID      uuid.UUID
	Type    string
	Display string
	Email   string
}

type ActorResolver interface {
	ResolveActors(ctx context.Context, ids []uuid.UUID, meta ResolveContext) (map[uuid.UUID]ActorInfo, error)
}

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

type EnrichedSink struct {
	Sink         types.ActivitySink
	Enricher     ActivityEnricher
	ErrorHandler EnrichmentErrorHandler
}

type EnricherChain []ActivityEnricher

type EnricherFunc func(ctx context.Context, record types.ActivityRecord) (types.ActivityRecord, error)

type EnricherWithHandler interface {
	EnrichWithHandler(ctx context.Context, record types.ActivityRecord, handler EnrichmentErrorHandler) (types.ActivityRecord, error)
}

type EnrichmentErrorHandler func(ctx context.Context, err error, enricher ActivityEnricher, current types.ActivityRecord, original types.ActivityRecord) (types.ActivityRecord, error)

type EnrichmentErrorStrategy int

type EnrichmentScope string

type EnrichmentWriteMode string

type EnvelopeMapper struct {
	DefaultChannel    string
	DefaultObjectType string
}

type FilterConfig struct {
	ChannelAllowlist []string
	ChannelDenylist  []string

	// Machine activity settings are reserved for policy layers that can inspect
	// records (actor type/data); BuildFilterFromActor does not use them directly.
	MachineActivityEnabled bool
	MachineActorTypes      []string
	MachineDataKeys        []string

	SuperadminScope bool

	AdminRoleAliases      []string
	SuperadminRoleAliases []string
}

type FilterOption func(*FilterConfig)

type LogEntry struct {
	bun.BaseModel `bun:"table:user_activity"`

	ID         uuid.UUID      `bun:",pk,type:uuid"`
	UserID     uuid.UUID      `bun:"user_id,type:uuid"`
	ActorID    uuid.UUID      `bun:"actor_id,type:uuid"`
	TenantID   uuid.UUID      `bun:"tenant_id,type:uuid"`
	OrgID      uuid.UUID      `bun:"org_id,type:uuid"`
	Verb       string         `bun:"verb"`
	ObjectType string         `bun:"object_type"`
	ObjectID   string         `bun:"object_id"`
	Channel    string         `bun:"channel"`
	IP         string         `bun:"ip"`
	Data       map[string]any `bun:"data,type:jsonb"`
	CreatedAt  time.Time      `bun:"created_at"`
}

type MetadataExposureStrategy int

type MetadataSanitizer func(actor *auth.ActorContext, role string, record types.ActivityRecord) map[string]any

type ObjectInfo struct {
	ID      string
	Type    string
	Display string
	Deleted bool
}

type ObjectResolver interface {
	ResolveObjects(ctx context.Context, objectType string, ids []string, meta ResolveContext) (map[string]ObjectInfo, error)
}

type RecordOption func(*types.ActivityRecord)

type RegistryMapper struct {
	Registry *ActivityMapperRegistry
	Name     string
}

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

type RepositoryConfig struct {
	DB         *bun.DB
	Repository repository.Repository[*LogEntry]
	Clock      types.Clock
	IDGen      types.IDGenerator
	Enricher   ActivityEnricher
	// EnrichmentErrorHandler controls fail-fast vs best-effort behavior.
	EnrichmentErrorHandler EnrichmentErrorHandler
}

type ResolveContext struct {
	TenantID uuid.UUID
	ActorID  uuid.UUID
	Verb     string
	Source   string
	Metadata map[string]any
}

type SanitizerConfig struct {
	Masker *masker.Masker
}

type SessionIDProvider interface {
	SessionID(ctx context.Context) (string, bool)
}

type SessionIDProviderFunc func(ctx context.Context) (string, bool)

type UsersActivityHook struct {
	Sink            types.ActivitySink
	Mapper          ActivityEventMapper
	SessionProvider SessionIDProvider
	Enricher        ActivityEnricher
	ErrorHandler    EnrichmentErrorHandler
}