@tumbaland/frontend-core 1.7.0 → 1.9.0

package/dist/authService.js

@@ -1,5 +1,30 @@
 import { getCorrelationId, getSessionId, logger } from './monitoring';
+import { clearSessionScopedStorage } from './sessionStorage';
 const AUTH_CACHE_TTL = 5 * 60 * 1000;
+/**
+ * Tell the shell its session just ended.
+ *
+ * Each app runs in the shell's iframe with its own copy of this module, so a
+ * logout inside the frame clears only the frame's cache and reloads only the
+ * frame. The shell keeps serving its own five-minute-old `authenticated:
+ * true` from memory, which is why signing out and clicking home still showed
+ * the signed-in page instead of the landing page.
+ *
+ * The message carries nothing, so `'*'` gives nothing away; the shell is the
+ * side that authenticates it, by origin and by frame (see `useShellBridge`).
+ */
+function notifyShellOfLogout() {
+    if (typeof window === 'undefined' || window.parent === window.self)
+        return;
+    try {
+        // Contract lives in @tumbaland/components `routing/messages` — a lower
+        // layer cannot import it, so the literal is repeated here.
+        window.parent.postMessage({ source: 'tumbaland-app', type: 'app:logout' }, '*');
+    }
+    catch (error) {
+        logger.warn('Failed to notify shell of logout', { error });
+    }
+}
 function authHeaders() {
     return {
         'Content-Type': 'application/json',
@@ -81,6 +106,8 @@ export function createAuthService(config) {
                 if (data.success) {
                     authCache = null;
                     authCacheTime = 0;
+                    clearSessionScopedStorage();
+                    notifyShellOfLogout();
                     window.location.reload();
                 }
                 return data.success;

package/dist/entitlementsService.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The caller's own plan, limits and live meter readings.
+ *
+ * **The vocabulary is duplicated from `@tumbaland/backend-core`; the numbers
+ * never are.** A browser bundle cannot import backend-core — it pulls in
+ * mongoose — so the meter *keys* are restated here. That is a deliberate line:
+ * duplicating the key names costs a rename, while duplicating the limits would
+ * recreate exactly the defect Phase 0 removed, where `PlansPage` advertised six
+ * ceilings that no service enforced. Every number below arrives from the API at
+ * runtime, resolved by the same `normalizeLimits` the middleware enforces from.
+ */
+export type MeterKey = 'storageBytes' | 'aiJobs' | 'trackedTickers' | 'seats';
+export type FeatureKey = 'cleanExport';
+/** Matches `UNLIMITED` in backend-core. Chosen over `Infinity` because it survives JSON. */
+export declare const UNLIMITED = -1;
+export interface PlanLimits {
+    meters: Record<MeterKey, number>;
+    features: Record<FeatureKey, boolean>;
+    /** How far back reads may reach. `-1` means the full history. */
+    retentionDays: number;
+}
+export interface Entitlements {
+    email: string;
+    planCode: string;
+    /** Subscription status backing the plan; `null` on the implicit free plan. */
+    status: string | null;
+    limits: PlanLimits;
+    /** Cheapest active plan priced above the current one, for an upgrade CTA. */
+    upgradeTo?: string;
+    /** Granted by an admin rather than bought — render as "Complimentary". */
+    isComp?: boolean;
+    hasOverride?: boolean;
+    /** Live meter readings, same keys as `limits.meters`. */
+    usage: Record<MeterKey, number>;
+}
+export interface EntitlementsServiceConfig {
+    /** Read fresh at call time (config may not be resolved yet at module load). */
+    getPaymentApiUrl: () => string;
+    onUnauthorized?: () => void;
+}
+/**
+ * Builds a per-front entitlements service.
+ *
+ *   export const { getMyEntitlements } = createEntitlementsService({
+ *     getPaymentApiUrl: () => getGlobalConfig().PAYMENT_API_URL!
+ *   });
+ */
+export declare function createEntitlementsService(config: EntitlementsServiceConfig): {
+    getMyEntitlements(): Promise<Entitlements>;
+};
+export type EntitlementsService = ReturnType<typeof createEntitlementsService>;
+/** True when a meter has no ceiling. */
+export declare function isUnlimited(limit: number): boolean;
+/**
+ * Share of a meter consumed, 0–1, clamped. Unlimited meters report 0 — there is
+ * no ceiling to be a fraction of, and reporting 1 would paint them as full.
+ */
+export declare function usageRatio(used: number, limit: number): number;

package/dist/entitlementsService.js

@@ -0,0 +1,53 @@
+import { createApiClient } from './apiClient';
+/** Matches `UNLIMITED` in backend-core. Chosen over `Infinity` because it survives JSON. */
+export const UNLIMITED = -1;
+const ZERO_USAGE = {
+    storageBytes: 0,
+    aiJobs: 0,
+    trackedTickers: 0,
+    seats: 0
+};
+/**
+ * Builds a per-front entitlements service.
+ *
+ *   export const { getMyEntitlements } = createEntitlementsService({
+ *     getPaymentApiUrl: () => getGlobalConfig().PAYMENT_API_URL!
+ *   });
+ */
+export function createEntitlementsService(config) {
+    const client = createApiClient({
+        baseUrl: () => config.getPaymentApiUrl(),
+        onUnauthorized: config.onUnauthorized
+    });
+    return {
+        async getMyEntitlements() {
+            const body = await client.get('/api/subscriptions/me/entitlements');
+            // Reject rather than return a half-built object. Without `limits` there
+            // is no ceiling to meter against, and handing back a truthy
+            // `Entitlements` whose `limits` is undefined pushes the crash into every
+            // call site's property access instead of failing here, once.
+            if (!body?.limits?.meters) {
+                throw new Error('Entitlements response is missing limits');
+            }
+            return {
+                ...body,
+                // A meter with no counter yet is simply absent from the snapshot, which
+                // would otherwise render as `undefined of 1 GB`.
+                usage: { ...ZERO_USAGE, ...(body.usage ?? {}) }
+            };
+        }
+    };
+}
+/** True when a meter has no ceiling. */
+export function isUnlimited(limit) {
+    return limit === UNLIMITED || limit < 0;
+}
+/**
+ * Share of a meter consumed, 0–1, clamped. Unlimited meters report 0 — there is
+ * no ceiling to be a fraction of, and reporting 1 would paint them as full.
+ */
+export function usageRatio(used, limit) {
+    if (isUnlimited(limit) || limit === 0)
+        return 0;
+    return Math.min(1, Math.max(0, used / limit));
+}

package/dist/index.d.ts

@@ -4,6 +4,9 @@ export { createAuthService, createAppAuthService } from './authService';
 export type { AuthServiceConfig, AuthService, AppAuthConfig } from './authService';
 export { createGroupService } from './groupService';
 export type { GroupServiceConfig, GroupService } from './groupService';
+export { createEntitlementsService, isUnlimited, usageRatio, UNLIMITED } from './entitlementsService';
+export type { EntitlementsServiceConfig, EntitlementsService, Entitlements, PlanLimits, MeterKey, FeatureKey } from './entitlementsService';
 export type { User, AuthResponse, Group, ApiResponse } from './types';
+export { TENANT_STORAGE_KEY, clearSessionScopedStorage } from './sessionStorage';
 export { initMonitoring, captureException, captureMessage, setUser, setTag, startTransaction, recordMetric, initWebVitals, flushLogs, initConsoleInterception, generateCorrelationId, getCorrelationId, getSessionId, logger } from './monitoring';
 export type { MonitoringConfig } from './monitoring';

package/dist/index.js

@@ -2,5 +2,7 @@
 export { createApiClient, ApiError } from './apiClient';
 export { createAuthService, createAppAuthService } from './authService';
 export { createGroupService } from './groupService';
+export { createEntitlementsService, isUnlimited, usageRatio, UNLIMITED } from './entitlementsService';
+export { TENANT_STORAGE_KEY, clearSessionScopedStorage } from './sessionStorage';
 // Monitoring: headless logging, error capture, correlation IDs, and web-vitals
 export { initMonitoring, captureException, captureMessage, setUser, setTag, startTransaction, recordMetric, initWebVitals, flushLogs, initConsoleInterception, generateCorrelationId, getCorrelationId, getSessionId, logger } from './monitoring';

package/dist/sessionStorage.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Browser storage that belongs to the signed-in session rather than to the
+ * browser.
+ *
+ * localStorage is scoped per origin, so anything written here outlives a
+ * sign-out and is handed to whoever signs in next. For preferences that is
+ * fine — for anything the backend authorizes against, it is a bug: the
+ * incoming account sends the previous account's context and gets 403s it
+ * cannot explain, from a UI that looks correctly configured.
+ *
+ * `logout()` clears every key listed here. Add a key to this list rather than
+ * clearing it at the call site, so a new front or a second logout button
+ * cannot miss it.
+ */
+/** Tenant (personal vs group) context — owned by `useTenant` in @tumbaland/components. */
+export declare const TENANT_STORAGE_KEY = "selectedTenant";
+export declare function clearSessionScopedStorage(): void;

package/dist/sessionStorage.js

@@ -0,0 +1,28 @@
+import { logger } from './monitoring';
+/**
+ * Browser storage that belongs to the signed-in session rather than to the
+ * browser.
+ *
+ * localStorage is scoped per origin, so anything written here outlives a
+ * sign-out and is handed to whoever signs in next. For preferences that is
+ * fine — for anything the backend authorizes against, it is a bug: the
+ * incoming account sends the previous account's context and gets 403s it
+ * cannot explain, from a UI that looks correctly configured.
+ *
+ * `logout()` clears every key listed here. Add a key to this list rather than
+ * clearing it at the call site, so a new front or a second logout button
+ * cannot miss it.
+ */
+/** Tenant (personal vs group) context — owned by `useTenant` in @tumbaland/components. */
+export const TENANT_STORAGE_KEY = 'selectedTenant';
+const SESSION_SCOPED_KEYS = [TENANT_STORAGE_KEY];
+export function clearSessionScopedStorage() {
+    for (const key of SESSION_SCOPED_KEYS) {
+        try {
+            localStorage.removeItem(key);
+        }
+        catch (err) {
+            logger.warn('Failed to clear session-scoped storage', { key, error: err });
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tumbaland/frontend-core",
-  "version": "1.7.0",
+  "version": "1.9.0",
   "description": "Shared frontend auth/group/API-client logic for Tumbaland frontends",
   "author": "Tumbaland",
   "license": "MIT",