@payez/next-mvp 3.1.0 → 3.1.1

package/dist/auth/callbacks/jwt.js

@@ -1,305 +1,305 @@
-"use strict";
-/**
- * JWT Callback
- *
- * Minimal token strategy - only store redisSessionId in JWT.
- * All session data lives in Redis, not in the browser cookie.
- *
- * HANDLES:
- * - Initial sign-in (credentials): Store redisSessionId from authorize()
- * - Initial sign-in (OAuth): Register with IDP, create session, store redisSessionId
- * - Subsequent requests: Validate session exists, return token
- *
- * @version 1.0.0
- * @since auth-refactor-2026-01
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.jwtCallback = jwtCallback;
-const crypto_1 = require("crypto");
-const session_store_1 = require("../../lib/session-store");
-const idp_client_config_1 = require("../../lib/idp-client-config");
-const idp_client_1 = require("../utils/idp-client");
-const token_utils_1 = require("../utils/token-utils");
-// NOTE: Using any for sessionData until Phase 3 normalizes types
-// ============================================================================
-// VIBE ROLE FETCHING
-// ============================================================================
-/**
- * Generate HMAC signature for Vibe API request.
- */
-function generateVibeSignature(endpoint, clientId, timestamp) {
-    const signingKey = process.env.VIBE_SIGNING_KEY;
-    if (!signingKey) {
-        return '';
-    }
-    const stringToSign = `${timestamp}|GET|${endpoint}|${clientId}`;
-    return (0, crypto_1.createHmac)('sha256', Buffer.from(signingKey, 'base64'))
-        .update(stringToSign)
-        .digest('base64');
-}
-/**
- * Fetch user's roles from Vibe API.
- * Returns empty array on failure (non-blocking).
- * Uses HMAC signature for authentication when signing key is configured.
- */
-async function fetchVibeRoles(userId, clientId) {
-    const vibeApiUrl = process.env.VIBE_API_URL;
-    if (!vibeApiUrl) {
-        return [];
-    }
-    const endpoint = `/api/v1/users/${userId}/roles`;
-    const timestamp = Math.floor(Date.now() / 1000);
-    const signature = generateVibeSignature(endpoint, clientId, timestamp);
-    // Build headers with optional signature
-    const headers = {
-        'Accept': 'application/json',
-        'X-Client-Id': clientId,
-        'X-Vibe-Client-Id': clientId,
-    };
-    if (signature) {
-        headers['X-Vibe-Timestamp'] = String(timestamp);
-        headers['X-Vibe-Signature'] = signature;
-    }
-    try {
-        const response = await fetch(`${vibeApiUrl}${endpoint}`, {
-            method: 'GET',
-            headers,
-            // 2 second timeout
-            signal: AbortSignal.timeout(2000),
-        });
-        if (!response.ok) {
-            console.warn('[JWT_CALLBACK] Failed to fetch Vibe roles:', response.status);
-            return [];
-        }
-        const data = await response.json();
-        const roles = data.roles?.map((r) => r.role_name || r) || [];
-        console.log('[JWT_CALLBACK] Fetched Vibe roles:', roles);
-        return roles;
-    }
-    catch (error) {
-        console.warn('[JWT_CALLBACK] Error fetching Vibe roles (continuing with IDP roles only):', error);
-        return [];
-    }
-}
-/**
- * Merge IDP roles with Vibe roles, deduplicating.
- */
-function mergeRoles(idpRoles, vibeRoles) {
-    return [...new Set([...idpRoles, ...vibeRoles])];
-}
-// ============================================================================
-// JWT CALLBACK
-// ============================================================================
-/**
- * JWT callback - builds the NextAuth JWT token.
- *
- * MINIMAL TOKEN STRATEGY:
- * - Only store redisSessionId (key to Redis session)
- * - All tokens and user data live in Redis
- * - Browser cookie stays small and secure
- *
- * @param params - JWT callback parameters from NextAuth
- * @returns JWT payload to store in browser cookie
- */
-async function jwtCallback({ token, user, account, trigger, }) {
-    console.log('[JWT_CALLBACK] Called with:', {
-        trigger,
-        hasAccount: !!account,
-        provider: account?.provider,
-        hasUser: !!user,
-        userEmail: user?.email,
-        existingRedisSessionId: token?.redisSessionId ? 'yes' : 'no',
-    });
-    // -------------------------------------------------------------------------
-    // OAuth Sign-In: Register with IDP and create session
-    // -------------------------------------------------------------------------
-    if (account && account.provider !== 'credentials') {
-        console.log('[JWT_CALLBACK] Handling OAuth sign-in for provider:', account.provider);
-        return handleOAuthSignIn(token, user, account);
-    }
-    // -------------------------------------------------------------------------
-    // Credentials Sign-In: Session already created in authorize()
-    // -------------------------------------------------------------------------
-    if (user && user.redisSessionId) {
-        // Credentials authorize() returns redisSessionId
-        const redisSessionId = user.redisSessionId;
-        return {
-            ...token,
-            redisSessionId,
-            sub: user.id || token.sub || 'unknown',
-        };
-    }
-    // -------------------------------------------------------------------------
-    // Subsequent Requests: Validate session exists
-    // -------------------------------------------------------------------------
-    const redisSessionId = user?.redisSessionId || token?.redisSessionId || token?.redisSessionId;
-    if (!redisSessionId) {
-        return { ...token, error: 'NoSession', sub: token.sub || 'unknown' };
-    }
-    // Validate session still exists in Redis
-    try {
-        const sessionData = await (0, session_store_1.getSession)(redisSessionId);
-        if (!sessionData) {
-            // Session expired or deleted
-            return { ...token, error: 'SessionNotFound', sub: token.sub || 'unknown' };
-        }
-        // Check if refresh token has expired (session should be terminated)
-        if (sessionData.idpRefreshTokenExpires && Date.now() >= sessionData.idpRefreshTokenExpires) {
-            return { ...token, error: 'RefreshTokenExpired', sub: token.sub || 'unknown' };
-        }
-        // Check if MFA has expired (requires step-up authentication)
-        if (sessionData.mfaExpiresAt && Date.now() > sessionData.mfaExpiresAt) {
-            return {
-                ...token,
-                redisSessionId,
-                sub: sessionData.userId,
-                error: 'MfaExpired',
-            };
-        }
-    }
-    catch (error) {
-        console.error('[JWT_CALLBACK] Session validation error:', error);
-        return { ...token, error: 'SessionError', sub: token.sub || 'unknown' };
-    }
-    // Session is valid - return minimal token
-    return {
-        ...token,
-        redisSessionId,
-        sub: token.sub || 'unknown',
-    };
-}
-// ============================================================================
-// OAUTH SIGN-IN HANDLER
-// ============================================================================
-/**
- * Handle OAuth sign-in by registering with IDP and creating session.
- */
-async function handleOAuthSignIn(token, user, account) {
-    console.log('[JWT_CALLBACK] handleOAuthSignIn starting for:', {
-        provider: account.provider,
-        email: user?.email,
-        providerAccountId: account.providerAccountId,
-    });
-    try {
-        // Call IDP to register/authenticate OAuth user
-        const idpResult = await (0, idp_client_1.idpOAuthCallback)({
-            provider: account.provider,
-            providerAccountId: account.providerAccountId,
-            email: user?.email || '',
-            name: user?.name || '',
-            image: user?.image || '',
-            accessToken: account.access_token,
-            refreshToken: account.refresh_token,
-            expiresAt: account.expires_at,
-        });
-        // Build session data using normalized field names
-        let sessionData;
-        let mfaVerified = false;
-        if (idpResult.success && idpResult.data?.accessToken) {
-            // IDP integration succeeded - we have IDP tokens
-            const decoded = (0, token_utils_1.decodeIdpAccessToken)(idpResult.data.accessToken);
-            const amrClaims = decoded ? (0, token_utils_1.extractAmrFromToken)(decoded) : [];
-            const acrLevel = decoded?.acr || '1';
-            // Extract kid from JWT header (CRITICAL: different from client_id in payload)
-            const bearerKeyId = (0, token_utils_1.extractKidFromToken)(idpResult.data.accessToken);
-            if (bearerKeyId) {
-                console.log('[JWT_CALLBACK] Extracted bearerKeyId (kid) from JWT header:', bearerKeyId);
-            }
-            else {
-                console.warn('[JWT_CALLBACK] No kid found in JWT header');
-            }
-            // Check if MFA is required for this client
-            try {
-                const clientConfig = await (0, idp_client_config_1.getIDPClientConfig)();
-                const require2FA = clientConfig?.authSettings?.require2FA ?? true;
-                mfaVerified = !require2FA; // If MFA not required, mark as verified
-            }
-            catch {
-                // Default to requiring MFA if config unavailable
-                mfaVerified = false;
-            }
-            sessionData = {
-                userId: idpResult.data.user?.userId?.toString() || account.providerAccountId,
-                email: idpResult.data.user?.email || user?.email || '',
-                name: idpResult.data.user?.fullName || user?.name || '',
-                roles: idpResult.data.user?.roles || [],
-                // IDP tokens (normalized names)
-                idpAccessToken: idpResult.data.accessToken,
-                idpRefreshToken: idpResult.data.refreshToken,
-                idpAccessTokenExpires: decoded?.exp ? (0, token_utils_1.expClaimToMs)(decoded.exp) : Date.now() + 3600000,
-                decodedAccessToken: decoded || undefined,
-                // Bearer key ID from JWT header (NOT client_id from payload)
-                bearerKeyId,
-                // MFA state (normalized names)
-                mfaVerified,
-                authenticationMethods: amrClaims,
-                authenticationLevel: acrLevel,
-                // OAuth provider info (normalized names)
-                oauthProvider: account.provider,
-                oauthProviderToken: account.access_token,
-                oauthProviderRefreshToken: account.refresh_token,
-                // Multi-tenant info
-                idpClientId: decoded?.client_id,
-                merchantId: decoded?.merchant_id,
-            };
-        }
-        else {
-            // IDP integration failed - create OAuth-only session
-            // This allows OAuth login to work even if IDP is unavailable
-            mfaVerified = true; // OAuth IS multi-factor (Google/Microsoft handle MFA)
-            sessionData = {
-                userId: account.providerAccountId,
-                email: user?.email || '',
-                name: user?.name || '',
-                roles: [],
-                mfaVerified: true, // OAuth IS multi-factor
-                oauthProvider: account.provider,
-                oauthProviderToken: account.access_token,
-                oauthProviderRefreshToken: account.refresh_token,
-                idpAccessTokenExpires: account.expires_at
-                    ? account.expires_at * 1000
-                    : Date.now() + 3600000,
-            };
-        }
-        // -------------------------------------------------------------------------
-        // ROLE MERGING: Fetch Vibe roles and merge with IDP roles
-        // -------------------------------------------------------------------------
-        const clientId = sessionData.idpClientId || process.env.IDP_CLIENT_ID || '';
-        if (clientId && sessionData.userId) {
-            const vibeRoles = await fetchVibeRoles(sessionData.userId, clientId);
-            // SECURITY: Filter out protected IDP-level role prefixes to prevent injection
-            const safeVibeRoles = vibeRoles.filter(r => !r.startsWith('payez_'));
-            const idpRoles = sessionData.roles || [];
-            sessionData.roles = mergeRoles(idpRoles, safeVibeRoles);
-            console.log('[JWT_CALLBACK] Merged roles:', {
-                idpRoles,
-                vibeRoles,
-                safeVibeRoles,
-                merged: sessionData.roles,
-            });
-        }
-        // Create Redis session
-        console.log('[JWT_CALLBACK] Creating Redis session for:', {
-            userId: sessionData.userId,
-            email: sessionData.email,
-            mfaVerified: sessionData.mfaVerified,
-            roles: sessionData.roles,
-        });
-        const redisSessionId = await (0, session_store_1.createSession)(sessionData);
-        console.log('[JWT_CALLBACK] Redis session created:', {
-            redisSessionId: redisSessionId ? redisSessionId.substring(0, 8) + '...' : 'NONE',
-        });
-        // Check if immediate MFA redirect is needed
-        const needsImmediateTwoFactor = !mfaVerified;
-        return {
-            ...token,
-            redisSessionId,
-            sub: sessionData.userId,
-            requiresTwoFactorRedirect: needsImmediateTwoFactor,
-        };
-    }
-    catch (error) {
-        console.error('[JWT_CALLBACK] handleOAuthSignIn FAILED:', error);
-        return { ...token, error: 'OAuthSignInFailed', sub: token.sub || 'unknown' };
-    }
-}
+"use strict";
+/**
+ * JWT Callback
+ *
+ * Minimal token strategy - only store redisSessionId in JWT.
+ * All session data lives in Redis, not in the browser cookie.
+ *
+ * HANDLES:
+ * - Initial sign-in (credentials): Store redisSessionId from authorize()
+ * - Initial sign-in (OAuth): Register with IDP, create session, store redisSessionId
+ * - Subsequent requests: Validate session exists, return token
+ *
+ * @version 1.0.0
+ * @since auth-refactor-2026-01
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jwtCallback = jwtCallback;
+const crypto_1 = require("crypto");
+const session_store_1 = require("../../lib/session-store");
+const idp_client_config_1 = require("../../lib/idp-client-config");
+const idp_client_1 = require("../utils/idp-client");
+const token_utils_1 = require("../utils/token-utils");
+// NOTE: Using any for sessionData until Phase 3 normalizes types
+// ============================================================================
+// VIBE ROLE FETCHING
+// ============================================================================
+/**
+ * Generate HMAC signature for Vibe API request.
+ */
+function generateVibeSignature(endpoint, clientId, timestamp) {
+    const signingKey = process.env.VIBE_SIGNING_KEY;
+    if (!signingKey) {
+        return '';
+    }
+    const stringToSign = `${timestamp}|GET|${endpoint}|${clientId}`;
+    return (0, crypto_1.createHmac)('sha256', Buffer.from(signingKey, 'base64'))
+        .update(stringToSign)
+        .digest('base64');
+}
+/**
+ * Fetch user's roles from Vibe API.
+ * Returns empty array on failure (non-blocking).
+ * Uses HMAC signature for authentication when signing key is configured.
+ */
+async function fetchVibeRoles(userId, clientId) {
+    const vibeApiUrl = process.env.VIBE_API_URL;
+    if (!vibeApiUrl) {
+        return [];
+    }
+    const endpoint = `/api/v1/users/${userId}/roles`;
+    const timestamp = Math.floor(Date.now() / 1000);
+    const signature = generateVibeSignature(endpoint, clientId, timestamp);
+    // Build headers with optional signature
+    const headers = {
+        'Accept': 'application/json',
+        'X-Client-Id': clientId,
+        'X-Vibe-Client-Id': clientId,
+    };
+    if (signature) {
+        headers['X-Vibe-Timestamp'] = String(timestamp);
+        headers['X-Vibe-Signature'] = signature;
+    }
+    try {
+        const response = await fetch(`${vibeApiUrl}${endpoint}`, {
+            method: 'GET',
+            headers,
+            // 2 second timeout
+            signal: AbortSignal.timeout(2000),
+        });
+        if (!response.ok) {
+            console.warn('[JWT_CALLBACK] Failed to fetch Vibe roles:', response.status);
+            return [];
+        }
+        const data = await response.json();
+        const roles = data.roles?.map((r) => r.role_name || r) || [];
+        console.log('[JWT_CALLBACK] Fetched Vibe roles:', roles);
+        return roles;
+    }
+    catch (error) {
+        console.warn('[JWT_CALLBACK] Error fetching Vibe roles (continuing with IDP roles only):', error);
+        return [];
+    }
+}
+/**
+ * Merge IDP roles with Vibe roles, deduplicating.
+ */
+function mergeRoles(idpRoles, vibeRoles) {
+    return [...new Set([...idpRoles, ...vibeRoles])];
+}
+// ============================================================================
+// JWT CALLBACK
+// ============================================================================
+/**
+ * JWT callback - builds the NextAuth JWT token.
+ *
+ * MINIMAL TOKEN STRATEGY:
+ * - Only store redisSessionId (key to Redis session)
+ * - All tokens and user data live in Redis
+ * - Browser cookie stays small and secure
+ *
+ * @param params - JWT callback parameters from NextAuth
+ * @returns JWT payload to store in browser cookie
+ */
+async function jwtCallback({ token, user, account, trigger, }) {
+    console.log('[JWT_CALLBACK] Called with:', {
+        trigger,
+        hasAccount: !!account,
+        provider: account?.provider,
+        hasUser: !!user,
+        userEmail: user?.email,
+        existingRedisSessionId: token?.redisSessionId ? 'yes' : 'no',
+    });
+    // -------------------------------------------------------------------------
+    // OAuth Sign-In: Register with IDP and create session
+    // -------------------------------------------------------------------------
+    if (account && account.provider !== 'credentials') {
+        console.log('[JWT_CALLBACK] Handling OAuth sign-in for provider:', account.provider);
+        return handleOAuthSignIn(token, user, account);
+    }
+    // -------------------------------------------------------------------------
+    // Credentials Sign-In: Session already created in authorize()
+    // -------------------------------------------------------------------------
+    if (user && user.redisSessionId) {
+        // Credentials authorize() returns redisSessionId
+        const redisSessionId = user.redisSessionId;
+        return {
+            ...token,
+            redisSessionId,
+            sub: user.id || token.sub || 'unknown',
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Subsequent Requests: Validate session exists
+    // -------------------------------------------------------------------------
+    const redisSessionId = user?.redisSessionId || token?.redisSessionId || token?.redisSessionId;
+    if (!redisSessionId) {
+        return { ...token, error: 'NoSession', sub: token.sub || 'unknown' };
+    }
+    // Validate session still exists in Redis
+    try {
+        const sessionData = await (0, session_store_1.getSession)(redisSessionId);
+        if (!sessionData) {
+            // Session expired or deleted
+            return { ...token, error: 'SessionNotFound', sub: token.sub || 'unknown' };
+        }
+        // Check if refresh token has expired (session should be terminated)
+        if (sessionData.idpRefreshTokenExpires && Date.now() >= sessionData.idpRefreshTokenExpires) {
+            return { ...token, error: 'RefreshTokenExpired', sub: token.sub || 'unknown' };
+        }
+        // Check if MFA has expired (requires step-up authentication)
+        if (sessionData.mfaExpiresAt && Date.now() > sessionData.mfaExpiresAt) {
+            return {
+                ...token,
+                redisSessionId,
+                sub: sessionData.userId,
+                error: 'MfaExpired',
+            };
+        }
+    }
+    catch (error) {
+        console.error('[JWT_CALLBACK] Session validation error:', error);
+        return { ...token, error: 'SessionError', sub: token.sub || 'unknown' };
+    }
+    // Session is valid - return minimal token
+    return {
+        ...token,
+        redisSessionId,
+        sub: token.sub || 'unknown',
+    };
+}
+// ============================================================================
+// OAUTH SIGN-IN HANDLER
+// ============================================================================
+/**
+ * Handle OAuth sign-in by registering with IDP and creating session.
+ */
+async function handleOAuthSignIn(token, user, account) {
+    console.log('[JWT_CALLBACK] handleOAuthSignIn starting for:', {
+        provider: account.provider,
+        email: user?.email,
+        providerAccountId: account.providerAccountId,
+    });
+    try {
+        // Call IDP to register/authenticate OAuth user
+        const idpResult = await (0, idp_client_1.idpOAuthCallback)({
+            provider: account.provider,
+            providerAccountId: account.providerAccountId,
+            email: user?.email || '',
+            name: user?.name || '',
+            image: user?.image || '',
+            accessToken: account.access_token,
+            refreshToken: account.refresh_token,
+            expiresAt: account.expires_at,
+        });
+        // Build session data using normalized field names
+        let sessionData;
+        let mfaVerified = false;
+        if (idpResult.success && idpResult.data?.accessToken) {
+            // IDP integration succeeded - we have IDP tokens
+            const decoded = (0, token_utils_1.decodeIdpAccessToken)(idpResult.data.accessToken);
+            const amrClaims = decoded ? (0, token_utils_1.extractAmrFromToken)(decoded) : [];
+            const acrLevel = decoded?.acr || '1';
+            // Extract kid from JWT header (CRITICAL: different from client_id in payload)
+            const bearerKeyId = (0, token_utils_1.extractKidFromToken)(idpResult.data.accessToken);
+            if (bearerKeyId) {
+                console.log('[JWT_CALLBACK] Extracted bearerKeyId (kid) from JWT header:', bearerKeyId);
+            }
+            else {
+                console.warn('[JWT_CALLBACK] No kid found in JWT header');
+            }
+            // Check if MFA is required for this client
+            try {
+                const clientConfig = await (0, idp_client_config_1.getIDPClientConfig)();
+                const require2FA = clientConfig?.authSettings?.require2FA ?? true;
+                mfaVerified = !require2FA; // If MFA not required, mark as verified
+            }
+            catch {
+                // Default to requiring MFA if config unavailable
+                mfaVerified = false;
+            }
+            sessionData = {
+                userId: idpResult.data.user?.userId?.toString() || account.providerAccountId,
+                email: idpResult.data.user?.email || user?.email || '',
+                name: idpResult.data.user?.fullName || user?.name || '',
+                roles: idpResult.data.user?.roles || [],
+                // IDP tokens (normalized names)
+                idpAccessToken: idpResult.data.accessToken,
+                idpRefreshToken: idpResult.data.refreshToken,
+                idpAccessTokenExpires: decoded?.exp ? (0, token_utils_1.expClaimToMs)(decoded.exp) : Date.now() + 3600000,
+                decodedAccessToken: decoded || undefined,
+                // Bearer key ID from JWT header (NOT client_id from payload)
+                bearerKeyId,
+                // MFA state (normalized names)
+                mfaVerified,
+                authenticationMethods: amrClaims,
+                authenticationLevel: acrLevel,
+                // OAuth provider info (normalized names)
+                oauthProvider: account.provider,
+                oauthProviderToken: account.access_token,
+                oauthProviderRefreshToken: account.refresh_token,
+                // Multi-tenant info
+                idpClientId: decoded?.client_id,
+                merchantId: decoded?.merchant_id,
+            };
+        }
+        else {
+            // IDP integration failed - create OAuth-only session
+            // This allows OAuth login to work even if IDP is unavailable
+            mfaVerified = true; // OAuth IS multi-factor (Google/Microsoft handle MFA)
+            sessionData = {
+                userId: account.providerAccountId,
+                email: user?.email || '',
+                name: user?.name || '',
+                roles: [],
+                mfaVerified: true, // OAuth IS multi-factor
+                oauthProvider: account.provider,
+                oauthProviderToken: account.access_token,
+                oauthProviderRefreshToken: account.refresh_token,
+                idpAccessTokenExpires: account.expires_at
+                    ? account.expires_at * 1000
+                    : Date.now() + 3600000,
+            };
+        }
+        // -------------------------------------------------------------------------
+        // ROLE MERGING: Fetch Vibe roles and merge with IDP roles
+        // -------------------------------------------------------------------------
+        const clientId = sessionData.idpClientId || process.env.IDP_CLIENT_ID || '';
+        if (clientId && sessionData.userId) {
+            const vibeRoles = await fetchVibeRoles(sessionData.userId, clientId);
+            // SECURITY: Filter out protected IDP-level role prefixes to prevent injection
+            const safeVibeRoles = vibeRoles.filter(r => !r.startsWith('payez_'));
+            const idpRoles = sessionData.roles || [];
+            sessionData.roles = mergeRoles(idpRoles, safeVibeRoles);
+            console.log('[JWT_CALLBACK] Merged roles:', {
+                idpRoles,
+                vibeRoles,
+                safeVibeRoles,
+                merged: sessionData.roles,
+            });
+        }
+        // Create Redis session
+        console.log('[JWT_CALLBACK] Creating Redis session for:', {
+            userId: sessionData.userId,
+            email: sessionData.email,
+            mfaVerified: sessionData.mfaVerified,
+            roles: sessionData.roles,
+        });
+        const redisSessionId = await (0, session_store_1.createSession)(sessionData);
+        console.log('[JWT_CALLBACK] Redis session created:', {
+            redisSessionId: redisSessionId ? redisSessionId.substring(0, 8) + '...' : 'NONE',
+        });
+        // Check if immediate MFA redirect is needed
+        const needsImmediateTwoFactor = !mfaVerified;
+        return {
+            ...token,
+            redisSessionId,
+            sub: sessionData.userId,
+            requiresTwoFactorRedirect: needsImmediateTwoFactor,
+        };
+    }
+    catch (error) {
+        console.error('[JWT_CALLBACK] handleOAuthSignIn FAILED:', error);
+        return { ...token, error: 'OAuthSignInFailed', sub: token.sub || 'unknown' };
+    }
+}

package/dist/auth/providers/credentials.js

@@ -1,223 +1,223 @@
-"use strict";
-/**
- * Credentials Provider
- *
- * Handles email/password authentication via PayEz IDP.
- * Creates Redis session and returns minimal user object to NextAuth.
- *
- * FLOW:
- * 1. User submits email/password
- * 2. We call IDP /api/ExternalAuth/login
- * 3. IDP returns tokens if credentials valid
- * 4. We create Redis session with tokens
- * 5. Return user object with redisSessionId to NextAuth
- *
- * @version 1.0.0
- * @since auth-refactor-2026-01
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCredentialsProvider = createCredentialsProvider;
-const credentials_1 = __importDefault(require("next-auth/providers/credentials"));
-const session_store_1 = require("../../lib/session-store");
-const idp_client_1 = require("../utils/idp-client");
-const token_utils_1 = require("../utils/token-utils");
-const auth_types_1 = require("../types/auth-types");
-// NOTE: Using any for sessionData until Phase 3 normalizes types
-// ============================================================================
-// CREDENTIALS PROVIDER
-// ============================================================================
-/**
- * Create the CredentialsProvider for NextAuth.
- *
- * This provider handles email/password login. The authorize function
- * is called when a user submits the login form.
- */
-function createCredentialsProvider() {
-    return (0, credentials_1.default)({
-        id: 'credentials',
-        name: 'Credentials',
-        credentials: {
-            email: { label: 'Email', type: 'email' },
-            password: { label: 'Password', type: 'password' },
-        },
-        authorize: authorizeCredentials,
-    });
-}
-/**
- * Authorize user with email/password.
- *
- * This is the core authentication function. It:
- * 1. Validates credentials with IDP
- * 2. Decodes the returned tokens
- * 3. Creates a Redis session
- * 4. Returns user info for NextAuth JWT
- *
- * @param credentials - Email and password from login form
- * @param req - The incoming request (for IP/UA forwarding)
- * @returns User object for NextAuth, or null/throws on failure
- */
-async function authorizeCredentials(credentials, req) {
-    // -------------------------------------------------------------------------
-    // Validate Input
-    // -------------------------------------------------------------------------
-    if (!credentials?.email || !credentials?.password) {
-        throw new Error('Email and password required');
-    }
-    const loginCredentials = {
-        email: credentials.email,
-        password: credentials.password,
-    };
-    // Extract client info for audit logging
-    const clientHeaders = extractClientHeaders(req);
-    // -------------------------------------------------------------------------
-    // Call IDP
-    // -------------------------------------------------------------------------
-    const loginResult = await (0, idp_client_1.idpLogin)(loginCredentials, clientHeaders);
-    if (!loginResult.success || !loginResult.result) {
-        // Build structured error for frontend
-        const errorResponse = buildAuthError(loginResult.error);
-        throw new Error(JSON.stringify(errorResponse));
-    }
-    const { access_token, refresh_token, user: idpUser } = loginResult.result;
-    // -------------------------------------------------------------------------
-    // Decode Token
-    // -------------------------------------------------------------------------
-    const decoded = (0, token_utils_1.decodeIdpAccessToken)(access_token);
-    if (!decoded) {
-        throw new Error('Failed to decode token');
-    }
-    // Extract kid from JWT header (CRITICAL: this is different from client_id in payload)
-    const bearerKeyId = (0, token_utils_1.extractKidFromToken)(access_token);
-    if (bearerKeyId) {
-        console.log('[CREDENTIALS] Extracted bearerKeyId (kid) from JWT header:', bearerKeyId);
-    }
-    else {
-        console.warn('[CREDENTIALS] No kid found in JWT header - token may be unsigned or malformed');
-    }
-    // Extract claims from token
-    const email = (0, token_utils_1.extractEmailFromToken)(decoded);
-    const roles = (0, token_utils_1.extractRolesFromToken)(decoded);
-    const amrClaims = (0, token_utils_1.extractAmrFromToken)(decoded);
-    const acrLevel = decoded.acr || '1';
-    const userId = decoded.sub;
-    // Check if 2FA is complete based on ACR level
-    // ACR=1: Provisional token (requires 2FA)
-    // ACR=2: Full authentication (2FA complete)
-    const mfaVerified = acrLevel === '2';
-    // Decode refresh token expiry if available
-    let refreshTokenExpires;
-    try {
-        const refreshDecoded = (0, token_utils_1.decodeIdpAccessToken)(refresh_token);
-        if (refreshDecoded?.exp) {
-            refreshTokenExpires = (0, token_utils_1.expClaimToMs)(refreshDecoded.exp);
-        }
-    }
-    catch {
-        // Ignore - will use default expiry
-    }
-    // -------------------------------------------------------------------------
-    // Create Redis Session
-    // -------------------------------------------------------------------------
-    // Using normalized field names (session-store handles backward compatibility)
-    const sessionData = {
-        userId,
-        email,
-        roles,
-        // IDP tokens (normalized names)
-        idpAccessToken: access_token,
-        idpRefreshToken: refresh_token,
-        idpAccessTokenExpires: (0, token_utils_1.expClaimToMs)(decoded.exp),
-        idpRefreshTokenExpires: refreshTokenExpires,
-        decodedAccessToken: decoded,
-        // Bearer key ID from JWT header (NOT client_id from payload)
-        bearerKeyId,
-        // MFA state (normalized names)
-        mfaVerified,
-        authenticationMethods: amrClaims,
-        authenticationLevel: acrLevel,
-        // MFA timing info from token
-        mfaCompletedAt: decoded.mfa_time ? (0, token_utils_1.expClaimToMs)(decoded.mfa_time) : undefined,
-        mfaExpiresAt: decoded.mfa_expires ? (0, token_utils_1.expClaimToMs)(decoded.mfa_expires) : undefined,
-        mfaValidityHours: decoded.mfa_validity_hours,
-    };
-    // Determine MFA method from IDP user info
-    let mfaMethod;
-    if (idpUser?.isEmailConfirmed) {
-        mfaMethod = 'email';
-    }
-    else if (idpUser?.isSmsConfirmed) {
-        mfaMethod = 'sms';
-    }
-    if (mfaMethod) {
-        sessionData.mfaMethod = mfaMethod;
-    }
-    // Create the Redis session
-    const redisSessionId = await (0, session_store_1.createSession)(sessionData);
-    // -------------------------------------------------------------------------
-    // Return User Object for NextAuth
-    // -------------------------------------------------------------------------
-    // NextAuth requires 'id' field - we use userId from IDP
-    // The redisSessionId is passed through to the JWT callback
-    return {
-        id: userId,
-        email,
-        roles,
-        redisSessionId: (0, auth_types_1.toRedisSessionId)(redisSessionId),
-        mfaRequired: !mfaVerified,
-        mfaMethod,
-    };
-}
-// ============================================================================
-// HELPER FUNCTIONS
-// ============================================================================
-/**
- * Extract client headers from request for audit logging.
- */
-function extractClientHeaders(req) {
-    const headers = {};
-    // Extract client IP
-    const forwardedFor = req?.headers?.['x-forwarded-for'];
-    const realIp = req?.headers?.['x-real-ip'];
-    if (forwardedFor) {
-        const ip = Array.isArray(forwardedFor) ? forwardedFor[0] : forwardedFor.split(',')[0].trim();
-        headers.ip = ip;
-    }
-    else if (realIp) {
-        headers.ip = Array.isArray(realIp) ? realIp[0] : realIp;
-    }
-    // Extract User-Agent
-    const userAgent = req?.headers?.['user-agent'];
-    if (userAgent) {
-        headers.userAgent = Array.isArray(userAgent) ? userAgent[0] : userAgent;
-    }
-    return headers;
-}
-/**
- * Build structured error response for frontend.
- *
- * The frontend expects a specific error structure to display
- * appropriate messages and handle things like lockout.
- */
-function buildAuthError(error) {
-    if (!error) {
-        return {
-            success: false,
-            error: {
-                code: 'AUTH_ERROR',
-                message: 'Authentication failed',
-                details: {},
-            },
-        };
-    }
-    return {
-        success: false,
-        error: {
-            code: error.code || 'AUTH_ERROR',
-            message: error.message || 'Authentication failed',
-            details: error.details || {},
-        },
-    };
-}
+"use strict";
+/**
+ * Credentials Provider
+ *
+ * Handles email/password authentication via PayEz IDP.
+ * Creates Redis session and returns minimal user object to NextAuth.
+ *
+ * FLOW:
+ * 1. User submits email/password
+ * 2. We call IDP /api/ExternalAuth/login
+ * 3. IDP returns tokens if credentials valid
+ * 4. We create Redis session with tokens
+ * 5. Return user object with redisSessionId to NextAuth
+ *
+ * @version 1.0.0
+ * @since auth-refactor-2026-01
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCredentialsProvider = createCredentialsProvider;
+const credentials_1 = __importDefault(require("next-auth/providers/credentials"));
+const session_store_1 = require("../../lib/session-store");
+const idp_client_1 = require("../utils/idp-client");
+const token_utils_1 = require("../utils/token-utils");
+const auth_types_1 = require("../types/auth-types");
+// NOTE: Using any for sessionData until Phase 3 normalizes types
+// ============================================================================
+// CREDENTIALS PROVIDER
+// ============================================================================
+/**
+ * Create the CredentialsProvider for NextAuth.
+ *
+ * This provider handles email/password login. The authorize function
+ * is called when a user submits the login form.
+ */
+function createCredentialsProvider() {
+    return (0, credentials_1.default)({
+        id: 'credentials',
+        name: 'Credentials',
+        credentials: {
+            email: { label: 'Email', type: 'email' },
+            password: { label: 'Password', type: 'password' },
+        },
+        authorize: authorizeCredentials,
+    });
+}
+/**
+ * Authorize user with email/password.
+ *
+ * This is the core authentication function. It:
+ * 1. Validates credentials with IDP
+ * 2. Decodes the returned tokens
+ * 3. Creates a Redis session
+ * 4. Returns user info for NextAuth JWT
+ *
+ * @param credentials - Email and password from login form
+ * @param req - The incoming request (for IP/UA forwarding)
+ * @returns User object for NextAuth, or null/throws on failure
+ */
+async function authorizeCredentials(credentials, req) {
+    // -------------------------------------------------------------------------
+    // Validate Input
+    // -------------------------------------------------------------------------
+    if (!credentials?.email || !credentials?.password) {
+        throw new Error('Email and password required');
+    }
+    const loginCredentials = {
+        email: credentials.email,
+        password: credentials.password,
+    };
+    // Extract client info for audit logging
+    const clientHeaders = extractClientHeaders(req);
+    // -------------------------------------------------------------------------
+    // Call IDP
+    // -------------------------------------------------------------------------
+    const loginResult = await (0, idp_client_1.idpLogin)(loginCredentials, clientHeaders);
+    if (!loginResult.success || !loginResult.result) {
+        // Build structured error for frontend
+        const errorResponse = buildAuthError(loginResult.error);
+        throw new Error(JSON.stringify(errorResponse));
+    }
+    const { access_token, refresh_token, user: idpUser } = loginResult.result;
+    // -------------------------------------------------------------------------
+    // Decode Token
+    // -------------------------------------------------------------------------
+    const decoded = (0, token_utils_1.decodeIdpAccessToken)(access_token);
+    if (!decoded) {
+        throw new Error('Failed to decode token');
+    }
+    // Extract kid from JWT header (CRITICAL: this is different from client_id in payload)
+    const bearerKeyId = (0, token_utils_1.extractKidFromToken)(access_token);
+    if (bearerKeyId) {
+        console.log('[CREDENTIALS] Extracted bearerKeyId (kid) from JWT header:', bearerKeyId);
+    }
+    else {
+        console.warn('[CREDENTIALS] No kid found in JWT header - token may be unsigned or malformed');
+    }
+    // Extract claims from token
+    const email = (0, token_utils_1.extractEmailFromToken)(decoded);
+    const roles = (0, token_utils_1.extractRolesFromToken)(decoded);
+    const amrClaims = (0, token_utils_1.extractAmrFromToken)(decoded);
+    const acrLevel = decoded.acr || '1';
+    const userId = decoded.sub;
+    // Check if 2FA is complete based on ACR level
+    // ACR=1: Provisional token (requires 2FA)
+    // ACR=2: Full authentication (2FA complete)
+    const mfaVerified = acrLevel === '2';
+    // Decode refresh token expiry if available
+    let refreshTokenExpires;
+    try {
+        const refreshDecoded = (0, token_utils_1.decodeIdpAccessToken)(refresh_token);
+        if (refreshDecoded?.exp) {
+            refreshTokenExpires = (0, token_utils_1.expClaimToMs)(refreshDecoded.exp);
+        }
+    }
+    catch {
+        // Ignore - will use default expiry
+    }
+    // -------------------------------------------------------------------------
+    // Create Redis Session
+    // -------------------------------------------------------------------------
+    // Using normalized field names (session-store handles backward compatibility)
+    const sessionData = {
+        userId,
+        email,
+        roles,
+        // IDP tokens (normalized names)
+        idpAccessToken: access_token,
+        idpRefreshToken: refresh_token,
+        idpAccessTokenExpires: (0, token_utils_1.expClaimToMs)(decoded.exp),
+        idpRefreshTokenExpires: refreshTokenExpires,
+        decodedAccessToken: decoded,
+        // Bearer key ID from JWT header (NOT client_id from payload)
+        bearerKeyId,
+        // MFA state (normalized names)
+        mfaVerified,
+        authenticationMethods: amrClaims,
+        authenticationLevel: acrLevel,
+        // MFA timing info from token
+        mfaCompletedAt: decoded.mfa_time ? (0, token_utils_1.expClaimToMs)(decoded.mfa_time) : undefined,
+        mfaExpiresAt: decoded.mfa_expires ? (0, token_utils_1.expClaimToMs)(decoded.mfa_expires) : undefined,
+        mfaValidityHours: decoded.mfa_validity_hours,
+    };
+    // Determine MFA method from IDP user info
+    let mfaMethod;
+    if (idpUser?.isEmailConfirmed) {
+        mfaMethod = 'email';
+    }
+    else if (idpUser?.isSmsConfirmed) {
+        mfaMethod = 'sms';
+    }
+    if (mfaMethod) {
+        sessionData.mfaMethod = mfaMethod;
+    }
+    // Create the Redis session
+    const redisSessionId = await (0, session_store_1.createSession)(sessionData);
+    // -------------------------------------------------------------------------
+    // Return User Object for NextAuth
+    // -------------------------------------------------------------------------
+    // NextAuth requires 'id' field - we use userId from IDP
+    // The redisSessionId is passed through to the JWT callback
+    return {
+        id: userId,
+        email,
+        roles,
+        redisSessionId: (0, auth_types_1.toRedisSessionId)(redisSessionId),
+        mfaRequired: !mfaVerified,
+        mfaMethod,
+    };
+}
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Extract client headers from request for audit logging.
+ */
+function extractClientHeaders(req) {
+    const headers = {};
+    // Extract client IP
+    const forwardedFor = req?.headers?.['x-forwarded-for'];
+    const realIp = req?.headers?.['x-real-ip'];
+    if (forwardedFor) {
+        const ip = Array.isArray(forwardedFor) ? forwardedFor[0] : forwardedFor.split(',')[0].trim();
+        headers.ip = ip;
+    }
+    else if (realIp) {
+        headers.ip = Array.isArray(realIp) ? realIp[0] : realIp;
+    }
+    // Extract User-Agent
+    const userAgent = req?.headers?.['user-agent'];
+    if (userAgent) {
+        headers.userAgent = Array.isArray(userAgent) ? userAgent[0] : userAgent;
+    }
+    return headers;
+}
+/**
+ * Build structured error response for frontend.
+ *
+ * The frontend expects a specific error structure to display
+ * appropriate messages and handle things like lockout.
+ */
+function buildAuthError(error) {
+    if (!error) {
+        return {
+            success: false,
+            error: {
+                code: 'AUTH_ERROR',
+                message: 'Authentication failed',
+                details: {},
+            },
+        };
+    }
+    return {
+        success: false,
+        error: {
+            code: error.code || 'AUTH_ERROR',
+            message: error.message || 'Authentication failed',
+            details: error.details || {},
+        },
+    };
+}

package/dist/lib/idp-client-config.js

@@ -120,7 +120,8 @@ async function getIDPClientConfig(forceRefresh = false) {
             }
             // Set IDENTITY_CLIENT_BASE_EXTERNAL_URL from cached config
             // AUTH_TRUST_HOST=true tells NextAuth to derive OAuth callback URLs from headers.
-            if (redisConfig.baseClientUrl) {
+            // Only set if not already defined (allows deployment override for beta/staging)
+            if (redisConfig.baseClientUrl && !process.env.IDENTITY_CLIENT_BASE_EXTERNAL_URL) {
                 process.env.IDENTITY_CLIENT_BASE_EXTERNAL_URL = redisConfig.baseClientUrl;
             }
             return redisConfig;
@@ -152,7 +153,8 @@ async function getIDPClientConfig(forceRefresh = false) {
         }
         // Set IDENTITY_CLIENT_BASE_EXTERNAL_URL from config
         // AUTH_TRUST_HOST=true tells NextAuth to derive OAuth callback URLs from headers.
-        if (config.baseClientUrl) {
+        // Only set if not already defined (allows deployment override for beta/staging)
+        if (config.baseClientUrl && !process.env.IDENTITY_CLIENT_BASE_EXTERNAL_URL) {
             process.env.IDENTITY_CLIENT_BASE_EXTERNAL_URL = config.baseClientUrl;
             console.log("[IDP_CONFIG] Set IDENTITY_CLIENT_BASE_EXTERNAL_URL:", config.baseClientUrl);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@payez/next-mvp",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "sideEffects": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/lib/idp-client-config.ts

@@ -177,7 +177,8 @@ export async function getIDPClientConfig(forceRefresh: boolean = false): Promise
 
             // Set IDENTITY_CLIENT_BASE_EXTERNAL_URL from cached config
             // AUTH_TRUST_HOST=true tells NextAuth to derive OAuth callback URLs from headers.
-            if (redisConfig.baseClientUrl) {
+            // Only set if not already defined (allows deployment override for beta/staging)
+            if (redisConfig.baseClientUrl && !process.env.IDENTITY_CLIENT_BASE_EXTERNAL_URL) {
                 process.env.IDENTITY_CLIENT_BASE_EXTERNAL_URL = redisConfig.baseClientUrl;
             }
 
@@ -215,7 +216,8 @@ export async function getIDPClientConfig(forceRefresh: boolean = false): Promise
 
             // Set IDENTITY_CLIENT_BASE_EXTERNAL_URL from config
             // AUTH_TRUST_HOST=true tells NextAuth to derive OAuth callback URLs from headers.
-            if (config.baseClientUrl) {
+            // Only set if not already defined (allows deployment override for beta/staging)
+            if (config.baseClientUrl && !process.env.IDENTITY_CLIENT_BASE_EXTERNAL_URL) {
                 process.env.IDENTITY_CLIENT_BASE_EXTERNAL_URL = config.baseClientUrl;
                 console.log("[IDP_CONFIG] Set IDENTITY_CLIENT_BASE_EXTERNAL_URL:", config.baseClientUrl);
             }