@open-mercato/core 0.6.7-develop.6673.1.a9bf54a072 → 0.6.7-develop.6676.1.7dad6df292

package/src/modules/directory/api/organization-switcher/route.ts

@@ -6,12 +6,19 @@ import { Organization } from '@open-mercato/core/modules/directory/data/entities
 import { computeHierarchyForOrganizations, type ComputedHierarchy } from '@open-mercato/core/modules/directory/lib/hierarchy'
 import { isAllOrganizationsSelection } from '@open-mercato/core/modules/directory/constants'
 import {
+  buildOrgScopeTenantCacheTag,
   getSelectedOrganizationFromRequest,
   getSelectedTenantFromRequest,
   resolveOrganizationScope,
 } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { runWithCacheTenant, type CacheStrategy } from '@open-mercato/cache'
 import type { OpenApiMethodDoc, OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
-import { directoryTag, directoryErrorSchema, organizationSwitcherResponseSchema } from '../openapi'
+import {
+  directoryTag,
+  directoryErrorSchema,
+  directoryIdSchema,
+  organizationSwitcherResponseSchema,
+} from '../openapi'
 import { Tenant } from '@open-mercato/core/modules/directory/data/entities'
 import type { EntityManager } from '@mikro-orm/postgresql'
 import type { RbacService } from '@open-mercato/core/modules/auth/services/rbacService'
@@ -19,6 +26,21 @@ import type { FilterQuery } from '@mikro-orm/core'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 
 const logger = createLogger('directory').child({ component: 'organization-switcher' })
+const ORGANIZATION_SWITCHER_CACHE_TTL_MS = 60_000
+const organizationSwitcherCachePayloadSchema = organizationSwitcherResponseSchema.or(
+  organizationSwitcherResponseSchema.pick({
+    items: true,
+    selectedId: true,
+    canManage: true,
+  }),
+)
+
+function buildSelectionCacheKeyPart(rawSelected: string | null): string | null {
+  if (isAllOrganizationsSelection(rawSelected)) return 'mode:all'
+  if (rawSelected === null) return 'mode:none'
+  const parsedOrganizationId = directoryIdSchema.safeParse(rawSelected)
+  return parsedOrganizationId.success ? `org:${parsedOrganizationId.data.toLowerCase()}` : null
+}
 
 type OrganizationMenuNode = {
   id: string
@@ -141,6 +163,49 @@ export async function GET(req: NextRequest) {
       })
     }
 
+    const rawSelected = getSelectedOrganizationFromRequest(req)
+    const requestedAll = isAllOrganizationsSelection(rawSelected)
+    const selectedKeyPart = buildSelectionCacheKeyPart(rawSelected)
+    const cacheKey = selectedKeyPart
+      ? `org-switcher:v1:${auth.sub}:${tenantId}:${selectedKeyPart}`
+      : null
+    let cache: CacheStrategy | null = null
+    if (!actorIsSuperAdmin && cacheKey) {
+      try {
+        cache = container.resolve<CacheStrategy>('cache')
+      } catch {
+        cache = null
+      }
+    }
+
+    const logAccess = async (payload: { items: unknown[]; selectedId: string | null }) => {
+      await logCrudAccess({
+        container,
+        auth,
+        request: req,
+        items: payload.items,
+        idField: 'id',
+        resourceKind: 'directory.organization_switcher',
+        organizationId: payload.selectedId,
+        tenantId,
+        query: Object.fromEntries(url.searchParams.entries()),
+      })
+    }
+
+    if (cache && cacheKey) {
+      const activeCache = cache
+      try {
+        const cached = await runWithCacheTenant(tenantId, () => activeCache.get(cacheKey))
+        const parsedCached = organizationSwitcherCachePayloadSchema.safeParse(cached)
+        if (parsedCached.success) {
+          await logAccess(parsedCached.data)
+          return NextResponse.json(parsedCached.data)
+        }
+      } catch (err) {
+        logger.warn('Failed to read organization switcher cache', { err })
+      }
+    }
+
     const scopedOrgId = actorTenantId && actorTenantId === tenantId ? auth.orgId ?? null : null
     const acl = await rbac.loadAcl(auth.sub, { tenantId, organizationId: scopedOrgId })
     const aclIsSuperAdmin = acl?.isSuperAdmin === true
@@ -163,9 +228,7 @@ export async function GET(req: NextRequest) {
       { orderBy: { name: 'ASC' } },
     )
     const hierarchy = computeHierarchyForOrganizations(orgEntities, tenantId)
-    const rawSelected = getSelectedOrganizationFromRequest(req)
     let hasSelectionCookie = rawSelected !== null
