uploadrevision

type CompressionRoundTripper ¶

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

CompressionRoundTripper is an http.RoundTripper that automatically compresses request bodies using gzip compression. It wraps another RoundTripper and adds Content-Encoding: gzip header while removing Content-Length to allow proper compression handling.

func NewCompressionRoundTripper(drt http.RoundTripper) *CompressionRoundTripper

func (crt *CompressionRoundTripper) RoundTrip(r *http.Request) (*http.Response, error)

type Config ¶

type Config struct {
	BaseURL string
}

Config contains the configuration for the file upload client.

type ErrorResponseBody ¶

type ErrorResponseBody struct {
	Errors []ResponseError `json:"errors"`
}

ErrorResponseBody contains the complete error response body.

type FakeClientConfig ¶

type FakeClientConfig struct {
	Limits
}

type FakeSealableClient ¶

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

FakeSealableClient is a mock implementation of the SealableClient for testing. It tracks revisions in memory and enforces the revision lifecycle (create -> upload -> seal).

func NewFakeSealableClient(cfg FakeClientConfig) *FakeSealableClient

func (f *FakeSealableClient) CreateRevision(_ context.Context, orgID OrgID) (*ResponseBody, error)

func (f *FakeSealableClient) GetLimits() Limits

func (f *FakeSealableClient) GetSealedRevisionFiles(revisionID RevisionID) ([]LoadedFile, error)

func (f *FakeSealableClient) SealRevision(_ context.Context, orgID OrgID, revisionID RevisionID) (*SealResponseBody, error)

func (f *FakeSealableClient) UploadFiles(_ context.Context, orgID OrgID, revisionID RevisionID, files []UploadFile) error

type FileAccessError ¶

type FileAccessError struct {
	FilePath string
	Err      error
}

FileAccessError indicates a file cannot be accessed or read.

func NewFileAccessError(filePath string, err error) *FileAccessError

func (e *FileAccessError) Error() string

func (e *FileAccessError) Unwrap() error

type FileCountLimitError ¶

type FileCountLimitError struct {
	Count int
	Limit int
}

FileCountLimitError indicates too many files were provided.

func NewFileCountLimitError(count, limit int) *FileCountLimitError

func (e *FileCountLimitError) Error() string

type FilePathLengthLimitError ¶

type FilePathLengthLimitError struct {
	FilePath string
	Length   int
	Limit    int
}

FilePathLengthLimitError indicates a file path exceeds the maximum allowed length.

func NewFilePathLengthLimitError(filePath string, length, limit int) *FilePathLengthLimitError

func (e *FilePathLengthLimitError) Error() string

type FileSizeLimitError ¶

type FileSizeLimitError struct {
	FilePath string
	FileSize int64
	Limit    int64
}

FileSizeLimitError indicates a file exceeds the maximum allowed size.

func NewFileSizeLimitError(filePath string, fileSize, limit int64) *FileSizeLimitError

func (e *FileSizeLimitError) Error() string

type HTTPError ¶

type HTTPError struct {
	StatusCode int
	Status     string
	Operation  string
	Body       []byte
}

HTTPError represents an HTTP error response.

func NewHTTPError(statusCode int, status, operation string, body []byte) *HTTPError

func (e *HTTPError) Error() string

type HTTPSealableClient ¶

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

HTTPSealableClient implements the SealableClient interface for file upload operations via HTTP API.

func NewClient(cfg Config, opts ...Opt) *HTTPSealableClient

func (c *HTTPSealableClient) CreateRevision(ctx context.Context, orgID OrgID) (*ResponseBody, error)

func (c *HTTPSealableClient) GetLimits() Limits

func (c *HTTPSealableClient) SealRevision(ctx context.Context, orgID OrgID, revisionID RevisionID) (*SealResponseBody, error)

func (c *HTTPSealableClient) UploadFiles(ctx context.Context, orgID OrgID, revisionID RevisionID, files []UploadFile) error

type Limits ¶

type Limits struct {
	// FileCountLimit specifies the maximum number of files allowed in a single upload.
	FileCountLimit int
	// FileSizeLimit specifies the maximum allowed file size in bytes.
	FileSizeLimit int64
	// TotalPayloadSizeLimit specifies the maximum total uncompressed payload size in bytes.
	TotalPayloadSizeLimit int64
	// FilePathLengthLimit specifies the maximum allowed file name length in characters.
	FilePathLengthLimit int
}

Limits contains the limits enforced by the low level client.

type LoadedFile ¶

type LoadedFile struct {
	Path    string
	Content string
}

type MultipartError ¶

type MultipartError struct {
	FilePath string
	Err      error
}

MultipartError indicates an error creating multipart form data.

func NewMultipartError(filePath string, err error) *MultipartError

func (e *MultipartError) Error() string

func (e *MultipartError) Unwrap() error

type Opt ¶

type Opt func(*HTTPSealableClient)

Opt is a function that configures an HTTPSealableClient instance.

func WithHTTPClient(httpClient *http.Client) Opt

type OrgID ¶

type OrgID = uuid.UUID

OrgID represents an organization identifier.

type RequestAttributes ¶

