@camox/api 0.3.1 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camox/api",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "files": [
     "src"
   ],

package/src/routes/projects.ts

@@ -1,5 +1,5 @@
 import { ORPCError } from "@orpc/server";
-import { and, eq } from "drizzle-orm";
+import { and, eq, inArray, or } from "drizzle-orm";
 import { generateKeyBetween } from "fractional-indexing";
 import { z } from "zod";
 
@@ -8,8 +8,11 @@ import { resolveEnvironment } from "../lib/resolve-environment";
 import { generateUniqueSlug } from "../lib/slug";
 import { authed, pub } from "../orpc";
 import {
+  aiJobs,
+  blockDefinitions,
   blocks,
   environments,
+  files,
   layouts,
   organizationTable,
   pages,
@@ -133,9 +136,123 @@ const update = authed
 const deleteFn = authed.input(z.object({ id: z.number() })).handler(async ({ context, input }) => {
   const project = await getAuthorizedProject(context.db, input.id, context.user.id);
   if (!project) throw new ORPCError("NOT_FOUND");
+
+  const projectId = project.id;
+
+  // Collect IDs needed for cascade deletion
+  const pageRows = await context.db
+    .select({ id: pages.id })
+    .from(pages)
+    .where(eq(pages.projectId, projectId));
+  const pageIds = pageRows.map((r) => r.id);
+
+  const layoutRows = await context.db
+    .select({ id: layouts.id })
+    .from(layouts)
+    .where(eq(layouts.projectId, projectId));
+  const layoutIds = layoutRows.map((r) => r.id);
+
+  const blockConditions = [
+    ...(pageIds.length > 0 ? [inArray(blocks.pageId, pageIds)] : []),
+    ...(layoutIds.length > 0 ? [inArray(blocks.layoutId, layoutIds)] : []),
+  ];
+  const blockRows =
+    blockConditions.length > 0
+      ? await context.db
+          .select({ id: blocks.id })
+          .from(blocks)
+          .where(or(...blockConditions))
+      : [];
+  const blockIds = blockRows.map((r) => r.id);
+
+  const repeatableItemRows =
+    blockIds.length > 0
+      ? await context.db
+          .select({ id: repeatableItems.id })
+          .from(repeatableItems)
+          .where(inArray(repeatableItems.blockId, blockIds))
+      : [];
+  const repeatableItemIds = repeatableItemRows.map((r) => r.id);
+
+  const fileRows = await context.db
+    .select({ id: files.id, blobId: files.blobId })
+    .from(files)
+    .where(eq(files.projectId, projectId));
+  const fileIds = fileRows.map((r) => r.id);
+
+  // Delete AI jobs for all collected entities
+  const aiJobConditions = [
+    ...(pageIds.length > 0
+      ? [
+          and(
+            eq(aiJobs.entityTable, "pages"),
+            inArray(
+              aiJobs.entityId,
+              pageIds.map((id) => String(id)),
+            ),
+          ),
+        ]
+      : []),
+    ...(blockIds.length > 0
+      ? [
+          and(
+            eq(aiJobs.entityTable, "blocks"),
+            inArray(
+              aiJobs.entityId,
+              blockIds.map((id) => String(id)),
+            ),
+          ),
+        ]
+      : []),
+    ...(repeatableItemIds.length > 0
+      ? [
+          and(
+            eq(aiJobs.entityTable, "repeatableItems"),
+            inArray(
+              aiJobs.entityId,
+              repeatableItemIds.map((id) => String(id)),
+            ),
+          ),
+        ]
+      : []),
+    ...(fileIds.length > 0
+      ? [
+          and(
+            eq(aiJobs.entityTable, "files"),
+            inArray(
+              aiJobs.entityId,
+              fileIds.map((id) => String(id)),
+            ),
+          ),
+        ]
+      : []),
+  ];
+  if (aiJobConditions.length > 0) {
+    await context.db.delete(aiJobs).where(or(...aiJobConditions));
+  }
+
+  // Delete in FK-safe order
+  if (repeatableItemIds.length > 0) {
+    await context.db.delete(repeatableItems).where(inArray(repeatableItems.id, repeatableItemIds));
+  }
+  if (blockIds.length > 0) {
+    await context.db.delete(blocks).where(inArray(blocks.id, blockIds));
+  }
+  await context.db.delete(pages).where(eq(pages.projectId, projectId));
+
+  // Delete files from R2 and database
+  if (fileRows.length > 0) {
+    await Promise.all(fileRows.map((f) => context.env.FILES_BUCKET.delete(f.blobId)));
+    await context.db.delete(files).where(eq(files.projectId, projectId));
+  }
+
+  await context.db.delete(layouts).where(eq(layouts.projectId, projectId));
+  await context.db.delete(blockDefinitions).where(eq(blockDefinitions.projectId, projectId));
+  await context.db.delete(environments).where(eq(environments.projectId, projectId));
+
   const result = await context.db
     .delete(projects)
-    .where(eq(projects.id, input.id))
+    .where(eq(projects.id, projectId))
     .returning()
     .get();
   return result;