@mohasinac/appkit 2.3.0 → 2.3.1

package/dist/features/auth/hooks/useAuth.js

@@ -0,0 +1,163 @@
+"use client";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { getClientAuthProvider } from "../../../contracts/client-auth";
+import { apiClient } from "../../../http";
+import { useAuthEvent } from "./useAuthEvent";
+import { RealtimeEventStatus } from "../../../react/hooks/useRealtimeEvent";
+import { AUTH_ENDPOINTS, ACCOUNT_ENDPOINTS, } from "../../../constants/api-endpoints";
+export function useCurrentUser(opts) {
+    const query = useQuery({
+        queryKey: ["auth", "me"],
+        queryFn: async () => {
+            try {
+                return await apiClient.get(AUTH_ENDPOINTS.ME);
+            }
+            catch {
+                return null;
+            }
+        },
+        initialData: opts?.initialData ?? undefined,
+        enabled: opts?.enabled,
+        staleTime: 5 * 60 * 1000,
+    });
+    return {
+        user: query.data ?? null,
+        isLoading: query.isLoading,
+        isAuthenticated: !!query.data,
+        error: query.error,
+        refetch: query.refetch,
+    };
+}
+export function useLogin(options) {
+    return useMutation({
+        mutationFn: async (credentials) => {
+            await apiClient.post(AUTH_ENDPOINTS.LOGIN, {
+                email: credentials.email.trim(),
+                password: credentials.password,
+            });
+            await getClientAuthProvider().signInWithEmailAndPassword(credentials.email.trim(), credentials.password);
+            return { success: true };
+        },
+        onSuccess: options?.onSuccess,
+        onError: options?.onError,
+    });
+}
+export function useGoogleLogin(options) {
+    const authEvent = useAuthEvent();
+    const [initiating, setInitiating] = useState(false);
+    const onSuccessRef = useRef(options?.onSuccess);
+    const onErrorRef = useRef(options?.onError);
+    const onSessionSyncedRef = useRef(options?.onSessionSynced);
+    useEffect(() => {
+        onSuccessRef.current = options?.onSuccess;
+    }, [options?.onSuccess]);
+    useEffect(() => {
+        onErrorRef.current = options?.onError;
+    }, [options?.onError]);
+    useEffect(() => {
+        onSessionSyncedRef.current = options?.onSessionSynced;
+    }, [options?.onSessionSynced]);
+    useEffect(() => {
+        if (authEvent.status === RealtimeEventStatus.SUCCESS) {
+            Promise.resolve(onSessionSyncedRef.current?.()).then(() => {
+                onSuccessRef.current?.(authEvent.data);
+            });
+        }
+        else if (authEvent.status === RealtimeEventStatus.FAILED ||
+            authEvent.status === RealtimeEventStatus.TIMEOUT) {
+            onErrorRef.current?.(new Error(authEvent.error ?? "Sign-in failed. Please try again."));
+        }
+    }, [authEvent.status, authEvent.error, authEvent.data]);
+    const mutate = useCallback(async () => {
+        const popup = window.open(`${window.location.origin}/auth.html`, "oauth_google", "width=500,height=660,left=400,top=100");
+        if (!popup) {
+            onErrorRef.current?.(new Error("Popup blocked. Please allow popups for this site."));
+            return;
+        }
+        try {
+            setInitiating(true);
+            authEvent.reset();
+            const { eventId, customToken } = await apiClient.post(AUTH_ENDPOINTS.EVENT_INIT, {});
+            const url = `${window.location.origin}${AUTH_ENDPOINTS.GOOGLE_START}?eventId=${encodeURIComponent(eventId)}`;
+            localStorage.setItem("letitrip_oauth_redirect", url);
+            authEvent.subscribe(eventId, customToken);
+        }
+        catch (err) {
+            popup.close();
+            onErrorRef.current?.(err instanceof Error ? err : new Error("Failed to start sign-in."));
+        }
+        finally {
+            setInitiating(false);
+        }
+    }, [authEvent]);
+    const isLoading = initiating ||
+        authEvent.status === RealtimeEventStatus.SUBSCRIBING ||
+        authEvent.status === RealtimeEventStatus.PENDING;
+    return { mutate, isLoading };
+}
+export function useRegister(options) {
+    return useMutation({
+        mutationFn: async (data) => {
+            const response = await apiClient.post(AUTH_ENDPOINTS.REGISTER, {
+                email: data.email.trim(),
+                password: data.password,
+                displayName: data.displayName?.trim() || "",
+                acceptTerms: data.acceptTerms,
+            });
+            await getClientAuthProvider().signInWithEmailAndPassword(data.email.trim(), data.password);
+            return { success: true, ...response };
+        },
+        onSuccess: options?.onSuccess,
+        onError: options?.onError,
+    });
+}
+export function useVerifyEmail(options) {
+    return useMutation({
+        mutationFn: async ({ token }) => {
+            const authProvider = getClientAuthProvider();
+            await authProvider.applyActionCode(token);
+            await authProvider.reloadCurrentUser();
+            return { success: true, emailVerified: true };
+        },
+        onSuccess: options?.onSuccess,
+        onError: options?.onError,
+    });
+}
+export function useResendVerification(options) {
+    return useMutation({
+        mutationFn: (data) => apiClient.post(AUTH_ENDPOINTS.RESEND_VERIFICATION, data),
+        onSuccess: options?.onSuccess,
+        onError: options?.onError,
+    });
+}
+export function useForgotPassword(options) {
+    return useMutation({
+        mutationFn: async (data) => {
+            await getClientAuthProvider().sendPasswordResetEmail(data.email);
+            return { success: true };
+        },
+        onSuccess: options?.onSuccess,
+        onError: options?.onError,
+    });
+}
+export function useResetPassword(options) {
+    return useMutation({
+        mutationFn: async (data) => {
+            await getClientAuthProvider().confirmPasswordReset(data.token, data.newPassword);
+            return { success: true };
+        },
+        onSuccess: options?.onSuccess,
+        onError: options?.onError,
+    });
+}
+export function useChangePassword(options) {
+    return useMutation({
+        mutationFn: async (data) => {
+            await getClientAuthProvider().reauthenticateAndChangePassword(data.currentPassword, data.newPassword);
+            return apiClient.post(ACCOUNT_ENDPOINTS.CHANGE_PASSWORD, data);
+        },
+        onSuccess: options?.onSuccess,
+        onError: options?.onError,
+    });
+}

