@nodefony/redis 10.0.0-beta.1 → 10.0.0-beta.3
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/README.md +13 -8
- package/dist/_virtual/{_@oxc-project_runtime@0.151.0 → _@oxc-project_runtime@0.153.0}/helpers/esm/decorate.js +1 -1
- package/dist/_virtual/{_@oxc-project_runtime@0.151.0 → _@oxc-project_runtime@0.153.0}/helpers/esm/decorateMetadata.js +1 -1
- package/dist/index.js +2 -2
- package/dist/nodefony/config/config.js +7 -3
- package/dist/nodefony/config/configSchema.js +19 -0
- package/dist/nodefony/config/defineModuleConfig.js +13 -22
- package/dist/nodefony/src/RedisTokenStore.js +56 -25
- package/dist/nodefony/src/RedisWebAuthnCredentialStore.js +26 -19
- package/dist/nodefony/src/SessionStorage.js +201 -55
- package/dist/nodefony/src/scanCursor.js +54 -1
- package/dist/nodefony/src/sessionIndex.js +185 -0
- package/dist/types/nodefony/config/configSchema.d.ts +12 -0
- package/dist/types/nodefony/src/SessionStorage.d.ts +16 -14
- package/dist/types/nodefony/src/scanCursor.d.ts +32 -0
- package/dist/types/nodefony/src/sessionIndex.d.ts +89 -0
- package/docs/architecture.md +77 -79
- package/docs/configuration.md +44 -34
- package/docs/index.md +1 -1
- package/package.json +16 -15
|
@@ -1,4 +1,5 @@
|
|
|
1
|
-
import { MAX_SCAN,
|
|
1
|
+
import { MAX_SCAN, scanPage } from "./scanCursor.js";
|
|
2
|
+
import { SessionIndex, supportsScripts } from "./sessionIndex.js";
|
|
2
3
|
import { assertPageQuery } from "nodefony";
|
|
3
4
|
import { SessionsService } from "@nodefony/http";
|
|
4
5
|
//#region nodefony/src/SessionStorage.ts
|
|
@@ -12,6 +13,25 @@ import { SessionsService } from "@nodefony/http";
|
|
|
12
13
|
*/
|
|
13
14
|
const KEY_BASE = "nf:sess";
|
|
14
15
|
/**
|
|
16
|
+
* Relit une session stockée : `null` si la valeur n'est pas du JSON, ou pas un
|
|
17
|
+
* objet. La forme des sacs se contrôle ensuite au seul consommateur
|
|
18
|
+
* (`Session.deSerialize`, @nodefony/http) — pour tous les stores à la fois.
|
|
19
|
+
*/
|
|
20
|
+
function parseSession(raw) {
|
|
21
|
+
let v;
|
|
22
|
+
try {
|
|
23
|
+
v = JSON.parse(raw);
|
|
24
|
+
} catch {
|
|
25
|
+
return null;
|
|
26
|
+
}
|
|
27
|
+
return typeof v === "object" && v !== null && !Array.isArray(v) ? v : null;
|
|
28
|
+
}
|
|
29
|
+
/** Propriétaire d'une session relue, `""` s'il manque ou n'est pas une chaîne. */
|
|
30
|
+
function ownerOf(data) {
|
|
31
|
+
const user = data.user;
|
|
32
|
+
return typeof user === "string" ? user : "";
|
|
33
|
+
}
|
|
34
|
+
/**
|
|
15
35
|
* Stockage de session **Redis** — branché sur la connexion `main` du
|
|
16
36
|
* {@link RedisService}. Implémente le contrat unifié {@link ISessionStorage}
|
|
17
37
|
* consommé par le `SessionsService` de `@nodefony/http`.
|
|
@@ -35,6 +55,14 @@ var RedisSessionStorage = class {
|
|
|
35
55
|
#service = null;
|
|
36
56
|
/** Préfixe cloisonné, calculé une seule fois (il est lu à chaque clé). */
|
|
37
57
|
#prefixCache = null;
|
|
58
|
+
/** Index de comptage — lazy, construit sur le préfixe au premier usage. */
|
|
59
|
+
#indexCache = null;
|
|
60
|
+
/**
|
|
61
|
+
* Reconstruction EN COURS dans ce process : les comptages concurrents (les
|
|
62
|
+
* quatre cartes de la console partent ensemble) l'attendent au lieu de rendre
|
|
63
|
+
* « inconnu » parce que le premier d'entre eux tient le verrou.
|
|
64
|
+
*/
|
|
65
|
+
#building = null;
|
|
38
66
|
constructor(manager) {
|
|
39
67
|
this.manager = manager;
|
|
40
68
|
this.idleTimeoutS = manager.options.idleTimeoutS;
|
|
@@ -63,12 +91,26 @@ var RedisSessionStorage = class {
|
|
|
63
91
|
#key(id) {
|
|
64
92
|
return `${this.#prefix()}:${id}`;
|
|
65
93
|
}
|
|
94
|
+
/** L'index de comptage de CETTE cloison (cf `sessionIndex.ts`). */
|
|
95
|
+
#index() {
|
|
96
|
+
this.#indexCache ??= new SessionIndex(this.#prefix());
|
|
97
|
+
return this.#indexCache;
|
|
98
|
+
}
|
|
99
|
+
/**
|
|
100
|
+
* Un échec de l'index ne doit JAMAIS faire échouer la session : il est
|
|
101
|
+
* journalisé, et l'index INVALIDÉ — le prochain comptage le reconstruit
|
|
102
|
+
* plutôt que de rendre un chiffre faux.
|
|
103
|
+
*/
|
|
104
|
+
#indexFailed(client, e) {
|
|
105
|
+
this.manager.log(`REDIS SESSIONS index: ${e instanceof Error ? e.message : String(e)} — index invalidé, reconstruit au prochain comptage`, "WARNING");
|
|
106
|
+
client.del(this.#index().builtKey).catch(() => void 0);
|
|
107
|
+
}
|
|
66
108
|
async read(id) {
|
|
67
109
|
const client = this.#client();
|
|
68
110
|
if (!client) return {};
|
|
69
111
|
const raw = await client.get(this.#key(id));
|
|
70
112
|
if (!raw) return {};
|
|
71
|
-
return
|
|
113
|
+
return parseSession(raw) ?? {};
|
|
72
114
|
}
|
|
73
115
|
async start(id) {
|
|
74
116
|
return this.read(id);
|
|
@@ -81,10 +123,20 @@ var RedisSessionStorage = class {
|
|
|
81
123
|
updatedAt: now
|
|
82
124
|
};
|
|
83
125
|
const client = this.#client();
|
|
84
|
-
if (client)
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
126
|
+
if (client) {
|
|
127
|
+
const written = client.set(this.#key(id), JSON.stringify(payload), { expiration: {
|
|
128
|
+
type: "EX",
|
|
129
|
+
value: this.idleTimeoutS
|
|
130
|
+
} });
|
|
131
|
+
if (supportsScripts(client)) {
|
|
132
|
+
const indexed = this.#index().add(client, {
|
|
133
|
+
id,
|
|
134
|
+
user: payload.user || "",
|
|
135
|
+
expiresAt: now.getTime() + this.idleTimeoutS * 1e3
|
|
136
|
+
}).catch((e) => this.#indexFailed(client, e));
|
|
137
|
+
await Promise.all([written, indexed]);
|
|
138
|
+
} else await written;
|
|
139
|
+
}
|
|
88
140
|
return payload;
|
|
89
141
|
}
|
|
90
142
|
async open() {
|
|
@@ -96,7 +148,13 @@ var RedisSessionStorage = class {
|
|
|
96
148
|
}
|
|
97
149
|
async destroy(id) {
|
|
98
150
|
const client = this.#client();
|
|
99
|
-
if (client)
|
|
151
|
+
if (client) {
|
|
152
|
+
const deleted = client.del(this.#key(id));
|
|
153
|
+
if (supportsScripts(client)) {
|
|
154
|
+
const dropped = this.#index().drop(client, id).catch((e) => this.#indexFailed(client, e));
|
|
155
|
+
await Promise.all([deleted, dropped]);
|
|
156
|
+
} else await deleted;
|
|
157
|
+
}
|
|
100
158
|
return true;
|
|
101
159
|
}
|
|
102
160
|
async gc() {}
|
|
@@ -110,7 +168,28 @@ var RedisSessionStorage = class {
|
|
|
110
168
|
async touch(id, idleSeconds) {
|
|
111
169
|
const client = this.#client();
|
|
112
170
|
if (!client) return;
|
|
113
|
-
|
|
171
|
+
const idle = idleSeconds ?? this.idleTimeoutS;
|
|
172
|
+
const expired = client.expire(this.#key(id), idle);
|
|
173
|
+
if (!supportsScripts(client)) {
|
|
174
|
+
await expired;
|
|
175
|
+
return;
|
|
176
|
+
}
|
|
177
|
+
const expiresAt = Date.now() + idle * 1e3;
|
|
178
|
+
const [, known] = await Promise.all([expired, this.#index().touch(client, id, expiresAt).catch((e) => {
|
|
179
|
+
this.#indexFailed(client, e);
|
|
180
|
+
return true;
|
|
181
|
+
})]);
|
|
182
|
+
if (!known) {
|
|
183
|
+
const raw = await client.get(this.#key(id));
|
|
184
|
+
if (!raw) return;
|
|
185
|
+
const data = parseSession(raw);
|
|
186
|
+
if (!data) return;
|
|
187
|
+
await this.#index().add(client, {
|
|
188
|
+
id,
|
|
189
|
+
user: ownerOf(data),
|
|
190
|
+
expiresAt
|
|
191
|
+
}).catch((e) => this.#indexFailed(client, e));
|
|
192
|
+
}
|
|
114
193
|
}
|
|
115
194
|
/**
|
|
116
195
|
* Énumération admin (capacité optionnelle d'`ISessionStorage`) par **SCAN**
|
|
@@ -138,12 +217,8 @@ var RedisSessionStorage = class {
|
|
|
138
217
|
scanned++;
|
|
139
218
|
const raw = await client.get(key);
|
|
140
219
|
if (!raw) continue;
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
data = JSON.parse(raw);
|
|
144
|
-
} catch {
|
|
145
|
-
continue;
|
|
146
|
-
}
|
|
220
|
+
const data = parseSession(raw);
|
|
221
|
+
if (!data) continue;
|
|
147
222
|
if (filter?.user !== void 0 && data.user !== filter.user) continue;
|
|
148
223
|
out.push({
|
|
149
224
|
id: key.slice(prefixLen),
|
|
@@ -160,12 +235,13 @@ var RedisSessionStorage = class {
|
|
|
160
235
|
/**
|
|
161
236
|
* {@inheritDoc ISessionStorage.listPage}
|
|
162
237
|
*
|
|
163
|
-
* **Curseur SCAN** :
|
|
164
|
-
*
|
|
165
|
-
*
|
|
166
|
-
*
|
|
167
|
-
*
|
|
168
|
-
*
|
|
238
|
+
* **Curseur SCAN** : les lots `SCAN` s'enchaînent jusqu'à REMPLIR la page, finir
|
|
239
|
+
* le balayage, ou épuiser l'effort borné ({@link MAX_SCAN} emplacements
|
|
240
|
+
* examinés par appel, cold-path admin). Capacité réduite ASSUMÉE et annoncée —
|
|
241
|
+
* pas de `total`, pas d'ordre global sur `updatedAt` (Redis n'a pas d'index
|
|
242
|
+
* secondaire ici). Une page n'est incomplète qu'en FIN de balayage ou budget
|
|
243
|
+
* épuisé, et porte alors son `nextCursor`. La garantie qui compte est tenue :
|
|
244
|
+
* **le keyspace n'est jamais matérialisé** — un lot à la fois.
|
|
169
245
|
*
|
|
170
246
|
* ⚠️ **`COUNT` n'est PAS un plafond** — c'est un indice d'effort par itération.
|
|
171
247
|
* Redis peut rendre plus de clés que demandé (typiquement un petit keyspace
|
|
@@ -187,64 +263,134 @@ var RedisSessionStorage = class {
|
|
|
187
263
|
hasNext: false,
|
|
188
264
|
nextCursor: null
|
|
189
265
|
};
|
|
190
|
-
const { scanCursor, skip } = decodeCursor(query.cursor);
|
|
191
|
-
const res = await client.scan(scanCursor, {
|
|
192
|
-
MATCH: `${this.#prefix()}:*`,
|
|
193
|
-
COUNT: limit
|
|
194
|
-
});
|
|
195
|
-
const next = res.cursor;
|
|
196
266
|
const prefixLen = this.#prefix().length + 1;
|
|
197
|
-
const
|
|
198
|
-
|
|
199
|
-
|
|
200
|
-
|
|
201
|
-
|
|
267
|
+
const match = `${this.#prefix()}:*`;
|
|
268
|
+
const { items, nextCursor } = await scanPage((cursor) => client.scan(cursor, {
|
|
269
|
+
MATCH: match,
|
|
270
|
+
COUNT: limit
|
|
271
|
+
}), query.cursor, limit, async (key) => {
|
|
202
272
|
const raw = await client.get(key);
|
|
203
|
-
if (!raw)
|
|
204
|
-
|
|
205
|
-
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
}
|
|
210
|
-
if (query.user !== void 0 && data.user !== query.user) continue;
|
|
211
|
-
if (query.authenticated !== void 0 && !!data.user !== query.authenticated) continue;
|
|
212
|
-
items.push({
|
|
273
|
+
if (!raw) return null;
|
|
274
|
+
const data = parseSession(raw);
|
|
275
|
+
if (!data) return null;
|
|
276
|
+
if (query.user !== void 0 && data.user !== query.user) return null;
|
|
277
|
+
if (query.authenticated !== void 0 && !!data.user !== query.authenticated) return null;
|
|
278
|
+
return {
|
|
213
279
|
id: key.slice(prefixLen),
|
|
214
280
|
data: {
|
|
215
281
|
...data,
|
|
216
282
|
Attributes: {},
|
|
217
283
|
flashBag: {}
|
|
218
284
|
}
|
|
219
|
-
}
|
|
220
|
-
}
|
|
221
|
-
const
|
|
285
|
+
};
|
|
286
|
+
});
|
|
287
|
+
const total = await this.countSessions(query);
|
|
222
288
|
return {
|
|
223
289
|
items,
|
|
224
290
|
limit,
|
|
225
291
|
hasNext: nextCursor !== null,
|
|
226
|
-
nextCursor
|
|
292
|
+
nextCursor,
|
|
293
|
+
...total >= 0 ? { total } : {}
|
|
227
294
|
};
|
|
228
295
|
}
|
|
229
296
|
/**
|
|
297
|
+
* L'index couvre-t-il les sessions ANTÉRIEURES à lui ? Sinon, un seul pod le
|
|
298
|
+
* reconstruit (verrou `SET NX`) par un balayage complet — une fois par
|
|
299
|
+
* déploiement, sur le chemin d'administration, jamais sur une requête.
|
|
300
|
+
*
|
|
301
|
+
* @returns `false` si un autre pod reconstruit en ce moment : le comptage
|
|
302
|
+
* rend alors « inconnu », pas un chiffre partiel.
|
|
303
|
+
*/
|
|
304
|
+
#ensureIndexBuilt(client) {
|
|
305
|
+
this.#building ??= this.#buildIndex(client).finally(() => {
|
|
306
|
+
this.#building = null;
|
|
307
|
+
});
|
|
308
|
+
return this.#building;
|
|
309
|
+
}
|
|
310
|
+
async #buildIndex(client) {
|
|
311
|
+
const index = this.#index();
|
|
312
|
+
if (await client.get(index.builtKey) !== null) return true;
|
|
313
|
+
if (await client.set(index.lockKey, String(process.pid), {
|
|
314
|
+
condition: "NX",
|
|
315
|
+
expiration: {
|
|
316
|
+
type: "EX",
|
|
317
|
+
value: 300
|
|
318
|
+
}
|
|
319
|
+
}) === null) return false;
|
|
320
|
+
try {
|
|
321
|
+
const prefixLen = this.#prefix().length + 1;
|
|
322
|
+
let cursor = "0";
|
|
323
|
+
let indexed = 0;
|
|
324
|
+
do {
|
|
325
|
+
const res = await client.scan(cursor, {
|
|
326
|
+
MATCH: `${this.#prefix()}:*`,
|
|
327
|
+
COUNT: 500
|
|
328
|
+
});
|
|
329
|
+
cursor = res.cursor;
|
|
330
|
+
for (const key of res.keys) {
|
|
331
|
+
const [raw, ttl] = await Promise.all([client.get(key), client.pTTL(key)]);
|
|
332
|
+
if (!raw || ttl <= 0) continue;
|
|
333
|
+
const data = parseSession(raw);
|
|
334
|
+
if (!data) continue;
|
|
335
|
+
await index.add(client, {
|
|
336
|
+
id: key.slice(prefixLen),
|
|
337
|
+
user: ownerOf(data),
|
|
338
|
+
expiresAt: Date.now() + ttl
|
|
339
|
+
});
|
|
340
|
+
indexed += 1;
|
|
341
|
+
}
|
|
342
|
+
} while (cursor !== "0");
|
|
343
|
+
await client.set(index.builtKey, String(Date.now()));
|
|
344
|
+
this.manager.log(`REDIS SESSIONS index reconstruit : ${indexed} session(s)`, "INFO");
|
|
345
|
+
return true;
|
|
346
|
+
} finally {
|
|
347
|
+
await client.del(index.lockKey);
|
|
348
|
+
}
|
|
349
|
+
}
|
|
350
|
+
/** Le client `main`, s'il sait exécuter les scripts de l'index. */
|
|
351
|
+
#clientForIndex() {
|
|
352
|
+
const client = this.#client();
|
|
353
|
+
return client && supportsScripts(client) ? client : null;
|
|
354
|
+
}
|
|
355
|
+
/**
|
|
230
356
|
* {@inheritDoc ISessionStorage.countSessions}
|
|
231
357
|
*
|
|
232
|
-
*
|
|
233
|
-
*
|
|
234
|
-
*
|
|
358
|
+
* Compté par l'INDEX (`sessionIndex.ts`), jamais par balayage : `ZCOUNT` sur
|
|
359
|
+
* les sessions dont l'expiration est à venir. Même périmètre que le filtre
|
|
360
|
+
* de liste — filtres contradictoires (`user` + `authenticated: false`) = 0.
|
|
361
|
+
* Rend **`-1`** (« inconnu ») quand l'index n'est pas disponible : client
|
|
362
|
+
* sans scripts, ou reconstruction en cours sur un autre pod.
|
|
235
363
|
*/
|
|
236
|
-
countSessions(
|
|
237
|
-
|
|
364
|
+
async countSessions(query) {
|
|
365
|
+
const client = this.#clientForIndex();
|
|
366
|
+
if (!client || !await this.#ensureIndexBuilt(client)) return -1;
|
|
367
|
+
const index = this.#index();
|
|
368
|
+
const now = Date.now();
|
|
369
|
+
await index.prune(client, now);
|
|
370
|
+
const user = query?.user;
|
|
371
|
+
const auth = query?.authenticated;
|
|
372
|
+
if (user !== void 0 && user !== "") return auth === false ? 0 : index.count(client, { user }, now);
|
|
373
|
+
const anonymous = async () => await index.count(client, "all", now) - await index.count(client, "auth", now);
|
|
374
|
+
if (user === "") return auth === true ? 0 : anonymous();
|
|
375
|
+
if (auth === true) return index.count(client, "auth", now);
|
|
376
|
+
if (auth === false) return anonymous();
|
|
377
|
+
return index.count(client, "all", now);
|
|
238
378
|
}
|
|
239
379
|
/**
|
|
240
380
|
* {@inheritDoc ISessionStorage.countDistinctUsers}
|
|
241
381
|
*
|
|
242
|
-
*
|
|
243
|
-
*
|
|
244
|
-
* Renvoie **`-1`** — la console affiche « — », elle n'invente pas un chiffre.
|
|
382
|
+
* Les PERSONNES : l'index tient chaque utilisateur avec l'expiration de sa
|
|
383
|
+
* session la plus tardive — il disparaît du compte avec sa dernière session.
|
|
245
384
|
*/
|
|
246
|
-
countDistinctUsers(
|
|
247
|
-
|
|
385
|
+
async countDistinctUsers(query) {
|
|
386
|
+
const client = this.#clientForIndex();
|
|
387
|
+
if (!client || !await this.#ensureIndexBuilt(client)) return -1;
|
|
388
|
+
if (query?.authenticated === false || query?.user === "") return 0;
|
|
389
|
+
const index = this.#index();
|
|
390
|
+
const now = Date.now();
|
|
391
|
+
await index.prune(client, now);
|
|
392
|
+
if (query?.user !== void 0) return await index.count(client, { user: query.user }, now) > 0 ? 1 : 0;
|
|
393
|
+
return index.count(client, "users", now);
|
|
248
394
|
}
|
|
249
395
|
};
|
|
250
396
|
SessionsService.registerStorage("redis", RedisSessionStorage);
|
|
@@ -65,5 +65,58 @@ function decodeCursor(cursor) {
|
|
|
65
65
|
function scanOrZero(value) {
|
|
66
66
|
return /^\d+$/.test(value) ? value : "0";
|
|
67
67
|
}
|
|
68
|
+
/**
|
|
69
|
+
* Rend UNE page d'un balayage `SCAN` filtré — règle unique des trois stores.
|
|
70
|
+
*
|
|
71
|
+
* Les lots s'enchaînent jusqu'à **remplir** la page, finir le balayage, ou
|
|
72
|
+
* épuiser l'effort borné ({@link MAX_SCAN} emplacements examinés par appel).
|
|
73
|
+
* 🔴 Un seul lot ne suffit pas : `SCAN COUNT` examine des emplacements de TOUT
|
|
74
|
+
* le keyspace (autres applications, idempotence, jetons), et un lot peut ne
|
|
75
|
+
* contenir aucune clé retenue par le filtre. Rendre cette page vide ferait
|
|
76
|
+
* conclure « rien » à tout consommateur qui ne suit pas le curseur — c'était
|
|
77
|
+
* le cas de la console « Mes sessions » sur un Redis partagé.
|
|
78
|
+
*
|
|
79
|
+
* Le curseur rendu est composite ({@link encodeCursor}) : une page pleine au
|
|
80
|
+
* milieu d'un lot reprend au MÊME lot, à la bonne position. Le keyspace n'est
|
|
81
|
+
* jamais matérialisé — un lot à la fois.
|
|
82
|
+
*
|
|
83
|
+
* @param scan - lance un `SCAN` depuis ce curseur (MATCH et COUNT fixés par
|
|
84
|
+
* l'appelant ; `COUNT` doit rester le même d'une page à l'autre)
|
|
85
|
+
* @param cursor - curseur reçu du client (non fiable — décodé et validé)
|
|
86
|
+
* @param limit - taille maximale de la page
|
|
87
|
+
* @param accept - lit une clé et rend l'élément à publier, ou `null` s'il est
|
|
88
|
+
* écarté (filtre, clé expirée, valeur corrompue)
|
|
89
|
+
* @returns les éléments de la page et le curseur suivant (`null` = fin)
|
|
90
|
+
*/
|
|
91
|
+
async function scanPage(scan, cursor, limit, accept) {
|
|
92
|
+
let { scanCursor, skip } = decodeCursor(cursor);
|
|
93
|
+
const items = [];
|
|
94
|
+
let budget = Math.max(1, Math.ceil(MAX_SCAN / limit));
|
|
95
|
+
for (;;) {
|
|
96
|
+
const res = await scan(scanCursor);
|
|
97
|
+
budget -= 1;
|
|
98
|
+
let consumed = 0;
|
|
99
|
+
for (const key of res.keys.slice(skip)) {
|
|
100
|
+
if (items.length >= limit) break;
|
|
101
|
+
consumed += 1;
|
|
102
|
+
const item = await accept(key);
|
|
103
|
+
if (item !== null) items.push(item);
|
|
104
|
+
}
|
|
105
|
+
if (skip + consumed < res.keys.length) return {
|
|
106
|
+
items,
|
|
107
|
+
nextCursor: encodeCursor(scanCursor, skip + consumed)
|
|
108
|
+
};
|
|
109
|
+
if (res.cursor === "0") return {
|
|
110
|
+
items,
|
|
111
|
+
nextCursor: null
|
|
112
|
+
};
|
|
113
|
+
scanCursor = scanOrZero(res.cursor);
|
|
114
|
+
skip = 0;
|
|
115
|
+
if (items.length >= limit || budget <= 0) return {
|
|
116
|
+
items,
|
|
117
|
+
nextCursor: encodeCursor(scanCursor, 0)
|
|
118
|
+
};
|
|
119
|
+
}
|
|
120
|
+
}
|
|
68
121
|
//#endregion
|
|
69
|
-
export { MAX_SCAN, decodeCursor, encodeCursor, scanOrZero };
|
|
122
|
+
export { MAX_SCAN, decodeCursor, encodeCursor, scanOrZero, scanPage };
|
|
@@ -0,0 +1,185 @@
|
|
|
1
|
+
//#region nodefony/src/sessionIndex.ts
|
|
2
|
+
/** Taille d'un lot de purge : borne le temps d'un script, qui bloque Redis. */
|
|
3
|
+
const PRUNE_BATCH = 500;
|
|
4
|
+
/**
|
|
5
|
+
* Inscrit (ou réinscrit) une session. Gère le CHANGEMENT de propriétaire : la
|
|
6
|
+
* session quitte l'index de l'ancien, dont l'expiration la plus tardive est
|
|
7
|
+
* recalculée — sinon un utilisateur déconnecté resterait compté.
|
|
8
|
+
*/
|
|
9
|
+
const ADD = `
|
|
10
|
+
local b, id, user, exp = ARGV[1], ARGV[2], ARGV[3], ARGV[4]
|
|
11
|
+
local owner = b .. ':owner'
|
|
12
|
+
local old = redis.call('HGET', owner, id)
|
|
13
|
+
if old and old ~= user and old ~= '' then
|
|
14
|
+
local uk = b .. ':u:' .. old
|
|
15
|
+
redis.call('ZREM', uk, id)
|
|
16
|
+
local top = redis.call('ZRANGE', uk, -1, -1, 'WITHSCORES')
|
|
17
|
+
if #top == 0 then redis.call('ZREM', b .. ':users', old)
|
|
18
|
+
else redis.call('ZADD', b .. ':users', top[2], old) end
|
|
19
|
+
end
|
|
20
|
+
redis.call('HSET', owner, id, user)
|
|
21
|
+
redis.call('ZADD', b .. ':all', exp, id)
|
|
22
|
+
if user ~= '' then
|
|
23
|
+
redis.call('ZADD', b .. ':auth', exp, id)
|
|
24
|
+
redis.call('ZADD', b .. ':u:' .. user, exp, id)
|
|
25
|
+
redis.call('ZADD', b .. ':users', 'GT', exp, user)
|
|
26
|
+
else
|
|
27
|
+
redis.call('ZREM', b .. ':auth', id)
|
|
28
|
+
end
|
|
29
|
+
return 1
|
|
30
|
+
`;
|
|
31
|
+
/** Prolonge une session DÉJÀ indexée ; rend 0 si elle ne l'est pas. */
|
|
32
|
+
const TOUCH = `
|
|
33
|
+
local b, id, exp = ARGV[1], ARGV[2], ARGV[3]
|
|
34
|
+
local user = redis.call('HGET', b .. ':owner', id)
|
|
35
|
+
if not user then return 0 end
|
|
36
|
+
redis.call('ZADD', b .. ':all', 'XX', exp, id)
|
|
37
|
+
if user ~= '' then
|
|
38
|
+
redis.call('ZADD', b .. ':auth', 'XX', exp, id)
|
|
39
|
+
redis.call('ZADD', b .. ':u:' .. user, 'XX', exp, id)
|
|
40
|
+
redis.call('ZADD', b .. ':users', 'GT', exp, user)
|
|
41
|
+
end
|
|
42
|
+
return 1
|
|
43
|
+
`;
|
|
44
|
+
/** Retire une session détruite (révocation, déconnexion). */
|
|
45
|
+
const DROP = `
|
|
46
|
+
local b, id = ARGV[1], ARGV[2]
|
|
47
|
+
local owner = b .. ':owner'
|
|
48
|
+
local user = redis.call('HGET', owner, id)
|
|
49
|
+
redis.call('HDEL', owner, id)
|
|
50
|
+
redis.call('ZREM', b .. ':all', id)
|
|
51
|
+
redis.call('ZREM', b .. ':auth', id)
|
|
52
|
+
if user and user ~= '' then
|
|
53
|
+
local uk = b .. ':u:' .. user
|
|
54
|
+
redis.call('ZREM', uk, id)
|
|
55
|
+
local top = redis.call('ZRANGE', uk, -1, -1, 'WITHSCORES')
|
|
56
|
+
if #top == 0 then redis.call('ZREM', b .. ':users', user)
|
|
57
|
+
else redis.call('ZADD', b .. ':users', top[2], user) end
|
|
58
|
+
end
|
|
59
|
+
return 1
|
|
60
|
+
`;
|
|
61
|
+
/**
|
|
62
|
+
* Purge UN lot d'entrées expirées. Les utilisateurs n'ont pas besoin de
|
|
63
|
+
* recalcul : le score d'un utilisateur est son expiration la plus TARDIVE, donc
|
|
64
|
+
* il n'expire qu'avec sa dernière session.
|
|
65
|
+
*/
|
|
66
|
+
const PRUNE = `
|
|
67
|
+
local b, now, batch = ARGV[1], ARGV[2], tonumber(ARGV[3])
|
|
68
|
+
local ids = redis.call('ZRANGEBYSCORE', b .. ':all', '-inf', now, 'LIMIT', 0, batch)
|
|
69
|
+
for _, id in ipairs(ids) do
|
|
70
|
+
local user = redis.call('HGET', b .. ':owner', id)
|
|
71
|
+
redis.call('HDEL', b .. ':owner', id)
|
|
72
|
+
if user and user ~= '' then redis.call('ZREM', b .. ':u:' .. user, id) end
|
|
73
|
+
end
|
|
74
|
+
if #ids > 0 then
|
|
75
|
+
redis.call('ZREM', b .. ':all', unpack(ids))
|
|
76
|
+
redis.call('ZREM', b .. ':auth', unpack(ids))
|
|
77
|
+
end
|
|
78
|
+
redis.call('ZREMRANGEBYSCORE', b .. ':users', '-inf', now)
|
|
79
|
+
return #ids
|
|
80
|
+
`;
|
|
81
|
+
/** Compte ce qui expire APRÈS `now` — l'expiré n'est jamais compté. */
|
|
82
|
+
const COUNT = `
|
|
83
|
+
local key, now = ARGV[1], ARGV[2]
|
|
84
|
+
return redis.call('ZCOUNT', key, '(' .. now, '+inf')
|
|
85
|
+
`;
|
|
86
|
+
/**
|
|
87
|
+
* Index des sessions d'UN store (une cloison d'application).
|
|
88
|
+
*
|
|
89
|
+
* Il ne lève jamais vers le chemin d'une requête : un échec d'indexation est
|
|
90
|
+
* rendu à l'appelant, qui le journalise et INVALIDE l'index ({@link invalidate})
|
|
91
|
+
* — le prochain comptage le reconstruit plutôt que de rendre un chiffre faux.
|
|
92
|
+
*/
|
|
93
|
+
var SessionIndex = class {
|
|
94
|
+
/** Base des clés : `<préfixe>~{idx}`. */
|
|
95
|
+
base;
|
|
96
|
+
#shas = /* @__PURE__ */ new Map();
|
|
97
|
+
constructor(prefix) {
|
|
98
|
+
this.base = `${prefix}~{idx}`;
|
|
99
|
+
}
|
|
100
|
+
/** Clé du marqueur « l'index couvre les sessions antérieures ». */
|
|
101
|
+
get builtKey() {
|
|
102
|
+
return `${this.base}:built`;
|
|
103
|
+
}
|
|
104
|
+
/** Clé du verrou de reconstruction (un seul pod reconstruit). */
|
|
105
|
+
get lockKey() {
|
|
106
|
+
return `${this.base}:building`;
|
|
107
|
+
}
|
|
108
|
+
/** Inscrit ou réinscrit une session. */
|
|
109
|
+
async add(client, s) {
|
|
110
|
+
await this.#run(client, "add", ADD, [
|
|
111
|
+
this.base,
|
|
112
|
+
s.id,
|
|
113
|
+
s.user,
|
|
114
|
+
String(s.expiresAt)
|
|
115
|
+
]);
|
|
116
|
+
}
|
|
117
|
+
/**
|
|
118
|
+
* Prolonge une session indexée.
|
|
119
|
+
*
|
|
120
|
+
* @returns `false` si la session n'est pas dans l'index (antérieure à lui, ou
|
|
121
|
+
* écrite par une version qui ne l'alimentait pas) : à l'appelant de l'y
|
|
122
|
+
* inscrire, lui seul sait lire son propriétaire.
|
|
123
|
+
*/
|
|
124
|
+
async touch(client, id, expiresAt) {
|
|
125
|
+
return await this.#run(client, "touch", TOUCH, [
|
|
126
|
+
this.base,
|
|
127
|
+
id,
|
|
128
|
+
String(expiresAt)
|
|
129
|
+
]) === 1;
|
|
130
|
+
}
|
|
131
|
+
/** Retire une session détruite. */
|
|
132
|
+
async drop(client, id) {
|
|
133
|
+
await this.#run(client, "drop", DROP, [this.base, id]);
|
|
134
|
+
}
|
|
135
|
+
/** Purge les entrées expirées, par lots — borne la mémoire de l'index. */
|
|
136
|
+
async prune(client, now) {
|
|
137
|
+
let total = 0;
|
|
138
|
+
for (;;) {
|
|
139
|
+
const n = Number(await this.#run(client, "prune", PRUNE, [
|
|
140
|
+
this.base,
|
|
141
|
+
String(now),
|
|
142
|
+
String(500)
|
|
143
|
+
]));
|
|
144
|
+
total += n;
|
|
145
|
+
if (n < 500) return total;
|
|
146
|
+
}
|
|
147
|
+
}
|
|
148
|
+
/** Compte les entrées vivantes d'un ensemble de l'index. */
|
|
149
|
+
async count(client, what, now) {
|
|
150
|
+
const key = typeof what === "object" ? `${this.base}:u:${what.user}` : `${this.base}:${what}`;
|
|
151
|
+
return Number(await this.#run(client, "count", COUNT, [key, String(now)]));
|
|
152
|
+
}
|
|
153
|
+
/**
|
|
154
|
+
* Exécute un script par son empreinte, et le recharge si Redis l'a oublié
|
|
155
|
+
* (redémarrage, `SCRIPT FLUSH`) — UNE fois : un second `NOSCRIPT` n'est pas
|
|
156
|
+
* un oubli, c'est une panne, et il remonte.
|
|
157
|
+
*/
|
|
158
|
+
async #run(client, name, script, args) {
|
|
159
|
+
for (let attempt = 0;; attempt += 1) {
|
|
160
|
+
let sha = this.#shas.get(name);
|
|
161
|
+
if (sha === void 0) {
|
|
162
|
+
sha = await client.scriptLoad(script);
|
|
163
|
+
this.#shas.set(name, sha);
|
|
164
|
+
}
|
|
165
|
+
try {
|
|
166
|
+
return await client.evalSha(sha, {
|
|
167
|
+
keys: [],
|
|
168
|
+
arguments: args
|
|
169
|
+
});
|
|
170
|
+
} catch (e) {
|
|
171
|
+
if (attempt === 0 && String(e).includes("NOSCRIPT")) {
|
|
172
|
+
this.#shas.delete(name);
|
|
173
|
+
continue;
|
|
174
|
+
}
|
|
175
|
+
throw e;
|
|
176
|
+
}
|
|
177
|
+
}
|
|
178
|
+
}
|
|
179
|
+
};
|
|
180
|
+
/** Le client sait-il exécuter des scripts ? (un double de test, non.) */
|
|
181
|
+
function supportsScripts(client) {
|
|
182
|
+
return typeof client === "object" && client !== null && "scriptLoad" in client && typeof client.scriptLoad === "function" && "evalSha" in client && typeof client.evalSha === "function";
|
|
183
|
+
}
|
|
184
|
+
//#endregion
|
|
185
|
+
export { PRUNE_BATCH, SessionIndex, supportsScripts };
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* JSON Schema de la configuration de `@nodefony/redis` — lu SANS démarrer
|
|
3
|
+
* l'application, par `nodefony env` et la notice `.env.example`, qui y
|
|
4
|
+
* trouvent les noms courts (`.meta({ env })`).
|
|
5
|
+
*
|
|
6
|
+
* Déclaré dans `package.json` → `nodefony.configSchema` ; le nom de l'export
|
|
7
|
+
* est FIXE. Fichier FEUILLE : il n'importe que zod et le schéma, et n'ouvre
|
|
8
|
+
* rien à l'import — une commande qui ne démarre pas l'application l'exécute.
|
|
9
|
+
*
|
|
10
|
+
* @returns le JSON Schema, métadonnées Nodefony comprises.
|
|
11
|
+
*/
|
|
12
|
+
export declare function configJsonSchema(): unknown;
|
|
@@ -49,12 +49,13 @@ declare class RedisSessionStorage implements ISessionStorage {
|
|
|
49
49
|
/**
|
|
50
50
|
* {@inheritDoc ISessionStorage.listPage}
|
|
51
51
|
*
|
|
52
|
-
* **Curseur SCAN** :
|
|
53
|
-
*
|
|
54
|
-
*
|
|
55
|
-
*
|
|
56
|
-
*
|
|
57
|
-
*
|
|
52
|
+
* **Curseur SCAN** : les lots `SCAN` s'enchaînent jusqu'à REMPLIR la page, finir
|
|
53
|
+
* le balayage, ou épuiser l'effort borné ({@link MAX_SCAN} emplacements
|
|
54
|
+
* examinés par appel, cold-path admin). Capacité réduite ASSUMÉE et annoncée —
|
|
55
|
+
* pas de `total`, pas d'ordre global sur `updatedAt` (Redis n'a pas d'index
|
|
56
|
+
* secondaire ici). Une page n'est incomplète qu'en FIN de balayage ou budget
|
|
57
|
+
* épuisé, et porte alors son `nextCursor`. La garantie qui compte est tenue :
|
|
58
|
+
* **le keyspace n'est jamais matérialisé** — un lot à la fois.
|
|
58
59
|
*
|
|
59
60
|
* ⚠️ **`COUNT` n'est PAS un plafond** — c'est un indice d'effort par itération.
|
|
60
61
|
* Redis peut rendre plus de clés que demandé (typiquement un petit keyspace
|
|
@@ -70,18 +71,19 @@ declare class RedisSessionStorage implements ISessionStorage {
|
|
|
70
71
|
/**
|
|
71
72
|
* {@inheritDoc ISessionStorage.countSessions}
|
|
72
73
|
*
|
|
73
|
-
*
|
|
74
|
-
*
|
|
75
|
-
*
|
|
74
|
+
* Compté par l'INDEX (`sessionIndex.ts`), jamais par balayage : `ZCOUNT` sur
|
|
75
|
+
* les sessions dont l'expiration est à venir. Même périmètre que le filtre
|
|
76
|
+
* de liste — filtres contradictoires (`user` + `authenticated: false`) = 0.
|
|
77
|
+
* Rend **`-1`** (« inconnu ») quand l'index n'est pas disponible : client
|
|
78
|
+
* sans scripts, ou reconstruction en cours sur un autre pod.
|
|
76
79
|
*/
|
|
77
|
-
countSessions(
|
|
80
|
+
countSessions(query?: Partial<ISessionListQuery>): Promise<number>;
|
|
78
81
|
/**
|
|
79
82
|
* {@inheritDoc ISessionStorage.countDistinctUsers}
|
|
80
83
|
*
|
|
81
|
-
*
|
|
82
|
-
*
|
|
83
|
-
* Renvoie **`-1`** — la console affiche « — », elle n'invente pas un chiffre.
|
|
84
|
+
* Les PERSONNES : l'index tient chaque utilisateur avec l'expiration de sa
|
|
85
|
+
* session la plus tardive — il disparaît du compte avec sa dernière session.
|
|
84
86
|
*/
|
|
85
|
-
countDistinctUsers(
|
|
87
|
+
countDistinctUsers(query?: Partial<ISessionListQuery>): Promise<number>;
|
|
86
88
|
}
|
|
87
89
|
export default RedisSessionStorage;
|