@plyaz/auth 1.0.0 → 1.0.2

package/src/client/hooks/useAuth.ts

@@ -6,7 +6,6 @@ import type {
   AuthSession,
   AuthUser,
   Tokens,
-
   ConnectedAccount,
 } from "@plyaz/types";
 
@@ -27,7 +26,10 @@ export interface UseAuthReturn {
   isAuthenticated: boolean;
   isLoading: boolean;
   error: string | null;
-  signIn: (provider?: AUTHPROVIDER, credentials?: AuthCredentials) => Promise<{
+  signIn: (
+    provider?: AUTHPROVIDER,
+    credentials?: AuthCredentials,
+  ) => Promise<{
     user: AuthAdapterUser;
     session: AuthSession;
     tokens: Tokens;
@@ -35,7 +37,9 @@ export interface UseAuthReturn {
   signUp: (provider: AUTHPROVIDER, data?: unknown) => Promise<void>;
   signOut: () => Promise<void>;
   linkAccount: (
-   userId:string,provider:AUTHPROVIDER,data:ConnectedAccount
+    userId: string,
+    provider: AUTHPROVIDER,
+    data: ConnectedAccount,
   ) => Promise<void | ConnectedAccount>;
   unlinkAccount: (accountId: string) => Promise<void>;
 }
@@ -51,25 +55,20 @@ export function useAuth(): UseAuthReturn {
    * @private
    */
 
-  const handleAuthAction = async <T,>(
-    action: () => Promise<T>
-  ): Promise<T> => {
+  const handleAuthAction = async <T>(action: () => Promise<T>): Promise<T> => {
     store.setLoading(true);
     store.setError(null);
 
     try {
       const result = await action();
       return result;
-    } 
-   catch (err: unknown) {
-  const errorMessage =
-    err instanceof Error ? err.message : "Authentication failed";
-
-  store.setError(errorMessage);
-  throw err;
-}
+    } catch (err: unknown) {
+      const errorMessage =
+        err instanceof Error ? err.message : "Authentication failed";
 
-    finally {
+      store.setError(errorMessage);
+      throw err;
+    } finally {
       store.setLoading(false);
     }
   };
@@ -81,7 +80,7 @@ export function useAuth(): UseAuthReturn {
     error: store.error,
     signIn: async (
       provider?: AUTHPROVIDER,
-      credentials?: AuthCredentials
+      credentials?: AuthCredentials,
     ): Promise<{
       user: AuthAdapterUser;
       session: AuthSession;
@@ -99,12 +98,13 @@ export function useAuth(): UseAuthReturn {
     },
 
     linkAccount: async (
-    userId:string,provider:AUTHPROVIDER,data:ConnectedAccount
+      userId: string,
+      provider: AUTHPROVIDER,
+      data: ConnectedAccount,
     ): Promise<void> => {
       return handleAuthAction(async () => {
         // Construct a ConnectedAccount object; adjust fields as needed
         const connectedAccount: ConnectedAccount = {
-         
           ...data,
           userId,
           provider,
@@ -115,14 +115,16 @@ export function useAuth(): UseAuthReturn {
           isActive: false,
           linkedAt: new Date(),
           createdAt: new Date(),
-          updatedAt: new Date()
+          updatedAt: new Date(),
         };
         store.addConnectedAccount(connectedAccount);
       });
     },
 
     unlinkAccount: async (accountId: string): Promise<void> => {
-      return handleAuthAction(async () => store.removeConnectedAccount(accountId));
+      return handleAuthAction(async () =>
+        store.removeConnectedAccount(accountId),
+      );
     },
   };
-}
+}

package/src/client/hooks/useConnectedAccounts.ts

@@ -3,14 +3,17 @@
  * @module @plyaz/auth/client/hooks/useConnectedAccounts
  */
 
-import { useState, useEffect } from 'react';
-import { useAuth } from './useAuth';
-import type { AuthCredentials, ConnectedAccount } from '@plyaz/types';
+import { useState, useEffect } from "react";
+import { useAuth } from "./useAuth";
+import type { AuthCredentials, ConnectedAccount } from "@plyaz/types";
 
 export interface UseConnectedAccountsReturn {
   accounts: ConnectedAccount[];
   isLoading: boolean;
-  linkAccount: (provider: string, credentials: AuthCredentials) => Promise<void>;
+  linkAccount: (
+    provider: string,
+    credentials: AuthCredentials,
+  ) => Promise<void>;
   unlinkAccount: (accountId: string) => Promise<void>;
   setPrimaryAccount: (accountId: string) => Promise<void>;
   refreshAccounts: () => Promise<void>;
@@ -21,67 +24,78 @@ export const useConnectedAccounts = (): UseConnectedAccountsReturn => {
   const [isLoading, setIsLoading] = useState(true);
   const { user } = useAuth();
 
-  const linkAccount = async (provider: string, credentials:AuthCredentials):Promise<void> => {
-    if (!user) throw new Error('User not authenticated');
-    
+  const linkAccount = async (
+    provider: string,
+    credentials: AuthCredentials,
+  ): Promise<void> => {
+    if (!user) throw new Error("User not authenticated");
+
     setIsLoading(true);
     try {
-      const response = await globalThis.fetch('/api/auth/accounts/link', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ provider, credentials })
+      const response = await globalThis.fetch("/api/auth/accounts/link", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ provider, credentials }),
       });
-      
-      if (!response.ok) throw new Error('Failed to link account');
-      
-      const newAccount = await response.json() as ConnectedAccount;
-      setAccounts(prev => [...prev, newAccount]);
+
+      if (!response.ok) throw new Error("Failed to link account");
+
+      const newAccount = (await response.json()) as ConnectedAccount;
+      setAccounts((prev) => [...prev, newAccount]);
     } finally {
       setIsLoading(false);
     }
   };
 
-  const unlinkAccount = async (accountId: string):Promise<void> => {
+  const unlinkAccount = async (accountId: string): Promise<void> => {
     setIsLoading(true);
     try {
-      const response = await globalThis.fetch(`/api/auth/accounts/${accountId}/unlink`, {
-        method: 'DELETE'
-      });
-      
-      if (!response.ok) throw new Error('Failed to unlink account');
-      
-      setAccounts(prev => prev.filter(acc => acc.id !== accountId));
+      const response = await globalThis.fetch(
+        `/api/auth/accounts/${accountId}/unlink`,
+        {
+          method: "DELETE",
+        },
+      );
+
+      if (!response.ok) throw new Error("Failed to unlink account");
+
+      setAccounts((prev) => prev.filter((acc) => acc.id !== accountId));
     } finally {
       setIsLoading(false);
     }
   };
 
-  const setPrimaryAccount = async (accountId: string):Promise<void> => {
+  const setPrimaryAccount = async (accountId: string): Promise<void> => {
     setIsLoading(true);
     try {
-      const response = await globalThis.fetch(`/api/auth/accounts/${accountId}/primary`, {
-        method: 'PUT'
-      });
-      
-      if (!response.ok) throw new Error('Failed to set primary account');
-      
-      setAccounts(prev => prev.map(acc => ({
-        ...acc,
-        isPrimary: acc.id === accountId
-      })));
+      const response = await globalThis.fetch(
+        `/api/auth/accounts/${accountId}/primary`,
+        {
+          method: "PUT",
+        },
+      );
+
+      if (!response.ok) throw new Error("Failed to set primary account");
+
+      setAccounts((prev) =>
+        prev.map((acc) => ({
+          ...acc,
+          isPrimary: acc.id === accountId,
+        })),
+      );
     } finally {
       setIsLoading(false);
     }
   };
 
-  const refreshAccounts = async ():Promise<void>=> {
+  const refreshAccounts = async (): Promise<void> => {
     if (!user) return;
-    
+
     setIsLoading(true);
     try {
-      const response = await globalThis.fetch('/api/auth/accounts');
+      const response = await globalThis.fetch("/api/auth/accounts");
       if (response.ok) {
-        const data = await response.json() as ConnectedAccount[];
+        const data = (await response.json()) as ConnectedAccount[];
         setAccounts(data);
       }
     } finally {
@@ -90,11 +104,9 @@ export const useConnectedAccounts = (): UseConnectedAccountsReturn => {
   };
 
   useEffect(() => {
-    void (async():Promise<void> => {
- await refreshAccounts();
-})();
-
-   
+    void (async (): Promise<void> => {
+      await refreshAccounts();
+    })();
   }, [user]);
 
   return {
@@ -105,4 +117,4 @@ export const useConnectedAccounts = (): UseConnectedAccountsReturn => {
     setPrimaryAccount,
     refreshAccounts,
   };
-};
+};

package/src/client/hooks/usePermissions.ts

@@ -3,7 +3,7 @@
  * @module @plyaz/auth/client/hooks/usePermissions
  */
 
-import type { Permission} from "./useAuth";
+import type { Permission } from "./useAuth";
 import { useAuth } from "./useAuth";
 
 export interface UsePermissionsReturn {

package/src/client/hooks/useRBAC.ts

@@ -1,4 +1,4 @@
-import { useAuth } from './useAuth';
+import { useAuth } from "./useAuth";
 
 export interface UseRBACReturn {
   hasRole: (role: string) => boolean;
@@ -18,11 +18,11 @@ export const useRBAC = (): UseRBACReturn => {
   };
 
   const hasAnyRole = (roles: string[]): boolean => {
-    return roles.some(role => userRoles.includes(role));
+    return roles.some((role) => userRoles.includes(role));
   };
 
   const hasAllRoles = (roles: string[]): boolean => {
-    return roles.every(role => userRoles.includes(role));
+    return roles.every((role) => userRoles.includes(role));
   };
 
   return {
@@ -30,7 +30,7 @@ export const useRBAC = (): UseRBACReturn => {
     hasAnyRole,
     hasAllRoles,
     userRoles,
-    isAdmin: hasRole('ADMIN'),
-    isModerator: hasRole('MODERATOR')
+    isAdmin: hasRole("ADMIN"),
+    isModerator: hasRole("MODERATOR"),
   };
-};
+};

package/src/client/hooks/useSession.ts

@@ -1,11 +1,11 @@
 import type { Session } from "@plyaz/types";
 import { useAuthStore } from "../store/auth.store";
 
-export function useSession() : {
-    session: Session | null;
-    isValid: boolean;
-    expiresAt: Date | null;
-    refresh: () => Promise<void>;
+export function useSession(): {
+  session: Session | null;
+  isValid: boolean;
+  expiresAt: Date | null;
+  refresh: () => Promise<void>;
 } {
   const store = useAuthStore();
 

package/src/client/providers/AuthProvider.tsx

@@ -2,13 +2,13 @@ import type { ReactNode } from "react";
 import { createContext } from "react";
 import type { UseAuthReturn } from "../hooks/useAuth";
 import { useAuthStore } from "../store/auth.store";
-import type  { 
-  AuthCredentials, 
-  AUTHPROVIDER, 
-  ConnectedAccount, 
+import type {
+  AuthCredentials,
+  AUTHPROVIDER,
+  ConnectedAccount,
   AuthAdapterUser,
   AuthSession,
-  Tokens
+  Tokens,
 } from "@plyaz/types";
 
 /**
@@ -27,9 +27,7 @@ export function AuthProvider({ children }: { children: ReactNode }): ReactNode {
   const store = useAuthStore();
 
   // Wrap actions in a helper to handle loading and errors
-  const handleAuthAction = async <T,>(
-    action: () => Promise<T>
-  ): Promise<T> => {
+  const handleAuthAction = async <T,>(action: () => Promise<T>): Promise<T> => {
     store.setLoading(true);
     store.setError(null);
 
@@ -54,7 +52,10 @@ export function AuthProvider({ children }: { children: ReactNode }): ReactNode {
     error: store.error,
 
     // Auth API actions wrapped with handleAuthAction
-    signIn: async (provider?: AUTHPROVIDER, credentials?: AuthCredentials): Promise<{
+    signIn: async (
+      provider?: AUTHPROVIDER,
+      credentials?: AuthCredentials,
+    ): Promise<{
       user: AuthAdapterUser;
       session: AuthSession;
       tokens: Tokens;
@@ -62,7 +63,11 @@ export function AuthProvider({ children }: { children: ReactNode }): ReactNode {
       return handleAuthAction(() => store.signIn(provider, credentials));
     },
 
-    signUp: async (provider: AUTHPROVIDER, credentials:unknown, data?:unknown) => {
+    signUp: async (
+      provider: AUTHPROVIDER,
+      credentials: unknown,
+      data?: unknown,
+    ) => {
       return handleAuthAction(() => store.signUp(provider, data));
     },
 
@@ -70,11 +75,14 @@ export function AuthProvider({ children }: { children: ReactNode }): ReactNode {
       return handleAuthAction(() => store.signOut());
     },
 
-    linkAccount: async (userId:string,provider:AUTHPROVIDER,data:ConnectedAccount): Promise<void |ConnectedAccount> => {
+    linkAccount: async (
+      userId: string,
+      provider: AUTHPROVIDER,
+      data: ConnectedAccount,
+    ): Promise<void | ConnectedAccount> => {
       return handleAuthAction(async () => {
         // Create a minimal ConnectedAccount object with only required properties
         const connectedAccount: ConnectedAccount = {
-        
           ...data,
           userId,
           provider,
@@ -85,7 +93,7 @@ export function AuthProvider({ children }: { children: ReactNode }): ReactNode {
           isActive: false,
           linkedAt: new Date(),
           createdAt: new Date(),
-          updatedAt: new Date()
+          updatedAt: new Date(),
         };
         store.addConnectedAccount(connectedAccount);
       });
@@ -97,8 +105,6 @@ export function AuthProvider({ children }: { children: ReactNode }): ReactNode {
   };
 
   return (
-    <AuthContext.Provider value={authValue}>
-      {children}
-    </AuthContext.Provider>
+    <AuthContext.Provider value={authValue}>{children}</AuthContext.Provider>
   );
-}
+}

package/src/client/store/auth.store.ts

@@ -1,10 +1,18 @@
-
-import type { AuthAdapterUser, AuthCredentials, AUTHPROVIDER, AuthSession, AuthTokens,AuthUser,ConnectedAccount, Session, Tokens, } from "@plyaz/types";
+import type {
+  AuthAdapterUser,
+  AuthCredentials,
+  AUTHPROVIDER,
+  AuthSession,
+  AuthTokens,
+  AuthUser,
+  ConnectedAccount,
+  Session,
+  Tokens,
+} from "@plyaz/types";
 import { create } from "zustand";
 import { persist, subscribeWithSelector } from "zustand/middleware";
 import type { AuthPermissions } from "../hooks/useAuth";
 
-
 interface AuthState {
   // User & Authentication
   user: AuthPermissions | null;
@@ -31,8 +39,6 @@ interface AuthState {
   error: string | null;
 }
 
-
-
 export interface AuthActions {
   // User Management
   setUser: (user: AuthUser | null) => void;
@@ -56,9 +62,12 @@ export interface AuthActions {
   setRoles: (roles: string[]) => void;
   hasPermission: (permission: string) => boolean;
   hasRole: (role: string) => boolean;
-  
+
   // Authentication Actions
-  signIn: (provider?: AUTHPROVIDER, credentials?: AuthCredentials) => Promise<{
+  signIn: (
+    provider?: AUTHPROVIDER,
+    credentials?: AuthCredentials,
+  ) => Promise<{
     user: AuthAdapterUser;
     session: AuthSession;
     tokens: Tokens;
@@ -134,8 +143,8 @@ export const useAuthStore = create<AuthState & AuthActions>()(
               await get().signOut();
             }
           } catch (error: unknown) {
-            globalThis.console.log(error)
-         await   get().signOut();
+            globalThis.console.log(error);
+            await get().signOut();
           }
         },
 
@@ -162,7 +171,7 @@ export const useAuthStore = create<AuthState & AuthActions>()(
           const { connectedAccounts } = get();
           set({
             connectedAccounts: connectedAccounts.filter(
-              (acc) => acc.id !== accountId
+              (acc) => acc.id !== accountId,
             ),
           });
         },
@@ -220,55 +229,55 @@ export const useAuthStore = create<AuthState & AuthActions>()(
             set({ isLoading: false });
           }
         },
-       signIn: async (provider, credentials) => {
-  set({ isLoading: true, error: null });
-  try {
-    const endpoint = provider
-      ? `/api/auth/signin/${provider}`
-      : "/api/auth/signin";
-    const response = await globalThis.fetch(endpoint, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(credentials),
-    });
-
-    if (!response.ok) {
-      const errorData = (await response.json()) as { message?: string };
-      throw new Error(errorData.message ?? "Sign in failed");
-    }
-
-    const data = (await response.json()) as {
-      user: AuthUser;
-      tokens: AuthTokens;
-      session: Session;
-    };
-    const { user, tokens, session } = data;
-    
-    // Update the store state
-    set({
-      user,
-      tokens,
-      session,
-      isAuthenticated: true,
-      lastActivity: new Date(),
-    });
-    
-    // Return the expected object with proper types
-    return {
-      user: user as AuthAdapterUser, // Cast to match expected type
-      session: session as AuthSession, // Cast to match expected type
-      tokens: tokens as Tokens, // Cast to match expected type
-    };
-  } catch (error: unknown) {
-    const errorMessage =
-      error instanceof Error ? error.message : "Sign in failed";
-    set({ error: errorMessage });
-    // Re-throw the error to maintain the Promise rejection
-    throw error;
-  } finally {
-    set({ isLoading: false });
-  }
-},
+        signIn: async (provider, credentials) => {
+          set({ isLoading: true, error: null });
+          try {
+            const endpoint = provider
+              ? `/api/auth/signin/${provider}`
+              : "/api/auth/signin";
+            const response = await globalThis.fetch(endpoint, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(credentials),
+            });
+
+            if (!response.ok) {
+              const errorData = (await response.json()) as { message?: string };
+              throw new Error(errorData.message ?? "Sign in failed");
+            }
+
+            const data = (await response.json()) as {
+              user: AuthUser;
+              tokens: AuthTokens;
+              session: Session;
+            };
+            const { user, tokens, session } = data;
+
+            // Update the store state
+            set({
+              user,
+              tokens,
+              session,
+              isAuthenticated: true,
+              lastActivity: new Date(),
+            });
+
+            // Return the expected object with proper types
+            return {
+              user: user as AuthAdapterUser, // Cast to match expected type
+              session: session as AuthSession, // Cast to match expected type
+              tokens: tokens as Tokens, // Cast to match expected type
+            };
+          } catch (error: unknown) {
+            const errorMessage =
+              error instanceof Error ? error.message : "Sign in failed";
+            set({ error: errorMessage });
+            // Re-throw the error to maintain the Promise rejection
+            throw error;
+          } finally {
+            set({ isLoading: false });
+          }
+        },
 
         signOut: async () => {
           set({ isLoading: true });
@@ -300,7 +309,7 @@ export const useAuthStore = create<AuthState & AuthActions>()(
           rememberMe: state.rememberMe,
           connectedAccounts: state.connectedAccounts,
         }),
-      }
-    )
-  )
+      },
+    ),
+  ),
 );