fix(auth): ensure that authStore is a true shared resource store (#371)

Author: ryanbonial

packages/core/src/auth/authStore.ts

@@ -157,6 +157,7 @@ export interface AuthStoreState {
 
 export const authStore = createResource<AuthStoreState>({
   name: 'Auth',
+  isShared: true,
   getInitialState(instance) {
     const {
       apiHost,

packages/core/src/resources/createResource.ts

@@ -7,6 +7,14 @@ import {getEnv} from '../utils/getEnv'
 
 const resourceCache = new WeakMap<SdkIdentity, Map<string, InitializedResource<unknown>>>()
 
+// Create a singleton identity for the shared auth store
+const SHARED_IDENTITY: SdkIdentity = {
+  id: 'shared',
+  resourceId: 'shared.shared',
+  projectId: 'shared',
+  dataset: 'shared',
+} as const
+
 type Teardown = () => void
 
 export interface Resource<TState> {
@@ -16,6 +24,7 @@ export interface Resource<TState> {
     this: {instance: SanityInstance; state: ResourceState<TState>},
     instance: SanityInstance,
   ) => Teardown
+  isShared?: boolean
 }
 
 export function createResource<TState>(resource: Resource<TState>): Resource<TState> {
@@ -62,8 +71,9 @@ export function initializeResource<TState>(
   instance: SanityInstance,
   resource: Resource<TState>,
 ): InitializedResource<TState> {
-  const fullName =
-    resource.name === 'Auth' ? 'Auth-global' : `${resource.name}-${instance.identity.resourceId}`
+  const fullName = resource.isShared
+    ? `${resource.name}-shared`
+    : `${resource.name}-${instance.identity.resourceId}`
   const initialState = resource.getInitialState(instance)
   const state = createResourceState(initialState, {
     name: fullName,
@@ -74,16 +84,30 @@ export function initializeResource<TState>(
   return {state, dispose}
 }
 
+// Track which instances are using which shared resources
+const instanceSharedResources = new Map<SdkIdentity, Set<string>>()
+
 export function getOrCreateResource<TState>(
   instance: SanityInstance,
   resource: Resource<TState>,
 ): InitializedResource<TState> {
-  const fullName =
-    resource.name === 'Auth' ? 'Auth-global' : `${resource.name}-${instance.identity.resourceId}`
-  if (!resourceCache.has(instance.identity)) {
-    resourceCache.set(instance.identity, new Map())
+  const identityKey = resource.isShared ? SHARED_IDENTITY : instance.identity
+  const fullName = resource.isShared
+    ? `${resource.name}-shared`
+    : `${resource.name}-${instance.identity.resourceId}`
+
+  if (resource.isShared) {
+    // Track that this instance is using this shared resource
+    if (!instanceSharedResources.has(instance.identity)) {
+      instanceSharedResources.set(instance.identity, new Set())
+    }
+    instanceSharedResources.get(instance.identity)!.add(fullName)
   }
-  const initializedResources = resourceCache.get(instance.identity)!
+
+  if (!resourceCache.has(identityKey)) {
+    resourceCache.set(identityKey, new Map())
+  }
+  const initializedResources = resourceCache.get(identityKey)!
   const cached = initializedResources.get(fullName)
   if (cached) return cached as InitializedResource<TState>
 
@@ -93,10 +117,50 @@ export function getOrCreateResource<TState>(
 }
 
 export function disposeResources(identity: SdkIdentity): void {
+  // Handle instance-specific resources (not shared)
   const resources = resourceCache.get(identity)
-  if (!resources) return
+  if (resources) {
+    for (const resource of resources.values()) {
+      resource.dispose()
+    }
+    resourceCache.delete(identity)
+  }
+
+  // Handle shared resources this instance may have been using
+  const usedSharedResources = instanceSharedResources.get(identity)
+  if (usedSharedResources) {
+    const sharedResources = resourceCache.get(SHARED_IDENTITY)
+    if (sharedResources) {
+      for (const fullName of usedSharedResources) {
+        const resource = sharedResources.get(fullName)
+        if (resource) {
+          // Remove this instance from tracking
+          usedSharedResources.delete(fullName)
+
+          // Check if any other instances are still using this shared resource
+          let stillInUse = false
+          for (const [otherIdentity, otherUsed] of instanceSharedResources.entries()) {
+            if (otherIdentity !== identity && otherUsed.has(fullName)) {
+              stillInUse = true
+              break
+            }
+          }
+
+          // If no other instances are using it, dispose and clean up
+          if (!stillInUse) {
+            resource.dispose()
+            sharedResources.delete(fullName)
+          }
+        }
+      }
+
+      // Clean up shared resources map if empty
+      if (sharedResources.size === 0) {
+        resourceCache.delete(SHARED_IDENTITY)
+      }
+    }
 
-  for (const resource of resources.values()) {
-    resource.dispose()
+    // Clean up instance tracking
+    instanceSharedResources.delete(identity)
   }
 }