repository

type ACLEntry struct {
	URI         string   `json:"uri"`
	Permissions []string `json:"permissions"`
}

type Aggregation int16

type ArchiveEventType int

type ArchiveSignature struct {
	KeyID     string
	Hash      [sha256.Size]byte
	Signature []byte
}

type ArchivedDocumentStatus struct {
	UUID             uuid.UUID       `json:"uuid"`
	Name             string          `json:"name"`
	ID               int64           `json:"id"`
	Version          int64           `json:"version"`
	Created          time.Time       `json:"created"`
	CreatorURI       string          `json:"creator_uri"`
	Meta             json.RawMessage `json:"meta,omitempty"`
	ParentSignature  string          `json:"parent_signature,omitempty"`
	VersionSignature string          `json:"version_signature"`
}

type ArchivedDocumentVersion struct {
	UUID            uuid.UUID       `json:"uuid"`
	Version         int64           `json:"version"`
	Created         time.Time       `json:"created"`
	CreatorURI      string          `json:"creator_uri"`
	Meta            json.RawMessage `json:"meta,omitempty"`
	DocumentData    json.RawMessage `json:"document_data"`
	ParentSignature string          `json:"parent_signature,omitempty"`
}

type ArchivedEvent struct {
	Type ArchiveEventType `json:"type"`
	UUID uuid.UUID        `json:"uuid"`
	// Version is the version of a document or the ID of a status.
	Version int64  `json:"version"`
	Name    string `json:"name,omitempty"`
}

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

type ArchiverOptions struct {
	Logger            *slog.Logger
	S3                *s3.Client
	Bucket            string
	DB                *pgxpool.Pool
	MetricsRegisterer prometheus.Registerer
}

type CheckPermissionRequest struct {
	UUID        uuid.UUID
	GranteeURIs []string
	Permissions []Permission
}

type CheckPermissionResult int

type DeleteRequest struct {
	UUID      uuid.UUID
	Updated   time.Time
	Updater   string
	Meta      newsdoc.DataMap
	IfMatch   int64
	LockToken string
}

type DocStore interface {
	GetDocumentMeta(
		ctx context.Context, uuid uuid.UUID) (*DocumentMeta, error)
	GetDocument(
		ctx context.Context, uuid uuid.UUID, version int64,
	) (*newsdoc.Document, int64, error)
	GetVersion(
		ctx context.Context, uuid uuid.UUID, version int64,
	) (DocumentUpdate, error)
	GetVersionHistory(
		ctx context.Context, uuid uuid.UUID,
		before int64, count int,
	) ([]DocumentUpdate, error)
	Update(
		ctx context.Context,
		workflows WorkflowProvider,
		update []*UpdateRequest,
	) ([]DocumentUpdate, error)
	Delete(ctx context.Context, req DeleteRequest) error
	CheckPermissions(
		ctx context.Context, req CheckPermissionRequest,
	) (CheckPermissionResult, error)
	GetMetaTypeForDocument(
		ctx context.Context, uuid uuid.UUID,
	) (DocumentMetaType, error)
	RegisterMetaType(
		ctx context.Context, metaType string, exclusive bool,
	) error
	RegisterMetaTypeUse(
		ctx context.Context, mainType string, metaType string,
	) error
	GetEventlog(
		ctx context.Context, after int64, limit int32,
	) ([]Event, error)
	GetLastEvent(
		ctx context.Context,
	) (*Event, error)
	GetLastEventID(
		ctx context.Context,
	) (int64, error)
	GetCompactedEventlog(
		ctx context.Context, req GetCompactedEventlogRequest,
	) ([]Event, error)
	OnEventlog(
		ctx context.Context, ch chan int64,
	)
	GetStatusHistory(
		ctx context.Context, uuid uuid.UUID,
		name string, before int64, count int,
	) ([]Status, error)
	GetDocumentACL(
		ctx context.Context, uuid uuid.UUID,
	) ([]ACLEntry, error)
	Lock(
		ctx context.Context, req LockRequest,
	) (LockResult, error)
	UpdateLock(
		ctx context.Context, req UpdateLockRequest,
	) (LockResult, error)
	Unlock(
		ctx context.Context, uuid uuid.UUID, token string,
	) error
}

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

type DocStoreErrorCode string

type DocumentMeta struct {
	Created        time.Time
	Modified       time.Time
	CurrentVersion int64
	ACL            []ACLEntry
	Statuses       map[string]Status
	Deleting       bool
	Lock           Lock
	MainDocument   string
}

type DocumentMetaType struct {
	MetaType       string
	IsMetaDocument bool
	Exists         bool
}

type DocumentStatus struct {
	Name     string
	Disabled bool
}

type DocumentUpdate struct {
	UUID    uuid.UUID
	Version int64
	Creator string
	Created time.Time
	Meta    newsdoc.DataMap
}

