@useauthio/react 0.2.3 → 0.2.4
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.
- package/CHANGELOG.md +13 -0
- package/README.md +34 -0
- package/dist/index.cjs +379 -0
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.cts +119 -1
- package/dist/index.d.ts +119 -1
- package/dist/index.js +370 -2
- package/dist/index.js.map +1 -1
- package/package.json +2 -1
- package/src/PasskeyManager.tsx +164 -0
- package/src/index.ts +24 -0
- package/src/passkeys.ts +247 -0
- package/src/provider.tsx +10 -0
- package/src/types.ts +8 -0
- package/src/usePasskeys.ts +134 -0
|
@@ -0,0 +1,164 @@
|
|
|
1
|
+
import React, { useState } from "react";
|
|
2
|
+
import { usePasskeys } from "./usePasskeys";
|
|
3
|
+
|
|
4
|
+
export interface PasskeyManagerProps {
|
|
5
|
+
className?: string;
|
|
6
|
+
/** Passed to {@link enrollPasskey} as `returnUrl`. */
|
|
7
|
+
enrollReturnUrl?: string;
|
|
8
|
+
enrollNext?: string;
|
|
9
|
+
}
|
|
10
|
+
|
|
11
|
+
/**
|
|
12
|
+
* Drop-in passkey device list for customer apps. Lists, renames, and
|
|
13
|
+
* revokes via `/v1/me/passkeys`; "Add passkey" redirects to the hosted
|
|
14
|
+
* sign-in UI (`mode=add_credential`) so the WebAuthn ceremony runs on
|
|
15
|
+
* the sign-in origin.
|
|
16
|
+
*/
|
|
17
|
+
export function PasskeyManager({
|
|
18
|
+
className,
|
|
19
|
+
enrollReturnUrl,
|
|
20
|
+
enrollNext,
|
|
21
|
+
}: PasskeyManagerProps): React.ReactElement {
|
|
22
|
+
const { passkeys, loading, error, rename, revoke, enroll } = usePasskeys();
|
|
23
|
+
const [busyId, setBusyId] = useState<string | null>(null);
|
|
24
|
+
const [actionError, setActionError] = useState<string | null>(null);
|
|
25
|
+
const [enrolling, setEnrolling] = useState(false);
|
|
26
|
+
|
|
27
|
+
async function onRename(id: string, nickname: string) {
|
|
28
|
+
setBusyId(id);
|
|
29
|
+
setActionError(null);
|
|
30
|
+
try {
|
|
31
|
+
await rename(id, nickname);
|
|
32
|
+
} catch (err) {
|
|
33
|
+
setActionError(err instanceof Error ? err.message : "Rename failed");
|
|
34
|
+
} finally {
|
|
35
|
+
setBusyId(null);
|
|
36
|
+
}
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
async function onRevoke(id: string) {
|
|
40
|
+
setBusyId(id);
|
|
41
|
+
setActionError(null);
|
|
42
|
+
try {
|
|
43
|
+
await revoke(id);
|
|
44
|
+
} catch (err) {
|
|
45
|
+
setActionError(err instanceof Error ? err.message : "Revoke failed");
|
|
46
|
+
} finally {
|
|
47
|
+
setBusyId(null);
|
|
48
|
+
}
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
async function onEnroll() {
|
|
52
|
+
setEnrolling(true);
|
|
53
|
+
setActionError(null);
|
|
54
|
+
try {
|
|
55
|
+
await enroll({ returnUrl: enrollReturnUrl, next: enrollNext });
|
|
56
|
+
} catch (err) {
|
|
57
|
+
setEnrolling(false);
|
|
58
|
+
setActionError(err instanceof Error ? err.message : "Could not start enrollment");
|
|
59
|
+
}
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
return (
|
|
63
|
+
<section className={className} aria-labelledby="authio-passkey-manager-title">
|
|
64
|
+
<div className="authio-passkey-manager__header">
|
|
65
|
+
<h2 id="authio-passkey-manager-title">Passkeys</h2>
|
|
66
|
+
<button
|
|
67
|
+
type="button"
|
|
68
|
+
onClick={() => void onEnroll()}
|
|
69
|
+
disabled={enrolling || loading}
|
|
70
|
+
>
|
|
71
|
+
{enrolling ? "Redirecting…" : "Add passkey"}
|
|
72
|
+
</button>
|
|
73
|
+
</div>
|
|
74
|
+
|
|
75
|
+
{(error || actionError) && (
|
|
76
|
+
<p role="alert" className="authio-passkey-manager__error">
|
|
77
|
+
{error ?? actionError}
|
|
78
|
+
</p>
|
|
79
|
+
)}
|
|
80
|
+
|
|
81
|
+
{loading ? (
|
|
82
|
+
<p className="authio-passkey-manager__loading">Loading passkeys…</p>
|
|
83
|
+
) : passkeys.length === 0 ? (
|
|
84
|
+
<p className="authio-passkey-manager__empty">
|
|
85
|
+
No passkeys yet. Add one to sign in faster on this account.
|
|
86
|
+
</p>
|
|
87
|
+
) : (
|
|
88
|
+
<ul className="authio-passkey-manager__list">
|
|
89
|
+
{passkeys.map((p) => (
|
|
90
|
+
<li key={p.id} className="authio-passkey-manager__item">
|
|
91
|
+
<PasskeyRow
|
|
92
|
+
passkey={p}
|
|
93
|
+
busy={busyId === p.id}
|
|
94
|
+
onRename={onRename}
|
|
95
|
+
onRevoke={onRevoke}
|
|
96
|
+
/>
|
|
97
|
+
</li>
|
|
98
|
+
))}
|
|
99
|
+
</ul>
|
|
100
|
+
)}
|
|
101
|
+
</section>
|
|
102
|
+
);
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
function PasskeyRow({
|
|
106
|
+
passkey,
|
|
107
|
+
busy,
|
|
108
|
+
onRename,
|
|
109
|
+
onRevoke,
|
|
110
|
+
}: {
|
|
111
|
+
passkey: {
|
|
112
|
+
id: string;
|
|
113
|
+
nickname: string | null;
|
|
114
|
+
authenticator_name: string;
|
|
115
|
+
created_at: string;
|
|
116
|
+
last_used_at: string | null;
|
|
117
|
+
};
|
|
118
|
+
busy: boolean;
|
|
119
|
+
onRename: (id: string, nickname: string) => Promise<void>;
|
|
120
|
+
onRevoke: (id: string) => Promise<void>;
|
|
121
|
+
}) {
|
|
122
|
+
const [nickname, setNickname] = useState(passkey.nickname ?? "");
|
|
123
|
+
|
|
124
|
+
return (
|
|
125
|
+
<div className="authio-passkey-manager__row">
|
|
126
|
+
<div>
|
|
127
|
+
<strong>{passkey.authenticator_name}</strong>
|
|
128
|
+
<div className="authio-passkey-manager__meta">
|
|
129
|
+
Added {new Date(passkey.created_at).toLocaleDateString()}
|
|
130
|
+
{passkey.last_used_at
|
|
131
|
+
? ` · Last used ${new Date(passkey.last_used_at).toLocaleDateString()}`
|
|
132
|
+
: ""}
|
|
133
|
+
</div>
|
|
134
|
+
</div>
|
|
135
|
+
<form
|
|
136
|
+
className="authio-passkey-manager__rename"
|
|
137
|
+
onSubmit={(e) => {
|
|
138
|
+
e.preventDefault();
|
|
139
|
+
void onRename(passkey.id, nickname.trim());
|
|
140
|
+
}}
|
|
141
|
+
>
|
|
142
|
+
<input
|
|
143
|
+
type="text"
|
|
144
|
+
value={nickname}
|
|
145
|
+
onChange={(e) => setNickname(e.target.value)}
|
|
146
|
+
placeholder="Nickname"
|
|
147
|
+
maxLength={64}
|
|
148
|
+
disabled={busy}
|
|
149
|
+
/>
|
|
150
|
+
<button type="submit" disabled={busy}>
|
|
151
|
+
Save
|
|
152
|
+
</button>
|
|
153
|
+
</form>
|
|
154
|
+
<button
|
|
155
|
+
type="button"
|
|
156
|
+
disabled={busy}
|
|
157
|
+
onClick={() => void onRevoke(passkey.id)}
|
|
158
|
+
className="authio-passkey-manager__revoke"
|
|
159
|
+
>
|
|
160
|
+
Revoke
|
|
161
|
+
</button>
|
|
162
|
+
</div>
|
|
163
|
+
);
|
|
164
|
+
}
|
package/src/index.ts
CHANGED
|
@@ -18,6 +18,30 @@ export type {
|
|
|
18
18
|
} from "./gates";
|
|
19
19
|
|
|
20
20
|
export { signInWithMagicLink, signInWithPasskey } from "./sign-in";
|
|
21
|
+
|
|
22
|
+
export {
|
|
23
|
+
addPasskey,
|
|
24
|
+
listPasskeys,
|
|
25
|
+
renamePasskey,
|
|
26
|
+
revokePasskey,
|
|
27
|
+
mintPasskeyRegisterIntent,
|
|
28
|
+
buildEnrollPasskeyUrl,
|
|
29
|
+
enrollPasskey,
|
|
30
|
+
signInOrigin,
|
|
31
|
+
canEnrollPasskeyEmbedded,
|
|
32
|
+
} from "./passkeys";
|
|
33
|
+
export type {
|
|
34
|
+
AuthioPasskey,
|
|
35
|
+
PasskeyApiOptions,
|
|
36
|
+
AddPasskeyOptions,
|
|
37
|
+
EnrollPasskeyOptions,
|
|
38
|
+
} from "./passkeys";
|
|
39
|
+
|
|
40
|
+
export { usePasskeys } from "./usePasskeys";
|
|
41
|
+
export type { UsePasskeysResult } from "./usePasskeys";
|
|
42
|
+
|
|
43
|
+
export { PasskeyManager } from "./PasskeyManager";
|
|
44
|
+
export type { PasskeyManagerProps } from "./PasskeyManager";
|
|
21
45
|
export type {
|
|
22
46
|
SignInWithMagicLinkOptions,
|
|
23
47
|
SignInWithPasskeyOptions,
|
package/src/passkeys.ts
ADDED
|
@@ -0,0 +1,247 @@
|
|
|
1
|
+
import { AuthioError } from "@useauthio/node";
|
|
2
|
+
import { startRegistration } from "@simplewebauthn/browser";
|
|
3
|
+
import { authioFetch } from "./fetch";
|
|
4
|
+
import { isBrowser } from "./ssr";
|
|
5
|
+
|
|
6
|
+
export interface AuthioPasskey {
|
|
7
|
+
id: string;
|
|
8
|
+
nickname: string | null;
|
|
9
|
+
aaguid: string | null;
|
|
10
|
+
authenticator_name: string;
|
|
11
|
+
transports: string[];
|
|
12
|
+
sign_count: number;
|
|
13
|
+
last_used_at: string | null;
|
|
14
|
+
created_at: string;
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
/** Shared options for authenticated `/v1/me/passkeys` calls. */
|
|
18
|
+
export interface PasskeyApiOptions {
|
|
19
|
+
apiUrl: string;
|
|
20
|
+
projectId: string;
|
|
21
|
+
accessToken: string;
|
|
22
|
+
signal?: AbortSignal;
|
|
23
|
+
fetchImpl?: typeof fetch;
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
export interface AddPasskeyOptions extends PasskeyApiOptions {
|
|
27
|
+
email: string;
|
|
28
|
+
/**
|
|
29
|
+
* WebAuthn ceremony origin (sent as `X-Authio-Origin`). Defaults to
|
|
30
|
+
* `window.location.origin` in the browser.
|
|
31
|
+
*/
|
|
32
|
+
origin?: string;
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
export interface EnrollPasskeyOptions extends PasskeyApiOptions {
|
|
36
|
+
email: string;
|
|
37
|
+
/** Hosted sign-in UI base URL (lobby / custom domain). */
|
|
38
|
+
signInUrl: string;
|
|
39
|
+
/** Where to return after enrollment (`redirect_uri` query param). */
|
|
40
|
+
returnUrl?: string;
|
|
41
|
+
/** Post-login path on the return host (`next` query param). */
|
|
42
|
+
next?: string;
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
export interface BuildEnrollPasskeyUrlOptions {
|
|
46
|
+
signInUrl: string;
|
|
47
|
+
projectId: string;
|
|
48
|
+
email: string;
|
|
49
|
+
registerToken: string;
|
|
50
|
+
redirectUri?: string;
|
|
51
|
+
next?: string;
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
/** Normalize a hosted-UI base URL (no trailing slash). */
|
|
55
|
+
export function signInOrigin(signInUrl: string): string {
|
|
56
|
+
return signInUrl.replace(/\/$/, "");
|
|
57
|
+
}
|
|
58
|
+
|
|
59
|
+
/**
|
|
60
|
+
* True when inline WebAuthn registration can run on the current page
|
|
61
|
+
* (same origin as the hosted sign-in UI / custom auth domain).
|
|
62
|
+
*/
|
|
63
|
+
export function canEnrollPasskeyEmbedded(signInUrl: string): boolean {
|
|
64
|
+
if (!isBrowser()) return false;
|
|
65
|
+
return window.location.origin === signInOrigin(signInUrl);
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
/** Build the hosted-UI URL for `mode=add_credential` passkey enrollment. */
|
|
69
|
+
export function buildEnrollPasskeyUrl(
|
|
70
|
+
opts: BuildEnrollPasskeyUrlOptions,
|
|
71
|
+
): string {
|
|
72
|
+
const url = new URL(signInOrigin(opts.signInUrl));
|
|
73
|
+
url.searchParams.set("mode", "add_credential");
|
|
74
|
+
url.searchParams.set("project_id", opts.projectId);
|
|
75
|
+
url.searchParams.set("email", opts.email);
|
|
76
|
+
url.searchParams.set("token", opts.registerToken);
|
|
77
|
+
if (opts.redirectUri) {
|
|
78
|
+
url.searchParams.set("redirect_uri", opts.redirectUri);
|
|
79
|
+
}
|
|
80
|
+
if (opts.next) {
|
|
81
|
+
url.searchParams.set("next", opts.next);
|
|
82
|
+
}
|
|
83
|
+
return url.toString();
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
function bearerHeaders(
|
|
87
|
+
accessToken: string,
|
|
88
|
+
origin?: string,
|
|
89
|
+
): Record<string, string> {
|
|
90
|
+
const h: Record<string, string> = {
|
|
91
|
+
Authorization: `Bearer ${accessToken}`,
|
|
92
|
+
};
|
|
93
|
+
if (origin) h["X-Authio-Origin"] = origin;
|
|
94
|
+
return h;
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
/** Mint a short-lived JWT for add-credential WebAuthn (`register-intent`). */
|
|
98
|
+
export async function mintPasskeyRegisterIntent(
|
|
99
|
+
opts: PasskeyApiOptions,
|
|
100
|
+
): Promise<{ token: string; expiresIn: number }> {
|
|
101
|
+
const body = await authioFetch<{ token: string; expires_in: number }>({
|
|
102
|
+
apiUrl: opts.apiUrl,
|
|
103
|
+
projectId: opts.projectId,
|
|
104
|
+
path: "/v1/me/passkeys/register-intent",
|
|
105
|
+
method: "POST",
|
|
106
|
+
body: {},
|
|
107
|
+
signal: opts.signal,
|
|
108
|
+
fetchImpl: opts.fetchImpl,
|
|
109
|
+
extraHeaders: bearerHeaders(opts.accessToken),
|
|
110
|
+
});
|
|
111
|
+
return { token: body.token, expiresIn: body.expires_in };
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
/**
|
|
115
|
+
* Enroll a passkey by redirecting to the hosted sign-in UI on the
|
|
116
|
+
* sign-in origin (`mode=add_credential`). Use when the SPA origin
|
|
117
|
+
* differs from the WebAuthn RP ID.
|
|
118
|
+
*/
|
|
119
|
+
export async function enrollPasskey(opts: EnrollPasskeyOptions): Promise<void> {
|
|
120
|
+
if (!isBrowser()) {
|
|
121
|
+
throw new AuthioError({
|
|
122
|
+
code: "not_in_browser",
|
|
123
|
+
message: "enrollPasskey can only be invoked in a browser environment.",
|
|
124
|
+
status: 0,
|
|
125
|
+
});
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
const intent = await mintPasskeyRegisterIntent(opts);
|
|
129
|
+
const redirectUri =
|
|
130
|
+
opts.returnUrl ?? (typeof window !== "undefined" ? window.location.href : "");
|
|
131
|
+
const target = buildEnrollPasskeyUrl({
|
|
132
|
+
signInUrl: opts.signInUrl,
|
|
133
|
+
projectId: opts.projectId,
|
|
134
|
+
email: opts.email,
|
|
135
|
+
registerToken: intent.token,
|
|
136
|
+
redirectUri,
|
|
137
|
+
next: opts.next,
|
|
138
|
+
});
|
|
139
|
+
window.location.assign(target);
|
|
140
|
+
}
|
|
141
|
+
|
|
142
|
+
/**
|
|
143
|
+
* Enroll a passkey inline on the current origin via WebAuthn.
|
|
144
|
+
*
|
|
145
|
+
* 1. `POST /v1/me/passkeys/register-intent`
|
|
146
|
+
* 2. `POST /v1/auth/passkey/register/options` + ceremony
|
|
147
|
+
* 3. `POST /v1/auth/passkey/register/verify`
|
|
148
|
+
*/
|
|
149
|
+
export async function addPasskey(opts: AddPasskeyOptions): Promise<void> {
|
|
150
|
+
if (!isBrowser()) {
|
|
151
|
+
throw new AuthioError({
|
|
152
|
+
code: "not_in_browser",
|
|
153
|
+
message: "addPasskey can only be invoked in a browser environment.",
|
|
154
|
+
status: 0,
|
|
155
|
+
});
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
const origin = opts.origin ?? window.location.origin;
|
|
159
|
+
const intent = await mintPasskeyRegisterIntent(opts);
|
|
160
|
+
|
|
161
|
+
const options = await authioFetch<
|
|
162
|
+
Parameters<typeof startRegistration>[0]["optionsJSON"]
|
|
163
|
+
>({
|
|
164
|
+
apiUrl: opts.apiUrl,
|
|
165
|
+
projectId: opts.projectId,
|
|
166
|
+
path: "/v1/auth/passkey/register/options",
|
|
167
|
+
method: "POST",
|
|
168
|
+
body: { email: opts.email },
|
|
169
|
+
signal: opts.signal,
|
|
170
|
+
fetchImpl: opts.fetchImpl,
|
|
171
|
+
extraHeaders: bearerHeaders(intent.token, origin),
|
|
172
|
+
});
|
|
173
|
+
|
|
174
|
+
let attestation: Awaited<ReturnType<typeof startRegistration>>;
|
|
175
|
+
try {
|
|
176
|
+
attestation = await startRegistration({ optionsJSON: options });
|
|
177
|
+
} catch (err) {
|
|
178
|
+
throw new AuthioError({
|
|
179
|
+
code: "webauthn_cancelled",
|
|
180
|
+
message:
|
|
181
|
+
err instanceof Error
|
|
182
|
+
? err.message
|
|
183
|
+
: "Passkey registration cancelled by user.",
|
|
184
|
+
status: 0,
|
|
185
|
+
});
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
await authioFetch<{ ok?: boolean }>({
|
|
189
|
+
apiUrl: opts.apiUrl,
|
|
190
|
+
projectId: opts.projectId,
|
|
191
|
+
path: "/v1/auth/passkey/register/verify",
|
|
192
|
+
method: "POST",
|
|
193
|
+
body: { email: opts.email, credential: attestation },
|
|
194
|
+
signal: opts.signal,
|
|
195
|
+
fetchImpl: opts.fetchImpl,
|
|
196
|
+
extraHeaders: bearerHeaders(intent.token, origin),
|
|
197
|
+
});
|
|
198
|
+
}
|
|
199
|
+
|
|
200
|
+
/** List passkeys for the signed-in user (`GET /v1/me/passkeys`). */
|
|
201
|
+
export async function listPasskeys(
|
|
202
|
+
opts: PasskeyApiOptions,
|
|
203
|
+
): Promise<AuthioPasskey[]> {
|
|
204
|
+
const res = await authioFetch<{ data: AuthioPasskey[] }>({
|
|
205
|
+
apiUrl: opts.apiUrl,
|
|
206
|
+
projectId: opts.projectId,
|
|
207
|
+
path: "/v1/me/passkeys",
|
|
208
|
+
signal: opts.signal,
|
|
209
|
+
fetchImpl: opts.fetchImpl,
|
|
210
|
+
extraHeaders: bearerHeaders(opts.accessToken),
|
|
211
|
+
});
|
|
212
|
+
return res.data ?? [];
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
/** Rename a passkey (`PATCH /v1/me/passkeys/{credentialId}`). */
|
|
216
|
+
export async function renamePasskey(
|
|
217
|
+
opts: PasskeyApiOptions,
|
|
218
|
+
credentialId: string,
|
|
219
|
+
name: string,
|
|
220
|
+
): Promise<void> {
|
|
221
|
+
await authioFetch<{ ok: boolean }>({
|
|
222
|
+
apiUrl: opts.apiUrl,
|
|
223
|
+
projectId: opts.projectId,
|
|
224
|
+
path: `/v1/me/passkeys/${encodeURIComponent(credentialId)}`,
|
|
225
|
+
method: "PATCH",
|
|
226
|
+
body: { nickname: name },
|
|
227
|
+
signal: opts.signal,
|
|
228
|
+
fetchImpl: opts.fetchImpl,
|
|
229
|
+
extraHeaders: bearerHeaders(opts.accessToken),
|
|
230
|
+
});
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
/** Revoke a passkey (`DELETE /v1/me/passkeys/{credentialId}`). */
|
|
234
|
+
export async function revokePasskey(
|
|
235
|
+
opts: PasskeyApiOptions,
|
|
236
|
+
credentialId: string,
|
|
237
|
+
): Promise<void> {
|
|
238
|
+
await authioFetch<{ ok: boolean }>({
|
|
239
|
+
apiUrl: opts.apiUrl,
|
|
240
|
+
projectId: opts.projectId,
|
|
241
|
+
path: `/v1/me/passkeys/${encodeURIComponent(credentialId)}`,
|
|
242
|
+
method: "DELETE",
|
|
243
|
+
signal: opts.signal,
|
|
244
|
+
fetchImpl: opts.fetchImpl,
|
|
245
|
+
extraHeaders: bearerHeaders(opts.accessToken),
|
|
246
|
+
});
|
|
247
|
+
}
|
package/src/provider.tsx
CHANGED
|
@@ -454,11 +454,17 @@ export function AuthioProvider(props: AuthioProviderProps): React.ReactElement {
|
|
|
454
454
|
[],
|
|
455
455
|
);
|
|
456
456
|
|
|
457
|
+
const resolvedSignInUrl = signInUrl ?? DEFAULT_SIGN_IN_URL;
|
|
458
|
+
|
|
457
459
|
const value = useMemo<AuthioContextValue>(
|
|
458
460
|
() => ({
|
|
459
461
|
user,
|
|
460
462
|
status,
|
|
461
463
|
accessToken,
|
|
464
|
+
apiUrl,
|
|
465
|
+
projectId,
|
|
466
|
+
signInUrl: resolvedSignInUrl,
|
|
467
|
+
fetchImpl,
|
|
462
468
|
getAccessToken,
|
|
463
469
|
signIn,
|
|
464
470
|
signOut,
|
|
@@ -469,6 +475,10 @@ export function AuthioProvider(props: AuthioProviderProps): React.ReactElement {
|
|
|
469
475
|
user,
|
|
470
476
|
status,
|
|
471
477
|
accessToken,
|
|
478
|
+
apiUrl,
|
|
479
|
+
projectId,
|
|
480
|
+
resolvedSignInUrl,
|
|
481
|
+
fetchImpl,
|
|
472
482
|
getAccessToken,
|
|
473
483
|
signIn,
|
|
474
484
|
signOut,
|
package/src/types.ts
CHANGED
|
@@ -35,6 +35,14 @@ export interface AuthioContextValue {
|
|
|
35
35
|
user: AuthioUser | null;
|
|
36
36
|
status: AuthioStatus;
|
|
37
37
|
accessToken: string | null;
|
|
38
|
+
/** Same `apiUrl` passed to `<AuthioProvider>`. */
|
|
39
|
+
apiUrl: string;
|
|
40
|
+
/** Same `projectId` passed to `<AuthioProvider>`. */
|
|
41
|
+
projectId: string;
|
|
42
|
+
/** Resolved hosted sign-in URL (custom domain or Lobby default). */
|
|
43
|
+
signInUrl: string;
|
|
44
|
+
/** Custom fetch from provider props, if any. */
|
|
45
|
+
fetchImpl?: typeof fetch;
|
|
38
46
|
/**
|
|
39
47
|
* Returns the current access token, silently refreshing if it's
|
|
40
48
|
* within 10 seconds of expiry. Returns `null` when no session
|
|
@@ -0,0 +1,134 @@
|
|
|
1
|
+
import { useCallback, useEffect, useState } from "react";
|
|
2
|
+
import { useAuthio } from "./hooks";
|
|
3
|
+
import {
|
|
4
|
+
enrollPasskey,
|
|
5
|
+
listPasskeys,
|
|
6
|
+
renamePasskey,
|
|
7
|
+
revokePasskey,
|
|
8
|
+
type AuthioPasskey,
|
|
9
|
+
} from "./passkeys";
|
|
10
|
+
|
|
11
|
+
export interface UsePasskeysResult {
|
|
12
|
+
passkeys: AuthioPasskey[];
|
|
13
|
+
loading: boolean;
|
|
14
|
+
error: string | null;
|
|
15
|
+
refresh: () => Promise<void>;
|
|
16
|
+
rename: (credentialId: string, nickname: string) => Promise<void>;
|
|
17
|
+
revoke: (credentialId: string) => Promise<void>;
|
|
18
|
+
enroll: (opts?: { returnUrl?: string; next?: string }) => Promise<void>;
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
/**
|
|
22
|
+
* Load and mutate the signed-in user's passkeys via `/v1/me/passkeys`.
|
|
23
|
+
* Requires `<AuthioProvider>` with a live session.
|
|
24
|
+
*/
|
|
25
|
+
export function usePasskeys(): UsePasskeysResult {
|
|
26
|
+
const ctx = useAuthio();
|
|
27
|
+
const [passkeys, setPasskeys] = useState<AuthioPasskey[]>([]);
|
|
28
|
+
const [loading, setLoading] = useState(true);
|
|
29
|
+
const [error, setError] = useState<string | null>(null);
|
|
30
|
+
|
|
31
|
+
const refresh = useCallback(async () => {
|
|
32
|
+
if (ctx.status !== "authenticated") {
|
|
33
|
+
setPasskeys([]);
|
|
34
|
+
setLoading(false);
|
|
35
|
+
return;
|
|
36
|
+
}
|
|
37
|
+
setLoading(true);
|
|
38
|
+
setError(null);
|
|
39
|
+
try {
|
|
40
|
+
const token = await ctx.getAccessToken();
|
|
41
|
+
if (!token) {
|
|
42
|
+
setPasskeys([]);
|
|
43
|
+
return;
|
|
44
|
+
}
|
|
45
|
+
const rows = await listPasskeys({
|
|
46
|
+
apiUrl: ctx.apiUrl,
|
|
47
|
+
projectId: ctx.projectId,
|
|
48
|
+
accessToken: token,
|
|
49
|
+
fetchImpl: ctx.fetchImpl,
|
|
50
|
+
});
|
|
51
|
+
setPasskeys(rows);
|
|
52
|
+
} catch (err) {
|
|
53
|
+
setError(err instanceof Error ? err.message : "Failed to load passkeys");
|
|
54
|
+
setPasskeys([]);
|
|
55
|
+
} finally {
|
|
56
|
+
setLoading(false);
|
|
57
|
+
}
|
|
58
|
+
}, [
|
|
59
|
+
ctx.status,
|
|
60
|
+
ctx.getAccessToken,
|
|
61
|
+
ctx.apiUrl,
|
|
62
|
+
ctx.projectId,
|
|
63
|
+
ctx.fetchImpl,
|
|
64
|
+
]);
|
|
65
|
+
|
|
66
|
+
useEffect(() => {
|
|
67
|
+
void refresh();
|
|
68
|
+
}, [refresh, ctx.status]);
|
|
69
|
+
|
|
70
|
+
const rename = useCallback(
|
|
71
|
+
async (credentialId: string, nickname: string) => {
|
|
72
|
+
const token = await ctx.getAccessToken();
|
|
73
|
+
if (!token) throw new Error("Not signed in");
|
|
74
|
+
await renamePasskey(
|
|
75
|
+
{
|
|
76
|
+
apiUrl: ctx.apiUrl,
|
|
77
|
+
projectId: ctx.projectId,
|
|
78
|
+
accessToken: token,
|
|
79
|
+
fetchImpl: ctx.fetchImpl,
|
|
80
|
+
},
|
|
81
|
+
credentialId,
|
|
82
|
+
nickname,
|
|
83
|
+
);
|
|
84
|
+
await refresh();
|
|
85
|
+
},
|
|
86
|
+
[ctx.getAccessToken, ctx.apiUrl, ctx.projectId, ctx.fetchImpl, refresh],
|
|
87
|
+
);
|
|
88
|
+
|
|
89
|
+
const revoke = useCallback(
|
|
90
|
+
async (credentialId: string) => {
|
|
91
|
+
const token = await ctx.getAccessToken();
|
|
92
|
+
if (!token) throw new Error("Not signed in");
|
|
93
|
+
await revokePasskey(
|
|
94
|
+
{
|
|
95
|
+
apiUrl: ctx.apiUrl,
|
|
96
|
+
projectId: ctx.projectId,
|
|
97
|
+
accessToken: token,
|
|
98
|
+
fetchImpl: ctx.fetchImpl,
|
|
99
|
+
},
|
|
100
|
+
credentialId,
|
|
101
|
+
);
|
|
102
|
+
await refresh();
|
|
103
|
+
},
|
|
104
|
+
[ctx.getAccessToken, ctx.apiUrl, ctx.projectId, ctx.fetchImpl, refresh],
|
|
105
|
+
);
|
|
106
|
+
|
|
107
|
+
const enroll = useCallback(
|
|
108
|
+
async (opts?: { returnUrl?: string; next?: string }) => {
|
|
109
|
+
const token = await ctx.getAccessToken();
|
|
110
|
+
const email = ctx.user?.email;
|
|
111
|
+
if (!token || !email) throw new Error("Not signed in");
|
|
112
|
+
await enrollPasskey({
|
|
113
|
+
apiUrl: ctx.apiUrl,
|
|
114
|
+
projectId: ctx.projectId,
|
|
115
|
+
accessToken: token,
|
|
116
|
+
fetchImpl: ctx.fetchImpl,
|
|
117
|
+
email,
|
|
118
|
+
signInUrl: ctx.signInUrl,
|
|
119
|
+
returnUrl: opts?.returnUrl,
|
|
120
|
+
next: opts?.next,
|
|
121
|
+
});
|
|
122
|
+
},
|
|
123
|
+
[
|
|
124
|
+
ctx.getAccessToken,
|
|
125
|
+
ctx.user?.email,
|
|
126
|
+
ctx.apiUrl,
|
|
127
|
+
ctx.projectId,
|
|
128
|
+
ctx.fetchImpl,
|
|
129
|
+
ctx.signInUrl,
|
|
130
|
+
],
|
|
131
|
+
);
|
|
132
|
+
|
|
133
|
+
return { passkeys, loading, error, refresh, rename, revoke, enroll };
|
|
134
|
+
}
|