Photo and video uploads for iOS and Android apps

import Foundation

struct PresignBody: Encodable { let filename: String; let contentType: String; let sizeBytes: Int64 }
struct UploadSlot: Decodable { let id: String; let uploadUrl: String?; let alreadyExists: Bool? }

// api is your backend, e.g. https://api.example.com. Add your own session auth header.
func upload(fileURL: URL, contentType: String, api: URL) async throws {
    let attributes = try FileManager.default.attributesOfItem(atPath: fileURL.path)
    let size = (attributes[.size] as? NSNumber)?.int64Value ?? 0

    // 1. Ask your backend for a single-use upload URL
    var presign = URLRequest(url: api.appendingPathComponent("uploads/presign"))
    presign.httpMethod = "POST"
    presign.setValue("application/json", forHTTPHeaderField: "Content-Type")
    presign.httpBody = try JSONEncoder().encode(
        PresignBody(filename: fileURL.lastPathComponent, contentType: contentType, sizeBytes: size))
    let (data, _) = try await URLSession.shared.data(for: presign)
    let slot = try JSONDecoder().decode(UploadSlot.self, from: data)

    // 2. PUT the bytes straight to Dreep; Content-Type must match the presign
    if let target = slot.uploadUrl.flatMap(URL.init(string:)) {
        var put = URLRequest(url: target)
        put.httpMethod = "PUT"
        put.setValue(contentType, forHTTPHeaderField: "Content-Type")
        let (_, response) = try await URLSession.shared.upload(for: put, fromFile: fileURL)
        guard let http = response as? HTTPURLResponse, (200..<300).contains(http.statusCode) else {
            throw URLError(.badServerResponse)
        }
    }

    // 3. Ask your backend to confirm
    var confirm = URLRequest(url: api.appendingPathComponent("uploads/\(slot.id)/confirm"))
    confirm.httpMethod = "POST"
    _ = try await URLSession.shared.data(for: confirm)
}

import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.asRequestBody
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject
import java.io.File

private val http = OkHttpClient()

// Run on Dispatchers.IO. api is your backend; add your own session auth header.
fun upload(file: File, contentType: String, api: String) {
    // 1. Ask your backend for a single-use upload URL
    val body = JSONObject()
        .put("filename", file.name)
        .put("contentType", contentType) // "image/heic", "image/jpeg" or "video/mp4"
        .put("sizeBytes", file.length())
        .toString()
        .toRequestBody("application/json".toMediaType())
    val slot = http.newCall(Request.Builder().url("$api/uploads/presign").post(body).build())
        .execute().use { JSONObject(it.body!!.string()) }

    // 2. PUT the bytes straight to Dreep; Content-Type and length must match
    if (!slot.optBoolean("alreadyExists")) {
        val put = Request.Builder()
            .url(slot.getString("uploadUrl"))
            .put(file.asRequestBody(contentType.toMediaType()))
            .build()
        http.newCall(put).execute().use { check(it.isSuccessful) { "Upload failed: ${it.code}" } }
    }

    // 3. Ask your backend to confirm
    val confirm = Request.Builder()
        .url("$api/uploads/${slot.getString("id")}/confirm")
        .post(ByteArray(0).toRequestBody(null))
        .build()
    http.newCall(confirm).execute().close()
}

import { Dreep } from "dreep";

const dreep = new Dreep({ apiKey: process.env.DREEP_API_KEY });

// POST /uploads/presign (the app calls this with its user session)
export const presignMobileUpload = async ({ userId, filename, contentType, sizeBytes }) => {
  const upload = await dreep.presignUpload({
    filename,
    contentType,
    sizeBytes,
    folder: "users/" + userId + "/uploads",
  });

  return { id: upload.id, uploadUrl: upload.uploadUrl, alreadyExists: upload.alreadyExists };
};

// POST /uploads/:id/confirm
export const confirmMobileUpload = async ({ id }) => {
  const asset = await dreep.confirmUpload({ id });

  if (asset.mimetype.startsWith("video/")) {
    return {
      id: asset.id,
      // An image format on a video returns a frame; append &time=2 to choose one.
      poster: dreep.url(asset, { format: "webp", width: 750 }),
      clip: dreep.url(asset, { format: "mp4", trimStart: 0, trimEnd: 6, width: 640 }),
      preview: dreep.url(asset, { format: "gif", trimStart: 0, trimEnd: 3, fps: 12, width: 384 }),
    };
  }

  // The app appends &dpr=1, 2 or 3 for its own screen.
  return {
    id: asset.id,
    feed: dreep.url(asset, { width: 384, fit: "inside", format: "avif", quality: 65 }),
    full: dreep.url(asset, { width: 1080, fit: "inside", format: "avif", quality: 75 }),
  };
};

// POST /uploads/presign
upload, err := client.PresignUpload(ctx, dreep.PresignOptions{
	Filename:    body.Filename,
	ContentType: body.ContentType, // "image/heic" is accepted as is
	SizeBytes:   body.SizeBytes,
	Destination: dreep.Destination{Folder: "users/" + userID + "/uploads"},
})

// POST /uploads/{id}/confirm
asset, err := client.ConfirmUpload(ctx, id, nil)

feed := client.URL(asset.ID, &dreep.Transform{
	Width:   384,
	Fit:     dreep.FitInside,
	Format:  dreep.FormatAVIF,
	Quality: 65,
})

// For a video: a 3-second, 12 fps GIF preview for the feed.
preview := client.URL(asset.ID, &dreep.Transform{
	Format:    dreep.FormatGIF,
	TrimStart: dreep.Ptr(0.0),
	TrimEnd:   dreep.Ptr(3.0),
	FPS:       12,
	Width:     384,
})

# 1. Your backend presigns (API key stays server side)
curl -X POST https://api.dreep.cloud/api/v1/upload/presign \
  -H "Authorization: Bearer $DREEP_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"filename":"IMG_0042.MOV","contentType":"video/quicktime","sizeBytes":48211340,
       "folder":"users/u_193/uploads"}'

# 2. The app PUTs to uploadUrl, then 3. your backend confirms
curl -X POST https://api.dreep.cloud/api/v1/upload/$UPLOAD_ID/confirm \
  -H "Authorization: Bearer $DREEP_API_KEY"

# Feed thumbnail at 2 seconds
curl -o poster.webp "https://cdn.dreep.cloud/api/v1/fetch/$UPLOAD_ID?format=webp&time=2&width=750"

# GIF preview: 202 while processing, 200 once cached. Re-request the same URL.
curl -i "https://cdn.dreep.cloud/api/v1/fetch/$UPLOAD_ID?format=gif&trimStart=0&trimEnd=3&fps=12&width=384"