Référence d'API — @nodefony/redis

stable

Documentation › Référence d’API › @nodefony/redis

Générée depuis les déclarations de types publiées de @nodefony/redis 10.0.0-beta.5 : exactement ce que reçoit une application qui l’installe. Cette page n’existe dans aucun dépôt — pour la corriger, on corrige le TSDoc du code.

@nodefony/redis#

import { … } from "@nodefony/redis" — 14 symboles.

Classes (5)#

RedisService#

class RedisService extends Service

Service Redis Nodefony — orchestre N connexions nommées (par défaut main, publish, subscribe) à partir de la config validée par Zod.

• module: Module
• constructor(module: Module)
• log(pci: Pci, severity?: Severity, msgid?: Msgid, msg?: Message): import("nodefony").Pdu — Émet une entrée de log structurée — point d’entrée central pour TOUT log Nodefony.
• get connections(): Record<string, Connection> — Connexions ouvertes (vide si aucune).
• get keyNamespace(): string — Cloison des clés de CETTE application, résolue une fois.
• keyPrefix(base: string): string — Préfixe de clés d’un store, cloisonné par application.
• init(): Promise<this> — Ouvre toutes les connexions déclarées dans la config (si enabled).
• createConnection(name: string): Promise<Connection> — Crée et ouvre une connexion nommée.
• getConnection(name: string): Connection — Connexion par nom (ou undefined).
• getClient(name: string): RedisClientType | null — Client redis brut d’une connexion utilisable, ou null.
• closeConnections(): Promise<void> — Ferme toutes les connexions ouvertes (idempotent).
• generateId(): string

RedisSessionStorage#

class RedisSessionStorage implements ISessionStorage

Stockage de session Redis — branché sur la connexion main du RedisService. Implémente le contrat unifié ISessionStorage consommé par le SessionsService de @nodefony/http.

• manager: SessionsService
• idleTimeoutS: number — Idle timeout en secondes (= TTL Redis natif, glissant via write/touch).
• constructor(manager: SessionsService)
• read(id: string): Promise<ISerializedSession>
• start(id: string): Promise<ISerializedSession>
• write(id: string, data: ISerializedSession): Promise<ISerializedSession>
• open(): Promise<number>
• close(): boolean
• destroy(id: string): Promise<boolean>
• gc(): Promise<void> — Purge les sessions expirées sur les deux bornes NIST/OWASP : idle (inactivité depuis updatedAt) ET absolute (âge depuis createdAt, jamais prolongé).
• touch(id: string, idleSeconds?: number): Promise<void> — Prolonge l’idle d’une session (timeout glissant) en repositionnant le TTL natif (EXPIRE, O(1)) — SANS réécrire la valeur (touch NIST/OWASP).
• listAll(filter?: ISessionListFilter): Promise<ISessionRecord[]> — Énumération admin (capacité optionnelle d’ISessionStorage) par SCAN non-bloquant (MATCH <prefix>:*, curseur), filtrable par user.
• listPage(query: ISessionListQuery): Promise<IPage<ISessionRecord>> — {@inheritDoc ISessionStorage.listPage}
• countSessions(query?: Partial<ISessionListQuery>): Promise<number> — {@inheritDoc ISessionStorage.countSessions}
• countDistinctUsers(query?: Partial<ISessionListQuery>): Promise<number> — {@inheritDoc ISessionStorage.countDistinctUsers}

RedisTokenStore#

class RedisTokenStore implements ITokenStore

Store de jetons Redis (node-redis v6) — implémentation d’ITokenStore pour le cluster (source unique cross-pod, denylist hot).

• constructor(resolveClient: () => RedisClientLike | null, now?: () => number, retentionRevokedMs?: number, resolvePrefix?: () => string, notify?: (message: string) => void)
• static from(service: RedisService, now?: () => number, retentionRevokedMs?: number): RedisTokenStore — Construit le store depuis un RedisService (connexion main).
• put(record: IAccessTokenRecord): Promise<void> — Enregistre (ou remplace) un jeton persistant.
• findById(id: string): Promise<IAccessTokenRecord | null> — Recherche par identifiant (jti/id public).
• findByHash(secretHash: string): Promise<IAccessTokenRecord | null> — Recherche par hash de secret présenté.
• findBySubject(subjectId: string): Promise<IAccessTokenRecord[]> — Tous les jetons d’un porteur (console « mes jetons », révocation ciblée).
• listAll(): Promise<IAccessTokenRecord[]> — Tous les jetons (PAT + refresh) — vue d’administration cross-porteur.
• listPage(query: ITokenListQuery): Promise<IPage<IAccessTokenRecord>> — {@inheritDoc ITokenStore.listPage}
• countTokens(_query: ITokenListQuery): Promise<number> — {@inheritDoc ITokenStore.countTokens}
• markUsed(id: string, usage: ITokenUsage): Promise<void> — Met à jour lastUsedAt/IP/UA (no-op si l’id est inconnu).
• revoke(id: string, reason: TokenRevokeReason): Promise<void> — Révoque un jeton (pose revokedAt+revokedReason) — idempotent.
• revokeFamily(family: string, reason: TokenRevokeReason): Promise<void> — Révoque TOUTE la famille de rotation (détection de rejeu, RFC 9700).
• denyJti(jti: string, expiresAt: number): Promise<void> — Inscrit un jti d’access sur la denylist jusqu’à expiresAt (epoch ms) — révocation immédiate avant l’exp du JWT.
• isJtiDenied(jti: string): Promise<boolean> — true si le jti est denylisté et non encore expiré.
• revokeAllForSubject(subjectId: string, invalidBefore: number): Promise<void> — Pose le seuil invalidBefore (epoch ms) d’un porteur : tout access auto-porté dont iat < invalidBefore est rejeté.
• getInvalidBefore(subjectId: string): Promise<number | null> — Seuil invalidBefore d’un porteur (epoch ms) ou null si aucun.
• gc(): Promise<number> — No-op : Redis gère toute l’expiration par TTL natif (refresh par leur exp, PAT révoqués par la rétention posée au revoke, denylist par EX).

