@nodefony/security 10.0.0-alpha.1

package/dist/nodefony/errors/InvalidTargetError.js

@@ -0,0 +1,39 @@
+import { nodefonyError } from "nodefony";
+//#region nodefony/errors/InvalidTargetError.ts
+/**
+* La ressource demandée à l'émission ne peut pas être servie — `code = 400`,
+* code d'erreur OAuth `invalid_target` (RFC 8707 §2).
+*
+* Le paramètre `resource` dit POUR QUI le jeton est demandé. Trois raisons de
+* refuser, et la RFC les couvre d'un seul code : « The requested resource is
+* invalid, missing, unknown, or malformed. »
+*
+* **Pourquoi refuser plutôt qu'ignorer.** Un `resource` accepté puis jeté rend
+* un jeton parfaitement valide… pour quelqu'un d'autre. Le client croit tenir
+* une clé pour la porte A, la présente, reçoit un `401`, et n'a aucun moyen de
+* comprendre que sa demande n'a jamais été honorée : l'erreur se manifeste chez
+* la ressource, loin de l'endroit où elle a été commise. Refuser à l'émission
+* met le diagnostic là où la faute est.
+*
+* **Le message est constant** et ne nomme pas les audiences acceptées : les
+* énumérer offrirait la carte des ressources protégées de l'application à qui
+* possède un simple identifiant. La valeur refusée, elle, vient du client — la
+* lui rendre ne lui apprend rien.
+*/
+var InvalidTargetError = class extends nodefonyError {
+	/** Code d'erreur OAuth à rendre au client (RFC 6749 §5.2 / RFC 8707 §2). */
+	oauthError = "invalid_target";
+	/** Ce que le client a demandé, tel qu'il l'a écrit — pour le journal. */
+	requested;
+	/**
+	* @param description - raison, destinée à `error_description` (aucune fuite :
+	*          elle qualifie la DEMANDE, jamais la configuration du serveur)
+	* @param requested - la valeur refusée, pour le journal
+	*/
+	constructor(description, requested) {
+		super(description, 400);
+		this.requested = requested;
+	}
+};
+//#endregion
+export { InvalidTargetError, InvalidTargetError as default };

package/dist/nodefony/errors/SsrfError.js

@@ -0,0 +1,17 @@
+import { nodefonyError } from "nodefony";
+//#region nodefony/errors/SsrfError.ts
+/**
+* URL rejetée par la protection SSRF — `code = 422`. Levée quand une URL sortante
+* (endpoint webhook, fetch applicatif…) est syntaxiquement valide mais cible une
+* ressource **interdite** : protocole non autorisé, identifiants embarqués, hôte
+* non résolvable, ou IP non publique (loopback, privée, link-local, métadonnées
+* cloud `169.254.169.254`…). Sémantique alignée sur GitHub (422 à l'enregistrement
+* d'un webhook invalide).
+*/
+var SsrfError = class extends nodefonyError {
+	constructor(message = "URL sortante interdite (SSRF)") {
+		super(message, 422);
+	}
+};
+//#endregion
+export { SsrfError, SsrfError as default };

package/dist/nodefony/errors/ThrottledError.js

@@ -0,0 +1,21 @@
+import { nodefonyError } from "nodefony";
+//#region nodefony/errors/ThrottledError.ts
+/**
+* Tentatives de login trop rapprochées — `code = 429` (RFC 6585 §4).
+*
+* Levée par `UserPasswordAuthenticator` quand le backoff progressif
+* ({@link LoginThrottler}) bloque encore l'identifiant saisi. Distincte du 401 :
+* un client légitime doit savoir QU'ATTENDRE (header `Retry-After`, posé par le
+* firewall), pas re-soumettre en boucle. Le message reste générique — la
+* politique de throttle (seuils, compteurs) n'est jamais détaillée au client.
+*/
+var ThrottledError = class extends nodefonyError {
+	/** Secondes restantes avant la prochaine tentative autorisée (header `Retry-After`). */
+	retryAfterS;
+	constructor(retryAfterS) {
+		super("Too many attempts", 429);
+		this.retryAfterS = retryAfterS;
+	}
+};
+//#endregion
+export { ThrottledError, ThrottledError as default };

package/dist/nodefony/errors/UnverifiableTokenError.js

