mulguard 1.1.6 → 1.1.8

package/dist/index.d.ts

@@ -1,21 +0,0 @@
-/**
- * mulguard
- * Modern authentication library for Next.js
- *
- * This is the **server-safe** entrypoint. It must NOT import React
- * or any client-only hooks/components, otherwise Next.js will treat
- * anything that imports `mulguard` as a Client Component.
- *
- * - Server / shared functionality is exported from here.
- * - React hooks & components are exposed via subpath exports:
- *   - `mulguard/client` for hooks & provider
- *   - (future) `mulguard/components/*` for UI components
- */
-export * from './core';
-export * from './mulguard';
-export * from './server';
-export * from './handlers/route';
-export * from './handlers/api';
-export * from './middleware';
-export { createProxyMiddleware, checkRole as checkRoleProxy, } from './middleware/proxy';
-export * from './middleware/security';

package/dist/middleware/index.d.ts

@@ -1,28 +0,0 @@
-import { NextResponse, NextRequest } from 'next/server';
-import { MulguardInstance } from '../mulguard';
-export interface AuthMiddlewareConfig {
-    /**
-     * Protected routes - require authentication
-     */
-    protectedRoutes?: string[];
-    /**
-     * Public routes - accessible without authentication
-     */
-    publicRoutes?: string[];
-    /**
-     * Redirect to login if not authenticated
-     */
-    redirectTo?: string;
-    /**
-     * Redirect to home if authenticated (for login/register pages)
-     */
-    redirectIfAuthenticated?: string;
-}
-/**
- * Create authentication middleware
- */
-export declare function createAuthMiddleware(auth: MulguardInstance, config?: AuthMiddlewareConfig): (request: NextRequest) => Promise<NextResponse<unknown>>;
-/**
- * Helper to check if user has required role
- */
-export declare function checkRole(auth: MulguardInstance, requiredRole: string): Promise<boolean>;

package/dist/middleware/proxy.d.ts

@@ -1,53 +0,0 @@
-import { NextResponse, NextRequest } from 'next/server';
-import { MulguardInstance } from '../mulguard';
-export interface ProxyMiddlewareConfig {
-    /**
-     * Auth instance
-     */
-    auth: MulguardInstance;
-    /**
-     * Protected routes - require authentication
-     */
-    protectedRoutes?: string[];
-    /**
-     * Public routes - accessible without authentication
-     */
-    publicRoutes?: string[];
-    /**
-     * Redirect to login if not authenticated
-     */
-    redirectTo?: string;
-    /**
-     * Redirect to home if authenticated (for login/register pages)
-     */
-    redirectIfAuthenticated?: string;
-    /**
-     * API routes prefix (default: '/api/auth')
-     */
-    apiPrefix?: string;
-}
-/**
- * Create proxy middleware for authentication
- *
- * @example
- * ```typescript
- * // middleware.ts
- * import { auth } from '@/auth'
- * import { createProxyMiddleware } from 'mulguard/middleware/proxy'
- *
- * export default createProxyMiddleware({
- *   auth,
- *   protectedRoutes: ['/dashboard', '/profile'],
- *   redirectTo: '/login',
- * })
- *
- * export const config = {
- *   matcher: ['/((?!_next/static|_next/image|favicon.ico).*)'],
- * }
- * ```
- */
-export declare function createProxyMiddleware(config: ProxyMiddlewareConfig): (request: NextRequest) => Promise<NextResponse<unknown>>;
-/**
- * Helper to check if user has required role
- */
-export declare function checkRole(auth: MulguardInstance, requiredRole: string): Promise<boolean>;

package/dist/middleware/security.d.ts

@@ -1,9 +0,0 @@
-import { NextResponse, NextRequest } from 'next/server';
-/**
- * Apply security headers to response
- */
-export declare function withSecurityHeaders(_request: NextRequest, response: NextResponse): NextResponse;
-/**
- * Security middleware wrapper
- */
-export declare function createSecurityMiddleware(): (request: NextRequest) => Promise<NextResponse>;

package/dist/mulguard.d.ts

