feat: add cascade option to deleteGallery and deletePhoto procedures to remove associated items

__generated__/lexicons.ts

···
                 format: 'at-uri',
                 description: 'Unique identifier of the gallery to delete',
               },
+              cascade: {
+                type: 'boolean',
+                default: true,
+                description:
+                  'If true, will also delete any associated items in the gallery.',
+              },
             },
           },
         },
···
                 type: 'string',
                 format: 'at-uri',
                 description: 'AT URI of the photo to delete.',
+              },
+              cascade: {
+                type: 'boolean',
+                default: true,
+                description:
+                  'If true, will also delete any associated EXIF data and gallery items.',
               },
             },
           },

__generated__/types/social/grain/gallery/deleteGallery.ts

···
 export interface InputSchema {
   /** Unique identifier of the gallery to delete */
   uri: string;
+  /** If true, will also delete any associated items in the gallery. */
+  cascade: boolean;
 }
 
 export interface OutputSchema {

__generated__/types/social/grain/photo/deletePhoto.ts

···
 export interface InputSchema {
   /** AT URI of the photo to delete. */
   uri: string;
+  /** If true, will also delete any associated EXIF data and gallery items. */
+  cascade: boolean;
 }
 
 export interface OutputSchema {

lexicons/social/grain/gallery/deleteGallery.json

···
               "type": "string",
               "format": "at-uri",
               "description": "Unique identifier of the gallery to delete"
+            },
+            "cascade": {
+              "type": "boolean",
+              "default": true,
+              "description": "If true, will also delete any associated items in the gallery."
             }
           }
         }

lexicons/social/grain/photo/deletePhoto.json

···
               "type": "string",
               "format": "at-uri",
               "description": "AT URI of the photo to delete."
+            },
+            "cascade": {
+              "type": "boolean",
+              "default": true,
+              "description": "If true, will also delete any associated EXIF data and gallery items."
             }
           }
         }

src/api/mod.ts

···
   getFollowingWithProfiles,
 } from "../lib/graph.ts";
 import { getNotificationsDetailed } from "../lib/notifications.ts";
-import { applyAlts, createExif, createPhoto } from "../lib/photo.ts";
+import {
+  applyAlts,
+  createExif,
+  createPhoto,
+  deletePhoto,
+} from "../lib/photo.ts";
 import { getTimeline } from "../lib/timeline.ts";
 import { createComment, getGalleryComments } from "../modules/comments.tsx";
 
···
     ["POST"],
     async (req, _params, ctx) => {
       ctx.requireAuth();
-      const { uri } = await parseDeleteGalleryInputs(
+      const { uri, cascade = true } = await parseDeleteGalleryInputs(
         req,
       );
-      const success = await deleteGallery(uri, ctx);
+      const success = await deleteGallery(uri, cascade, ctx);
       return ctx.json({ success } satisfies DeleteGalleryOutputSchema);
     },
   ),
···
     ["POST"],
     async (req, _params, ctx) => {
       ctx.requireAuth();
-      const { uri } = await parseDeletePhotoInputs(req);
-      try {
-        await ctx.deleteRecord(uri);
-        return ctx.json({ success: true } satisfies DeletePhotoOutputSchema);
-      } catch (error) {
-        console.error("Error deleting photo:", error);
-        return ctx.json({ success: false } satisfies DeletePhotoOutputSchema);
-      }
+      const { uri, cascade = true } = await parseDeletePhotoInputs(req);
+      const success = await deletePhoto(uri, cascade, ctx);
+      return ctx.json({ success } satisfies DeletePhotoOutputSchema);
     },
   ),
   route(
···
   if (!uri) {
     throw new XRPCError("InvalidRequest", "Missing uri input");
   }
-  return { uri };
+  const cascade = typeof body.cascade === "boolean" ? body.cascade : undefined;
+  return { uri, cascade };
 }
 
 async function parseCreateGalleryItemInputs(
···
   if (!uri) {
     throw new XRPCError("InvalidRequest", "Missing uri input");
   }
-  return { uri };
+  const cascade = typeof body.cascade === "boolean" ? body.cascade : undefined;
+  return { uri, cascade };
 }
 
 async function parseCreateFollowInputs(

src/lib/gallery.ts

···
   });
 }
 