type DocumentValidator interface {
	ValidateDocument(ctx context.Context, document *newsdoc.Document) []revisor.ValidationResult
}

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

type Event struct {
	ID           int64      `json:"id"`
	Event        EventType  `json:"event"`
	UUID         uuid.UUID  `json:"uuid"`
	Timestamp    time.Time  `json:"timestamp"`
	Updater      string     `json:"updater"`
	Type         string     `json:"type"`
	Language     string     `json:"language"`
	OldLanguage  string     `json:"old_language,omitempty"`
	MainDocument *uuid.UUID `json:"main_document,omitempty"`
	Version      int64      `json:"version,omitempty"`
	StatusID     int64      `json:"status_id,omitempty"`
	Status       string     `json:"status,omitempty"`
	ACL          []ACLEntry `json:"acl,omitempty"`
}

type EventType string

type FanOut[T any] struct {
	// contains filtered or unexported fields
}

type GetCompactedEventlogRequest struct {
	After  int64
	Until  int64
	Type   string
	Limit  *int32
	Offset int32
}

type Lock struct {
	Token   string
	URI     string
	Created time.Time
	Expires time.Time
	App     string
	Comment string
}

type LockRequest struct {
	UUID    uuid.UUID
	URI     string
	TTL     int32
	App     string
	Comment string
}

type LockResult struct {
	Token   string
	Created time.Time
	Expires time.Time
}

type Metric struct {
	UUID  uuid.UUID
	Kind  string
	Label string
	Value int64
}

type MetricKind struct {
	Name        string
	Aggregation Aggregation
}

type MetricStore interface {
	RegisterMetricKind(
		ctx context.Context, name string, aggregation Aggregation,
	) error
	DeleteMetricKind(
		ctx context.Context, name string,
	) error
	GetMetricKind(
		ctx context.Context, name string,
	) (*MetricKind, error)
	GetMetricKinds(
		ctx context.Context,
	) ([]*MetricKind, error)
	RegisterOrReplaceMetric(
		ctx context.Context, metric Metric,
	) error
	RegisterOrIncrementMetric(
		ctx context.Context, metric Metric,
	) error
}

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

type NotifyChannel string

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

type PGDocStoreOptions struct {
	DeleteTimeout time.Duration
}

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

type Permission string

type Queryer interface {
	Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error)
}

type RegisterSchemaRequest struct {
	Name          string
	Version       string
	Specification revisor.ConstraintSet
	Activate      bool
}

type Report struct {
	Name           string        `json:"name"`
	Title          string        `json:"title"`
	CronExpression string        `json:"cron_expression"`
	CronTimezone   string        `json:"cron_timezone"`
	GenerateSheet  bool          `json:"generate_sheet,omitempty"`
	Queries        []ReportQuery `json:"queries"`
	SlackChannels  []string      `json:"slack_channels,omitempty"`
}

type ReportListItem struct {
	Name           string `json:"name"`
	Title          string `json:"title"`
	CronExpression string `json:"cron_expression"`
	CronTimezone   string `json:"cron_timezone"`
}

type ReportObject struct {
	Specification Report    `json:"specification"`
	Tables        []string  `json:"tables"`
	Created       time.Time `json:"created"`
}

type ReportQuery struct {
	Name            string                          `json:"name"`
	SQL             string                          `json:"sql"`
	ValueProcessing map[string][]ReportValueProcess `json:"value_processing,omitempty"`
	Summarise       []int                           `json:"summarize,omitempty"`
}

type ReportResult struct {
	Tables      []string
	Spreadsheet *bytes.Buffer
}

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

type ReportRunnerOptions struct {
	Logger *slog.Logger
	S3     *s3.Client
	Bucket string
	// ReportQueryer should be a read-only connection to the database with
	// access to the tables `document`, `delete_record`, `document_version`,
	// `document_status`, `status_heads`, `acl`, `acl_audit`.
	ReportQueryer Queryer
	// DB should be a normal database connection with full repository
	// access.
	DB                *pgxpool.Pool
	MetricsRegisterer prometheus.Registerer
}

type ReportStore interface {
	ListReports(
		ctx context.Context,
	) ([]ReportListItem, error)
	UpdateReport(
		ctx context.Context, report Report, enabled bool,
	) (time.Time, error)
	GetReport(
		ctx context.Context, name string,
	) (*StoredReport, error)
	DeleteReport(
		ctx context.Context, name string,
	) error
}

type ReportValueProcess string

type Reporter interface {
	AddHeader(q ReportQuery, columns []string) error
	AddRow(values []any) error
	QueryDone() error
}

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

type RouterOption func(router *httprouter.Router) error

