@terreno/syncdb 57.16.1 → 57.17.0
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/dist/auth/betterAuthAdapter.d.ts +15 -4
- package/dist/auth/betterAuthAdapter.d.ts.map +1 -1
- package/dist/auth/betterAuthAdapter.js +130 -12
- package/dist/auth/betterAuthAdapter.js.map +1 -1
- package/dist/auth/betterAuthAdapter.test.js +321 -0
- package/dist/auth/betterAuthAdapter.test.js.map +1 -1
- package/dist/client.test.js +39 -0
- package/dist/client.test.js.map +1 -1
- package/package.json +1 -1
- package/src/auth/betterAuthAdapter.test.ts +384 -0
- package/src/auth/betterAuthAdapter.ts +155 -14
- package/src/client.test.ts +41 -0
|
@@ -9,14 +9,25 @@ export interface BetterAuthAdapterOptions {
|
|
|
9
9
|
setIntervalFn?: (handler: () => void, ms: number) => unknown;
|
|
10
10
|
/** Interval canceller matching `setIntervalFn` (default global clearInterval). */
|
|
11
11
|
clearIntervalFn?: (handle: unknown) => void;
|
|
12
|
+
/**
|
|
13
|
+
* Synchronous bearer-token reader, for clients that keep the session token locally
|
|
14
|
+
* (for example rtk's `getBetterAuthBearerToken` in web bearer mode). When it returns a
|
|
15
|
+
* token, `getToken` uses it without calling `getSession()`. A null or empty result, or a
|
|
16
|
+
* throw, falls back to reading `getSession()`. `getUserId`, `onAuthChange` and `refresh`
|
|
17
|
+
* always read the session.
|
|
18
|
+
*/
|
|
19
|
+
getBearerToken?: () => string | null;
|
|
12
20
|
}
|
|
13
21
|
/**
|
|
14
22
|
* Adapt a Better Auth client to syncdb's {@link AuthProvider} contract.
|
|
15
|
-
* Tokens
|
|
16
|
-
*
|
|
23
|
+
* Tokens and user ids are read per call via `getSession()`, unless
|
|
24
|
+
* `options.getBearerToken` supplies the token. Tokens are never cached, so
|
|
25
|
+
* Better Auth session refresh is picked up transparently. Auth changes are
|
|
17
26
|
* delivered through the client's nanostore session atom when available, with
|
|
18
|
-
* an injectable polling fallback otherwise.
|
|
19
|
-
*
|
|
27
|
+
* an injectable polling fallback otherwise. Read errors never throw: a failed
|
|
28
|
+
* token read returns null, and a failed user-id read returns the user id the
|
|
29
|
+
* server last confirmed (null before the first confirmation), so a request that
|
|
30
|
+
* fails while offline is never reported as a sign-out.
|
|
20
31
|
*/
|
|
21
32
|
export declare const betterAuthAdapter: (authClient: BetterAuthClientLike, options?: BetterAuthAdapterOptions) => AuthProvider;
|
|
22
33
|
//# sourceMappingURL=betterAuthAdapter.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"betterAuthAdapter.d.ts","sourceRoot":"","sources":["../../src/auth/betterAuthAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,UAAU,CAAC;AAC3C,OAAO,KAAK,
|
|
1
|
+
{"version":3,"file":"betterAuthAdapter.d.ts","sourceRoot":"","sources":["../../src/auth/betterAuthAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,UAAU,CAAC;AAC3C,OAAO,KAAK,EACV,oBAAoB,EAGrB,MAAM,SAAS,CAAC;AAEjB,+EAA+E;AAC/E,eAAO,MAAM,6BAA6B,OAAQ,CAAC;AAEnD,MAAM,WAAW,wBAAwB;IACvC,gGAAgG;IAChG,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2FAA2F;IAC3F,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC;IAC7D,kFAAkF;IAClF,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IAC5C;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;CACtC;AAwCD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,GAC5B,YAAY,oBAAoB,EAChC,UAAS,wBAA6B,KACrC,YAmRF,CAAC"}
|
|
@@ -14,13 +14,35 @@ const unwrapSession = (result) => {
|
|
|
14
14
|
}
|
|
15
15
|
return result;
|
|
16
16
|
};
|
|
17
|
+
/** True for an error whose status says the server has no session for this client. */
|
|
18
|
+
const isUnauthorizedError = (error) => {
|
|
19
|
+
return (Boolean(error) && typeof error === "object" && error.status === 401);
|
|
20
|
+
};
|
|
21
|
+
/**
|
|
22
|
+
* True for a `{error}` envelope from a fetch that failed: Better Auth's client returns one
|
|
23
|
+
* instead of rejecting for many failures. A 401 is the server saying "signed out", so it
|
|
24
|
+
* stays a successful (signed-out) read.
|
|
25
|
+
*/
|
|
26
|
+
const isFailedReadEnvelope = (result) => {
|
|
27
|
+
if (!result || typeof result !== "object" || !("error" in result)) {
|
|
28
|
+
return false;
|
|
29
|
+
}
|
|
30
|
+
const error = result.error;
|
|
31
|
+
if (!error) {
|
|
32
|
+
return false;
|
|
33
|
+
}
|
|
34
|
+
return !isUnauthorizedError(error);
|
|
35
|
+
};
|
|
17
36
|
/**
|
|
18
37
|
* Adapt a Better Auth client to syncdb's {@link AuthProvider} contract.
|
|
19
|
-
* Tokens
|
|
20
|
-
*
|
|
38
|
+
* Tokens and user ids are read per call via `getSession()`, unless
|
|
39
|
+
* `options.getBearerToken` supplies the token. Tokens are never cached, so
|
|
40
|
+
* Better Auth session refresh is picked up transparently. Auth changes are
|
|
21
41
|
* delivered through the client's nanostore session atom when available, with
|
|
22
|
-
* an injectable polling fallback otherwise.
|
|
23
|
-
*
|
|
42
|
+
* an injectable polling fallback otherwise. Read errors never throw: a failed
|
|
43
|
+
* token read returns null, and a failed user-id read returns the user id the
|
|
44
|
+
* server last confirmed (null before the first confirmation), so a request that
|
|
45
|
+
* fails while offline is never reported as a sign-out.
|
|
24
46
|
*/
|
|
25
47
|
export const betterAuthAdapter = (authClient, options = {}) => {
|
|
26
48
|
const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_AUTH_POLL_INTERVAL_MS;
|
|
@@ -28,18 +50,71 @@ export const betterAuthAdapter = (authClient, options = {}) => {
|
|
|
28
50
|
((handler, ms) => setInterval(handler, ms));
|
|
29
51
|
const clearIntervalFn = options.clearIntervalFn ??
|
|
30
52
|
((handle) => clearInterval(handle));
|
|
53
|
+
/**
|
|
54
|
+
* The user id the server last confirmed: set by successful session reads and by
|
|
55
|
+
* session-atom emissions, cleared when either reports signed out. `undefined` until the
|
|
56
|
+
* first confirmation. {@link getUserId} answers with it when a read fails.
|
|
57
|
+
*/
|
|
58
|
+
let confirmedUserId;
|
|
59
|
+
/**
|
|
60
|
+
* Ordering for {@link confirmedUserId}. Every session read takes a ticket when it starts,
|
|
61
|
+
* and every emission that changes or clears the identity takes one when it arrives. The
|
|
62
|
+
* cache keeps the answer with the highest ticket, so a read that started before a sign-out
|
|
63
|
+
* or user switch and resolves after it cannot restore the previous user.
|
|
64
|
+
*/
|
|
65
|
+
let lastTicket = 0;
|
|
66
|
+
let confirmedTicket = 0;
|
|
67
|
+
const takeTicket = () => {
|
|
68
|
+
lastTicket += 1;
|
|
69
|
+
return lastTicket;
|
|
70
|
+
};
|
|
71
|
+
const confirmUserId = (userId, ticket) => {
|
|
72
|
+
if (ticket < confirmedTicket) {
|
|
73
|
+
return;
|
|
74
|
+
}
|
|
75
|
+
confirmedTicket = ticket;
|
|
76
|
+
confirmedUserId = userId;
|
|
77
|
+
};
|
|
78
|
+
/**
|
|
79
|
+
* Record an emission's identity. An emission that only re-confirms the cached user takes no
|
|
80
|
+
* ticket, so it does not discard an in-flight read that may carry a newer sign-out. A
|
|
81
|
+
* signed-out emission always takes one, so it discards every read that started before it.
|
|
82
|
+
*
|
|
83
|
+
* A replay (the atom's current value, delivered synchronously to a new subscriber) is not a
|
|
84
|
+
* new server answer: it may be older than a read that already confirmed a sign-out. It
|
|
85
|
+
* counts as the oldest answer, so it only fills the cache before anything is confirmed.
|
|
86
|
+
*/
|
|
87
|
+
const confirmUserIdFromEmission = (userId, isReplay) => {
|
|
88
|
+
if (isReplay) {
|
|
89
|
+
confirmUserId(userId, 0);
|
|
90
|
+
return;
|
|
91
|
+
}
|
|
92
|
+
if (userId !== null && userId === confirmedUserId) {
|
|
93
|
+
return;
|
|
94
|
+
}
|
|
95
|
+
confirmUserId(userId, takeTicket());
|
|
96
|
+
};
|
|
31
97
|
/**
|
|
32
98
|
* Read the session, distinguishing "read failed" from "signed out". Both surface as
|
|
33
99
|
* a null session, but only the latter is an identity change — see
|
|
34
|
-
* {@link classifyEmission}.
|
|
100
|
+
* {@link classifyEmission}. Better Auth reports a failed fetch either by rejecting or
|
|
101
|
+
* as a `{data: null, error}` envelope; a 401 error means signed out.
|
|
35
102
|
*/
|
|
36
103
|
const readSessionResult = async () => {
|
|
104
|
+
const ticket = takeTicket();
|
|
105
|
+
let result;
|
|
37
106
|
try {
|
|
38
|
-
|
|
107
|
+
result = await authClient.getSession();
|
|
39
108
|
}
|
|
40
109
|
catch {
|
|
41
110
|
return { ok: false, session: null };
|
|
42
111
|
}
|
|
112
|
+
if (isFailedReadEnvelope(result)) {
|
|
113
|
+
return { ok: false, session: null };
|
|
114
|
+
}
|
|
115
|
+
const session = unwrapSession(result);
|
|
116
|
+
confirmUserId(session?.user?.id ?? null, ticket);
|
|
117
|
+
return { ok: true, session };
|
|
43
118
|
};
|
|
44
119
|
const readSession = async () => {
|
|
45
120
|
return (await readSessionResult()).session;
|
|
@@ -55,12 +130,40 @@ export const betterAuthAdapter = (authClient, options = {}) => {
|
|
|
55
130
|
const session = await readSession();
|
|
56
131
|
return Boolean(session?.session?.token);
|
|
57
132
|
};
|
|
133
|
+
/**
|
|
134
|
+
* Read the caller's bearer token, treating a throw (for example blocked storage) like a
|
|
135
|
+
* missing token so the session read still gets a chance.
|
|
136
|
+
*/
|
|
137
|
+
const readBearerToken = () => {
|
|
138
|
+
if (!options.getBearerToken) {
|
|
139
|
+
return null;
|
|
140
|
+
}
|
|
141
|
+
try {
|
|
142
|
+
return options.getBearerToken() || null;
|
|
143
|
+
}
|
|
144
|
+
catch {
|
|
145
|
+
return null;
|
|
146
|
+
}
|
|
147
|
+
};
|
|
58
148
|
const getToken = async () => {
|
|
149
|
+
const bearerToken = readBearerToken();
|
|
150
|
+
if (bearerToken) {
|
|
151
|
+
return bearerToken;
|
|
152
|
+
}
|
|
59
153
|
const session = await readSession();
|
|
60
154
|
return session?.session?.token ?? null;
|
|
61
155
|
};
|
|
156
|
+
/**
|
|
157
|
+
* A failed read answers with the last confirmed user id instead of null: callers such as
|
|
158
|
+
* the syncdb client treat null as a sign-out, and a request that fails while the device is
|
|
159
|
+
* offline proves nothing about the session (INV-2). Before any read has succeeded, a failed
|
|
160
|
+
* read still answers null.
|
|
161
|
+
*/
|
|
62
162
|
const getUserId = async () => {
|
|
63
|
-
const session = await
|
|
163
|
+
const { ok, session } = await readSessionResult();
|
|
164
|
+
if (!ok) {
|
|
165
|
+
return confirmedUserId ?? null;
|
|
166
|
+
}
|
|
64
167
|
return session?.user?.id ?? null;
|
|
65
168
|
};
|
|
66
169
|
/**
|
|
@@ -77,9 +180,12 @@ export const betterAuthAdapter = (authClient, options = {}) => {
|
|
|
77
180
|
};
|
|
78
181
|
/**
|
|
79
182
|
* Classify a session-atom emission for the subscribe path:
|
|
80
|
-
* - "pending": an in-flight fetch state (`isPending: true`)
|
|
81
|
-
* (`
|
|
82
|
-
*
|
|
183
|
+
* - "pending": an in-flight fetch state (`isPending: true`), a refetch start
|
|
184
|
+
* (`isRefetching: true`, which re-emits the previous data rather than a server answer),
|
|
185
|
+
* or a FAILED read (`error` set, other than a 401) — never a change;
|
|
186
|
+
* - `{key}`: a parseable session envelope reduced to its identity (userId|token). A 401
|
|
187
|
+
* error is the server saying "signed out", so it reduces to the signed-out identity,
|
|
188
|
+
* matching how a 401 from `getSession()` is read;
|
|
83
189
|
* - null: an opaque value the adapter cannot interpret.
|
|
84
190
|
*
|
|
85
191
|
* A failed read is deliberately indistinguishable from "pending" here. Better Auth
|
|
@@ -95,9 +201,12 @@ export const betterAuthAdapter = (authClient, options = {}) => {
|
|
|
95
201
|
return null;
|
|
96
202
|
}
|
|
97
203
|
const emission = value;
|
|
98
|
-
if (emission.isPending === true) {
|
|
204
|
+
if (emission.isPending === true || emission.isRefetching === true) {
|
|
99
205
|
return "pending";
|
|
100
206
|
}
|
|
207
|
+
if (isUnauthorizedError(emission.error)) {
|
|
208
|
+
return { key: "|", userId: null };
|
|
209
|
+
}
|
|
101
210
|
if (emission.error) {
|
|
102
211
|
return "pending";
|
|
103
212
|
}
|
|
@@ -114,7 +223,10 @@ export const betterAuthAdapter = (authClient, options = {}) => {
|
|
|
114
223
|
else {
|
|
115
224
|
return null;
|
|
116
225
|
}
|
|
117
|
-
return {
|
|
226
|
+
return {
|
|
227
|
+
key: `${payload?.user?.id ?? ""}|${payload?.session?.token ?? ""}`,
|
|
228
|
+
userId: payload?.user?.id ?? null,
|
|
229
|
+
};
|
|
118
230
|
};
|
|
119
231
|
const onAuthChange = (callback) => {
|
|
120
232
|
const subscribe = authClient.useSession?.subscribe;
|
|
@@ -127,6 +239,7 @@ export const betterAuthAdapter = (authClient, options = {}) => {
|
|
|
127
239
|
// token rotation) may fire the callback. In-flight (`isPending`) states are
|
|
128
240
|
// skipped; opaque values the adapter cannot parse are forwarded as before.
|
|
129
241
|
let lastKey;
|
|
242
|
+
let isSubscribing = true;
|
|
130
243
|
const unsubscribe = subscribe((value) => {
|
|
131
244
|
const parsed = classifyEmission(value);
|
|
132
245
|
if (parsed === "pending") {
|
|
@@ -136,12 +249,17 @@ export const betterAuthAdapter = (authClient, options = {}) => {
|
|
|
136
249
|
callback();
|
|
137
250
|
return;
|
|
138
251
|
}
|
|
252
|
+
// An emission repeating the atom's own last value is not a new server answer (a
|
|
253
|
+
// fetch that started before a newer read can settle late), so it must not
|
|
254
|
+
// overwrite what that read confirmed.
|
|
139
255
|
if (parsed.key === lastKey) {
|
|
140
256
|
return;
|
|
141
257
|
}
|
|
258
|
+
confirmUserIdFromEmission(parsed.userId, isSubscribing);
|
|
142
259
|
lastKey = parsed.key;
|
|
143
260
|
callback();
|
|
144
261
|
});
|
|
262
|
+
isSubscribing = false;
|
|
145
263
|
return typeof unsubscribe === "function" ? unsubscribe : () => { };
|
|
146
264
|
}
|
|
147
265
|
// Polling fallback: sample the session identity and fire on change. The
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"betterAuthAdapter.js","sourceRoot":"","sources":["../../src/auth/betterAuthAdapter.ts"],"names":[],"mappings":"
|
|
1
|
+
{"version":3,"file":"betterAuthAdapter.js","sourceRoot":"","sources":["../../src/auth/betterAuthAdapter.ts"],"names":[],"mappings":"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"}
|
|
@@ -35,11 +35,115 @@ describe("betterAuthAdapter", () => {
|
|
|
35
35
|
expect(await adapter.getToken()).toBeNull();
|
|
36
36
|
expect(await adapter.getUserId()).toBeNull();
|
|
37
37
|
});
|
|
38
|
+
it("keeps the confirmed user id when a later read fails, so offline is not a sign-out", async () => {
|
|
39
|
+
let next = async () => ({
|
|
40
|
+
data: { session: { token: "tok" }, user: { id: "u1" } },
|
|
41
|
+
});
|
|
42
|
+
const adapter = betterAuthAdapter(makeClient(() => next()));
|
|
43
|
+
expect(await adapter.getUserId()).toBe("u1");
|
|
44
|
+
next = async () => {
|
|
45
|
+
throw new TypeError("Failed to fetch");
|
|
46
|
+
};
|
|
47
|
+
expect(await adapter.getUserId()).toBe("u1");
|
|
48
|
+
expect(await adapter.getToken()).toBeNull();
|
|
49
|
+
next = async () => ({
|
|
50
|
+
data: null,
|
|
51
|
+
error: { status: 0, statusText: "Failed to fetch" },
|
|
52
|
+
});
|
|
53
|
+
expect(await adapter.getUserId()).toBe("u1");
|
|
54
|
+
});
|
|
55
|
+
it("returns null after the server confirms sign-out, even if a later read fails", async () => {
|
|
56
|
+
let next = async () => ({
|
|
57
|
+
data: { session: { token: "tok" }, user: { id: "u1" } },
|
|
58
|
+
});
|
|
59
|
+
const adapter = betterAuthAdapter(makeClient(() => next()));
|
|
60
|
+
expect(await adapter.getUserId()).toBe("u1");
|
|
61
|
+
next = async () => ({ data: null });
|
|
62
|
+
expect(await adapter.getUserId()).toBeNull();
|
|
63
|
+
next = async () => {
|
|
64
|
+
throw new TypeError("Failed to fetch");
|
|
65
|
+
};
|
|
66
|
+
expect(await adapter.getUserId()).toBeNull();
|
|
67
|
+
});
|
|
68
|
+
it("treats a 401 error envelope as signed out", async () => {
|
|
69
|
+
let next = async () => ({
|
|
70
|
+
data: { session: { token: "tok" }, user: { id: "u1" } },
|
|
71
|
+
});
|
|
72
|
+
const adapter = betterAuthAdapter(makeClient(() => next()));
|
|
73
|
+
expect(await adapter.getUserId()).toBe("u1");
|
|
74
|
+
next = async () => ({
|
|
75
|
+
data: null,
|
|
76
|
+
error: { status: 401, statusText: "Unauthorized" },
|
|
77
|
+
});
|
|
78
|
+
expect(await adapter.getUserId()).toBeNull();
|
|
79
|
+
});
|
|
38
80
|
it("returns null when getSession resolves to a non-object", async () => {
|
|
39
81
|
const adapter = betterAuthAdapter(makeClient(async () => "nonsense"));
|
|
40
82
|
expect(await adapter.getToken()).toBeNull();
|
|
41
83
|
});
|
|
42
84
|
});
|
|
85
|
+
describe("getBearerToken option", () => {
|
|
86
|
+
const makeCountingClient = () => {
|
|
87
|
+
let count = 0;
|
|
88
|
+
return {
|
|
89
|
+
calls: () => count,
|
|
90
|
+
client: makeClient(async () => {
|
|
91
|
+
count += 1;
|
|
92
|
+
return { data: { session: { token: "session-tok" }, user: { id: "u1" } } };
|
|
93
|
+
}),
|
|
94
|
+
};
|
|
95
|
+
};
|
|
96
|
+
it("returns the bearer token without calling getSession", async () => {
|
|
97
|
+
const { client, calls } = makeCountingClient();
|
|
98
|
+
const adapter = betterAuthAdapter(client, { getBearerToken: () => "t1" });
|
|
99
|
+
expect(await adapter.getToken()).toBe("t1");
|
|
100
|
+
expect(calls()).toBe(0);
|
|
101
|
+
});
|
|
102
|
+
it("reads the getter on every call, so a rotated token is picked up", async () => {
|
|
103
|
+
const { client, calls } = makeCountingClient();
|
|
104
|
+
let bearer = "t1";
|
|
105
|
+
const adapter = betterAuthAdapter(client, { getBearerToken: () => bearer });
|
|
106
|
+
expect(await adapter.getToken()).toBe("t1");
|
|
107
|
+
bearer = "t2";
|
|
108
|
+
expect(await adapter.getToken()).toBe("t2");
|
|
109
|
+
expect(calls()).toBe(0);
|
|
110
|
+
});
|
|
111
|
+
it("reads getSession when the getter returns null", async () => {
|
|
112
|
+
const { client, calls } = makeCountingClient();
|
|
113
|
+
const adapter = betterAuthAdapter(client, { getBearerToken: () => null });
|
|
114
|
+
expect(await adapter.getToken()).toBe("session-tok");
|
|
115
|
+
expect(calls()).toBe(1);
|
|
116
|
+
});
|
|
117
|
+
it("reads getSession when the getter returns an empty string", async () => {
|
|
118
|
+
const { client, calls } = makeCountingClient();
|
|
119
|
+
const adapter = betterAuthAdapter(client, { getBearerToken: () => "" });
|
|
120
|
+
expect(await adapter.getToken()).toBe("session-tok");
|
|
121
|
+
expect(calls()).toBe(1);
|
|
122
|
+
});
|
|
123
|
+
it("reads getSession when the getter throws", async () => {
|
|
124
|
+
const { client, calls } = makeCountingClient();
|
|
125
|
+
const adapter = betterAuthAdapter(client, {
|
|
126
|
+
getBearerToken: () => {
|
|
127
|
+
throw new Error("storage blocked");
|
|
128
|
+
},
|
|
129
|
+
});
|
|
130
|
+
expect(await adapter.getToken()).toBe("session-tok");
|
|
131
|
+
expect(calls()).toBe(1);
|
|
132
|
+
});
|
|
133
|
+
it("reads getSession without the option", async () => {
|
|
134
|
+
const { client, calls } = makeCountingClient();
|
|
135
|
+
const adapter = betterAuthAdapter(client);
|
|
136
|
+
expect(await adapter.getToken()).toBe("session-tok");
|
|
137
|
+
expect(calls()).toBe(1);
|
|
138
|
+
});
|
|
139
|
+
it("leaves getUserId and refresh reading getSession", async () => {
|
|
140
|
+
const { client, calls } = makeCountingClient();
|
|
141
|
+
const adapter = betterAuthAdapter(client, { getBearerToken: () => "t1" });
|
|
142
|
+
expect(await adapter.getUserId()).toBe("u1");
|
|
143
|
+
expect(await adapter.refresh?.()).toBe(true);
|
|
144
|
+
expect(calls()).toBe(2);
|
|
145
|
+
});
|
|
146
|
+
});
|
|
43
147
|
describe("refresh (A4)", () => {
|
|
44
148
|
it("returns true when a re-fetched session carries a token", async () => {
|
|
45
149
|
const adapter = betterAuthAdapter(makeClient(async () => ({ data: { session: { token: "tok-1" }, user: { id: "u1" } } })));
|
|
@@ -167,6 +271,30 @@ describe("betterAuthAdapter", () => {
|
|
|
167
271
|
atom.emit({ data: null });
|
|
168
272
|
expect(count).toBe(2);
|
|
169
273
|
});
|
|
274
|
+
it("answers an auth-change callback's getUserId from the emission when the read fails", async () => {
|
|
275
|
+
// The syncdb client re-reads getUserId inside its auth-change handler. When the
|
|
276
|
+
// device goes offline between the emission and that read, a null answer would be
|
|
277
|
+
// taken as a sign-out.
|
|
278
|
+
const atom = makeAtom();
|
|
279
|
+
const adapter = betterAuthAdapter(makeClient(async () => {
|
|
280
|
+
throw new TypeError("Failed to fetch");
|
|
281
|
+
}, {
|
|
282
|
+
subscribe: (listener) => {
|
|
283
|
+
atom.listeners.add(listener);
|
|
284
|
+
return () => atom.listeners.delete(listener);
|
|
285
|
+
},
|
|
286
|
+
}));
|
|
287
|
+
const seen = [];
|
|
288
|
+
adapter.onAuthChange(() => {
|
|
289
|
+
void adapter.getUserId().then((userId) => seen.push(userId));
|
|
290
|
+
});
|
|
291
|
+
atom.emit({ data: { session: { token: "tok" }, user: { id: "u1" } } });
|
|
292
|
+
await flush();
|
|
293
|
+
expect(seen).toEqual(["u1"]);
|
|
294
|
+
atom.emit({ data: null });
|
|
295
|
+
await flush();
|
|
296
|
+
expect(seen).toEqual(["u1", null]);
|
|
297
|
+
});
|
|
170
298
|
it("forwards opaque emissions it cannot parse (back-compat)", () => {
|
|
171
299
|
const atom = makeAtom();
|
|
172
300
|
const adapter = betterAuthAdapter(makeClient(async () => null, {
|
|
@@ -346,5 +474,198 @@ describe("betterAuthAdapter", () => {
|
|
|
346
474
|
expect(calls).toBeGreaterThanOrEqual(1);
|
|
347
475
|
});
|
|
348
476
|
});
|
|
477
|
+
describe("confirmed user id ordering", () => {
|
|
478
|
+
const makeScriptedClient = () => {
|
|
479
|
+
const listeners = new Set();
|
|
480
|
+
const queue = [];
|
|
481
|
+
let fallback = async () => null;
|
|
482
|
+
return {
|
|
483
|
+
answerWith: (result) => {
|
|
484
|
+
fallback = result;
|
|
485
|
+
},
|
|
486
|
+
client: {
|
|
487
|
+
getSession: () => (queue.shift() ?? fallback)(),
|
|
488
|
+
useSession: {
|
|
489
|
+
subscribe: (listener) => {
|
|
490
|
+
listeners.add(listener);
|
|
491
|
+
return () => listeners.delete(listener);
|
|
492
|
+
},
|
|
493
|
+
},
|
|
494
|
+
},
|
|
495
|
+
emit: (value) => {
|
|
496
|
+
for (const listener of listeners) {
|
|
497
|
+
listener(value);
|
|
498
|
+
}
|
|
499
|
+
},
|
|
500
|
+
holdNext: () => {
|
|
501
|
+
let release = () => { };
|
|
502
|
+
const held = new Promise((resolve) => {
|
|
503
|
+
release = resolve;
|
|
504
|
+
});
|
|
505
|
+
queue.push(() => held);
|
|
506
|
+
return (result) => release(result);
|
|
507
|
+
},
|
|
508
|
+
};
|
|
509
|
+
};
|
|
510
|
+
const offline = async () => {
|
|
511
|
+
throw new TypeError("Failed to fetch");
|
|
512
|
+
};
|
|
513
|
+
const u1Session = { data: { session: { token: "tok-1" }, user: { id: "u1" } } };
|
|
514
|
+
it("drops a read that started before a sign-out emission and resolved after it", async () => {
|
|
515
|
+
const scripted = makeScriptedClient();
|
|
516
|
+
const adapter = betterAuthAdapter(scripted.client);
|
|
517
|
+
adapter.onAuthChange(() => { });
|
|
518
|
+
scripted.emit(u1Session);
|
|
519
|
+
const release = scripted.holdNext();
|
|
520
|
+
const staleRead = adapter.getUserId();
|
|
521
|
+
scripted.emit({ data: null });
|
|
522
|
+
release(u1Session);
|
|
523
|
+
// The read still answers its own caller with what the server returned.
|
|
524
|
+
expect(await staleRead).toBe("u1");
|
|
525
|
+
scripted.answerWith(offline);
|
|
526
|
+
expect(await adapter.getUserId()).toBeNull();
|
|
527
|
+
});
|
|
528
|
+
it("drops a read that resolved after a newer read confirmed sign-out", async () => {
|
|
529
|
+
const scripted = makeScriptedClient();
|
|
530
|
+
const adapter = betterAuthAdapter(scripted.client);
|
|
531
|
+
scripted.answerWith(async () => u1Session);
|
|
532
|
+
expect(await adapter.getUserId()).toBe("u1");
|
|
533
|
+
const release = scripted.holdNext();
|
|
534
|
+
const staleRead = adapter.getUserId();
|
|
535
|
+
scripted.answerWith(async () => ({ data: null }));
|
|
536
|
+
expect(await adapter.getUserId()).toBeNull();
|
|
537
|
+
release(u1Session);
|
|
538
|
+
expect(await staleRead).toBe("u1");
|
|
539
|
+
scripted.answerWith(offline);
|
|
540
|
+
expect(await adapter.getUserId()).toBeNull();
|
|
541
|
+
});
|
|
542
|
+
it("keeps the switched-to user when a read from before the switch resolves late", async () => {
|
|
543
|
+
const scripted = makeScriptedClient();
|
|
544
|
+
const adapter = betterAuthAdapter(scripted.client);
|
|
545
|
+
adapter.onAuthChange(() => { });
|
|
546
|
+
scripted.emit(u1Session);
|
|
547
|
+
const release = scripted.holdNext();
|
|
548
|
+
const staleRead = adapter.getUserId();
|
|
549
|
+
scripted.emit({ data: { session: { token: "tok-2" }, user: { id: "u2" } } });
|
|
550
|
+
release(u1Session);
|
|
551
|
+
expect(await staleRead).toBe("u1");
|
|
552
|
+
scripted.answerWith(offline);
|
|
553
|
+
expect(await adapter.getUserId()).toBe("u2");
|
|
554
|
+
});
|
|
555
|
+
it("does not drop a newer read because an older read resolved first", async () => {
|
|
556
|
+
const scripted = makeScriptedClient();
|
|
557
|
+
const adapter = betterAuthAdapter(scripted.client);
|
|
558
|
+
const releaseOlder = scripted.holdNext();
|
|
559
|
+
const releaseNewer = scripted.holdNext();
|
|
560
|
+
const olderRead = adapter.getUserId();
|
|
561
|
+
const newerRead = adapter.getUserId();
|
|
562
|
+
releaseOlder({ data: { session: { token: "tok-2" }, user: { id: "u2" } } });
|
|
563
|
+
expect(await olderRead).toBe("u2");
|
|
564
|
+
releaseNewer(u1Session);
|
|
565
|
+
expect(await newerRead).toBe("u1");
|
|
566
|
+
scripted.answerWith(offline);
|
|
567
|
+
expect(await adapter.getUserId()).toBe("u1");
|
|
568
|
+
});
|
|
569
|
+
it("lets an in-flight read confirm sign-out when an emission only re-confirmed the same user", async () => {
|
|
570
|
+
const scripted = makeScriptedClient();
|
|
571
|
+
const adapter = betterAuthAdapter(scripted.client);
|
|
572
|
+
adapter.onAuthChange(() => { });
|
|
573
|
+
scripted.emit(u1Session);
|
|
574
|
+
const release = scripted.holdNext();
|
|
575
|
+
const read = adapter.getUserId();
|
|
576
|
+
scripted.emit(u1Session);
|
|
577
|
+
release({ data: null });
|
|
578
|
+
expect(await read).toBeNull();
|
|
579
|
+
scripted.answerWith(offline);
|
|
580
|
+
expect(await adapter.getUserId()).toBeNull();
|
|
581
|
+
});
|
|
582
|
+
it("keeps a read-confirmed user when a late atom fetch repeats the atom's own value", async () => {
|
|
583
|
+
const scripted = makeScriptedClient();
|
|
584
|
+
const adapter = betterAuthAdapter(scripted.client);
|
|
585
|
+
adapter.onAuthChange(() => { });
|
|
586
|
+
scripted.emit(u1Session);
|
|
587
|
+
scripted.answerWith(async () => ({ data: { session: { token: "tok-2" }, user: { id: "u2" } } }));
|
|
588
|
+
expect(await adapter.getUserId()).toBe("u2");
|
|
589
|
+
// An atom fetch that started before that read settles late with the atom's old value.
|
|
590
|
+
scripted.emit(u1Session);
|
|
591
|
+
scripted.answerWith(offline);
|
|
592
|
+
expect(await adapter.getUserId()).toBe("u2");
|
|
593
|
+
});
|
|
594
|
+
it("treats a 401 session-atom emission as a sign-out", async () => {
|
|
595
|
+
const scripted = makeScriptedClient();
|
|
596
|
+
const adapter = betterAuthAdapter(scripted.client);
|
|
597
|
+
let calls = 0;
|
|
598
|
+
adapter.onAuthChange(() => {
|
|
599
|
+
calls += 1;
|
|
600
|
+
});
|
|
601
|
+
scripted.emit(u1Session);
|
|
602
|
+
expect(calls).toBe(1);
|
|
603
|
+
scripted.answerWith(offline);
|
|
604
|
+
scripted.emit({ data: null, error: { status: 401, statusText: "Unauthorized" } });
|
|
605
|
+
expect(calls).toBe(2);
|
|
606
|
+
expect(await adapter.getUserId()).toBeNull();
|
|
607
|
+
// Repeated 401s, and a plain signed-out emission, share one identity and are deduped.
|
|
608
|
+
scripted.emit({ data: null, error: { status: 401, statusText: "Unauthorized" } });
|
|
609
|
+
scripted.emit({ data: null });
|
|
610
|
+
expect(calls).toBe(2);
|
|
611
|
+
});
|
|
612
|
+
it("ignores the stale data a refetch-start emission carries", async () => {
|
|
613
|
+
const scripted = makeScriptedClient();
|
|
614
|
+
const adapter = betterAuthAdapter(scripted.client);
|
|
615
|
+
adapter.onAuthChange(() => { });
|
|
616
|
+
scripted.emit(u1Session);
|
|
617
|
+
// A direct read sees the session revoked while the atom still holds u1.
|
|
618
|
+
scripted.answerWith(async () => ({ data: null }));
|
|
619
|
+
expect(await adapter.getUserId()).toBeNull();
|
|
620
|
+
// Better Auth starts every refetch by re-emitting the previous data.
|
|
621
|
+
scripted.emit({ ...u1Session, error: null, isPending: false, isRefetching: true });
|
|
622
|
+
scripted.answerWith(offline);
|
|
623
|
+
expect(await adapter.getUserId()).toBeNull();
|
|
624
|
+
});
|
|
625
|
+
it("does not let a new subscriber's replay of the cached session restore a signed-out user", async () => {
|
|
626
|
+
// nanostores replays the atom's current value to each new listener synchronously.
|
|
627
|
+
const atomValue = u1Session;
|
|
628
|
+
const listeners = new Set();
|
|
629
|
+
let next = async () => u1Session;
|
|
630
|
+
const adapter = betterAuthAdapter({
|
|
631
|
+
getSession: () => next(),
|
|
632
|
+
useSession: {
|
|
633
|
+
subscribe: (listener) => {
|
|
634
|
+
listeners.add(listener);
|
|
635
|
+
listener(atomValue);
|
|
636
|
+
return () => listeners.delete(listener);
|
|
637
|
+
},
|
|
638
|
+
},
|
|
639
|
+
});
|
|
640
|
+
let calls = 0;
|
|
641
|
+
adapter.onAuthChange(() => {
|
|
642
|
+
calls += 1;
|
|
643
|
+
});
|
|
644
|
+
expect(calls).toBe(1);
|
|
645
|
+
expect(await adapter.getUserId()).toBe("u1");
|
|
646
|
+
next = async () => ({ data: null });
|
|
647
|
+
expect(await adapter.getUserId()).toBeNull();
|
|
648
|
+
// A second consumer subscribes while the atom still holds the old session.
|
|
649
|
+
adapter.onAuthChange(() => {
|
|
650
|
+
calls += 1;
|
|
651
|
+
});
|
|
652
|
+
expect(calls).toBe(2);
|
|
653
|
+
next = offline;
|
|
654
|
+
expect(await adapter.getUserId()).toBeNull();
|
|
655
|
+
});
|
|
656
|
+
it("uses a subscriber's replay as the first confirmation when nothing is confirmed yet", async () => {
|
|
657
|
+
const adapter = betterAuthAdapter({
|
|
658
|
+
getSession: offline,
|
|
659
|
+
useSession: {
|
|
660
|
+
subscribe: (listener) => {
|
|
661
|
+
listener(u1Session);
|
|
662
|
+
return () => { };
|
|
663
|
+
},
|
|
664
|
+
},
|
|
665
|
+
});
|
|
666
|
+
adapter.onAuthChange(() => { });
|
|
667
|
+
expect(await adapter.getUserId()).toBe("u1");
|
|
668
|
+
});
|
|
669
|
+
});
|
|
349
670
|
});
|
|
350
671
|
//# sourceMappingURL=betterAuthAdapter.test.js.map
|