@qwickapps/server 1.4.0 → 1.5.1

package/src/plugins/users/__tests__/postgres-store.test.ts

@@ -0,0 +1,326 @@
+/**
+ * PostgreSQL User Store Tests
+ *
+ * Unit tests for the PostgreSQL user store implementation,
+ * focusing on getByIdentifier() and linkIdentifiers() methods.
+ *
+ * Copyright (c) 2025 QwickApps.com. All rights reserved.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { postgresUserStore } from '../stores/postgres-store.js';
+import type { User, UserIdentifiers } from '../types.js';
+
+// Mock user data
+const mockUser: User = {
+  id: 'test-user-id-123',
+  email: 'test@example.com',
+  name: 'Test User',
+  external_id: 'auth0|abc123',
+  provider: 'auth0',
+  picture: 'https://example.com/avatar.jpg',
+  metadata: {
+    identifiers: {
+      auth0_user_id: 'auth0|abc123',
+      wp_user_id: 42,
+      keap_contact_id: 12345,
+    },
+  },
+  created_at: new Date('2025-01-01'),
+  updated_at: new Date('2025-01-01'),
+  last_login_at: new Date('2025-12-13'),
+};
+
+// Mock pg pool
+const createMockPool = () => {
+  const mockQuery = vi.fn();
+  return {
+    query: mockQuery,
+    _mockQuery: mockQuery, // Expose for test assertions
+  };
+};
+
+describe('PostgreSQL User Store', () => {
+  let mockPool: ReturnType<typeof createMockPool>;
+  let store: ReturnType<typeof postgresUserStore>;
+
+  beforeEach(() => {
+    mockPool = createMockPool();
+    store = postgresUserStore({
+      pool: mockPool as any,
+      autoCreateTables: false, // Skip table creation in tests
+    });
+  });
+
+  describe('getByIdentifier()', () => {
+    it('should throw error when no identifier is provided (UT-001)', async () => {
+      const emptyIdentifiers: UserIdentifiers = {};
+
+      await expect(store.getByIdentifier(emptyIdentifiers)).rejects.toThrow(
+        'At least one identifier must be provided'
+      );
+
+      // Should not make any DB queries
+      expect(mockPool._mockQuery).not.toHaveBeenCalled();
+    });
+
+    it('should find user by email first (priority 1) (UT-002)', async () => {
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [mockUser] });
+
+      const identifiers: UserIdentifiers = {
+        email: 'test@example.com',
+        auth0_user_id: 'auth0|abc123',
+        wp_user_id: 42,
+      };
+
+      const result = await store.getByIdentifier(identifiers);
+
+      expect(result).toEqual(mockUser);
+      expect(mockPool._mockQuery).toHaveBeenCalledTimes(1);
+      expect(mockPool._mockQuery).toHaveBeenCalledWith(
+        expect.stringContaining('LOWER(email) = LOWER($1)'),
+        ['test@example.com']
+      );
+    });
+
+    it('should find user by auth0_user_id if email not found (priority 2) (UT-003)', async () => {
+      // Email query returns no results
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [] });
+      // auth0_user_id query in metadata returns user
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [mockUser] });
+
+      const identifiers: UserIdentifiers = {
+        email: 'nonexistent@example.com',
+        auth0_user_id: 'auth0|abc123',
+      };
+
+      const result = await store.getByIdentifier(identifiers);
+
+      expect(result).toEqual(mockUser);
+      expect(mockPool._mockQuery).toHaveBeenCalledTimes(2);
+      expect(mockPool._mockQuery).toHaveBeenNthCalledWith(
+        2,
+        expect.stringContaining("metadata->'identifiers'->>'auth0_user_id'"),
+        ['auth0|abc123']
+      );
+    });
+
+    it('should check legacy external_id for auth0 users (UT-004)', async () => {
+      // No email provided, so skip email check
+      // auth0_user_id in metadata returns no results
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [] });
+      // Legacy external_id query returns user
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [mockUser] });
+
+      const identifiers: UserIdentifiers = {
+        auth0_user_id: 'auth0|abc123',
+      };
+
+      const result = await store.getByIdentifier(identifiers);
+
+      expect(result).toEqual(mockUser);
+      expect(mockPool._mockQuery).toHaveBeenCalledTimes(2);
+      expect(mockPool._mockQuery).toHaveBeenNthCalledWith(
+        2,
+        expect.stringContaining('external_id = $1'),
+        ['auth0|abc123']
+      );
+    });
+
+    it('should find user by wp_user_id (priority 3) (UT-005)', async () => {
+      // All higher priority queries return no results
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [] }); // email
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [] }); // auth0 metadata
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [] }); // auth0 external_id
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [mockUser] }); // wp_user_id
+
+      const identifiers: UserIdentifiers = {
+        email: 'nonexistent@example.com',
+        auth0_user_id: 'auth0|xyz',
+        wp_user_id: 42,
+      };
+
+      const result = await store.getByIdentifier(identifiers);
+
+      expect(result).toEqual(mockUser);
+      expect(mockPool._mockQuery).toHaveBeenNthCalledWith(
+        4,
+        expect.stringContaining("(metadata->'identifiers'->>'wp_user_id')::int"),
+        [42]
+      );
+    });
+
+    it('should find user by keap_contact_id (priority 4) (UT-006)', async () => {
+      // All higher priority queries return no results
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [] }); // wp_user_id
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [mockUser] }); // keap_contact_id
+
+      const identifiers: UserIdentifiers = {
+        wp_user_id: 999,
+        keap_contact_id: 12345,
+      };
+
+      const result = await store.getByIdentifier(identifiers);
+
+      expect(result).toEqual(mockUser);
+      expect(mockPool._mockQuery).toHaveBeenNthCalledWith(
+        2,
+        expect.stringContaining("(metadata->'identifiers'->>'keap_contact_id')::int"),
+        [12345]
+      );
+    });
+
+    it('should return null if no user found by any identifier (UT-007)', async () => {
+      // All queries return no results
+      mockPool._mockQuery.mockResolvedValue({ rows: [] });
+
+      const identifiers: UserIdentifiers = {
+        email: 'nonexistent@example.com',
+        auth0_user_id: 'auth0|nonexistent',
+        wp_user_id: 99999,
+        keap_contact_id: 99999,
+      };
+
+      const result = await store.getByIdentifier(identifiers);
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle wp_user_id of 0 as valid identifier (UT-008)', async () => {
+      // Only wp_user_id provided (no email or auth0_user_id)
+      // So only 1 query for wp_user_id should be made
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [mockUser] });
+
+      const identifiers: UserIdentifiers = {
+        wp_user_id: 0,
+      };
+
+      const result = await store.getByIdentifier(identifiers);
+
+      expect(result).toEqual(mockUser);
+      expect(mockPool._mockQuery).toHaveBeenCalledTimes(1);
+      expect(mockPool._mockQuery).toHaveBeenCalledWith(
+        expect.stringContaining("(metadata->'identifiers'->>'wp_user_id')::int"),
+        [0]
+      );
+    });
+
+    it('should handle keap_contact_id of 0 as valid identifier (UT-009)', async () => {
+      // Only keap_contact_id provided (no email, auth0_user_id, or wp_user_id)
+      // So only 1 query for keap_contact_id should be made
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [mockUser] });
+
+      const identifiers: UserIdentifiers = {
+        keap_contact_id: 0,
+      };
+
+      const result = await store.getByIdentifier(identifiers);
+
+      expect(result).toEqual(mockUser);
+      expect(mockPool._mockQuery).toHaveBeenCalledTimes(1);
+      expect(mockPool._mockQuery).toHaveBeenCalledWith(
+        expect.stringContaining("(metadata->'identifiers'->>'keap_contact_id')::int"),
+        [0]
+      );
+    });
+  });
+
+  describe('linkIdentifiers()', () => {
+    it('should not make DB query when no identifiers provided (UT-010)', async () => {
+      await store.linkIdentifiers('user-123', {});
+
+      expect(mockPool._mockQuery).not.toHaveBeenCalled();
+    });
+
+    it('should update metadata with single identifier (UT-011)', async () => {
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [], rowCount: 1 });
+
+      await store.linkIdentifiers('user-123', {
+        wp_user_id: 42,
+      });
+
+      expect(mockPool._mockQuery).toHaveBeenCalledTimes(1);
+      expect(mockPool._mockQuery).toHaveBeenCalledWith(
+        expect.stringContaining('jsonb_set'),
+        [JSON.stringify({ wp_user_id: 42 }), 'user-123']
+      );
+    });
+
+    it('should update metadata with multiple identifiers (UT-012)', async () => {
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [], rowCount: 1 });
+
+      await store.linkIdentifiers('user-123', {
+        wp_user_id: 42,
+        auth0_user_id: 'auth0|abc123',
+        keap_contact_id: 12345,
+      });
+
+      expect(mockPool._mockQuery).toHaveBeenCalledTimes(1);
+      const [, args] = mockPool._mockQuery.mock.calls[0];
+      const identifiersJson = JSON.parse(args[0] as string);
+
+      expect(identifiersJson).toEqual({
+        wp_user_id: 42,
+        auth0_user_id: 'auth0|abc123',
+        keap_contact_id: 12345,
+      });
+      expect(args[1]).toBe('user-123');
+    });
+
+    it('should preserve existing identifiers (uses COALESCE) (UT-013)', async () => {
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [], rowCount: 1 });
+
+      await store.linkIdentifiers('user-123', {
+        wp_user_id: 42,
+      });
+
+      // Verify the query uses COALESCE to preserve existing values
+      expect(mockPool._mockQuery).toHaveBeenCalledWith(
+        expect.stringContaining("COALESCE(metadata->'identifiers', '{}'::jsonb)"),
+        expect.any(Array)
+      );
+    });
+
+    it('should handle undefined values correctly (UT-014)', async () => {
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: [], rowCount: 1 });
+
+      await store.linkIdentifiers('user-123', {
+        wp_user_id: undefined,
+        auth0_user_id: 'auth0|abc123',
+        keap_contact_id: undefined,
+      });
+
+      expect(mockPool._mockQuery).toHaveBeenCalledTimes(1);
+      const [, args] = mockPool._mockQuery.mock.calls[0];
+      const identifiersJson = JSON.parse(args[0] as string);
+
+      // Should only include defined values
+      expect(identifiersJson).toEqual({
+        auth0_user_id: 'auth0|abc123',
+      });
+    });
+  });
+
+  describe('getByIds()', () => {
+    it('should return empty array for empty input (UT-015)', async () => {
+      const result = await store.getByIds([]);
+
+      expect(result).toEqual([]);
+      expect(mockPool._mockQuery).not.toHaveBeenCalled();
+    });
+
+    it('should batch query multiple users (UT-016)', async () => {
+      const mockUsers = [mockUser, { ...mockUser, id: 'user-2' }];
+      mockPool._mockQuery.mockResolvedValueOnce({ rows: mockUsers });
+
+      const result = await store.getByIds(['user-1', 'user-2']);
+
+      expect(result).toEqual(mockUsers);
+      expect(mockPool._mockQuery).toHaveBeenCalledTimes(1);
+      expect(mockPool._mockQuery).toHaveBeenCalledWith(
+        expect.stringContaining('id = ANY($1)'),
+        [['user-1', 'user-2']]
+      );
+    });
+  });
+});

package/src/plugins/users/__tests__/users-plugin.test.ts

@@ -54,8 +54,11 @@ describe('Users Plugin', () => {
     name: 'mock',
     initialize: vi.fn().mockResolvedValue(undefined),
     getById: vi.fn().mockResolvedValue(mockUser),
+    getByIds: vi.fn().mockResolvedValue([mockUser]),
     getByEmail: vi.fn().mockResolvedValue(mockUser),
     getByExternalId: vi.fn().mockResolvedValue(null),
+    getByIdentifier: vi.fn().mockResolvedValue(mockUser),
+    linkIdentifiers: vi.fn().mockResolvedValue(undefined),
     create: vi.fn().mockResolvedValue(mockUser),
     update: vi.fn().mockResolvedValue(mockUser),
     delete: vi.fn().mockResolvedValue(true),

package/src/plugins/users/index.ts

@@ -12,7 +12,10 @@ export {
   createUsersPlugin,
   getUserStore,
   getUserById,
+  getUsersByIds,
   getUserByEmail,
+  getUserByIdentifier,
+  linkUserIdentifiers,
   findOrCreateUser,
   buildUserInfo,
 } from './users-plugin.js';
@@ -32,6 +35,9 @@ export type {
   UsersUiConfig,
   UserInfo,
   UserSyncInput,
+  UserIdentifiers,
+  StoredIdentifiers,
+  UserProfileInput,
 } from './types.js';
 
 // Stores

package/src/plugins/users/stores/postgres-store.ts

@@ -17,6 +17,8 @@ import type {
   UserSearchParams,
   UserListResponse,
   PostgresUserStoreConfig,
+  UserIdentifiers,
+  StoredIdentifiers,
 } from '../types.js';
 
 // Pool interface (from pg package)
@@ -86,6 +88,12 @@ export function postgresUserStore(config: PostgresUserStoreConfig): UserStore {
       return (result.rows[0] as User) || null;
     },
 
+    async getByIds(ids: string[]): Promise<User[]> {
+      if (ids.length === 0) return [];
+      const result = await getPool().query(`SELECT * FROM ${usersTableFull} WHERE id = ANY($1)`, [ids]);
+      return result.rows as User[];
+    },
+
     async getByEmail(email: string): Promise<User | null> {
       const result = await getPool().query(`SELECT * FROM ${usersTableFull} WHERE LOWER(email) = LOWER($1)`, [
         email,
@@ -101,6 +109,102 @@ export function postgresUserStore(config: PostgresUserStoreConfig): UserStore {
       return (result.rows[0] as User) || null;
     },
 
+    async getByIdentifier(identifiers: UserIdentifiers): Promise<User | null> {
+      // Validate that at least one identifier is provided
+      const hasIdentifier =
+        identifiers.email ||
+        identifiers.auth0_user_id ||
+        identifiers.wp_user_id !== undefined ||
+        identifiers.keap_contact_id !== undefined;
+
+      if (!hasIdentifier) {
+        throw new Error('At least one identifier must be provided');
+      }
+
+      // Priority 1: Email (most reliable, always unique)
+      if (identifiers.email) {
+        const result = await getPool().query(
+          `SELECT * FROM ${usersTableFull} WHERE LOWER(email) = LOWER($1)`,
+          [identifiers.email]
+        );
+        if (result.rows[0]) return result.rows[0] as User;
+      }
+
+      // Priority 2: Auth0 user ID (stored in metadata.identifiers.auth0_user_id)
+      if (identifiers.auth0_user_id) {
+        const result = await getPool().query(
+          `SELECT * FROM ${usersTableFull}
+           WHERE metadata->'identifiers'->>'auth0_user_id' = $1`,
+          [identifiers.auth0_user_id]
+        );
+        if (result.rows[0]) return result.rows[0] as User;
+
+        // Also check legacy external_id field for backwards compatibility
+        const legacyResult = await getPool().query(
+          `SELECT * FROM ${usersTableFull} WHERE external_id = $1`,
+          [identifiers.auth0_user_id]
+        );
+        if (legacyResult.rows[0]) return legacyResult.rows[0] as User;
+      }
+
+      // Priority 3: WordPress user ID (stored in metadata.identifiers.wp_user_id)
+      // Note: Use !== undefined to allow 0 as a valid ID
+      if (identifiers.wp_user_id !== undefined) {
+        const result = await getPool().query(
+          `SELECT * FROM ${usersTableFull}
+           WHERE (metadata->'identifiers'->>'wp_user_id')::int = $1`,
+          [identifiers.wp_user_id]
+        );
+        if (result.rows[0]) return result.rows[0] as User;
+      }
+
+      // Priority 4: Keap contact ID (stored in metadata.identifiers.keap_contact_id)
+      // Note: Use !== undefined to allow 0 as a valid ID
+      if (identifiers.keap_contact_id !== undefined) {
+        const result = await getPool().query(
+          `SELECT * FROM ${usersTableFull}
+           WHERE (metadata->'identifiers'->>'keap_contact_id')::int = $1`,
+          [identifiers.keap_contact_id]
+        );
+        if (result.rows[0]) return result.rows[0] as User;
+      }
+
+      return null;
+    },
+
+    async linkIdentifiers(userId: string, identifiers: Partial<StoredIdentifiers>): Promise<void> {
+      // Build the identifiers object to merge
+      const identifiersToMerge: Record<string, unknown> = {};
+
+      if (identifiers.wp_user_id !== undefined) {
+        identifiersToMerge.wp_user_id = identifiers.wp_user_id;
+      }
+      if (identifiers.auth0_user_id !== undefined) {
+        identifiersToMerge.auth0_user_id = identifiers.auth0_user_id;
+      }
+      if (identifiers.keap_contact_id !== undefined) {
+        identifiersToMerge.keap_contact_id = identifiers.keap_contact_id;
+      }
+
+      if (Object.keys(identifiersToMerge).length === 0) {
+        return; // Nothing to update
+      }
+
+      // Merge new identifiers with existing ones using jsonb_set and coalesce
+      // This preserves existing identifiers while adding/updating new ones
+      await getPool().query(
+        `UPDATE ${usersTableFull}
+         SET metadata = jsonb_set(
+           COALESCE(metadata, '{}'::jsonb),
+           '{identifiers}',
+           COALESCE(metadata->'identifiers', '{}'::jsonb) || $1::jsonb
+         ),
+         updated_at = NOW()
+         WHERE id = $2`,
+        [JSON.stringify(identifiersToMerge), userId]
+      );
+    },
+
     async create(input: CreateUserInput): Promise<User> {
       const result = await getPool().query(
         `INSERT INTO ${usersTableFull} (email, name, external_id, provider, picture, metadata)

package/src/plugins/users/types.ts

@@ -56,6 +56,32 @@ export interface UpdateUserInput {
   metadata?: Record<string, unknown>;
 }
 
+/**
+ * Known user identifiers for multi-system lookup.
+ * Users can be looked up by any of these identifiers.
+ * At least one identifier must be provided for lookup.
+ */
+export interface UserIdentifiers {
+  /** User's email address (most reliable) */
+  email?: string;
+  /** WordPress user ID */
+  wp_user_id?: number;
+  /** Auth0 user ID (sub claim, e.g., "auth0|123" or "google-oauth2|456") */
+  auth0_user_id?: string;
+  /** Keap CRM contact ID */
+  keap_contact_id?: number;
+}
+
+/**
+ * Stored identifiers in user metadata.
+ * These are stored in metadata.identifiers for multi-system linking.
+ */
+export interface StoredIdentifiers {
+  wp_user_id?: number;
+  auth0_user_id?: string;
+  keap_contact_id?: number;
+}
+
 /**
  * User search parameters
  */