type S3Options struct {
	Endpoint        string
	AccessKeyID     string
	AccessKeySecret string
	DisableHTTPS    bool
	HTTPClient      *http.Client
}

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

type Schema struct {
	Name          string
	Version       string
	Specification revisor.ConstraintSet
}

type SchemaEvent struct {
	Type SchemaEventType `json:"type"`
	Name string          `json:"name"`
}

type SchemaEventType int

type SchemaLoader interface {
	GetActiveSchemas(ctx context.Context) ([]*Schema, error)
	OnSchemaUpdate(ctx context.Context, ch chan SchemaEvent)
}

type SchemaStore interface {
	RegisterSchema(
		ctx context.Context, req RegisterSchemaRequest,
	) error
	ActivateSchema(
		ctx context.Context, name, version string,
	) error
	DeactivateSchema(
		ctx context.Context, name string,
	) error
	GetSchema(
		ctx context.Context, name, version string,
	) (*Schema, error)
	GetActiveSchemas(ctx context.Context) ([]*Schema, error)
	GetSchemaVersions(ctx context.Context) (map[string]string, error)
	OnSchemaUpdate(ctx context.Context, ch chan SchemaEvent)
	RegisterMetaType(
		ctx context.Context, metaType string, exclusive bool,
	) error
	RegisterMetaTypeUse(
		ctx context.Context, mainType string, metaType string,
	) error
}

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

type ServerOptions struct {
	Hooks          *twirp.ServerHooks
	AuthMiddleware func(
		w http.ResponseWriter, r *http.Request, next http.Handler,
	) error
}

type SigningKey struct {
	Spec *jwk.KeySpec `json:"spec"`

	// Key timestamps
	IssuedAt  time.Time `json:"iat"`
	NotBefore time.Time `json:"nbf"`
}

type SigningKeySet struct {
	Keys []SigningKey `json:"keys"`
	// contains filtered or unexported fields
}

type SpreadsheetReporter struct {
	File *excelize.File
	// contains filtered or unexported fields
}

type Status struct {
	ID             int64
	Version        int64
	Creator        string
	Created        time.Time
	Meta           newsdoc.DataMap
	MetaDocVersion int64
}

type StatusRule struct {
	Name        string
	Description string
	AccessRule  bool
	AppliesTo   []string
	ForTypes    []string
	Expression  string
}

type StatusRuleError struct {
	Violations []StatusRuleViolation
}

type StatusRuleInput struct {
	Name        string
	Status      Status
	Update      DocumentUpdate
	Document    newsdoc.Document
	VersionMeta newsdoc.DataMap
	Heads       map[string]Status
	User        elephantine.JWTClaims
}

type StatusRuleViolation struct {
	Name            string
	Description     string
	Error           string
	AccessViolation bool
}

type StatusUpdate struct {
	Name    string
	Version int64
	Meta    newsdoc.DataMap
}

type StoredReport struct {
	Report        Report
	Enabled       bool
	NextExecution time.Time
}

type TableReporter struct {
	Tables []table.Writer
	// contains filtered or unexported fields
}

type TokenResponse struct {
	AccessToken  string `json:"access_token"`
	TokenType    string `json:"token_type"`
	ExpiresIn    int    `json:"expires_in"`
	RefreshToken string `json:"refresh_token"`
}

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

type UpdateLockRequest struct {
	UUID  uuid.UUID
	TTL   int32
	Token string
}

type UpdateRequest struct {
	UUID         uuid.UUID
	Updated      time.Time
	Updater      string
	Meta         newsdoc.DataMap
	ACL          []ACLEntry
	DefaultACL   []ACLEntry
	Status       []StatusUpdate
	Document     *newsdoc.Document
	MainDocument *uuid.UUID
	IfMatch      int64
	LockToken    string
}

type UpdateStatusRequest struct {
	Name     string
	Disabled bool
}

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

type WorkflowEvent struct {
	Type WorkflowEventType `json:"type"`
	Name string            `json:"name"`
}

type WorkflowEventType int

type WorkflowLoader interface {
	GetStatuses(ctx context.Context) ([]DocumentStatus, error)
	GetStatusRules(ctx context.Context) ([]StatusRule, error)
	OnWorkflowUpdate(ctx context.Context, ch chan WorkflowEvent)
}

type WorkflowProvider interface {
	HasStatus(name string) bool
	EvaluateRules(input StatusRuleInput) []StatusRuleViolation
}

type WorkflowStore interface {
	UpdateStatus(
		ctx context.Context, req UpdateStatusRequest,
	) error
	GetStatuses(ctx context.Context) ([]DocumentStatus, error)
	UpdateStatusRule(
		ctx context.Context, rule StatusRule,
	) error
	DeleteStatusRule(
		ctx context.Context, name string,
	) error
	GetStatusRules(ctx context.Context) ([]StatusRule, error)
}

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

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