From 17b795cfb1719ee0cb4ddf00649aaf00e1fde373 Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Mon, 9 Dec 2024 19:12:45 +0000
Subject: [PATCH 01/26] feat: showing documents in archived and published
 releases

---
 .../sanity/src/core/releases/tool/detail/useBundleDocuments.ts   | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/sanity/src/core/releases/tool/detail/useBundleDocuments.ts b/packages/sanity/src/core/releases/tool/detail/useBundleDocuments.ts
index 9da71d61964..da4a2f21ffc 100644
--- a/packages/sanity/src/core/releases/tool/detail/useBundleDocuments.ts
+++ b/packages/sanity/src/core/releases/tool/detail/useBundleDocuments.ts
@@ -1,5 +1,6 @@
 import {isValidationErrorMarker, type SanityDocument} from '@sanity/types'
 import {uuid} from '@sanity/uuid'
+import {isBefore} from 'date-fns'
 import {useMemo} from 'react'
 import {useObservable} from 'react-rx'
 import {combineLatest, from, of} from 'rxjs'

From aeae15032fb4472c4d2d02af3f8cd00cfb7d1956 Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Tue, 10 Dec 2024 11:10:45 +0000
Subject: [PATCH 02/26] refactor: removing check for existing document in
 published

---
 .../sanity/src/core/releases/tool/detail/useBundleDocuments.ts   | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packages/sanity/src/core/releases/tool/detail/useBundleDocuments.ts b/packages/sanity/src/core/releases/tool/detail/useBundleDocuments.ts
index da4a2f21ffc..9da71d61964 100644
--- a/packages/sanity/src/core/releases/tool/detail/useBundleDocuments.ts
+++ b/packages/sanity/src/core/releases/tool/detail/useBundleDocuments.ts
@@ -1,6 +1,5 @@
 import {isValidationErrorMarker, type SanityDocument} from '@sanity/types'
 import {uuid} from '@sanity/uuid'
-import {isBefore} from 'date-fns'
 import {useMemo} from 'react'
 import {useObservable} from 'react-rx'
 import {combineLatest, from, of} from 'rxjs'

From 14859feba8614a898283b16865d628369b656196 Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Tue, 10 Dec 2024 14:04:01 +0000
Subject: [PATCH 03/26] feat: showing revert release button on published
 releases

---
 .../releaseCTAButtons/ReleaseRevertButton.tsx | 44 +++++++++++++++++++
 .../tool/detail/ReleaseDashboardFooter.tsx    |  7 +++
 2 files changed, 51 insertions(+)
 create mode 100644 packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx

diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
new file mode 100644
index 00000000000..d3f9358b47a
--- /dev/null
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
@@ -0,0 +1,44 @@
+import {RestoreIcon} from '@sanity/icons'
+
+import {Button} from '../../../../../ui-components/button/Button'
+import {type ReleaseDocument} from '../../../store/types'
+import {type DocumentInRelease} from '../../detail/useBundleDocuments'
+
+interface ReleasePublishAllButtonProps {
+  release: ReleaseDocument
+  documents: DocumentInRelease[]
+  disabled?: boolean
+}
+
+const fetchAndParseAll = async () => {
+  if (!versionIds) return
+  if (!releaseId) return
+  const transactions: TransactionLogEventWithEffects[] = []
+  const stream = await getJsonStream(transactionsUrl, token)
+  const reader = stream.getReader()
+  let result
+  for (;;) {
+    result = await reader.read()
+    if (result.done) {
+      break
+    }
+    if ('error' in result.value) {
+      throw new Error(result.value.error.description || result.value.error.type)
+    }
+    transactions.push(result.value)
+  }
+}
+
+const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
+  const transactionId = documents[0]?.document._rev
+}
+
+export const ReleaseRevertButton = ({release, documents, disabled}) => {
+  const getAdjacentTransactions = useAdjacentTransactions(documents)
+
+  return (
+    <>
+      <Button icon={RestoreIcon} text="Revert release" tone="critical" disabled={disabled} />
+    </>
+  )
+}
diff --git a/packages/sanity/src/core/releases/tool/detail/ReleaseDashboardFooter.tsx b/packages/sanity/src/core/releases/tool/detail/ReleaseDashboardFooter.tsx
index 9d39db130e6..3904ac47174 100644
--- a/packages/sanity/src/core/releases/tool/detail/ReleaseDashboardFooter.tsx
+++ b/packages/sanity/src/core/releases/tool/detail/ReleaseDashboardFooter.tsx
@@ -4,6 +4,7 @@ import {useMemo} from 'react'
 
 import {isReleaseScheduledOrScheduling, type ReleaseDocument} from '../../index'
 import {ReleasePublishAllButton} from '../components/releaseCTAButtons/ReleasePublishAllButton'
+import {ReleaseRevertButton} from '../components/releaseCTAButtons/ReleaseRevertButton'
 import {ReleaseScheduleButton} from '../components/releaseCTAButtons/ReleaseScheduleButton'
 import {ReleaseUnscheduleButton} from '../components/releaseCTAButtons/ReleaseUnscheduleButton'
 import {ReleaseMenuButton} from '../components/ReleaseMenuButton/ReleaseMenuButton'
@@ -45,6 +46,12 @@ export function ReleaseDashboardFooter(props: {
       )
     }
 
+    if (release.state === 'published') {
+      return (
+        <ReleaseRevertButton release={release} documents={documents} disabled={!documents.length} />
+      )
+    }
+
     return null
   }, [documents, release])
 

From dcd91d1d559cd759f44c13eb20aa42a4ce01be1d Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Tue, 10 Dec 2024 17:43:10 +0000
Subject: [PATCH 04/26] feat: supporting reverting of changed documents

---
 .../store/createReleaseOperationStore.ts      |   3 +-
 .../releaseCTAButtons/ReleaseRevertButton.tsx | 292 ++++++++++++++++--
 2 files changed, 271 insertions(+), 24 deletions(-)