package/dist/features/auth/hooks/useAuthEvent.d.ts

@@ -0,0 +1,22 @@
+import type { IClientRealtimeProvider } from "../../../contracts/client-realtime";
+import { RealtimeEventStatus, type RealtimeEventMessages } from "../../../react";
+export type { RealtimeEventStatus as AuthEventStatus };
+export interface AuthEventData {
+    isNewUser: boolean;
+    uid: string;
+    role: string;
+}
+export interface UseAuthEventReturn {
+    status: RealtimeEventStatus;
+    error: string | null;
+    data: AuthEventData | null;
+    subscribe: (eventId: string, customToken: string) => void;
+    reset: () => void;
+}
+export interface UseAuthEventOptions {
+    rtdbPath?: string;
+    timeoutMs?: number;
+    messages?: RealtimeEventMessages;
+    realtimeProvider?: IClientRealtimeProvider;
+}
+export declare function useAuthEvent(options?: UseAuthEventOptions): UseAuthEventReturn;

package/dist/features/auth/hooks/useAuthEvent.js

@@ -0,0 +1,30 @@
+import { logger } from "../../../core/Logger";
+import { RealtimeEventType, useRealtimeEvent, } from "../../../react";
+const AUTH_EVENT_TIMEOUT_MS = 5 * 60 * 1000;
+const DEFAULT_RTDB_PATH = "auth_events";
+function extractAuthData(raw) {
+    if (typeof raw.uid !== "string" ||
+        typeof raw.role !== "string" ||
+        typeof raw.isNewUser !== "boolean") {
+        return null;
+    }
+    return { isNewUser: raw.isNewUser, uid: raw.uid, role: raw.role };
+}
+export function useAuthEvent(options) {
+    const { status, error, data, subscribe, reset } = useRealtimeEvent({
+        type: RealtimeEventType.AUTH,
+        rtdbPath: options?.rtdbPath ?? DEFAULT_RTDB_PATH,
+        realtimeProvider: options?.realtimeProvider,
+        timeoutMs: options?.timeoutMs ?? AUTH_EVENT_TIMEOUT_MS,
+        onLogError: (message, err) => logger.error(message, err),
+        extractData: extractAuthData,
+        messages: {
+            tokenFailure: "Failed to initialize sign-in. Please try again.",
+            connectionLost: "Sign-in tracking connection was lost.",
+            timedOut: "Sign-in timed out. Please try again.",
+            failure: "Sign-in failed. Please try again.",
+            ...(options?.messages ?? {}),
+        },
+    });
+    return { status, error, data, subscribe, reset };
+}