type RequestAttributes struct {
	RevisionType RevisionType `json:"revision_type"` //nolint:tagliatelle // API expects snake_case
}

RequestAttributes contains the attributes for creating an upload revision.

type RequestBody ¶

type RequestBody struct {
	Data RequestData `json:"data"`
}

RequestBody contains the complete request body for creating an upload revision.

type RequestData ¶

type RequestData struct {
	Attributes RequestAttributes `json:"attributes"`
	Type       ResourceType      `json:"type"`
}

RequestData contains the data payload for creating an upload revision.

type ResourceType ¶

type ResourceType string

ResourceType represents the type of resource in API requests.

const (
	// ResourceTypeUploadRevision represents an upload revision resource type.
	ResourceTypeUploadRevision ResourceType = "upload_revision"
)

type ResponseAttributes ¶

type ResponseAttributes struct {
	RevisionType RevisionType `json:"revision_type"` //nolint:tagliatelle // API expects snake_case
	Sealed       bool         `json:"sealed"`
}

ResponseAttributes contains the attributes returned when creating an upload revision.

type ResponseBody ¶

type ResponseBody struct {
	Data ResponseData `json:"data"`
}

ResponseBody contains the complete response body when creating an upload revision.

type ResponseData ¶

type ResponseData struct {
	ID         RevisionID         `json:"id"`
	Type       ResourceType       `json:"type"`
	Attributes ResponseAttributes `json:"attributes"`
}

ResponseData contains the data returned when creating an upload revision.

type ResponseError ¶

type ResponseError struct {
	ID     string `json:"id"`
	Title  string `json:"title"`
	Status string `json:"status"`
	Detail string `json:"detail"`
}

ResponseError represents an error in an API response.

type RevisionID ¶

type RevisionID = uuid.UUID

RevisionID represents a revision identifier.

type RevisionType ¶

type RevisionType string

RevisionType represents the type of revision being created.

const (
	// RevisionTypeSnapshot represents a snapshot revision type.
	RevisionTypeSnapshot RevisionType = "snapshot"
)

type SealRequestAttributes ¶

type SealRequestAttributes struct {
	Sealed bool `json:"sealed"`
}

SealRequestAttributes contains the attributes for sealing an upload revision.

type SealRequestBody ¶

type SealRequestBody struct {
	Data SealRequestData `json:"data"`
}

SealRequestBody contains the complete request body for sealing an upload revision.

type SealRequestData ¶

type SealRequestData struct {
	ID         RevisionID            `json:"id"`
	Type       ResourceType          `json:"type"`
	Attributes SealRequestAttributes `json:"attributes"`
}

SealRequestData contains the data payload for sealing an upload revision.

type SealResponseAttributes ¶

type SealResponseAttributes struct {
	RevisionType RevisionType `json:"revision_type"` //nolint:tagliatelle // API expects snake_case
	Sealed       bool         `json:"sealed"`
}

SealResponseAttributes contains the attributes returned when sealing an upload revision.

type SealResponseBody ¶

type SealResponseBody struct {
	Data SealResponseData `json:"data"`
}

SealResponseBody contains the complete response body when sealing an upload revision.

type SealResponseData ¶

type SealResponseData struct {
	ID         RevisionID             `json:"id"`
	Type       ResourceType           `json:"type"`
	Attributes SealResponseAttributes `json:"attributes"`
}

SealResponseData contains the data returned when sealing an upload revision.

type SealableClient ¶

type SealableClient interface {
	CreateRevision(ctx context.Context, orgID OrgID) (*ResponseBody, error)
	UploadFiles(ctx context.Context, orgID OrgID, revisionID RevisionID, files []UploadFile) error
	SealRevision(ctx context.Context, orgID OrgID, revisionID RevisionID) (*SealResponseBody, error)

	GetLimits() Limits
}

SealableClient defines the interface for file upload API operations.

type SpecialFileError ¶

type SpecialFileError struct {
	FilePath string
	Mode     os.FileMode
}

SpecialFileError indicates a path points to a special file (device, pipe, socket, etc.) instead of a regular file.

func NewSpecialFileError(path string, mode os.FileMode) *SpecialFileError

func (e *SpecialFileError) Error() string

type TotalPayloadSizeLimitError ¶

type TotalPayloadSizeLimitError struct {
	TotalSize int64
	Limit     int64
}

TotalPayloadSizeLimitError indicates the total size of all files exceeds the maximum allowed payload size.

func NewTotalPayloadSizeLimitError(totalSize, limit int64) *TotalPayloadSizeLimitError

func (e *TotalPayloadSizeLimitError) Error() string

type UploadFile ¶

type UploadFile struct {
	Path string // The path of the uploaded file, relative to the root directory.

	// Size is the size in bytes of the content Reader produces. It is measured before the
	// upload, so a file changing in between makes it disagree with what is streamed.
	Size int64

	// Reader produces the content to upload. It is read while the file is streamed, so the
	// content is only held in memory for as long as that file is being uploaded.
	Reader io.Reader
}

UploadFile represents a file to be uploaded: where it goes, how large its content is, and a reader producing that content.