Handle deleting site & resources gracefully

server/routers/resource/deleteResource.ts

@@ -1,13 +1,15 @@
 import { Request, Response, NextFunction } from "express";
 import { z } from "zod";
 import { db } from "@server/db";
-import { resources } from "@server/db/schema";
+import { newts, resources, sites, targets } from "@server/db/schema";
 import { eq } from "drizzle-orm";
 import response from "@server/utils/response";
 import HttpCode from "@server/types/HttpCode";
 import createHttpError from "http-errors";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
+import { addPeer } from "../gerbil/peers";
+import { removeTargets } from "../newt/targets";
 
 // Define Zod schema for request parameters validation
 const deleteResourceSchema = z.object({
@@ -32,12 +34,17 @@ export async function deleteResource(
 
         const { resourceId } = parsedParams.data;
 
-        const deletedResource = await db
+        const targetsToBeRemoved = await db
+            .select()
+            .from(targets)
+            .where(eq(targets.resourceId, resourceId));
+
+        const [deletedResource] = await db
             .delete(resources)
             .where(eq(resources.resourceId, resourceId))
             .returning();
 
-        if (deletedResource.length === 0) {
+        if (!deletedResource) {
             return next(
                 createHttpError(
                     HttpCode.NOT_FOUND,
@@ -46,6 +53,55 @@ export async function deleteResource(
             );
         }
 
+        const [site] = await db
+            .select()
+            .from(sites)
+            .where(eq(sites.siteId, deletedResource.siteId!))
+            .limit(1);
+
+        if (!site) {
+            return next(
+                createHttpError(
+                    HttpCode.NOT_FOUND,
+                    `Site with ID ${deletedResource.siteId} not found`
+                )
+            );
+        }
+        
+        if (site.pubKey) {
+            if (site.type == "wireguard") {
+                // TODO: is this all inefficient?
+                // Fetch resources for this site
+                const resourcesRes = await db.query.resources.findMany({
+                    where: eq(resources.siteId, site.siteId),
+                });
+
+                // Fetch targets for all resources of this site
+                const targetIps = await Promise.all(
+                    resourcesRes.map(async (resource) => {
+                        const targetsRes = await db.query.targets.findMany({
+                            where: eq(targets.resourceId, resource.resourceId),
+                        });
+                        return targetsRes.map((target) => `${target.ip}/32`);
+                    })
+                );
+
+                await addPeer(site.exitNodeId!, {
+                    publicKey: site.pubKey,
+                    allowedIps: targetIps.flat(),
+                });
+            } else if (site.type == "newt") {
+                // get the newt on the site by querying the newt table for siteId
+                const [newt] = await db
+                    .select()
+                    .from(newts)
+                    .where(eq(newts.siteId, site.siteId))
+                    .limit(1);
+
+                removeTargets(newt.newtId, targetsToBeRemoved);
+            }
+        }
+
         return response(res, {
             data: null,
             success: true,