A data export produced by a background job, from request to download.

Pure halves of the upload index: the record a store makes, and what data
export shows of it.

Pure functional file validation logic.

This namespace contains no side effects - only pure functions for validating
files based on size, type, extension, etc.

Port definitions for file storage functionality.

This namespace defines the contracts that storage adapters must implement.
Follows the Functional Core / Imperative Shell pattern where ports define
the boundaries between pure logic and side effects.

Malli schemas for file storage validation.

Google Cloud Storage adapter.

Implements IFileStorage for storing files in Google Cloud Storage (GCS).
Suitable for production deployments on Google Cloud requiring scalable
object storage.

Java AWT-based image processing implementation.

Implements IImageProcessor using Java's built-in image processing capabilities.
No external dependencies required.

Local filesystem storage adapter.

Implements IFileStorage for storing files on the local filesystem.
Suitable for development and single-server deployments.

Amazon S3 storage adapter.

Implements IFileStorage for storing files in AWS S3 or S3-compatible services.
Suitable for production deployments requiring scalable object storage.

A streamed file written to a temporary file before it is stored: that
gives the length an upload needs up front without holding the file in
memory, and leaves nothing stored when the writer fails.

The storage module's contributions to data export and retention: a
subject's uploads, listed and, in a zip export, included; and the upload
retention policy.

Data export as a background job: POST /me/export-jobs for a signed-in
user's own, or `ExportJobs` for another module's admin export; then
GET /me/export-jobs/:id until it is done, then
GET /me/export-jobs/:id/download. A job is visible only to who asked, and
an export of someone else's data only while they are a platform admin.

`IExportJobStore` on the application database.

Data export as a background job, for a subject too large to zip during a
request: the job writes the archive to file storage, and its requester
downloads it for a day. Needs the jobs module.

`ctx` here is {:store IExportJobStore :file-storage IFileStorage
:provider kw :data-export IDataExport :job-queue IJobQueue :queue kw
:requests-per-hour n}.

HTTP handlers for file upload and download operations.

Provides Ring-compatible handlers for file operations.

Integrant lifecycle for the storage module.

Config key:

:wagoe/storage
  {:provider :local :root "uploads"}                ; local filesystem
  {:provider :s3  :bucket "b" :region "eu-west-1"}  ; AWS S3 / compatible
  {:provider :gcs :bucket "b" :project-id "p"}      ; Google Cloud Storage

  Returns {:provider <kw> :storage <IFileStorage> :service <IStorageService>}.
  Consumers (e.g. :wagoe/storage-routes) use :service.

The module also records every upload in `storage_uploads`
(:wagoe.storage/upload-index), and contributes a subject's uploads to data
export and the `:storage/uploads` retention policy. With the jobs module it
also serves a user's export as a background job (`export-jobs`), offers
other modules the same as `:wagoe/export-jobs` (privacy/IExportJobs), and
contributes the `:storage/export-archives` retention policy.

The `:local` provider accepts the catalogue's `:root` as an alias for the
local adapter's `:base-path`.

Storage service orchestrating file operations.

This service coordinates file validation, storage, and image processing.
Follows the Functional Core / Imperative Shell pattern where this service
represents the imperative shell that coordinates pure validation logic
with side-effectful storage operations.

`IUploadIndex` on the application database, and the boot step that creates
its table.