upload

type ClamAVScanner struct {
	// Addr is clamd's host:port.
	Addr string
	// Timeout bounds dialing and each read or write (default 30s).
	Timeout time.Duration
	// ChunkSize is the INSTREAM chunk size (default 64 KiB). Keep it
	// below clamd's StreamMaxLength.
	ChunkSize int
}

type DirectConfig struct {
	Presigner Presigner
	Rules     Rules
	// TTL of the presigned URLs (default 15 minutes, at most 1 hour).
	TTL time.Duration
	// Authorize runs first; an error denies the request (required).
	Authorize func(r *http.Request) error
}

type File struct {
	// Field is the form field name.
	Field string `json:"field"`
	// Name is the client's file name, sanitized. It is metadata only and
	// never part of Path.
	Name string `json:"name"`
	// Path is where the file was stored on the disk (random name).
	Path string `json:"path"`
	// Type is the MIME type detected from the content.
	Type string `json:"type"`
	// Size in bytes.
	Size int64 `json:"size"`
	// SHA256 is the hex digest of the content.
	SHA256 string `json:"sha256"`
}

type Form struct {
	Values url.Values
	Files  []File
}

type InfectedError struct {
	Signature string
}

type Presigned struct {
	// Key is the object's path on the disk (random name under Rules.Dir).
	Key string `json:"key"`
	// URL, Method and Headers describe the request to send.
	URL     string            `json:"url"`
	Method  string            `json:"method"`
	Headers map[string]string `json:"headers,omitempty"`
	// ExpiresAt is when the URL stops working.
	ExpiresAt time.Time `json:"expires_at"`
}

type Presigner interface {
	PresignPut(
		ctx context.Context,
		key, contentType string,
		maxSize int64,
		ttl time.Duration,
	) (url string, headers http.Header, err error)
}

type Rules struct {
	// MaxFileSize is the largest file in bytes (required).
	MaxFileSize int64
	// MaxSize caps the whole request body; 0 = MaxFiles*MaxFileSize + 1 MiB.
	// It replaces the router-wide body limit for this request.
	MaxSize int64
	// MaxFiles is the number of files accepted (default 1).
	MaxFiles int
	// Types are the allowed MIME types, matched against the type detected
	// from the content (http.DetectContentType); the client's
	// Content-Type is ignored (required).
	Types []string
	// Extensions optionally narrow the accepted file name extensions
	// (".jpg"). The extension must always match the detected type.
	Extensions []string
	// Dir is the directory files are stored under.
	Dir string
	// MaxFields and MaxFieldSize bound non-file fields (defaults 32, 64 KiB).
	MaxFields    int
	MaxFieldSize int64
	// Scanner, when set, scans every file in QuarantineDir before moving
	// it to Dir; infected files are deleted and rejected.
	Scanner Scanner
	// QuarantineDir holds files until they are scanned (default
	// "quarantine"). Quarantined names start with a dot, so
	// storage.Handler never serves them.
	QuarantineDir string
}

type Scanner interface {
	Scan(ctx context.Context, r io.Reader) error
}

type TusConfig struct {
	// Dir holds partial uploads (opened with os.Root; created if needed).
	// Keep it outside any publicly served directory.
	Dir string
	// BasePath is the URL path the handler is mounted at ("/uploads/tus/");
	// upload URLs are BasePath + id.
	BasePath string
	// MaxSize is the largest Upload-Length accepted (required).
	MaxSize int64
	// Authorize runs before every request except OPTIONS; an error denies
	// it (its status when it has one, 403 otherwise). Required: upload
	// endpoints are never open by accident.
	Authorize func(r *http.Request) error
	// OnComplete receives a finished upload. open reads its bytes (close
	// it before returning). It typically calls Save to validate the
	// content and move it to a disk. The partial data is deleted after it
	// returns; an error is sent to the client (422 for validation errors).
	OnComplete func(ctx context.Context, info TusInfo, open func() (io.ReadCloser, error)) error
	// Expiry is how long an unfinished upload is kept (default 24h).
	// Call Cleanup periodically (scheduler) to delete expired uploads.
	Expiry time.Duration
	// Now is the clock (default time.Now).
	Now func() time.Time
}

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

type TusInfo struct {
	ID       string            `json:"id"`
	Length   int64             `json:"length"`
	Offset   int64             `json:"-"`
	Metadata map[string]string `json:"metadata,omitempty"`
	Created  time.Time         `json:"created"`
	Expires  time.Time         `json:"expires"`
}