@usehercules/auth 1.0.42 → 1.0.44
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/convex-react/ConvexProviderWithHercules.tsx"],"sourcesContent":[],"mappings":";;;;;
|
|
1
|
+
{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/convex-react/ConvexProviderWithHercules.tsx"],"sourcesContent":[],"mappings":";;;;;iBAuIgB,8BAAA;;;AAAhB;YAIY;UACF;AALV,CAAA,CAAA,EAMC,kBAAA,CAAA,GAAA,CAAA,OAN6C"}
|
|
@@ -1,36 +1,70 @@
|
|
|
1
|
-
import { useCallback, useMemo } from "react";
|
|
1
|
+
import { useCallback, useMemo, useRef } from "react";
|
|
2
2
|
import { useAuth } from "react-oidc-context";
|
|
3
3
|
import { jsx } from "react/jsx-runtime";
|
|
4
4
|
import { ConvexProviderWithAuth } from "convex/react";
|
|
5
|
+
import { jwtDecode } from "jwt-decode";
|
|
5
6
|
|
|
6
7
|
//#region src/convex-react/ConvexProviderWithHercules.tsx
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
8
|
+
const REFRESH_THRESHOLD_MS = 3600 * 1e3;
|
|
9
|
+
const LOCK_KEY = "__herculesAuthRefresh";
|
|
10
|
+
function tokenExpiresWithin(token, ms) {
|
|
11
|
+
try {
|
|
12
|
+
return jwtDecode(token).exp * 1e3 - Date.now() < ms;
|
|
13
|
+
} catch {
|
|
14
|
+
return true;
|
|
15
|
+
}
|
|
16
|
+
}
|
|
17
|
+
async function withLock(key, callback) {
|
|
18
|
+
if (typeof navigator !== "undefined" && navigator.locks) return navigator.locks.request(key, callback);
|
|
19
|
+
return manualMutex(key, callback);
|
|
20
|
+
}
|
|
21
|
+
const mutexes = /* @__PURE__ */ new Map();
|
|
22
|
+
async function manualMutex(key, callback) {
|
|
23
|
+
return new Promise((resolve, reject) => {
|
|
24
|
+
const wrapped = () => callback().then(resolve).catch(reject).finally(() => {
|
|
25
|
+
const mutex$1 = mutexes.get(key);
|
|
26
|
+
const next = mutex$1.waiting.shift();
|
|
27
|
+
if (next) mutex$1.running = next();
|
|
28
|
+
else mutex$1.running = null;
|
|
29
|
+
});
|
|
30
|
+
let mutex = mutexes.get(key);
|
|
31
|
+
if (!mutex) {
|
|
32
|
+
mutex = {
|
|
33
|
+
running: null,
|
|
34
|
+
waiting: []
|
|
35
|
+
};
|
|
36
|
+
mutexes.set(key, mutex);
|
|
37
|
+
}
|
|
38
|
+
if (mutex.running === null) mutex.running = wrapped();
|
|
39
|
+
else mutex.waiting.push(wrapped);
|
|
20
40
|
});
|
|
21
41
|
}
|
|
22
42
|
function useUseAuthFromHercules() {
|
|
23
43
|
const { isAuthenticated, user, isLoading, signinSilent } = useAuth();
|
|
24
44
|
const idToken = user?.id_token;
|
|
25
|
-
const
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
45
|
+
const idTokenRef = useRef(idToken);
|
|
46
|
+
idTokenRef.current = idToken;
|
|
47
|
+
const inFlightRefresh = useRef(null);
|
|
48
|
+
const fetchAccessToken = useCallback(async ({ forceRefreshToken }) => {
|
|
49
|
+
if (!forceRefreshToken) return idToken ?? null;
|
|
50
|
+
if (idToken != null && !tokenExpiresWithin(idToken, REFRESH_THRESHOLD_MS)) return idToken;
|
|
51
|
+
if (inFlightRefresh.current) return inFlightRefresh.current;
|
|
52
|
+
const refresh = withLock(LOCK_KEY, async () => {
|
|
53
|
+
const currentToken = idTokenRef.current;
|
|
54
|
+
if (currentToken != null && !tokenExpiresWithin(currentToken, REFRESH_THRESHOLD_MS)) return currentToken;
|
|
55
|
+
try {
|
|
56
|
+
return (await signinSilent())?.id_token ?? null;
|
|
57
|
+
} catch {
|
|
58
|
+
return null;
|
|
59
|
+
}
|
|
60
|
+
}).finally(() => {
|
|
61
|
+
inFlightRefresh.current = null;
|
|
62
|
+
});
|
|
63
|
+
inFlightRefresh.current = refresh;
|
|
64
|
+
return refresh;
|
|
31
65
|
}, [idToken, signinSilent]);
|
|
32
66
|
return useMemo(() => ({
|
|
33
|
-
isLoading,
|
|
67
|
+
isLoading: isAuthenticated ? false : isLoading,
|
|
34
68
|
isAuthenticated,
|
|
35
69
|
fetchAccessToken
|
|
36
70
|
}), [
|
|
@@ -39,6 +73,21 @@ function useUseAuthFromHercules() {
|
|
|
39
73
|
fetchAccessToken
|
|
40
74
|
]);
|
|
41
75
|
}
|
|
76
|
+
/**
|
|
77
|
+
* A wrapper React component which provides a {@link ConvexReactClient}
|
|
78
|
+
* authenticated with Hercules Auth.
|
|
79
|
+
*
|
|
80
|
+
* It must be wrapped by a configured `{@link HerculesAuthProvider}`.
|
|
81
|
+
*
|
|
82
|
+
* @public
|
|
83
|
+
*/
|
|
84
|
+
function ConvexProviderWithHerculesAuth({ children, client }) {
|
|
85
|
+
return /* @__PURE__ */ jsx(ConvexProviderWithAuth, {
|
|
86
|
+
client,
|
|
87
|
+
useAuth: useUseAuthFromHercules,
|
|
88
|
+
children
|
|
89
|
+
});
|
|
90
|
+
}
|
|
42
91
|
|
|
43
92
|
//#endregion
|
|
44
93
|
export { ConvexProviderWithHerculesAuth };
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"index.mjs","names":[],"sources":["../../src/convex-react/ConvexProviderWithHercules.tsx"],"sourcesContent":["\"use client\";\n\nimport type { ReactNode } from \"react\";\nimport { ConvexProviderWithAuth, type ConvexReactClient } from \"convex/react\";\nimport { useCallback, useMemo } from \"react\";\nimport { useAuth } from \"react-oidc-context\";\nimport type { HerculesAuthProvider } from \"../react/HerculesAuthProvider\";\n\
|
|
1
|
+
{"version":3,"file":"index.mjs","names":["mutex"],"sources":["../../src/convex-react/ConvexProviderWithHercules.tsx"],"sourcesContent":["\"use client\";\n\nimport type { ReactNode } from \"react\";\nimport { ConvexProviderWithAuth, type ConvexReactClient } from \"convex/react\";\nimport { jwtDecode } from \"jwt-decode\";\nimport { useCallback, useMemo, useRef } from \"react\";\nimport { useAuth } from \"react-oidc-context\";\nimport type { HerculesAuthProvider } from \"../react/HerculesAuthProvider\";\n\nconst REFRESH_THRESHOLD_MS = 60 * 60 * 1000; // 1 hour\nconst LOCK_KEY = \"__herculesAuthRefresh\";\n\nfunction tokenExpiresWithin(token: string, ms: number): boolean {\n try {\n const payload = jwtDecode(token);\n return payload.exp! * 1000 - Date.now() < ms;\n } catch {\n return true;\n }\n}\n\n// Cross-tab mutex: uses Web Locks API when available, falls back to a\n// simple in-memory queue for environments that don't support it.\nasync function withLock<T>(key: string, callback: () => Promise<T>): Promise<T> {\n if (typeof navigator !== \"undefined\" && navigator.locks) {\n return navigator.locks.request(key, callback);\n }\n return manualMutex(key, callback);\n}\n\nconst mutexes = new Map<\n string,\n { running: Promise<void> | null; waiting: Array<() => Promise<void>> }\n>();\n\nasync function manualMutex<T>(\n key: string,\n callback: () => Promise<T>,\n): Promise<T> {\n return new Promise<T>((resolve, reject) => {\n const wrapped = () =>\n callback()\n .then(resolve)\n .catch(reject)\n .finally(() => {\n const mutex = mutexes.get(key)!;\n const next = mutex.waiting.shift();\n if (next) {\n mutex.running = next();\n } else {\n mutex.running = null;\n }\n });\n\n let mutex = mutexes.get(key);\n if (!mutex) {\n mutex = { running: null, waiting: [] };\n mutexes.set(key, mutex);\n }\n\n if (mutex.running === null) {\n mutex.running = wrapped();\n } else {\n mutex.waiting.push(wrapped);\n }\n });\n}\n\nfunction useUseAuthFromHercules() {\n const { isAuthenticated, user, isLoading, signinSilent } = useAuth();\n const idToken = user?.id_token;\n\n // Ref so the re-check inside the lock sees updates from other tabs\n const idTokenRef = useRef(idToken);\n idTokenRef.current = idToken;\n\n const inFlightRefresh = useRef<Promise<string | null> | null>(null);\n\n const fetchAccessToken = useCallback(\n async ({ forceRefreshToken }: { forceRefreshToken: boolean }) => {\n if (!forceRefreshToken) {\n return idToken ?? null;\n }\n if (\n idToken != null &&\n !tokenExpiresWithin(idToken, REFRESH_THRESHOLD_MS)\n ) {\n return idToken;\n }\n // Same-tab dedup: concurrent callers share one promise\n if (inFlightRefresh.current) {\n return inFlightRefresh.current;\n }\n const refresh = withLock(LOCK_KEY, async () => {\n // Re-check after acquiring lock — another tab may have refreshed\n const currentToken = idTokenRef.current;\n if (\n currentToken != null &&\n !tokenExpiresWithin(currentToken, REFRESH_THRESHOLD_MS)\n ) {\n return currentToken;\n }\n try {\n const refreshed = await signinSilent();\n return refreshed?.id_token ?? null;\n } catch {\n return null;\n }\n }).finally(() => {\n inFlightRefresh.current = null;\n });\n inFlightRefresh.current = refresh;\n return refresh;\n },\n [idToken, signinSilent],\n );\n\n return useMemo(\n () => ({\n isLoading: isAuthenticated ? false : isLoading,\n isAuthenticated,\n fetchAccessToken,\n }),\n [isLoading, isAuthenticated, fetchAccessToken],\n );\n}\n\n/**\n * A wrapper React component which provides a {@link ConvexReactClient}\n * authenticated with Hercules Auth.\n *\n * It must be wrapped by a configured `{@link HerculesAuthProvider}`.\n *\n * @public\n */\nexport function ConvexProviderWithHerculesAuth({\n children,\n client,\n}: {\n children: ReactNode;\n client: ConvexReactClient;\n}) {\n return (\n <ConvexProviderWithAuth client={client} useAuth={useUseAuthFromHercules}>\n {children}\n </ConvexProviderWithAuth>\n );\n}\n"],"mappings":";;;;;;;AASA,MAAM,uBAAuB,OAAU;AACvC,MAAM,WAAW;AAEjB,SAAS,mBAAmB,OAAe,IAAqB;AAC9D,KAAI;AAEF,SADgB,UAAU,MAAM,CACjB,MAAO,MAAO,KAAK,KAAK,GAAG;SACpC;AACN,SAAO;;;AAMX,eAAe,SAAY,KAAa,UAAwC;AAC9E,KAAI,OAAO,cAAc,eAAe,UAAU,MAChD,QAAO,UAAU,MAAM,QAAQ,KAAK,SAAS;AAE/C,QAAO,YAAY,KAAK,SAAS;;AAGnC,MAAM,0BAAU,IAAI,KAGjB;AAEH,eAAe,YACb,KACA,UACY;AACZ,QAAO,IAAI,SAAY,SAAS,WAAW;EACzC,MAAM,gBACJ,UAAU,CACP,KAAK,QAAQ,CACb,MAAM,OAAO,CACb,cAAc;GACb,MAAMA,UAAQ,QAAQ,IAAI,IAAI;GAC9B,MAAM,OAAOA,QAAM,QAAQ,OAAO;AAClC,OAAI,KACF,SAAM,UAAU,MAAM;OAEtB,SAAM,UAAU;IAElB;EAEN,IAAI,QAAQ,QAAQ,IAAI,IAAI;AAC5B,MAAI,CAAC,OAAO;AACV,WAAQ;IAAE,SAAS;IAAM,SAAS,EAAE;IAAE;AACtC,WAAQ,IAAI,KAAK,MAAM;;AAGzB,MAAI,MAAM,YAAY,KACpB,OAAM,UAAU,SAAS;MAEzB,OAAM,QAAQ,KAAK,QAAQ;GAE7B;;AAGJ,SAAS,yBAAyB;CAChC,MAAM,EAAE,iBAAiB,MAAM,WAAW,iBAAiB,SAAS;CACpE,MAAM,UAAU,MAAM;CAGtB,MAAM,aAAa,OAAO,QAAQ;AAClC,YAAW,UAAU;CAErB,MAAM,kBAAkB,OAAsC,KAAK;CAEnE,MAAM,mBAAmB,YACvB,OAAO,EAAE,wBAAwD;AAC/D,MAAI,CAAC,kBACH,QAAO,WAAW;AAEpB,MACE,WAAW,QACX,CAAC,mBAAmB,SAAS,qBAAqB,CAElD,QAAO;AAGT,MAAI,gBAAgB,QAClB,QAAO,gBAAgB;EAEzB,MAAM,UAAU,SAAS,UAAU,YAAY;GAE7C,MAAM,eAAe,WAAW;AAChC,OACE,gBAAgB,QAChB,CAAC,mBAAmB,cAAc,qBAAqB,CAEvD,QAAO;AAET,OAAI;AAEF,YADkB,MAAM,cAAc,GACpB,YAAY;WACxB;AACN,WAAO;;IAET,CAAC,cAAc;AACf,mBAAgB,UAAU;IAC1B;AACF,kBAAgB,UAAU;AAC1B,SAAO;IAET,CAAC,SAAS,aAAa,CACxB;AAED,QAAO,eACE;EACL,WAAW,kBAAkB,QAAQ;EACrC;EACA;EACD,GACD;EAAC;EAAW;EAAiB;EAAiB,CAC/C;;;;;;;;;;AAWH,SAAgB,+BAA+B,EAC7C,UACA,UAIC;AACD,QACE,oBAAC;EAA+B;EAAQ,SAAS;EAC9C;GACsB"}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@usehercules/auth",
|
|
3
|
-
"version": "1.0.
|
|
3
|
+
"version": "1.0.44",
|
|
4
4
|
"description": "Authentication utilities for Hercules applications using OIDC",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"sideEffects": false,
|
|
@@ -26,6 +26,7 @@
|
|
|
26
26
|
"access": "public"
|
|
27
27
|
},
|
|
28
28
|
"dependencies": {
|
|
29
|
+
"jwt-decode": "^4.0.0",
|
|
29
30
|
"oidc-client-ts": "^3.4.1",
|
|
30
31
|
"react-oidc-context": "^3.3.0",
|
|
31
32
|
"zod": "^4.3.6"
|
|
@@ -0,0 +1,240 @@
|
|
|
1
|
+
import { describe, it, expect, vi, beforeEach } from "vitest";
|
|
2
|
+
import type { ReactNode } from "react";
|
|
3
|
+
import { renderHook, act, configure } from "@testing-library/react";
|
|
4
|
+
import { ConvexProviderWithHerculesAuth } from "./ConvexProviderWithHercules.js";
|
|
5
|
+
|
|
6
|
+
configure({ reactStrictMode: true });
|
|
7
|
+
|
|
8
|
+
function makeJwt(exp: number): string {
|
|
9
|
+
const header = btoa(JSON.stringify({ alg: "none" }));
|
|
10
|
+
const payload = btoa(JSON.stringify({ exp }));
|
|
11
|
+
return `${header}.${payload}.sig`;
|
|
12
|
+
}
|
|
13
|
+
|
|
14
|
+
const mockSigninSilent = vi.fn();
|
|
15
|
+
|
|
16
|
+
let mockAuthState: Record<string, unknown> = {};
|
|
17
|
+
|
|
18
|
+
vi.mock("react-oidc-context", () => ({
|
|
19
|
+
useAuth: () => mockAuthState,
|
|
20
|
+
}));
|
|
21
|
+
|
|
22
|
+
type CapturedUseAuth = () => {
|
|
23
|
+
isLoading: boolean;
|
|
24
|
+
isAuthenticated: boolean;
|
|
25
|
+
fetchAccessToken: (args: {
|
|
26
|
+
forceRefreshToken: boolean;
|
|
27
|
+
}) => Promise<string | null>;
|
|
28
|
+
};
|
|
29
|
+
|
|
30
|
+
let capturedUseAuth: CapturedUseAuth | null = null;
|
|
31
|
+
|
|
32
|
+
vi.mock("convex/react", () => ({
|
|
33
|
+
ConvexProviderWithAuth: ({
|
|
34
|
+
children,
|
|
35
|
+
useAuth,
|
|
36
|
+
}: {
|
|
37
|
+
children: ReactNode;
|
|
38
|
+
useAuth: CapturedUseAuth;
|
|
39
|
+
}) => {
|
|
40
|
+
capturedUseAuth = useAuth;
|
|
41
|
+
return children;
|
|
42
|
+
},
|
|
43
|
+
}));
|
|
44
|
+
|
|
45
|
+
// Token expiring in 30 minutes (within the 1hr refresh threshold)
|
|
46
|
+
const EXPIRING_TOKEN = makeJwt(Math.floor(Date.now() / 1000) + 30 * 60);
|
|
47
|
+
// Token expiring in 2 hours (outside the 1hr refresh threshold)
|
|
48
|
+
const LONG_LIVED_TOKEN = makeJwt(Math.floor(Date.now() / 1000) + 2 * 60 * 60);
|
|
49
|
+
|
|
50
|
+
function setAuthState(overrides: Record<string, unknown>) {
|
|
51
|
+
mockAuthState = {
|
|
52
|
+
isLoading: false,
|
|
53
|
+
isAuthenticated: true,
|
|
54
|
+
user: { id_token: EXPIRING_TOKEN },
|
|
55
|
+
signinSilent: mockSigninSilent,
|
|
56
|
+
...overrides,
|
|
57
|
+
};
|
|
58
|
+
}
|
|
59
|
+
|
|
60
|
+
beforeEach(() => {
|
|
61
|
+
setAuthState({});
|
|
62
|
+
mockSigninSilent.mockReset();
|
|
63
|
+
capturedUseAuth = null;
|
|
64
|
+
});
|
|
65
|
+
|
|
66
|
+
function renderUseAuth() {
|
|
67
|
+
renderHook(() => null, {
|
|
68
|
+
wrapper: ({ children }) => (
|
|
69
|
+
<ConvexProviderWithHerculesAuth client={{} as never}>
|
|
70
|
+
{children}
|
|
71
|
+
</ConvexProviderWithHerculesAuth>
|
|
72
|
+
),
|
|
73
|
+
});
|
|
74
|
+
if (!capturedUseAuth) {
|
|
75
|
+
throw new Error("useAuth not captured");
|
|
76
|
+
}
|
|
77
|
+
const captured = capturedUseAuth;
|
|
78
|
+
return renderHook(() => captured());
|
|
79
|
+
}
|
|
80
|
+
|
|
81
|
+
describe("ConvexProviderWithHerculesAuth isLoading", () => {
|
|
82
|
+
it("reports isLoading false when isAuthenticated is true even if underlying isLoading is true", () => {
|
|
83
|
+
setAuthState({ isLoading: true, isAuthenticated: true });
|
|
84
|
+
|
|
85
|
+
const { result } = renderUseAuth();
|
|
86
|
+
|
|
87
|
+
expect(result.current.isLoading).toBe(false);
|
|
88
|
+
expect(result.current.isAuthenticated).toBe(true);
|
|
89
|
+
});
|
|
90
|
+
|
|
91
|
+
it("reports isLoading true when not authenticated and still loading", () => {
|
|
92
|
+
setAuthState({ isLoading: true, isAuthenticated: false, user: null });
|
|
93
|
+
|
|
94
|
+
const { result } = renderUseAuth();
|
|
95
|
+
|
|
96
|
+
expect(result.current.isLoading).toBe(true);
|
|
97
|
+
expect(result.current.isAuthenticated).toBe(false);
|
|
98
|
+
});
|
|
99
|
+
});
|
|
100
|
+
|
|
101
|
+
describe("ConvexProviderWithHerculesAuth fetchAccessToken", () => {
|
|
102
|
+
it("returns the cached id token when forceRefreshToken is false", async () => {
|
|
103
|
+
const { result } = renderUseAuth();
|
|
104
|
+
|
|
105
|
+
const token = await result.current.fetchAccessToken({
|
|
106
|
+
forceRefreshToken: false,
|
|
107
|
+
});
|
|
108
|
+
|
|
109
|
+
expect(token).toBe(EXPIRING_TOKEN);
|
|
110
|
+
expect(mockSigninSilent).not.toHaveBeenCalled();
|
|
111
|
+
});
|
|
112
|
+
|
|
113
|
+
it("skips refresh when token expires more than 1 hour from now", async () => {
|
|
114
|
+
setAuthState({ user: { id_token: LONG_LIVED_TOKEN } });
|
|
115
|
+
|
|
116
|
+
const { result } = renderUseAuth();
|
|
117
|
+
|
|
118
|
+
const token = await result.current.fetchAccessToken({
|
|
119
|
+
forceRefreshToken: true,
|
|
120
|
+
});
|
|
121
|
+
|
|
122
|
+
expect(token).toBe(LONG_LIVED_TOKEN);
|
|
123
|
+
expect(mockSigninSilent).not.toHaveBeenCalled();
|
|
124
|
+
});
|
|
125
|
+
|
|
126
|
+
it("calls signinSilent and returns the refreshed token when forceRefreshToken is true", async () => {
|
|
127
|
+
mockSigninSilent.mockResolvedValue({ id_token: "fresh-token" });
|
|
128
|
+
|
|
129
|
+
const { result } = renderUseAuth();
|
|
130
|
+
|
|
131
|
+
let token: string | null = null;
|
|
132
|
+
await act(async () => {
|
|
133
|
+
token = await result.current.fetchAccessToken({
|
|
134
|
+
forceRefreshToken: true,
|
|
135
|
+
});
|
|
136
|
+
});
|
|
137
|
+
|
|
138
|
+
expect(token).toBe("fresh-token");
|
|
139
|
+
expect(mockSigninSilent).toHaveBeenCalledOnce();
|
|
140
|
+
});
|
|
141
|
+
|
|
142
|
+
it("returns null when signinSilent throws", async () => {
|
|
143
|
+
mockSigninSilent.mockRejectedValue(new Error("refresh failed"));
|
|
144
|
+
|
|
145
|
+
const { result } = renderUseAuth();
|
|
146
|
+
|
|
147
|
+
let token: string | null = "unset";
|
|
148
|
+
await act(async () => {
|
|
149
|
+
token = await result.current.fetchAccessToken({
|
|
150
|
+
forceRefreshToken: true,
|
|
151
|
+
});
|
|
152
|
+
});
|
|
153
|
+
|
|
154
|
+
expect(token).toBeNull();
|
|
155
|
+
expect(mockSigninSilent).toHaveBeenCalledOnce();
|
|
156
|
+
});
|
|
157
|
+
|
|
158
|
+
it("returns null when signinSilent resolves without a user", async () => {
|
|
159
|
+
mockSigninSilent.mockResolvedValue(null);
|
|
160
|
+
|
|
161
|
+
const { result } = renderUseAuth();
|
|
162
|
+
|
|
163
|
+
let token: string | null = "unset";
|
|
164
|
+
await act(async () => {
|
|
165
|
+
token = await result.current.fetchAccessToken({
|
|
166
|
+
forceRefreshToken: true,
|
|
167
|
+
});
|
|
168
|
+
});
|
|
169
|
+
|
|
170
|
+
expect(token).toBeNull();
|
|
171
|
+
expect(mockSigninSilent).toHaveBeenCalledOnce();
|
|
172
|
+
});
|
|
173
|
+
|
|
174
|
+
it("dedupes concurrent forceRefreshToken calls into a single signinSilent", async () => {
|
|
175
|
+
let resolveSilent: ((value: { id_token: string }) => void) | null = null;
|
|
176
|
+
mockSigninSilent.mockImplementation(
|
|
177
|
+
() =>
|
|
178
|
+
new Promise<{ id_token: string }>((resolve) => {
|
|
179
|
+
resolveSilent = resolve;
|
|
180
|
+
}),
|
|
181
|
+
);
|
|
182
|
+
|
|
183
|
+
const { result } = renderUseAuth();
|
|
184
|
+
|
|
185
|
+
let firstToken: string | null = null;
|
|
186
|
+
let secondToken: string | null = null;
|
|
187
|
+
let thirdToken: string | null = null;
|
|
188
|
+
|
|
189
|
+
await act(async () => {
|
|
190
|
+
const first = result.current.fetchAccessToken({
|
|
191
|
+
forceRefreshToken: true,
|
|
192
|
+
});
|
|
193
|
+
const second = result.current.fetchAccessToken({
|
|
194
|
+
forceRefreshToken: true,
|
|
195
|
+
});
|
|
196
|
+
const third = result.current.fetchAccessToken({
|
|
197
|
+
forceRefreshToken: true,
|
|
198
|
+
});
|
|
199
|
+
|
|
200
|
+
resolveSilent?.({ id_token: "fresh-token" });
|
|
201
|
+
|
|
202
|
+
[firstToken, secondToken, thirdToken] = await Promise.all([
|
|
203
|
+
first,
|
|
204
|
+
second,
|
|
205
|
+
third,
|
|
206
|
+
]);
|
|
207
|
+
});
|
|
208
|
+
|
|
209
|
+
expect(firstToken).toBe("fresh-token");
|
|
210
|
+
expect(secondToken).toBe("fresh-token");
|
|
211
|
+
expect(thirdToken).toBe("fresh-token");
|
|
212
|
+
expect(mockSigninSilent).toHaveBeenCalledOnce();
|
|
213
|
+
});
|
|
214
|
+
|
|
215
|
+
it("allows a new refresh after the in-flight refresh settles", async () => {
|
|
216
|
+
mockSigninSilent
|
|
217
|
+
.mockResolvedValueOnce({ id_token: "first-fresh" })
|
|
218
|
+
.mockResolvedValueOnce({ id_token: "second-fresh" });
|
|
219
|
+
|
|
220
|
+
const { result } = renderUseAuth();
|
|
221
|
+
|
|
222
|
+
let firstToken: string | null = null;
|
|
223
|
+
let secondToken: string | null = null;
|
|
224
|
+
|
|
225
|
+
await act(async () => {
|
|
226
|
+
firstToken = await result.current.fetchAccessToken({
|
|
227
|
+
forceRefreshToken: true,
|
|
228
|
+
});
|
|
229
|
+
});
|
|
230
|
+
await act(async () => {
|
|
231
|
+
secondToken = await result.current.fetchAccessToken({
|
|
232
|
+
forceRefreshToken: true,
|
|
233
|
+
});
|
|
234
|
+
});
|
|
235
|
+
|
|
236
|
+
expect(firstToken).toBe("first-fresh");
|
|
237
|
+
expect(secondToken).toBe("second-fresh");
|
|
238
|
+
expect(mockSigninSilent).toHaveBeenCalledTimes(2);
|
|
239
|
+
});
|
|
240
|
+
});
|
|
@@ -2,10 +2,129 @@
|
|
|
2
2
|
|
|
3
3
|
import type { ReactNode } from "react";
|
|
4
4
|
import { ConvexProviderWithAuth, type ConvexReactClient } from "convex/react";
|
|
5
|
-
import {
|
|
5
|
+
import { jwtDecode } from "jwt-decode";
|
|
6
|
+
import { useCallback, useMemo, useRef } from "react";
|
|
6
7
|
import { useAuth } from "react-oidc-context";
|
|
7
8
|
import type { HerculesAuthProvider } from "../react/HerculesAuthProvider";
|
|
8
9
|
|
|
10
|
+
const REFRESH_THRESHOLD_MS = 60 * 60 * 1000; // 1 hour
|
|
11
|
+
const LOCK_KEY = "__herculesAuthRefresh";
|
|
12
|
+
|
|
13
|
+
function tokenExpiresWithin(token: string, ms: number): boolean {
|
|
14
|
+
try {
|
|
15
|
+
const payload = jwtDecode(token);
|
|
16
|
+
return payload.exp! * 1000 - Date.now() < ms;
|
|
17
|
+
} catch {
|
|
18
|
+
return true;
|
|
19
|
+
}
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
// Cross-tab mutex: uses Web Locks API when available, falls back to a
|
|
23
|
+
// simple in-memory queue for environments that don't support it.
|
|
24
|
+
async function withLock<T>(key: string, callback: () => Promise<T>): Promise<T> {
|
|
25
|
+
if (typeof navigator !== "undefined" && navigator.locks) {
|
|
26
|
+
return navigator.locks.request(key, callback);
|
|
27
|
+
}
|
|
28
|
+
return manualMutex(key, callback);
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
const mutexes = new Map<
|
|
32
|
+
string,
|
|
33
|
+
{ running: Promise<void> | null; waiting: Array<() => Promise<void>> }
|
|
34
|
+
>();
|
|
35
|
+
|
|
36
|
+
async function manualMutex<T>(
|
|
37
|
+
key: string,
|
|
38
|
+
callback: () => Promise<T>,
|
|
39
|
+
): Promise<T> {
|
|
40
|
+
return new Promise<T>((resolve, reject) => {
|
|
41
|
+
const wrapped = () =>
|
|
42
|
+
callback()
|
|
43
|
+
.then(resolve)
|
|
44
|
+
.catch(reject)
|
|
45
|
+
.finally(() => {
|
|
46
|
+
const mutex = mutexes.get(key)!;
|
|
47
|
+
const next = mutex.waiting.shift();
|
|
48
|
+
if (next) {
|
|
49
|
+
mutex.running = next();
|
|
50
|
+
} else {
|
|
51
|
+
mutex.running = null;
|
|
52
|
+
}
|
|
53
|
+
});
|
|
54
|
+
|
|
55
|
+
let mutex = mutexes.get(key);
|
|
56
|
+
if (!mutex) {
|
|
57
|
+
mutex = { running: null, waiting: [] };
|
|
58
|
+
mutexes.set(key, mutex);
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
if (mutex.running === null) {
|
|
62
|
+
mutex.running = wrapped();
|
|
63
|
+
} else {
|
|
64
|
+
mutex.waiting.push(wrapped);
|
|
65
|
+
}
|
|
66
|
+
});
|
|
67
|
+
}
|
|
68
|
+
|
|
69
|
+
function useUseAuthFromHercules() {
|
|
70
|
+
const { isAuthenticated, user, isLoading, signinSilent } = useAuth();
|
|
71
|
+
const idToken = user?.id_token;
|
|
72
|
+
|
|
73
|
+
// Ref so the re-check inside the lock sees updates from other tabs
|
|
74
|
+
const idTokenRef = useRef(idToken);
|
|
75
|
+
idTokenRef.current = idToken;
|
|
76
|
+
|
|
77
|
+
const inFlightRefresh = useRef<Promise<string | null> | null>(null);
|
|
78
|
+
|
|
79
|
+
const fetchAccessToken = useCallback(
|
|
80
|
+
async ({ forceRefreshToken }: { forceRefreshToken: boolean }) => {
|
|
81
|
+
if (!forceRefreshToken) {
|
|
82
|
+
return idToken ?? null;
|
|
83
|
+
}
|
|
84
|
+
if (
|
|
85
|
+
idToken != null &&
|
|
86
|
+
!tokenExpiresWithin(idToken, REFRESH_THRESHOLD_MS)
|
|
87
|
+
) {
|
|
88
|
+
return idToken;
|
|
89
|
+
}
|
|
90
|
+
// Same-tab dedup: concurrent callers share one promise
|
|
91
|
+
if (inFlightRefresh.current) {
|
|
92
|
+
return inFlightRefresh.current;
|
|
93
|
+
}
|
|
94
|
+
const refresh = withLock(LOCK_KEY, async () => {
|
|
95
|
+
// Re-check after acquiring lock — another tab may have refreshed
|
|
96
|
+
const currentToken = idTokenRef.current;
|
|
97
|
+
if (
|
|
98
|
+
currentToken != null &&
|
|
99
|
+
!tokenExpiresWithin(currentToken, REFRESH_THRESHOLD_MS)
|
|
100
|
+
) {
|
|
101
|
+
return currentToken;
|
|
102
|
+
}
|
|
103
|
+
try {
|
|
104
|
+
const refreshed = await signinSilent();
|
|
105
|
+
return refreshed?.id_token ?? null;
|
|
106
|
+
} catch {
|
|
107
|
+
return null;
|
|
108
|
+
}
|
|
109
|
+
}).finally(() => {
|
|
110
|
+
inFlightRefresh.current = null;
|
|
111
|
+
});
|
|
112
|
+
inFlightRefresh.current = refresh;
|
|
113
|
+
return refresh;
|
|
114
|
+
},
|
|
115
|
+
[idToken, signinSilent],
|
|
116
|
+
);
|
|
117
|
+
|
|
118
|
+
return useMemo(
|
|
119
|
+
() => ({
|
|
120
|
+
isLoading: isAuthenticated ? false : isLoading,
|
|
121
|
+
isAuthenticated,
|
|
122
|
+
fetchAccessToken,
|
|
123
|
+
}),
|
|
124
|
+
[isLoading, isAuthenticated, fetchAccessToken],
|
|
125
|
+
);
|
|
126
|
+
}
|
|
127
|
+
|
|
9
128
|
/**
|
|
10
129
|
* A wrapper React component which provides a {@link ConvexReactClient}
|
|
11
130
|
* authenticated with Hercules Auth.
|
|
@@ -27,30 +146,3 @@ export function ConvexProviderWithHerculesAuth({
|
|
|
27
146
|
</ConvexProviderWithAuth>
|
|
28
147
|
);
|
|
29
148
|
}
|
|
30
|
-
|
|
31
|
-
function useUseAuthFromHercules() {
|
|
32
|
-
const { isAuthenticated, user, isLoading, signinSilent } = useAuth();
|
|
33
|
-
const idToken = user?.id_token;
|
|
34
|
-
const fetchAccessToken = useCallback(
|
|
35
|
-
async ({ forceRefreshToken: _ignore }: { forceRefreshToken: boolean }) => {
|
|
36
|
-
try {
|
|
37
|
-
// if (forceRefreshToken) {
|
|
38
|
-
// const user = await signinSilent();
|
|
39
|
-
// return user?.id_token ?? null;
|
|
40
|
-
// }
|
|
41
|
-
return idToken ?? null;
|
|
42
|
-
} catch {
|
|
43
|
-
return null;
|
|
44
|
-
}
|
|
45
|
-
},
|
|
46
|
-
[idToken, signinSilent],
|
|
47
|
-
);
|
|
48
|
-
return useMemo(
|
|
49
|
-
() => ({
|
|
50
|
-
isLoading,
|
|
51
|
-
isAuthenticated,
|
|
52
|
-
fetchAccessToken,
|
|
53
|
-
}),
|
|
54
|
-
[isLoading, isAuthenticated, fetchAccessToken],
|
|
55
|
-
);
|
|
56
|
-
}
|