RedisWebAuthnCredentialStore#

class RedisWebAuthnCredentialStore implements IWebAuthnCredentialStore

Store de credentials WebAuthn Redis (node-redis v6) — implémentation d’IWebAuthnCredentialStore pour le cluster (source unique cross-pod, les passkeys survivent au redémarrage et sont partagées entre process).

• constructor(resolveClient: () => RedisClientLike | null, resolvePrefix?: () => string)
• static from(service: RedisService): RedisWebAuthnCredentialStore — Construit le store depuis un RedisService (connexion main).
• findById(credentialId: string): Promise<IWebAuthnCredential | null> — Credential par son id (base64url), ou null — résolution à l’authentification.
• findByUser(userId: string): Promise<IWebAuthnCredential[]> — Tous les credentials d’un utilisateur — pour allowCredentials (authentification ciblée) et l’UX « mes appareils ».
• countByUser(userId: string): Promise<number> — SCARD natif — O(1), aucune lecture de HASH (le plafond ne charge rien).
• save(credential: IWebAuthnCredential): Promise<void> — Persiste un nouveau credential (fin de la cérémonie d’enregistrement).
• update(credentialId: string, patch: WebAuthnAuthUpdate): Promise<void> — Met à jour l’état post-authentification (compteur, sauvegarde, UV, usage).
• delete(credentialId: string): Promise<void> — Révoque un credential (l’utilisateur retire un appareil).
• listPage(query: IWebAuthnListQuery): Promise<IPage<IWebAuthnCredentialSummary>> — {@inheritDoc IWebAuthnCredentialStore.listPage}
• countCredentials(_query: IWebAuthnListQuery): Promise<number> — {@inheritDoc IWebAuthnCredentialStore.countCredentials}

default#

class Redis extends Module<IRedisConfig>

• static critical: boolean — Module optionnel : un échec de son boot ne tue jamais le process (résilience Ph.3).
• constructor(kernel: Kernel)
• configSchema(): unknown — JSON Schema de la config redis → data plane admin (config riche Studio).
• onKernelRegister(): Promise<this> — Valide la config (défauts + module.options + surcharge env) au boot via defineRedisConfig, et l’expose au container sous redisConfig pour que le RedisService la consomme sans redupliquer la va …

Fonctions (3)#

defineRedisConfig#

function defineRedisConfig(config?: IRedisConfigInput): IRedisConfig

Builder type-safe de la configuration de @nodefony/redis.

redisConfigJsonSchema#

function redisConfigJsonSchema(): unknown

JSON Schema introspectable de la config Redis — destiné au formulaire d’édition Studio (futur) et à la documentation générée.

registerRedisFrameworkStores#

function registerRedisFrameworkStores(): void

Enregistre les fabriques de stores Redis dans les registres de @nodefony/security. Idempotent (guards) — rejouable sans effet.

Constantes (1)#

redisConfigSchema#

const redisConfigSchema: z.ZodObject<{ enabled: z.ZodDefault<z.ZodBoolean>; url: z.ZodOptional<z.ZodString>; globalOptions: z.ZodDefault<z.ZodObject<{ socket: z.ZodDefault<z.ZodObject<{ host: z.ZodDefault<z.ZodString>; port: z.ZodDefault<z.ZodNumber>; family: z.ZodDefault<z.ZodUnion<readonly [ z.ZodLiteral<0>, z.ZodLiteral<4>, z.ZodLiteral<6> ]>>; connectTimeout: z.ZodDefault<z.ZodNumber>; tls: z. …

Interfaces (1)#

RedisClientLike#

interface RedisClientLike

Sous-ensemble structural du client redis v6 utilisé par le store — permet de tester contre un double déterministe sans serveur (le vrai RedisClientType satisfait cette forme par ses méthodes camelCase v6).

• hSet(key: string, fields: Record<string, string>): Promise<number>
• hGetAll(key: string): Promise<Record<string, string>>
• hDel(key: string, field: string): Promise<number>
• get(key: string): Promise<string | null>
• set(key: string, value: string, options?: { EX?: number; }): Promise<unknown>
• del(key: string): Promise<number>
• exists(key: string): Promise<number>
• expire(key: string, seconds: number): Promise<unknown>
• sAdd(key: string, member: string): Promise<number>
• sRem(key: string, member: string): Promise<number>
• sMembers(key: string): Promise<string[]>
• scan(cursor: string, options?: { MATCH?: string; COUNT?: number; }): Promise<{ cursor: string; keys: string[]; }>
• eval(script: string, options: { keys: string[]; arguments: string[]; }): Promise<unknown>

Types (3)#

IRedisConfig#

type IRedisConfig = z.infer<typeof redisConfigSchema>

Configuration normalisée et gelée de @nodefony/redis (sortie du builder defineRedisConfig, lue par le RedisService).

IRedisConfigInput#

type IRedisConfigInput = z.input<typeof redisConfigSchema>

Entrée du builder defineRedisConfig — tous les champs portant un défaut sont optionnels (l’app ne fournit que ce qu’elle surcharge).

IRedisConnectionConfig#

type IRedisConnectionConfig = IRedisConfig["connections"][string]

Définition d’une connexion Redis nommée (sous-objet de connections).

Bibliothèques réexportées (1)#

redis#

La bibliothèque redis, réexportée telle quelle : sa documentation est la sienne.

← Toutes les références d’API