WIP: Refactor/corel nicer org limits

packages/sanity/src/core/releases/contexts/upsell/ReleasesUpsellProvider.tsx

@@ -1,6 +1,8 @@
+/* eslint-disable no-console */
 import {useTelemetry} from '@sanity/telemetry/react'
 import {template} from 'lodash'
 import {useCallback, useEffect, useMemo, useState} from 'react'
+import {firstValueFrom} from 'rxjs'
 import {ReleasesUpsellContext} from 'sanity/_singletons'
 
 import {useClient, useFeatureEnabled, useProjectId} from '../../../hooks'
@@ -14,6 +16,8 @@ import {TEMPLATE_OPTIONS} from '../../../studio/upsell/constants'
 import {type UpsellData} from '../../../studio/upsell/types'
 import {UpsellDialog} from '../../../studio/upsell/UpsellDialog'
 import {useActiveReleases} from '../../store/useActiveReleases'
+import {useOrgActiveReleaseCount} from '../../store/useOrgActiveReleaseCount'
+import {useReleaseLimits} from '../../store/useReleaseLimits'
 import {type ReleasesUpsellContextValue} from './types'
 
 class StudioReleaseLimitExceededError extends Error {
@@ -43,26 +47,22 @@ export function ReleasesUpsellProvider(props: {children: React.ReactNode}) {
   const projectId = useProjectId()
   const telemetry = useTelemetry()
   const client = useClient({apiVersion: API_VERSION})
-  const [releaseLimit, setReleaseLimit] = useState<number | undefined>(undefined)
   const {data: activeReleases} = useActiveReleases()
   const {enabled: isReleasesFeatureEnabled} = useFeatureEnabled('contentReleases')
 
   const mode = useMemo(() => {
     /**
      * upsell if:
      * plan is free, ie releases is not feature enabled
-     * there is a limit and the limit is reached or exceeded
      */
-    const isAtReleaseLimit =
-      !isReleasesFeatureEnabled || (releaseLimit && (activeReleases?.length || 0) >= releaseLimit)
-    if (isAtReleaseLimit && upsellData) {
+    if (!isReleasesFeatureEnabled && upsellData) {
       return 'upsell'
     }
-    if (isAtReleaseLimit && !upsellData) {
+    if (isReleasesFeatureEnabled && !upsellData) {
       return 'disabled'
     }
     return 'default'
-  }, [activeReleases?.length, isReleasesFeatureEnabled, releaseLimit, upsellData])
+  }, [isReleasesFeatureEnabled, upsellData])
 
   const telemetryLogs = useMemo(
     (): ReleasesUpsellContextValue['telemetryLogs'] => ({
@@ -146,40 +146,93 @@ export function ReleasesUpsellProvider(props: {children: React.ReactNode}) {
     }
   }, [client, projectId])
 
-  const handleOpenDialog = useCallback(() => {
-    setUpsellDialogOpen(true)
+  const [releaseCount, setReleaseCount] = useState<number | null>(null)
 
-    telemetry.log(UpsellDialogViewed, {
-      feature: FEATURE,
-      type: 'modal',
-      source: 'navbar',
-    })
-  }, [telemetry])
+  const handleOpenDialog = useCallback(
+    (orgActiveReleaseCount?: number) => {
+      setUpsellDialogOpen(true)
+      if (orgActiveReleaseCount !== undefined) {
+        setReleaseCount(orgActiveReleaseCount)
+      }
+
+      telemetry.log(UpsellDialogViewed, {
+        feature: FEATURE,
+        type: 'modal',
+        source: 'navbar',
+      })
+    },
+    [telemetry],
+  )
+
+  const limitsClient = client.withConfig({apiVersion: 'vX'}).observable
+  const {releaseLimits$} = useReleaseLimits(limitsClient)
+  const {orgActiveReleaseCount$} = useOrgActiveReleaseCount(limitsClient)
 
   const guardWithReleaseLimitUpsell = useCallback(
-    (cb: () => void, throwError: boolean = false) => {
-      if (mode === 'default') {
-        return cb()
+    async (cb: () => void, throwError: boolean = false) => {
+      const doUpsell: (count?: number) => false = (count) => {
+        handleOpenDialog(count)
+        if (throwError) {
+          throw new StudioReleaseLimitExceededError()
+        }
+        return false
       }
 
-      handleOpenDialog()
-      if (throwError) {
-        throw new StudioReleaseLimitExceededError()
+      if (mode === 'upsell') return doUpsell()
+
+      const fetchLimitsCount = async () => {
+        try {
+          console.log('Guard called, checking caches...')
+          // if either fails then catch the error
+          return await Promise.all([
+            firstValueFrom(orgActiveReleaseCount$),
+            firstValueFrom(releaseLimits$),
+          ])
+        } catch (e) {
+          console.error('Error fetching release limits and org count for upsell:', e)
+
+          return null
+        }
       }
-      return false
+
+      const result = await fetchLimitsCount()
+
+      // silently fail and allow pass through guard
+      if (result === null) return cb()
+
+      const [orgActiveReleaseCount, releaseLimits] = result
+
+      if (releaseLimits === null || orgActiveReleaseCount === null) return cb()
+
+      const {orgActiveReleaseLimit, datasetReleaseLimit} = releaseLimits
+
+      // orgActiveReleaseCount might be missing due to internal server error
+      // allow pass through guard in that case
+      if (orgActiveReleaseCount === null) return cb()
+
+      const activeReleasesCount = activeReleases?.length || 0
+
+      const isCurrentDatasetAtAboveDatasetLimit = activeReleasesCount >= datasetReleaseLimit
+      const isCurrentDatasetAtAboveOrgLimit =
+        orgActiveReleaseLimit !== null && activeReleasesCount >= orgActiveReleaseLimit
+      const isOrgAtAboveOrgLimit =
+        orgActiveReleaseLimit !== null && orgActiveReleaseCount >= orgActiveReleaseLimit
+
+      const shouldShowDialog =
+        isCurrentDatasetAtAboveDatasetLimit ||
+        isCurrentDatasetAtAboveOrgLimit ||
+        isOrgAtAboveOrgLimit
+
+      if (shouldShowDialog) return doUpsell(orgActiveReleaseCount)
+
+      return cb()
     },
-    [handleOpenDialog, mode],
+    [mode, handleOpenDialog, orgActiveReleaseCount$, releaseLimits$, activeReleases?.length],
   )
 
   const onReleaseLimitReached = useCallback(
-    (limit: number, suppressDialogOpening: boolean = false) => {
-      setReleaseLimit(limit)
-
-      if (!suppressDialogOpening && (activeReleases?.length || 0) >= limit) {
-        handleOpenDialog()
-      }
-    },
-    [activeReleases?.length, handleOpenDialog],
+    (limit: number) => handleOpenDialog(limit),
+    [handleOpenDialog],
   )
 
   const ctxValue = useMemo<ReleasesUpsellContextValue>(
@@ -193,7 +246,7 @@ export function ReleasesUpsellProvider(props: {children: React.ReactNode}) {
     [mode, upsellDialogOpen, guardWithReleaseLimitUpsell, onReleaseLimitReached, telemetryLogs],
   )
 
-  const interpolation = releaseLimit ? {releaseLimit} : undefined
+  const interpolation = releaseCount === null ? undefined : {releaseLimit: releaseCount}
 
   return (
     <ReleasesUpsellContext.Provider value={ctxValue}>

packages/sanity/src/core/releases/contexts/upsell/fetchReleaseLimits.ts

@@ -0,0 +1,53 @@
+import {type ClientError, type ObservableSanityClient} from '@sanity/client'
+import {catchError, map, type Observable, of, share} from 'rxjs'
+
+export interface ReleaseLimits {
+  orgActiveReleaseCount: number
+  defaultOrgActiveReleaseLimit: number
+  datasetReleaseLimit: number
+  // internal server error has no fallback number - it uses null
+  orgActiveReleaseLimit: number | null
+}
+
+interface ReleaseLimitsResponse {
+  data: ReleaseLimits
+}
+
+/**
+ * @internal
+ * fetches subscriptions for this project
+ */
+export function fetchReleaseLimits(clientOb: ObservableSanityClient): Observable<ReleaseLimits> {
+  const {projectId} = clientOb.config()
+
+  // This endpoint is prone to optimisation and further work
+  // it will never live within a versions API and will always be on vX
+  // until it goes away - there is graceful handling in `catchError`
+  // for when this endpoint is no longer available and limits are fetched
+  // some other way
+
+  return clientOb
+    .withConfig({apiVersion: 'vX'})
+    .request<ReleaseLimitsResponse>({
+      uri: `projects/${projectId}/new-content-release-allowed`,
+      // tag: `new-${new Date().getTime()}`,
+      tag: 'new-content-release-allowed',
+    })
+    .pipe(
+      share(),
+      catchError((error: ClientError) => {
+        console.error(error)
+
+        if (typeof error.response.body !== 'string' && 'data' in error.response.body) {
+          // body will still contain the limits and current count (if available)
+          // so still want to return these and just silently log the error
+          return of(error.response.body as ReleaseLimitsResponse)
+        }
+
+        // for internal server errors, or as a fallback
+        // propagate up the error
+        throw error
+      }),
+      map(({data}) => data),
+    )
+}

packages/sanity/src/core/releases/contexts/upsell/types.ts

@@ -8,8 +8,8 @@ export interface ReleasesUpsellContextValue {
    */
   mode: 'upsell' | 'default' | 'disabled'
   upsellDialogOpen: boolean
-  guardWithReleaseLimitUpsell: (callback: () => void, throwError?: boolean) => false | void
-  onReleaseLimitReached: (limit: number, suppressDialogOpening: boolean) => void
+  guardWithReleaseLimitUpsell: (callback: () => void, throwError?: boolean) => Promise<false | void>
+  onReleaseLimitReached: (limit: number) => void
   telemetryLogs: {
     dialogSecondaryClicked: () => void
     dialogPrimaryClicked: () => void

packages/sanity/src/core/releases/contexts/upsell/useReleasesUpsell.ts

@@ -19,7 +19,7 @@ const FALLBACK_CONTEXT_VALUE = {
   upsellDialogOpen: false,
   mode: 'default' as const,
   onReleaseLimitReached: () => null,
-  guardWithReleaseLimitUpsell: () => undefined,
+  guardWithReleaseLimitUpsell: async () => undefined,
   telemetryLogs: {
     dialogSecondaryClicked: () => null,
     dialogPrimaryClicked: () => null,

packages/sanity/src/core/releases/hooks/useIsReleasesPlus.ts

@@ -0,0 +1,21 @@
+import {useObservable} from 'react-rx'
+
+import {useClient} from '../../hooks/useClient'
+import {useReleaseLimits} from '../store/useReleaseLimits'
+
+/**
+ * @internal
+ * @returns `boolean` Whether the current org is on a Releases+ plan
+ */
+export const useIsReleasesPlus = (): boolean => {
+  const client = useClient().observable
+  const {releaseLimits$} = useReleaseLimits(client)
+
+  const releaseLimit = useObservable(releaseLimits$, null)
+
+  const {orgActiveReleaseLimit, defaultOrgActiveReleaseLimit = 0} = releaseLimit || {}
+
+  // presume not releases+ if null releaseLimit
+  // (because of internal server error or network error)
+  return !!orgActiveReleaseLimit && orgActiveReleaseLimit >= defaultOrgActiveReleaseLimit
+}

packages/sanity/src/core/releases/store/__tests__/createReleasePermissionsStore.test.ts

@@ -1,25 +1,28 @@
-import {beforeEach, describe, expect, it, vi} from 'vitest'
+import {describe, expect, it, vi} from 'vitest'
 
 import {createReleasePermissionsStore} from '../createReleasePermissionsStore'
-import {type useReleasePermissionsValue} from '../useReleasePermissions'
-
-const createStore = () => createReleasePermissionsStore()
 
 describe('useReleasePermissions', () => {
-  let store: useReleasePermissionsValue
+  describe('when content release feature is enabled', () => {
+    it('should return true when action succeeds', async () => {
+      const mockAction = vi.fn().mockResolvedValueOnce(undefined)
+      const result = await createReleasePermissionsStore(true).checkWithPermissionGuard(mockAction)
 
-  beforeEach(() => {
-    store = createStore()
+      expect(result).toBe(true)
+      expect(mockAction).toHaveBeenCalledWith({
+        dryRun: true,
+        skipCrossDatasetReferenceValidation: true,
+      })
+    })
   })
 
-  it('should return true when action succeeds', async () => {
-    const mockAction = vi.fn().mockResolvedValueOnce(undefined)
-    const result = await store.checkWithPermissionGuard(mockAction)
+  describe('when content release feature is disabled', () => {
+    it('should allow permissions', async () => {
+      const mockAction = vi.fn()
+      const result = await createReleasePermissionsStore(false).checkWithPermissionGuard(mockAction)
 
-    expect(result).toBe(true)
-    expect(mockAction).toHaveBeenCalledWith({
-      dryRun: true,
-      skipCrossDatasetReferenceValidation: true,
+      expect(result).toBe(true)
+      expect(mockAction).not.toHaveBeenCalled()
     })
   })
 })

packages/sanity/src/core/releases/store/createReleaseOperationStore.ts

@@ -355,9 +355,11 @@ export function createRequestAction(
         },
       })
     } catch (e) {
-      if (isReleaseLimitError(e)) {
+      // if dryRunning then essentially this is a silent request
+      // so don't want to create disruptive upsell because of limit
+      if (!options?.dryRun && isReleaseLimitError(e)) {
         // free accounts do not return limit, 0 is implied
-        onReleaseLimitReached(e.details.limit || 0, !!options?.dryRun)
+        onReleaseLimitReached(e.details.limit || 0)
       }
 
       throw e

packages/sanity/src/core/releases/store/createReleasePermissionsStore.ts

@@ -22,7 +22,9 @@ export const isReleasePermissionError = (error: unknown): error is ReleasePermis
  *
  * @internal
  */
-export function createReleasePermissionsStore(): useReleasePermissionsValue {
+export function createReleasePermissionsStore(
+  isContentReleasesEnabled: boolean,
+): useReleasePermissionsValue {
   let permissions: {[key: string]: boolean} = {}
 
   /**
@@ -36,6 +38,14 @@ export function createReleasePermissionsStore(): useReleasePermissionsValue {
     action: T,
     ...args: Parameters<T>
   ): Promise<boolean> => {
+    if (!isContentReleasesEnabled) {
+      /**
+       * When content releases feature flag is disabled
+       * assume allowed permissions to provide upsell
+       */
+      return true
+    }
+
     if (permissions[action.name] === undefined) {
       try {
         await action(...args, {