@@ -0,0 +1,42 @@
+import { nodefonyError } from "nodefony";
+//#region nodefony/errors/UnverifiableTokenError.ts
+/**
+* Le jeton n'a pas pu être VÉRIFIÉ — `code = 503`, et surtout **pas 401**.
+*
+* Levée quand ce qui sait valider un jeton est absent ou en panne : aucun
+* vérificateur posé au conteneur, émetteur injoignable, jeu de clés
+* inutilisable. Le jeton n'est alors ni valide ni invalide — on n'en sait
+* rien, et c'est une information différente.
+*
+* **Pourquoi une erreur distincte.** Répondre 401 à une panne envoie le client
+* chercher un autre jeton, qui échouera pareil : la boucle de renouvellement
+* remplace la panne par une tempête de requêtes, pendant que le tableau de bord
+* affiche une hausse d'« échecs d'authentification » qui ne désigne aucun
+* coupable. Le 503 dit la vérité — le service ne peut pas répondre — et le
+* client légitime attend au lieu d'insister.
+*
+* C'est la même distinction que celle tenue par le vérificateur lui-même, où
+* un refus rend `null` et une panne lève : la porte doit la conserver jusqu'à
+* la réponse, sinon elle est perdue là où elle sert.
+*
+* Le message est **constant**, et c'est structurel : il est rendu au client. La
+* cause technique — nom de l'émetteur défaillant, URL du jeu de clés, erreur
+* réseau — vit dans {@link detail}, que seul le journal lit. Composer la cause
+* dans le message revient à publier la topologie interne de l'authentification
+* à qui présente un jeton quelconque, et le rendu d'erreur de développement y
+* ajoute la pile d'appels par-dessus.
+*/
+var UnverifiableTokenError = class extends nodefonyError {
+	/** Cause technique, destinée au JOURNAL — jamais au client. */
+	detail;
+	/**
+	* @param detail - cause technique pour le journal ; n'apparaît jamais dans le
+	*          message rendu au client
+	*/
+	constructor(detail) {
+		super("Token verification unavailable", 503);
+		this.detail = detail;
+	}
+};
+//#endregion
+export { UnverifiableTokenError, UnverifiableTokenError as default };

package/dist/nodefony/errors/WebAuthnError.js

@@ -0,0 +1,21 @@
+import { nodefonyError } from "nodefony";
+//#region nodefony/errors/WebAuthnError.ts
+/**
+* Erreur de **gestion** d'un credential WebAuthn (enrôlement) — porte un `code`
+* HTTP que l'adaptateur framework mappe par duck-typing (il n'importe jamais les
+* classes de `@nodefony/security`).
+*
+*  - `409` — plafond `passkeys.maxPerUser` atteint.
+*
+* Distincte de la **cérémonie** elle-même (défi/signature/origine invalides →
+* `AuthenticationError` 401, message uniforme anti-énumération) : ici la
+* cérémonie a réussi cryptographiquement, c'est la politique du serveur qui
+* refuse d'enregistrer un credential de plus.
+*/
+var WebAuthnError = class extends nodefonyError {
+	constructor(message, code) {
+		super(message, code);
+	}
+};
+//#endregion
+export { WebAuthnError, WebAuthnError as default };

package/dist/nodefony/errors/index.js

@@ -0,0 +1,9 @@
+import { CsrfError } from "./CsrfError.js";
+import { AuthenticationError } from "./AuthenticationError.js";
+import { ThrottledError } from "./ThrottledError.js";
+import { UnverifiableTokenError } from "./UnverifiableTokenError.js";
+import { InvalidTargetError } from "./InvalidTargetError.js";
+import { WebAuthnError } from "./WebAuthnError.js";
+import { SsrfError } from "./SsrfError.js";
+import { AccessDeniedError } from "./AccessDeniedError.js";
+export { AccessDeniedError, AuthenticationError, CsrfError, InvalidTargetError, SsrfError, ThrottledError, UnverifiableTokenError, WebAuthnError };

package/dist/nodefony/service/accessTokenVerifier.js

