Add type declarations

Author: aptomaKetil

index.js

@@ -5,11 +5,6 @@ const internals = {
 	instances: {}
 };
 
-/**
- * @param {string} [name]
- * @param {import('./lib/logger').LoggerOptions} [opts]
- * @returns {Logger}
- */
 module.exports = function (name, opts) {
 	name = name || '_default';
 	if (typeof (name) === 'object') {

index.ts

@@ -0,0 +1,68 @@
+import type {Server, Request} from '@hapi/hapi';
+
+declare namespace hapiLog {
+	interface LogHandler {
+		log(message: string): void;
+	}
+
+	interface RequestInfo {
+		remoteAddress: string;
+		host: string;
+		path: string;
+		method: string;
+		query: Record<string, unknown>;
+		statusCode: number;
+		responseTime: number;
+		userAgent?: string;
+		contentLength?: string;
+		referer?: string;
+	}
+
+	interface LogData {
+		timestamp: number;
+		tags: string[];
+		log?: unknown;
+		requestInfo?: RequestInfo;
+		data?: Record<string, unknown>;
+	}
+
+	interface LoggerOptions {
+		handler?: LogHandler;
+		meta?: (request?: Request) => Record<string, unknown> | undefined;
+		formatTimestamp?: (timestamp: number) => string;
+		jsonOutput?: boolean;
+		requestInfoFilter?: (requestInfo: RequestInfo) => RequestInfo;
+	}
+
+	interface PluginOptions extends LoggerOptions {
+		name?: string;
+		ignorePaths?: string[];
+		ignoreMethods?: string[];
+		onPreResponseError?: boolean;
+	}
+
+	class Logger {
+		constructor(options?: LoggerOptions);
+
+		readonly formatTime: (timestamp: number) => string;
+
+		handleError(request: Request, data: {error: Error}): void;
+		handleRequest(request: Request, event: {timestamp: number; tags: string[]; data?: unknown; error?: Error}): void;
+		handleResponse(request: Request): void;
+		handleLog(event: {timestamp: number; tags: string[]; data?: unknown; error?: Error}): void;
+		log(tags: string | string[], ...messages: unknown[]): void;
+		formatter(obj: LogData): string;
+		humanReadableFormatter(obj: LogData): string;
+		stringifyRequestInfo(data: RequestInfo): string;
+		write(obj: LogData): void;
+	}
+
+	const plugin: {
+		name: string;
+		register(server: Server, options?: PluginOptions): void;
+	};
+}
+
+declare function hapiLog(name?: string | hapiLog.LoggerOptions, opts?: hapiLog.LoggerOptions): hapiLog.Logger;
+
+export = hapiLog;

lib/logger.js

@@ -14,104 +14,30 @@ const internals = {
 };
 
 
-/**
- * Default meta data to append to logs
- * @param  {HapiRequest} [request]
- * @return {Record<string, unknown>|undefined}
- */
 function defaultMeta(request) {
 	if (!request) {
 		return;
 	}
 	return {requestId: request.info.id};
 }
 
-/**
- * defaultHandler for outputing the logs
- * @return {object}
- */
 function defaultHandler() {
 	return {
-		/**
-		 * @param {string} str
-		 */
 		log(str) {
 			process.stdout.write(str + '\n');
 		}
 	};
 }
 
-/**
- * @typedef {object} RequestInfo
- * @property {string} remoteAddress
- * @property {string} host
- * @property {string} path
- * @property {string} method
- * @property {object} query
- * @property {number} statusCode
- * @property {number} responseTime
- * @property {string} [userAgent]
- * @property {string} [contentLength]
- * @property {string} [referer]
- */
-
-/**
- * @typedef {object} HapiRequest - Hapi request object
- * @property {object} request.info - Request information
- * @property {string} request.info.id - Unique request identifier
- * @property {string} request.info.remoteAddress - Client IP address
- * @property {string} request.info.hostname - Request hostname
- * @property {number} request.info.received - Timestamp when request was received
- * @property {string} request.path - Request path
- * @property {string} request.method - HTTP method
- * @property {Record<string, unknown>} request.query - Query propertyeters
- * @property {Record<string, string>} request.headers - Request headers
- * @property {object} request.raw - Raw request/response objects
- * @property {object} request.raw.req - Raw Node.js request object
- * @property {Record<string, string>} request.raw.req.headers - Raw request headers
- * @property {object} request.raw.res - Raw Node.js response object
- * @property {number} request.raw.res.statusCode - HTTP status code
- * @property {object} [request.response] - Hapi response object
- * @property {Record<string, string>} [request.response.headers] - Response headers
-*/
-
-/**
- * @typedef {object} LogData
- * @property {number} timestamp when the log event occured
- * @property {string[]} tags
- * @property {object|string} [log] the log message or object
- * @property {RequestInfo} [requestInfo]
- * @property {object} [data] optional meta data
- */
-
-/**
- * @typedef {object} LoggerOptions
- * @property {{log: (message: string) => void}} [handler] Handler implementing `log(message)` method, defaults to console logging
- * @property {(request?: HapiRequest) => Record<string, unknown>} [meta] Should return meta data as an Object that is appended to logs. Default returns {requestId:request.info.id} This function doesnt always recieve request object.
- * @property {(timestamp: number) => string} [formatTime]
- * @property {boolean} [jsonOutput] output all data as stringified json
- */
-
 class Logger {
 
-	/**
-	 * Creates a new Logger
-	 *
-	 * @class Logger
-	 * @param {LoggerOptions} [options]
-	 */
 	constructor(options) {
 		this.opts = {...internals.defaults, ...options};
 		this.handler = this.opts.handler || defaultHandler();
 		this.meta = this.opts.meta || defaultMeta;
 		this.formatTime = this.opts.formatTimestamp;
 	}
 
-	/**
-	 * Handle Error
-	 * @param  {HapiRequest} request
-	 * @param  {object} data
-	 */
 	handleError(request, data) {
 		this.write({
 			timestamp: Date.now(),
@@ -121,11 +47,6 @@ class Logger {
 		});
 	}
 
-	/**
-	 * Handle 'request' event
-	 * @param  {HapiRequest} request
-	 * @param  {object} event
-	 */
 	handleRequest(request, event) {
 		this.write({
 			timestamp: event.timestamp,
@@ -135,10 +56,6 @@ class Logger {
 		});
 	}
 
-	/**
-	 * Handle 'response' event
-	 * @param {HapiRequest} request
-	 */
 	handleResponse(request) {
 		const referer = request.raw.req.headers.referer;
 		const contentLength = request.response?.headers?.['content-length'];
@@ -150,7 +67,6 @@ class Logger {
 			remoteAddress = xFF.split(',')[0];
 		}
 
-		/** @type {RequestInfo} */
 		const requestInfo = {
 			remoteAddress,
 			host: request.info.hostname,
@@ -178,11 +94,6 @@ class Logger {
 		});
 	}
 
-	/**
-	 * Format RequestInfo to a human friendly string
-	 * @param  {RequestInfo} data
-	 * @return {string}
-	 */
 	stringifyRequestInfo(data) {
 		return printf(
 			'%s, %s %s %s %s %s (%sms), %s%s',
@@ -198,10 +109,6 @@ class Logger {
 		);
 	}
 
-	/**
-	 * Handle 'log' event
-	 * @param  {object} event
-	 */
 	handleLog(event) {
 		this.write({
 			timestamp: event.timestamp,
@@ -210,11 +117,6 @@ class Logger {
 		});
 	}
 
-	/**
-	 * Format log data to human readable string
-	 * @param  {LogData} obj
-	 * @return {string}
-	 */
 	humanReadableFormatter(obj) {
 		let log;
 		if (obj.requestInfo) {
@@ -233,11 +135,6 @@ class Logger {
 		);
 	}
 
-	/**
-	 * Formats Log to a string
-	 * @param  {LogData} obj
-	 * @return {String}
-	 */
 	formatter(obj) {
 		if (!this.opts.jsonOutput) {
 			return this.humanReadableFormatter(obj);
@@ -263,19 +160,10 @@ class Logger {
 		return stringify(formatted);
 	}
 
-	/**
-	 * Formats and writes the log data
-	 * @param  {LogData} obj
-	 */
 	write(obj) {
 		this.handler.log(this.formatter(obj));
 	}
 
-	/**
-	 * Add a log entry
-	 * @param  {Array|String} tags
-	 * @param  {Object|String} messages
-	 */
 	log(tags, ...messages) {
 		// only apply printf if it has multiple messages
 		// we want to be able to handle a single error objects for jsonOutput differently