package/dist/features/auth/hooks/useLogout.d.ts

@@ -0,0 +1,16 @@
+/**
+ * useLogout
+ *
+ * Mutation hook that calls the backend logout endpoint to clear the session
+ * cookie and revoke tokens.
+ *
+ * @example
+ * const { mutateAsync: logout } = useLogout();
+ * await logout();
+ */
+export declare function useLogout(options?: {
+    /** Override the logout API endpoint. Defaults to `/api/auth/logout`. */
+    endpoint?: string;
+    onSuccess?: () => void;
+    onError?: (err: Error) => void;
+}): import("@tanstack/react-query").UseMutationResult<void, Error, void, unknown>;

package/dist/features/auth/hooks/useLogout.js

@@ -0,0 +1,21 @@
+import { useMutation } from "@tanstack/react-query";
+import { apiClient } from "../../../http";
+import { AUTH_ENDPOINTS } from "../../../constants/api-endpoints";
+/**
+ * useLogout
+ *
+ * Mutation hook that calls the backend logout endpoint to clear the session
+ * cookie and revoke tokens.
+ *
+ * @example
+ * const { mutateAsync: logout } = useLogout();
+ * await logout();
+ */
+export function useLogout(options) {
+    const endpoint = options?.endpoint ?? AUTH_ENDPOINTS.LOGOUT;
+    return useMutation({
+        mutationFn: () => apiClient.post(endpoint, {}),
+        onSuccess: options?.onSuccess,
+        onError: options?.onError,
+    });
+}

package/dist/features/auth/hooks/useRBAC.d.ts

@@ -0,0 +1,38 @@
+import type { UserRole } from "../types";
+import { useCurrentUser } from "./useAuth";
+export declare function useHasRole(role: UserRole | UserRole[]): boolean;
+export declare function useIsAdmin(): boolean;
+export declare function useIsModerator(): boolean;
+export declare function useIsSeller(): boolean;
+export declare function useCanAccess(path: string, options?: {
+    checkAccess?: (user: {
+        role?: string;
+        emailVerified?: boolean;
+    } | null, path: string) => {
+        allowed: boolean;
+        reason?: string;
+        redirectTo?: string;
+    };
+}): {
+    allowed: boolean;
+    reason?: string;
+    redirectTo?: string;
+};
+export declare function useRoleChecks(): {
+    isAuthenticated: boolean;
+    isAdmin: boolean;
+    isModerator: boolean;
+    isSeller: boolean;
+    isUser: boolean;
+    role: UserRole | null;
+    hasRole: (role: UserRole | UserRole[]) => boolean;
+};
+export declare function useIsOwner(resourceOwnerId: string | null | undefined): boolean;
+export declare function useRequireAuth(): {
+    user: NonNullable<ReturnType<typeof useCurrentUser>["user"]>;
+    loading: boolean;
+};
+export declare function useRequireRole(role: UserRole | UserRole[]): {
+    user: NonNullable<ReturnType<typeof useCurrentUser>["user"]>;
+    loading: boolean;
+};

