feat: add unpublish functionality for domains

- Add unpublish button for project domain and custom domains
- Call edge-api deployment.unpublish to delete worker
- Remove domain from all builds in DB (not just latest)
- Disable domain renaming only when that specific domain is published
- Add PUBLISHER_HOST to deployment context for domain suffix handling
- Add error details to unpublish error messages

Author: kof

packages/domain/src/trpc/domain.ts

@@ -185,19 +185,20 @@ export const domainRouter = router({
         if (result.success === false && result.error !== "NOT_IMPLEMENTED") {
           return {
             success: false,
-            message: `Failed to unpublish ${input.domain}`,
-          } as const;
+            message: `Failed to unpublish ${input.domain}: ${result.error}`,
+          };
         }
 
         return {
           success: true,
           message: `${input.domain} unpublished`,
-        } as const;
+        };
       } catch (error) {
+        console.error("Unpublish failed:", error);
         return {
           success: false,
-          message: `Failed to unpublish ${input.domain}`,
-        } as const;
+          message: `Failed to unpublish ${input.domain}: ${error instanceof Error ? error.message : "Unknown error"}`,
+        };
       }
     }),
   /**

packages/project-build/src/db/build.ts

@@ -247,7 +247,7 @@ export const unpublishBuild = async (
     );
   }
 
-  // Find the build that has this domain in its deployment
+  // Find all builds that have this domain in their deployment
   const buildsResult = await context.postgrest.client
     .from("Build")
     .select("id, deployment")
@@ -259,8 +259,8 @@ export const unpublishBuild = async (
     throw buildsResult.error;
   }
 
-  // Find the build with this specific domain in deployment.domains
-  const targetBuild = buildsResult.data.find((build) => {
+  // Find all builds with this specific domain in deployment.domains
+  const targetBuilds = buildsResult.data.filter((build) => {
     const deployment = parseDeployment(build.deployment);
     if (deployment === undefined) {
       return false;
@@ -271,44 +271,49 @@ export const unpublishBuild = async (
     return deployment.domains.includes(props.domain);
   });
 
-  if (targetBuild === undefined) {
+  if (targetBuilds.length === 0) {
     throw new Error(`Domain ${props.domain} is not published`);
   }
 
-  const deployment = parseDeployment(targetBuild.deployment);
+  // Process all builds that contain this domain
+  for (const targetBuild of targetBuilds) {
+    const deployment = parseDeployment(targetBuild.deployment);
 
-  if (deployment === undefined || deployment.destination !== "saas") {
-    throw new Error("Build is not published to SaaS");
-  }
-
-  // Remove the domain from the deployment
-  const remainingDomains = deployment.domains.filter((d) => d !== props.domain);
+    if (deployment === undefined || deployment.destination !== "saas") {
+      continue;
+    }
 
-  if (remainingDomains.length === 0) {
-    // Delete the production build entirely when no domains remain
-    // Don't set deployment=null as that would create a duplicate "dev build"
-    const result = await context.postgrest.client
-      .from("Build")
-      .delete()
-      .eq("id", targetBuild.id);
+    // Remove the domain from the deployment
+    const remainingDomains = deployment.domains.filter(
+      (d) => d !== props.domain
+    );
 
-    if (result.error) {
-      throw result.error;
-    }
-  } else {
-    // Update with remaining domains
-    const newDeployment = JSON.stringify({
-      ...deployment,
-      domains: remainingDomains,
-    });
-
-    const result = await context.postgrest.client
-      .from("Build")
-      .update({ deployment: newDeployment })
-      .eq("id", targetBuild.id);
-
-    if (result.error) {
-      throw result.error;
+    if (remainingDomains.length === 0) {
+      // Delete the production build entirely when no domains remain
+      // Don't set deployment=null as that would create a duplicate "dev build"
+      const result = await context.postgrest.client
+        .from("Build")
+        .delete()
+        .eq("id", targetBuild.id);
+
+      if (result.error) {
+        throw result.error;
+      }
+    } else {
+      // Update with remaining domains
+      const newDeployment = JSON.stringify({
+        ...deployment,
+        domains: remainingDomains,
+      });
+
+      const result = await context.postgrest.client
+        .from("Build")
+        .update({ deployment: newDeployment })
+        .eq("id", targetBuild.id);
+
+      if (result.error) {
+        throw result.error;
+      }
     }
   }
 };

packages/project/src/db/project.ts

@@ -269,20 +269,46 @@ export const updateDomain = async (
 
   await assertEditPermission(input.id, context);
 
-  // Check if project has been published - forbid renaming wstd domain after publishing
-  const projectData = await context.postgrest.client
-    .from("DashboardProject")
-    .select("isPublished")
+  // Check if the current wstd domain is published - forbid renaming while published
+  // Get current domain first
+  const currentProject = await context.postgrest.client
+    .from("Project")
+    .select("domain")
     .eq("id", input.id)
     .single();
 
-  if (projectData.error) {
-    throw projectData.error;
+  if (currentProject.error) {
+    throw currentProject.error;
+  }
+
+  // Check if any build has this domain in deployment.domains
+  const buildsWithDomain = await context.postgrest.client
+    .from("Build")
+    .select("id, deployment")
+    .eq("projectId", input.id)
+    .not("deployment", "is", null);
+
+  if (buildsWithDomain.error) {
+    throw buildsWithDomain.error;
   }
 
-  if (projectData.data.isPublished) {
+  const isDomainPublished = buildsWithDomain.data.some((build) => {
+    const deployment = build.deployment as {
+      destination?: string;
+      domains?: string[];
+    } | null;
+    if (deployment === null) {
+      return false;
+    }
+    if (deployment.destination === "static") {
+      return false;
+    }
+    return deployment.domains?.includes(currentProject.data.domain) ?? false;
+  });
+
+  if (isDomainPublished) {
     throw new Error(
-      "Cannot change domain after the project has been published"
+      "Cannot change domain while it is published. Unpublish first."
     );
   }