nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/Container.js

@@ -0,0 +1,367 @@
+import { extend, isPlainObject } from "./Tools.js";
+//#region src/Container.ts
+const ISDefined = function(ele) {
+	return ele !== null && ele !== void 0;
+};
+const parseParameterString = function(str, value) {
+	if (!this) throw new Error(`Bad call`);
+	const parts = str.split(".");
+	const currentPart = parts.shift();
+	if (currentPart !== void 0) {
+		if (parts.length === 0) {
+			if (value !== void 0) this[currentPart] = value;
+			return this[currentPart] ?? null;
+		}
+		if (this[currentPart] === void 0 || this[currentPart] === null) {
+			if (value !== void 0) this[currentPart] = {};
+			else return null;
+		}
+		if (typeof this[currentPart] !== "object") throw new Error(`Cannot create property '${parts[0]}' on ${typeof this[currentPart]} '${this[currentPart]}'`);
+		return parseParameterString.call(this[currentPart], parts.join("."), value);
+	}
+	return this;
+};
+let containerSeq = 0;
+/**
+* Dependency Injection container — registers services by name and exposes
+* them to the rest of the framework.
+*
+* Services are stored on a prototype-backed object (`protoService`) so they
+* are inherited by child scopes (see {@link Scope}). The container also
+* carries an arbitrary parameter tree (`parameters`) used for configuration.
+*
+* Conventional usage:
+* ```ts
+* const c = new Container();
+* c.set("logger", new LoggerService());
+* c.setParameters("kernel.environment", "development");
+* const logger = c.get<LoggerService>("logger");
+* ```
+*
+* See `src/nodefony/docs/container.md` for the high-level rationale and the
+* scope model used by the HTTP/WS request pipeline.
+*/
+var Container = class Container {
+	protoService;
+	services;
+	protoParameters;
+	parameters;
+	id;
+	scopes = null;
+	/**
+	* Create a new container. When an existing container is passed in, the
+	* new instance inherits its services (via prototype chaining) and clones
+	* its parameters — used by {@link Scope} to build short-lived containers
+	* that share base services but isolate per-request state.
+	*
+	* @param input - parent container to inherit services from
+	* @param deep - if `true`, parameters are deep-cloned via `structuredClone`
+	* (falls back to shallow copy if `structuredClone` throws on unsupported types)
+	* @param adoptedProtoService - @internal canal {@link Scope} : adopte le
+	* proto-services du PARENT au lieu d'allouer une closure locale morte
+	* (2 closures + 2 `Object.create` jetés par requête avant ce chemin)
+	* @param adoptedProtoParameters - @internal idem pour les paramètres
+	*/
+	constructor(input, deep = false, adoptedProtoService, adoptedProtoParameters) {
+		this.id = (++containerSeq).toString(36);
+		this.protoService = adoptedProtoService ?? function() {};
+		this.protoParameters = adoptedProtoParameters ?? function() {};
+		if (input && input instanceof Container) {
+			this.services = Object.create(input.protoService.prototype);
+			this.parameters = Object.create(input.protoParameters.prototype);
+			this.setServices(input.services ?? {});
+			if (deep) try {
+				this.setParametersBulk(structuredClone(input.parameters ?? {}));
+			} catch {
+				this.setParametersBulk(input.parameters ?? {});
+			}
+			else this.setParametersBulk(input.parameters ?? {});
+		} else {
+			this.services = Object.create(this.protoService.prototype);
+			this.parameters = Object.create(this.protoParameters.prototype);
+		}
+	}
+	setServices(services) {
+		for (const service in services) this.set(service, services[service]);
+	}
+	setParametersBulk(parameters) {
+		for (const parameter in parameters) this.setParameters(parameter, parameters[parameter]);
+	}
+	/**
+	* Emit a log entry through the registered `syslog` service. Falls back to
+	* `console.warn` when no syslog is set (early boot, isolated test).
+	*
+	* @param pci - log payload (string or structured PDU body)
+	* @param severity - syslog severity level
+	* @param msgid - message id; defaults to `"SERVICES CONTAINER"`
+	* @param msg - optional message detail
+	*/
+	log(pci, severity, msgid, msg) {
+		const syslog = this.get("syslog");
+		if (!syslog) {
+			console.warn(`[Container] no syslog registered —`, pci);
+			return;
+		}
+		if (!msgid) msgid = "SERVICES CONTAINER";
+		return syslog.log(pci, severity, msgid, msg);
+	}
+	/**
+	* Register a service under `name`. The service is stored both directly on
+	* the container and on its prototype, so child scopes can read it without
+	* an extra hop.
+	*
+	* @param name - service identifier (any non-empty string)
+	* @param object - the instance to register (no type constraint — services
+	* are not required to extend any base class)
+	* @throws Error if `name` is empty or the container has been cleaned
+	*/
+	set(name, object) {
+		if (this.services && name) {
+			this.protoService.prototype[name] = object;
+			this.services[name] = object;
+		} else throw new Error("Container bad argument name");
+	}
+	/**
+	* Resolve a service by name. Returns `null` if the service is unknown or
+	* the container has been cleaned — callers should narrow the result
+	* before use.
+	*
+	* @param name - service identifier
+	* @returns the service instance typed as `T`, or `null`
+	*/
+	get(name) {
+		if (this.services && name in this.services) return this.services[name];
+		return null;
+	}
+	/**
+	* Unregister a service and cascade the removal into every child scope.
+	*
+	* @param name - service identifier
+	* @returns `true` when a service was actually removed, `false` otherwise
+	*/
+	remove(name) {
+		if (!this.services) return false;
+		if (name in this.services) {
+			delete this.services[name];
+			if (name in this.protoService.prototype) delete this.protoService.prototype[name];
+			if (this.scopes) for (const bucket of this.scopes.values()) for (const scope of bucket.values()) scope.remove(name);
+			return true;
+		}
+		return false;
+	}
+	/** Whether a service is registered under `name`. */
+	has(name) {
+		return this.services != null && name in this.services;
+	}
+	/** All service names currently registered on this container. */
+	keys() {
+		return Object.keys(this.services ?? {});
+	}
+	/** All `[name, service]` pairs currently registered on this container. */
+	entries() {
+		return Object.entries(this.services ?? {});
+	}
+	/**
+	* Declare a scope. Scopes are short-lived containers (typically created
+	* per HTTP/WS request) that inherit services from this container but
+	* store their own per-request services and parameters. Must be called
+	* once before {@link enterScope} can produce instances.
+	*
+	* @param name - scope identifier (e.g. `"request"`)
+	* @returns the underlying scope bucket (rarely used by callers)
+	*/
+	addScope(name) {
+		if (this.scopes === null) this.scopes = /* @__PURE__ */ new Map();
+		let bucket = this.scopes.get(name);
+		if (!bucket) {
+			bucket = /* @__PURE__ */ new Map();
+			this.scopes.set(name, bucket);
+		}
+		return bucket;
+	}
+	/**
+	* Open a new instance of the named scope. The returned {@link Scope}
+	* inherits services from this container but tracks its own services and
+	* parameters in isolation.
+	*
+	* @param name - scope name previously declared via {@link addScope}
+	* @returns a fresh `Scope` instance with a unique `id`
+	* @throws Error when the scope has not been declared
+	*/
+	enterScope(name) {
+		const bucket = this.scopes?.get(name);
+		if (!bucket) throw new Error(`Scope "${name}" not declared. Call addScope("${name}") first.`);
+		const sc = new Scope(name, this, this.protoService, this.protoParameters);
+		bucket.set(sc.id, sc);
+		return sc;
+	}
+	/**
+	* Close a scope instance and release its services/parameters. Always
+	* called when the unit of work that opened the scope finishes (request
+	* end, WS close).
+	*
+	* @param scope - the scope instance returned by {@link enterScope}
+	*/
+	leaveScope(scope) {
+		const bucket = this.scopes?.get(scope.name);
+		if (bucket) {
+			const sc = bucket.get(scope.id);
+			if (sc) {
+				sc.clean();
+				bucket.delete(scope.id);
+			}
+		}
+	}
+	/**
+	* Nombre d'instances VIVANTES du scope nommé — introspection bon marché
+	* (sondes de fuite, Studio, diagnostics) sans exposer la structure interne.
+	*
+	* @param name - scope identifier (e.g. `"request"`)
+	* @returns le nombre de scopes ouverts, `0` si le scope est inconnu
+	*/
+	scopeCount(name) {
+		return this.scopes?.get(name)?.size ?? 0;
+	}
+	/**
+	* Close every open instance of the named scope and forget it. After this
+	* call, {@link enterScope}(`name`) will throw until {@link addScope} is
+	* called again.
+	*
+	* @param name - scope identifier
+	*/
+	removeScope(name) {
+		const bucket = this.scopes?.get(name);
+		if (bucket) {
+			for (const scope of bucket.values()) this.leaveScope(scope);
+			this.scopes?.delete(name);
+		}
+	}
+	removeAllScopes() {
+		if (!this.scopes) return;
+		for (const name of this.scopes.keys()) this.removeScope(name);
+		this.scopes = null;
+	}
+	/**
+	* Set a value in the parameter tree using a dotted path. Intermediate
+	* objects are created on demand (`a.b.c = 1` creates `a` and `b` if they
+	* are missing).
+	*
+	* @param name - dotted path (e.g. `"kernel.environment"`)
+	* @param ele - value to assign (must not be `undefined`)
+	* @returns the parameter subtree containing the assigned value, or `null`
+	* if the container has been cleaned
+	* @throws Error when `name` is not a string or `ele` is `undefined`
+	*/
+	setParameters(name, ele) {
+		if (typeof name !== "string") throw new Error("setParameters : container parameter name must be a string");
+		if (ele === void 0) throw new Error(`setParameters : ${name} container parameter value must be defined`);
+		if (!this.parameters) return null;
+		return parseParameterString.call(this.parameters, name, ele);
+	}
+	/**
+	* Read a value (or subtree) from the parameter tree.
+	*
+	* @param name - dotted path (e.g. `"kernel.environment"`)
+	* @returns the value, the subtree, or `null` if absent
+	* @throws Error when `name` is empty
+	*/
+	getParameters(name) {
+		if (!name) throw new Error(`getParameters : invalid name "${name}"`);
+		if (!this.parameters) return null;
+		return parseParameterString.call(this.parameters, name);
+	}
+	/**
+	* Tear the container down: close every scope, drop services and
+	* parameters. After `clean()`, any `get`/`set`/`enterScope` call on this
+	* instance throws or returns `null`. Called by the kernel during
+	* graceful shutdown.
+	*/
+	clean() {
+		this.removeAllScopes();
+		this.services = null;
+		this.parameters = null;
+	}
+	/**
+	* Clean the container and rebuild fresh prototype chains, leaving it
+	* ready to register services again. Used by hot-reload paths in tests
+	* and dev mode; production code rarely calls this directly.
+	*/
+	reset() {
+		this.clean();
+		this.protoService = function() {};
+		this.protoParameters = function() {};
+		this.services = Object.create(this.protoService.prototype);
+		this.parameters = Object.create(this.protoParameters.prototype);
+	}
+};
+/**
+* Short-lived child container tied to a parent {@link Container}. Used by
+* the HTTP/WS kernel to isolate per-request services (e.g. request-bound
+* sessions, scoped resolvers) without polluting the global container.
+*
+* Services and parameters defined on a `Scope` shadow the parent's — reads
+* fall back to the parent transparently when nothing is found locally.
+*/
+var Scope = class extends Container {
+	name;
+	parent;
+	constructor(name, parent, parentProtoService, parentProtoParameters) {
+		super(void 0, false, parentProtoService, parentProtoParameters);
+		this.name = name;
+		this.parent = parent;
+	}
+	/**
+	* Register a per-request service — own property ONLY (shadowing). Depuis
+	* l'adoption des protos parents, l'écriture prototype de
+	* {@link Container.set} toucherait le proto PARTAGÉ du parent : un service
+	* per-request (controller, context) deviendrait visible de TOUTES les
+	* requêtes concurrentes. (L'ancien chemin écrivait sur un proto local mort
+	* — travail perdu à chaque set.)
+	*/
+	set(name, object) {
+		if (this.services && name) this.services[name] = object;
+		else throw new Error("Container bad argument name");
+	}
+	/**
+	* Unregister a service registered ON THIS SCOPE (own property only). Les
+	* services hérités du parent ne sont jamais touchés — même raison que
+	* {@link Scope.set} : le proto est partagé depuis l'adoption.
+	*/
+	remove(name) {
+		if (this.services && Object.prototype.hasOwnProperty.call(this.services, name)) {
+			delete this.services[name];
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Read a parameter from the scope, falling back to the parent container.
+	* When both sides hold plain objects, the result is a merged view (deep
+	* by default) so a scope can override a few keys without losing the rest.
+	*
+	* @param name - dotted path
+	* @param merge - when `true` (default), merge scope and parent objects;
+	* when `false`, scope value wins outright if present
+	* @param deep - deep vs. shallow merge (only when `merge` is `true`)
+	*/
+	getParameters(name, merge = true, deep = true) {
+		const res = parseParameterString.call(this.parameters ?? {}, name);
+		const obj = this.parent?.getParameters(name);
+		if (ISDefined(res)) {
+			if (merge && isPlainObject(obj) && isPlainObject(res)) return extend(deep, obj, res);
+			return res;
+		}
+		return obj ?? null;
+	}
+	/**
+	* Break the parent link and clean the scope. Called by
+	* {@link Container.leaveScope} when the unit of work that owns the scope
+	* finishes.
+	*/
+	clean() {
+		this.parent = null;
+		return super.clean();
+	}
+};
+//#endregion
+export { Scope, Container as default };

package/dist/node/Error.js

@@ -0,0 +1,309 @@
+import { Nodefony } from "./Nodefony.js";
+import clc from "./colors.js";
+import { typeOf } from "./Tools.js";
+import { inspect } from "node:util";
+import assert from "node:assert";
+import { STATUS_CODES } from "node:http";
+//#region src/Error.ts
+Object.defineProperty(Error.prototype, "toJSON", {
+	configurable: true,
+	writable: true,
+	value() {
+		const alt = {};
+		const storeKey = function(key) {
+			alt[key] = this[key];
+		};
+		Object.getOwnPropertyNames(this).forEach(storeKey, this);
+		return alt;
+	}
+});
+const exclude = {
+	context: true,
+	resolver: true,
+	container: true,
+	secure: true
+};
+const jsonNodefony = {
+	configurable: true,
+	writable: true,
+	value() {
+		const alt = {};
+		const storeKey = function(key) {
+			if (key in exclude) return;
+			alt[key] = this[key];
+		};
+		Object.getOwnPropertyNames(this).forEach(storeKey, this);
+		return alt;
+	}
+};
+let _errorAdapters = null;
+/**
+* Enregistre un adapter d'erreurs tiers sous une clé (ex. le nom du driver ORM
+* `"mongoose"`). Inversion de dépendance : le module s'enregistre lui-même à son
+* boot, le core ne connaît aucune bibliothèque. `null` retire l'adapter (teardown,
+* tests).
+*
+* @param name - clé unique de l'adapter (nom du module/driver).
+* @param adapter - implémentation `{ isError, errorToString }`, ou `null` pour retirer.
+*/
+function registerErrorAdapter(name, adapter) {
+	if (adapter === null) {
+		_errorAdapters?.delete(name);
+		return;
+	}
+	if (_errorAdapters === null) _errorAdapters = /* @__PURE__ */ new Map();
+	_errorAdapters.set(name, adapter);
+}
+/**
+* Premier adapter dont relève l'erreur, ou `null`. Gratuit tant qu'aucun adapter
+* n'est enregistré (registre `null`). Un adapter qui throw est ignoré — il ne doit
+* jamais casser la classification d'une erreur.
+*/
+const findErrorAdapter = function(error) {
+	if (_errorAdapters === null) return null;
+	for (const adapter of _errorAdapters.values()) try {
+		if (adapter.isError(error)) return adapter;
+	} catch {}
+	return null;
+};
+/**
+* Erreur Nodefony — wrapper riche autour de `Error` natif qui ajoute :
+* - Un `code` numérique (HTTP status ou code custom — pas un string).
+* - Un `errorType` détecté automatiquement (TypeError, SystemError,
+*   AssertionError, OrmError, ClientError, etc.).
+* - Une sérialisation `toJSON()` filtrée qui exclut `context`, `resolver`,
+*   `container`, `secure` (références circulaires).
+* - Un `toString()` coloré (cli-color) qui adapte le format selon
+*   l'environnement (production = message court ; dev = champs détaillés).
+*
+* @example Wrap d'une erreur existante
+* ```ts
+* try { ... } catch (e) { throw new nodefonyError(e, 500); }
+* ```
+*
+* @example Erreur custom
+* ```ts
+* throw new nodefonyError("user not found", 404);
+* ```
+*
+* @remarks Les erreurs de bibliothèques tierces (drivers ORM…) sont reconnues
+*   et formatées via un adapter injecté par `registerErrorAdapter` — le core
+*   reste découplé des modules. Sans adapter enregistré, l'erreur retombe sur la
+*   classification générique.
+*/
+var nodefonyError = class nodefonyError extends Error {
+	code;
+	error;
+	errorType;
+	/** Adapter d'erreur tiers résolu (erreur ORM…) quand `errorType === "OrmError"`. */
+	#errorAdapter = null;
+	/**
+	* @param message - string ou `Error` natif à wrapper. Si Error, ses champs
+	*   (message, code, stack) sont copiés ; le type est détecté.
+	* @param code - statut HTTP ou code custom (utilisé par HttpError pour le
+	*   status code de la réponse).
+	*/
+	constructor(message, code) {
+		if (message instanceof Error) super(message.message);
+		else super(message);
+		this.name = this.constructor.name;
+		this.code = null;
+		this.errorType = this.name;
+		if (code) this.code = code;
+		if (message) this.parseMessage(message);
+	}
+	/**
+	* Type guard — vérifie qu'une valeur est une instance d'`Error`.
+	*
+	* Override de la méthode native ajoutée par TS 6 ; conserve la signature
+	* pour rester compatible avec les consommateurs qui utilisent `Error.isError`.
+	*
+	* @param error - valeur inconnue à tester.
+	* @returns `true` si `error instanceof Error`.
+	*/
+	static isError(error) {
+		return error instanceof Error;
+	}
+	/**
+	* Détecte la catégorie d'une erreur (TypeError, SystemError, OrmError, etc.).
+	*
+	* Utilisée par `getType()` pour peupler `errorType` et copier les champs
+	* spécifiques au type (errno, syscall, bytesParsed, etc.).
+	*
+	* @param error - instance d'`Error` à classifier.
+	* @returns nom de la catégorie ou `false` si pas une `Error`.
+	*/
+	static detectType(error) {
+		switch (true) {
+			case error instanceof ReferenceError: return "ReferenceError";
+			case error instanceof TypeError: return "TypeError";
+			case error instanceof SyntaxError: return "SyntaxError";
+			case error instanceof assert.AssertionError: return "AssertionError";
+			case findErrorAdapter(error) !== null: return "OrmError";
+			case error instanceof Error:
+				if (error.errno) return "SystemError";
+				if (error.bytesParsed) return "ClientError";
+				try {
+					return error.constructor.name || "Error";
+				} catch (e) {
+					return "Error";
+				}
+		}
+		return false;
+	}
+	/**
+	* Détecte le type d'erreur et copie ses champs spécifiques sur `this`.
+	*
+	* Côté SystemError → `errno/syscall/address/port` ; AssertionError →
+	* `actual/expected/operator` ; ClientError → `bytesParsed/rawPacket`, etc.
+	*
+	* @param error - erreur source à analyser.
+	* @returns nom de la catégorie (jamais `false` — fallback `error.constructor.name` ou `"Error"`).
+	*/
+	getType(error) {
+		const errorType = nodefonyError.detectType(error);
+		if (errorType) switch (errorType) {
+			case "TypeError":
+			case "ReferenceError":
+			case "SyntaxError": return errorType;
+			case "AssertionError":
+				this.actual = error.actual;
+				this.expected = error.expected;
+				this.operator = error.operator;
+				return errorType;
+			case "SystemError":
+				this.errno = error.errno;
+				this.syscall = error.syscall;
+				this.address = error.address;
+				this.port = error.port;
+				this.stack = error.stack;
+				return errorType;
+			case "ClientError":
+				this.bytesParsed = error.bytesParsed;
+				this.rawPacket = error.rawPacket;
+				return errorType;
+			case "OrmError":
+				this.#errorAdapter = findErrorAdapter(error);
+				return errorType;
+			default: return error.constructor.name;
+		}
+		if (error && error.constructor) return error.constructor.name;
+		return "Error";
+	}
+	/**
+	* Sérialise l'erreur en string coloré (cli-color) selon `errorType` et l'environnement.
+	*
+	* En **production**, retourne un message court (type + message) ; sinon, formatage
+	* détaillé multi-lignes. Ajoute la stack si `kernel.debug` est actif.
+	*
+	* ⚠️ La garde compare à `"production"` **en toutes lettres**. Elle a longtemps
+	* comparé à `"prod"` — jamais vraie : `Kernel.setEnv()` réduit toujours
+	* l'environnement à `"development" | "production"` (`resolveRuntimeEnv`), même
+	* quand l'utilisateur a écrit `prod`. Le format court n'était donc jamais rendu.
+	*
+	* @returns string formatée prête pour `console.log` ou syslog.
+	*/
+	toString() {
+		let err = "";
+		switch (this.errorType) {
+			case "Error":
+				if (Nodefony.getKernel()?.environment === "production") return err;
+				err = `${clc.blue("Name :")} ${this.name}
+        ${clc.blue("Type :")} ${this.errorType}
+        ${clc.red("Code :")} ${this.code}
+        ${clc.red("Message :")} ${this.message}`;
+				break;
+			case "SystemError":
+				if (Nodefony.getKernel()?.environment === "production") return ` ${clc.blue("Type :")} ${this.errorType} ${clc.red(this.message)}`;
+				err = `${clc.blue("Name :")} ${this.name}
+      ${clc.blue("Type :")} ${this.errorType}
+      ${clc.red("Message :")} ${this.message}
+      ${clc.red("Ernno :")} ${this.errno}
+      ${clc.blue("Syscall :")} ${this.syscall}
+      ${clc.blue("Address :")} ${this.address}
+      ${clc.blue("Port :")} ${this.port}`;
+				break;
+			case "AssertionError":
+				if (Nodefony.getKernel()?.environment === "production") return ` ${clc.blue("Type :")} ${this.errorType} ${clc.red(this.message)}`;
+				err = `${clc.blue("Name :")} ${this.name}
+      ${clc.blue("Type :")} ${this.errorType}
+      ${clc.red("Code :")} ${this.code}
+      ${clc.red("Message :")} ${this.message}
+      ${clc.white("Actual :")} ${this.actual}
+      ${clc.white("Expected :")} ${this.expected}
+      ${clc.white("Operator :")} ${this.operator}`;
+				break;
+			case "ClientError":
+				if (Nodefony.getKernel()?.environment === "production") return ` ${clc.blue("Type :")} ${this.errorType} ${clc.red(this.message)}`;
+				err = `${clc.blue("Name :")} ${this.name}
+      ${clc.blue("Type :")} ${this.errorType}
+      ${clc.red("Code :")} ${this.code}
+      ${clc.red("Message :")} ${this.message}
+      ${clc.white("BytesParsed :")} ${this.bytesParsed}
+      ${clc.white("RawPacket :")} ${this.rawPacket}`;
+				break;
+			case "OrmError": return this.#errorAdapter?.errorToString(this) ?? this.message;
+			default:
+				if (Nodefony.getKernel()?.environment === "production") return ` ${clc.blue("Type :")} ${this.errorType} ${clc.red(this.message)}`;
+				err = `${clc.blue("Name :")} ${this.name}
+        ${clc.blue("Type :")} ${this.errorType}
+        ${clc.red("Message :")} ${this.message}`;
+		}
+		if (Nodefony.getKernel()?.debug) err += `
+        ${clc.green("Stack :")} ${this.stack}`;
+		return err;
+	}
+	/**
+	* Parse l'argument du constructeur et hydrate les champs (`message`, `code`, `stack`).
+	*
+	* Trois cas : `Error` natif (copie message/code/stack), `object` (extrait
+	* `status/code/message` + capture stack), autre (fallback `getDefaultMessage`).
+	*
+	* @param message - string, `Error`, ou objet quelconque à interpréter.
+	*/
+	parseMessage(message) {
+		this.errorType = this.getType(message);
+		switch (typeOf(message)) {
+			case "Error":
+				this.message = message.message;
+				if (message.code) this.code = message.code;
+				this.stack = message.stack;
+				break;
+			case "object":
+				Error.captureStackTrace(message, this.constructor);
+				if (message.status) this.code = message.status;
+				if (message.code) this.code = message.code;
+				try {
+					if (message.message) this.message = message.message;
+					else this.message = inspect(message, { depth: 0 });
+				} catch (e) {
+					this.error = e;
+				}
+				break;
+			default: this.getDefaultMessage();
+		}
+	}
+	/**
+	* Renseigne `this.message` à partir du `code` HTTP via `STATUS_CODES`.
+	*
+	* Fallback quand aucun message n'est fourni mais qu'un code est connu —
+	* ex : `new nodefonyError(undefined, 404)` → message `"Not Found"`.
+	*/
+	getDefaultMessage() {
+		if (!this.message && this.code) {
+			const str = this.code.toString();
+			if (str in STATUS_CODES) this.message = STATUS_CODES[str] || "";
+		}
+	}
+	/**
+	* Affiche l'erreur formatée sur `console.log` (raccourci de `toString()`).
+	*
+	* @returns `undefined` — `console.log` ne retourne rien.
+	*/
+	logger() {
+		return console.log(this.toString());
+	}
+};
+Object.defineProperty(nodefonyError.prototype, "toJSON", jsonNodefony);
+//#endregion
+export { nodefonyError as default, registerErrorAdapter };