@nodefony/redis 10.0.0-alpha.8 → 10.0.0-beta.1

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,4 +1,4 @@
1
- //#region \0@oxc-project+runtime@0.150.0/helpers/esm/decorate.js
1
+ //#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorate.js
2
2
  function __decorate(decorators, target, key, desc) {
3
3
  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
4
4
  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -1,4 +1,4 @@
1
- //#region \0@oxc-project+runtime@0.150.0/helpers/esm/decorateMetadata.js
1
+ //#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorateMetadata.js
2
2
  function __decorateMetadata(k, v) {
3
3
  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
4
4
  }
package/dist/index.js CHANGED
@@ -4,8 +4,8 @@ import { defineRedisConfig, redisConfigJsonSchema } from "./nodefony/config/defi
4
4
  import { RedisTokenStore } from "./nodefony/src/RedisTokenStore.js";
5
5
  import { RedisWebAuthnCredentialStore } from "./nodefony/src/RedisWebAuthnCredentialStore.js";
6
6
  import { registerRedisFrameworkStores } from "./nodefony/registerStores.js";
7
- import __decorateMetadata from "./_virtual/_@oxc-project_runtime@0.150.0/helpers/esm/decorateMetadata.js";
8
- import __decorate from "./_virtual/_@oxc-project_runtime@0.150.0/helpers/esm/decorate.js";
7
+ import __decorateMetadata from "./_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/decorateMetadata.js";
8
+ import __decorate from "./_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/decorate.js";
9
9
  import RedisSessionStorage from "./nodefony/src/SessionStorage.js";
10
10
  import { Kernel, Module, services } from "nodefony";
11
11
  import * as redis from "redis";
@@ -19,9 +19,9 @@ import { getTokenStoreFactory, getWebAuthnStoreFactory, registerTokenStore, regi
19
19
  */
20
20
  /** Résout le service redis du container — échec FRANC avec la cause exacte. */
21
21
  function resolveRedisService(store, container) {
22
- const service = container?.get?.("redis") ?? null;
22
+ const service = container?.get("redis") ?? null;
23
23
  if (!service) throw new Error(`${store} : service "redis" introuvable — le module @nodefony/redis est-il chargé (manifeste "modules") ?`);
24
- const kernel = service.module?.kernel ?? null;
24
+ const kernel = service.module.kernel ?? null;
25
25
  if (kernel && !runNeedsExternalServices(kernel)) throw new Error(`${store} : demandé EXPLICITEMENT dans un run qui n'ouvre aucune connexion. Le store serait créé sans client Redis : ses écritures seraient perdues et ses lectures rendraient vide, SANS erreur. ${durableStoreRemedy(false)} Un store "auto" n'atteint jamais ce point — il bascule en mémoire, véridiquement et avec sa raison ; seule une demande EXPLICITE arrive ici.`);
26
26
  return service;
27
27
  }
@@ -31,11 +31,11 @@ function resolveRedisService(store, container) {
31
31
  */
32
32
  function registerRedisFrameworkStores() {
33
33
  if (!getTokenStoreFactory("redis")) registerTokenStore("redis", (ctx) => {
34
- const service = resolveRedisService(`tokenStore "redis"`, ctx?.container);
35
- const days = ctx?.config?.tokenStore?.retentionRevokedDays;
34
+ const service = resolveRedisService(`tokenStore "redis"`, ctx.container);
35
+ const days = ctx.config.tokenStore.retentionRevokedDays;
36
36
  return RedisTokenStore.from(service, void 0, typeof days === "number" ? days * 864e5 : void 0);
37
37
  });
38
- if (!getWebAuthnStoreFactory("redis")) registerWebAuthnStore("redis", (ctx) => RedisWebAuthnCredentialStore.from(resolveRedisService(`passkeys.store "redis"`, ctx?.container)));
38
+ if (!getWebAuthnStoreFactory("redis")) registerWebAuthnStore("redis", (ctx) => RedisWebAuthnCredentialStore.from(resolveRedisService(`passkeys.store "redis"`, ctx.container)));
39
39
  }
40
40
  //#endregion
41
41
  export { registerRedisFrameworkStores };
@@ -132,7 +132,7 @@ var RedisService = class extends Service {
132
132
  if (!definition) throw new Error(`${this.name} connection "${name}" undefined in config`);
133
133
  const options = buildClientOptions(config, definition);
134
134
  const conn = new Connection(name, options, this);
135
- if (this.#connections === null) this.#connections = Object.create(null);
135
+ this.#connections ??= Object.create(null);
136
136
  this.#connections[name] = conn;
137
137
  await conn.create();
138
138
  this.fire("connection", conn.client, conn);
@@ -171,7 +171,7 @@ var RedisService = class extends Service {
171
171
  }
172
172
  return client;
173
173
  }
174
- if (!this.#unavailable) this.#unavailable = /* @__PURE__ */ new Set();
174
+ this.#unavailable ??= /* @__PURE__ */ new Set();
175
175
  if (!this.#unavailable.has(name)) {
176
176
  this.#unavailable.add(name);
177
177
  this.log(`connexion "${name}" indisponible (${client ? "socket fermé" : "jamais ouverte"}) — les consommateurs de cette connexion dégradent tant qu'elle ne revient pas`, "WARNING");
@@ -181,8 +181,8 @@ var RedisService = class extends Service {
181
181
  /** Ferme toutes les connexions ouvertes (idempotent). */
182
182
  async closeConnections() {
183
183
  if (!this.#connections) return;
184
- for (const name in this.#connections) try {
185
- await this.#connections[name].close();
184
+ for (const connection of Object.values(this.#connections)) try {
185
+ await connection.close();
186
186
  } catch (e) {
187
187
  this.log(e, "ERROR");
188
188
  }
@@ -12,6 +12,18 @@ const KEY_BASE = "nf:tok";
12
12
  /** Fenêtre par défaut de conservation d'un PAT révoqué sans expiration (30 j). */
13
13
  const DEFAULT_RETENTION_REVOKED_MS = 2592e6;
14
14
  /**
15
+ * Pose un seuil **monotone** en UNE instruction côté serveur : `GET` puis `SET`
16
+ * séparés par un aller-retour laissaient deux révocations simultanées lire le
17
+ * même état et écrire toutes les deux — le seuil le plus ANCIEN pouvait rester,
18
+ * et des jetons révoqués redevenaient valides. Le script garde la clé en chaîne
19
+ * (aucune migration des données existantes, contrairement à un `ZADD GT`).
20
+ */
21
+ const MONOTONIC_SET_SCRIPT = `local c = redis.call('GET', KEYS[1])
22
+ if (not c) or (tonumber(ARGV[1]) > tonumber(c)) then
23
+ redis.call('SET', KEYS[1], ARGV[1])
24
+ end
25
+ return 1`;
26
+ /**
15
27
  * Store de jetons **Redis** (node-redis v6) — implémentation d'{@link ITokenStore}
16
28
  * pour le cluster (source unique cross-pod, denylist hot).
17
29
  *
@@ -71,7 +83,7 @@ var RedisTokenStore = class RedisTokenStore {
71
83
  }
72
84
  /** Préfixe effectif des clés, cloisonné par application (mémoïsé). */
73
85
  #prefix() {
74
- if (this.#prefixCache === null) this.#prefixCache = this.#resolvePrefix();
86
+ this.#prefixCache ??= this.#resolvePrefix();
75
87
  return this.#prefixCache;
76
88
  }
77
89
  #client() {
@@ -104,7 +116,7 @@ var RedisTokenStore = class RedisTokenStore {
104
116
  #encode(record) {
105
117
  const h = {};
106
118
  const put = (k, v) => {
107
- if (v !== null && v !== void 0) h[k] = String(v);
119
+ if (v !== null) h[k] = String(v);
108
120
  };
109
121
  put("id", record.id);
110
122
  put("kind", record.kind);
@@ -134,21 +146,22 @@ var RedisTokenStore = class RedisTokenStore {
134
146
  }
135
147
  /** Désérialise un HASH en record (`null` pour les champs absents). */
136
148
  #decode(h) {
137
- const str = (k) => k in h ? h[k] : null;
149
+ const str = (k) => h[k] ?? null;
138
150
  const num = (k) => k in h ? Number(h[k]) : null;
151
+ const req = (k) => h[k] ?? "";
139
152
  return {
140
- id: h.id,
153
+ id: req("id"),
141
154
  kind: h.kind,
142
- name: h.name,
155
+ name: req("name"),
143
156
  prefix: str("prefix"),
144
- subjectId: h.subjectId,
157
+ subjectId: req("subjectId"),
145
158
  subjectType: h.subjectType,
146
159
  tenantId: str("tenantId"),
147
160
  scopes: h.scopes ? JSON.parse(h.scopes) : [],
148
161
  audience: h.audience ? JSON.parse(h.audience) : [],
149
162
  resources: h.resources ? JSON.parse(h.resources) : null,
150
- secretHash: h.secretHash,
151
- hashAlg: h.hashAlg,
163
+ secretHash: req("secretHash"),
164
+ hashAlg: req("hashAlg"),
152
165
  clientId: str("clientId"),
153
166
  cnf: str("cnf"),
154
167
  family: str("family"),
@@ -167,9 +180,19 @@ var RedisTokenStore = class RedisTokenStore {
167
180
  const client = this.#client();
168
181
  if (!client) return;
169
182
  const recKey = this.#recKey(record.id);
183
+ const hashKey = this.#hashKey(record.secretHash);
184
+ const owner = await client.get(hashKey);
185
+ if (owner !== null && owner !== record.id && await client.exists(this.#recKey(owner)) === 1) throw new Error(`secretHash déjà porté par le jeton ${owner} : un secret ne désigne qu'un jeton`);
186
+ const previous = await client.hGetAll(recKey);
187
+ if (Object.keys(previous).length > 0) {
188
+ const old = this.#decode(previous);
189
+ if (old.secretHash !== record.secretHash) await client.del(this.#hashKey(old.secretHash));
190
+ if (old.subjectId !== record.subjectId) await client.sRem(this.#subjKey(old.subjectId), record.id);
191
+ if (old.family && old.family !== record.family) await client.sRem(this.#famKey(old.family), record.id);
192
+ }
170
193
  await client.del(recKey);
171
194
  await client.hSet(recKey, this.#encode(record));
172
- const ttl = this.#ttlSeconds(record.expiresAt);
195
+ const ttl = record.expiresAt === null && record.revokedAt !== null ? this.#ttlSeconds(record.revokedAt + this.#retentionRevokedMs) : this.#ttlSeconds(record.expiresAt);
173
196
  if (ttl !== void 0) {
174
197
  await client.expire(recKey, ttl);
175
198
  await client.set(this.#hashKey(record.secretHash), record.id, { EX: ttl });
@@ -231,7 +254,7 @@ var RedisTokenStore = class RedisTokenStore {
231
254
  MATCH: match,
232
255
  COUNT: 200
233
256
  });
234
- cursor = String(res.cursor);
257
+ cursor = res.cursor;
235
258
  for (const key of res.keys) {
236
259
  const h = await client.hGetAll(key);
237
260
  if (Object.keys(h).length > 0) out.push(this.#decode(h));
@@ -268,7 +291,7 @@ var RedisTokenStore = class RedisTokenStore {
268
291
  MATCH: `${this.#prefix()}:rec:*`,
269
292
  COUNT: limit
270
293
  });
271
- const next = String(res.cursor);
294
+ const next = res.cursor;
272
295
  const now = this.#now();
273
296
  const items = [];
274
297
  let consumed = 0;
@@ -365,9 +388,10 @@ var RedisTokenStore = class RedisTokenStore {
365
388
  async revokeAllForSubject(subjectId, invalidBefore) {
366
389
  const client = this.#client();
367
390
  if (!client) return;
368
- const key = this.#revsubKey(subjectId);
369
- const current = await client.get(key);
370
- if (current === null || invalidBefore > Number(current)) await client.set(key, String(invalidBefore));
391
+ await client.eval(MONOTONIC_SET_SCRIPT, {
392
+ keys: [this.#revsubKey(subjectId)],
393
+ arguments: [String(invalidBefore)]
394
+ });
371
395
  }
372
396
  async getInvalidBefore(subjectId) {
373
397
  const client = this.#client();
@@ -387,4 +411,4 @@ var RedisTokenStore = class RedisTokenStore {
387
411
  }
388
412
  };
389
413
  //#endregion
390
- export { RedisTokenStore };
414
+ export { MONOTONIC_SET_SCRIPT, RedisTokenStore };
@@ -58,7 +58,7 @@ var RedisWebAuthnCredentialStore = class RedisWebAuthnCredentialStore {
58
58
  }
59
59
  /** Préfixe effectif des clés, cloisonné par application (mémoïsé). */
60
60
  #prefix() {
61
- if (this.#prefixCache === null) this.#prefixCache = this.#resolvePrefix();
61
+ this.#prefixCache ??= this.#resolvePrefix();
62
62
  return this.#prefixCache;
63
63
  }
64
64
  #client() {
@@ -89,10 +89,11 @@ var RedisWebAuthnCredentialStore = class RedisWebAuthnCredentialStore {
89
89
  }
90
90
  /** Désérialise un HASH en credential (`lastUsedAt`/`nickname` absents → `null`/omis). */
91
91
  #decode(h) {
92
+ const req = (k) => h[k] ?? "";
92
93
  return {
93
- id: h.id,
94
- userId: h.userId,
95
- publicKey: h.publicKey,
94
+ id: req("id"),
95
+ userId: req("userId"),
96
+ publicKey: req("publicKey"),
96
97
  signCount: Number(h.signCount),
97
98
  transports: h.transports ? JSON.parse(h.transports) : [],
98
99
  backupEligible: h.backupEligible === "1",
@@ -194,7 +195,7 @@ var RedisWebAuthnCredentialStore = class RedisWebAuthnCredentialStore {
194
195
  MATCH: `${this.#prefix()}:cred:*`,
195
196
  COUNT: limit
196
197
  });
197
- const next = String(res.cursor);
198
+ const next = res.cursor;
198
199
  const items = [];
199
200
  let consumed = 0;
200
201
  for (const key of res.keys.slice(skip)) {
@@ -45,7 +45,7 @@ var RedisSessionStorage = class {
45
45
  * à la construction du storage).
46
46
  */
47
47
  #client() {
48
- if (!this.#service) this.#service = this.manager.get("redis") ?? null;
48
+ this.#service ??= this.manager.get("redis") ?? null;
49
49
  return this.#service?.getClient("main") ?? null;
50
50
  }
51
51
  /**
@@ -81,7 +81,10 @@ var RedisSessionStorage = class {
81
81
  updatedAt: now
82
82
  };
83
83
  const client = this.#client();
84
- if (client) await client.set(this.#key(id), JSON.stringify(payload), { EX: this.idleTimeoutS });
84
+ if (client) await client.set(this.#key(id), JSON.stringify(payload), { expiration: {
85
+ type: "EX",
86
+ value: this.idleTimeoutS
87
+ } });
85
88
  return payload;
86
89
  }
87
90
  async open() {
@@ -189,7 +192,7 @@ var RedisSessionStorage = class {
189
192
  MATCH: `${this.#prefix()}:*`,
190
193
  COUNT: limit
191
194
  });
192
- const next = String(res.cursor);
195
+ const next = res.cursor;
193
196
  const prefixLen = this.#prefix().length + 1;
194
197
  const items = [];
195
198
  let consumed = 0;
@@ -50,11 +50,11 @@ function buildClientOptions(config, connection) {
50
50
  ...connection.socket
51
51
  };
52
52
  options.socket = {
53
- host: socket.host,
54
- port: socket.port,
55
- family: socket.family,
56
- connectTimeout: socket.connectTimeout,
57
- tls: socket.tls === true ? true : void 0,
53
+ ...socket.host !== void 0 && { host: socket.host },
54
+ ...socket.port !== void 0 && { port: socket.port },
55
+ ...socket.family !== void 0 && { family: socket.family },
56
+ ...socket.connectTimeout !== void 0 && { connectTimeout: socket.connectTimeout },
57
+ ...socket.tls && { tls: true },
58
58
  reconnectStrategy
59
59
  };
60
60
  return options;
@@ -27,7 +27,19 @@ export interface RedisClientLike {
27
27
  cursor: string;
28
28
  keys: string[];
29
29
  }>;
30
+ eval(script: string, options: {
31
+ keys: string[];
32
+ arguments: string[];
33
+ }): Promise<unknown>;
30
34
  }
35
+ /**
36
+ * Pose un seuil **monotone** en UNE instruction côté serveur : `GET` puis `SET`
37
+ * séparés par un aller-retour laissaient deux révocations simultanées lire le
38
+ * même état et écrire toutes les deux — le seuil le plus ANCIEN pouvait rester,
39
+ * et des jetons révoqués redevenaient valides. Le script garde la clé en chaîne
40
+ * (aucune migration des données existantes, contrairement à un `ZADD GT`).
41
+ */
42
+ export declare const MONOTONIC_SET_SCRIPT = "local c = redis.call('GET', KEYS[1])\nif (not c) or (tonumber(ARGV[1]) > tonumber(c)) then\n redis.call('SET', KEYS[1], ARGV[1])\nend\nreturn 1";
31
43
  /**
32
44
  * Store de jetons **Redis** (node-redis v6) — implémentation d'{@link ITokenStore}
33
45
  * pour le cluster (source unique cross-pod, denylist hot).
@@ -127,8 +127,8 @@ service par la chaîne `"redis"` dans le conteneur, jamais par un `import`. `Red
127
127
  `import type`, effacé à la compilation. Résultat, aucune dépendance runtime ne circule entre l'infra
128
128
  et la sécurité, dans aucun sens — et le graphe de modules reste acyclique.
129
129
 
130
- **Charger le module suffit.** `Redis.onKernelRegister()` (`index.ts:54`) valide la configuration puis
131
- appelle `registerRedisFrameworkStores()` (`registerStores.ts:46`), qui inscrit les fabriques `redis`
130
+ **Charger le module suffit.** `Redis.onKernelRegister()` (`index.ts:64`) valide la configuration puis
131
+ appelle `registerRedisFrameworkStores()` (`registerStores.ts:72`), qui inscrit les fabriques `redis`
132
132
  dans les registres de jetons et de passkeys. Le store de session, lui, s'auto-déclare à l'import du
133
133
  fichier (`SessionStorage.ts:323`). Aucune application n'a de câblage à écrire : il ne reste qu'à
134
134
  nommer le store — ou à laisser `auto` choisir.
@@ -278,7 +278,7 @@ Trois détails de ce schéma décident de tout le comportement en panne :
278
278
 
279
279
  1. `RedisService.init()` (`redis.ts:123`) enveloppe **chaque** connexion dans son propre `try/catch` :
280
280
  une connexion qui échoue est journalisée en `ERROR` et les suivantes sont quand même tentées.
281
- 2. `RedisService.createConnection()` (`redis.ts:146`) inscrit la connexion dans `#connections`
281
+ 2. `RedisService.createConnection()` (`redis.ts:175`) inscrit la connexion dans `#connections`
282
282
  **avant** d'attendre son ouverture (`redis.ts:75`).
283
283
  3. `Connection.create()` (`Connection.ts:86`) affecte `this.client` **avant** d'appeler `connect()`.
284
284
 
@@ -290,7 +290,7 @@ démarrage raté, la connexion existe, le client existe — mais il est fermé.
290
290
  Prenons une lecture de session. Elle traverse exactement quatre gestes :
291
291
 
292
292
  1. Le store résout le service **paresseusement**, au premier accès seulement :
293
- `RedisSessionStorage.#client()` (`SessionStorage.ts:96`) mémorise le service puis demande
293
+ `RedisSessionStorage.#client()` (`SessionStorage.ts:89`) mémorise le service puis demande
294
294
  `getClient("main")` à chaque appel. La résolution tardive est nécessaire — l'ordre de démarrage
295
295
  des modules n'est pas garanti, le store est construit avant que Redis soit prêt.
296
296
  2. `RedisService.getClient()` (`redis.ts:220`) rend le client de la connexion nommée, ou `null`.
@@ -335,12 +335,12 @@ vue d'ensemble ; les fiches détaillent les choix qui surprennent.
335
335
 
336
336
  ### `nf:sess:*` — la session, une chaîne et un TTL
337
337
 
338
- Une session est un blob JSON écrit d'un coup. `RedisSessionStorage.write()` (`SessionStorage.ts:123`)
338
+ Une session est un blob JSON écrit d'un coup. `RedisSessionStorage.write()` (`SessionStorage.ts:106`)
339
339
  pose **systématiquement** un `EX` : une clé de session sans TTL serait une session immortelle, donc un
340
340
  défaut de sécurité, pas une commodité.
341
341
 
342
342
  L'expiration par inactivité (« idle ») est donc portée par Redis lui-même. Deux conséquences
343
- directes : `gc()` (`SessionStorage.ts:168`) est un **no-op** assumé — aucun balayage, aucune requête
343
+ directes : `gc()` (`SessionStorage.ts:151`) est un **no-op** assumé — aucun balayage, aucune requête
344
344
  de purge périodique — et `touch()` (`SessionStorage.ts:166`) se réduit à un `EXPIRE`, en O(1), **sans
345
345
  réécrire la valeur**. C'est le renouvellement le moins coûteux de tous les backends de session.
346
346
 
@@ -351,22 +351,22 @@ survivre dans Redis jusqu'à la fin de son TTL d'inactivité, mais elle est refu
351
351
  ### `nf:tok:*` — les jetons, un HASH et quatre index
352
352
 
353
353
  Pourquoi un HASH plutôt qu'un blob JSON comme la session ? Parce qu'un jeton est **mis à jour en
354
- place** à chaque usage. `RedisTokenStore.markUsed()` (`RedisTokenStore.ts:436`) écrit un à trois
354
+ place** à chaque usage. `RedisTokenStore.markUsed()` (`RedisTokenStore.ts:487`) écrit un à trois
355
355
  champs (`lastUsedAt`, IP, agent) sans relire l'enregistrement, sans le réécrire, et **sans toucher au
356
356
  TTL**. Avec un blob, chaque appel d'API coûterait une lecture, une désérialisation, une réécriture —
357
357
  et remettrait en jeu la date d'expiration.
358
358
 
359
359
  Ce choix impose une précaution : `HSET` sur une clé absente la **recrée**, et une clé recréée n'a pas
360
- de TTL. Le store vérifie donc l'existence d'abord (`RedisTokenStore.ts:254`) et ne fait rien si
360
+ de TTL. Le store vérifie donc l'existence d'abord (`RedisTokenStore.ts:494`) et ne fait rien si
361
361
  l'identifiant est inconnu. Sans ce test, un jeton expiré ressusciterait, immortel, à sa prochaine
362
362
  utilisation.
363
363
 
364
364
  Les quatre index secondaires sont des SET (`subj`, `fam`) et des chaînes (`hash`, `revsub`). Aucun
365
365
  n'a de TTL : ils sont nettoyés **paresseusement**, quand une lecture tombe sur un membre dont
366
- l'enregistrement a expiré — voir `RedisTokenStore.findBySubject()` (`RedisTokenStore.ts:294`) et
367
- `RedisTokenStore.findByHash()` (`RedisTokenStore.ts:276`).
366
+ l'enregistrement a expiré — voir `RedisTokenStore.findBySubject()` (`RedisTokenStore.ts:348`) et
367
+ `RedisTokenStore.findByHash()` (`RedisTokenStore.ts:330`).
368
368
 
369
- La révocation combine les deux régimes. `RedisTokenStore.#applyRevoke()` (`RedisTokenStore.ts:470`)
369
+ La révocation combine les deux régimes. `RedisTokenStore.#applyRevoke()` (`RedisTokenStore.ts:550`)
370
370
  pose la date et la raison, puis — si le jeton n'avait **pas** d'expiration (cas d'un PAT) — lui donne
371
371
  un TTL égal à la durée de rétention. Un jeton révoqué reste donc consultable un temps, puis disparaît
372
372
  tout seul.
@@ -378,7 +378,7 @@ d'ailleurs pas de méthode de maintenance. Deux structures suffisent : un HASH p
378
378
  SET d'identifiants par utilisateur.
379
379
 
380
380
  Un point de conception mérite d'être connu : `countByUser()`
381
- (`RedisWebAuthnCredentialStore.ts:203`) utilise `SCARD`, en O(1), sans lire un seul HASH. Il peut donc
381
+ (`RedisWebAuthnCredentialStore.ts:199`) utilise `SCARD`, en O(1), sans lire un seul HASH. Il peut donc
382
382
  **sur-compter** les membres orphelins qu'une lecture n'a pas encore nettoyés. L'écart est assumé et
383
383
  orienté **fail-closed** : au pire un enrôlement supplémentaire est refusé, jamais un de trop accepté.
384
384
 
@@ -450,7 +450,7 @@ muet ne l'est pas. Voici ce que le code fait réellement, moment par moment.
450
450
  ### Moment 1 — Redis est absent au démarrage
451
451
 
452
452
  Le module est déclaré non critique (`index.ts:36`), et l'initialisation du service est **bornée dans
453
- le temps** : `Kernel.guardInitialize()` (`Kernel.ts:3651`) enveloppe l'appel dans un délai maximal de
453
+ le temps** : `Kernel.guardInitialize()` (`Kernel.ts:4043`) enveloppe l'appel dans un délai maximal de
454
454
  démarrage. Un `init()` qui pend ne gèle donc pas le boot ; l'échec est agrégé au rapport de démarrage,
455
455
  qui fait dire « démarrage DÉGRADÉ » au superviseur au lieu de mentir sur un état sain.
456
456
 
@@ -485,10 +485,10 @@ Tous les stores commencent par le même geste : demander le client, et se replie
485
485
  garde ne se déclenche que dans deux situations exactes :
486
486
 
487
487
  - **avant** l'initialisation du service — la carte des connexions vaut encore `null` ;
488
- - **après** `RedisService.closeConnections()` (`redis.ts:247`), qui remet la carte à `null`.
488
+ - **après** `RedisService.closeConnections()` (`redis.ts:243`), qui remet la carte à `null`.
489
489
 
490
490
  Il ne se déclenche **pas** après un `connect()` raté. Puisque la connexion est inscrite dans
491
- `#connections` avant d'être ouverte (`redis.ts:114`) et que `Connection.create()` affecte son client
491
+ `#connections` avant d'être ouverte (`redis.ts:76`) et que `Connection.create()` affecte son client
492
492
  avant de le connecter (`Connection.ts:86`), `getClient("main")` rend alors un client **non nul et
493
493
  fermé**. La commande part donc, et la bibliothèque la rejette :
494
494
 
@@ -506,7 +506,7 @@ ClientClosedError: The client is closed
506
506
  ### Moment 4 — l'arrêt
507
507
 
508
508
  Le service s'abonne une fois pour toutes à la fin de vie du kernel dans son constructeur
509
- (`redis.ts:218`). `closeConnections()` (`redis.ts:218`) ferme chaque connexion, avale et journalise les
509
+ (`redis.ts:243`). `closeConnections()` (`redis.ts:243`) ferme chaque connexion, avale et journalise les
510
510
  échecs individuels, puis libère la carte. `Connection.close()` (`Connection.ts:146`) appelle la
511
511
  fermeture gracieuse du client — qui draine les commandes en vol — puis retire **explicitement** les
512
512
  cinq écouteurs via `Connection.#removeListeners()`, dans un bloc `finally` (`Connection.ts:122`).
@@ -528,7 +528,7 @@ L'ordre compte : les écouteurs sont retirés même si la fermeture échoue.
528
528
  | Idempotence : `redis` demandé, module absent | échec franc au démarrage | ✅ fail-loud |
529
529
 
530
530
  Les deux lignes rouges sont un **écart réel au principe** du framework : `RedisSessionStorage.write()`
531
- (`SessionStorage.ts:123`) rend la charge utile sans la persister et sans un mot. Sur la fenêtre
531
+ (`SessionStorage.ts:106`) rend la charge utile sans la persister et sans un mot. Sur la fenêtre
532
532
  étroite qu'il couvre — avant l'ouverture, après la fermeture — l'impact est faible ; le principe, lui,
533
533
  voudrait une trace. À l'inverse, `RedisSessionStorage.destroy()` (`SessionStorage.ts:143`) rend `true`
534
534
  sans connexion **délibérément** : l'appelant est une déconnexion, et lui répondre « échec » laisserait
@@ -594,9 +594,9 @@ erreur.
594
594
  ### Les vidages complets
595
595
 
596
596
  À côté de la pagination, deux méthodes déversent tout. `RedisSessionStorage.listAll()`
597
- (`SessionStorage.ts:198`) est **plafonnée** à un maximum de clés parcourues et journalise un
597
+ (`SessionStorage.ts:181`) est **plafonnée** à un maximum de clés parcourues et journalise un
598
598
  `WARNING` quand elle tronque — listing partiel signalé, jamais silencieux.
599
- `RedisTokenStore.listAll()` (`RedisTokenStore.ts:319`), en revanche, boucle jusqu'à la fin du
599
+ `RedisTokenStore.listAll()` (`RedisTokenStore.ts:378`), en revanche, boucle jusqu'à la fin du
600
600
  keyspace sans plafond : à grande échelle, préférez la pagination ou le système de référence SQL pour
601
601
  la gouvernance.
602
602
 
@@ -635,15 +635,15 @@ c'est la contrepartie assumée de la séparation imposée par le protocole.
635
635
 
636
636
  - **Écran Stores** (`/nodefony/stores`) : pour chaque brique, le store réellement retenu au démarrage
637
637
  **et la raison**. La résolution est enregistrée par `SessionsService.initializeStorage()`
638
- (`sessions-service.ts:231`), qui journalise aussi la décision au format « `auto` → `redis` (infra
639
- cache) ». Le choix automatique lui-même vient de `resolveAutoStore()` (`infra.ts:241`) : Redis n'est
638
+ (`sessions-service.ts:258`), qui journalise aussi la décision au format « `auto` → `redis` (infra
639
+ cache) ». Le choix automatique lui-même vient de `resolveAutoStore()` (`infra.ts:297`) : Redis n'est
640
640
  proposé que pour les natures non durables.
641
641
  - **Écran Sessions** : l'énumération y passe par `listPage` en mode curseur — d'où l'absence de
642
642
  compteur total et la navigation « page suivante » seule. C'est la capacité réduite décrite plus
643
643
  haut, rendue visible.
644
644
  - **Carte du module** (`/nodefony/modules/redis`) : documentation, symboles, tests, couverture, et la
645
645
  configuration validée. Le formulaire est dérivé du JSON Schema publié par `Redis.configSchema()`
646
- (`index.ts:43`), jamais écrit à la main.
646
+ (`index.ts:53`), jamais écrit à la main.
647
647
 
648
648
  Le module **n'expose pas** de plan de données propre (`/nodefony/redis/api/*`) : il n'a ni état
649
649
  métier ni introspection spécifique. Ce qui compte de lui — quelles connexions, quel store gagne — est
@@ -657,10 +657,10 @@ surfacé par les écrans transverses ci-dessus.
657
657
  | Le démarrage pend sans Redis | Tentatives illimitées : `connect()` ne rend pas la main | Fixer un maximum fini ; hors production c'est déjà fait (`defineModuleConfig.ts:65`) |
658
658
  | Deux applications se renvoient leurs messages temps réel | Le pub/sub ignore le numéro de base — cloisonnement inexistant | Poser un namespace de canal explicite (`RedisBackplane.ts:31`) |
659
659
  | Les mêmes messages sont diffusés deux fois localement | Anti-echo court-circuité (identifiant d'origine partagé) | Un identifiant d'origine distinct par pod (`RedisBackplane.ts:212`) |
660
- | Un jeton expiré « revient » et n'expire plus | `HSET` recrée une clé absente, sans TTL | Le test d'existence préalable (`RedisTokenStore.ts:254`) — ne pas le retirer |
661
- | `?cursor=…` fait échouer un listing de jetons | Curseur transmis sans validation (`RedisTokenStore.ts:35`) | Ne pas fabriquer de curseur à la main ; rejouer `nextCursor` tel quel |
660
+ | Un jeton expiré « revient » et n'expire plus | `HSET` recrée une clé absente, sans TTL | Le test d'existence préalable (`RedisTokenStore.ts:494`) — ne pas le retirer |
661
+ | `?cursor=…` fait échouer un listing de jetons | Curseur transmis sans validation (`RedisTokenStore.ts:46`) | Ne pas fabriquer de curseur à la main ; rejouer `nextCursor` tel quel |
662
662
  | L'écran d'administration n'affiche aucun total | `countSessions` / `countTokens` rendent `-1` (comptage O(N) refusé) | Afficher « inconnu » ; ne jamais inventer un total |
663
- | Un `offset` envoyé n'a aucun effet | Le mode curseur ne lit que `cursor` (`SessionStorage.ts:258`) | Paginer par curseur, pas par décalage |
663
+ | Un `offset` envoyé n'a aucun effet | Le mode curseur ne lit que `cursor` (`SessionStorage.ts:196`) | Paginer par curseur, pas par décalage |
664
664
  | Des passkeys disparaissent | Politique d'éviction Redis (`allkeys-lru`) sur des clés **sans** TTL | `noeviction` + persistance sur l'instance qui porte les passkeys |
665
665
  | Une session survit à son âge maximal côté Redis | Le TTL glissant n'exprime pas l'absolu (`SessionStorage.ts:168`) | Comportement voulu — l'âge est refusé à la lecture, pas dans le stockage |
666
666
  | Une surcharge de connexion écrase l'hôte global | Un schéma partiel qui réapplique ses défauts clobberait la valeur globale | Ne poser que les champs voulus dans la surcharge — voir [Configuration](./configuration.md) |
@@ -696,7 +696,7 @@ cette prose. Ce qui doit être dit ici, c'est **ce qui est prouvé, et par quoi*
696
696
  > **Une suite verte ne prouve rien sans serveur Redis.** Les bancs d'intégration se **skippent**
697
697
  > quand l'infra manque, et un skip compte comme un succès : on peut lire « tout est vert » sur une
698
698
  > suite qui n'a rien exercé. La gate du module est déclarée une seule fois — `REDIS_GATE` dans
699
- > `vitest.gates.ts:329` — et la fin de run nomme la cible non exercée avec la commande exacte pour la
699
+ > `vitest.gates.ts:339` — et la fin de run nomme la cible non exercée avec la commande exacte pour la
700
700
  > satisfaire. **Les variables et la commande docker se lisent là, pas ici** : les recopier dans cette
701
701
  > page les condamnerait à diverger.
702
702
 
@@ -125,7 +125,7 @@ options ». Il possède **un schéma Zod commenté**, et tout en dérive :
125
125
  pendant d'entrée `IRedisConfigInput` (`IRedisConfig.ts:17`), où tout champ portant un défaut devient
126
126
  optionnel.
127
127
  - **Le texte d'aide** vit dans les `.describe()` du schéma, ce qui permet à
128
- `redisConfigJsonSchema()` (`defineModuleConfig.ts:110`) de publier un JSON Schema **documenté** que
128
+ `redisConfigJsonSchema()` (`defineModuleConfig.ts:121`) de publier un JSON Schema **documenté** que
129
129
  Studio transforme en formulaire.
130
130
  - **Les champs sensibles se déclarent** : `url` et `password` portent un `.meta({ secret: true })`
131
131
  (`config.ts:187`), ce qui les fait masquer là où la configuration est affichée.
@@ -331,7 +331,7 @@ historiques (`nf:sess`, `nf:tok`, `nf:wac`) sont conservés tels quels.
331
331
  | ---------- | --------------- | ------------------------- | --------------------------------------------------------------------------------------------------------- |
332
332
  | `socket` | objet | défauts de `socketSchema` | Les options TCP/TLS communes. |
333
333
  | `username` | chaîne | _absent_ | Utilisateur ACL (Redis 6+). Absent avec un `password` présent = authentification héritée `requirepass`. |
334
- | `password` | chaîne (secret) | _absent_ | Mot de passe. Marqué secret dans `globalOptionsSchema` (`config.ts:187`) → masqué là où il s'afficherait. |
334
+ | `password` | chaîne (secret) | _absent_ | Mot de passe. Marqué secret dans `globalOptionsSchema` (`config.ts:173`) → masqué là où il s'afficherait. |
335
335
 
336
336
  `username` n'a **pas** de variable d'environnement dédiée : sur un serveur à ACL, il se pose dans la
337
337
  configuration de l'application (il n'est pas secret par lui-même), ou dans l'URL.
@@ -460,7 +460,7 @@ jamais où les sessions ont atterri. Le comparatif transverse vit dans
460
460
  ### Quand une URL est posée, ce qui devient sans effet
461
461
 
462
462
  Dès que `url` est renseignée — par l'application ou par l'environnement — `buildClientOptions()`
463
- (`buildClientOptions.ts:68`) **ne pose plus** `socket.host` ni `socket.port` : ils entreraient en
463
+ (`buildClientOptions.ts:45`) **ne pose plus** `socket.host` ni `socket.port` : ils entreraient en
464
464
  conflit avec ceux de l'URL. Trois conséquences à connaître :
465
465
 
466
466
  <!-- prettier-ignore -->
@@ -495,7 +495,7 @@ définitivement.
495
495
  ouverture ne rend jamais la main tant que Redis ne répond pas ; la file d'attente hors ligne du client
496
496
  retient les commandes, et un démarrage sans serveur se transforme en attente infinie plutôt qu'en
497
497
  échec lisible. D'où `applyResilienceDefaults()` (`defineModuleConfig.ts:65`), qui borne les tentatives
498
- à `DEV_DEFAULT_MAX_RETRIES` (`defineModuleConfig.ts:45`) — cinq — quand, et seulement quand,
498
+ à `DEV_DEFAULT_MAX_RETRIES` (`defineModuleConfig.ts:52`) — cinq — quand, et seulement quand,
499
499
  l'application ne s'est pas prononcée.
500
500
 
501
501
  | `NODE_ENV` | L'application fixe `maxRetries` ? | Valeur effective |
@@ -534,7 +534,7 @@ abonné ne peut plus émettre de commandes normales. Une connexion unique rendra
534
534
  stockage mutuellement exclusifs.
535
535
 
536
536
  Ajouter une connexion se fait en nommant une nouvelle clé. La fusion du manifeste est **profonde** —
537
- `loadModulesFromManifest()` (`Kernel.ts:1492`) fusionne la configuration de `use()` sous les défauts
537
+ `loadModulesFromManifest()` (`Kernel.ts:1714`) fusionne la configuration de `use()` sous les défauts
538
538
  déjà matérialisés du module — donc les trois connexions d'usine restent en place :
539
539
 
540
540
  ```ts ignore
@@ -611,7 +611,7 @@ Aucune ligne dans `nodefony.config.ts`. Le mot de passe voyage dans l'URL : trai
611
611
  secret entier, jamais comme une adresse.
612
612
 
613
613
  **La limite de forme à connaître** : le schéma n'expose qu'un **booléen** `tls`
614
- (`socketSchema` (`config.ts:114`)). Autorité de certification privée, certificat client, nom de
614
+ (`socketSchema` (`config.ts:79`)). Autorité de certification privée, certificat client, nom de
615
615
  serveur explicite — rien de tout cela n'est exprimable. Un service managé à certificat public
616
616
  fonctionne ; une authentification mutuelle par certificat n'est pas couverte par la configuration du
617
617
  module.
@@ -671,18 +671,18 @@ Mieux vaut le savoir en concevant l'infrastructure qu'en la déployant.
671
671
  Deux échecs très différents partagent le même symptôme apparent — « Redis ne marche pas » — et se
672
672
  règlent à des endroits opposés.
673
673
 
674
- **La configuration est invalide.** `Redis.onKernelRegister()` (`index.ts:54`) valide avant tout le
674
+ **La configuration est invalide.** `Redis.onKernelRegister()` (`index.ts:64`) valide avant tout le
675
675
  reste et refuse de démarrer sur une valeur hors bornes. Le message nomme le champ fautif
676
676
  (`index.ts:68`) :
677
677
 
678
678
  ```
679
- [@nodefony/redis] Invalid config: globalOptions.socket.port: Too big: expected number to be <=65535
679
+ [@nodefony/redis] configuration invalide — globalOptions.socket.port : Too big: expected number to be <=65535
680
680
  ```
681
681
 
682
682
  C'est un défaut de configuration : rien à chercher côté réseau.
683
683
 
684
684
  **Le serveur ne répond pas.** La configuration est bonne, l'ouverture échoue. Le module est déclaré
685
- **non critique** — `Redis.critical` (`index.ts:36`) vaut `false` — donc l'application démarre quand
685
+ **non critique** — `Redis.critical` (`index.ts:46`) vaut `false` — donc l'application démarre quand
686
686
  même, en état dégradé annoncé. Chaque connexion est tentée indépendamment et journalisée en `ERROR`
687
687
  par `RedisService.init()` (`redis.ts:123`) : une connexion en échec n'empêche pas les suivantes.
688
688
 
@@ -697,12 +697,12 @@ faire avant une mise en production.
697
697
  | Symptôme | Cause | Correction |
698
698
  | --- | --- | --- |
699
699
  | Une clé de configuration n'a aucun effet, aucune erreur | Clé inconnue du schéma : la validation Zod **écarte** les clés qu'elle ne connaît pas | Vérifier l'orthographe dans les tables ci-dessus ; contrôler la cible effective (§ Démarrage rapide) |
700
- | L'hôte configuré est ignoré | Une `url` est présente — `buildClientOptions()` (`buildClientOptions.ts:68`) ne pose plus host/port | Retirer `NF_REDIS_URL`/`REDIS_URL`, ou tout mettre dans l'URL |
701
- | `NF_REDIS_PORT` semble sans effet | Valeur non entière ou hors `1..65535` : `applyEnvOverrides()` (`defineModuleConfig.ts:32`) l'ignore | Corriger la valeur — l'ignorance est silencieuse par conception |
700
+ | L'hôte configuré est ignoré | Une `url` est présente — `buildClientOptions()` (`buildClientOptions.ts:45`) ne pose plus host/port | Retirer `NF_REDIS_URL`/`REDIS_URL`, ou tout mettre dans l'URL |
701
+ | `NF_REDIS_PORT` semble sans effet | Valeur non entière ou hors `1..65535` : `applyEnvOverrides()` (`defineModuleConfig.ts:24`) l'ignore | Corriger la valeur — l'ignorance est silencieuse par conception |
702
702
  | Toutes les connexions atterrissent sur la même base | L'URL porte un chemin (`…/2`) qui écrase le `database` de chaque connexion | Déclarer l'URL sans chemin et laisser `database` cloisonner |
703
703
  | Le démarrage pend, sans erreur, sans Redis | Tentatives illimitées : la première ouverture ne rend pas la main | Hors production c'est déjà borné (`applyResilienceDefaults()` (`defineModuleConfig.ts:65`)) ; sinon fixer une valeur finie |
704
704
  | Erreur `NOAUTH` alors que le mot de passe est configuré | L'URL porte des identifiants qui recouvrent `NF_REDIS_PASSWORD` | Ne pas mélanger : l'URL **ou** hôte + mot de passe |
705
- | Les sessions ont changé de magasin sans qu'on touche à la configuration | `NF_REDIS_URL` déclare une infra de cache → `resolveAutoStore()` (`infra.ts:241`) bascule les briques `auto` | Nommer le store explicitement pour un comportement identique partout |
705
+ | Les sessions ont changé de magasin sans qu'on touche à la configuration | `NF_REDIS_URL` déclare une infra de cache → `resolveAutoStore()` (`infra.ts:297`) bascule les briques `auto` | Nommer le store explicitement pour un comportement identique partout |
706
706
  | Une surcharge de connexion ramène le port à `6379` | Un schéma partiel qui réappliquerait ses défauts — d'où `socketOverrideSchema` (`config.ts:133`) sans défaut | Ne poser que les champs voulus ; les autres héritent du socket global |
707
707
  | Le module démarre mais n'ouvre rien | `enabled: false` — module chargé, inerte (`RedisService.init()` (`redis.ts:123`)) | Le réactiver, ou retirer le module du manifeste |
708
708
  | Le formulaire Studio annonce `maxRetries: 0` en développement | Le JSON Schema décrit le schéma, pas la superposition d'exécution | Lire la configuration effective du service |
@@ -712,7 +712,7 @@ faire avant une mise en production.
712
712
  ## 📡 Observabilité — Studio
713
713
 
714
714
  - **Carte du module** (`/nodefony/modules/redis`) : la configuration validée, rendue par un formulaire
715
- **dérivé** du JSON Schema que publie `Redis.configSchema()` (`index.ts:43`). Les champs marqués
715
+ **dérivé** du JSON Schema que publie `Redis.configSchema()` (`index.ts:53`). Les champs marqués
716
716
  secrets — `url`, `password` — y sont masqués par construction, pas par une liste d'exclusion tenue
717
717
  à la main.
718
718
  - **Écran Stores** (`/nodefony/stores`) : pour chaque brique, le store réellement retenu au démarrage
@@ -749,7 +749,7 @@ rester pur.
749
749
  > **Une suite verte ne prouve rien du reste sans serveur Redis.** Les bancs d'intégration se
750
750
  > **skippent** quand l'infra manque, et un skip compte comme un succès : on peut lire « tout est
751
751
  > vert » sur une suite qui n'a rien exercé. La gate du module est déclarée une seule fois —
752
- > `REDIS_GATE` (`vitest.gates.ts:329`) — et la fin de run nomme la cible non exercée avec la commande
752
+ > `REDIS_GATE` (`vitest.gates.ts:339`) — et la fin de run nomme la cible non exercée avec la commande
753
753
  > exacte pour la satisfaire. **Les variables et la commande docker se lisent là, pas ici** : les
754
754
  > recopier dans cette page les condamnerait à diverger.
755
755
 
package/docs/index.md CHANGED
@@ -273,7 +273,7 @@ chose**.
273
273
  > [!IMPORTANT]
274
274
  > **Une suite verte ne prouve rien sans serveur Redis.** Les bancs d'intégration se **skippent** quand
275
275
  > l'infra manque, et un skip compte comme un succès : on peut lire « tout est vert » sur une suite qui
276
- > n'a rien exercé. Le module déclare donc sa gate — `REDIS_GATE` dans `vitest.gates.ts:329` — et la
276
+ > n'a rien exercé. Le module déclare donc sa gate — `REDIS_GATE` dans `vitest.gates.ts:339` — et la
277
277
  > fin de run nomme la cible non testée avec la commande exacte pour la satisfaire. **Lis ce bloc avant
278
278
  > de conclure.** Les variables et la commande docker viennent de là, pas de cette page : les recopier
279
279
  > ici les condamnerait à diverger.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@nodefony/redis",
3
- "version": "10.0.0-alpha.8",
3
+ "version": "10.0.0-beta.1",
4
4
  "description": "Connecteur Redis de Nodefony : dépôts clé-valeur, cache, sessions partagées et transport de diffusion entre instances",
5
5
  "nodefony": {
6
6
  "storeKind": "cache",
@@ -24,8 +24,8 @@
24
24
  },
25
25
  "scripts": {
26
26
  "start": "node dist/index.js",
27
- "build": "rimraf dist && rolldown -c rolldown.config.ts && tsgo -p tsconfig.declarations.json",
28
- "clean": "rimraf dist",
27
+ "build": "rolldown -c rolldown.config.ts && tsgo -p tsconfig.declarations.json",
28
+ "clean": "node --eval \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
29
29
  "dev": "rolldown -c rolldown.config.ts --watch",
30
30
  "test": "vitest run",
31
31
  "test:watch": "vitest",
@@ -51,20 +51,19 @@
51
51
  "tslib": "2.8.1"
52
52
  },
53
53
  "devDependencies": {
54
- "@nodefony/framework": "^10.0.0-alpha.8",
55
- "@nodefony/http": "^10.0.0-alpha.8",
56
- "@nodefony/security": "^10.0.0-alpha.8",
57
- "@types/node": "26.6.2",
58
- "@vitest/coverage-v8": "5.0.1",
59
- "nodefony": "^10.0.0-alpha.8",
60
- "rimraf": "6.1.3",
61
- "vitest": "5.0.1"
54
+ "@nodefony/framework": "^10.0.0-beta.1",
55
+ "@nodefony/http": "^10.0.0-beta.1",
56
+ "@nodefony/security": "^10.0.0-beta.1",
57
+ "@types/node": "26.6.3",
58
+ "@vitest/coverage-v8": "5.0.2",
59
+ "nodefony": "^10.0.0-beta.1",
60
+ "vitest": "5.0.2"
62
61
  },
63
62
  "peerDependencies": {
64
- "@nodefony/framework": "^10.0.0-alpha.8",
65
- "@nodefony/http": "^10.0.0-alpha.8",
66
- "@nodefony/security": "^10.0.0-alpha.8",
67
- "nodefony": "^10.0.0-alpha.8",
63
+ "@nodefony/framework": "^10.0.0-beta.1",
64
+ "@nodefony/http": "^10.0.0-beta.1",
65
+ "@nodefony/security": "^10.0.0-beta.1",
66
+ "nodefony": "^10.0.0-beta.1",
68
67
  "zod": "^4.6.5"
69
68
  },
70
69
  "repository": {