server: discard unused blobs and dont store files which would take the blob storage for a user over ~0.25gb

server/src/backfill/blob.ts

···
 import { Client, simpleFetchHandler } from "@atcute/client";
-import { getPds } from "../utils.ts";
+import { getPds, MAX_SITE_SIZE } from "../utils.ts";
 
 export default async function (
   did: `did:${"plc" | "web"}:${string}`,
···
 
   // check for CSAM etc here
 
-  await Deno.mkdir(`./blobs/${did}`, { recursive: true })
-    .then(async () =>
-      Deno.writeFile(`./blobs/${did}/${cid}`, await data.bytes(), {
-        createNew: true,
-      })
-    )
-    .catch((err) => {
-      if (err instanceof Error) {
-        err.cause = "Deno.writefile";
-      }
-      throw err;
+  await Deno.mkdir(`./blobs/${did}`, { recursive: true });
+  let size = 0;
+  for await (const file of Deno.readDir(`./blobs/${did}`)) {
+    size += (await Deno.stat(`./blobs/${did}/${file.name}`)).size;
+  }
+  // only write if total stays below max site size
+  if (size + data.size <= MAX_SITE_SIZE)
+    await Deno.writeFile(`./blobs/${did}/${cid}`, await data.bytes(), {
+      createNew: true,
     });
 
   return data;

server/src/backfill/new-records.ts

···
                   mime: data.value.page.blob.mimeType,
                 });
 
-                console.log("wrote route");
-
                 continue;
               }
               case "delete": {
-                const id = (
+                const deleted = (
                   await db
                     .select({
                       id: routes.id,
+                      cid: routes.blob_cid,
                     })
                     .from(routes)
                     .where(
···
                       )
                     )
                 ).at(0);
-                if (!id) continue;
+                if (!deleted) continue;
+
+                await db.delete(routes).where(eq(routes.id, deleted.id));
 
-                await db.delete(routes).where(eq(routes.id, id.id));
-                console.log("deleted route");
+                const cidInUse =
+                  (
+                    await db
+                      .select({})
+                      .from(routes)
+                      .where(eq(routes.blob_cid, deleted.cid))
+                  ).length > 0;
+
+                // purge cid if not in use
+                if (!cidInUse)
+                  Deno.remove(`./blobs/${payload.repo}/${deleted.cid}`);
 
                 continue;
               }

server/src/utils.ts

···
 
 export const ROOT_DOMAIN = Deno.env.get("HOSTNAME") || "localhost";
 export const PORT = Number(Deno.env.get("PORT")) || 80;
+export const MAX_SITE_SIZE = Number(Deno.env.get("MAX_SITE_SIZE")) || 250000000;
 
 export const SUBDOMAIN_REGEX = new RegExp(`.+(?=\\.${ROOT_DOMAIN}$)`, "gm");