diff --git a/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts b/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts
index 6cdd6889c7e..05d7a0af33e 100644
--- a/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts
+++ b/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts
@@ -127,7 +127,8 @@ export function createReleaseOperationsStore(options: {
     }
 
     const versionDocument = {
-      ...(document || initialValue || {}),
+      ...(document || {}),
+      ...(initialValue || {}),
       _id: getVersionId(documentId, releaseId),
     } as IdentifiedSanityDocumentStub
 
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
index d3f9358b47a..0d065f6f673 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
@@ -1,7 +1,21 @@
 import {RestoreIcon} from '@sanity/icons'
+import {Box, Card, Checkbox, Flex, Text, useToast} from '@sanity/ui'
+import {useCallback, useMemo, useState} from 'react'
+import {useObservable} from 'react-rx'
+import {combineLatest, filter, forkJoin, from, map, switchMap} from 'rxjs'
 
+import {useRouter} from '../../../../../router'
 import {Button} from '../../../../../ui-components/button/Button'
+import {Dialog} from '../../../../../ui-components/dialog'
+import {useClient} from '../../../../hooks/useClient'
+import {Translate, useTranslation} from '../../../../i18n'
+import {getTransactionsLogs} from '../../../../store/translog/getTransactionLogs'
+import {API_VERSION} from '../../../../tasks/constants'
+import {releasesLocaleNamespace} from '../../../i18n'
 import {type ReleaseDocument} from '../../../store/types'
+import {useReleaseOperations} from '../../../store/useReleaseOperations'
+import {createReleaseId} from '../../../util/createReleaseId'
+import {getReleaseIdFromReleaseDocumentId} from '../../../util/getReleaseIdFromReleaseDocumentId'
 import {type DocumentInRelease} from '../../detail/useBundleDocuments'
 
 interface ReleasePublishAllButtonProps {
@@ -10,35 +24,267 @@ interface ReleasePublishAllButtonProps {
   disabled?: boolean
 }
 
-const fetchAndParseAll = async () => {
-  if (!versionIds) return
-  if (!releaseId) return
-  const transactions: TransactionLogEventWithEffects[] = []
-  const stream = await getJsonStream(transactionsUrl, token)
-  const reader = stream.getReader()
-  let result
-  for (;;) {
-    result = await reader.read()
-    if (result.done) {
-      break
-    }
-    if ('error' in result.value) {
-      throw new Error(result.value.error.description || result.value.error.type)
-    }
-    transactions.push(result.value)
-  }
-}
-
-const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
+const useGetAdjacentTransactions = (documents: DocumentInRelease[]) => {
+  const client = useClient({apiVersion: API_VERSION})
+  const observableClient = client.observable
   const transactionId = documents[0]?.document._rev
+  const {dataset} = client.config()
+
+  const hasPostPublishTransactions$ = useMemo(
+    () =>
+      from(
+        getTransactionsLogs(
+          client,
+          documents.map(({document}) => document._id),
+          {
+            fromTransaction: transactionId,
+            limit: 2,
+          },
+        ),
+      ).pipe(
+        // the transaction of published is also returned
+        // so post publish transactions will result in more than 1 transaction
+        map((transactions) => transactions.length > 1),
+      ),
+    [client, documents, transactionId],
+  )
+
+  const revertToDocuments$ = useMemo(
+    () =>
+      from(
+        getTransactionsLogs(
+          client,
+          documents.map(({document}) => document._id),
+          {
+            toTransaction: transactionId,
+            limit: documents.length + 1,
+            // // reverse to find the transaction before publish first
+            reverse: true,
+          },
+        ),
+      ).pipe(
+        filter((transactions) => transactions.length > 0),
+        map(([publishTransaction, ...otherTransactions]) => otherTransactions),
+        map((transactions) =>
+          documents.map(({document}) => ({
+            docId: document._id,
+            // eslint-disable-next-line max-nested-callbacks
+            revisionId: transactions.find(({documentIDs}) => documentIDs.includes(document._id))
+              ?.id,
+          })),
+        ),
+        switchMap((docRevisionPairs) =>
+          forkJoin(
+            docRevisionPairs.map(({docId, revisionId}) =>
+              observableClient
+                .request<{documents: DocumentInRelease['document'][]}>({
+                  url: `/data/history/${dataset}/documents/${docId}?revision=${revisionId}`,
+                })
+                // eslint-disable-next-line max-nested-callbacks
+                .pipe(map((response) => response.documents[0])),
+            ),
+          ),
+        ),
+      ),
+    [client, dataset, documents, observableClient, transactionId],
+  )
+
+  const memoObservable = useMemo(
+    () =>
+      combineLatest([hasPostPublishTransactions$, revertToDocuments$]).pipe(
+        map(([hasPostPublishTransactions, revertToDocuments]) => ({
+          hasPostPublishTransactions,
+          revertToDocuments,
+        })),
+      ),
+    [hasPostPublishTransactions$, revertToDocuments$],
+  )
+
+  return useObservable(memoObservable, {
+    hasPostPublishTransactions: null,
+    revertToDocuments: null,
+  })
 }
 
-export const ReleaseRevertButton = ({release, documents, disabled}) => {
-  const getAdjacentTransactions = useAdjacentTransactions(documents)
+export const ReleaseRevertButton = ({
+  release,
+  documents,
+  disabled,
+}: ReleasePublishAllButtonProps) => {
+  const {hasPostPublishTransactions, revertToDocuments} = useGetAdjacentTransactions(documents)
+  const {t} = useTranslation(releasesLocaleNamespace)
+  const [revertReleaseStatus, setRevertReleaseStatus] = useState<'idle' | 'confirm' | 'reverting'>(
+    'idle',
+  )
+  const toast = useToast()
+  const router = useRouter()
+  const [stageNewRevertRelease, setStageNewRevertRelease] = useState(true)
+  const {createRelease, publishRelease, createVersion} = useReleaseOperations()
+
+  const handleRevertRelease = useCallback(async () => {
+    if (!revertToDocuments) return
+
+    setRevertReleaseStatus('reverting')
+    const revertReleaseId = createReleaseId()
+
+    try {
+      await createRelease({
+        _id: revertReleaseId,
+        metadata: {
+          title: `Reverting "${release.metadata.title}"`,
+          description: `This release reverts the changes made in "${release.metadata.title}"`,
+          releaseType: 'asap',
+        },
+      })
+
+      await Promise.allSettled(
+        revertToDocuments.map((document) =>
+          createVersion(getReleaseIdFromReleaseDocumentId(revertReleaseId), document._id, document),
+        ),
+      )
+
+      if (stageNewRevertRelease) {
+        toast.push({
+          closable: true,
+          status: 'success',
+          title: (
+            <Text muted size={1}>
+              <Translate
+                t={t}
+                i18nKey="toast.revert-stage.success"
+                values={{title: release.metadata.title}}
+              />
+            </Text>
+          ),
+          description: (
+            <Text size={1} weight="medium" as="a">
+              <a
+                onClick={() =>
+                  router.navigate({releaseId: getReleaseIdFromReleaseDocumentId(revertReleaseId)})
+                }
+                style={{cursor: 'pointer'}}
+              >
+                View revert release
+              </a>
+            </Text>
+          ),
+        })
+      } else {
+        await publishRelease(revertReleaseId)
+
+        toast.push({
+          closable: true,
+          status: 'success',
+          title: (
+            <Text muted size={1}>
+              <Translate
+                t={t}
+                i18nKey="toast.immediate-revert.success"
+                values={{title: release.metadata.title}}
+              />
+            </Text>
+          ),
+        })
+      }
+    } catch (revertError) {
+      toast.push({
+        status: 'error',
+        title: (
+          <Text muted size={1}>
+            <Translate t={t} i18nKey="toast.revert.error" values={{error: revertError.message}} />
+          </Text>
+        ),
+      })
+      console.error(revertError)
+    } finally {
+      setRevertReleaseStatus('idle')
+    }
+  }, [
+    createRelease,
+    createVersion,
+    publishRelease,
+    release.metadata.title,
+    revertToDocuments,
+    stageNewRevertRelease,
+    t,
+    toast,
+  ])
+
+  const confirmReleaseDialog = useMemo(() => {
+    if (revertReleaseStatus === 'idle') return null
+
+    return (
+      <Dialog
+        id="confirm-revert-dialog"
+        header={t('revert-dialog.confirm-revert.title')}
+        onClose={() => setRevertReleaseStatus('idle')}
+        footer={{
+          confirmButton: {
+            text: t(
+              stageNewRevertRelease
+                ? 'action.create-revert-release'
+                : 'action.immediate-revert-release',
+            ),
+            tone: 'positive',
+            onClick: handleRevertRelease,
+            loading: revertReleaseStatus === 'reverting',
+            disabled: revertReleaseStatus === 'reverting',
+          },
+        }}
+      >
+        <Text muted size={1}>
+          {
+            <Translate
+              t={t}
+              i18nKey="revert-dialog.confirm-revert-description"
+              values={{
+                releaseDocumentsLength: documents.length,
+              }}
+            />
+          }
+        </Text>
+        <Flex align="center" paddingTop={4}>
+          <Checkbox
+            onChange={() => setStageNewRevertRelease((current) => !current)}
+            id="stage-release"
+            style={{display: 'block'}}
+            checked={stageNewRevertRelease}
+          />
+          <Box flex={1} paddingLeft={3}>
+            <Text muted size={1}>
+              <label htmlFor="stage-release">Stage revert actions in a new release</label>
+            </Text>
+          </Box>
+        </Flex>
+        {hasPostPublishTransactions && !stageNewRevertRelease && (
+          <Card marginTop={4} padding={3} radius={2} shadow={1} tone="critical">
+            <Text muted size={1}>
+              Changes were made to documents in this release after they were published. Reverting
+              will revert all changes
+            </Text>
+          </Card>
+        )}
+      </Dialog>
+    )
+  }, [
+    revertReleaseStatus,
+    t,
+    stageNewRevertRelease,
+    handleRevertRelease,
+    documents.length,
+    hasPostPublishTransactions,
+  ])
 
   return (
     <>
-      <Button icon={RestoreIcon} text="Revert release" tone="critical" disabled={disabled} />
+      <Button
+        icon={RestoreIcon}
+        onClick={() => setRevertReleaseStatus('confirm')}
+        text="Revert release"
+        tone="critical"
+        disabled={disabled}
+      />
+      {confirmReleaseDialog}
     </>
   )
 }

From cb2ffbdb1ae3bb0047cafefa478d3e8e22d65d0e Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Tue, 10 Dec 2024 17:50:06 +0000
Subject: [PATCH 05/26] feat: reverting unpublishes created documents

---
 .../releaseCTAButtons/ReleaseRevertButton.tsx | 32 +++++++++++++------
 1 file changed, 22 insertions(+), 10 deletions(-)

diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
index 0d065f6f673..12200cd9105 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
@@ -2,7 +2,7 @@ import {RestoreIcon} from '@sanity/icons'
 import {Box, Card, Checkbox, Flex, Text, useToast} from '@sanity/ui'
 import {useCallback, useMemo, useState} from 'react'
 import {useObservable} from 'react-rx'
-import {combineLatest, filter, forkJoin, from, map, switchMap} from 'rxjs'
+import {combineLatest, filter, forkJoin, from, map, of, switchMap} from 'rxjs'
 
 import {useRouter} from '../../../../../router'
 import {Button} from '../../../../../ui-components/button/Button'
@@ -38,6 +38,7 @@ const useGetAdjacentTransactions = (documents: DocumentInRelease[]) => {
           documents.map(({document}) => document._id),
           {
             fromTransaction: transactionId,
+            // one transaction for every document plus the publish transaction
             limit: 2,
           },
         ),
@@ -57,8 +58,9 @@ const useGetAdjacentTransactions = (documents: DocumentInRelease[]) => {
           documents.map(({document}) => document._id),
           {
             toTransaction: transactionId,
+            // one transaction for every document plus the publish transaction
             limit: documents.length + 1,
-            // // reverse to find the transaction before publish first
+            // // reverse to find the transactions immediately before publish
             reverse: true,
           },
         ),
@@ -75,14 +77,23 @@ const useGetAdjacentTransactions = (documents: DocumentInRelease[]) => {
         ),
         switchMap((docRevisionPairs) =>
           forkJoin(
-            docRevisionPairs.map(({docId, revisionId}) =>
-              observableClient
-                .request<{documents: DocumentInRelease['document'][]}>({
-                  url: `/data/history/${dataset}/documents/${docId}?revision=${revisionId}`,
+            docRevisionPairs.map(({docId, revisionId}) => {
+              if (!revisionId)
+                return of({
+                  _id: docId,
+                  // eslint-disable-next-line max-nested-callbacks
+                  ...documents.find(({document}) => document._id === docId),
+                  _system: {delete: true},
                 })
-                // eslint-disable-next-line max-nested-callbacks
-                .pipe(map((response) => response.documents[0])),
-            ),
+              return (
+                observableClient
+                  .request<{documents: DocumentInRelease['document'][]}>({
+                    url: `/data/history/${dataset}/documents/${docId}?revision=${revisionId}`,
+                  })
+                  // eslint-disable-next-line max-nested-callbacks
+                  .pipe(map((response) => response.documents[0]))
+              )
+            }),
           ),
         ),
       ),
@@ -157,7 +168,7 @@ export const ReleaseRevertButton = ({
             </Text>
           ),
           description: (
-            <Text size={1} weight="medium" as="a">
+            <Text size={1} weight="medium">
               <a
                 onClick={() =>
                   router.navigate({releaseId: getReleaseIdFromReleaseDocumentId(revertReleaseId)})
@@ -205,6 +216,7 @@ export const ReleaseRevertButton = ({
     publishRelease,
     release.metadata.title,
     revertToDocuments,
+    router,
     stageNewRevertRelease,
     t,
     toast,

From e8cb1917cbf660e4be6dabe5abd89f9cdb1a181f Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Tue, 10 Dec 2024 17:50:33 +0000
Subject: [PATCH 06/26] fix: resolving issue where doc wasn't being repopulated
 in unpublish cases

---
 .../releaseCTAButtons/ReleaseRevertButton.tsx         | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
index 12200cd9105..fb6733247ce 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
@@ -78,13 +78,18 @@ const useGetAdjacentTransactions = (documents: DocumentInRelease[]) => {
         switchMap((docRevisionPairs) =>
           forkJoin(
             docRevisionPairs.map(({docId, revisionId}) => {
-              if (!revisionId)
+              if (!revisionId) {
+                const {publishedDocumentExists, ...unpublishDocument} =
+                  // eslint-disable-next-line max-nested-callbacks
+                  documents.find(({document}) => document._id === docId)?.document || {}
+
                 return of({
                   _id: docId,
-                  // eslint-disable-next-line max-nested-callbacks
-                  ...documents.find(({document}) => document._id === docId),
+                  ...unpublishDocument,
                   _system: {delete: true},
                 })
+              }
+
               return (
                 observableClient
                   .request<{documents: DocumentInRelease['document'][]}>({

From e33559b2132cbcc0a1178a07a6936f77ea63e54a Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Tue, 10 Dec 2024 18:11:51 +0000
Subject: [PATCH 07/26] chore: adding i18n

---
 .../src/core/releases/i18n/resources.ts       | 42 ++++++++++++++++---
 .../releaseCTAButtons/ReleaseRevertButton.tsx | 25 +++++++----
 2 files changed, 52 insertions(+), 15 deletions(-)

diff --git a/packages/sanity/src/core/releases/i18n/resources.ts b/packages/sanity/src/core/releases/i18n/resources.ts
index d2745c59ec6..7be57d13ce8 100644
--- a/packages/sanity/src/core/releases/i18n/resources.ts
+++ b/packages/sanity/src/core/releases/i18n/resources.ts
@@ -14,6 +14,8 @@ const releasesLocaleStrings = {
   'action.archived': 'Archived',
   /** Action text for comparing document versions */
   'action.compare-versions': 'Compare versions',
+  /** Action text for reverting a release by creating a new release */
+  'action.create-revert-release': 'Stage in new release',
   /** Action text for deleting a release */
   'action.delete-release': 'Delete release',
   /** Action text for editing a release */
@@ -34,6 +36,8 @@ const releasesLocaleStrings = {
   'action.review': 'Review changes',
   /** Text for the summary button in release tool */
   'actions.summary': 'Summary',
+  /** Action text for reverting a release immediately without staging changes */
+  'action.immediate-revert-release': 'Revert now',
   /** Label for unarchiving a release */
   'action.unarchive': 'Unarchive release',
   /** Header for the dialog confirming the archive of a release */
@@ -185,6 +189,29 @@ const releasesLocaleStrings = {
   /** Label for when documents in release have validation errors */
   'publish-dialog.validation.error': 'Some documents have validation errors',
 
+  /** Description for the review changes button in release tool */
+  'review.description': 'Add documents to this release to review changes',
+  /** Text for when a document is edited */
+  'review.edited': 'Edited <RelativeTime/>',
+  /** Description for the dialog confirming the revert of a release with multiple documents */
+  'revert-dialog.confirm-revert-description_one':
+    'This will revert {{releaseDocumentsLength}} document version.',
+  /** Description for the dialog confirming the revert of a release with multiple documents */
+  'revert-dialog.confirm-revert-description_other':
+    'This will revert {{releaseDocumentsLength}} document versions.',
+  /** Title for the dialog confirming the revert of a release */
+  'revert-dialog.confirm-revert.title': "Are you sure you want to revert the '{{title}}' release?",
+  /** Checkbox label to confirm whether to create a staged release for revert or immediately revert */
+  'revert-dialog.confirm-revert.stage-revert-checkbox-label':
+    'Stage revert actions in a new release',
+  /** Warning card text for when immediately revert a release with history */
+  'revert-dialog.confirm-revert.warning-card':
+    'Changes were made to documents in this release after they were published. Reverting will revert all changes',
+  /** Title of a reverted release */
+  'revert-release.title': 'Reverting "{{title}}"',
+  /** Description of a reverted release */
+  'revert-release.description': 'Revert changes to document versions in "{{title}}".',
+
   /** Title o unschedule release dialog */
   'schedule-button.tooltip': 'Are you sure you want to unschedule the release?',
 
@@ -204,7 +231,7 @@ const releasesLocaleStrings = {
     "The '<strong>{{title}}</strong>' release and its document will be published on the selected date.",
   /** Description for the dialog confirming the publish of a release with multiple documents */
   'schedule-dialog.confirm-description_other':
-    'The <strong>{{title}}</strong> release and its {{count}}  document versions will be scheduled for publishing.',
+    'The <strong>{{title}}</strong> release and its {{count}} document versions will be scheduled for publishing.',
 
   /** Description for the confirm button for scheduling a release */
   'schedule-dialog.confirm-button': 'Yes, schedule for publishing',
@@ -218,11 +245,6 @@ const releasesLocaleStrings = {
   'unschedule-dialog.confirm-description':
     'The release will no longer be published on the scheduled date',
 
-  /** Description for the review changes button in release tool */
-  'review.description': 'Add documents to this release to review changes',
-  /** Text for when a document is edited */
-  'review.edited': 'Edited <RelativeTime/>',
-
   /** Placeholder for search of documents in a release */
   'search-documents-placeholder': 'Search documents',
   /** Text for when the release was created */
@@ -282,6 +304,14 @@ const releasesLocaleStrings = {
   'toast.unschedule.success': "The '<strong>{{title}}</strong>' release was unscheduled.",
   /** Text for tooltip when a release has been scheduled */
   'type-picker.tooltip.scheduled': 'The release is scheduled, unschedule it to change type',
+  /** Text for toast when release failed to revert */
+  'toast.revert.error': 'Failed to revert release: {{error}}',
+  /** Text for toast when release has been reverted immediately */
+  'toast.immediate-revert.success': "The '{{title}}' release was successfully reverted",
+  /** Text for toast when release has reverted release successfully staged */
+  'toast.revert-stage.success': "Revert release for '{{title}}' was successfully created",
+  /** Link text for toast link to the generated revert release */
+  'toast.revert-stage.success-link': 'View revert release',
 
   /** Title for the dialog confirming the unpublish of a release */
   'unpublish-dialog.header': 'Are you sure you want to unpublish this document when releasing?',
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
index fb6733247ce..ca175b6032d 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
@@ -147,8 +147,8 @@ export const ReleaseRevertButton = ({
       await createRelease({
         _id: revertReleaseId,
         metadata: {
-          title: `Reverting "${release.metadata.title}"`,
-          description: `This release reverts the changes made in "${release.metadata.title}"`,
+          title: t('revert-release.title', {title: release.metadata.title}),
+          description: t('revert-release.description', {title: release.metadata.title}),
           releaseType: 'asap',
         },
       })
@@ -180,7 +180,7 @@ export const ReleaseRevertButton = ({
                 }
                 style={{cursor: 'pointer'}}
               >
-                View revert release
+                {t('toast.revert-stage.success-link')}
               </a>
             </Text>
           ),
@@ -230,10 +230,15 @@ export const ReleaseRevertButton = ({
   const confirmReleaseDialog = useMemo(() => {
     if (revertReleaseStatus === 'idle') return null
 
+    const description =
+      documents.length > 1
+        ? 'revert-dialog.confirm-revert-description_other'
+        : 'revert-dialog.confirm-revert-description_one'
+
     return (
       <Dialog
         id="confirm-revert-dialog"
-        header={t('revert-dialog.confirm-revert.title')}
+        header={t('revert-dialog.confirm-revert.title', {title: release.metadata.title})}
         onClose={() => setRevertReleaseStatus('idle')}
         footer={{
           confirmButton: {
@@ -253,7 +258,7 @@ export const ReleaseRevertButton = ({
           {
             <Translate
               t={t}
-              i18nKey="revert-dialog.confirm-revert-description"
+              i18nKey={description}
               values={{
                 releaseDocumentsLength: documents.length,
               }}
@@ -269,15 +274,16 @@ export const ReleaseRevertButton = ({
           />
           <Box flex={1} paddingLeft={3}>
             <Text muted size={1}>
-              <label htmlFor="stage-release">Stage revert actions in a new release</label>
+              <label htmlFor="stage-release">
+                {t('revert-dialog.confirm-revert.stage-revert-checkbox-label')}
+              </label>
             </Text>
           </Box>
         </Flex>
         {hasPostPublishTransactions && !stageNewRevertRelease && (
           <Card marginTop={4} padding={3} radius={2} shadow={1} tone="critical">
             <Text muted size={1}>
-              Changes were made to documents in this release after they were published. Reverting
-              will revert all changes
+              {t('revert-dialog.confirm-revert.warning-card')}
             </Text>
           </Card>
         )}
@@ -285,10 +291,11 @@ export const ReleaseRevertButton = ({
     )
   }, [
     revertReleaseStatus,
+    documents.length,
     t,
+    release.metadata.title,
     stageNewRevertRelease,
     handleRevertRelease,
-    documents.length,
     hasPostPublishTransactions,
   ])
 

From a7b8dcb8be153b28cbda526a99737e2bbd961ed0 Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Tue, 10 Dec 2024 18:19:32 +0000
Subject: [PATCH 08/26] refactor: separating hook

---
 .../src/core/releases/i18n/resources.ts       |   2 +
 .../ReleaseRevertButton.tsx                   | 134 +++---------------
 .../useAdjacentTransactions.ts                | 106 ++++++++++++++
 .../tool/detail/ReleaseDashboardFooter.tsx    |   2 +-
 4 files changed, 125 insertions(+), 119 deletions(-)
 rename packages/sanity/src/core/releases/tool/components/releaseCTAButtons/{ => ReleaseRevertButton}/ReleaseRevertButton.tsx (55%)
 create mode 100644 packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts

diff --git a/packages/sanity/src/core/releases/i18n/resources.ts b/packages/sanity/src/core/releases/i18n/resources.ts
index 7be57d13ce8..25dba42498c 100644
--- a/packages/sanity/src/core/releases/i18n/resources.ts
+++ b/packages/sanity/src/core/releases/i18n/resources.ts
@@ -34,6 +34,8 @@ const releasesLocaleStrings = {
   'action.publish-all-documents': 'Publish all documents',
   /** Text for the review changes button in release tool */
   'action.review': 'Review changes',
+  /** Action text for reverting a release */
+  'action.revert': 'Revert release',
   /** Text for the summary button in release tool */
   'actions.summary': 'Summary',
   /** Action text for reverting a release immediately without staging changes */
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
similarity index 55%
rename from packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
rename to packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
index ca175b6032d..af602e25f77 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
@@ -1,22 +1,18 @@
 import {RestoreIcon} from '@sanity/icons'
 import {Box, Card, Checkbox, Flex, Text, useToast} from '@sanity/ui'
 import {useCallback, useMemo, useState} from 'react'
-import {useObservable} from 'react-rx'
-import {combineLatest, filter, forkJoin, from, map, of, switchMap} from 'rxjs'
 
-import {useRouter} from '../../../../../router'
-import {Button} from '../../../../../ui-components/button/Button'
-import {Dialog} from '../../../../../ui-components/dialog'
-import {useClient} from '../../../../hooks/useClient'
-import {Translate, useTranslation} from '../../../../i18n'
-import {getTransactionsLogs} from '../../../../store/translog/getTransactionLogs'
-import {API_VERSION} from '../../../../tasks/constants'
-import {releasesLocaleNamespace} from '../../../i18n'
-import {type ReleaseDocument} from '../../../store/types'
-import {useReleaseOperations} from '../../../store/useReleaseOperations'
-import {createReleaseId} from '../../../util/createReleaseId'
-import {getReleaseIdFromReleaseDocumentId} from '../../../util/getReleaseIdFromReleaseDocumentId'
-import {type DocumentInRelease} from '../../detail/useBundleDocuments'
+import {useRouter} from '../../../../../../router'
+import {Button} from '../../../../../../ui-components/button/Button'
+import {Dialog} from '../../../../../../ui-components/dialog'
+import {Translate, useTranslation} from '../../../../../i18n'
+import {releasesLocaleNamespace} from '../../../../i18n'
+import {type ReleaseDocument} from '../../../../store/types'
+import {useReleaseOperations} from '../../../../store/useReleaseOperations'
+import {createReleaseId} from '../../../../util/createReleaseId'
+import {getReleaseIdFromReleaseDocumentId} from '../../../../util/getReleaseIdFromReleaseDocumentId'
+import {type DocumentInRelease} from '../../../detail/useBundleDocuments'
+import {useAdjacentTransactions} from './useAdjacentTransactions'
 
 interface ReleasePublishAllButtonProps {
   release: ReleaseDocument
@@ -24,110 +20,12 @@ interface ReleasePublishAllButtonProps {
   disabled?: boolean
 }
 
-const useGetAdjacentTransactions = (documents: DocumentInRelease[]) => {
-  const client = useClient({apiVersion: API_VERSION})
-  const observableClient = client.observable
-  const transactionId = documents[0]?.document._rev
-  const {dataset} = client.config()
-
-  const hasPostPublishTransactions$ = useMemo(
-    () =>
-      from(
-        getTransactionsLogs(
-          client,
-          documents.map(({document}) => document._id),
-          {
-            fromTransaction: transactionId,
-            // one transaction for every document plus the publish transaction
-            limit: 2,
-          },
-        ),
-      ).pipe(
-        // the transaction of published is also returned
-        // so post publish transactions will result in more than 1 transaction
-        map((transactions) => transactions.length > 1),
-      ),
-    [client, documents, transactionId],
-  )
-
-  const revertToDocuments$ = useMemo(
-    () =>
-      from(
-        getTransactionsLogs(
-          client,
-          documents.map(({document}) => document._id),
-          {
-            toTransaction: transactionId,
-            // one transaction for every document plus the publish transaction
-            limit: documents.length + 1,
-            // // reverse to find the transactions immediately before publish
-            reverse: true,
-          },
-        ),
-      ).pipe(
-        filter((transactions) => transactions.length > 0),
-        map(([publishTransaction, ...otherTransactions]) => otherTransactions),
-        map((transactions) =>
-          documents.map(({document}) => ({
-            docId: document._id,
-            // eslint-disable-next-line max-nested-callbacks
-            revisionId: transactions.find(({documentIDs}) => documentIDs.includes(document._id))
-              ?.id,
-          })),
-        ),
-        switchMap((docRevisionPairs) =>
-          forkJoin(
-            docRevisionPairs.map(({docId, revisionId}) => {
-              if (!revisionId) {
-                const {publishedDocumentExists, ...unpublishDocument} =
-                  // eslint-disable-next-line max-nested-callbacks
-                  documents.find(({document}) => document._id === docId)?.document || {}
-
-                return of({
-                  _id: docId,
-                  ...unpublishDocument,
-                  _system: {delete: true},
-                })
-              }
-
-              return (
-                observableClient
-                  .request<{documents: DocumentInRelease['document'][]}>({
-                    url: `/data/history/${dataset}/documents/${docId}?revision=${revisionId}`,
-                  })
-                  // eslint-disable-next-line max-nested-callbacks
-                  .pipe(map((response) => response.documents[0]))
-              )
-            }),
-          ),
-        ),
-      ),
-    [client, dataset, documents, observableClient, transactionId],
-  )
-
-  const memoObservable = useMemo(
-    () =>
-      combineLatest([hasPostPublishTransactions$, revertToDocuments$]).pipe(
-        map(([hasPostPublishTransactions, revertToDocuments]) => ({
-          hasPostPublishTransactions,
-          revertToDocuments,
-        })),
-      ),
-    [hasPostPublishTransactions$, revertToDocuments$],
-  )
-
-  return useObservable(memoObservable, {
-    hasPostPublishTransactions: null,
-    revertToDocuments: null,
-  })
-}
-
 export const ReleaseRevertButton = ({
   release,
   documents,
   disabled,
 }: ReleasePublishAllButtonProps) => {
-  const {hasPostPublishTransactions, revertToDocuments} = useGetAdjacentTransactions(documents)
+  const {hasPostPublishTransactions, documentRevertStates} = useAdjacentTransactions(documents)
   const {t} = useTranslation(releasesLocaleNamespace)
   const [revertReleaseStatus, setRevertReleaseStatus] = useState<'idle' | 'confirm' | 'reverting'>(
     'idle',
@@ -138,7 +36,7 @@ export const ReleaseRevertButton = ({
   const {createRelease, publishRelease, createVersion} = useReleaseOperations()
 
   const handleRevertRelease = useCallback(async () => {
-    if (!revertToDocuments) return
+    if (!documentRevertStates) return
 
     setRevertReleaseStatus('reverting')
     const revertReleaseId = createReleaseId()
@@ -154,7 +52,7 @@ export const ReleaseRevertButton = ({
       })
 
       await Promise.allSettled(
-        revertToDocuments.map((document) =>
+        documentRevertStates.map((document) =>
           createVersion(getReleaseIdFromReleaseDocumentId(revertReleaseId), document._id, document),
         ),
       )
@@ -220,7 +118,7 @@ export const ReleaseRevertButton = ({
     createVersion,
     publishRelease,
     release.metadata.title,
-    revertToDocuments,
+    documentRevertStates,
     router,
     stageNewRevertRelease,
     t,
@@ -304,7 +202,7 @@ export const ReleaseRevertButton = ({
       <Button
         icon={RestoreIcon}
         onClick={() => setRevertReleaseStatus('confirm')}
-        text="Revert release"
+        text={t('action.revert')}
         tone="critical"
         disabled={disabled}
       />
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
new file mode 100644
index 00000000000..4a26477f15c
--- /dev/null
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
@@ -0,0 +1,106 @@
+import {useMemo} from 'react'
+import {useObservable} from 'react-rx'
+import {combineLatest, filter, forkJoin, from, map, switchMap} from 'rxjs'
+
+import {useClient} from '../../../../../hooks/useClient'
+import {getTransactionsLogs} from '../../../../../store/translog/getTransactionLogs'
+import {API_VERSION} from '../../../../../tasks/constants'
+import {type DocumentInRelease} from '../../../detail/useBundleDocuments'
+
+export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
+  const client = useClient({apiVersion: API_VERSION})
+  const observableClient = client.observable
+  const transactionId = documents[0]?.document._rev
+  const {dataset} = client.config()
+
+  const hasPostPublishTransactions$ = useMemo(
+    () =>
+      from(
+        getTransactionsLogs(
+          client,
+          documents.map(({document}) => document._id),
+          {
+            fromTransaction: transactionId,
+            // one transaction for every document plus the publish transaction
+            limit: 2,
+          },
+        ),
+      ).pipe(
+        // the transaction of published is also returned
+        // so post publish transactions will result in more than 1 transaction
+        map((transactions) => transactions.length > 1),
+      ),
+    [client, documents, transactionId],
+  )
+
+  const documentRevertStates$ = useMemo(
+    () =>
+      from(
+        getTransactionsLogs(
+          client,
+          documents.map(({document}) => document._id),
+          {
+            toTransaction: transactionId,
+            // one transaction for every document plus the publish transaction
+            limit: documents.length + 1,
+            // // reverse to find the transactions immediately before publish
+            reverse: true,
+          },
+        ),
+      ).pipe(
+        filter((transactions) => transactions.length > 0),
+        map(([publishTransaction, ...otherTransactions]) => otherTransactions),
+        map((transactions) =>
+          documents.map(({document}) => ({
+            docId: document._id,
+            // eslint-disable-next-line max-nested-callbacks
+            revisionId: transactions.find(({documentIDs}) => documentIDs.includes(document._id))
+              ?.id,
+          })),
+        ),
+        switchMap((docRevisionPairs) =>
+          forkJoin(
+            docRevisionPairs.map(({docId, revisionId}) => {
+              if (!revisionId) {
+                const {publishedDocumentExists, ...unpublishDocument} =
+                  // eslint-disable-next-line max-nested-callbacks
+                  documents.find(({document}) => document._id === docId)?.document || {}
+
+                return of({
+                  _id: docId,
+                  ...unpublishDocument,
+                  _system: {delete: true},
+                })
+              }
+
+              return (
+                observableClient
+                  .request<{documents: DocumentInRelease['document'][]}>({
+                    url: `/data/history/${dataset}/documents/${docId}?revision=${revisionId}`,
+                  })
+                  // eslint-disable-next-line max-nested-callbacks
+                  .pipe(map((response) => response.documents[0]))
+              )
+            }),
+          ),
+        ),
+      ),
+    [client, dataset, documents, observableClient, transactionId],
+  )
+
+  const memoObservable = useMemo(
+    () =>
+      combineLatest([hasPostPublishTransactions$, documentRevertStates$]).pipe(
+        map(([hasPostPublishTransactions, documentRevertStates]) => ({
+          hasPostPublishTransactions,
+          documentRevertStates,
+        })),
+      ),
+    [hasPostPublishTransactions$, documentRevertStates$],
+  )
+
+  return useObservable(memoObservable, {
+    hasPostPublishTransactions: null,
+    documentRevertStates: null,
+  })
+}
diff --git a/packages/sanity/src/core/releases/tool/detail/ReleaseDashboardFooter.tsx b/packages/sanity/src/core/releases/tool/detail/ReleaseDashboardFooter.tsx
index 3904ac47174..fadfe578ab4 100644
--- a/packages/sanity/src/core/releases/tool/detail/ReleaseDashboardFooter.tsx
+++ b/packages/sanity/src/core/releases/tool/detail/ReleaseDashboardFooter.tsx
@@ -4,7 +4,7 @@ import {useMemo} from 'react'
 
 import {isReleaseScheduledOrScheduling, type ReleaseDocument} from '../../index'
 import {ReleasePublishAllButton} from '../components/releaseCTAButtons/ReleasePublishAllButton'
-import {ReleaseRevertButton} from '../components/releaseCTAButtons/ReleaseRevertButton'
+import {ReleaseRevertButton} from '../components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton'
 import {ReleaseScheduleButton} from '../components/releaseCTAButtons/ReleaseScheduleButton'
 import {ReleaseUnscheduleButton} from '../components/releaseCTAButtons/ReleaseUnscheduleButton'
 import {ReleaseMenuButton} from '../components/ReleaseMenuButton/ReleaseMenuButton'

From 927c4bec38bd520192122e26ae45f1b46c53bca8 Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Wed, 11 Dec 2024 09:26:38 +0000
Subject: [PATCH 09/26] chore: telemetry for reverting release

---
 .../__telemetry__/releases.telemetry.ts         | 16 ++++++++++++++++
 .../ReleaseRevertButton/ReleaseRevertButton.tsx | 17 ++++++++++++-----
 2 files changed, 28 insertions(+), 5 deletions(-)

diff --git a/packages/sanity/src/core/releases/__telemetry__/releases.telemetry.ts b/packages/sanity/src/core/releases/__telemetry__/releases.telemetry.ts
index 2888a123dff..8048ff8fb91 100644
--- a/packages/sanity/src/core/releases/__telemetry__/releases.telemetry.ts
+++ b/packages/sanity/src/core/releases/__telemetry__/releases.telemetry.ts
@@ -20,6 +20,13 @@ export interface OriginInfo {
   origin: 'structure' | 'release-plugin'
 }
 
+export interface RevertInfo {
+  /**
+   * determined whether reverting a release created a new staged release, or immediately reverted
+   */
+  revertType: 'immediately' | 'staged'
+}
+
 /**
  * When a document (version) is successfully added to a release
  * @internal
@@ -101,3 +108,12 @@ export const UnarchivedRelease = defineEvent({
   version: 1,
   description: 'User unarchived a release',
 })
+
+/** When a release is successfully reverted
+ * @internal
+ */
+export const RevertRelease = defineEvent<RevertInfo>({
+  name: 'Revert release',
+  version: 1,
+  description: 'User reverted a release',
+})
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
index af602e25f77..9b30c124486 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
@@ -1,4 +1,5 @@
 import {RestoreIcon} from '@sanity/icons'
+import {useTelemetry} from '@sanity/telemetry/react'
 import {Box, Card, Checkbox, Flex, Text, useToast} from '@sanity/ui'
 import {useCallback, useMemo, useState} from 'react'
 
@@ -6,6 +7,7 @@ import {useRouter} from '../../../../../../router'
 import {Button} from '../../../../../../ui-components/button/Button'
 import {Dialog} from '../../../../../../ui-components/dialog'
 import {Translate, useTranslation} from '../../../../../i18n'
+import {RevertRelease} from '../../../../__telemetry__/releases.telemetry'
 import {releasesLocaleNamespace} from '../../../../i18n'
 import {type ReleaseDocument} from '../../../../store/types'
 import {useReleaseOperations} from '../../../../store/useReleaseOperations'
@@ -32,6 +34,7 @@ export const ReleaseRevertButton = ({
   )
   const toast = useToast()
   const router = useRouter()
+  const telemetry = useTelemetry()
   const [stageNewRevertRelease, setStageNewRevertRelease] = useState(true)
   const {createRelease, publishRelease, createVersion} = useReleaseOperations()
 
@@ -58,6 +61,7 @@ export const ReleaseRevertButton = ({
       )
 
       if (stageNewRevertRelease) {
+        telemetry.log(RevertRelease, {revertType: 'staged'})
         toast.push({
           closable: true,
           status: 'success',
@@ -86,6 +90,8 @@ export const ReleaseRevertButton = ({
       } else {
         await publishRelease(revertReleaseId)
 
+        telemetry.log(RevertRelease, {revertType: 'immediately'})
+
         toast.push({
           closable: true,
           status: 'success',
@@ -114,15 +120,16 @@ export const ReleaseRevertButton = ({
       setRevertReleaseStatus('idle')
     }
   }, [
+    documentRevertStates,
     createRelease,
-    createVersion,
-    publishRelease,
+    t,
     release.metadata.title,
-    documentRevertStates,
-    router,
     stageNewRevertRelease,
-    t,
+    createVersion,
+    telemetry,
     toast,
+    router,
+    publishRelease,
   ])
 
   const confirmReleaseDialog = useMemo(() => {

From 1740fbfb283bb0fcddb67fdf545dc82f96d8804f Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Wed, 11 Dec 2024 11:16:05 +0000
Subject: [PATCH 10/26] refactor: tidy to useAdjacent (check back here for
 before state)

---
 .../ReleaseRevertButton.tsx                   |  13 +-
 .../useAdjacentTransactions.ts                | 214 +++++++++++-------
 2 files changed, 141 insertions(+), 86 deletions(-)

diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
index 9b30c124486..394e69c31b8 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
@@ -1,7 +1,7 @@
 import {RestoreIcon} from '@sanity/icons'
 import {useTelemetry} from '@sanity/telemetry/react'
 import {Box, Card, Checkbox, Flex, Text, useToast} from '@sanity/ui'
-import {useCallback, useMemo, useState} from 'react'
+import {useCallback, useEffect, useMemo, useState} from 'react'
 
 import {useRouter} from '../../../../../../router'
 import {Button} from '../../../../../../ui-components/button/Button'
@@ -27,7 +27,8 @@ export const ReleaseRevertButton = ({
   documents,
   disabled,
 }: ReleasePublishAllButtonProps) => {
-  const {hasPostPublishTransactions, documentRevertStates} = useAdjacentTransactions(documents)
+  const {result, trigger} = useAdjacentTransactions(documents)
+  const {documentRevertStates, hasPostPublishTransactions} = result || {}
   const {t} = useTranslation(releasesLocaleNamespace)
   const [revertReleaseStatus, setRevertReleaseStatus] = useState<'idle' | 'confirm' | 'reverting'>(
     'idle',
@@ -38,6 +39,14 @@ export const ReleaseRevertButton = ({
   const [stageNewRevertRelease, setStageNewRevertRelease] = useState(true)
   const {createRelease, publishRelease, createVersion} = useReleaseOperations()
 
+  useEffect(() => {
+    if (revertReleaseStatus === 'confirm') {
+      trigger()
+    }
+  }, [revertReleaseStatus, trigger])
+
+  console.log({documentRevertStates, hasPostPublishTransactions})
+
   const handleRevertRelease = useCallback(async () => {
     if (!documentRevertStates) return
 
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
index 4a26477f15c..5661a4d1911 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
@@ -1,106 +1,152 @@
-import {useMemo} from 'react'
+import {useCallback, useMemo, useState} from 'react'
 import {useObservable} from 'react-rx'
-import {combineLatest, filter, forkJoin, from, map, switchMap} from 'rxjs'
+import {
+  combineLatest,
+  delay,
+  filter,
+  forkJoin,
+  from,
+  map,
+  type Observable,
+  of,
+  switchMap,
+} from 'rxjs'
 
 import {useClient} from '../../../../../hooks/useClient'
 import {getTransactionsLogs} from '../../../../../store/translog/getTransactionLogs'
 import {API_VERSION} from '../../../../../tasks/constants'
 import {type DocumentInRelease} from '../../../detail/useBundleDocuments'
 
+type RevertDocuments = (Omit<DocumentInRelease['document'], 'publishedDocumentExists'> & {
+  _system?: {
+    delete: boolean
+  }
+})[]
+
+interface AdjacentTransactionsResult {
+  hasPostPublishTransactions: boolean | null
+  documentRevertStates: RevertDocuments | null
+}
+
 export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
   const client = useClient({apiVersion: API_VERSION})
   const observableClient = client.observable
   const transactionId = documents[0]?.document._rev
   const {dataset} = client.config()
+  const [trigger, setTrigger] = useState(0)
+  const [resolvePromise, setResolvePromise] = useState<
+    ((result: AdjacentTransactionsResult) => void) | null
+  >(null)
 
-  const hasPostPublishTransactions$ = useMemo(
-    () =>
-      from(
-        getTransactionsLogs(
-          client,
-          documents.map(({document}) => document._id),
-          {
-            fromTransaction: transactionId,
-            // one transaction for every document plus the publish transaction
-            limit: 2,
-          },
-        ),
-      ).pipe(
-        // the transaction of published is also returned
-        // so post publish transactions will result in more than 1 transaction
-        map((transactions) => transactions.length > 1),
+  const memoObservable = useMemo(() => {
+    if (!trigger) {
+      // If not triggered, return null to prevent the observable from running
+      return of({
+        hasPostPublishTransactions: null,
+        documentRevertStates: null,
+      })
+    }
+
+    // Observable to check if there are post-publish transactions
+    const hasPostPublishTransactions$ = from(
+      getTransactionsLogs(
+        client,
+        documents.map(({document}) => document._id),
+        {
+          fromTransaction: transactionId,
+          // one transaction for every document plus the publish transaction
+          limit: 2,
+        },
       ),
-    [client, documents, transactionId],
-  )
-
-  const documentRevertStates$ = useMemo(
-    () =>
-      from(
-        getTransactionsLogs(
-          client,
-          documents.map(({document}) => document._id),
-          {
-            toTransaction: transactionId,
-            // one transaction for every document plus the publish transaction
-            limit: documents.length + 1,
-            // // reverse to find the transactions immediately before publish
-            reverse: true,
-          },
-        ),
-      ).pipe(
-        filter((transactions) => transactions.length > 0),
-        map(([publishTransaction, ...otherTransactions]) => otherTransactions),
-        map((transactions) =>
-          documents.map(({document}) => ({
-            docId: document._id,
-            // eslint-disable-next-line max-nested-callbacks
-            revisionId: transactions.find(({documentIDs}) => documentIDs.includes(document._id))
-              ?.id,
-          })),
-        ),
-        switchMap((docRevisionPairs) =>
-          forkJoin(
-            docRevisionPairs.map(({docId, revisionId}) => {
-              if (!revisionId) {
-                const {publishedDocumentExists, ...unpublishDocument} =
-                  // eslint-disable-next-line max-nested-callbacks
-                  documents.find(({document}) => document._id === docId)?.document || {}
-
-                return of({
-                  _id: docId,
-                  ...unpublishDocument,
-                  _system: {delete: true},
-                })
-              }
-
-              return (
-                observableClient
-                  .request<{documents: DocumentInRelease['document'][]}>({
-                    url: `/data/history/${dataset}/documents/${docId}?revision=${revisionId}`,
-                  })
-                  // eslint-disable-next-line max-nested-callbacks
-                  .pipe(map((response) => response.documents[0]))
+    ).pipe(
+      // the transaction of published is also returned
+      // so post publish transactions will result in more than 1 transaction
+      map((transactions) => transactions.length > 1),
+    )
+
+    // Observable to get the revert states of the documents
+    const documentRevertStates$: Observable<RevertDocuments> = from(
+      getTransactionsLogs(
+        client,
+        documents.map(({document}) => document._id),
+        {
+          toTransaction: transactionId,
+          // one transaction for every document plus the publish transaction
+          limit: documents.length + 1,
+          // reverse to find the transactions immediately before publish
+          reverse: true,
+        },
+      ),
+    ).pipe(
+      filter((transactions) => transactions.length > 0),
+      map(([publishTransaction, ...otherTransactions]) => {
+        const getDocumentTransaction = (docId: string) =>
+          otherTransactions.find(({documentIDs}) => documentIDs.includes(docId))?.id
+
+        return documents.map(({document}) => ({
+          docId: document._id,
+          revisionId: getDocumentTransaction(document._id),
+        }))
+      }),
+      switchMap((docRevisionPairs) =>
+        forkJoin(
+          docRevisionPairs.map(({docId, revisionId}) => {
+            if (!revisionId) {
+              const {publishedDocumentExists, ...unpublishDocument} =
+                // eslint-disable-next-line max-nested-callbacks
+                documents.find(({document}) => document._id === docId)?.document || {}
+
+              return of({
+                _id: docId,
+                ...unpublishDocument,
+                _system: {delete: true},
+              })
+            }
+
+            return observableClient
+              .request<{
+                documents: Omit<DocumentInRelease['document'], 'publishedDocumentExists'>[]
+              }>({
+                url: `/data/history/${dataset}/documents/${docId}?revision=${revisionId}`,
+              })
+              .pipe(
+                map((response) => response.documents[0]),
+                delay(5000),
               )
-            }),
-          ),
+          }),
         ),
       ),
-    [client, dataset, documents, observableClient, transactionId],
-  )
-
-  const memoObservable = useMemo(
-    () =>
-      combineLatest([hasPostPublishTransactions$, documentRevertStates$]).pipe(
-        map(([hasPostPublishTransactions, documentRevertStates]) => ({
-          hasPostPublishTransactions,
-          documentRevertStates,
-        })),
-      ),
-    [hasPostPublishTransactions$, documentRevertStates$],
-  )
+    )
+
+    return combineLatest([hasPostPublishTransactions$, documentRevertStates$]).pipe(
+      map(([hasPostPublishTransactions, documentRevertStates]) => {
+        const result = {hasPostPublishTransactions, documentRevertStates}
 
-  return useObservable(memoObservable, {
+        if (resolvePromise) {
+          resolvePromise(result)
+          setResolvePromise(null)
+        }
+        return result
+      }),
+    )
+  }, [trigger, client, documents, transactionId, observableClient, dataset, resolvePromise])
+
+  const observableResult = useObservable(memoObservable, {
     hasPostPublishTransactions: null,
     documentRevertStates: null,
   })
+
+  const startObservables = useCallback(() => {
+    if (resolvePromise) return resolvePromise
+
+    return new Promise((res) => {
+      setResolvePromise(() => res)
+      setTrigger((curTrigger) => curTrigger + 1)
+    })
+  }, [resolvePromise])
+
+  return {
+    ...observableResult,
+    getAdjacentTransactions: startObservables,
+  }
 }

From 426928f4cd6c960a37612456d7c1e7d43028e6e1 Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Wed, 11 Dec 2024 11:16:31 +0000
Subject: [PATCH 11/26] refactor: optimistic fetch of revert states that
 carries into the handler

---
 .../src/core/releases/i18n/resources.ts       |  2 +-
 .../ReleaseRevertButton.tsx                   | 34 ++++++------
 .../useAdjacentTransactions.ts                | 55 ++++++++++++-------
 3 files changed, 53 insertions(+), 38 deletions(-)

diff --git a/packages/sanity/src/core/releases/i18n/resources.ts b/packages/sanity/src/core/releases/i18n/resources.ts
index 25dba42498c..d3135486b90 100644
--- a/packages/sanity/src/core/releases/i18n/resources.ts
+++ b/packages/sanity/src/core/releases/i18n/resources.ts
@@ -208,7 +208,7 @@ const releasesLocaleStrings = {
     'Stage revert actions in a new release',
   /** Warning card text for when immediately revert a release with history */
   'revert-dialog.confirm-revert.warning-card':
-    'Changes were made to documents in this release after they were published. Reverting will revert all changes',
+    'Changes were made to documents in this release after they were published. Reverting will revert all changes.',
   /** Title of a reverted release */
   'revert-release.title': 'Reverting "{{title}}"',
   /** Description of a reverted release */
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
index 394e69c31b8..ad97bd1ec9c 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
@@ -27,8 +27,7 @@ export const ReleaseRevertButton = ({
   documents,
   disabled,
 }: ReleasePublishAllButtonProps) => {
-  const {result, trigger} = useAdjacentTransactions(documents)
-  const {documentRevertStates, hasPostPublishTransactions} = result || {}
+  const {hasPostPublishTransactions, getAdjacentTransactions} = useAdjacentTransactions(documents)
   const {t} = useTranslation(releasesLocaleNamespace)
   const [revertReleaseStatus, setRevertReleaseStatus] = useState<'idle' | 'confirm' | 'reverting'>(
     'idle',
@@ -40,20 +39,26 @@ export const ReleaseRevertButton = ({
   const {createRelease, publishRelease, createVersion} = useReleaseOperations()
 
   useEffect(() => {
-    if (revertReleaseStatus === 'confirm') {
-      trigger()
-    }
-  }, [revertReleaseStatus, trigger])
+    if (revertReleaseStatus === 'confirm') getAdjacentTransactions()
+  }, [getAdjacentTransactions, revertReleaseStatus])
 
-  console.log({documentRevertStates, hasPostPublishTransactions})
+  const navigateToRevertRelease = useCallback(
+    (revertReleaseId: string) => () =>
+      router.navigate({releaseId: getReleaseIdFromReleaseDocumentId(revertReleaseId)}),
+    [router],
+  )
 
   const handleRevertRelease = useCallback(async () => {
-    if (!documentRevertStates) return
-
     setRevertReleaseStatus('reverting')
+    const {documentRevertStates} = await getAdjacentTransactions()
+
     const revertReleaseId = createReleaseId()
 
     try {
+      if (!documentRevertStates) {
+        throw new Error('Unable to find documents to revert')
+      }
+
       await createRelease({
         _id: revertReleaseId,
         metadata: {
@@ -85,12 +90,7 @@ export const ReleaseRevertButton = ({
           ),
           description: (
             <Text size={1} weight="medium">
-              <a
-                onClick={() =>
-                  router.navigate({releaseId: getReleaseIdFromReleaseDocumentId(revertReleaseId)})
-                }
-                style={{cursor: 'pointer'}}
-              >
+              <a onClick={navigateToRevertRelease(revertReleaseId)} style={{cursor: 'pointer'}}>
                 {t('toast.revert-stage.success-link')}
               </a>
             </Text>
@@ -129,7 +129,7 @@ export const ReleaseRevertButton = ({
       setRevertReleaseStatus('idle')
     }
   }, [
-    documentRevertStates,
+    getAdjacentTransactions,
     createRelease,
     t,
     release.metadata.title,
@@ -137,7 +137,7 @@ export const ReleaseRevertButton = ({
     createVersion,
     telemetry,
     toast,
-    router,
+    navigateToRevertRelease,
     publishRelease,
   ])
 
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
index 5661a4d1911..00a0978a2c8 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
@@ -1,4 +1,4 @@
-import {useCallback, useMemo, useState} from 'react'
+import {useCallback, useEffect, useMemo, useRef, useState} from 'react'
 import {useObservable} from 'react-rx'
 import {
   combineLatest,
@@ -34,9 +34,9 @@ export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
   const transactionId = documents[0]?.document._rev
   const {dataset} = client.config()
   const [trigger, setTrigger] = useState(0)
-  const [resolvePromise, setResolvePromise] = useState<
-    ((result: AdjacentTransactionsResult) => void) | null
-  >(null)
+  const promiseRef = useRef<Promise<AdjacentTransactionsResult> | null>(null)
+  const resolvePromiseRef = useRef<((value: AdjacentTransactionsResult) => void) | null>(null)
+  const resolvedValueRef = useRef<AdjacentTransactionsResult | null>(null)
 
   const memoObservable = useMemo(() => {
     if (!trigger) {
@@ -119,31 +119,46 @@ export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
     )
 
     return combineLatest([hasPostPublishTransactions$, documentRevertStates$]).pipe(
-      map(([hasPostPublishTransactions, documentRevertStates]) => {
-        const result = {hasPostPublishTransactions, documentRevertStates}
-
-        if (resolvePromise) {
-          resolvePromise(result)
-          setResolvePromise(null)
-        }
-        return result
-      }),
+      map(([hasPostPublishTransactions, documentRevertStates]) => ({
+        hasPostPublishTransactions,
+        documentRevertStates,
+      })),
     )
-  }, [trigger, client, documents, transactionId, observableClient, dataset, resolvePromise])
+  }, [trigger, client, documents, transactionId, observableClient, dataset])
 
   const observableResult = useObservable(memoObservable, {
     hasPostPublishTransactions: null,
     documentRevertStates: null,
   })
 
+  useEffect(() => {
+    if (observableResult.hasPostPublishTransactions !== null) {
+      resolvedValueRef.current = observableResult
+
+      // Resolve the promise if it exists
+      if (resolvePromiseRef.current) {
+        resolvePromiseRef.current(observableResult)
+        resolvePromiseRef.current = null
+        promiseRef.current = null // Reset the promiseRef for future fetches
+      }
+    }
+  }, [observableResult])
+
   const startObservables = useCallback(() => {
-    if (resolvePromise) return resolvePromise
+    if (resolvedValueRef.current) {
+      // Return resolved value immediately if available
+      return Promise.resolve(resolvedValueRef.current)
+    }
+
+    if (!promiseRef.current) {
+      promiseRef.current = new Promise((res) => {
+        resolvePromiseRef.current = res
+        setTrigger((curTrigger) => curTrigger + 1)
+      })
+    }
 
-    return new Promise((res) => {
-      setResolvePromise(() => res)
-      setTrigger((curTrigger) => curTrigger + 1)
-    })
-  }, [resolvePromise])
+    return promiseRef.current
+  }, [])
 
   return {
     ...observableResult,

From 8ce775da5c9565de18c3f14b4f2b7ba4f3658101 Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Wed, 11 Dec 2024 13:40:26 +0000
Subject: [PATCH 12/26] refactor: types for useAdjacentTransactions

---
 .../src/core/releases/i18n/resources.ts       |  2 +-
 .../ReleaseRevertButton.tsx                   | 24 ++++++++++-----
 .../useAdjacentTransactions.ts                | 29 ++++++-------------
 3 files changed, 27 insertions(+), 28 deletions(-)

diff --git a/packages/sanity/src/core/releases/i18n/resources.ts b/packages/sanity/src/core/releases/i18n/resources.ts
index d3135486b90..9b5278af36b 100644
--- a/packages/sanity/src/core/releases/i18n/resources.ts
+++ b/packages/sanity/src/core/releases/i18n/resources.ts
@@ -311,7 +311,7 @@ const releasesLocaleStrings = {
   /** Text for toast when release has been reverted immediately */
   'toast.immediate-revert.success': "The '{{title}}' release was successfully reverted",
   /** Text for toast when release has reverted release successfully staged */
-  'toast.revert-stage.success': "Revert release for '{{title}}' was successfully created",
+  'toast.revert-stage.success': "Revert release for '{{title}}' was successfully created. <Link/>",
   /** Link text for toast link to the generated revert release */
   'toast.revert-stage.success-link': 'View revert release',
 
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
index ad97bd1ec9c..069f75caea3 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
@@ -82,19 +82,29 @@ export const ReleaseRevertButton = ({
           title: (
             <Text muted size={1}>
               <Translate
+                components={{
+                  Link: () => (
+                    <Text
+                      size={1}
+                      weight="medium"
+                      data-as="a"
+                      onClick={navigateToRevertRelease(revertReleaseId)}
+                      style={{
+                        cursor: 'pointer',
+                        marginBottom: '0.5rem',
+                        display: 'flex',
+                      }}
+                    >
+                      {t('toast.revert-stage.success-link')}
+                    </Text>
+                  ),
+                }}
                 t={t}
                 i18nKey="toast.revert-stage.success"
                 values={{title: release.metadata.title}}
               />
             </Text>
           ),
-          description: (
-            <Text size={1} weight="medium">
-              <a onClick={navigateToRevertRelease(revertReleaseId)} style={{cursor: 'pointer'}}>
-                {t('toast.revert-stage.success-link')}
-              </a>
-            </Text>
-          ),
         })
       } else {
         await publishRelease(revertReleaseId)
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
index 00a0978a2c8..96511d54954 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
@@ -1,27 +1,20 @@
+import {type SanityDocument} from '@sanity/types'
 import {useCallback, useEffect, useMemo, useRef, useState} from 'react'
 import {useObservable} from 'react-rx'
-import {
-  combineLatest,
-  delay,
-  filter,
-  forkJoin,
-  from,
-  map,
-  type Observable,
-  of,
-  switchMap,
-} from 'rxjs'
+import {combineLatest, filter, forkJoin, from, map, type Observable, of, switchMap} from 'rxjs'
 
 import {useClient} from '../../../../../hooks/useClient'
 import {getTransactionsLogs} from '../../../../../store/translog/getTransactionLogs'
 import {API_VERSION} from '../../../../../tasks/constants'
 import {type DocumentInRelease} from '../../../detail/useBundleDocuments'
 
-type RevertDocuments = (Omit<DocumentInRelease['document'], 'publishedDocumentExists'> & {
+type RevertDocument = SanityDocument & {
   _system?: {
     delete: boolean
   }
-})[]
+}
+
+type RevertDocuments = RevertDocument[]
 
 interface AdjacentTransactionsResult {
   hasPostPublishTransactions: boolean | null
@@ -97,22 +90,18 @@ export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
                 documents.find(({document}) => document._id === docId)?.document || {}
 
               return of({
-                _id: docId,
-                ...unpublishDocument,
+                ...(unpublishDocument as SanityDocument),
                 _system: {delete: true},
               })
             }
 
             return observableClient
               .request<{
-                documents: Omit<DocumentInRelease['document'], 'publishedDocumentExists'>[]
+                documents: RevertDocuments
               }>({
                 url: `/data/history/${dataset}/documents/${docId}?revision=${revisionId}`,
               })
-              .pipe(
-                map((response) => response.documents[0]),
-                delay(5000),
-              )
+              .pipe(map((response) => response.documents[0]))
           }),
         ),
       ),

From 9da82529f12403786a3c758fca433e72c62d54f6 Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Thu, 12 Dec 2024 02:10:06 +0000
Subject: [PATCH 13/26] refactor: post pub transactions separated hook;
 separate component for confirm revert

---
 .../ReleaseRevertButton.tsx                   | 354 +++++++++---------
 .../useAdjacentTransactions.ts                |  60 +--
 .../usePostPublishTransactions.ts             |  38 ++
 3 files changed, 244 insertions(+), 208 deletions(-)
 create mode 100644 packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts

diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
index 069f75caea3..d42b9153ed8 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
@@ -1,7 +1,7 @@
 import {RestoreIcon} from '@sanity/icons'
 import {useTelemetry} from '@sanity/telemetry/react'
 import {Box, Card, Checkbox, Flex, Text, useToast} from '@sanity/ui'
-import {useCallback, useEffect, useMemo, useState} from 'react'
+import {useCallback, useEffect, useState} from 'react'
 
 import {useRouter} from '../../../../../../router'
 import {Button} from '../../../../../../ui-components/button/Button'
@@ -15,6 +15,7 @@ import {createReleaseId} from '../../../../util/createReleaseId'
 import {getReleaseIdFromReleaseDocumentId} from '../../../../util/getReleaseIdFromReleaseDocumentId'
 import {type DocumentInRelease} from '../../../detail/useBundleDocuments'
 import {useAdjacentTransactions} from './useAdjacentTransactions'
+import {usePostPublishTransactions} from './usePostPublishTransactions'
 
 interface ReleasePublishAllButtonProps {
   release: ReleaseDocument
@@ -22,20 +23,99 @@ interface ReleasePublishAllButtonProps {
   disabled?: boolean
 }
 
+type RevertReleaseStatus = 'idle' | 'confirm' | 'reverting'
+
+const ConfirmReleaseDialog = ({
+  revertReleaseStatus,
+  documents,
+  setRevertReleaseStatus,
+  release,
+  handleRevertRelease,
+}: {
+  revertReleaseStatus: RevertReleaseStatus
+  documents: DocumentInRelease[]
+  setRevertReleaseStatus: (status: RevertReleaseStatus) => void
+  release: ReleaseDocument
+  handleRevertRelease: (stageNewRevertRelease: boolean) => Promise<void>
+}) => {
+  const {t} = useTranslation(releasesLocaleNamespace)
+  const hasPostPublishTransactions = usePostPublishTransactions(documents)
+  const [stageNewRevertRelease, setStageNewRevertRelease] = useState(true)
+
+  if (revertReleaseStatus === 'idle') return null
+
+  const description =
+    documents.length > 1
+      ? 'revert-dialog.confirm-revert-description_other'
+      : 'revert-dialog.confirm-revert-description_one'
+
+  return (
+    <Dialog
+      id="confirm-revert-dialog"
+      header={t('revert-dialog.confirm-revert.title', {title: release.metadata.title})}
+      onClose={() => setRevertReleaseStatus('idle')}
+      footer={{
+        confirmButton: {
+          text: t(
+            stageNewRevertRelease
+              ? 'action.create-revert-release'
+              : 'action.immediate-revert-release',
+          ),
+          tone: 'positive',
+          onClick: () => handleRevertRelease(stageNewRevertRelease),
+          loading: revertReleaseStatus === 'reverting',
+          disabled: revertReleaseStatus === 'reverting',
+        },
+      }}
+    >
+      <Text muted size={1}>
+        {
+          <Translate
+            t={t}
+            i18nKey={description}
+            values={{
+              releaseDocumentsLength: documents.length,
+            }}
+          />
+        }
+      </Text>
+      <Flex align="center" paddingTop={4}>
+        <Checkbox
+          onChange={() => setStageNewRevertRelease((current) => !current)}
+          id="stage-release"
+          style={{display: 'block'}}
+          checked={stageNewRevertRelease}
+        />
+        <Box flex={1} paddingLeft={3}>
+          <Text muted size={1}>
+            <label htmlFor="stage-release">
+              {t('revert-dialog.confirm-revert.stage-revert-checkbox-label')}
+            </label>
+          </Text>
+        </Box>
+      </Flex>
+      {hasPostPublishTransactions && !stageNewRevertRelease && (
+        <Card marginTop={4} padding={3} radius={2} shadow={1} tone="critical">
+          <Text muted size={1}>
+            {t('revert-dialog.confirm-revert.warning-card')}
+          </Text>
+        </Card>
+      )}
+    </Dialog>
+  )
+}
+
 export const ReleaseRevertButton = ({
   release,
   documents,
   disabled,
 }: ReleasePublishAllButtonProps) => {
-  const {hasPostPublishTransactions, getAdjacentTransactions} = useAdjacentTransactions(documents)
+  const {getAdjacentTransactions} = useAdjacentTransactions(documents)
   const {t} = useTranslation(releasesLocaleNamespace)
-  const [revertReleaseStatus, setRevertReleaseStatus] = useState<'idle' | 'confirm' | 'reverting'>(
-    'idle',
-  )
+  const [revertReleaseStatus, setRevertReleaseStatus] = useState<RevertReleaseStatus>('idle')
   const toast = useToast()
   const router = useRouter()
   const telemetry = useTelemetry()
-  const [stageNewRevertRelease, setStageNewRevertRelease] = useState(true)
   const {createRelease, publishRelease, createVersion} = useReleaseOperations()
 
   useEffect(() => {
@@ -48,180 +128,114 @@ export const ReleaseRevertButton = ({
     [router],
   )
 
-  const handleRevertRelease = useCallback(async () => {
-    setRevertReleaseStatus('reverting')
-    const {documentRevertStates} = await getAdjacentTransactions()
-
-    const revertReleaseId = createReleaseId()
+  const handleRevertRelease = useCallback(
+    async (stageNewRevertRelease: boolean) => {
+      setRevertReleaseStatus('reverting')
+      const documentRevertStates = await getAdjacentTransactions()
 
-    try {
-      if (!documentRevertStates) {
-        throw new Error('Unable to find documents to revert')
-      }
+      const revertReleaseId = createReleaseId()
 
-      await createRelease({
-        _id: revertReleaseId,
-        metadata: {
-          title: t('revert-release.title', {title: release.metadata.title}),
-          description: t('revert-release.description', {title: release.metadata.title}),
-          releaseType: 'asap',
-        },
-      })
+      try {
+        if (!documentRevertStates) {
+          throw new Error('Unable to find documents to revert')
+        }
 
-      await Promise.allSettled(
-        documentRevertStates.map((document) =>
-          createVersion(getReleaseIdFromReleaseDocumentId(revertReleaseId), document._id, document),
-        ),
-      )
+        await createRelease({
+          _id: revertReleaseId,
+          metadata: {
+            title: t('revert-release.title', {title: release.metadata.title}),
+            description: t('revert-release.description', {title: release.metadata.title}),
+            releaseType: 'asap',
+          },
+        })
 
-      if (stageNewRevertRelease) {
-        telemetry.log(RevertRelease, {revertType: 'staged'})
-        toast.push({
-          closable: true,
-          status: 'success',
-          title: (
-            <Text muted size={1}>
-              <Translate
-                components={{
-                  Link: () => (
-                    <Text
-                      size={1}
-                      weight="medium"
-                      data-as="a"
-                      onClick={navigateToRevertRelease(revertReleaseId)}
-                      style={{
-                        cursor: 'pointer',
-                        marginBottom: '0.5rem',
-                        display: 'flex',
-                      }}
-                    >
-                      {t('toast.revert-stage.success-link')}
-                    </Text>
-                  ),
-                }}
-                t={t}
-                i18nKey="toast.revert-stage.success"
-                values={{title: release.metadata.title}}
-              />
-            </Text>
+        await Promise.allSettled(
+          documentRevertStates.map((document) =>
+            createVersion(
+              getReleaseIdFromReleaseDocumentId(revertReleaseId),
+              document._id,
+              document,
+            ),
           ),
-        })
-      } else {
-        await publishRelease(revertReleaseId)
+        )
+
+        if (stageNewRevertRelease) {
+          telemetry.log(RevertRelease, {revertType: 'staged'})
+          toast.push({
+            closable: true,
+            status: 'success',
+            title: (
+              <Text muted size={1}>
+                <Translate
+                  components={{
+                    Link: () => (
+                      <Text
+                        size={1}
+                        weight="medium"
+                        data-as="a"
+                        onClick={navigateToRevertRelease(revertReleaseId)}
+                        style={{
+                          cursor: 'pointer',
+                          marginBottom: '0.5rem',
+                          display: 'flex',
+                        }}
+                      >
+                        {t('toast.revert-stage.success-link')}
+                      </Text>
+                    ),
+                  }}
+                  t={t}
+                  i18nKey="toast.revert-stage.success"
+                  values={{title: release.metadata.title}}
+                />
+              </Text>
+            ),
+          })
+        } else {
+          await publishRelease(revertReleaseId)
 
-        telemetry.log(RevertRelease, {revertType: 'immediately'})
+          telemetry.log(RevertRelease, {revertType: 'immediately'})
 
+          toast.push({
+            closable: true,
+            status: 'success',
+            title: (
+              <Text muted size={1}>
+                <Translate
+                  t={t}
+                  i18nKey="toast.immediate-revert.success"
+                  values={{title: release.metadata.title}}
+                />
+              </Text>
+            ),
+          })
+        }
+      } catch (revertError) {
         toast.push({
-          closable: true,
-          status: 'success',
+          status: 'error',
           title: (
             <Text muted size={1}>
-              <Translate
-                t={t}
-                i18nKey="toast.immediate-revert.success"
-                values={{title: release.metadata.title}}
-              />
+              <Translate t={t} i18nKey="toast.revert.error" values={{error: revertError.message}} />
             </Text>
           ),
         })
+        console.error(revertError)
+      } finally {
+        setRevertReleaseStatus('idle')
       }
-    } catch (revertError) {
-      toast.push({
-        status: 'error',
-        title: (
-          <Text muted size={1}>
-            <Translate t={t} i18nKey="toast.revert.error" values={{error: revertError.message}} />
-          </Text>
-        ),
-      })
-      console.error(revertError)
-    } finally {
-      setRevertReleaseStatus('idle')
-    }
-  }, [
-    getAdjacentTransactions,
-    createRelease,
-    t,
-    release.metadata.title,
-    stageNewRevertRelease,
-    createVersion,
-    telemetry,
-    toast,
-    navigateToRevertRelease,
-    publishRelease,
-  ])
-
-  const confirmReleaseDialog = useMemo(() => {
-    if (revertReleaseStatus === 'idle') return null
-
-    const description =
-      documents.length > 1
-        ? 'revert-dialog.confirm-revert-description_other'
-        : 'revert-dialog.confirm-revert-description_one'
-
-    return (
-      <Dialog
-        id="confirm-revert-dialog"
-        header={t('revert-dialog.confirm-revert.title', {title: release.metadata.title})}
-        onClose={() => setRevertReleaseStatus('idle')}
-        footer={{
-          confirmButton: {
-            text: t(
-              stageNewRevertRelease
-                ? 'action.create-revert-release'
-                : 'action.immediate-revert-release',
-            ),
-            tone: 'positive',
-            onClick: handleRevertRelease,
-            loading: revertReleaseStatus === 'reverting',
-            disabled: revertReleaseStatus === 'reverting',
-          },
-        }}
-      >
-        <Text muted size={1}>
-          {
-            <Translate
-              t={t}
-              i18nKey={description}
-              values={{
-                releaseDocumentsLength: documents.length,
-              }}
-            />
-          }
-        </Text>
-        <Flex align="center" paddingTop={4}>
-          <Checkbox
-            onChange={() => setStageNewRevertRelease((current) => !current)}
-            id="stage-release"
-            style={{display: 'block'}}
-            checked={stageNewRevertRelease}
-          />
-          <Box flex={1} paddingLeft={3}>
-            <Text muted size={1}>
-              <label htmlFor="stage-release">
-                {t('revert-dialog.confirm-revert.stage-revert-checkbox-label')}
-              </label>
-            </Text>
-          </Box>
-        </Flex>
-        {hasPostPublishTransactions && !stageNewRevertRelease && (
-          <Card marginTop={4} padding={3} radius={2} shadow={1} tone="critical">
-            <Text muted size={1}>
-              {t('revert-dialog.confirm-revert.warning-card')}
-            </Text>
-          </Card>
-        )}
-      </Dialog>
-    )
-  }, [
-    revertReleaseStatus,
-    documents.length,
-    t,
-    release.metadata.title,
-    stageNewRevertRelease,
-    handleRevertRelease,
-    hasPostPublishTransactions,
-  ])
+    },
+    [
+      getAdjacentTransactions,
+      createRelease,
+      t,
+      release.metadata.title,
+      createVersion,
+      telemetry,
+      toast,
+      navigateToRevertRelease,
+      publishRelease,
+    ],
+  )
 
   return (
     <>
@@ -232,7 +246,13 @@ export const ReleaseRevertButton = ({
         tone="critical"
         disabled={disabled}
       />
-      {confirmReleaseDialog}
+      <ConfirmReleaseDialog
+        release={release}
+        documents={documents}
+        handleRevertRelease={handleRevertRelease}
+        revertReleaseStatus={revertReleaseStatus}
+        setRevertReleaseStatus={setRevertReleaseStatus}
+      />
     </>
   )
 }
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
index 96511d54954..709cf98b4e6 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
@@ -1,7 +1,7 @@
 import {type SanityDocument} from '@sanity/types'
 import {useCallback, useEffect, useMemo, useRef, useState} from 'react'
 import {useObservable} from 'react-rx'
-import {combineLatest, filter, forkJoin, from, map, type Observable, of, switchMap} from 'rxjs'
+import {filter, forkJoin, from, map, type Observable, of, switchMap} from 'rxjs'
 
 import {useClient} from '../../../../../hooks/useClient'
 import {getTransactionsLogs} from '../../../../../store/translog/getTransactionLogs'
@@ -17,7 +17,6 @@ type RevertDocument = SanityDocument & {
 type RevertDocuments = RevertDocument[]
 
 interface AdjacentTransactionsResult {
-  hasPostPublishTransactions: boolean | null
   documentRevertStates: RevertDocuments | null
 }
 
@@ -27,36 +26,20 @@ export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
   const transactionId = documents[0]?.document._rev
   const {dataset} = client.config()
   const [trigger, setTrigger] = useState(0)
-  const promiseRef = useRef<Promise<AdjacentTransactionsResult> | null>(null)
-  const resolvePromiseRef = useRef<((value: AdjacentTransactionsResult) => void) | null>(null)
-  const resolvedValueRef = useRef<AdjacentTransactionsResult | null>(null)
+  const promiseRef = useRef<Promise<AdjacentTransactionsResult['documentRevertStates']> | null>(
+    null,
+  )
+  const resolvePromiseRef = useRef<
+    ((value: AdjacentTransactionsResult['documentRevertStates']) => void) | null
+  >(null)
+  const resolvedValueRef = useRef<AdjacentTransactionsResult['documentRevertStates'] | null>(null)
 
   const memoObservable = useMemo(() => {
     if (!trigger) {
       // If not triggered, return null to prevent the observable from running
-      return of({
-        hasPostPublishTransactions: null,
-        documentRevertStates: null,
-      })
+      return of(null)
     }
 
-    // Observable to check if there are post-publish transactions
-    const hasPostPublishTransactions$ = from(
-      getTransactionsLogs(
-        client,
-        documents.map(({document}) => document._id),
-        {
-          fromTransaction: transactionId,
-          // one transaction for every document plus the publish transaction
-          limit: 2,
-        },
-      ),
-    ).pipe(
-      // the transaction of published is also returned
-      // so post publish transactions will result in more than 1 transaction
-      map((transactions) => transactions.length > 1),
-    )
-
     // Observable to get the revert states of the documents
     const documentRevertStates$: Observable<RevertDocuments> = from(
       getTransactionsLogs(
@@ -107,21 +90,13 @@ export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
       ),
     )
 
-    return combineLatest([hasPostPublishTransactions$, documentRevertStates$]).pipe(
-      map(([hasPostPublishTransactions, documentRevertStates]) => ({
-        hasPostPublishTransactions,
-        documentRevertStates,
-      })),
-    )
+    return documentRevertStates$
   }, [trigger, client, documents, transactionId, observableClient, dataset])
 
-  const observableResult = useObservable(memoObservable, {
-    hasPostPublishTransactions: null,
-    documentRevertStates: null,
-  })
+  const observableResult = useObservable(memoObservable, null)
 
   useEffect(() => {
-    if (observableResult.hasPostPublishTransactions !== null) {
+    if (observableResult !== null) {
       resolvedValueRef.current = observableResult
 
       // Resolve the promise if it exists
@@ -149,8 +124,11 @@ export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
     return promiseRef.current
   }, [])
 
-  return {
-    ...observableResult,
-    getAdjacentTransactions: startObservables,
-  }
+  return useMemo(
+    () => ({
+      documentRevertStates: observableResult,
+      getAdjacentTransactions: startObservables,
+    }),
+    [observableResult, startObservables],
+  )
 }
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts
new file mode 100644
index 00000000000..8cb0ee51301
--- /dev/null
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts
@@ -0,0 +1,38 @@
+import {useMemo} from 'react'
+import {useObservable} from 'react-rx'
+import {from, map} from 'rxjs'
+
+import {useClient} from '../../../../../hooks/useClient'
+import {getTransactionsLogs} from '../../../../../store/translog/getTransactionLogs'
+import {API_VERSION} from '../../../../../tasks/constants'
+import {type DocumentInRelease} from '../../../detail/useBundleDocuments'
+
+export const usePostPublishTransactions = (documents: DocumentInRelease[]) => {
+  const client = useClient({apiVersion: API_VERSION})
+  const transactionId = documents[0]?.document._rev
+
+  const memoObservable = useMemo(() => {
+    // Observable to check if there are post-publish transactions
+    const hasPostPublishTransactions$ = from(
+      getTransactionsLogs(
+        client,
+        documents.map(({document}) => document._id),
+        {
+          fromTransaction: transactionId,
+          // one transaction for every document plus the publish transaction
+          limit: 2,
+        },
+      ),
+    ).pipe(
+      // the transaction of published is also returned
+      // so post publish transactions will result in more than 1 transaction
+      map((transactions) => transactions.length > 1),
+    )
+
+    return hasPostPublishTransactions$
+  }, [client, documents, transactionId])
+
+  const observableResult = useObservable(memoObservable, null)
+
+  return observableResult
+}

From 852ae2c7ee07ef325a813d39ad9009865459d42b Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Thu, 12 Dec 2024 03:27:25 +0000
Subject: [PATCH 14/26] refactor: revert dialog handle the revert operation

---
 .../ReleaseRevertButton.tsx                   | 262 +++++++++---------
 1 file changed, 127 insertions(+), 135 deletions(-)

diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
index d42b9153ed8..4734701b675 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
@@ -30,19 +30,134 @@ const ConfirmReleaseDialog = ({
   documents,
   setRevertReleaseStatus,
   release,
-  handleRevertRelease,
 }: {
   revertReleaseStatus: RevertReleaseStatus
   documents: DocumentInRelease[]
   setRevertReleaseStatus: (status: RevertReleaseStatus) => void
   release: ReleaseDocument
-  handleRevertRelease: (stageNewRevertRelease: boolean) => Promise<void>
 }) => {
   const {t} = useTranslation(releasesLocaleNamespace)
   const hasPostPublishTransactions = usePostPublishTransactions(documents)
+  const {getAdjacentTransactions} = useAdjacentTransactions(documents)
   const [stageNewRevertRelease, setStageNewRevertRelease] = useState(true)
+  const toast = useToast()
+  const telemetry = useTelemetry()
+  const {createRelease, publishRelease, createVersion} = useReleaseOperations()
+  const router = useRouter()
+
+  const navigateToRevertRelease = useCallback(
+    (revertReleaseId: string) => () =>
+      router.navigate({releaseId: getReleaseIdFromReleaseDocumentId(revertReleaseId)}),
+    [router],
+  )
+
+  useEffect(() => {
+    getAdjacentTransactions()
+  }, [getAdjacentTransactions])
+
+  const handleRevertRelease = useCallback(async () => {
+    setRevertReleaseStatus('reverting')
+    const documentRevertStates = await getAdjacentTransactions()
+
+    const revertReleaseId = createReleaseId()
+
+    try {
+      if (!documentRevertStates) {
+        throw new Error('Unable to find documents to revert')
+      }
+
+      await createRelease({
+        _id: revertReleaseId,
+        metadata: {
+          title: t('revert-release.title', {title: release.metadata.title}),
+          description: t('revert-release.description', {title: release.metadata.title}),
+          releaseType: 'asap',
+        },
+      })
 
-  if (revertReleaseStatus === 'idle') return null
+      await Promise.allSettled(
+        documentRevertStates.map((document) =>
+          createVersion(getReleaseIdFromReleaseDocumentId(revertReleaseId), document._id, document),
+        ),
+      )
+
+      if (stageNewRevertRelease) {
+        telemetry.log(RevertRelease, {revertType: 'staged'})
+        toast.push({
+          closable: true,
+          status: 'success',
+          title: (
+            <Text muted size={1}>
+              <Translate
+                components={{
+                  Link: () => (
+                    <Text
+                      size={1}
+                      weight="medium"
+                      data-as="a"
+                      onClick={navigateToRevertRelease(revertReleaseId)}
+                      style={{
+                        cursor: 'pointer',
+                        marginBottom: '0.5rem',
+                        display: 'flex',
+                      }}
+                    >
+                      {t('toast.revert-stage.success-link')}
+                    </Text>
+                  ),
+                }}
+                t={t}
+                i18nKey="toast.revert-stage.success"
+                values={{title: release.metadata.title}}
+              />
+            </Text>
+          ),
+        })
+      } else {
+        await publishRelease(revertReleaseId)
+
+        telemetry.log(RevertRelease, {revertType: 'immediately'})
+
+        toast.push({
+          closable: true,
+          status: 'success',
+          title: (
+            <Text muted size={1}>
+              <Translate
+                t={t}
+                i18nKey="toast.immediate-revert.success"
+                values={{title: release.metadata.title}}
+              />
+            </Text>
+          ),
+        })
+      }
+    } catch (revertError) {
+      toast.push({
+        status: 'error',
+        title: (
+          <Text muted size={1}>
+            <Translate t={t} i18nKey="toast.revert.error" values={{error: revertError.message}} />
+          </Text>
+        ),
+      })
+      console.error(revertError)
+    } finally {
+      setRevertReleaseStatus('idle')
+    }
+  }, [
+    setRevertReleaseStatus,
+    getAdjacentTransactions,
+    createRelease,
+    t,
+    release.metadata.title,
+    stageNewRevertRelease,
+    createVersion,
+    telemetry,
+    toast,
+    navigateToRevertRelease,
+    publishRelease,
+  ])
 
   const description =
     documents.length > 1
@@ -62,7 +177,7 @@ const ConfirmReleaseDialog = ({
               : 'action.immediate-revert-release',
           ),
           tone: 'positive',
-          onClick: () => handleRevertRelease(stageNewRevertRelease),
+          onClick: handleRevertRelease,
           loading: revertReleaseStatus === 'reverting',
           disabled: revertReleaseStatus === 'reverting',
         },
@@ -110,132 +225,8 @@ export const ReleaseRevertButton = ({
   documents,
   disabled,
 }: ReleasePublishAllButtonProps) => {
-  const {getAdjacentTransactions} = useAdjacentTransactions(documents)
   const {t} = useTranslation(releasesLocaleNamespace)
   const [revertReleaseStatus, setRevertReleaseStatus] = useState<RevertReleaseStatus>('idle')
-  const toast = useToast()
-  const router = useRouter()
-  const telemetry = useTelemetry()
-  const {createRelease, publishRelease, createVersion} = useReleaseOperations()
-
-  useEffect(() => {
-    if (revertReleaseStatus === 'confirm') getAdjacentTransactions()
-  }, [getAdjacentTransactions, revertReleaseStatus])
-
-  const navigateToRevertRelease = useCallback(
-    (revertReleaseId: string) => () =>
-      router.navigate({releaseId: getReleaseIdFromReleaseDocumentId(revertReleaseId)}),
-    [router],
-  )
-
-  const handleRevertRelease = useCallback(
-    async (stageNewRevertRelease: boolean) => {
-      setRevertReleaseStatus('reverting')
-      const documentRevertStates = await getAdjacentTransactions()
-
-      const revertReleaseId = createReleaseId()
-
-      try {
-        if (!documentRevertStates) {
-          throw new Error('Unable to find documents to revert')
-        }
-
-        await createRelease({
-          _id: revertReleaseId,
-          metadata: {
-            title: t('revert-release.title', {title: release.metadata.title}),
-            description: t('revert-release.description', {title: release.metadata.title}),
-            releaseType: 'asap',
-          },
-        })
-
-        await Promise.allSettled(
-          documentRevertStates.map((document) =>
-            createVersion(
-              getReleaseIdFromReleaseDocumentId(revertReleaseId),
-              document._id,
-              document,
-            ),
-          ),
-        )
-
-        if (stageNewRevertRelease) {
-          telemetry.log(RevertRelease, {revertType: 'staged'})
-          toast.push({
-            closable: true,
-            status: 'success',
-            title: (
-              <Text muted size={1}>
-                <Translate
-                  components={{
-                    Link: () => (
-                      <Text
-                        size={1}
-                        weight="medium"
-                        data-as="a"
-                        onClick={navigateToRevertRelease(revertReleaseId)}
-                        style={{
-                          cursor: 'pointer',
-                          marginBottom: '0.5rem',
-                          display: 'flex',
-                        }}
-                      >
-                        {t('toast.revert-stage.success-link')}
-                      </Text>
-                    ),
-                  }}
-                  t={t}
-                  i18nKey="toast.revert-stage.success"
-                  values={{title: release.metadata.title}}
-                />
-              </Text>
-            ),
-          })
-        } else {
-          await publishRelease(revertReleaseId)
-
-          telemetry.log(RevertRelease, {revertType: 'immediately'})
-
-          toast.push({
-            closable: true,
-            status: 'success',
-            title: (
-              <Text muted size={1}>
-                <Translate
-                  t={t}
-                  i18nKey="toast.immediate-revert.success"
-                  values={{title: release.metadata.title}}
-                />
-              </Text>
-            ),
-          })
-        }
-      } catch (revertError) {
-        toast.push({
-          status: 'error',
-          title: (
-            <Text muted size={1}>
-              <Translate t={t} i18nKey="toast.revert.error" values={{error: revertError.message}} />
-            </Text>
-          ),
-        })
-        console.error(revertError)
-      } finally {
-        setRevertReleaseStatus('idle')
-      }
-    },
-    [
-      getAdjacentTransactions,
-      createRelease,
-      t,
-      release.metadata.title,
-      createVersion,
-      telemetry,
-      toast,
-      navigateToRevertRelease,
-      publishRelease,
-    ],
-  )
 
   return (
     <>
@@ -246,13 +237,14 @@ export const ReleaseRevertButton = ({
         tone="critical"
         disabled={disabled}
       />
-      <ConfirmReleaseDialog
-        release={release}
-        documents={documents}
-        handleRevertRelease={handleRevertRelease}
-        revertReleaseStatus={revertReleaseStatus}
-        setRevertReleaseStatus={setRevertReleaseStatus}
-      />
+      {revertReleaseStatus !== 'idle' && (
+        <ConfirmReleaseDialog
+          release={release}
+          documents={documents}
+          revertReleaseStatus={revertReleaseStatus}
+          setRevertReleaseStatus={setRevertReleaseStatus}
+        />
+      )}
     </>
   )
 }

From d19b2480f6ea1c6cd936ee57c66be2356dd7ba14 Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Thu, 12 Dec 2024 03:57:34 +0000
Subject: [PATCH 15/26] refactor: simplified hook for adjacent transactions

---
 .../ReleaseRevertButton.tsx                   |  8 +--
 .../useAdjacentTransactions.ts                | 68 +++++++------------
 2 files changed, 27 insertions(+), 49 deletions(-)

diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
index 4734701b675..c2c9eebfb2a 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
@@ -1,7 +1,7 @@
 import {RestoreIcon} from '@sanity/icons'
 import {useTelemetry} from '@sanity/telemetry/react'
 import {Box, Card, Checkbox, Flex, Text, useToast} from '@sanity/ui'
-import {useCallback, useEffect, useState} from 'react'
+import {useCallback, useState} from 'react'
 
 import {useRouter} from '../../../../../../router'
 import {Button} from '../../../../../../ui-components/button/Button'
@@ -38,7 +38,7 @@ const ConfirmReleaseDialog = ({
 }) => {
   const {t} = useTranslation(releasesLocaleNamespace)
   const hasPostPublishTransactions = usePostPublishTransactions(documents)
-  const {getAdjacentTransactions} = useAdjacentTransactions(documents)
+  const getAdjacentTransactions = useAdjacentTransactions(documents)
   const [stageNewRevertRelease, setStageNewRevertRelease] = useState(true)
   const toast = useToast()
   const telemetry = useTelemetry()
@@ -51,10 +51,6 @@ const ConfirmReleaseDialog = ({
     [router],
   )
 
-  useEffect(() => {
-    getAdjacentTransactions()
-  }, [getAdjacentTransactions])
-
   const handleRevertRelease = useCallback(async () => {
     setRevertReleaseStatus('reverting')
     const documentRevertStates = await getAdjacentTransactions()
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
index 709cf98b4e6..900c04ee296 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
@@ -1,5 +1,5 @@
 import {type SanityDocument} from '@sanity/types'
-import {useCallback, useEffect, useMemo, useRef, useState} from 'react'
+import {useCallback, useEffect, useMemo, useRef} from 'react'
 import {useObservable} from 'react-rx'
 import {filter, forkJoin, from, map, type Observable, of, switchMap} from 'rxjs'
 
@@ -16,30 +16,21 @@ type RevertDocument = SanityDocument & {
 
 type RevertDocuments = RevertDocument[]
 
-interface AdjacentTransactionsResult {
-  documentRevertStates: RevertDocuments | null
-}
+type DocumentRevertStates = RevertDocuments | null
 
 export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
   const client = useClient({apiVersion: API_VERSION})
   const observableClient = client.observable
   const transactionId = documents[0]?.document._rev
   const {dataset} = client.config()
-  const [trigger, setTrigger] = useState(0)
-  const promiseRef = useRef<Promise<AdjacentTransactionsResult['documentRevertStates']> | null>(
-    null,
-  )
-  const resolvePromiseRef = useRef<
-    ((value: AdjacentTransactionsResult['documentRevertStates']) => void) | null
-  >(null)
-  const resolvedValueRef = useRef<AdjacentTransactionsResult['documentRevertStates'] | null>(null)
 
-  const memoObservable = useMemo(() => {
-    if (!trigger) {
-      // If not triggered, return null to prevent the observable from running
-      return of(null)
-    }
+  const resultPromiseRef = useRef<Promise<DocumentRevertStates> | null>(null)
+  const resolvedDocumentRevertStatesPromiseRef = useRef<
+    ((value: DocumentRevertStates) => void) | null
+  >(null)
+  const resolvedDocumentRevertStatesResultRef = useRef<DocumentRevertStates | null>(null)
 
+  const memoDocumentRevertStates = useMemo(() => {
     // Observable to get the revert states of the documents
     const documentRevertStates$: Observable<RevertDocuments> = from(
       getTransactionsLogs(
@@ -84,51 +75,42 @@ export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
               }>({
                 url: `/data/history/${dataset}/documents/${docId}?revision=${revisionId}`,
               })
-              .pipe(map((response) => response.documents[0]))
+              .pipe(map(({documents: [revertDocument]}) => revertDocument))
           }),
         ),
       ),
     )
 
     return documentRevertStates$
-  }, [trigger, client, documents, transactionId, observableClient, dataset])
+  }, [client, documents, transactionId, observableClient, dataset])
 
-  const observableResult = useObservable(memoObservable, null)
+  const documentRevertStatesResult = useObservable(memoDocumentRevertStates, null)
 
   useEffect(() => {
-    if (observableResult !== null) {
-      resolvedValueRef.current = observableResult
+    if (documentRevertStatesResult !== null) {
+      resolvedDocumentRevertStatesResultRef.current = documentRevertStatesResult
 
       // Resolve the promise if it exists
-      if (resolvePromiseRef.current) {
-        resolvePromiseRef.current(observableResult)
-        resolvePromiseRef.current = null
-        promiseRef.current = null // Reset the promiseRef for future fetches
+      if (resolvedDocumentRevertStatesPromiseRef.current) {
+        resolvedDocumentRevertStatesPromiseRef.current(documentRevertStatesResult)
+        resolvedDocumentRevertStatesPromiseRef.current = null
+        resultPromiseRef.current = null // Reset the resultPromiseRef for future fetches
       }
     }
-  }, [observableResult])
+  }, [documentRevertStatesResult])
 
-  const startObservables = useCallback(() => {
-    if (resolvedValueRef.current) {
+  return useCallback(() => {
+    if (resolvedDocumentRevertStatesResultRef.current) {
       // Return resolved value immediately if available
-      return Promise.resolve(resolvedValueRef.current)
+      return Promise.resolve(resolvedDocumentRevertStatesResultRef.current)
     }
 
-    if (!promiseRef.current) {
-      promiseRef.current = new Promise((res) => {
-        resolvePromiseRef.current = res
-        setTrigger((curTrigger) => curTrigger + 1)
+    if (!resultPromiseRef.current) {
+      resultPromiseRef.current = new Promise((res) => {
+        resolvedDocumentRevertStatesPromiseRef.current = res
       })
     }
 
-    return promiseRef.current
+    return resultPromiseRef.current
   }, [])
-
-  return useMemo(
-    () => ({
-      documentRevertStates: observableResult,
-      getAdjacentTransactions: startObservables,
-    }),
-    [observableResult, startObservables],
-  )
 }

From d73d702bc7a2e7321301af2a7b56d849eff2d31a Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Thu, 12 Dec 2024 04:14:58 +0000
Subject: [PATCH 16/26] test: testing usePostPublishTransactions

---
 .../usePostPublishTransactions.test.ts        | 114 ++++++++++++++++++
 .../usePostPublishTransactions.ts             |   7 +-
 2 files changed, 117 insertions(+), 4 deletions(-)
 create mode 100644 packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/usePostPublishTransactions.test.ts

diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/usePostPublishTransactions.test.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/usePostPublishTransactions.test.ts
new file mode 100644
index 00000000000..ab8ede56b6c
--- /dev/null
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/usePostPublishTransactions.test.ts
@@ -0,0 +1,114 @@
+import {act, renderHook, waitFor} from '@testing-library/react'
+import {from} from 'rxjs'
+import {beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
+
+import {useClient} from '../../../../../../hooks/useClient'
+import {getTransactionsLogs} from '../../../../../../store/translog/getTransactionLogs'
+import {type DocumentInRelease} from '../../../../detail/useBundleDocuments'
+import {usePostPublishTransactions} from '../usePostPublishTransactions'
+
+vi.mock('../../../../../../hooks/useClient', () => ({
+  useClient: vi.fn(),
+}))
+
+vi.mock('../../../../../../store/translog/getTransactionLogs', () => ({
+  getTransactionsLogs: vi.fn(),
+}))
+
+const processMicroTasks = () =>
+  act(async () => {
+    await Promise.resolve() // Process pending updates
+  })
+
+describe('usePostPublishTransactions', () => {
+  const mockDocuments = [
+    {document: {_id: 'doc1', _rev: 'rev1'}},
+    {document: {_id: 'doc2', _rev: 'rev2'}},
+  ] as DocumentInRelease[]
+
+  const mockClient = {getUrl: vi.fn(), config: vi.fn()}
+
+  const mockUseClient = useClient as Mock
+  const mockGetTransactionsLogs = getTransactionsLogs as Mock
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    mockUseClient.mockReturnValue(mockClient)
+  })
+
+  const mockTransactionLogs = [
+    {
+      id: 'trans1',
+      type: 'publish',
+      effects: [],
+      timestamp: '2024-01-01T00:00:00Z',
+    },
+    {
+      id: 'trans2',
+      type: 'update',
+      effects: [],
+      timestamp: '2024-01-01T01:00:00Z',
+    },
+  ]
+
+  it('should return null initially', () => {
+    mockGetTransactionsLogs.mockReturnValue(from([]))
+
+    const {result} = renderHook(() => usePostPublishTransactions(mockDocuments))
+
+    expect(result.current).toBeNull()
+  })
+
+  it('should call getTransactionsLogs with the correct params', async () => {
+    mockGetTransactionsLogs.mockResolvedValue(mockTransactionLogs)
+
+    const {result} = renderHook(() => usePostPublishTransactions(mockDocuments))
+
+    await processMicroTasks()
+
+    expect(mockGetTransactionsLogs).toHaveBeenCalledTimes(1)
+    expect(mockGetTransactionsLogs).toHaveBeenCalledWith(mockClient, ['doc1', 'doc2'], {
+      fromTransaction: 'rev1',
+      limit: 2,
+    })
+    expect(result.current).toBe(true)
+  })
+
+  it('should return true if there are post-publish transactions', async () => {
+    mockGetTransactionsLogs.mockResolvedValue(mockTransactionLogs)
+
+    const {result} = renderHook(() => usePostPublishTransactions(mockDocuments))
+
+    await waitFor(() => {
+      expect(result.current).toBe(true)
+    })
+  })
+
+  it('should return false if there are no post-publish transactions', async () => {
+    mockGetTransactionsLogs.mockResolvedValue([
+      {
+        id: 'trans1',
+        type: 'publish',
+        effects: [],
+        timestamp: '2024-01-01T00:00:00Z',
+      },
+    ])
+
+    const {result} = renderHook(() => usePostPublishTransactions(mockDocuments))
+
+    await waitFor(() => {
+      expect(result.current).toBe(false)
+    })
+  })
+
+  it('should return null when getTransactionsLogs throws an error', async () => {
+    mockGetTransactionsLogs.mockRejectedValue(new Error('Failed to fetch transaction logs'))
+
+    const {result} = renderHook(() => usePostPublishTransactions(mockDocuments))
+
+    await waitFor(() => {
+      expect(result.current).toBeNull()
+    })
+  })
+})
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts
index 8cb0ee51301..294979153f6 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts
@@ -1,6 +1,6 @@
 import {useMemo} from 'react'
 import {useObservable} from 'react-rx'
-import {from, map} from 'rxjs'
+import {catchError, from, map, of} from 'rxjs'
 
 import {useClient} from '../../../../../hooks/useClient'
 import {getTransactionsLogs} from '../../../../../store/translog/getTransactionLogs'
@@ -13,7 +13,7 @@ export const usePostPublishTransactions = (documents: DocumentInRelease[]) => {
 
   const memoObservable = useMemo(() => {
     // Observable to check if there are post-publish transactions
-    const hasPostPublishTransactions$ = from(
+    return from(
       getTransactionsLogs(
         client,
         documents.map(({document}) => document._id),
@@ -27,9 +27,8 @@ export const usePostPublishTransactions = (documents: DocumentInRelease[]) => {
       // the transaction of published is also returned
       // so post publish transactions will result in more than 1 transaction
       map((transactions) => transactions.length > 1),
+      catchError(() => of(null)),
     )
-
-    return hasPostPublishTransactions$
   }, [client, documents, transactionId])
 
   const observableResult = useObservable(memoObservable, null)

From 54a90f61d59c290ed0f03c2656338c62431332e3 Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Thu, 12 Dec 2024 12:56:31 +0000
Subject: [PATCH 17/26] refactor: revert becomes an operation; testing for
 hooks and operations

---
 .../__mocks/useReleaseOperations.mock.ts      |   1 +
 .../createReleaseOperationsStore.test.ts      | 355 ++++++++++++++++++
 .../store/createReleaseOperationStore.ts      |  37 ++
 .../ReleaseRevertButton.tsx                   |  22 +-
 .../__tests__/useAdjacentTransactions.test.ts | 202 ++++++++++
 .../usePostPublishTransactions.test.ts        |   6 +
 .../useAdjacentTransactions.ts                |  59 ++-
 .../usePostPublishTransactions.ts             |   5 +-
 .../core/store/translog/getTransactionLogs.ts |   4 +-
 9 files changed, 655 insertions(+), 36 deletions(-)
 create mode 100644 packages/sanity/src/core/releases/store/__tests__/createReleaseOperationsStore.test.ts
 create mode 100644 packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/useAdjacentTransactions.test.ts

diff --git a/packages/sanity/src/core/releases/store/__tests__/__mocks/useReleaseOperations.mock.ts b/packages/sanity/src/core/releases/store/__tests__/__mocks/useReleaseOperations.mock.ts
index 01d0abaa10d..9b7ce14aeca 100644
--- a/packages/sanity/src/core/releases/store/__tests__/__mocks/useReleaseOperations.mock.ts
+++ b/packages/sanity/src/core/releases/store/__tests__/__mocks/useReleaseOperations.mock.ts
@@ -14,6 +14,7 @@ export const useReleaseOperationsMockReturn: Mocked<ReleaseOperationsStore> = {
   unschedule: vi.fn(),
   updateRelease: vi.fn(),
   deleteRelease: vi.fn(),
+  revertRelease: vi.fn(),
   unpublishVersion: vi.fn(),
 }
 
diff --git a/packages/sanity/src/core/releases/store/__tests__/createReleaseOperationsStore.test.ts b/packages/sanity/src/core/releases/store/__tests__/createReleaseOperationsStore.test.ts
new file mode 100644
index 00000000000..f018263b036
--- /dev/null
+++ b/packages/sanity/src/core/releases/store/__tests__/createReleaseOperationsStore.test.ts
@@ -0,0 +1,355 @@
+import {type ReleaseDocument} from 'sanity'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {type RevertDocument} from '../../tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions'
+import {createReleaseOperationsStore} from '../createReleaseOperationStore'
+
+describe('createReleaseOperationsStore', () => {
+  let mockClient: any
+
+  beforeEach(() => {
+    mockClient = {
+      config: vi.fn().mockReturnValue({dataset: 'test-dataset'}),
+      request: vi.fn().mockResolvedValue(undefined),
+      create: vi.fn().mockResolvedValue(undefined),
+      getDocument: vi.fn(),
+    }
+  })
+
+  const createStore = () => createReleaseOperationsStore({client: mockClient})
+
+  it('should create a release', async () => {
+    const store = createStore()
+    const release = {_id: '_.releases.release-id', metadata: {title: 'Test Release'}}
+    await store.createRelease(release)
+    expect(mockClient.request).toHaveBeenCalledWith({
+      uri: '/data/actions/test-dataset',
+      method: 'POST',
+      body: {
+        actions: [
+          {
+            actionType: 'sanity.action.release.create',
+            releaseId: 'release-id',
+            metadata: release.metadata,
+          },
+        ],
+      },
+    })
+  })
+
+  it('should update a release', async () => {
+    const store = createStore()
+    const release = {_id: '_.releases.release-id', metadata: {title: 'Updated Title'}}
+    await store.updateRelease(release)
+    expect(mockClient.request).toHaveBeenCalledWith({
+      uri: '/data/actions/test-dataset',
+      method: 'POST',
+      body: {
+        actions: [
+          {
+            actionType: 'sanity.action.release.edit',
+            releaseId: 'release-id',
+            patch: {
+              set: {metadata: release.metadata},
+              unset: [],
+            },
+          },
+        ],
+      },
+    })
+  })
+
+  it('should publish a release using new publish', async () => {
+    const store = createStore()
+    await store.publishRelease('_.releases.release-id', true)
+    expect(mockClient.request).toHaveBeenCalledWith({
+      uri: '/data/actions/test-dataset',
+      method: 'POST',
+      body: {
+        actions: [
+          {
+            actionType: 'sanity.action.release.publish2',
+            releaseId: 'release-id',
+          },
+        ],
+      },
+    })
+  })
+
+  it('should publish a release using stable publish', async () => {
+    const store = createStore()
+    await store.publishRelease('_.releases.release-id', false)
+    expect(mockClient.request).toHaveBeenCalledWith({
+      uri: '/data/actions/test-dataset',
+      method: 'POST',
+      body: {
+        actions: [
+          {
+            actionType: 'sanity.action.release.publish',
+            releaseId: 'release-id',
+          },
+        ],
+      },
+    })
+  })
+
+  it('should schedule a release', async () => {
+    const store = createStore()
+    const date = new Date('2024-01-01T00:00:00Z')
+    await store.schedule('_.releases.release-id', date)
+    expect(mockClient.request).toHaveBeenCalledWith({
+      uri: '/data/actions/test-dataset',
+      method: 'POST',
+      body: {
+        actions: [
+          {
+            actionType: 'sanity.action.release.schedule',
+            releaseId: 'release-id',
+            publishAt: date.toISOString(),
+          },
+        ],
+      },
+    })
+  })
+
+  it('should unschedule a release', async () => {
+    const store = createStore()
+    await store.unschedule('_.releases.release-id')
+    expect(mockClient.request).toHaveBeenCalledWith({
+      uri: '/data/actions/test-dataset',
+      method: 'POST',
+      body: {
+        actions: [
+          {
+            actionType: 'sanity.action.release.unschedule',
+            releaseId: 'release-id',
+          },
+        ],
+      },
+    })
+  })
+
+  it('should archive a release', async () => {
+    const store = createStore()
+    await store.archive('_.releases.release-id')
+    expect(mockClient.request).toHaveBeenCalledWith({
+      uri: '/data/actions/test-dataset',
+      method: 'POST',
+      body: {
+        actions: [
+          {
+            actionType: 'sanity.action.release.archive',
+            releaseId: 'release-id',
+          },
+        ],
+      },
+    })
+  })
+
+  it('should unarchive a release', async () => {
+    const store = createStore()
+    await store.unarchive('_.releases.release-id')
+    expect(mockClient.request).toHaveBeenCalledWith({
+      uri: '/data/actions/test-dataset',
+      method: 'POST',
+      body: {
+        actions: [
+          {
+            actionType: 'sanity.action.release.unarchive',
+            releaseId: 'release-id',
+          },
+        ],
+      },
+    })
+  })
+
+  it('should delete a release', async () => {
+    const store = createStore()
+    await store.deleteRelease('_.releases.release-id')
+    expect(mockClient.request).toHaveBeenCalledWith({
+      uri: '/data/actions/test-dataset',
+      method: 'POST',
+      body: {
+        actions: [
+          {
+            actionType: 'sanity.action.release.delete',
+            releaseId: 'release-id',
+          },
+        ],
+      },
+    })
+  })
+
+  describe('revertRelease', () => {
+    let store: ReturnType<typeof createStore>
+    const revertReleaseId: string = 'revert-release-id'
+    const revertReleaseDocumentId: string = '_.releases.revert-release-id'
+    let releaseDocuments: RevertDocument[]
+    let releaseMetadata: ReleaseDocument['metadata']
+
+    beforeEach(() => {
+      store = createStore()
+      releaseDocuments = [{_id: 'doc1'}, {_id: 'doc2'}] as RevertDocument[]
+      releaseMetadata = {
+        title: 'Revert Release',
+        description: 'A reverted release',
+      } as ReleaseDocument['metadata']
+    })
+
+    it('should create a new release and publish immediately when revertType is "immediate"', async () => {
+      await store.revertRelease(
+        revertReleaseDocumentId,
+        releaseDocuments,
+        releaseMetadata,
+        'immediately',
+      )
+
+      expect(mockClient.request).toHaveBeenCalledWith({
+        uri: '/data/actions/test-dataset',
+        method: 'POST',
+        body: {
+          actions: [
+            {
+              actionType: 'sanity.action.release.create',
+              releaseId: revertReleaseId,
+              metadata: {...releaseMetadata, releaseType: 'asap'},
+            },
+          ],
+        },
+      })
+
+      expect(mockClient.create).toHaveBeenNthCalledWith(1, {
+        _id: `versions.${revertReleaseId}.doc1`,
+      })
+      expect(mockClient.create).toHaveBeenNthCalledWith(2, {
+        _id: `versions.${revertReleaseId}.doc2`,
+      })
+
+      expect(mockClient.request).toHaveBeenCalledWith({
+        uri: '/data/actions/test-dataset',
+        method: 'POST',
+        body: {
+          actions: [
+            {
+              actionType: 'sanity.action.release.publish',
+              releaseId: 'revert-release-id',
+            },
+          ],
+        },
+      })
+    })
+
+    it('should create a new release without publishing when revertType is "staged"', async () => {
+      await store.revertRelease(
+        revertReleaseDocumentId,
+        releaseDocuments,
+        releaseMetadata,
+        'staged',
+      )
+
+      expect(mockClient.request).toHaveBeenCalledWith({
+        uri: '/data/actions/test-dataset',
+        method: 'POST',
+        body: {
+          actions: [
+            {
+              actionType: 'sanity.action.release.create',
+              releaseId: revertReleaseId,
+              metadata: {...releaseMetadata, releaseType: 'asap'},
+            },
+          ],
+        },
+      })
+
+      expect(mockClient.create).toHaveBeenCalledTimes(2)
+      expect(mockClient.request).toHaveBeenCalledTimes(1)
+    })
+
+    it('should fail if a document does not exist and no initial value is provided', async () => {
+      mockClient.getDocument.mockResolvedValueOnce(null) // Simulate a missing document
+
+      await expect(
+        store.revertRelease(
+          revertReleaseDocumentId,
+          [{_id: 'missing-doc'}] as RevertDocument[],
+          releaseMetadata,
+          'staged',
+        ),
+      ).resolves.toBeUndefined()
+    })
+
+    it('should handle partial failure gracefully when creating versions', async () => {
+      mockClient.create.mockRejectedValueOnce(new Error('Failed to create version'))
+
+      const result = await store.revertRelease(
+        revertReleaseDocumentId,
+        releaseDocuments,
+        releaseMetadata,
+        'staged',
+      )
+
+      expect(result).toBeUndefined()
+      expect(mockClient.create).toHaveBeenCalledTimes(2)
+      expect(mockClient.create).toHaveBeenNthCalledWith(1, {
+        _id: `versions.${revertReleaseId}.doc1`,
+      })
+      expect(mockClient.create).toHaveBeenNthCalledWith(2, {
+        _id: `versions.${revertReleaseId}.doc2`,
+      })
+    })
+
+    it('should throw an error if creating the release fails', async () => {
+      mockClient.request.mockRejectedValueOnce(new Error('Failed to create release'))
+
+      await expect(
+        store.revertRelease(revertReleaseDocumentId, releaseDocuments, releaseMetadata, 'staged'),
+      ).rejects.toThrow('Failed to create release')
+    })
+  })
+
+  it('should create a version of a document', async () => {
+    const store = createStore()
+    mockClient.getDocument.mockResolvedValue({_id: 'doc-id', data: 'example'})
+    await store.createVersion('release-id', 'doc-id', {newData: 'value'})
+    expect(mockClient.create).toHaveBeenCalledWith({
+      _id: `versions.release-id.doc-id`,
+      data: 'example',
+      newData: 'value',
+    })
+  })
+
+  it('should discard a version of a document', async () => {
+    const store = createStore()
+    await store.discardVersion('release-id', 'doc-id')
+    expect(mockClient.request).toHaveBeenCalledWith({
+      uri: '/data/actions/test-dataset',
+      method: 'POST',
+      body: {
+        actions: [
+          {
+            actionType: 'sanity.action.document.discard',
+            draftId: 'versions.release-id.doc-id',
+          },
+        ],
+      },
+    })
+  })
+
+  it('should unpublish a version of a document', async () => {
+    const store = createStore()
+    await store.unpublishVersion('doc-id')
+    expect(mockClient.request).toHaveBeenCalledWith({
+      uri: '/data/actions/test-dataset',
+      method: 'POST',
+      body: {
+        actions: [
+          {
+            actionType: 'sanity.action.document.version.unpublish',
+            draftId: 'doc-id',
+            publishedId: `doc-id`,
+          },
+        ],
+      },
+    })
+  })
+})
diff --git a/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts b/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts
index 05d7a0af33e..49e5bf8e7a7 100644
--- a/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts
+++ b/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts
@@ -7,6 +7,7 @@ import {
 
 import {getPublishedId, getVersionId} from '../../util'
 import {getReleaseIdFromReleaseDocumentId, type ReleaseDocument} from '../index'
+import {type RevertDocument} from '../tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions'
 import {type EditableReleaseDocument} from './types'
 
 export interface ReleaseOperationsStore {
@@ -19,6 +20,12 @@ export interface ReleaseOperationsStore {
   updateRelease: (release: EditableReleaseDocument) => Promise<void>
   createRelease: (release: EditableReleaseDocument) => Promise<void>
   deleteRelease: (releaseId: string) => Promise<void>
+  revertRelease: (
+    revertReleaseId: string,
+    documents: RevertDocument[],
+    releaseMetadata: ReleaseDocument['metadata'],
+    revertType: 'staged' | 'immediately',
+  ) => Promise<void>
   createVersion: (
     releaseId: string,
     documentId: string,
@@ -160,6 +167,35 @@ export function createReleaseOperationsStore(options: {
       },
     ])
 
+  const handleRevertRelease = async (
+    revertReleaseId: string,
+    releaseDocuments: RevertDocument[],
+    releaseMetadata: ReleaseDocument['metadata'],
+    revertType: 'staged' | 'immediately',
+  ) => {
+    await handleCreateRelease({
+      _id: revertReleaseId,
+      metadata: {
+        title: releaseMetadata.title,
+        description: releaseMetadata.description,
+        releaseType: 'asap',
+      },
+    })
+    await Promise.allSettled(
+      releaseDocuments.map((document) =>
+        handleCreateVersion(
+          getReleaseIdFromReleaseDocumentId(revertReleaseId),
+          document._id,
+          document,
+        ),
+      ),
+    )
+
+    if (revertType === 'immediately') {
+      await handlePublishRelease(revertReleaseId)
+    }
+  }
+
   return {
     archive: handleArchiveRelease,
     unarchive: handleUnarchiveRelease,
@@ -169,6 +205,7 @@ export function createReleaseOperationsStore(options: {
     updateRelease: handleUpdateRelease,
     publishRelease: handlePublishRelease,
     deleteRelease: handleDeleteRelease,
+    revertRelease: handleRevertRelease,
     createVersion: handleCreateVersion,
     discardVersion: handleDiscardVersion,
     unpublishVersion: handleUnpublishVersion,
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
index c2c9eebfb2a..062b86739ff 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
@@ -42,7 +42,7 @@ const ConfirmReleaseDialog = ({
   const [stageNewRevertRelease, setStageNewRevertRelease] = useState(true)
   const toast = useToast()
   const telemetry = useTelemetry()
-  const {createRelease, publishRelease, createVersion} = useReleaseOperations()
+  const {revertRelease} = useReleaseOperations()
   const router = useRouter()
 
   const navigateToRevertRelease = useCallback(
@@ -62,19 +62,15 @@ const ConfirmReleaseDialog = ({
         throw new Error('Unable to find documents to revert')
       }
 
-      await createRelease({
-        _id: revertReleaseId,
-        metadata: {
+      await revertRelease(
+        revertReleaseId,
+        documentRevertStates,
+        {
           title: t('revert-release.title', {title: release.metadata.title}),
           description: t('revert-release.description', {title: release.metadata.title}),
           releaseType: 'asap',
         },
-      })
-
-      await Promise.allSettled(
-        documentRevertStates.map((document) =>
-          createVersion(getReleaseIdFromReleaseDocumentId(revertReleaseId), document._id, document),
-        ),
+        stageNewRevertRelease ? 'staged' : 'immediately',
       )
 
       if (stageNewRevertRelease) {
@@ -110,8 +106,6 @@ const ConfirmReleaseDialog = ({
           ),
         })
       } else {
-        await publishRelease(revertReleaseId)
-
         telemetry.log(RevertRelease, {revertType: 'immediately'})
 
         toast.push({
@@ -144,15 +138,13 @@ const ConfirmReleaseDialog = ({
   }, [
     setRevertReleaseStatus,
     getAdjacentTransactions,
-    createRelease,
+    revertRelease,
     t,
     release.metadata.title,
     stageNewRevertRelease,
-    createVersion,
     telemetry,
     toast,
     navigateToRevertRelease,
-    publishRelease,
   ])
 
   const description =
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/useAdjacentTransactions.test.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/useAdjacentTransactions.test.ts
new file mode 100644
index 00000000000..507d412e873
--- /dev/null
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/useAdjacentTransactions.test.ts
@@ -0,0 +1,202 @@
+import {renderHook, waitFor} from '@testing-library/react'
+import {of} from 'rxjs'
+import {beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
+
+import {useClient} from '../../../../../../hooks/useClient'
+import {getTransactionsLogs} from '../../../../../../store/translog/getTransactionLogs'
+import {type DocumentInRelease} from '../../../../detail/useBundleDocuments'
+import {useAdjacentTransactions} from '../useAdjacentTransactions'
+
+vi.mock('../../../../../../hooks/useClient', () => ({
+  useClient: vi.fn(),
+}))
+
+vi.mock('../../../../../../store/translog/getTransactionLogs', () => ({
+  getTransactionsLogs: vi.fn(),
+}))
+
+describe('useAdjacentTransactions', () => {
+  const mockDocuments = [
+    {document: {_id: 'doc1', _rev: 'rev1'}},
+    {document: {_id: 'doc2', _rev: 'rev2'}},
+  ] as DocumentInRelease[]
+
+  const mockClient = {
+    getUrl: vi.fn(),
+    config: vi.fn().mockReturnValue({dataset: 'test-dataset'}),
+    observable: {
+      request: vi.fn(),
+    },
+  }
+
+  const mockUseClient = useClient as Mock
+  const mockGetTransactionsLogs = getTransactionsLogs as Mock
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+
+    mockUseClient.mockReturnValue(mockClient)
+
+    mockGetTransactionsLogs.mockResolvedValue([
+      {id: 'trans1', documentIDs: ['doc1'], timestamp: new Date().toISOString()},
+      {id: 'trans2', documentIDs: ['doc2'], timestamp: new Date().toISOString()},
+    ])
+
+    mockClient.observable.request.mockImplementation(({url}) => {
+      if (url.includes('doc1')) {
+        return of({
+          documents: [
+            {
+              _id: 'doc1',
+              _rev: 'observable-rev-1',
+              title: 'Reverted Document 1',
+            },
+          ],
+        })
+      }
+      if (url.includes('doc2')) {
+        return of({
+          documents: [
+            {
+              _id: 'doc2',
+              _rev: 'observable-rev-2',
+              title: 'Reverted Document 2',
+            },
+          ],
+        })
+      }
+      return of({documents: []})
+    })
+  })
+
+  it('should return a function', () => {
+    const {result} = renderHook(() => useAdjacentTransactions(mockDocuments))
+    expect(typeof result.current).toBe('function')
+  })
+
+  it('should fetch adjacent transactions and resolve to revert states', async () => {
+    const {result} = renderHook(() => useAdjacentTransactions(mockDocuments))
+
+    await waitFor(async () => {
+      const resolvedResult = await result.current()
+      expect(resolvedResult).toEqual([
+        {
+          _id: 'doc1',
+          _rev: 'rev1',
+          _system: {delete: true},
+        },
+        {
+          _id: 'doc2',
+          _rev: 'observable-rev-2',
+          title: 'Reverted Document 2',
+        },
+      ])
+    })
+
+    expect(mockGetTransactionsLogs).toHaveBeenCalledWith(mockClient, ['doc1', 'doc2'], {
+      toTransaction: 'rev1',
+      limit: 3,
+      reverse: true,
+    })
+
+    expect(mockClient.observable.request).toHaveBeenCalledWith({
+      url: '/data/history/test-dataset/documents/doc2?revision=trans2',
+    })
+  })
+
+  it('should handle missing revisions and mark for deletion', async () => {
+    mockClient.observable.request.mockReturnValueOnce(of({documents: []})) // No revert document found
+
+    const {result} = renderHook(() => useAdjacentTransactions(mockDocuments))
+
+    await waitFor(async () => {
+      const resolvedResult = await result.current()
+      expect(resolvedResult).toEqual([
+        {
+          _id: 'doc1',
+          _rev: 'rev1',
+          _system: {delete: true},
+        },
+      ])
+    })
+
+    expect(mockGetTransactionsLogs).toHaveBeenCalledWith(mockClient, ['doc1', 'doc2'], {
+      toTransaction: 'rev1',
+      limit: 3,
+      reverse: true,
+    })
+  })
+
+  it('should return null if no transactions exist', async () => {
+    mockGetTransactionsLogs.mockResolvedValue([]) // No transactions
+
+    const {result} = renderHook(() => useAdjacentTransactions(mockDocuments))
+
+    await waitFor(async () => {
+      const resolvedResult = await result.current()
+      expect(resolvedResult).toBeUndefined()
+    })
+
+    expect(mockGetTransactionsLogs).toHaveBeenCalledWith(mockClient, ['doc1', 'doc2'], {
+      toTransaction: 'rev1',
+      limit: 3,
+      reverse: true,
+    })
+
+    expect(mockClient.observable.request).not.toHaveBeenCalled() // No API calls for empty transactions
+  })
+
+  it('should handle errors gracefully and return undefined', async () => {
+    mockGetTransactionsLogs.mockRejectedValue(new Error('Failed to fetch transactions'))
+
+    const {result} = renderHook(() => useAdjacentTransactions(mockDocuments))
+
+    await waitFor(async () => {
+      const resolvedResult = await result.current()
+      expect(resolvedResult).toBeUndefined()
+    })
+
+    expect(mockGetTransactionsLogs).toHaveBeenCalledWith(mockClient, ['doc1', 'doc2'], {
+      toTransaction: 'rev1',
+      limit: 3,
+      reverse: true,
+    })
+
+    expect(mockClient.observable.request).not.toHaveBeenCalled() // No API calls on failure
+  })
+
+  it('should handle a mix of existing and missing revisions', async () => {
+    mockClient.observable.request.mockImplementation(({url}) => {
+      if (url.includes('doc1')) {
+        return of({
+          documents: [
+            {
+              _id: 'doc1',
+              title: 'Reverted Document 1',
+            },
+          ],
+        })
+      }
+      return of({documents: []}) // No revert document for doc2
+    })
+
+    const {result} = renderHook(() => useAdjacentTransactions(mockDocuments))
+
+    await waitFor(async () => {
+      const resolvedResult = await result.current()
+      expect(resolvedResult).toEqual([
+        {
+          _id: 'doc1',
+          _rev: 'rev1',
+          _system: {delete: true},
+        },
+      ])
+    })
+
+    expect(mockGetTransactionsLogs).toHaveBeenCalledWith(mockClient, ['doc1', 'doc2'], {
+      toTransaction: 'rev1',
+      limit: 3,
+      reverse: true,
+    })
+  })
+})
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/usePostPublishTransactions.test.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/usePostPublishTransactions.test.ts
index ab8ede56b6c..8179515ecef 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/usePostPublishTransactions.test.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/usePostPublishTransactions.test.ts
@@ -60,6 +60,12 @@ describe('usePostPublishTransactions', () => {
     expect(result.current).toBeNull()
   })
 
+  it('should return false when no documents provided', async () => {
+    const {result} = renderHook(() => usePostPublishTransactions([]))
+
+    expect(result.current).toBe(false)
+  })
+
   it('should call getTransactionsLogs with the correct params', async () => {
     mockGetTransactionsLogs.mockResolvedValue(mockTransactionLogs)
 
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
index 900c04ee296..46278d939cc 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
@@ -1,14 +1,14 @@
 import {type SanityDocument} from '@sanity/types'
 import {useCallback, useEffect, useMemo, useRef} from 'react'
 import {useObservable} from 'react-rx'
-import {filter, forkJoin, from, map, type Observable, of, switchMap} from 'rxjs'
+import {catchError, filter, forkJoin, from, map, type Observable, of, switchMap} from 'rxjs'
 
 import {useClient} from '../../../../../hooks/useClient'
 import {getTransactionsLogs} from '../../../../../store/translog/getTransactionLogs'
 import {API_VERSION} from '../../../../../tasks/constants'
 import {type DocumentInRelease} from '../../../detail/useBundleDocuments'
 
-type RevertDocument = SanityDocument & {
+export type RevertDocument = SanityDocument & {
   _system?: {
     delete: boolean
   }
@@ -16,7 +16,7 @@ type RevertDocument = SanityDocument & {
 
 type RevertDocuments = RevertDocument[]
 
-type DocumentRevertStates = RevertDocuments | null
+type DocumentRevertStates = RevertDocuments | null | undefined
 
 export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
   const client = useClient({apiVersion: API_VERSION})
@@ -30,9 +30,18 @@ export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
   >(null)
   const resolvedDocumentRevertStatesResultRef = useRef<DocumentRevertStates | null>(null)
 
+  useEffect(() => {
+    if (!resultPromiseRef.current) {
+      resultPromiseRef.current = new Promise((resolve) => {
+        resolvedDocumentRevertStatesPromiseRef.current = resolve
+      })
+    }
+  }, [])
+
   const memoDocumentRevertStates = useMemo(() => {
-    // Observable to get the revert states of the documents
-    const documentRevertStates$: Observable<RevertDocuments> = from(
+    if (!documents.length) return of(undefined)
+
+    const documentRevertStates$: Observable<RevertDocuments | null | undefined> = from(
       getTransactionsLogs(
         client,
         documents.map(({document}) => document._id),
@@ -45,8 +54,14 @@ export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
         },
       ),
     ).pipe(
-      filter((transactions) => transactions.length > 0),
-      map(([publishTransaction, ...otherTransactions]) => {
+      filter(Boolean),
+      map((transactions) => {
+        if (transactions.length === 0) {
+          throw new Error('No transactions found.')
+        }
+
+        const [publishTransaction, ...otherTransactions] = transactions
+
         const getDocumentTransaction = (docId: string) =>
           otherTransactions.find(({documentIDs}) => documentIDs.includes(docId))?.id
 
@@ -55,12 +70,13 @@ export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
           revisionId: getDocumentTransaction(document._id),
         }))
       }),
-      switchMap((docRevisionPairs) =>
-        forkJoin(
+      switchMap((docRevisionPairs) => {
+        if (!docRevisionPairs) return of(undefined) // Pass undefined if no docRevisionPairs
+
+        return forkJoin(
           docRevisionPairs.map(({docId, revisionId}) => {
             if (!revisionId) {
               const {publishedDocumentExists, ...unpublishDocument} =
-                // eslint-disable-next-line max-nested-callbacks
                 documents.find(({document}) => document._id === docId)?.document || {}
 
               return of({
@@ -75,10 +91,21 @@ export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
               }>({
                 url: `/data/history/${dataset}/documents/${docId}?revision=${revisionId}`,
               })
-              .pipe(map(({documents: [revertDocument]}) => revertDocument))
+              .pipe(
+                map(({documents: [revertDocument]}) => revertDocument),
+                catchError((err) => {
+                  console.error(`Error fetching document ${docId}:`, err)
+                  return of(undefined) // Return undefined for errors
+                }),
+              )
           }),
-        ),
-      ),
+        )
+      }),
+      map((results) => results?.filter((result) => result !== undefined)),
+      catchError((err) => {
+        console.error('Error in the adjacent transactions pipeline:', err)
+        return of(undefined)
+      }),
     )
 
     return documentRevertStates$
@@ -105,12 +132,6 @@ export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
       return Promise.resolve(resolvedDocumentRevertStatesResultRef.current)
     }
 
-    if (!resultPromiseRef.current) {
-      resultPromiseRef.current = new Promise((res) => {
-        resolvedDocumentRevertStatesPromiseRef.current = res
-      })
-    }
-
     return resultPromiseRef.current
   }, [])
 }
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts
index 294979153f6..6761940adbc 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts
@@ -1,6 +1,6 @@
 import {useMemo} from 'react'
 import {useObservable} from 'react-rx'
-import {catchError, from, map, of} from 'rxjs'
+import {catchError, filter, from, map, of} from 'rxjs'
 
 import {useClient} from '../../../../../hooks/useClient'
 import {getTransactionsLogs} from '../../../../../store/translog/getTransactionLogs'
@@ -12,6 +12,8 @@ export const usePostPublishTransactions = (documents: DocumentInRelease[]) => {
   const transactionId = documents[0]?.document._rev
 
   const memoObservable = useMemo(() => {
+    if (!documents.length) return of(false)
+
     // Observable to check if there are post-publish transactions
     return from(
       getTransactionsLogs(
@@ -24,6 +26,7 @@ export const usePostPublishTransactions = (documents: DocumentInRelease[]) => {
         },
       ),
     ).pipe(
+      filter(Boolean),
       // the transaction of published is also returned
       // so post publish transactions will result in more than 1 transaction
       map((transactions) => transactions.length > 1),
diff --git a/packages/sanity/src/core/store/translog/getTransactionLogs.ts b/packages/sanity/src/core/store/translog/getTransactionLogs.ts
index 9655eddae2d..d9de60fc94c 100644
--- a/packages/sanity/src/core/store/translog/getTransactionLogs.ts
+++ b/packages/sanity/src/core/store/translog/getTransactionLogs.ts
@@ -68,7 +68,7 @@ export async function getTransactionsLogs(
      */
     authors?: string
   },
-): Promise<TransactionLogEventWithEffects[]> {
+): Promise<TransactionLogEventWithEffects[] | undefined> {
   const clientConfig = client.config()
   const dataset = clientConfig.dataset
   const queryParams = new URLSearchParams({
@@ -90,6 +90,8 @@ export async function getTransactionsLogs(
     }?${queryParams.toString()}`,
   )
 
+  if (!documentIds.length) return undefined
+
   const stream = await getJsonStream(transactionsUrl, clientConfig.token)
   const transactions: TransactionLogEventWithEffects[] = []
 

From cf416b69a861260c02f2ed17407de56c617e2ccf Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Thu, 12 Dec 2024 13:17:53 +0000
Subject: [PATCH 18/26] test: resolving test types

---
 .../createReleaseOperationsStore.test.ts      |  2 +-
 .../store/createReleaseOperationStore.ts      |  2 +-
 .../ReleaseRevertButton.tsx                   |  4 +--
 ...est.ts => useDocumentRevertStates.test.ts} | 35 +++++++++++--------
 .../usePostPublishTransactions.test.ts        | 23 ++++++------
 ...sactions.ts => useDocumentRevertStates.ts} |  2 +-
 6 files changed, 38 insertions(+), 30 deletions(-)
 rename packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/{useAdjacentTransactions.test.ts => useDocumentRevertStates.test.ts} (82%)
 rename packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/{useAdjacentTransactions.ts => useDocumentRevertStates.ts} (98%)

diff --git a/packages/sanity/src/core/releases/store/__tests__/createReleaseOperationsStore.test.ts b/packages/sanity/src/core/releases/store/__tests__/createReleaseOperationsStore.test.ts
index f018263b036..f9ab9345f6d 100644
--- a/packages/sanity/src/core/releases/store/__tests__/createReleaseOperationsStore.test.ts
+++ b/packages/sanity/src/core/releases/store/__tests__/createReleaseOperationsStore.test.ts
@@ -1,7 +1,7 @@
 import {type ReleaseDocument} from 'sanity'
 import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {type RevertDocument} from '../../tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions'
+import {type RevertDocument} from '../../tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates'
 import {createReleaseOperationsStore} from '../createReleaseOperationStore'
 
 describe('createReleaseOperationsStore', () => {
diff --git a/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts b/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts
index 49e5bf8e7a7..1ebea3affee 100644
--- a/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts
+++ b/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts
@@ -7,7 +7,7 @@ import {
 
 import {getPublishedId, getVersionId} from '../../util'
 import {getReleaseIdFromReleaseDocumentId, type ReleaseDocument} from '../index'
-import {type RevertDocument} from '../tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions'
+import {type RevertDocument} from '../tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates'
 import {type EditableReleaseDocument} from './types'
 
 export interface ReleaseOperationsStore {
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
index 062b86739ff..be92c5a901c 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
@@ -14,7 +14,7 @@ import {useReleaseOperations} from '../../../../store/useReleaseOperations'
 import {createReleaseId} from '../../../../util/createReleaseId'
 import {getReleaseIdFromReleaseDocumentId} from '../../../../util/getReleaseIdFromReleaseDocumentId'
 import {type DocumentInRelease} from '../../../detail/useBundleDocuments'
-import {useAdjacentTransactions} from './useAdjacentTransactions'
+import {useDocumentRevertStates} from './useDocumentRevertStates'
 import {usePostPublishTransactions} from './usePostPublishTransactions'
 
 interface ReleasePublishAllButtonProps {
@@ -38,7 +38,7 @@ const ConfirmReleaseDialog = ({
 }) => {
   const {t} = useTranslation(releasesLocaleNamespace)
   const hasPostPublishTransactions = usePostPublishTransactions(documents)
-  const getAdjacentTransactions = useAdjacentTransactions(documents)
+  const getAdjacentTransactions = useDocumentRevertStates(documents)
   const [stageNewRevertRelease, setStageNewRevertRelease] = useState(true)
   const toast = useToast()
   const telemetry = useTelemetry()
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/useAdjacentTransactions.test.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/useDocumentRevertStates.test.ts
similarity index 82%
rename from packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/useAdjacentTransactions.test.ts
rename to packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/useDocumentRevertStates.test.ts
index 507d412e873..a2bbcfee1ac 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/useAdjacentTransactions.test.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/useDocumentRevertStates.test.ts
@@ -1,3 +1,5 @@
+import {type SanityClient} from '@sanity/client'
+import {type TransactionLogEventWithEffects} from '@sanity/types'
 import {renderHook, waitFor} from '@testing-library/react'
 import {of} from 'rxjs'
 import {beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
@@ -5,7 +7,7 @@ import {beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
 import {useClient} from '../../../../../../hooks/useClient'
 import {getTransactionsLogs} from '../../../../../../store/translog/getTransactionLogs'
 import {type DocumentInRelease} from '../../../../detail/useBundleDocuments'
-import {useAdjacentTransactions} from '../useAdjacentTransactions'
+import {useDocumentRevertStates} from '../useDocumentRevertStates'
 
 vi.mock('../../../../../../hooks/useClient', () => ({
   useClient: vi.fn(),
@@ -15,22 +17,27 @@ vi.mock('../../../../../../store/translog/getTransactionLogs', () => ({
   getTransactionsLogs: vi.fn(),
 }))
 
-describe('useAdjacentTransactions', () => {
+describe('useDocumentRevertStates', () => {
   const mockDocuments = [
     {document: {_id: 'doc1', _rev: 'rev1'}},
     {document: {_id: 'doc2', _rev: 'rev2'}},
   ] as DocumentInRelease[]
 
+  /** @todo improve the useClient mock */
   const mockClient = {
     getUrl: vi.fn(),
     config: vi.fn().mockReturnValue({dataset: 'test-dataset'}),
     observable: {
       request: vi.fn(),
     },
+  } as unknown as SanityClient & {
+    observable: {
+      request: Mock<SanityClient['observable']['request']>
+    }
   }
 
-  const mockUseClient = useClient as Mock
-  const mockGetTransactionsLogs = getTransactionsLogs as Mock
+  const mockUseClient = useClient as Mock<typeof useClient>
+  const mockGetTransactionsLogs = getTransactionsLogs as Mock<typeof getTransactionsLogs>
 
   beforeEach(() => {
     vi.clearAllMocks()
@@ -40,10 +47,10 @@ describe('useAdjacentTransactions', () => {
     mockGetTransactionsLogs.mockResolvedValue([
       {id: 'trans1', documentIDs: ['doc1'], timestamp: new Date().toISOString()},
       {id: 'trans2', documentIDs: ['doc2'], timestamp: new Date().toISOString()},
-    ])
+    ] as TransactionLogEventWithEffects[])
 
     mockClient.observable.request.mockImplementation(({url}) => {
-      if (url.includes('doc1')) {
+      if (url!.includes('doc1')) {
         return of({
           documents: [
             {
@@ -54,7 +61,7 @@ describe('useAdjacentTransactions', () => {
           ],
         })
       }
-      if (url.includes('doc2')) {
+      if (url!.includes('doc2')) {
         return of({
           documents: [
             {
@@ -70,12 +77,12 @@ describe('useAdjacentTransactions', () => {
   })
 
   it('should return a function', () => {
-    const {result} = renderHook(() => useAdjacentTransactions(mockDocuments))
+    const {result} = renderHook(() => useDocumentRevertStates(mockDocuments))
     expect(typeof result.current).toBe('function')
   })
 
   it('should fetch adjacent transactions and resolve to revert states', async () => {
-    const {result} = renderHook(() => useAdjacentTransactions(mockDocuments))
+    const {result} = renderHook(() => useDocumentRevertStates(mockDocuments))
 
     await waitFor(async () => {
       const resolvedResult = await result.current()
@@ -107,7 +114,7 @@ describe('useAdjacentTransactions', () => {
   it('should handle missing revisions and mark for deletion', async () => {
     mockClient.observable.request.mockReturnValueOnce(of({documents: []})) // No revert document found
 
-    const {result} = renderHook(() => useAdjacentTransactions(mockDocuments))
+    const {result} = renderHook(() => useDocumentRevertStates(mockDocuments))
 
     await waitFor(async () => {
       const resolvedResult = await result.current()
@@ -130,7 +137,7 @@ describe('useAdjacentTransactions', () => {
   it('should return null if no transactions exist', async () => {
     mockGetTransactionsLogs.mockResolvedValue([]) // No transactions
 
-    const {result} = renderHook(() => useAdjacentTransactions(mockDocuments))
+    const {result} = renderHook(() => useDocumentRevertStates(mockDocuments))
 
     await waitFor(async () => {
       const resolvedResult = await result.current()
@@ -149,7 +156,7 @@ describe('useAdjacentTransactions', () => {
   it('should handle errors gracefully and return undefined', async () => {
     mockGetTransactionsLogs.mockRejectedValue(new Error('Failed to fetch transactions'))
 
-    const {result} = renderHook(() => useAdjacentTransactions(mockDocuments))
+    const {result} = renderHook(() => useDocumentRevertStates(mockDocuments))
 
     await waitFor(async () => {
       const resolvedResult = await result.current()
@@ -167,7 +174,7 @@ describe('useAdjacentTransactions', () => {
 
   it('should handle a mix of existing and missing revisions', async () => {
     mockClient.observable.request.mockImplementation(({url}) => {
-      if (url.includes('doc1')) {
+      if (url!.includes('doc1')) {
         return of({
           documents: [
             {
@@ -180,7 +187,7 @@ describe('useAdjacentTransactions', () => {
       return of({documents: []}) // No revert document for doc2
     })
 
-    const {result} = renderHook(() => useAdjacentTransactions(mockDocuments))
+    const {result} = renderHook(() => useDocumentRevertStates(mockDocuments))
 
     await waitFor(async () => {
       const resolvedResult = await result.current()
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/usePostPublishTransactions.test.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/usePostPublishTransactions.test.ts
index 8179515ecef..3c4caef0f3e 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/usePostPublishTransactions.test.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/__tests__/usePostPublishTransactions.test.ts
@@ -1,5 +1,5 @@
+import {type TransactionLogEventWithEffects} from '@sanity/types'
 import {act, renderHook, waitFor} from '@testing-library/react'
-import {from} from 'rxjs'
 import {beforeEach, describe, expect, it, type Mock, vi} from 'vitest'
 
 import {useClient} from '../../../../../../hooks/useClient'
@@ -17,7 +17,7 @@ vi.mock('../../../../../../store/translog/getTransactionLogs', () => ({
 
 const processMicroTasks = () =>
   act(async () => {
-    await Promise.resolve() // Process pending updates
+    await Promise.resolve()
   })
 
 describe('usePostPublishTransactions', () => {
@@ -29,7 +29,7 @@ describe('usePostPublishTransactions', () => {
   const mockClient = {getUrl: vi.fn(), config: vi.fn()}
 
   const mockUseClient = useClient as Mock
-  const mockGetTransactionsLogs = getTransactionsLogs as Mock
+  const mockGetTransactionsLogs = getTransactionsLogs as Mock<typeof getTransactionsLogs>
 
   beforeEach(() => {
     vi.clearAllMocks()
@@ -40,20 +40,20 @@ describe('usePostPublishTransactions', () => {
   const mockTransactionLogs = [
     {
       id: 'trans1',
-      type: 'publish',
-      effects: [],
+      author: 'author1',
+      documentIDs: ['doc1'],
       timestamp: '2024-01-01T00:00:00Z',
     },
     {
       id: 'trans2',
-      type: 'update',
-      effects: [],
+      author: 'author1',
+      documentIDs: ['doc1'],
       timestamp: '2024-01-01T01:00:00Z',
     },
-  ]
+  ] as TransactionLogEventWithEffects[]
 
   it('should return null initially', () => {
-    mockGetTransactionsLogs.mockReturnValue(from([]))
+    mockGetTransactionsLogs.mockResolvedValue(undefined)
 
     const {result} = renderHook(() => usePostPublishTransactions(mockDocuments))
 
@@ -95,8 +95,9 @@ describe('usePostPublishTransactions', () => {
     mockGetTransactionsLogs.mockResolvedValue([
       {
         id: 'trans1',
-        type: 'publish',
-        effects: [],
+        author: 'author1',
+        documentIDs: ['doc1'],
+        effects: {},
         timestamp: '2024-01-01T00:00:00Z',
       },
     ])
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates.ts
similarity index 98%
rename from packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
rename to packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates.ts
index 46278d939cc..c96f6cdfec4 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useAdjacentTransactions.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates.ts
@@ -18,7 +18,7 @@ type RevertDocuments = RevertDocument[]
 
 type DocumentRevertStates = RevertDocuments | null | undefined
 
-export const useAdjacentTransactions = (documents: DocumentInRelease[]) => {
+export const useDocumentRevertStates = (documents: DocumentInRelease[]) => {
   const client = useClient({apiVersion: API_VERSION})
   const observableClient = client.observable
   const transactionId = documents[0]?.document._rev

From 8d281f5a736d2a617c3d18c2deae71fd9d0410d7 Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Thu, 12 Dec 2024 13:25:31 +0000
Subject: [PATCH 19/26] chore: updating copy

---
 packages/sanity/src/core/releases/i18n/resources.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/sanity/src/core/releases/i18n/resources.ts b/packages/sanity/src/core/releases/i18n/resources.ts
index 9b5278af36b..40fa620f7aa 100644
--- a/packages/sanity/src/core/releases/i18n/resources.ts
+++ b/packages/sanity/src/core/releases/i18n/resources.ts
@@ -208,7 +208,7 @@ const releasesLocaleStrings = {
     'Stage revert actions in a new release',
   /** Warning card text for when immediately revert a release with history */
   'revert-dialog.confirm-revert.warning-card':
-    'Changes were made to documents in this release after they were published. Reverting will revert all changes.',
+    'Changes were made to documents in this release after they were published. Reverting will overwrite these changes.',
   /** Title of a reverted release */
   'revert-release.title': 'Reverting "{{title}}"',
   /** Description of a reverted release */

From cc88fc80a63db8ceeb2589397b31fe937e8ed53d Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Thu, 12 Dec 2024 13:29:27 +0000
Subject: [PATCH 20/26] fix: type on mock

---
 .../store/__tests__/__mocks/createReleaseOperationsStore.mock.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/sanity/src/core/releases/store/__tests__/__mocks/createReleaseOperationsStore.mock.ts b/packages/sanity/src/core/releases/store/__tests__/__mocks/createReleaseOperationsStore.mock.ts
index 4411b11e58b..dcb169cf213 100644
--- a/packages/sanity/src/core/releases/store/__tests__/__mocks/createReleaseOperationsStore.mock.ts
+++ b/packages/sanity/src/core/releases/store/__tests__/__mocks/createReleaseOperationsStore.mock.ts
@@ -16,6 +16,7 @@ export const createReleaseOperationsStoreReturn: Mocked<ReleaseOperationsStore>
   unschedule: vi.fn(),
   updateRelease: vi.fn(),
   deleteRelease: vi.fn(),
+  revertRelease: vi.fn(),
   unpublishVersion: vi.fn(),
 }
 

From 61681e8343c12dbb87a296e0e43de449985df310 Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Thu, 12 Dec 2024 13:38:57 +0000
Subject: [PATCH 21/26] fix: import path

---
 .../ReleaseRevertButton/ReleaseRevertButton.tsx                 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
index be92c5a901c..b1bf423a9b3 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
@@ -2,8 +2,8 @@ import {RestoreIcon} from '@sanity/icons'
 import {useTelemetry} from '@sanity/telemetry/react'
 import {Box, Card, Checkbox, Flex, Text, useToast} from '@sanity/ui'
 import {useCallback, useState} from 'react'
+import {useRouter} from 'sanity/router'
 
-import {useRouter} from '../../../../../../router'
 import {Button} from '../../../../../../ui-components/button/Button'
 import {Dialog} from '../../../../../../ui-components/dialog'
 import {Translate, useTranslation} from '../../../../../i18n'

From 9f0808bf5c707a12b6d9488f97a9e271e689ed93 Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Thu, 12 Dec 2024 14:19:52 +0000
Subject: [PATCH 22/26] refactor: comment tidy

---
 .../ReleaseRevertButton/useDocumentRevertStates.ts | 14 ++++++--------
 .../usePostPublishTransactions.ts                  |  9 +++------
 2 files changed, 9 insertions(+), 14 deletions(-)

diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates.ts
index c96f6cdfec4..f0bc66b3ebf 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates.ts
@@ -56,9 +56,7 @@ export const useDocumentRevertStates = (documents: DocumentInRelease[]) => {
     ).pipe(
       filter(Boolean),
       map((transactions) => {
-        if (transactions.length === 0) {
-          throw new Error('No transactions found.')
-        }
+        if (transactions.length === 0) throw new Error('No transactions found.')
 
         const [publishTransaction, ...otherTransactions] = transactions
 
@@ -71,7 +69,7 @@ export const useDocumentRevertStates = (documents: DocumentInRelease[]) => {
         }))
       }),
       switchMap((docRevisionPairs) => {
-        if (!docRevisionPairs) return of(undefined) // Pass undefined if no docRevisionPairs
+        if (!docRevisionPairs) return of(undefined)
 
         return forkJoin(
           docRevisionPairs.map(({docId, revisionId}) => {
@@ -95,7 +93,7 @@ export const useDocumentRevertStates = (documents: DocumentInRelease[]) => {
                 map(({documents: [revertDocument]}) => revertDocument),
                 catchError((err) => {
                   console.error(`Error fetching document ${docId}:`, err)
-                  return of(undefined) // Return undefined for errors
+                  return of(undefined)
                 }),
               )
           }),
@@ -103,7 +101,7 @@ export const useDocumentRevertStates = (documents: DocumentInRelease[]) => {
       }),
       map((results) => results?.filter((result) => result !== undefined)),
       catchError((err) => {
-        console.error('Error in the adjacent transactions pipeline:', err)
+        console.error('Error in document revert states pipeline:', err)
         return of(undefined)
       }),
     )
@@ -117,11 +115,11 @@ export const useDocumentRevertStates = (documents: DocumentInRelease[]) => {
     if (documentRevertStatesResult !== null) {
       resolvedDocumentRevertStatesResultRef.current = documentRevertStatesResult
 
-      // Resolve the promise if it exists
+      // Resolve promise if it exists
       if (resolvedDocumentRevertStatesPromiseRef.current) {
         resolvedDocumentRevertStatesPromiseRef.current(documentRevertStatesResult)
         resolvedDocumentRevertStatesPromiseRef.current = null
-        resultPromiseRef.current = null // Reset the resultPromiseRef for future fetches
+        resultPromiseRef.current = null // Reset resultPromiseRef for future fetches
       }
     }
   }, [documentRevertStatesResult])
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts
index 6761940adbc..3f010273673 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts
@@ -11,17 +11,16 @@ export const usePostPublishTransactions = (documents: DocumentInRelease[]) => {
   const client = useClient({apiVersion: API_VERSION})
   const transactionId = documents[0]?.document._rev
 
-  const memoObservable = useMemo(() => {
+  const memoHasPostPublishTransactions = useMemo(() => {
     if (!documents.length) return of(false)
 
-    // Observable to check if there are post-publish transactions
     return from(
       getTransactionsLogs(
         client,
         documents.map(({document}) => document._id),
         {
           fromTransaction: transactionId,
-          // one transaction for every document plus the publish transaction
+          // publish transaction + at least one post publish transaction
           limit: 2,
         },
       ),
@@ -34,7 +33,5 @@ export const usePostPublishTransactions = (documents: DocumentInRelease[]) => {
     )
   }, [client, documents, transactionId])
 
-  const observableResult = useObservable(memoObservable, null)
-
-  return observableResult
+  return useObservable(memoHasPostPublishTransactions, null)
 }

From 959a533f3af3d62f2048f45256141b7166c112c4 Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Thu, 12 Dec 2024 18:30:39 +0000
Subject: [PATCH 23/26] refactor: immediate instead of immediately

---
 .../src/core/releases/__telemetry__/releases.telemetry.ts   | 2 +-
 .../src/core/releases/store/createReleaseOperationStore.ts  | 6 +++---
 .../ReleaseRevertButton/ReleaseRevertButton.tsx             | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/packages/sanity/src/core/releases/__telemetry__/releases.telemetry.ts b/packages/sanity/src/core/releases/__telemetry__/releases.telemetry.ts
index 8048ff8fb91..029e2630803 100644
--- a/packages/sanity/src/core/releases/__telemetry__/releases.telemetry.ts
+++ b/packages/sanity/src/core/releases/__telemetry__/releases.telemetry.ts
@@ -24,7 +24,7 @@ export interface RevertInfo {
   /**
    * determined whether reverting a release created a new staged release, or immediately reverted
    */
-  revertType: 'immediately' | 'staged'
+  revertType: 'immediate' | 'staged'
 }
 
 /**
diff --git a/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts b/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts
index 1ebea3affee..cec8509b5a5 100644
--- a/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts
+++ b/packages/sanity/src/core/releases/store/createReleaseOperationStore.ts
@@ -24,7 +24,7 @@ export interface ReleaseOperationsStore {
     revertReleaseId: string,
     documents: RevertDocument[],
     releaseMetadata: ReleaseDocument['metadata'],
-    revertType: 'staged' | 'immediately',
+    revertType: 'staged' | 'immediate',
   ) => Promise<void>
   createVersion: (
     releaseId: string,
@@ -171,7 +171,7 @@ export function createReleaseOperationsStore(options: {
     revertReleaseId: string,
     releaseDocuments: RevertDocument[],
     releaseMetadata: ReleaseDocument['metadata'],
-    revertType: 'staged' | 'immediately',
+    revertType: 'staged' | 'immediate',
   ) => {
     await handleCreateRelease({
       _id: revertReleaseId,
@@ -191,7 +191,7 @@ export function createReleaseOperationsStore(options: {
       ),
     )
 
-    if (revertType === 'immediately') {
+    if (revertType === 'immediate') {
       await handlePublishRelease(revertReleaseId)
     }
   }
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
index b1bf423a9b3..0b0f9fdc9ce 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
@@ -70,7 +70,7 @@ const ConfirmReleaseDialog = ({
           description: t('revert-release.description', {title: release.metadata.title}),
           releaseType: 'asap',
         },
-        stageNewRevertRelease ? 'staged' : 'immediately',
+        stageNewRevertRelease ? 'staged' : 'immediate',
       )
 
       if (stageNewRevertRelease) {
@@ -106,7 +106,7 @@ const ConfirmReleaseDialog = ({
           ),
         })
       } else {
-        telemetry.log(RevertRelease, {revertType: 'immediately'})
+        telemetry.log(RevertRelease, {revertType: 'immediate'})
 
         toast.push({
           closable: true,

From f1e9de418a41b521563dc69a06b9364510b87d6f Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Thu, 12 Dec 2024 18:55:30 +0000
Subject: [PATCH 24/26] test: mocking promise.withResolvers; using inside
 useDocumentRevertStates

---
 .../ReleaseRevertButton/ReleaseRevertButton.tsx     |  6 +++---
 .../ReleaseRevertButton/useDocumentRevertStates.ts  | 13 +++++++------
 packages/sanity/test/setup/environment.ts           | 12 ++++++++++++
 3 files changed, 22 insertions(+), 9 deletions(-)

diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
index 0b0f9fdc9ce..825cc07203f 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/ReleaseRevertButton.tsx
@@ -38,7 +38,7 @@ const ConfirmReleaseDialog = ({
 }) => {
   const {t} = useTranslation(releasesLocaleNamespace)
   const hasPostPublishTransactions = usePostPublishTransactions(documents)
-  const getAdjacentTransactions = useDocumentRevertStates(documents)
+  const getDocumentRevertStates = useDocumentRevertStates(documents)
   const [stageNewRevertRelease, setStageNewRevertRelease] = useState(true)
   const toast = useToast()
   const telemetry = useTelemetry()
@@ -53,7 +53,7 @@ const ConfirmReleaseDialog = ({
 
   const handleRevertRelease = useCallback(async () => {
     setRevertReleaseStatus('reverting')
-    const documentRevertStates = await getAdjacentTransactions()
+    const documentRevertStates = await getDocumentRevertStates()
 
     const revertReleaseId = createReleaseId()
 
@@ -137,7 +137,7 @@ const ConfirmReleaseDialog = ({
     }
   }, [
     setRevertReleaseStatus,
-    getAdjacentTransactions,
+    getDocumentRevertStates,
     revertRelease,
     t,
     release.metadata.title,
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates.ts
index f0bc66b3ebf..ad65942b635 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates.ts
@@ -10,7 +10,7 @@ import {type DocumentInRelease} from '../../../detail/useBundleDocuments'
 
 export type RevertDocument = SanityDocument & {
   _system?: {
-    delete: boolean
+    delete: true
   }
 }
 
@@ -32,9 +32,10 @@ export const useDocumentRevertStates = (documents: DocumentInRelease[]) => {
 
   useEffect(() => {
     if (!resultPromiseRef.current) {
-      resultPromiseRef.current = new Promise((resolve) => {
-        resolvedDocumentRevertStatesPromiseRef.current = resolve
-      })
+      const {promise, resolve} = Promise.withResolvers<DocumentRevertStates>()
+
+      resultPromiseRef.current = promise
+      resolvedDocumentRevertStatesPromiseRef.current = resolve
     }
   }, [])
 
@@ -78,9 +79,9 @@ export const useDocumentRevertStates = (documents: DocumentInRelease[]) => {
                 documents.find(({document}) => document._id === docId)?.document || {}
 
               return of({
-                ...(unpublishDocument as SanityDocument),
+                ...unpublishDocument,
                 _system: {delete: true},
-              })
+              } as RevertDocument)
             }
 
             return observableClient
diff --git a/packages/sanity/test/setup/environment.ts b/packages/sanity/test/setup/environment.ts
index 63c8c07ddb1..9370c9aac06 100644
--- a/packages/sanity/test/setup/environment.ts
+++ b/packages/sanity/test/setup/environment.ts
@@ -59,6 +59,18 @@ window.matchMedia = vi.fn().mockImplementation((query) => ({
   dispatchEvent: vi.fn(),
 }))
 
+window.Promise.withResolvers = <T>() => {
+  let resolve: (value: T | PromiseLike<T>) => void = () => {}
+  let reject: (reason?: any) => void = () => {}
+
+  const promise: Promise<T> = new Promise((res, rej) => {
+    resolve = res
+    reject = rej
+  })
+
+  return {promise, resolve, reject}
+}
+
 // Resets the matchMedia mock
 beforeEach(() => {
   window.matchMedia = vi.fn().mockImplementation((query) => ({

From 44dedc7ba7df5f464bb560a195c06e1017ceb04a Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Thu, 12 Dec 2024 19:08:59 +0000
Subject: [PATCH 25/26] test: fixing test due to update with type of revert

---
 .../store/__tests__/createReleaseOperationsStore.test.ts        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/sanity/src/core/releases/store/__tests__/createReleaseOperationsStore.test.ts b/packages/sanity/src/core/releases/store/__tests__/createReleaseOperationsStore.test.ts
index f9ab9345f6d..b7993c8785d 100644
--- a/packages/sanity/src/core/releases/store/__tests__/createReleaseOperationsStore.test.ts
+++ b/packages/sanity/src/core/releases/store/__tests__/createReleaseOperationsStore.test.ts
@@ -201,7 +201,7 @@ describe('createReleaseOperationsStore', () => {
         revertReleaseDocumentId,
         releaseDocuments,
         releaseMetadata,
-        'immediately',
+        'immediate',
       )
 
       expect(mockClient.request).toHaveBeenCalledWith({

From 5a2a17a033bd1d2300f5eb1b0a6b8e822e2ea5d0 Mon Sep 17 00:00:00 2001
From: Jordan Lawrence <jordanl17@me.com>
Date: Fri, 13 Dec 2024 18:05:07 +0000
Subject: [PATCH 26/26] refactor: removing undefined return type from
 getTransLogs when no doc IDs provided

---
 .../ReleaseRevertButton/useDocumentRevertStates.ts            | 3 +--
 .../ReleaseRevertButton/usePostPublishTransactions.ts         | 3 +--
 packages/sanity/src/core/store/translog/getTransactionLogs.ts | 4 +---
 3 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates.ts
index ad65942b635..56fc9f8f639 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/useDocumentRevertStates.ts
@@ -1,7 +1,7 @@
 import {type SanityDocument} from '@sanity/types'
 import {useCallback, useEffect, useMemo, useRef} from 'react'
 import {useObservable} from 'react-rx'
-import {catchError, filter, forkJoin, from, map, type Observable, of, switchMap} from 'rxjs'
+import {catchError, forkJoin, from, map, type Observable, of, switchMap} from 'rxjs'
 
 import {useClient} from '../../../../../hooks/useClient'
 import {getTransactionsLogs} from '../../../../../store/translog/getTransactionLogs'
@@ -55,7 +55,6 @@ export const useDocumentRevertStates = (documents: DocumentInRelease[]) => {
         },
       ),
     ).pipe(
-      filter(Boolean),
       map((transactions) => {
         if (transactions.length === 0) throw new Error('No transactions found.')
 
diff --git a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts
index 3f010273673..369c5e74593 100644
--- a/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts
+++ b/packages/sanity/src/core/releases/tool/components/releaseCTAButtons/ReleaseRevertButton/usePostPublishTransactions.ts
@@ -1,6 +1,6 @@
 import {useMemo} from 'react'
 import {useObservable} from 'react-rx'
-import {catchError, filter, from, map, of} from 'rxjs'
+import {catchError, from, map, of} from 'rxjs'
 
 import {useClient} from '../../../../../hooks/useClient'
 import {getTransactionsLogs} from '../../../../../store/translog/getTransactionLogs'
@@ -25,7 +25,6 @@ export const usePostPublishTransactions = (documents: DocumentInRelease[]) => {
         },
       ),
     ).pipe(
-      filter(Boolean),
       // the transaction of published is also returned
       // so post publish transactions will result in more than 1 transaction
       map((transactions) => transactions.length > 1),
diff --git a/packages/sanity/src/core/store/translog/getTransactionLogs.ts b/packages/sanity/src/core/store/translog/getTransactionLogs.ts
index d9de60fc94c..9655eddae2d 100644
--- a/packages/sanity/src/core/store/translog/getTransactionLogs.ts
+++ b/packages/sanity/src/core/store/translog/getTransactionLogs.ts
@@ -68,7 +68,7 @@ export async function getTransactionsLogs(
      */
     authors?: string
   },
-): Promise<TransactionLogEventWithEffects[] | undefined> {
+): Promise<TransactionLogEventWithEffects[]> {
   const clientConfig = client.config()
   const dataset = clientConfig.dataset
   const queryParams = new URLSearchParams({
@@ -90,8 +90,6 @@ export async function getTransactionsLogs(
     }?${queryParams.toString()}`,
   )
 
-  if (!documentIds.length) return undefined
-
   const stream = await getJsonStream(transactionsUrl, clientConfig.token)
   const transactions: TransactionLogEventWithEffects[] = []