mulguard 1.1.7 → 1.1.9

package/dist/index.d.ts

@@ -1,18 +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 './nextjs/server';
-export * from './nextjs/handlers';
-export * from './nextjs/proxy';

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;

package/dist/nextjs/client/hooks.d.ts

@@ -1,122 +0,0 @@
-import { Session, AuthResult, EmailCredentials, RegisterData, RememberedUser, Verify2FAData } from '../../core/types';
-import { MulguardInstance } from '../../mulguard';
-export interface UseAuthReturn {
-    session: Session | null;
-    isLoading: boolean;
-    /**
-     * Unified sign in method - professional interface similar to auth.js
-     *
-     * @example
-     * ```typescript
-     * // OAuth providers
-     * await signIn('google')
-     * await signIn('github')
-     *
-     * // Credentials
-     * await signIn('credentials', { email: 'user@example.com', password: 'password' })
-     *
-     * // OTP
-     * await signIn('otp', { email: 'user@example.com', code: '123456' })
-     * ```
-     */
-    signIn(provider: 'google' | 'github' | 'apple' | 'facebook' | string): Promise<{
-        url: string;
-        state: string;
-    }>;
-    signIn(provider: 'credentials', credentials: EmailCredentials): Promise<AuthResult>;
-    signIn(provider: 'otp', options: {
-        email: string;
-        code?: string;
-    }): Promise<AuthResult>;
-    signIn(provider: 'passkey', options?: {
-        userId?: string;
-    }): Promise<AuthResult>;
-    /**
-     * Legacy sign in methods (for backward compatibility)
-     */
-    signInMethods: {
-        email(credentials: EmailCredentials): Promise<AuthResult>;
-        oauth(provider: string): Promise<{
-            url: string;
-            state: string;
-        }>;
-        passkey(options?: {
-            userId?: string;
-        }): Promise<AuthResult>;
-        otp(email: string, code?: string): Promise<AuthResult>;
-    };
-    signUp(data: RegisterData): Promise<AuthResult>;
-    signOut(): Promise<void>;
-    resetPassword(email: string): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    verifyEmail(token: string): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    verify2FA(data: Verify2FAData): Promise<AuthResult>;
-}
-export interface UseSessionReturn {
-    session: Session | null;
-    isLoading: boolean;
-    error: Error | null;
-}
-export interface UseAccountPickerReturn {
-    lastUsers: RememberedUser[];
-    isLoading: boolean;
-    rememberUser: (user: {
-        id: string;
-        email: string;
-        name: string;
-        avatar?: string;
-    }, provider?: 'email' | 'oauth' | 'passkey') => Promise<void>;
-    clearUser: (userId: string) => Promise<void>;
-    clearAll: () => Promise<void>;
-    refresh: () => Promise<void>;
-}
-/**
- * Main authentication hook
- *
- * @example
- * ```tsx
- * import { useAuth } from 'mulguard/client'
- * import { auth } from '@/auth'
- *
- * function LoginButton() {
- *   const { session, signIn, signOut } = useAuth(auth)
- *   // ...
- * }
- * ```
- */
-export declare function useAuth(auth: MulguardInstance): UseAuthReturn;
-/**
- * Session hook
- *
- * @example
- * ```tsx
- * import { useSession } from 'mulguard/client'
- * import { auth } from '@/auth'
- *
- * function Profile() {
- *   const { session, isLoading } = useSession(auth)
- *   // ...
- * }
- * ```
- */
-export declare function useSession(auth: MulguardInstance): UseSessionReturn;
-/**
- * Account Picker hook
- *
- * @example
- * ```tsx
- * import { useAccountPicker } from 'mulguard/client'
- * import { auth } from '@/auth'
- *
- * function AccountList() {
- *   const { lastUsers, clearUser } = useAccountPicker(auth)
- *   // ...
- * }
- * ```
- */
-export declare function useAccountPicker(auth: MulguardInstance): UseAccountPickerReturn;

