server: use "backfill" when avaliable

server/src/index.ts

···
 import root from "./root.ts";
 import user from "./user.ts";
+import backfill from "./backfill.ts";
+import { routes } from "./db/schema.ts";
 
 const ROOT_DOMAIN = Deno.env.get("HOSTNAME") || "localhost";
 const PORT = Number(Deno.env.get("PORT")) || 80;
···
   }
   return head;
 }
+
+const db = await backfill();
 
 Deno.serve({ port: PORT, hostname: ROOT_DOMAIN }, async (req) => {
   const reqUrl = new URL(req.url);
···
   // did:web example: `vielle.dev.did-web.ROOT_DOMAIN
   // last segment must be did-plc or did-web
   if (subdomain.at(-1)?.match(/^did-(web|plc)+$/gm)) {
-    const res = await user(req, {
+    const res = await user(db, req, {
       did: `did:${subdomain.at(-1) === "did-plc" ? "plc" : "web"}:${subdomain.slice(0, -1).join(".")}`,
     });
     return new Response(res.body, {
···
   // ex: vielle.dev.ROOT_DOMAIN
   // cannot contain hyphen in top level domain
   if (!subdomain.at(-1)?.startsWith("did-") && subdomain.length > 1) {
-    const res = await user(req, {
+    const res = await user(db, req, {
       handle: subdomain.join(".") as `${string}.${string}`,
     });
     return new Response(res.body, {

server/src/types.ts

···
+import { LibSQLDatabase } from "drizzle-orm/libsql";
+import { Client } from "@libsql/client";
+import * as schema from "./db/schema.ts";
+
+export type db = LibSQLDatabase<typeof schema> & {
+  $client: Client;
+};

server/src/user.ts

···
   WebDidDocumentResolver,
 } from "@atcute/identity-resolver";
 import { DevAtcitiesRoute } from "./lexicons/index.ts";
+import { db } from "./types.ts";
+import { and, eq } from "drizzle-orm";
+import { routes } from "./db/schema.ts";
 
 const handleResolver = new CompositeHandleResolver({
   strategy: "race",
···
 }
 
 export default async function (
+  db: db,
   req: Request,
   user:
     | { handle: `${string}.${string}` }
···
       });
     }
   } else did = user.did;
+
+  // look up in db
+  const db_res =
+    (
+      await db
+        .select()
+        .from(routes)
+        .where(
+          and(
+            eq(routes.did, did),
+            eq(routes.url_route, new URL(req.url).pathname)
+          )
+        )
+    ).at(0) ??
+    (
+      await db
+        .select()
+        .from(routes)
+        .where(and(eq(routes.did, did), eq(routes.url_route, "404")))
+    ).at(0);
+
+  if (db_res) {
+    try {
+      const file = await Deno.readFile(
+        `./blobs/${db_res.did}/${db_res.blob_cid}`
+      );
+      return new Response(file, {
+        headers: {
+          "Content-Type": db_res.mime,
+        },
+      });
+    } catch {
+      return new Response(
+        "Could not find in CDN; TODO: fallback to fetch from pds && add to cdn if missing\nNB: should this be default? index routes in db but only cache used pages"
+      );
+    }
+  }
 
   // resolve did doc
   let doc;