@@ -1,373 +0,0 @@
-import { MulguardConfig, Session, AuthResult, EmailCredentials, RegisterData, Verify2FAData, User, SessionConfig } from './core/types';
-/**
- * Main Mulguard authentication instance interface
- *
- * Provides all authentication methods using Server Actions
- * User implements custom logic in the config
- *
- * @example
- * ```typescript
- * const auth = mulguard({
- *   actions: {
- *     signIn: {
- *       email: async (credentials) => {
- *         // Your custom sign in logic
- *         const user = await db.user.findUnique({ where: { email: credentials.email } })
- *         if (!user || !await bcrypt.compare(credentials.password, user.password)) {
- *           return { success: false, error: 'Invalid credentials' }
- *         }
- *         return { success: true, user, session: { user, expiresAt: new Date() } }
- *       }
- *     }
- *   }
- * })
- * ```
- */
-export interface MulguardInstance {
-    /**
-     * Get current session
-     * Uses custom getSession action if provided, otherwise falls back to reading from cookie
-     */
-    getSession(): Promise<Session | null>;
-    /**
-     * Get access token from current session
-     */
-    getAccessToken(): Promise<string | null>;
-    /**
-     * Get refresh token from current session
-     */
-    getRefreshToken(): Promise<string | null>;
-    /**
-     * Check if session has valid tokens
-     */
-    hasValidTokens(): Promise<boolean>;
-    /**
-     * Set session directly (useful for Server Actions)
-     * Saves session to cookie automatically
-     *
-     * @param session - Session object to save
-     * @returns Result indicating success or failure
-     *
-     * @example
-     * ```typescript
-     * const result = await auth.setSession(newSession)
-     * if (!result.success) {
-     *   console.warn('Failed to save session:', result.error)
-     * }
-     * ```
-     */
-    setSession(session: Session): Promise<{
-        success: boolean;
-        error?: string;
-        warning?: string;
-    }>;
-    /**
-     * Internal method to get session config for Server Actions
-     * Used by verify2FAAction to save session cookie directly
-     * @internal
-     */
-    _getSessionConfig(): {
-        cookieName: string;
-        config: SessionConfig;
-    };
-    /**
-     * Internal method to get callbacks for Server Actions
-     * Used by Server Actions to execute callbacks
-     * @internal
-     */
-    _getCallbacks?(): import('./core/types').CallbacksConfig;
-    /**
-     * Internal method to get token refresh manager
-     * Used by HttpClient for automatic token refresh
-     * @internal
-     */
-    _getTokenRefreshManager?(): import('./core/client/token-refresh-manager').TokenRefreshManager | undefined;
-    /**
-     * Unified sign in method - supports both unified and direct method calls
-     *
-     * @example
-     * ```typescript
-     * // Unified interface (auth.js-like)
-     * await auth.signIn('google')
-     * await auth.signIn('credentials', { email: 'user@example.com', password: 'password' })
-     * await auth.signIn('otp', { email: 'user@example.com', code: '123456' })
-     *
-     * // Direct methods (for backward compatibility)
-     * await auth.signIn.email({ email: 'user@example.com', password: 'password' })
-     * await auth.signIn.oauth('google')
-     * ```
-     */
-    signIn: {
-        /**
-         * Unified sign in function - supports provider-based and direct method calls
-         */
-        (provider: 'google' | 'github' | 'apple' | 'facebook' | string): Promise<{
-            url: string;
-            state: string;
-        }>;
-        (provider: 'credentials', credentials: EmailCredentials): Promise<AuthResult>;
-        (provider: 'otp', options: {
-            email: string;
-            code?: string;
-        }): Promise<AuthResult>;
-        (provider: 'passkey', options?: {
-            userId?: string;
-        }): Promise<AuthResult>;
-        /**
-         * Sign in with email and password (direct method)
-         * Executes custom email action from config
-         */
-        email(credentials: EmailCredentials): Promise<AuthResult>;
-        /**
-         * Initiate OAuth sign in flow (direct method)
-         * Executes custom oauth action from config
-         */
-        oauth?(provider: string): Promise<{
-            url: string;
-            state: string;
-        }>;
-        /**
-         * Sign in with PassKey/WebAuthn (direct method)
-         * Executes custom passkey action from config
-         */
-        passkey?(options?: {
-            userId?: string;
-        }): Promise<AuthResult>;
-        /**
-         * Sign in with OTP (direct method)
-         * Executes custom otp action from config
-         */
-        otp?(email: string, code?: string): Promise<AuthResult>;
-    };
-    /**
-     * Sign in methods - uses custom actions from config (legacy interface)
-     */
-    signInMethods: {
-        /**
-         * Sign in with email and password
-         * Executes custom email action from config
-         */
-        email(credentials: EmailCredentials): Promise<AuthResult>;
-        /**
-         * Initiate OAuth sign in flow
-         * Executes custom oauth action from config
-         */
-        oauth?(provider: string): Promise<{
-            url: string;
-            state: string;
-        }>;
-        /**
-         * Sign in with PassKey/WebAuthn
-         * Executes custom passkey action from config
-         */
-        passkey?(options?: {
-            userId?: string;
-        }): Promise<AuthResult>;
-        /**
-         * Sign in with OTP
-         * Executes custom otp action from config
-         */
-        otp?(email: string, code?: string): Promise<AuthResult>;
-    };
-    /**
-     * Register new user
-     * Executes custom signUp action from config
-     */
-    signUp?(data: RegisterData): Promise<AuthResult>;
-    /**
-     * Sign out current session
-     * Executes custom signOut action from config
-     */
-    signOut(): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    /**
-     * Request password reset
-     * Executes custom resetPassword action from config
-     */
-    resetPassword?(email: string): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    /**
-     * Verify email address with token
-     * Executes custom verifyEmail action from config
-     */
-    verifyEmail?(token: string): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    /**
-     * Refresh session
-     * Executes custom refreshSession action from config with improved error handling
-     */
-    refreshSession?(): Promise<Session | null>;
-    /**
-     * OAuth callback handler
-     * Executes custom oauthCallback action from config
-     */
-    oauthCallback?(provider: string, code: string, state: string): Promise<AuthResult>;
-    /**
-     * Store OAuth state for validation (useful when using external backend API)
-     * This allows storing state generated by backend APIs in mulguard's state store
-     *
-     * @param state - OAuth state token
-     * @param provider - OAuth provider name
-     */
-    storeOAuthState?(state: string, provider: string): Promise<void>;
-    /**
-     * PassKey methods
-     */
-    passkey?: {
-        register?(options?: {
-            name?: string;
-            userId?: string;
-        }): Promise<{
-            success: boolean;
-            passkeyId?: string;
-            error?: string;
-        }>;
-        authenticate?(options?: {
-            userId?: string;
-        }): Promise<AuthResult>;
-        list?(): Promise<Array<{
-            id: string;
-            name: string;
-            createdAt: Date;
-            lastUsedAt?: Date;
-        }>>;
-        remove?(passKeyId: string): Promise<{
-            success: boolean;
-            error?: string;
-        }>;
-    };
-    /**
-     * Two-Factor Authentication methods
-     */
-    twoFactor?: {
-        enable?(): Promise<{
-            success: boolean;
-            qrCode?: string;
-            secret?: string;
-            error?: string;
-        }>;
-        verify?(code: string): Promise<{
-            success: boolean;
-            backupCodes?: string[];
-            error?: string;
-        }>;
-        disable?(): Promise<{
-            success: boolean;
-            error?: string;
-        }>;
-        generateBackupCodes?(): Promise<{
-            success: boolean;
-            backupCodes?: string[];
-            error?: string;
-        }>;
-        isEnabled?(): Promise<boolean>;
-        /**
-         * Verify 2FA code after initial sign in
-         * Used when signIn returns requires2FA: true
-         */
-        verify2FA?(data: Verify2FAData): Promise<AuthResult>;
-    };
-    /**
-     * Verify 2FA code after initial sign in
-     * Used when signIn returns requires2FA: true
-     *
-     * @param data - 2FA verification data
-     * @param options - Optional configuration
-     * @param options.skipCookieSave - If true, skip automatic cookie saving (useful for Server Actions)
-     */
-    verify2FA?(data: Verify2FAData, options?: {
-        skipCookieSave?: boolean;
-    }): Promise<AuthResult>;
-    /**
-     * Account Picker methods (optional)
-     * For remembering last logged-in users
-     */
-    accountPicker?: {
-        getLastUsers(): Promise<import('./core/types').RememberedUser[]>;
-        rememberUser(user: User, provider?: 'email' | 'oauth' | 'passkey'): Promise<void>;
-        clearUser(userId: string): Promise<void>;
-        clearAll(): Promise<void>;
-    };
-}
-/**
- * Create Mulguard instance with custom authentication actions
- *
- * @example
- * ```typescript
- * // lib/auth.ts
- * import { mulguard } from 'mulguard'
- *
- * export const auth = mulguard({
- *   session: {
- *     cookieName: '__mulguard_session',
- *     expiresIn: 60 * 60 * 24 * 7, // 7 days
- *   },
- *   actions: {
- *     signIn: {
- *       email: async (credentials) => {
- *         // Your custom sign in logic
- *         // Connect to your database, validate credentials, etc.
- *         const user = await yourDb.findUser(credentials.email)
- *         if (!user || !await verifyPassword(credentials.password, user.password)) {
- *           return { success: false, error: 'Invalid credentials' }
- *         }
- *
- *         const session = {
- *           user,
- *           expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)
- *         }
- *
- *         return { success: true, user, session }
- *       }
- *     },
- *     signUp: async (data) => {
- *       // Your custom sign up logic
- *       const user = await yourDb.createUser(data)
- *       return { success: true, user }
- *     },
- *     signOut: async () => {
- *       // Your custom sign out logic
- *       await yourDb.invalidateSession()
- *       return { success: true }
- *     },
- *     getSession: async () => {
- *       // Your custom session retrieval logic
- *       return await yourDb.getSession()
- *     }
- *   }
- * })
- * ```
- */
-/**
- * Creates a Mulguard authentication instance.
- *
- * @template TUser - User type (extends base User)
- * @template TSession - Session type (extends base Session)
- * @param config - Mulguard configuration
- * @returns Mulguard instance
- *
- * @example
- * ```typescript
- * const auth = mulguard({
- *   actions: {
- *     signIn: {
- *       email: async (credentials) => {
- *         // Your custom sign in logic
- *         const user = await db.user.findUnique({ where: { email: credentials.email } })
- *         if (!user || !await bcrypt.compare(credentials.password, user.password)) {
- *           return { success: false, error: 'Invalid credentials' }
- *         }
- *         return { success: true, user, session: { user, expiresAt: new Date() } }
- *       }
- *     }
- *   }
- * })
- * ```
- */
-export declare function mulguard<TUser extends User = User, TSession extends Session<TUser> = Session<TUser>>(config: MulguardConfig<TUser, TSession>): MulguardInstance;