@@ -102,6 +128,11 @@ export interface UserStore {
    */
   getById(id: string): Promise<User | null>;
 
+  /**
+   * Get multiple users by IDs (batch query)
+   */
+  getByIds(ids: string[]): Promise<User[]>;
+
   /**
    * Get a user by email
    */
@@ -112,6 +143,20 @@ export interface UserStore {
    */
   getByExternalId(externalId: string, provider: string): Promise<User | null>;
 
+  /**
+   * Get a user by any known identifier.
+   * Tries identifiers in priority order: email > auth0_user_id > wp_user_id > keap_contact_id.
+   * Returns the first match found.
+   */
+  getByIdentifier(identifiers: UserIdentifiers): Promise<User | null>;
+
+  /**
+   * Link external identifiers to a user.
+   * Stores identifiers in metadata.identifiers for future lookups.
+   * Merges with existing identifiers (doesn't overwrite unless value provided).
+   */
+  linkIdentifiers(userId: string, identifiers: Partial<StoredIdentifiers>): Promise<void>;
+
   /**
    * Create a new user
    */
@@ -231,17 +276,48 @@ export interface UserInfo {
 }
 
 /**
- * Input for POST /users/sync endpoint
+ * Input for POST /users/sync endpoint.
+ * Supports multiple identifiers for cross-system user linking.
  */
 export interface UserSyncInput {
-  /** User's email address */
+  /** User's email address (required for user lookup/creation) */
   email: string;
-  /** External provider ID (e.g., Auth0 user_id) */
-  external_id: string;
-  /** Provider name (e.g., 'auth0', 'google') */
-  provider: string;
+  /** WordPress user ID (optional) */
+  wp_user_id?: number;
+  /** Auth0 user ID (sub claim) (optional) */
+  auth0_user_id?: string;
+  /** Keap CRM contact ID (optional - typically looked up by AuthKeaper) */
+  keap_contact_id?: number;
+  /** Provider name indicating source of sync request (e.g., 'auth0', 'wordpress') */
+  provider?: string;
   /** User's display name (optional) */
   name?: string;
   /** Profile picture URL (optional) */
   picture?: string;
+
+  // Legacy fields for backwards compatibility
+  /** @deprecated Use auth0_user_id instead */
+  external_id?: string;
+}
+
+/**
+ * Input for PUT /users/profile endpoint.
+ * At least one identifier is required for user lookup.
+ */
+export interface UserProfileInput {
+  /** User's email address */
+  email?: string;
+  /** WordPress user ID */
+  wp_user_id?: number;
+  /** Auth0 user ID */
+  auth0_user_id?: string;
+  /** Profile data to update */
+  profile: {
+    name?: string;
+    first_name?: string;
+    last_name?: string;
+    phone?: string;
+    birthday?: string;
+    [key: string]: unknown;
+  };
 }

package/src/plugins/users/users-plugin.ts

@@ -20,6 +20,8 @@ import type {
   UserSearchParams,
   UserInfo,
   UserSyncInput,
+  UserIdentifiers,
+  StoredIdentifiers,
 } from './types.js';
 // Import helpers from other plugins for buildUserInfo
 // Note: These imports are used dynamically based on registry.hasPlugin() checks
@@ -309,6 +311,16 @@ export async function getUserByEmail(email: string): Promise<User | null> {
   return currentStore.getByEmail(email);
 }
 
+/**
+ * Get multiple users by IDs (batch query - more efficient than multiple getUserById calls)
+ */
+export async function getUsersByIds(ids: string[]): Promise<User[]> {
+  if (!currentStore) {
+    throw new Error('Users plugin not initialized');
+  }
+  return currentStore.getByIds(ids);
+}
+
 /**
  * Find or create a user from auth provider data
  */
@@ -416,3 +428,28 @@ export async function buildUserInfo(user: User, registry: PluginRegistry): Promi
   await Promise.all(promises);
   return info;
 }
+
+/**
+ * Get a user by any known identifier.
+ * Tries identifiers in priority order: email > auth0_user_id > wp_user_id > keap_contact_id.
+ */
+export async function getUserByIdentifier(identifiers: UserIdentifiers): Promise<User | null> {
+  if (!currentStore) {
+    throw new Error('Users plugin not initialized');
+  }
+  return currentStore.getByIdentifier(identifiers);
+}
+
+/**
+ * Link external identifiers to a user.
+ * Stores identifiers in metadata.identifiers for future lookups.
+ */
+export async function linkUserIdentifiers(
+  userId: string,
+  identifiers: Partial<StoredIdentifiers>
+): Promise<void> {
+  if (!currentStore) {
+    throw new Error('Users plugin not initialized');
+  }
+  return currentStore.linkIdentifiers(userId, identifiers);
+}

package/ui/src/App.tsx

@@ -16,6 +16,7 @@ import { UsersPage } from './pages/UsersPage';
 import { EntitlementsPage } from './pages/EntitlementsPage';
 import { AuthPage } from './pages/AuthPage';
 import { RateLimitPage } from './pages/RateLimitPage';
+import { NotificationsPage } from './pages/NotificationsPage';
 import { IntegrationsPage } from './pages/IntegrationsPage';
 import { PluginPage } from './pages/PluginPage';
 import { NotFoundPage } from './pages/NotFoundPage';
@@ -43,7 +44,7 @@ const builtInPluginNavItems: Record<string, NavigationItem> = {
 };
 
 // Routes that have dedicated page components
-const dedicatedRoutes = new Set(['/', '/plugins', '/logs', '/system', '/users', '/entitlements', '/auth', '/rate-limits', '/integrations']);
+const dedicatedRoutes = new Set(['/', '/plugins', '/logs', '/system', '/users', '/entitlements', '/auth', '/rate-limits', '/notifications', '/integrations']);
 
 // Package version - injected at build time or fallback
 const SERVER_VERSION = '1.0.0';
@@ -215,6 +216,9 @@ export function App() {
             {registeredPlugins.has('rate-limit') && (
               <Route path="/rate-limits" element={<RateLimitPage />} />
             )}
+            {registeredPlugins.has('notifications') && (
+              <Route path="/notifications" element={<NotificationsPage />} />
+            )}
             {registeredPlugins.has('ai-proxy') && (
               <Route path="/integrations" element={<IntegrationsPage />} />
             )}