Storage in depth

// schema.ts
import { table, t } from "cubek"

export const files = table("files", {
  id: t.id(),
  ownerId: t.string(),
  key: t.string().unique(),
  name: t.string(),
  type: t.string(),
  size: t.number(),
  status: t.enum(["pending", "ready"]).default("ready"),
  createdAt: t.timestamp().default("now"),
}).index("ownerId", "createdAt")

// src/app.tsx
import { app, crypto, db, storage, type Bytes } from "cubek"
import "./routes/uploads"

const ALLOWED = ["image/png", "image/jpeg", "image/webp", "application/pdf"]

app.post("/files", async (c) => {
  const form = await c.body<{ file?: { name: string; type: string; size: number; bytes: Bytes } }>()
  const f = form.file
  if (f === undefined || f.size === 0) return c.text("choose a file", 400)
  if (!ALLOWED.includes(f.type)) return c.text("unsupported type", 415)
  if (f.size > 5 * 1024 * 1024) return c.text("too large (5 MB max)", 413)
  const key = `u/demo/${crypto.randomUUID()}`
  await storage.put(key, f.bytes, { contentType: f.type })
  const row = await db.files.insert({ ownerId: "demo", key, name: f.name, type: f.type, size: f.size })
  return c.redirect(`/files/${row.id}`, 303)
})

// Download: check access, then redirect to a short-lived signed URL.
app.get("/files/:id", async (c) => {
  const row = await db.files.get(c.param("id"))
  if (row === null || row.status !== "ready") return c.notFound()
  return c.redirect(storage.url(row.key, { expires: "10m" }), 302)
})

// Or stream the bytes through the app (small files, custom headers).
app.get("/files/:id/raw", async (c) => {
  const row = await db.files.get(c.param("id"))
  const bytes = row === null ? null : await storage.get(row.key)
  if (row === null || bytes === null) return c.notFound()
  return c.body(bytes, 200, { "content-type": row.type, "content-disposition": `attachment; filename="${row.name.replaceAll("\"", "")}"` })
})

app.post("/files/:id/delete", async (c) => {
  const row = await db.files.get(c.param("id"))
  if (row === null) return c.notFound()
  await storage.delete(row.key)
  await db.files.delete(row.id)
  return c.redirect("/", 303)
})

// src/routes/uploads.ts
import { app, crypto, db, storage, validate } from "cubek"

const req = validate.object({ name: validate.string({ min: 1, max: 200 }), type: validate.string(), size: validate.number({ min: 1, max: 100 * 1024 * 1024 }) })

app.post("/api/uploads", async (c) => {
  const p = req.safeParse(await c.body())
  if (!p.success) return c.json({ error: p.error }, 400)
  const key = `big/${crypto.randomUUID()}`
  const row = await db.files.insert({ ownerId: "demo", key, name: p.data.name, type: p.data.type, size: p.data.size, status: "pending" })
  const url = storage.uploadUrl(key, { maxSize: p.data.size, contentType: p.data.type, expires: "15m" })
  return c.json({ id: row.id, url })
})

app.post("/api/uploads/:id/done", async (c) => {
  const row = await db.files.get(c.param("id"))
  if (row === null) return c.json({ error: "not found" }, 404)
  const found = (await storage.list(row.key)).find((o) => o.key === row.key)
  if (found === undefined) return c.json({ error: "not uploaded" }, 409)
  await db.files.update(row.id, { status: "ready", size: found.size })
  return c.json({ ok: true })
})

const { id, url } = await (await fetch("/api/uploads", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ name: file.name, type: file.type, size: file.size }) })).json()
await fetch(url, { method: "PUT", headers: { "content-type": file.type }, body: file })
await fetch(`/api/uploads/${id}/done`, { method: "POST" })