Create Presigned Upload

upload, err := client.PresignUpload(ctx, dreep.PresignOptions{
    Filename:    "video.mp4",
    ContentType: "video/mp4",
    SizeBytes:   84_000_000,
    Destination: dreep.Destination{Folder: "uploads/2026"},
})

func (c *Client) PresignUpload(ctx context.Context, o dreep.PresignOptions) (*dreep.PresignedUpload, error)

type PresignedUpload struct {
    ID            string
    UploadURL     string // empty when AlreadyExists is true
    ContentType   string
    AlreadyExists bool
}

fi, _ := f.Stat()

asset, err := client.UploadPresigned(ctx, dreep.DirectUploadOptions{
    PresignOptions: dreep.PresignOptions{
        ContentType: "video/mp4",
        SizeBytes:   fi.Size(),
        Filename:    "clip.mp4",
        ContentHash: sha256Hex, // optional dedupe
    },
    File: f,
})

// POST /uploads — returns { id, uploadUrl } to the browser
func presignHandler(client *dreep.Client) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Authorise the signed-in user and enforce your own quotas first.
        var in struct {
            Filename    string `json:"filename"`
            ContentType string `json:"contentType"`
            SizeBytes   int64  `json:"sizeBytes"`
        }
        if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
            http.Error(w, "bad request", http.StatusBadRequest)
            return
        }
        upload, err := client.PresignUpload(r.Context(), dreep.PresignOptions{
            Filename:    in.Filename,
            ContentType: in.ContentType,
            SizeBytes:   in.SizeBytes,
            Destination: dreep.Destination{Folder: "user-uploads"},
        })
        if err != nil {
            http.Error(w, "could not start upload", http.StatusBadGateway)
            return
        }
        json.NewEncoder(w).Encode(map[string]string{
            "id":        upload.ID,
            "uploadUrl": upload.UploadURL,
        })
    })
}

// POST /uploads/{id}/confirm — finalises the upload once the browser's PUT is done
func confirmHandler(client *dreep.Client) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // Check the id belongs to an upload this user started.
        asset, err := client.ConfirmUpload(r.Context(), r.PathValue("id"), nil)
        if err != nil {
            http.Error(w, "could not confirm upload", http.StatusBadGateway)
            return
        }
        json.NewEncoder(w).Encode(asset)
    })
}

mux := http.NewServeMux()
mux.Handle("POST /uploads", presignHandler(client))
mux.Handle("POST /uploads/{id}/confirm", confirmHandler(client))

await fetch(uploadUrl, { method: "PUT", body: file, headers: { "Content-Type": file.type } });
await fetch(`/uploads/${id}/confirm`, { method: "POST" });

upload, err := client.PresignUpload(ctx, dreep.PresignOptions{
    ContentType: "image/png",
    SizeBytes:   size,
    Filename:    "logo.png",
    ContentHash: sha256Hex,
})
if err != nil {
    return err
}
if !upload.AlreadyExists {
    // PUT the bytes to upload.UploadURL
}
asset, err := client.ConfirmUpload(ctx, upload.ID, nil)