@nodefony/redis 10.0.0-beta.2 → 10.0.0-beta.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.
@@ -1,7 +1,8 @@
1
- import { MAX_SCAN, decodeCursor, encodeCursor } from "./scanCursor.js";
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
- //#region nodefony/src/SessionStorage.ts
5
+ // nodefony/src/SessionStorage.ts
5
6
  /** Préfixe namespacé des clés de session dans Redis. */
6
7
  /**
7
8
  * Préfixe HISTORIQUE des clés de session. Il n'est utilisé tel quel que par une
@@ -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 JSON.parse(raw);
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) await client.set(this.#key(id), JSON.stringify(payload), { expiration: {
85
- type: "EX",
86
- value: this.idleTimeoutS
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) await client.del(this.#key(id));
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
- await client.expire(this.#key(id), idleSeconds ?? this.idleTimeoutS);
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
- let data;
142
- try {
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** : au plus UN passage `SCAN` par appel (cold-path admin).
164
- * Capacité réduite ASSUMÉE et annoncée — pas de `total`, pas d'ordre global sur
165
- * `updatedAt` (Redis n'a pas d'index secondaire ici), et la page peut compter
166
- * moins d'éléments que `limit` (le filtre s'applique au batch scanné). Le client
167
- * boucle tant que `hasNext`, en repassant `nextCursor`. La garantie qui compte
168
- * est tenue : **le keyspace n'est jamais matérialisé** — au plus un batch.
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,66 +263,135 @@ 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 items = [];
198
- let consumed = 0;
199
- for (const key of res.keys.slice(skip)) {
200
- if (items.length >= limit) break;
201
- consumed += 1;
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) continue;
204
- let data;
205
- try {
206
- data = JSON.parse(raw);
207
- } catch {
208
- continue;
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 nextCursor = skip + consumed < res.keys.length ? encodeCursor(scanCursor, skip + consumed) : next === "0" ? null : encodeCursor(next, 0);
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
- * Un comptage exact exigerait un `SCAN` complet O(keyspace) → refusé même sur le
233
- * cold-path admin : renvoie **`-1`** (« inconnu », capacité réduite Redis
234
- * assumée). L'appelant affiche l'inconnu, il ne l'invente pas.
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(_query) {
237
- return Promise.resolve(-1);
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
- * Dédupliquer exige d'avoir tout vu : c'est le `SCAN` complet que
243
- * {@link countSessions} refuse déjà, plus un ensemble à retenir en mémoire.
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(_query) {
247
- return Promise.resolve(-1);
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);
251
- //#endregion
252
397
  export { RedisSessionStorage as default };
@@ -1,4 +1,4 @@
1
- //#region nodefony/src/buildClientOptions.ts
1
+ // nodefony/src/buildClientOptions.ts
2
2
  /**
3
3
  * Construit la fonction `reconnectStrategy` de redis v6 à partir de la politique
4
4
  * déclarative (`baseMs`/`maxMs`/`maxRetries`) — back-off linéaire borné.
@@ -59,5 +59,4 @@ function buildClientOptions(config, connection) {
59
59
  };
60
60
  return options;
61
61
  }
62
- //#endregion
63
62
  export { buildClientOptions };
@@ -1,5 +1,5 @@
1
1
  import { nodefonyError } from "nodefony";
2
- //#region nodefony/src/keyNamespace.ts
2
+ // nodefony/src/keyNamespace.ts
3
3
  /**
4
4
  * Cloison des clés Redis **par application**.
5
5
  *
@@ -76,5 +76,4 @@ function resolveKeyPrefix(base, namespace) {
76
76
  if (separator === -1) return `${base}:${ns}`;
77
77
  return `${base.slice(0, separator)}:${ns}:${base.slice(separator + 1)}`;
78
78
  }
79
- //#endregion
80
79
  export { resolveKeyPrefix };
@@ -1,4 +1,4 @@
1
- //#region nodefony/src/scanCursor.ts
1
+ // nodefony/src/scanCursor.ts
2
2
  /**
3
3
  * Curseur de pagination `SCAN` — **règle unique** des trois stores Redis
4
4
  * (sessions, jetons, identifiants WebAuthn).
@@ -65,5 +65,57 @@ function decodeCursor(cursor) {
65
65
  function scanOrZero(value) {
66
66
  return /^\d+$/.test(value) ? value : "0";
67
67
  }
68
- //#endregion
69
- export { MAX_SCAN, decodeCursor, encodeCursor, scanOrZero };
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
+ }
121
+ export { MAX_SCAN, decodeCursor, encodeCursor, scanOrZero, scanPage };
@@ -0,0 +1,184 @@
1
+ // 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
+ 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;