-    const requestedAll = isAllOrganizationsSelection(rawSelected)
     const scope = await resolveOrganizationScope({
       em,
       rbac,
@@ -194,32 +257,40 @@ export async function GET(req: NextRequest) {
     }
 
     const showMenu = menuData.nodes.length > 0 || hasManageFeature || effectiveIsSuperAdmin
-    if (!showMenu) {
-      return NextResponse.json({ items: [], selectedId: null, canManage: false })
-    }
+    const response = showMenu
+      ? {
+          items: menuData.nodes,
+          selectedId,
+          canManage: !!hasManageFeature,
+          canViewAllOrganizations: accessible === null,
+          tenantId,
+          tenants: tenantRecords,
+          isSuperAdmin: effectiveIsSuperAdmin,
+        }
+      : {
+          items: [],
+          selectedId: null,
+          canManage: false,
+        }
 
-    const canViewAllOrganizations = accessible === null
-    const response = {
-      items: menuData.nodes,
-      selectedId,
-      canManage: !!hasManageFeature,
-      canViewAllOrganizations,
-      tenantId,
-      tenants: tenantRecords,
-      isSuperAdmin: effectiveIsSuperAdmin,
+    if (cache && cacheKey) {
+      const activeCache = cache
+      try {
+        await runWithCacheTenant(tenantId, () =>
+          activeCache.set(cacheKey, response, {
+            ttl: ORGANIZATION_SWITCHER_CACHE_TTL_MS,
+            tags: [
+              buildOrgScopeTenantCacheTag(tenantId),
+              `rbac:user:${auth.sub}`,
+            ],
+          }),
+        )
+      } catch (err) {
+        logger.warn('Failed to write organization switcher cache', { err })
+      }
     }
 
-    await logCrudAccess({
-      container,
-      auth,
-      request: req,
-      items: response.items,
-      idField: 'id',
-      resourceKind: 'directory.organization_switcher',
-      organizationId: response.selectedId,
-      tenantId,
-      query: Object.fromEntries(url.searchParams.entries()),
-    })
+    await logAccess(response)
 
     return NextResponse.json(response)
   } catch (err) {

package/src/modules/directory/subscribers/invalidateOrgScopeCache.ts

@@ -8,6 +8,7 @@
 // for races where the event fires after a request reads the cache.
 
 import { buildOrgScopeTenantCacheTag } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import { runWithCacheTenant } from '@open-mercato/cache'
 
 type CacheService = {
   deleteByTags(tags: string[]): Promise<number>
@@ -34,7 +35,9 @@ export default async function handle(
   }
   if (!cache) return
   try {
-    await cache.deleteByTags([buildOrgScopeTenantCacheTag(tenantId)])
+    await runWithCacheTenant(tenantId, () =>
+      cache.deleteByTags([buildOrgScopeTenantCacheTag(tenantId)]),
+    )
   } catch {
     // best-effort; TTL is the backstop.
   }

package/src/modules/directory/utils/organizationScope.ts

@@ -5,7 +5,7 @@ import { Organization } from '@open-mercato/core/modules/directory/data/entities
 import { isAllOrganizationsSelection } from '@open-mercato/core/modules/directory/constants'
 import type { RbacService } from '@open-mercato/core/modules/auth/services/rbacService'
 import type { AuthContext } from '@open-mercato/shared/lib/auth/server'
-import type { CacheStrategy } from '@open-mercato/cache'
+import { getCurrentCacheTenant, runWithCacheTenant, type CacheStrategy } from '@open-mercato/cache'
 import { parseSelectedOrganizationCookie, parseSelectedTenantCookie } from './scopeCookies'
 import { createLogger } from '@open-mercato/shared/lib/logger'
 
@@ -104,11 +104,15 @@ function resolveCacheFromContainer(container: AwilixContainer | null | undefined
 export async function invalidateOrganizationScopeCacheForUser(
   container: AwilixContainer,
   userId: string,
+  tenantId?: string | null,
 ): Promise<void> {
   const cache = resolveCacheFromContainer(container)
   if (!cache?.deleteByTags) return
   try {
-    await cache.deleteByTags([buildOrgScopeUserCacheTag(userId)])
+    const cacheTenantId = tenantId === undefined ? getCurrentCacheTenant() : tenantId
+    await runWithCacheTenant(cacheTenantId, () =>
+      cache.deleteByTags([buildOrgScopeUserCacheTag(userId)]),
+    )
   } catch (err) {
     logger.warn('Cache invalidate user failed', { err })
   }
@@ -121,7 +125,9 @@ export async function invalidateOrganizationScopeCacheForTenant(
   const cache = resolveCacheFromContainer(container)
   if (!cache?.deleteByTags) return
   try {
-    await cache.deleteByTags([buildOrgScopeTenantCacheTag(tenantId)])
+    await runWithCacheTenant(tenantId, () =>
+      cache.deleteByTags([buildOrgScopeTenantCacheTag(tenantId)]),
+    )
   } catch (err) {
     logger.warn('Cache invalidate tenant failed', { err })
   }