1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
import {
createContext,
useContext,
useEffect,
useState,
useCallback,
type ReactNode,
} from "react";
import { supabase, isAuthConfigured, SUPABASE_URL, type Session, type User } from "../lib/supabase";
interface AuthState {
user: User | null;
session: Session | null;
isLoading: boolean;
isAuthenticated: boolean;
isAuthConfigured: boolean;
}
interface AuthContextValue extends AuthState {
/** Get the current access token for API calls */
getAccessToken: () => string | null;
/** Sign in with email and password */
signIn: (email: string, password: string) => Promise<{ error: Error | null }>;
/** Sign up with email and password */
signUp: (email: string, password: string) => Promise<{ error: Error | null }>;
/** Sign out */
signOut: () => Promise<void>;
/** Sign in with OAuth provider */
signInWithOAuth: (provider: "github" | "google") => Promise<{ error: Error | null }>;
}
const AuthContext = createContext<AuthContextValue | null>(null);
export function AuthProvider({ children }: { children: ReactNode }) {
const [state, setState] = useState<AuthState>({
user: null,
session: null,
isLoading: true,
isAuthenticated: false,
isAuthConfigured: isAuthConfigured(),
});
// Initialize auth state
useEffect(() => {
// Get initial session
supabase.auth.getSession().then(({ data: { session } }) => {
setState({
user: session?.user ?? null,
session,
isLoading: false,
isAuthenticated: !!session,
isAuthConfigured: true,
});
});
// Listen for auth changes
const {
data: { subscription },
} = supabase.auth.onAuthStateChange((_event, session) => {
setState((prev) => ({
...prev,
user: session?.user ?? null,
session,
isAuthenticated: !!session,
}));
});
return () => subscription.unsubscribe();
}, []);
const getAccessToken = useCallback((): string | null => {
return state.session?.access_token ?? null;
}, [state.session]);
const signIn = useCallback(
async (email: string, password: string): Promise<{ error: Error | null }> => {
const { error } = await supabase.auth.signInWithPassword({ email, password });
return { error: error ? new Error(error.message) : null };
},
[]
);
const signUp = useCallback(
async (email: string, password: string): Promise<{ error: Error | null }> => {
const { error } = await supabase.auth.signUp({ email, password });
return { error: error ? new Error(error.message) : null };
},
[]
);
const signOut = useCallback(async () => {
// Always clear local state first
setState((prev) => ({
...prev,
user: null,
session: null,
isAuthenticated: false,
}));
// Clear Supabase storage directly in case signOut API fails
const storageKey = `sb-${SUPABASE_URL.split('//')[1]?.split('.')[0]}-auth-token`;
localStorage.removeItem(storageKey);
// Try to call signOut API (may fail if token is invalid, that's OK)
await supabase.auth.signOut({ scope: 'local' }).catch(() => {});
}, []);
const signInWithOAuth = useCallback(
async (provider: "github" | "google"): Promise<{ error: Error | null }> => {
const { error } = await supabase.auth.signInWithOAuth({
provider,
options: {
redirectTo: window.location.origin,
},
});
return { error: error ? new Error(error.message) : null };
},
[]
);
const value: AuthContextValue = {
...state,
getAccessToken,
signIn,
signUp,
signOut,
signInWithOAuth,
};
return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
}
export function useAuth(): AuthContextValue {
const context = useContext(AuthContext);
if (!context) {
throw new Error("useAuth must be used within an AuthProvider");
}
return context;
}
|