@@ -0,0 +1,77 @@
+import { defineSecurityConfig } from "../config/defineModuleConfig.js";
+import { RemoteJwtVerifier } from "../src/token/RemoteJwtVerifier.js";
+import { ACCESS_TOKEN_VERIFIER, Service, canonicalIssuer } from "nodefony";
+//#region nodefony/service/accessTokenVerifier.ts
+const serviceName = ACCESS_TOKEN_VERIFIER;
+/**
+* Pose (ou non) le vérificateur de jetons d'accès TIERS dans le conteneur.
+*
+* Ce service est une **décision de câblage**, pas de la cryptographie : toute la
+* mécanique vit dans {@link RemoteJwtVerifier}, et la doctrine de refus dans le
+* cœur (`nodefony/src/oauth/`). Ici, on lit la configuration et on tranche une
+* seule question — cette application accepte-t-elle des jetons émis ailleurs ?
+*
+* **Aucun émetteur déclaré = rien n'est posé**, et c'est le comportement voulu :
+* une porte protégée qui ne trouve pas de vérificateur refuse de servir en le
+* disant (503 + CRITIC), là où un vérificateur présent mais vide refuserait
+* chaque jeton un par un — même résultat pour l'appelant, diagnostic beaucoup
+* plus difficile pour l'exploitant.
+*
+* Le coût est nul quand la capacité n'est pas utilisée : rien n'est instancié,
+* aucune requête n'est faite au démarrage. La découverte des clés n'a lieu qu'au
+* PREMIER jeton réellement présenté, et une seule fois par émetteur.
+*/
+var AccessTokenVerifierService = class extends Service {
+	module;
+	#verifier = null;
+	constructor(module) {
+		super(serviceName, module.container, module.notificationsCenter, module.options);
+		this.module = module;
+		this.kernel?.once("onBoot", () => this.#build());
+	}
+	/** Le vérificateur, ou `null` si aucun émetteur n'est déclaré. */
+	get verifier() {
+		return this.#verifier;
+	}
+	#build() {
+		let config;
+		try {
+			config = defineSecurityConfig(this.options);
+		} catch {
+			return;
+		}
+		const { issuers, ...tuning } = config.resourceServer;
+		if (issuers.length === 0) {
+			this.log("aucun émetteur de confiance déclaré (security.resourceServer.issuers) — les jetons émis par un serveur d'autorisation tiers ne sont pas vérifiables ; une porte protégée refusera de servir.", "DEBUG");
+			return;
+		}
+		const localIssuer = config.jwt.issuer;
+		const armed = issuers.map((trusted) => localIssuer && canonicalIssuer(trusted.issuer) === canonicalIssuer(localIssuer) ? {
+			...trusted,
+			localJwks: async () => {
+				const keystore = this.container?.get("jwtKeystore");
+				if (!keystore) throw new Error(`l'émetteur « ${trusted.issuer} » est cette application, mais sa capacité JWT n'est pas armée (security.jwt) — aucune clé locale à présenter`);
+				return keystore.getPublicJWKS();
+			}
+		} : trusted);
+		try {
+			this.#verifier = new RemoteJwtVerifier({
+				issuers: armed,
+				timeoutMs: tuning.timeoutMs,
+				cooldownMs: tuning.cooldownMs,
+				cacheMaxAgeMs: tuning.cacheMaxAgeMs,
+				clockToleranceS: tuning.clockToleranceS,
+				log: (message) => this.log(message, "DEBUG")
+			});
+		} catch (error) {
+			this.log(`vérificateur de jetons non armé — ${error.message}`, "CRITIC");
+			return;
+		}
+		const verify = (token, audience) => this.#verifier.verify(token, audience);
+		this.container?.set(serviceName, verify);
+		const locaux = armed.filter((i) => "localJwks" in i).length;
+		this.log(`vérificateur de jetons armé — ${issuers.length} émetteur(s) de confiance : ` + issuers.map((i) => i.issuer).join(", ") + (locaux > 0 ? ` (dont ${locaux} servi par les clés LOCALES, sans requête)` : ""), "INFO");
+	}
+};
+//#endregion
+export { AccessTokenVerifierService, AccessTokenVerifierService as default };

package/dist/nodefony/service/apiKeys.js