package/dist/nextjs/client/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * Next.js Client-Side Integration for Mulguard Authentication Library.
- *
- * Provides client-side utilities for Next.js including:
- * - React hooks (useAuth, useSession)
- * - Provider component
- * - Client-side session management
- *
- * @module @mulguard/nextjs/client
- */
-export * from './hooks';
-export * from './provider';
-export type { Session, User, AuthResult } from '../../core/types';

package/dist/nextjs/client/provider.d.ts

@@ -1,69 +0,0 @@
-import { ReactNode } from 'react';
-import { MulguardInstance } from '../../mulguard';
-import { useSession, useAccountPicker } from './hooks';
-interface MulguardContextValue {
-    auth: MulguardInstance;
-    session: ReturnType<typeof useSession>;
-    accountPicker: ReturnType<typeof useAccountPicker>;
-}
-interface MulguardProviderProps {
-    auth: MulguardInstance;
-    children: ReactNode;
-}
-/**
- * Mulguard Provider - provides auth instance to children
- *
- * @example
- * ```tsx
- * import { MulguardProvider } from 'mulguard/client'
- * import { auth } from '@/lib/auth'
- *
- * export default function RootLayout({ children }) {
- *   return (
- *     <MulguardProvider auth={auth}>
- *       {children}
- *     </MulguardProvider>
- *   )
- * }
- * ```
- */
-export declare function MulguardProvider({ auth, children }: MulguardProviderProps): import("react/jsx-runtime").JSX.Element;
-/**
- * Use Mulguard context
- *
- * @example
- * ```tsx
- * import { useMulguardContext } from 'mulguard/client'
- *
- * function Component() {
- *   const { auth, session } = useMulguardContext()
- *   // ...
- * }
- * ```
- */
-export declare function useMulguardContext(): MulguardContextValue;
-/**
- * Convenience hook that uses context
- *
- * @example
- * ```tsx
- * import { useAuthFromContext } from 'mulguard/client'
- *
- * function Component() {
- *   const { signIn, signOut } = useAuthFromContext()
- *   // ...
- * }
- * ```
- */
-export declare function useAuthFromContext(): import('./hooks').UseAuthReturn;
-/**
- * @deprecated Use MulguardProvider instead
- * This is kept for backward compatibility
- */
-export declare const AuthProvider: typeof MulguardProvider;
-/**
- * @deprecated Use useMulguardContext instead
- * This is kept for backward compatibility
- */
-export declare const useAuthContext: typeof useMulguardContext;
-export {};

package/dist/nextjs/client/server-actions-helper.d.ts

@@ -1,22 +0,0 @@
-import { MulguardInstance } from '../../mulguard';
-import { Verify2FAData, AuthResult, EmailCredentials, RegisterData } from '../../core/types';
-/**
- * Verify 2FA with automatic fallback
- * Tries Server Action first, then falls back to Route Handler
- */
-export declare function verify2FAWithFallback(auth: MulguardInstance, data: Verify2FAData): Promise<AuthResult>;
-/**
- * Sign out with automatic fallback
- */
-export declare function signOutWithFallback(auth: MulguardInstance): Promise<{
-    success: boolean;
-    error?: string;
-}>;
-/**
- * Sign in with email with automatic fallback
- */
-export declare function signInEmailWithFallback(auth: MulguardInstance, credentials: EmailCredentials): Promise<AuthResult>;
-/**
- * Sign up with automatic fallback
- */
-export declare function signUpWithFallback(auth: MulguardInstance, data: RegisterData): Promise<AuthResult>;

package/dist/nextjs/handlers/api.d.ts

@@ -1,10 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server';
-import { MulguardInstance } from '../../mulguard';
-/**
- * Create API route handler
- */
-export declare function createApiHandler(_auth: MulguardInstance): (request: NextRequest) => Promise<NextResponse<any>>;
-/**
- * OAuth callback handler
- */
-export declare function createOAuthCallbackHandler(auth: MulguardInstance): (request: NextRequest) => Promise<NextResponse<unknown>>;

package/dist/nextjs/handlers/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Next.js Route Handlers for Mulguard Authentication Library.
- *
- * Provides route handlers for Next.js App Router API routes.
- *
- * @module @mulguard/nextjs/handlers
- */
-export { toNextJsHandler } from './route';
-export { createApiHandler } from './api';