package/dist/features/auth/hooks/useRBAC.js

@@ -0,0 +1,80 @@
+"use client";
+import { useCallback, useMemo } from "react";
+import { AuthenticationError, AuthorizationError } from "../../../errors";
+import { hasRole as checkRoleHierarchy } from "../auth-helpers";
+import { useCurrentUser } from "./useAuth";
+export function useHasRole(role) {
+    const { user } = useCurrentUser();
+    if (!user?.role)
+        return false;
+    const roles = Array.isArray(role) ? role : [role];
+    return roles.some((requiredRole) => checkRoleHierarchy(user.role, requiredRole));
+}
+export function useIsAdmin() {
+    return useHasRole("admin");
+}
+export function useIsModerator() {
+    return useHasRole(["moderator", "admin"]);
+}
+export function useIsSeller() {
+    return useHasRole(["seller", "moderator", "admin"]);
+}
+export function useCanAccess(path, options) {
+    const { user } = useCurrentUser();
+    if (options?.checkAccess) {
+        return options.checkAccess(user
+            ? {
+                role: user.role,
+                emailVerified: user.isEmailVerified,
+            }
+            : null, path);
+    }
+    return { allowed: true };
+}
+export function useRoleChecks() {
+    const { user } = useCurrentUser();
+    const hasRole = useCallback((role) => {
+        if (!user?.role)
+            return false;
+        const roles = Array.isArray(role) ? role : [role];
+        return roles.some((requiredRole) => checkRoleHierarchy(user.role, requiredRole));
+    }, [user?.role]);
+    return useMemo(() => ({
+        isAuthenticated: !!user,
+        isAdmin: hasRole("admin"),
+        isModerator: hasRole(["moderator", "admin"]),
+        isSeller: hasRole(["seller", "moderator", "admin"]),
+        isUser: !!user && (user.role ?? "user") === "user",
+        role: user?.role ?? null,
+        hasRole,
+    }), [user, hasRole]);
+}
+export function useIsOwner(resourceOwnerId) {
+    const { user } = useCurrentUser();
+    if (!user || !resourceOwnerId)
+        return false;
+    if (useHasRole("admin"))
+        return true;
+    return user.id === resourceOwnerId;
+}
+export function useRequireAuth() {
+    const { user, isLoading } = useCurrentUser();
+    if (!isLoading && !user) {
+        throw new AuthenticationError("Authentication required");
+    }
+    return {
+        user: user,
+        loading: isLoading,
+    };
+}
+export function useRequireRole(role) {
+    const { user, loading } = useRequireAuth();
+    if (!loading && user) {
+        const roles = Array.isArray(role) ? role : [role];
+        const userRole = user.role || "user";
+        if (!roles.some((requiredRole) => checkRoleHierarchy(userRole, requiredRole))) {
+            throw new AuthorizationError("Insufficient permissions");
+        }
+    }
+    return { user, loading };
+}

package/dist/features/auth/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./types";
+export * from "./schemas";
+export * from "./auth-helpers";
+export * from "./token-helpers";
+export * from "./hooks/useAuth";
+export * from "./hooks/useAuthEvent";
+export * from "./hooks/useRBAC";
+export * from "./hooks/useLogout";
+export * from "./components";
+export { manifest } from "./manifest";

package/dist/features/auth/index.js

@@ -0,0 +1,10 @@
+export * from "./types";
+export * from "./schemas";
+export * from "./auth-helpers";
+export * from "./token-helpers";
+export * from "./hooks/useAuth";
+export * from "./hooks/useAuthEvent";
+export * from "./hooks/useRBAC";
+export * from "./hooks/useLogout";
+export * from "./components";
+export { manifest } from "./manifest";

package/dist/features/auth/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { FeatureManifest } from "../../contracts";
+export declare const manifest: FeatureManifest;

package/dist/features/auth/manifest.js

