import { createTwoTierCache, type SharedStore, type TwoTierCache } from "@hivegrid/shared-store"; import { getSharedStore } from "~/shared-store.server"; import { clearCacheKey } from "~/utils/cache.server"; import { createScopedLogger } from "~/utils/logger.server"; const log = createScopedLogger("permission-cache"); // Pub/sub is the primary revocation path. The short TTL is the safety net for // a replica that was disconnected while an invalidation was published. const AUTHORIZATION_CACHE_TTL_SECONDS = 30; const ADMIN_SCOPE_KEY = "__admin__"; export type PermissionCache = TwoTierCache; let cacheSingleton: PermissionCache | null = null; let subscribeDisposer: (() => Promise) | null = null; function permissionCacheKey(userId: string, tenantId: string | null): string { return `${userId}:${tenantId ?? ADMIN_SCOPE_KEY}`; } function legacyPermissionCacheKey(userId: string, tenantId: string | null): string { return `userRoles:${userId}:${tenantId}`; } function pubsubEnabledFromEnv(): boolean { const raw = process.env.CACHE_INVALIDATION_ENABLED; if (raw === undefined || raw === null || raw === "") return true; return raw.toLowerCase() !== "false" && raw !== "0"; } export function createPermissionCache(store: SharedStore): PermissionCache { return createTwoTierCache({ store, namespace: "user-permissions", ttlSeconds: AUTHORIZATION_CACHE_TTL_SECONDS, pubsubEnabled: pubsubEnabledFromEnv(), logger: { warn: (obj, msg) => log.warn(obj, msg), info: (obj, msg) => log.info(obj, msg), error: (obj, msg) => log.error(obj, msg), }, }); } export function getPermissionCache(): PermissionCache { if (!cacheSingleton) { cacheSingleton = createPermissionCache(getSharedStore()); } return cacheSingleton; } export async function getCachedPermissionNames(userId: string, tenantId: string | null): Promise { try { const cached = await getPermissionCache().get(permissionCacheKey(userId, tenantId)); return cached === null ? null : [...cached]; } catch (error) { // Cache availability must not become an authorization availability // dependency. The caller falls back to the authoritative database. log.warn( { op: "permission-cache.read", err: { name: error instanceof Error ? error.name : "Error" } }, "Permission cache read failed; falling back to the database." ); return null; } } export async function cachePermissionNames(userId: string, tenantId: string | null, permissionNames: readonly string[]): Promise { try { await getPermissionCache().set(permissionCacheKey(userId, tenantId), [...permissionNames]); return true; } catch (error) { log.warn( { op: "permission-cache.write", err: { name: error instanceof Error ? error.name : "Error" } }, "Permission cache write failed; continuing with the database result." ); return false; } } /** * Invalidates one authorization scope locally, in shared L2, and on every * subscribed web replica. Publish errors propagate: callers changing roles * must not report success while peer replicas could still hold a stale grant. */ export async function invalidateUserPermissionCache(userId: string, tenantId: string | null): Promise { const key = permissionCacheKey(userId, tenantId); clearCacheKey(legacyPermissionCacheKey(userId, tenantId)); const cache = getPermissionCache(); cache.deleteLocal(key); try { await cache.l2.invalidate(key); } catch (error) { log.error( { op: "permission-cache.invalidate", err: { name: error instanceof Error ? error.name : "Error" } }, "Permission cache invalidation could not be published." ); throw error; } } export async function invalidateUserPermissionCacheScopes(scopes: readonly { userId: string; tenantId: string | null }[]): Promise { const unique = [...new Map(scopes.map((scope) => [permissionCacheKey(scope.userId, scope.tenantId), scope])).values()]; if (unique.length === 0) return; if (unique.length === 1) { const scope = unique[0]!; await invalidateUserPermissionCache(scope.userId, scope.tenantId); return; } const cache = getPermissionCache(); const keys = unique.map((scope) => permissionCacheKey(scope.userId, scope.tenantId)); unique.forEach((scope) => { clearCacheKey(legacyPermissionCacheKey(scope.userId, scope.tenantId)); cache.deleteLocal(permissionCacheKey(scope.userId, scope.tenantId)); }); try { // Delete every affected shared snapshot, then use one wildcard broadcast // to flush peer L1s. This avoids one PUBLISH per user on large roles. await Promise.all(keys.map((key) => cache.l2.delete(key))); await cache.l2.invalidate("*"); } catch (error) { log.error( { op: "permission-cache.invalidate-many", err: { name: error instanceof Error ? error.name : "Error" } }, "Permission cache invalidation batch could not be published." ); throw error; } } export async function subscribePermissionCache(): Promise<() => Promise> { if (subscribeDisposer) return subscribeDisposer; subscribeDisposer = await getPermissionCache().subscribe(); log.info({ namespace: "user-permissions" }, "Permission cache subscriber started."); return subscribeDisposer; } /** Test seam. */ export function __resetPermissionCacheForTests(): void { cacheSingleton = null; subscribeDisposer = null; }