@bagelink/auth 1.6.53 → 1.6.61

package/dist/pages/Callback.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/dist/pages/ForgotPasswordPage.vue.d.ts

@@ -0,0 +1,13 @@
+import { ForgotPasswordTexts } from '../components/auth/ForgotPasswordForm.vue';
+interface Props {
+    /** Custom texts for the forgot password form */
+    texts?: Partial<ForgotPasswordTexts>;
+    /** Card styling */
+    cardWidth?: string;
+    cardShadow?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    cardWidth: string;
+    cardShadow: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/pages/LoginPage.vue.d.ts

@@ -0,0 +1,38 @@
+import { LoginTexts } from '../components/auth/LoginForm.vue';
+interface Props {
+    /** Custom texts for the login form */
+    texts?: Partial<LoginTexts>;
+    /** Show/hide specific SSO providers */
+    showGithub?: boolean;
+    showGoogle?: boolean;
+    showMicrosoft?: boolean;
+    showApple?: boolean;
+    showOkta?: boolean;
+    showFacebook?: boolean;
+    /** SSO button styling */
+    ssoOutline?: boolean;
+    ssoShowValue?: boolean;
+    ssoBrandBackground?: boolean;
+    /** Show/hide form elements */
+    showForgotPassword?: boolean;
+    showSignupButton?: boolean;
+    /** Card styling */
+    cardWidth?: string;
+    cardShadow?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    showForgotPassword: boolean;
+    showSignupButton: boolean;
+    ssoOutline: boolean;
+    ssoShowValue: boolean;
+    ssoBrandBackground: boolean;
+    cardWidth: string;
+    cardShadow: boolean;
+    showGithub: boolean;
+    showGoogle: boolean;
+    showMicrosoft: boolean;
+    showApple: boolean;
+    showOkta: boolean;
+    showFacebook: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/pages/ResetPasswordPage.vue.d.ts

@@ -0,0 +1,13 @@
+import { ResetPasswordTexts } from '../components/auth/ResetPasswordForm.vue';
+interface Props {
+    /** Custom texts for the reset password form */
+    texts?: Partial<ResetPasswordTexts>;
+    /** Card styling */
+    cardWidth?: string;
+    cardShadow?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    cardWidth: string;
+    cardShadow: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/pages/SignupPage.vue.d.ts

@@ -0,0 +1,16 @@
+import { SignupTexts } from '../components/auth/SignupForm.vue';
+interface Props {
+    /** Custom texts for the signup form */
+    texts?: Partial<SignupTexts>;
+    /** Show name fields (first name, last name) */
+    showNames?: boolean;
+    /** Card styling */
+    cardWidth?: string;
+    cardShadow?: boolean;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {
+    showNames: boolean;
+    cardWidth: string;
+    cardShadow: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/routes.d.ts

@@ -0,0 +1,49 @@
+import { RouteRecordRaw } from 'vue-router';
+export interface AuthRouteConfig {
+    /** Base path for auth routes. Defaults to '/' */
+    basePath?: string;
+    /** Route names prefix. Defaults to '' */
+    namePrefix?: string;
+    /** Custom route names */
+    routeNames?: {
+        login?: string;
+        signup?: string;
+        forgotPassword?: string;
+        resetPassword?: string;
+        callback?: string;
+    };
+    /** Redirect path after successful auth. Defaults to '/' */
+    redirectTo?: string;
+    /** Custom layout wrapper component */
+    layout?: any;
+}
+/**
+ * Creates auth routes for Vue Router
+ *
+ * @example
+ * ```ts
+ * import { createAuthRoutes } from '@bagelink/auth'
+ *
+ * const routes = [
+ *   ...createAuthRoutes({
+ *     basePath: '/auth',
+ *     redirectTo: '/dashboard'
+ *   }),
+ *   // ... other routes
+ * ]
+ * ```
+ */
+export declare function createAuthRoutes(config?: AuthRouteConfig): RouteRecordRaw[];
+/**
+ * Creates a navigation guard to redirect authenticated users away from auth pages
+ *
+ * @example
+ * ```ts
+ * import { createAuthGuard } from '@bagelink/auth'
+ *
+ * router.beforeEach(createAuthGuard({ redirectTo: '/dashboard' }))
+ * ```
+ */
+export declare function createAuthGuard(config?: {
+    redirectTo?: string;
+}): (to: any, _from: any, next: any) => Promise<void>;

package/dist/sso.d.ts

@@ -0,0 +1,145 @@
+import { SSOProvider, AuthenticationResponse } from './types';
+/**
+ * Set the auth context for SSO operations
+ * This is called automatically when using useAuth()
+ */
+export declare function setAuthContext(authApi: any): void;
+/**
+ * SSO Provider Configuration
+ */
+export interface SSOProviderConfig {
+    /** Provider identifier */
+    id: SSOProvider;
+    /** Display name */
+    name: string;
+    /** Brand color (hex) */
+    color: string;
+    /** Icon identifier (for UI libraries) */
+    icon: string;
+    /** Default OAuth scopes */
+    defaultScopes: string[];
+    /** Provider-specific metadata */
+    metadata?: {
+        authDomain?: string;
+        buttonText?: string;
+        [key: string]: any;
+    };
+}
+/**
+ * OAuth Flow Options
+ */
+export interface OAuthFlowOptions {
+    /** Custom redirect URI (defaults to current origin + /auth/callback) */
+    redirectUri?: string;
+    /** State parameter for CSRF protection (auto-generated if not provided) */
+    state?: string;
+    /** Custom scopes (overrides provider defaults) */
+    scopes?: string[];
+    /** Additional OAuth parameters (prompt, login_hint, hd, domain, etc.) */
+    params?: Record<string, string>;
+    /** Popup window dimensions */
+    popupDimensions?: {
+        width?: number;
+        height?: number;
+    };
+    /** Timeout for popup flow in milliseconds (default: 90000) */
+    popupTimeout?: number;
+}
+/**
+ * Popup Result
+ */
+export interface PopupResult {
+    code: string;
+    state?: string;
+    error?: string;
+}
+/**
+ * SSO Error Types
+ */
+export declare class SSOError extends Error {
+    code: string;
+    constructor(message: string, code: string);
+}
+export declare class PopupBlockedError extends SSOError {
+    constructor();
+}
+export declare class PopupClosedError extends SSOError {
+    constructor();
+}
+export declare class PopupTimeoutError extends SSOError {
+    constructor();
+}
+export declare class StateMismatchError extends SSOError {
+    constructor();
+}
+/**
+ * SSO Provider Instance with functional methods
+ */
+export interface SSOProviderInstance extends SSOProviderConfig {
+    /**
+     * Initiate OAuth flow with redirect (most common)
+     * User is redirected to provider's authorization page
+     */
+    redirect: (options?: OAuthFlowOptions) => Promise<void>;
+    /**
+     * Initiate OAuth flow in a popup window
+     * Returns the authorization code without leaving the page
+     */
+    popup: (options?: OAuthFlowOptions) => Promise<AuthenticationResponse>;
+    /**
+     * Complete OAuth flow after callback
+     * Call this on your callback page
+     */
+    callback: (code: string, state?: string) => Promise<AuthenticationResponse>;
+    /**
+     * Link this provider to the current logged-in user
+     * Call this after OAuth redirect completes on link callback page
+     */
+    link: (code: string, state?: string) => Promise<void>;
+    /**
+     * Unlink this provider from the current user
+     */
+    unlink: () => Promise<void>;
+    /**
+     * Get authorization URL without redirecting
+     */
+    getAuthUrl: (options?: OAuthFlowOptions) => Promise<string>;
+    /**
+     * Whether this provider supports popup flow
+     * Some providers (like Apple) work better with redirect
+     */
+    supportsPopup?: boolean;
+}
+/**
+ * SSO object type with providers and helper methods
+ */
+export interface SSOObject {
+    google: SSOProviderInstance;
+    microsoft: SSOProviderInstance;
+    github: SSOProviderInstance;
+    okta: SSOProviderInstance;
+    apple: SSOProviderInstance;
+    facebook: SSOProviderInstance;
+    handleCallback: () => Promise<AuthenticationResponse | null>;
+    handleLinkCallback: () => Promise<void>;
+}
+/**
+ * SSO object with providers and global helper methods
+ */
+export declare const sso: SSOObject;
+/**
+ * Array of all SSO provider instances
+ */
+export declare const ssoProvidersList: readonly SSOProviderInstance[];
+/**
+ * Get SSO provider instance by ID
+ */
+export declare function getSSOProvider(provider: SSOProvider): SSOProviderInstance | undefined;
+/**
+ * Get all available SSO providers
+ */
+export declare function getAllSSOProviders(): readonly SSOProviderInstance[];
+/**
+ * Check if a provider is supported
+ */
+export declare function isSupportedProvider(provider: string): provider is SSOProvider;

package/dist/types/index.d.ts

@@ -0,0 +1,41 @@
+export interface ForgotPasswordTexts {
+    title?: string;
+    emailLabel?: string;
+    submitButton?: string;
+    backToLogin?: string;
+    emailSentTitle?: string;
+    emailSentMessage?: string;
+}
+export interface LoginTexts {
+    title?: string;
+    emailLabel?: string;
+    passwordLabel?: string;
+    forgotPassword?: string;
+    submitButton?: string;
+    noAccount?: string;
+    signupLink?: string;
+}
+export interface ResetPasswordTexts {
+    title?: string;
+    newPasswordLabel?: string;
+    confirmPasswordLabel?: string;
+    submitButton?: string;
+    passwordStrength?: {
+        weak?: string;
+        medium?: string;
+        strong?: string;
+    };
+}
+export interface SignupTexts {
+    title?: string;
+    emailLabel?: string;
+    passwordLabel?: string;
+    submitButton?: string;
+    haveAccount?: string;
+    loginLink?: string;
+    passwordStrength?: {
+        weak?: string;
+        medium?: string;
+        strong?: string;
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,254 @@
+import { AxiosResponse } from 'axios';
+export declare enum AuthState {
+    LOGIN = "login",
+    LOGOUT = "logout",
+    SIGNUP = "signup",
+    PASSWORD_RESET = "password_reset",
+    PASSWORD_CHANGE = "password_change",
+    PROFILE_UPDATE = "profile_update",
+    AUTH_CHECK = "auth_check",
+    EMAIL_VERIFIED = "email_verified",
+    SESSION_REFRESH = "session_refresh"
+}
+export type AuthEventHandler = () => void;
+export interface AuthEventMap {
+    [AuthState.LOGIN]: AuthEventHandler;
+    [AuthState.LOGOUT]: AuthEventHandler;
+    [AuthState.SIGNUP]: AuthEventHandler;
+    [AuthState.PASSWORD_RESET]: AuthEventHandler;
+    [AuthState.PASSWORD_CHANGE]: AuthEventHandler;
+    [AuthState.PROFILE_UPDATE]: AuthEventHandler;
+    [AuthState.AUTH_CHECK]: AuthEventHandler;
+    [AuthState.EMAIL_VERIFIED]: AuthEventHandler;
+    [AuthState.SESSION_REFRESH]: AuthEventHandler;
+}
+export type AuthenticationAccountType = 'person' | 'entity' | 'service';
+export type AuthenticationMethodType = 'password' | 'email_token' | 'sso' | 'otp';
+export type SSOProvider = 'google' | 'microsoft' | 'github' | 'okta' | 'apple' | 'facebook';
+export interface AuthenticationAccount {
+    created_at?: string;
+    updated_at?: string;
+    account_type?: AuthenticationAccountType;
+    person_id?: string;
+    entity_id?: string;
+    display_name?: string;
+    is_active?: boolean;
+    is_verified?: boolean;
+    account_metadata?: string;
+    last_login_at?: string;
+    failed_login_attempts?: number;
+    locked_until?: string;
+    id: string;
+}
+export interface PersonInfo {
+    id: string;
+    name: string;
+    email?: string;
+    phone?: string;
+    roles: string[];
+    first_name: string;
+    last_name: string;
+}
+export interface AuthMethodInfo {
+    id: string;
+    type: string;
+    identifier?: string;
+    is_verified: boolean;
+    last_used?: string;
+    use_count: number;
+    provider?: SSOProvider;
+    provider_user_id?: string;
+}
+export interface AccountInfo {
+    id: string;
+    account_type: string;
+    display_name: string;
+    is_active: boolean;
+    is_verified: boolean;
+    last_login?: string;
+    authentication_methods: AuthMethodInfo[];
+    person?: PersonInfo;
+    entity?: EntityInfo;
+}
+export interface EntityInfo {
+    id: string;
+    name: string;
+    type?: string;
+    metadata?: Record<string, any>;
+}
+export interface SessionInfo {
+    id: string;
+    created_at: string;
+    expires_at: string;
+    ip_address?: string;
+    user_agent?: string;
+    is_current?: boolean;
+}
+/**
+ * Unified user representation that works for both person and entity accounts
+ * This is the primary interface for accessing user data in the application
+ */
+export interface User {
+    /** Unique identifier (person_id or entity_id) */
+    id: string;
+    /** Account ID */
+    accountId: string;
+    /** Display name */
+    name: string;
+    /** Email address (from person or authentication methods) */
+    email?: string;
+    /** Account type: 'person', 'entity', or 'service' */
+    type: AuthenticationAccountType;
+    /** User roles (only for person accounts) */
+    roles?: string[];
+    /** Is the account active */
+    isActive: boolean;
+    /** Is the account verified */
+    isVerified: boolean;
+    /** Last login timestamp */
+    lastLogin?: string;
+    /** Entity-specific info (only for entity accounts) */
+    entityType?: string;
+    /** Additional metadata */
+    metadata?: Record<string, any>;
+    /** Person-specific info (only for person accounts) */
+    person?: PersonInfo;
+}
+export interface RegisterRequest {
+    email: string;
+    first_name: string;
+    last_name: string;
+    phone_number?: string;
+    password?: string;
+}
+export interface UpdateAccountRequest {
+    first_name?: string;
+    last_name?: string;
+    email?: string;
+    phone_number?: string;
+}
+export interface PasswordLoginRequest {
+    email: string;
+    password: string;
+}
+export interface ChangePasswordRequest {
+    current_password: string;
+    new_password: string;
+}
+export interface ForgotPasswordRequest {
+    email: string;
+}
+export interface ResetPasswordRequest {
+    token: string;
+    new_password: string;
+}
+export interface SendVerificationRequest {
+    email?: string;
+}
+export interface VerifyEmailRequest {
+    token: string;
+}
+export interface NewUser extends RegisterRequest {
+    confirmPassword: string;
+}
+export interface UpdatePasswordForm extends ChangePasswordRequest {
+    confirmNewPassword: string;
+}
+export interface MessageResponse {
+    message: string;
+}
+export interface AuthStatusResponse {
+    status: string;
+    methods: string[];
+}
+export interface AvailableMethodsResponse {
+    available_methods: {
+        [key: string]: any;
+    }[];
+}
+export interface OTPMetadata {
+    nonce: string;
+    verification_hash: string;
+    timestamp: number;
+    expires_in_minutes: number;
+    autofill: {
+        [key: string]: any;
+    };
+}
+export interface SSOMetadata {
+    provider: SSOProvider;
+    sso_user_info: {
+        [key: string]: any;
+    };
+    can_create_account?: boolean;
+}
+export interface SSOInitiateRequest {
+    provider: SSOProvider;
+    redirect_uri?: string;
+    state?: string;
+    scopes?: string[];
+    params?: Record<string, string>;
+    code_challenge?: string;
+    code_challenge_method?: 'S256' | 'plain';
+}
+export interface SSOCallbackRequest {
+    provider: SSOProvider;
+    code: string;
+    state?: string;
+}
+export interface SSOLinkRequest {
+    provider: SSOProvider;
+    code: string;
+    state: string;
+}
+export interface SSOUnlinkRequest {
+    provider: SSOProvider;
+}
+export interface AuthenticationResponse {
+    success: boolean;
+    account_id?: string;
+    session_token?: string;
+    requires_verification?: boolean;
+    verification_method?: AuthenticationMethodType;
+    message?: string;
+    metadata?: OTPMetadata | SSOMetadata | {
+        [key: string]: any;
+    };
+}
+export interface SessionListResponse {
+    account_id: string;
+    sessions: SessionInfo[];
+}
+export type LoginResponse = AxiosResponse<AuthenticationResponse>;
+export type RegisterResponse = AxiosResponse<AuthenticationResponse>;
+export type LogoutResponse = AxiosResponse<MessageResponse>;
+export type GetMeResponse = AxiosResponse<AccountInfo>;
+export type UpdateMeResponse = AxiosResponse<AccountInfo>;
+export type DeleteMeResponse = AxiosResponse<MessageResponse>;
+export type GetAccountResponse = AxiosResponse<AccountInfo>;
+export type UpdateAccountResponse = AxiosResponse<AccountInfo>;
+export type DeleteAccountResponse = AxiosResponse<MessageResponse>;
+export type ActivateAccountResponse = AxiosResponse<AccountInfo>;
+export type DeactivateAccountResponse = AxiosResponse<AccountInfo>;
+export type ChangePasswordResponse = AxiosResponse<MessageResponse>;
+export type ForgotPasswordResponse = AxiosResponse<MessageResponse>;
+export type ResetPasswordResponse = AxiosResponse<MessageResponse>;
+export type VerifyResetTokenResponse = AxiosResponse<MessageResponse>;
+export type SendVerificationResponse = AxiosResponse<MessageResponse>;
+export type VerifyEmailResponse = AxiosResponse<MessageResponse>;
+export type RefreshSessionResponse = AxiosResponse<AuthenticationResponse>;
+export type GetSessionsResponse = AxiosResponse<SessionListResponse>;
+export type DeleteSessionResponse = AxiosResponse<MessageResponse>;
+export type DeleteAllSessionsResponse = AxiosResponse<MessageResponse>;
+export type CleanupSessionsResponse = AxiosResponse<MessageResponse>;
+export type GetMethodsResponse = AxiosResponse<AvailableMethodsResponse>;
+export type SSOInitiateResponse = AxiosResponse<{
+    authorization_url: string;
+}>;
+export type SSOCallbackResponse = AxiosResponse<AuthenticationResponse>;
+export type SSOLinkResponse = AxiosResponse<MessageResponse>;
+export type SSOUnlinkResponse = AxiosResponse<MessageResponse>;
+/**
+ * Extract unified user from account info
+ */
+export declare function accountToUser(account: AccountInfo | null): User | null;

package/dist/useAuth.d.ts

@@ -0,0 +1,112 @@
+import { App } from 'vue';
+import { AccountInfo, User, NewUser, UpdatePasswordForm, UpdateAccountRequest, AuthEventMap, SSOProvider, SSOInitiateRequest, SSOCallbackRequest, SSOLinkRequest, AuthState } from './types';
+export declare function initAuth({ baseURL, }: {
+    baseURL: string;
+}): {
+    on<K extends AuthState>(event: K, handler: AuthEventMap[K]): void;
+    off<K extends AuthState>(event: K, handler: AuthEventMap[K]): void;
+    removeAllListeners<K extends AuthState>(event?: K): void;
+    install(app: App): void;
+};
+export declare function useAuth(): {
+    user: import('vue').ComputedRef<User | null>;
+    accountInfo: import('vue').Ref<{
+        id: string;
+        account_type: string;
+        display_name: string;
+        is_active: boolean;
+        is_verified: boolean;
+        last_login?: string | undefined;
+        authentication_methods: {
+            id: string;
+            type: string;
+            identifier?: string | undefined;
+            is_verified: boolean;
+            last_used?: string | undefined;
+            use_count: number;
+            provider?: SSOProvider | undefined;
+            provider_user_id?: string | undefined;
+        }[];
+        person?: {
+            id: string;
+            name: string;
+            email?: string | undefined;
+            phone?: string | undefined;
+            roles: string[];
+            first_name: string;
+            last_name: string;
+        } | undefined;
+        entity?: {
+            id: string;
+            name: string;
+            type?: string | undefined;
+            metadata?: Record<string, any> | undefined;
+        } | undefined;
+    } | null, AccountInfo | {
+        id: string;
+        account_type: string;
+        display_name: string;
+        is_active: boolean;
+        is_verified: boolean;
+        last_login?: string | undefined;
+        authentication_methods: {
+            id: string;
+            type: string;
+            identifier?: string | undefined;
+            is_verified: boolean;
+            last_used?: string | undefined;
+            use_count: number;
+            provider?: SSOProvider | undefined;
+            provider_user_id?: string | undefined;
+        }[];
+        person?: {
+            id: string;
+            name: string;
+            email?: string | undefined;
+            phone?: string | undefined;
+            roles: string[];
+            first_name: string;
+            last_name: string;
+        } | undefined;
+        entity?: {
+            id: string;
+            name: string;
+            type?: string | undefined;
+            metadata?: Record<string, any> | undefined;
+        } | undefined;
+    } | null>;
+    sso: import('./sso').SSOObject;
+    getFullName: () => string;
+    getIsLoggedIn: () => boolean;
+    getEmail: () => string;
+    getRoles: () => string[];
+    getAccountType: () => import('./types').AuthenticationAccountType;
+    isPersonAccount: () => boolean;
+    isEntityAccount: () => boolean;
+    login: (credentials: {
+        email: string;
+        password: string;
+    }) => Promise<import('./types').AuthenticationResponse>;
+    logout: () => Promise<void>;
+    signup: (newUser: NewUser) => Promise<import('./types').AuthenticationResponse>;
+    checkAuth: () => Promise<boolean>;
+    refreshSession: () => Promise<void>;
+    initiateSSO: (params: SSOInitiateRequest) => Promise<string>;
+    loginWithSSO: (params: SSOCallbackRequest) => Promise<import('./types').AuthenticationResponse>;
+    linkSSOProvider: (params: SSOLinkRequest) => Promise<void>;
+    unlinkSSOProvider: (provider: SSOProvider) => Promise<void>;
+    updateProfile: (updates: UpdateAccountRequest) => Promise<void>;
+    deleteCurrentUser: () => Promise<void>;
+    changePassword: (form: UpdatePasswordForm) => Promise<void>;
+    forgotPassword: (email: string) => Promise<void>;
+    verifyResetToken: (token: string) => Promise<void>;
+    resetPassword: (token: string, newPassword: string) => Promise<void>;
+    sendVerification: (email?: string) => Promise<void>;
+    verifyEmail: (token: string) => Promise<void>;
+    activateAccount: (accountId: string) => Promise<void>;
+    deactivateAccount: (accountId: string) => Promise<void>;
+    deleteAccount: (accountId: string) => Promise<void>;
+    getSessions: (accountId?: string) => Promise<import('./types').GetSessionsResponse>;
+    revokeSession: (sessionToken: string) => Promise<void>;
+    revokeAllSessions: (accountId?: string) => Promise<void>;
+};