-export async function deleteGallery(uri: string, ctx: BffContext) {
+export async function deleteGallery(
+  uri: string,
+  cascade: boolean,
+  ctx: BffContext,
+) {
   try {
     await ctx.deleteRecord(uri);
+    if (!cascade) return true;
     const { items: galleryItems } = ctx.indexService.getRecords<
       WithBffMeta<GalleryItem>
     >("social.grain.gallery.item", {

src/lib/photo.ts

···
+import { Record as Favorite } from "$lexicon/types/social/grain/favorite.ts";
 import { Record as Gallery } from "$lexicon/types/social/grain/gallery.ts";
 import { GalleryView } from "$lexicon/types/social/grain/gallery/defs.ts";
 import { Record as GalleryItem } from "$lexicon/types/social/grain/gallery/item.ts";
···
 
   return true;
 }
+
+export async function deletePhoto(
+  uri: string,
+  cascade: boolean,
+  ctx: BffContext,
+): Promise<boolean> {
+  const deleteUris: string[] = [];
+  try {
+    await ctx.deleteRecord(
+      uri,
+    );
+    if (!cascade) return true;
+    const { items: galleryItems } = ctx.indexService.getRecords<
+      WithBffMeta<GalleryItem>
+    >(
+      "social.grain.gallery.item",
+      {
+        where: [
+          {
+            field: "item",
+            equals: uri,
+          },
+        ],
+      },
+    );
+    for (const item of galleryItems) {
+      deleteUris.push(item.uri);
+    }
+    const { items: favorites } = ctx.indexService.getRecords<
+      WithBffMeta<Favorite>
+    >(
+      "social.grain.favorite",
+      {
+        where: [
+          {
+            field: "subject",
+            equals: uri,
+          },
+        ],
+      },
+    );
+    for (const favorite of favorites) {
+      deleteUris.push(favorite.uri);
+    }
+    const { items: exifItems } = ctx.indexService.getRecords<
+      WithBffMeta<PhotoExif>
+    >(
+      "social.grain.photo.exif",
+      {
+        where: [
+          {
+            field: "photo",
+            equals: uri,
+          },
+        ],
+      },
+    );
+    for (const item of exifItems) {
+      deleteUris.push(item.uri);
+    }
+    for (const uri of deleteUris) {
+      await ctx.deleteRecord(uri);
+    }
+  } catch (error) {
+    console.error("Failed to delete photo:", error);
+    return false;
+  }
+  return true;
+}

src/routes/actions.tsx

···
 import { Record as GalleryItem } from "$lexicon/types/social/grain/gallery/item.ts";
 import { Record as Photo } from "$lexicon/types/social/grain/photo.ts";
 import { isPhotoView } from "$lexicon/types/social/grain/photo/defs.ts";
-import { Record as PhotoExif } from "$lexicon/types/social/grain/photo/exif.ts";
 import { AtUri } from "@atproto/syntax";
 import { BffContext, RouteHandler, WithBffMeta } from "@bigmoves/bff";
 import {
···
   updateGallery,
 } from "../lib/gallery.ts";
 import { getFollowers } from "../lib/graph.ts";
-import { createExif, createPhoto, getPhoto } from "../lib/photo.ts";
+import {
+  createExif,
+  createPhoto,
+  deletePhoto,
+  getPhoto,
+} from "../lib/photo.ts";
 import type { State } from "../state.ts";
 import { galleryLink, profileLink, uploadPageLink } from "../utils.ts";
 
···
   const { handle } = ctx.requireAuth();
   const formData = await req.formData();
   const uri = formData.get("uri") as string;
-  await deleteGallery(uri, ctx);
+  await deleteGallery(uri, true, ctx);
   return ctx.redirect(profileLink(handle));
 };
 
···
   const selectedGalleryRkey = selectedGallery
     ? new AtUri(selectedGallery).rkey
     : undefined;
-  const deleteUris: string[] = [];
-  await ctx.deleteRecord(
-    `at://${did}/social.grain.photo/${params.rkey}`,
-  );
-  const { items: galleryItems } = ctx.indexService.getRecords<
-    WithBffMeta<GalleryItem>
-  >(
-    "social.grain.gallery.item",
-    {
-      where: [
-        {
-          field: "item",
-          equals: `at://${did}/social.grain.photo/${params.rkey}`,
-        },
-      ],
-    },
-  );
-  for (const item of galleryItems) {
-    deleteUris.push(item.uri);
-  }
-  const { items: favorites } = ctx.indexService.getRecords<
-    WithBffMeta<Favorite>
-  >(
-    "social.grain.favorite",
-    {
-      where: [
-        {
-          field: "subject",
-          equals: `at://${did}/social.grain.photo/${params.rkey}`,
-        },
-      ],
-    },
-  );
-  for (const favorite of favorites) {
-    deleteUris.push(favorite.uri);
-  }
-  const { items: exifItems } = ctx.indexService.getRecords<
-    WithBffMeta<PhotoExif>
-  >(
-    "social.grain.photo.exif",
-    {
-      where: [
-        {
-          field: "photo",
-          equals: `at://${did}/social.grain.photo/${params.rkey}`,
-        },
-      ],
-    },
-  );
-  for (const item of exifItems) {
-    deleteUris.push(item.uri);
-  }
-  for (const uri of deleteUris) {
-    await ctx.deleteRecord(uri);
-  }
+  const photoUri = `at://${did}/social.grain.photo/${params.rkey}`;
+  await deletePhoto(photoUri, true, ctx);
   return ctx.redirect(uploadPageLink(selectedGalleryRkey));
 };