@@ -0,0 +1,21 @@
+export const manifest = {
+    name: "auth",
+    i18nNamespace: "auth",
+    envKeys: [],
+    routes: [
+        { segment: "[locale]/auth/login", exports: { default: "LoginView" } },
+        { segment: "[locale]/auth/register", exports: { default: "RegisterView" } },
+        {
+            segment: "[locale]/auth/forgot-password",
+            exports: { default: "ForgotPasswordView" },
+        },
+        {
+            segment: "[locale]/auth/reset-password",
+            exports: { default: "ResetPasswordView" },
+        },
+    ],
+    apiRoutes: [
+        { segment: "api/auth/me", methods: ["GET"] },
+        { segment: "api/auth/session", methods: ["POST", "DELETE"] },
+    ],
+};

package/dist/features/auth/messages/en.json

@@ -0,0 +1,13 @@
+{
+  "login": "Sign In",
+  "logout": "Sign Out",
+  "register": "Create Account",
+  "forgotPassword": "Forgot Password?",
+  "email": "Email",
+  "password": "Password",
+  "confirmPassword": "Confirm Password",
+  "displayName": "Full Name",
+  "invalidCredentials": "Invalid email or password",
+  "emailSent": "Check your email for a reset link",
+  "passwordUpdated": "Password updated successfully"
+}

package/dist/features/auth/repository/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./user.repository";
+export * from "./token.repository";
+export * from "./session.repository";
+export * from "./sms-counter.repository";

package/dist/features/auth/repository/index.js

@@ -0,0 +1,4 @@
+export * from "./user.repository";
+export * from "./token.repository";
+export * from "./session.repository";
+export * from "./sms-counter.repository";

package/dist/features/auth/repository/session.repository.d.ts

@@ -0,0 +1,43 @@
+import type { DocumentReference } from "firebase-admin/firestore";
+import { BaseRepository, type FirebaseSieveFields, type FirebaseSieveResult, type SieveModel } from "../../../providers/db-firebase";
+import { type SessionCreateInput, type SessionDocument, type SessionUpdateInput } from "../schemas";
+export declare class SessionRepository extends BaseRepository<SessionDocument> {
+    static readonly SIEVE_FIELDS: FirebaseSieveFields;
+    constructor();
+    list(model: SieveModel): Promise<FirebaseSieveResult<SessionDocument>>;
+    listForUser(userId: string, model: SieveModel): Promise<FirebaseSieveResult<SessionDocument>>;
+    createSession(userId: string, data: Omit<SessionCreateInput, "userId" | "expiresAt" | "isActive">): Promise<SessionDocument>;
+    updateActivity(sessionId: string, data?: Partial<SessionUpdateInput>): Promise<void>;
+    revokeSession(sessionId: string, revokedBy: string): Promise<void>;
+    revokeAllUserSessions(userId: string, revokedBy: string): Promise<number>;
+    findActiveByUser(userId: string): Promise<SessionDocument[]>;
+    findAllByUser(userId: string, limitCount?: number): Promise<SessionDocument[]>;
+    findActiveSession(sessionId: string): Promise<SessionDocument | null>;
+    getAllActiveSessions(limitCount?: number): Promise<SessionDocument[]>;
+    cleanupExpiredSessions(): Promise<number>;
+    countActiveByUser(userId: string): Promise<number>;
+    getStats(): Promise<{
+        totalActive: number;
+        totalExpired: number;
+        uniqueUsers: number;
+        recentActivity: number;
+    }>;
+    findAllForAdmin(options?: {
+        userId?: string;
+        limit?: number;
+    }): Promise<{
+        sessions: SessionDocument[];
+        stats: {
+            totalActive: number;
+            totalExpired: number;
+            uniqueUsers: number;
+            recentActivity: number;
+        };
+    }>;
+    /**
+     * Cloud Functions: return refs for expired sessions for caller-managed batch deletion.
+     * Complements cleanupExpiredSessions() with a composable batch-friendly variant.
+     */
+    getExpiredRefs(now: Date): Promise<DocumentReference[]>;
+}
+export declare const sessionRepository: SessionRepository;