File Uploads

curl -X POST https://api.example.com/api/v1/blobs \
  -H "Authorization: Bearer $TOKEN" \
  -F "[email protected]" \
  -F "visibility=public"

{ "type": "base64", "data": "iVBORw0KGgo...", "filename": "photo.png", "mime_type": "image/png" }

use Glueful\Http\Response;
use Glueful\Uploader\FileUploader;

public function upload(): Response
{
    if ($this->currentUser === null) {
        return $this->unauthorized();
    }

    $uploader = app($this->getContext(), FileUploader::class);

    $result = $uploader->handleUpload(
        token: $this->currentUser->uuid(),
        getParams: ['user_id' => $this->currentUser->uuid()],
        fileParams: $this->request->files->all()
    );

    if (isset($result['error'])) {
        return Response::error($result['error'], $result['code']);
    }

    return Response::created([
        'uuid' => $result['uuid'],
        'url' => $result['url'],
    ]);
}

foreach (array_keys($this->request->files->all()) as $field) {
    $result = $uploader->handleUpload(
        token: $this->currentUser->uuid(),
        getParams: ['user_id' => $this->currentUser->uuid(), 'key' => $field],
        fileParams: $this->request->files->all()
    );

    if (!isset($result['error'])) {
        $uploaded[] = $result;
    }
}

use Glueful\Validation\ValidationException;

public function uploadMedia(string $postUuid): Response
{
    $uploader = app($this->getContext(), FileUploader::class);
    $file = $this->request->files->get('file');

    try {
        $result = $uploader->uploadMedia($file, 'posts/' . $postUuid, [
            'visibility' => 'public',
        ]);
    } catch (ValidationException $e) {
        return Response::error($e->getMessage(), 422);
    }

    // [
    //     'type' => 'image',             // image, video, audio, or file
    //     'url' => 'https://...',
    //     'thumb_url' => 'https://...',  // null without glueful/media
    //     'mime_type' => 'image/jpeg',
    //     'size_bytes' => 245678,
    //     'width' => 1920,               // null without glueful/media
    //     'height' => 1080,
    //     'duration_s' => null,          // video/audio duration
    //     'filename' => '1704123456_abc123.jpg',
    //     'path' => 'posts/uuid/1704123456_abc123.jpg',
    //     'blob_uuid' => 'abc123def456',
    // ]

    return Response::created($result);
}

$result = $uploader->uploadMedia($file, 'gallery/', [
    'generate_thumbnail' => true,   // Default: true for images
    'thumbnail_width' => 800,       // Default: 400
    'thumbnail_height' => 600,      // Default: 400
    'thumbnail_quality' => 90,      // Default: 80
    'save_to_blobs' => true,        // Default: true
    'visibility' => 'private',      // Default: uploads.default_visibility
]);

return [
    'enabled' => env('UPLOADS_ENABLED', true),
    'allowed_types' => ['image/*', 'video/*', 'audio/*', 'application/pdf'], // wildcards supported
    'max_size' => env('UPLOADS_MAX_SIZE', 10 * 1024 * 1024),
    'access' => env('UPLOADS_ACCESS', 'private'),
    'disk' => env('UPLOADS_DISK', 'uploads'),
    'default_visibility' => env('UPLOADS_DEFAULT_VISIBILITY', 'private'),
    'purge_deleted_after_days' => (int) env('UPLOADS_PURGE_DELETED_AFTER_DAYS', 30),
    'security' => [
        'scan_uploads' => true,
        'strip_exif' => env('UPLOADS_STRIP_EXIF', true),
    ],
    // also: signed_urls, native_urls, image_processing, thumbnails, rate_limits, response
];

$file = $this->request->files->get('file');

if ($file === null || $file->getSize() > 5 * 1024 * 1024) {
    return Response::error('File too large', 422);
}

if (!in_array($file->getMimeType(), ['image/jpeg', 'image/png', 'application/pdf'], true)) {
    return Response::error('Invalid file type', 422);
}

use Glueful\Uploader\Contracts\{BlobAccessContext, BlobAccessPolicy, BlobAccessPolicyRegistry, BlobAction};

final class OwnerOnlyDelete implements BlobAccessPolicy
{
    public function authorizeAccess(array $blob, BlobAccessContext $context): bool
    {
        if ($context->action !== BlobAction::DELETE) {
            return true;
        }
        return $context->authenticatedUserUuid !== null
            && $context->authenticatedUserUuid === ($blob['created_by'] ?? null);
    }
}

// In your ServiceProvider::boot()
$this->app->get(BlobAccessPolicyRegistry::class)->register('acme.owner-delete', new OwnerOnlyDelete());

php glueful blobs:purge                 # uses uploads.purge_deleted_after_days
php glueful blobs:purge --days=7 --limit=500

composer require glueful/storage-s3     # S3, R2, MinIO, Spaces, Wasabi
composer require glueful/storage-gcs    # Google Cloud Storage
composer require glueful/storage-azure  # Azure Blob Storage

use Glueful\Storage\StorageManager;

$storage = app($this->getContext(), StorageManager::class);
$disk = $storage->disk();

$disk->write('avatars/user123.jpg', $fileContent);
$content = $disk->read('avatars/user123.jpg');

if ($disk->fileExists('avatars/user123.jpg')) {
    $disk->delete('avatars/user123.jpg');
}

foreach ($storage->listContents('avatars') as $attr) {
    echo $attr->path();
}

use Glueful\Storage\StorageManager;
use Glueful\Storage\Support\UrlGenerator;
use Glueful\Uploader\Storage\FlysystemStorage;

$disk = new FlysystemStorage(
    app($this->getContext(), StorageManager::class),
    app($this->getContext(), UrlGenerator::class),
    's3'
);

$signedUrl = $disk->getSignedUrl('documents/invoice.pdf', 3600);

$uploader = app($this->getContext(), FileUploader::class);

$tempPath = $uploader->handleBase64Upload($base64);          // base64 → temp file path
$stats = $uploader->getDirectoryStats('uploads/');
$cleanup = $uploader->cleanupOldFiles('temp/', 2592000);      // older than 30 days
$checksum = $uploader->calculateChecksum($filePath);          // SHA-256 hex

// ✅ Good - async processing
$result = $uploader->uploadMedia($file, 'images/');
app($this->getContext(), \Glueful\Queue\QueueManager::class)
    ->push(ProcessImageJob::class, ['path' => $result['path']]);

// ❌ Bad - blocks response
$this->processImage($result['path']); // Slow!