@@ -0,0 +1,310 @@
+import { defineSecurityConfig } from "../config/defineModuleConfig.js";
+import { generateApiKey } from "../src/apikey/apiKeyFormat.js";
+import { recordAudit } from "../src/audit/recordAudit.js";
+import { TOKEN_FACETS } from "../src/token/tokenFilters.js";
+import { ApiKeyError } from "../errors/ApiKeyError.js";
+import { Service, countFacets } from "nodefony";
+import { randomUUID } from "node:crypto";
+//#region nodefony/service/apiKeys.ts
+const serviceName = "apiKeys";
+const MAX_NAME_LEN = 100;
+const MS_PER_DAY = 864e5;
+/**
+* Gestion des **clés API personnelles (PAT, P6.12)** — émission, listing et
+* révocation, au-dessus du `ITokenStore` **partagé** (posé au container par le
+* `TokenService`, qui en possède aussi le `gc`). Un PAT et un refresh token
+* cohabitent dans la même table (`kind`) ; ce service ne traite que `kind:"pat"`.
+*
+* **Sécurité** : le secret (256 bits aléatoires) n'est rendu en clair qu'à la
+* création (`IApiKeyCreated.token`, RFC « shown once ») ; seul son `sha256` est
+* persisté. Création/révocation s'appliquent **toujours à un porteur donné**
+* (jamais à autrui) — l'identité est résolue côté endpoint (session BFF). La
+* vérification d'une clé présentée vit, elle, dans `ApiKeyAuthenticator`.
+*
+* Le store est résolu **paresseusement** du container (`tokenStore`) au premier
+* usage : indépendant de l'ordre de boot des services.
+*/
+var ApiKeyService = class extends Service {
+	module;
+	#store = null;
+	#enabled = false;
+	#prefix = "nf";
+	#defaultExpiryDays = 90;
+	#maxPerSubject = 100;
+	#allowedScopes = null;
+	constructor(module) {
+		super(serviceName, module.container, module.notificationsCenter, module.options);
+		this.module = module;
+		this.kernel?.once("onBoot", () => this.#build());
+	}
+	#build() {
+		let config;
+		try {
+			config = defineSecurityConfig(this.options);
+		} catch {
+			return;
+		}
+		const ak = config.apiKeys;
+		if (!ak.enabled) {
+			this.log("api keys idle — désactivées en config", "DEBUG");
+			return;
+		}
+		this.#enabled = true;
+		this.#prefix = ak.prefix;
+		this.#defaultExpiryDays = ak.defaultExpiryDays;
+		this.#maxPerSubject = ak.maxPerSubject;
+		this.#allowedScopes = ak.allowedScopes;
+		this.log(`api keys ready — prefix "${ak.prefix}_", max ${ak.maxPerSubject}/porteur`, "DEBUG");
+	}
+	/** `true` si les clés API sont activées en config. */
+	isEnabled() {
+		return this.#enabled;
+	}
+	/**
+	* Champs de tri que le backend **actuellement branché** sait honorer, en
+	* vocabulaire public. Le data plane admin les passe en allowlist au traducteur
+	* de requête de page : hors de cette liste, un `?order=` est refusé en 400.
+	*
+	* La liste vient du store, jamais d'une constante recopiée ici : c'est ce qui
+	* fait qu'un backend à capacité réduite (Redis, dont le `SCAN` n'a pas d'ordre
+	* global) refuse le tri **sans qu'aucune règle supplémentaire ne soit écrite**.
+	* Store absent ou indisponible → aucune capacité annoncée, donc aucun tri promis.
+	*
+	* @returns les champs triables, ou un tableau vide.
+	*/
+	sortableFields() {
+		try {
+			return this.#resolveStore().sortableFields ?? [];
+		} catch {
+			return [];
+		}
+	}
+	/**
+	* Émet une nouvelle clé API pour un porteur — renvoie sa vue publique **+ le
+	* token en clair** (affiché une seule fois).
+	*
+	* @throws ApiKeyError 400 — nom vide/trop long, scope hors catalogue, expiry invalide.
+	* @throws ApiKeyError 409 — plafond `maxPerSubject` atteint.
+	* @throws ApiKeyError 503 — store indisponible.
+	*/
+	async createForSubject(subjectId, subjectType, opts) {
+		const store = this.#resolveStore();
+		const name = this.#normalizeName(opts.name);
+		const scopes = this.#normalizeScopes(opts.scopes);
+		const now = Date.now();
+		const expiresAt = this.#resolveExpiry(opts.expiresInDays, now);
+		if ((await store.findBySubject(subjectId)).filter((r) => r.kind === "pat" && this.#isActive(r, now)).length >= this.#maxPerSubject) throw new ApiKeyError(`API key limit reached (${this.#maxPerSubject})`, 409);
+		const generated = generateApiKey(this.#prefix);
+		const record = {
+			id: randomUUID(),
+			kind: "pat",
+			name,
+			prefix: generated.publicPrefix,
+			subjectId,
+			subjectType,
+			tenantId: opts.tenantId ?? null,
+			scopes,
+			audience: [],
+			resources: null,
+			secretHash: generated.secretHash,
+			hashAlg: "sha256",
+			clientId: null,
+			cnf: null,
+			family: null,
+			replacedBy: null,
+			createdAt: now,
+			expiresAt,
+			lastUsedAt: null,
+			lastUsedIp: null,
+			lastUsedUserAgent: null,
+			revokedAt: null,
+			revokedReason: null,
+			metadata: {}
+		};
+		await store.put(record);
+		this.log(`api key created — id=${record.id} subject=${subjectId} scopes=[${scopes.join(",")}]`, "INFO");
+		recordAudit(this.container, {
+			category: "token",
+			action: "apikey.created",
+			outcome: "success",
+			actor: subjectId,
+			resource: record.id,
+			metadata: {
+				scopes,
+				subjectType
+			}
+		});
+		return {
+			...this.#toView(record),
+			token: generated.token
+		};
+	}
+	/** Liste les clés (PAT) d'un porteur — vue publique, sans secret, récentes d'abord. */
+	async listForSubject(subjectId) {
+		return (await this.#resolveStore().findBySubject(subjectId)).filter((r) => r.kind === "pat").map((r) => this.#toView(r)).sort((a, b) => b.createdAt - a.createdAt);
+	}
+	/**
+	* Liste **paginée** des clés (PAT) du système, tous porteurs confondus — vue
+	* d'ADMINISTRATION (gouvernance / réponse à incident), publique et sans secret.
+	* Réservé au data plane admin (RBAC `ROLE_NODEFONY_ADMIN`) : l'identité du porteur
+	* (`subjectId`) est exposée pour la supervision.
+	*
+	* Pagination **native au store** (jamais un `listAll()` matérialisé en RAM) : `kind`
+	* est forcé à `"pat"` ; les autres filtres (`subjectId`/`revoked`) + la fenêtre
+	* (`limit`/`offset`/`cursor`) viennent de `query`. Tri `createdAt` DESC par défaut.
+	*
+	* @param query - filtres + fenêtre de page ({@link ITokenListQuery}, `kind` ignoré).
+	* @returns une page de vues publiques ({@link IApiKeyView}, sans secret).
+	*/
+	async listPagePat(query) {
+		const page = await this.#resolveStore().listPage({
+			...query,
+			kind: "pat"
+		});
+		return {
+			...page,
+			items: page.items.map((r) => this.#toView(r))
+		};
+	}
+	/**
+	* Les compteurs de tête de la console — posés sur la collection ENTIÈRE, pas
+	* sur la page affichée.
+	*
+	* Les trois états partitionnent, mais chacun est **compté** : une partition
+	* est une propriété du domaine d'aujourd'hui, pas une garantie du code, et un
+	* quatrième état la briserait en silence si l'un se déduisait des autres.
+	*
+	* `kind` reste forcé à `"pat"` comme pour la liste : ces cartes surplombent
+	* un tableau de clés d'API, pas de jetons de rafraîchissement.
+	*
+	* @param query - filtres à appliquer avant comptage (sans fenêtre).
+	*/
+	async countKeyFacets(query) {
+		const store = this.#resolveStore();
+		return countFacets(TOKEN_FACETS, (facet) => store.countTokens({
+			...query,
+			...facet,
+			kind: "pat"
+		}));
+	}
+	/**
+	* Révoque **n'importe quelle** clé (PAT) — action d'ADMINISTRATION (réponse à
+	* incident : clé compromise), SANS contrainte de porteur (≠ `revokeForSubject`).
+	* Audité avec l'acteur admin ET le porteur cible. Idempotent.
+	*
+	* @param id - identifiant public de la clé.
+	* @param actorId - identité de l'admin qui révoque (tracée pour l'audit).
+	* @returns la vue publique mise à jour, ou `null` si introuvable / pas un PAT.
+	*/
+	async revokeAnyPat(id, actorId) {
+		const store = this.#resolveStore();
+		const record = await store.findById(id);
+		if (!record || record.kind !== "pat") return null;
+		await store.revoke(id, "manual");
+		this.log(`api key revoked by admin — id=${id} actor=${actorId} subject=${record.subjectId}`, "INFO");
+		recordAudit(this.container, {
+			category: "token",
+			action: "apikey.revoked",
+			outcome: "success",
+			actor: actorId,
+			resource: id,
+			reason: "manual",
+			metadata: {
+				subject: record.subjectId,
+				viaAdmin: true
+			}
+		});
+		const updated = await store.findById(id);
+		return updated ? this.#toView(updated) : null;
+	}
+	/**
+	* Capacités/contraintes d'émission (plafond, scopes, préfixe, durée par défaut)
+	* — pour un formulaire de création honnête côté console. Aucune valeur sensible.
+	*/
+	describeCapabilities() {
+		return {
+			enabled: this.#enabled,
+			prefix: this.#prefix,
+			defaultExpiryDays: this.#defaultExpiryDays,
+			maxPerSubject: this.#maxPerSubject,
+			allowedScopes: this.#allowedScopes === null ? null : [...this.#allowedScopes]
+		};
+	}
+	/**
+	* Révoque une clé du porteur. **Anti-énumération** : une clé inexistante OU
+	* appartenant à autrui renvoie `false` (« introuvable pour ce porteur ») —
+	* jamais un 403 qui révélerait son existence. Idempotent (déjà révoquée → `true`).
+	*
+	* @returns `true` si la clé du porteur a été trouvée (et révoquée), sinon `false`.
+	*/
+	async revokeForSubject(subjectId, id) {
+		const store = this.#resolveStore();
+		const record = await store.findById(id);
+		if (!record || record.kind !== "pat" || record.subjectId !== subjectId) return false;
+		await store.revoke(id, "manual");
+		this.log(`api key revoked — id=${id} subject=${subjectId}`, "INFO");
+		recordAudit(this.container, {
+			category: "token",
+			action: "apikey.revoked",
+			outcome: "success",
+			actor: subjectId,
+			resource: id,
+			reason: "manual"
+		});
+		return true;
+	}
+	#resolveStore() {
+		if (this.#store === null) {
+			const store = this.get("tokenStore");
+			if (!store) throw new ApiKeyError("API key store unavailable", 503);
+			this.#store = store;
+		}
+		return this.#store;
+	}
+	#normalizeName(raw) {
+		if (typeof raw !== "string" || raw.trim().length === 0) throw new ApiKeyError("API key name is required", 400);
+		const name = raw.trim();
+		if (name.length > MAX_NAME_LEN) throw new ApiKeyError(`API key name too long (max ${MAX_NAME_LEN})`, 400);
+		return name;
+	}
+	#normalizeScopes(raw) {
+		if (raw === void 0 || raw === null) return [];
+		if (!Array.isArray(raw)) throw new ApiKeyError("scopes must be an array of strings", 400);
+		const scopes = [];
+		for (const entry of raw) {
+			if (typeof entry !== "string" || entry.trim().length === 0) throw new ApiKeyError("invalid scope", 400);
+			const scope = entry.trim();
+			if (this.#allowedScopes !== null && !this.#allowedScopes.includes(scope)) throw new ApiKeyError(`scope not allowed: ${scope}`, 400);
+			if (!scopes.includes(scope)) scopes.push(scope);
+		}
+		return scopes;
+	}
+	#resolveExpiry(expiresInDays, now) {
+		const days = expiresInDays === void 0 ? this.#defaultExpiryDays : expiresInDays;
+		if (days === null) return null;
+		if (typeof days !== "number" || !Number.isFinite(days) || days <= 0) throw new ApiKeyError("expiresInDays must be a positive number or null", 400);
+		return now + days * MS_PER_DAY;
+	}
+	#isActive(record, now) {
+		return record.revokedAt === null && (record.expiresAt === null || record.expiresAt > now);
+	}
+	#toView(record) {
+		return {
+			id: record.id,
+			prefix: record.prefix,
+			name: record.name,
+			scopes: [...record.scopes],
+			subjectId: record.subjectId,
+			subjectType: record.subjectType,
+			tenantId: record.tenantId,
+			createdAt: record.createdAt,
+			expiresAt: record.expiresAt,
+			lastUsedAt: record.lastUsedAt,
+			lastUsedIp: record.lastUsedIp,
+			lastUsedUserAgent: record.lastUsedUserAgent,
+			revokedAt: record.revokedAt
+		};
+	}
+};
+//#endregion
+export { ApiKeyService, ApiKeyService as default };