Fix resubmission after rejection, rename to "Update review", bump to 1.4.2

Author: nickustinov

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 1.4.2
+
+- Fix resubmission after App Review rejection – handle UNRESOLVED_ISSUES submissions to avoid ITEM_PART_OF_ANOTHER_SUBMISSION errors
+- Rename "Resubmit for review" button to "Update review" to match App Store Connect terminology
+- Revamp review insights prompt with three categories (strengths, weaknesses, potential) and stricter rules
+
 ## 1.4.1
 
 - Show informational banner when analytics reports are first requested – explains the 24–48 hour wait and displays elapsed time since the request was initiated

package.json

@@ -1,6 +1,6 @@
 {
   "name": "itsyconnect-macos",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "private": true,
   "license": "AGPL-3.0-only",
   "repository": {

src/components/layout/version-action-footer.tsx

@@ -376,8 +376,8 @@ function SubmitFooter({
   const checklistReady = useChecklistReady(version, isFirstVersion);
   const canSubmit = checklistReady && !hasValidationErrors && !isSaving;
 
-  const label = isResubmit ? "Resubmit for review" : "Submit for review";
-  const confirmTitle = isResubmit ? "Resubmit for review?" : "Submit for review?";
+  const label = isResubmit ? "Update review" : "Submit for review";
+  const confirmTitle = isResubmit ? "Update review?" : "Submit for review?";
 
   async function handleSubmit() {
     setConfirmOpen(false);
@@ -392,7 +392,7 @@ function SubmitFooter({
           body: JSON.stringify({ platform: version.attributes.platform }),
         },
       );
-      toast.success("Submitted for review");
+      toast.success(isResubmit ? "Review updated" : "Submitted for review");
       await delay(ASC_PROPAGATION_DELAY);
     } catch (err) {
       if (err instanceof ApiError && (err.ascErrors?.length || err.ascAssociatedErrors)) {
@@ -413,7 +413,7 @@ function SubmitFooter({
 
   return (
     <>
-      {loading && <LoadingOverlay label="Submitting for review…" />}
+      {loading && <LoadingOverlay label={isResubmit ? "Updating review…" : "Submitting for review…"} />}
       <Footer left={<SubmissionChecklist version={version} isFirstVersion={isFirstVersion} />}>
         <Button disabled={!canSubmit || loading} onClick={() => setConfirmOpen(true)}>
           {label}
@@ -424,13 +424,15 @@ function SubmitFooter({
           <AlertDialogHeader>
             <AlertDialogTitle>{confirmTitle}</AlertDialogTitle>
             <AlertDialogDescription>
-              Version {version.attributes.versionString} will be submitted to App Review.
+              {isResubmit
+                ? `Version ${version.attributes.versionString} will be resubmitted to App Review with your changes.`
+                : `Version ${version.attributes.versionString} will be submitted to App Review.`}
             </AlertDialogDescription>
           </AlertDialogHeader>
           <AlertDialogFooter>
             <AlertDialogCancel>Cancel</AlertDialogCancel>
             <AlertDialogAction onClick={handleSubmit}>
-              Submit
+              {isResubmit ? "Update" : "Submit"}
             </AlertDialogAction>
           </AlertDialogFooter>
         </AlertDialogContent>

src/lib/asc/version-mutations.ts

@@ -92,12 +92,18 @@ export async function submitForReview(
   versionId: string,
   platform: string,
 ): Promise<void> {
-  // Step 1: find an existing draft submission or create a new one.
-  // Draft submissions (READY_FOR_REVIEW) can't be deleted or cancelled,
-  // so we reuse them to avoid accumulating dangling drafts.
+  // After rejection the version stays attached to an UNRESOLVED_ISSUES
+  // submission. Re-confirming that submission resubmits it. We check for
+  // this state first to avoid the ITEM_PART_OF_ANOTHER_SUBMISSION error.
+  const unresolvedId = await findUnresolvedSubmission(appId);
+  if (unresolvedId) {
+    await confirmSubmission(unresolvedId);
+    return;
+  }
+
+  // Normal flow: find or create a READY_FOR_REVIEW submission, add item, confirm
   const submissionId = await findOrCreateReviewSubmission(appId, platform);
 
-  // Step 2: add the version as a review submission item
   await ascFetch("/v1/reviewSubmissionItems", {
     method: "POST",
     body: JSON.stringify({
@@ -115,7 +121,10 @@ export async function submitForReview(
     }),
   });
 
-  // Step 3: confirm the submission
+  await confirmSubmission(submissionId);
+}
+
+async function confirmSubmission(submissionId: string): Promise<void> {
   await ascFetch(`/v1/reviewSubmissions/${submissionId}`, {
     method: "PATCH",
     body: JSON.stringify({
@@ -128,6 +137,27 @@ export async function submitForReview(
   });
 }
 
+/**
+ * Find an UNRESOLVED_ISSUES submission for the app.
+ * After rejection, the old submission moves to this state and still owns
+ * the version. Re-confirming it resubmits for review.
+ */
+async function findUnresolvedSubmission(appId: string): Promise<string | null> {
+  try {
+    const res = await ascFetch<{
+      data: { id: string; attributes: { state: string } }[];
+    }>(
+      `/v1/apps/${appId}/reviewSubmissions?filter[state]=UNRESOLVED_ISSUES`,
+    );
+    if (res.data.length > 0) {
+      return res.data[0].id;
+    }
+  } catch {
+    // Fall through
+  }
+  return null;
+}
+
 async function findOrCreateReviewSubmission(
   appId: string,
   platform: string,

src/lib/version.ts

@@ -1,2 +1,2 @@
-export const APP_VERSION = "1.4.1";
-export const BUILD_NUMBER = "141";
+export const APP_VERSION = "1.4.2";
+export const BUILD_NUMBER = "142";

tests/unit/asc/version-mutations.test.ts

@@ -141,82 +141,97 @@ describe("version-mutations", () => {
   });
 
   describe("submitForReview", () => {
-    it("creates submission when no draft exists, adds item, then confirms", async () => {
+    /** Mock findUnresolvedSubmission returning no results. */
+    function mockNoUnresolved() {
+      mockAscFetch.mockResolvedValueOnce({ data: [] }); // no UNRESOLVED_ISSUES
+    }
+
+    it("creates submission when no unresolved or draft exists", async () => {
+      mockNoUnresolved();
       mockAscFetch
-        .mockResolvedValueOnce({ data: [] }) // find drafts: none
+        .mockResolvedValueOnce({ data: [] }) // findOrCreate: no READY_FOR_REVIEW drafts
         .mockResolvedValueOnce({ data: { id: "sub-1" } }) // create submission
         .mockResolvedValueOnce({}) // add item
         .mockResolvedValueOnce({}); // confirm
 
       await submitForReview("app-1", "ver-1", "MAC_OS");
 
-      // Step 1: check for existing drafts
-      expect(mockAscFetch.mock.calls[0][0]).toContain("/v1/apps/app-1/reviewSubmissions");
-
-      // Step 1b: create new submission (no draft found)
       expect(mockAscFetch).toHaveBeenCalledWith(
         "/v1/reviewSubmissions",
         expect.objectContaining({ method: "POST" }),
       );
-      const createBody = JSON.parse(mockAscFetch.mock.calls[1][1].body);
-      expect(createBody.data.type).toBe("reviewSubmissions");
-      expect(createBody.data.attributes.platform).toBe("MAC_OS");
-      expect(createBody.data.relationships.app.data.id).toBe("app-1");
-
-      // Step 2: add version as item
       expect(mockAscFetch).toHaveBeenCalledWith(
         "/v1/reviewSubmissionItems",
         expect.objectContaining({ method: "POST" }),
       );
-      const itemBody = JSON.parse(mockAscFetch.mock.calls[2][1].body);
-      expect(itemBody.data.relationships.reviewSubmission.data.id).toBe("sub-1");
-      expect(itemBody.data.relationships.appStoreVersion.data.id).toBe("ver-1");
 
-      // Step 3: confirm submission
-      const confirmBody = JSON.parse(mockAscFetch.mock.calls[3][1].body);
-      expect(confirmBody.data.attributes.submitted).toBe(true);
+      const lastCall = mockAscFetch.mock.calls[mockAscFetch.mock.calls.length - 1];
+      const body = JSON.parse(lastCall[1].body);
+      expect(body.data.attributes.submitted).toBe(true);
     });
 
-    it("reuses an existing draft submission instead of creating a new one", async () => {
+    it("resubmits UNRESOLVED_ISSUES submission directly after rejection", async () => {
+      mockAscFetch
+        .mockResolvedValueOnce({ data: [
+          { id: "rejected-sub", attributes: { state: "UNRESOLVED_ISSUES" } },
+        ] })
+        .mockResolvedValueOnce({}); // confirm
+
+      await submitForReview("app-1", "ver-1", "IOS");
+
+      // Should confirm the UNRESOLVED_ISSUES submission directly
+      const confirmCall = mockAscFetch.mock.calls[1];
+      expect(confirmCall[0]).toBe("/v1/reviewSubmissions/rejected-sub");
+      const body = JSON.parse(confirmCall[1].body);
+      expect(body.data.attributes.submitted).toBe(true);
+
+      // Should NOT create a new submission or add items
+      expect(mockAscFetch).toHaveBeenCalledTimes(2);
+    });
+
+    it("reuses an existing READY_FOR_REVIEW draft in normal flow", async () => {
+      mockNoUnresolved();
       mockAscFetch
         .mockResolvedValueOnce({ data: [
           { id: "existing-sub", attributes: { state: "READY_FOR_REVIEW" } },
-        ] }) // find drafts: one exists
+        ] })
         .mockResolvedValueOnce({}) // add item
         .mockResolvedValueOnce({}); // confirm
 
       await submitForReview("app-1", "ver-1", "IOS");
 
-      // Should NOT create a new submission – only 3 calls total
-      expect(mockAscFetch).toHaveBeenCalledTimes(3);
-
-      // Item should reference the existing submission
-      const itemBody = JSON.parse(mockAscFetch.mock.calls[1][1].body);
+      const addItemCall = mockAscFetch.mock.calls.find(
+        (c: unknown[]) => c[0] === "/v1/reviewSubmissionItems" && (c[1] as Record<string, string>)?.method === "POST",
+      )!;
+      const itemBody = JSON.parse((addItemCall[1] as Record<string, string>).body);
       expect(itemBody.data.relationships.reviewSubmission.data.id).toBe("existing-sub");
     });
 
-    it("throws when step 2 (add item) fails", async () => {
+    it("throws when add item fails", async () => {
+      mockNoUnresolved();
       mockAscFetch
-        .mockResolvedValueOnce({ data: [] }) // find drafts: none
+        .mockResolvedValueOnce({ data: [] }) // findOrCreate: none
         .mockResolvedValueOnce({ data: { id: "sub-1" } }) // create
-        .mockRejectedValueOnce(new Error("add item failed")); // add item fails
+        .mockRejectedValueOnce(new Error("add item failed"));
 
       await expect(submitForReview("app-1", "ver-1", "IOS")).rejects.toThrow("add item failed");
     });
 
-    it("throws when step 3 (confirm) fails", async () => {
+    it("throws when confirm fails", async () => {
+      mockNoUnresolved();
       mockAscFetch
-        .mockResolvedValueOnce({ data: [] }) // find drafts: none
+        .mockResolvedValueOnce({ data: [] }) // findOrCreate: none
         .mockResolvedValueOnce({ data: { id: "sub-1" } }) // create
         .mockResolvedValueOnce({}) // add item
-        .mockRejectedValueOnce(new Error("confirm failed")); // confirm fails
+        .mockRejectedValueOnce(new Error("confirm failed"));
 
       await expect(submitForReview("app-1", "ver-1", "IOS")).rejects.toThrow("confirm failed");
     });
 
-    it("falls through to create when listing drafts fails", async () => {
+    it("falls through to normal flow when unresolved search fails", async () => {
       mockAscFetch
-        .mockRejectedValueOnce(new Error("list failed")) // find drafts fails
+        .mockRejectedValueOnce(new Error("list failed")) // unresolved search fails
+        .mockResolvedValueOnce({ data: [] }) // findOrCreate: none
         .mockResolvedValueOnce({ data: { id: "sub-1" } }) // create
         .mockResolvedValueOnce({}) // add item
         .mockResolvedValueOnce({}); // confirm