@gratheon/log-lib 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gratheon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,186 @@
+# log-lib
+
+A TypeScript logging library with console output and MySQL database persistence support.
+
+## Features
+
+- **Dual Output**: Logs to both console and MySQL database
+- **Color-Coded Console**: ANSI colored output for different log levels
+- **TypeScript Support**: Full type definitions included
+- **Fastify Integration**: Special logger interface for Fastify framework
+- **Flexible Metadata**: Support for structured metadata in logs
+- **Error Handling**: Graceful handling of database connection failures
+- **Multiple Log Levels**: info, error, warn, debug (debug logs are not persisted to DB)
+
+## Installation
+
+```bash
+npm install @gratheon/log-lib
+```
+
+## Database Setup
+
+Before using the logger, you need to set up the MySQL database. Run the migration script:
+
+```bash
+mysql -u root -p < migrations/001-create-logs-table.sql
+```
+
+This will create:
+- A `logs` database
+- A `logs` table with fields: id, level, message, meta, timestamp
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { createLogger, LoggerConfig } from '@gratheon/log-lib';
+
+const config: LoggerConfig = {
+  mysql: {
+    host: 'localhost',
+    port: 3306,
+    user: 'your_user',
+    password: 'your_password',
+    database: 'logs' // optional, defaults to 'logs'
+  }
+};
+
+const { logger, fastifyLogger } = createLogger(config);
+
+// Log messages
+logger.info('Application started');
+logger.warn('Low memory warning', { available: '100MB' });
+logger.error('Failed to connect to API', { endpoint: '/api/users' });
+logger.debug('Processing item', { id: 123 }); // Not stored in DB
+
+// Error with stack trace
+try {
+  throw new Error('Something went wrong');
+} catch (err) {
+  logger.error(err); // Logs error with stack trace
+}
+
+// Enriched error logging
+logger.errorEnriched('Database query failed', err, { query: 'SELECT * FROM users' });
+```
+
+### Fastify Integration
+
+```typescript
+import Fastify from 'fastify';
+import { createLogger, LoggerConfig } from '@gratheon/log-lib';
+
+const config: LoggerConfig = {
+  mysql: {
+    host: 'localhost',
+    port: 3306,
+    user: 'your_user',
+    password: 'your_password'
+  }
+};
+
+const { fastifyLogger } = createLogger(config);
+
+const fastify = Fastify({
+  logger: fastifyLogger
+});
+
+fastify.listen(3000);
+```
+
+## API Reference
+
+### `createLogger(config: LoggerConfig)`
+
+Creates and returns logger instances.
+
+**Parameters:**
+- `config`: Configuration object with MySQL connection details
+
+**Returns:**
+```typescript
+{
+  logger: Logger,
+  fastifyLogger: FastifyLogger
+}
+```
+
+### Logger Methods
+
+#### `logger.info(message: string, meta?: LogMetadata)`
+Logs informational messages (console + DB)
+
+#### `logger.error(message: string | Error, meta?: LogMetadata)`
+Logs errors with automatic Error object detection (console + DB)
+
+#### `logger.errorEnriched(message: string, error: Error, meta?: LogMetadata)`
+Logs enriched error messages with context (console + DB)
+
+#### `logger.warn(message: string, meta?: LogMetadata)`
+Logs warning messages (console + DB)
+
+#### `logger.debug(message: string, meta?: LogMetadata)`
+Logs debug messages (console only, not persisted)
+
+### FastifyLogger Methods
+
+Compatible with Fastify's logger interface:
+- `info(msg: any)`
+- `error(message: string | Error, meta?: LogMetadata)`
+- `warn(msg: any)`
+- `debug(msg: any)`
+- `fatal(msg: any)` - Logs error and calls `process.exit(1)`
+- `trace(msg: any)` - No-op
+- `child(meta: any)` - Returns the same logger instance
+
+## Console Output Colors
+
+- **Time**: Blue
+- **Error**: Red (level) + Magenta (metadata)
+- **Info**: Green (level) + Magenta (metadata)
+- **Debug**: Gray (dimmed)
+- **Warn**: Yellow (level) + Magenta (metadata)
+
+## Database Schema
+
+```sql
+CREATE TABLE `logs` (
+    `id`        int auto_increment primary key,
+    `level`     varchar(16)   not null,
+    `message`   varchar(2048) not null,
+    `meta`      varchar(2048) not null,
+    `timestamp` datetime      not null
+);
+```
+
+## Error Handling
+
+The logger gracefully handles database connection failures:
+- Logs are always written to console
+- Database errors are logged to console only
+- Application continues running even if database is unavailable
+- Connection errors (ECONNREFUSED, ENOTFOUND, ETIMEDOUT) are handled with warnings
+
+## TypeScript Types
+
+```typescript
+interface LoggerConfig {
+  mysql: {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database?: string; // defaults to 'logs'
+  };
+}
+
+interface LogMetadata {
+  [key: string]: any;
+}
+```
+
+## License
+
+ISC

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { createLogger } from './logger';
+export { LoggerConfig, Logger, FastifyLogger, LogMetadata } from './types';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = void 0;
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "createLogger", { enumerable: true, get: function () { return logger_1.createLogger; } });

package/dist/logger.d.ts

@@ -0,0 +1,5 @@
+import { LoggerConfig, Logger, FastifyLogger } from "./types";
+export declare function createLogger(config: LoggerConfig): {
+    logger: Logger;
+    fastifyLogger: FastifyLogger;
+};

package/dist/logger.js

@@ -0,0 +1,167 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = void 0;
+const mysql_1 = __importStar(require("@databases/mysql"));
+const fast_safe_stringify_1 = __importDefault(require("fast-safe-stringify"));
+let conn;
+function initializeConnection(config) {
+    const database = config.mysql.database || 'logs';
+    conn = (0, mysql_1.default)(`mysql://${config.mysql.user}:${config.mysql.password}@${config.mysql.host}:${config.mysql.port}/${database}`);
+}
+function log(level, message, meta) {
+    let time = new Date().toISOString();
+    let hhMMTime = time.slice(11, 19);
+    // colorize time to have ansi blue color
+    hhMMTime = `\x1b[34m${hhMMTime}\x1b[0m`;
+    // colorize level to have ansi red color for errors
+    meta = meta ? (0, fast_safe_stringify_1.default)(meta) : "";
+    if (level === "error") {
+        level = `\x1b[31m${level}\x1b[0m`;
+        meta = `\x1b[35m${meta}\x1b[0m`;
+    }
+    else if (level === "info") {
+        level = `\x1b[32m${level}\x1b[0m`;
+        meta = `\x1b[35m${meta}\x1b[0m`;
+    }
+    else if (level === "debug") {
+        level = `\x1b[90m${level}\x1b[0m`;
+        message = `\x1b[90m${message}\x1b[0m`;
+        meta = `\x1b[90m${meta}\x1b[0m`;
+    }
+    else if (level === "warn") {
+        level = `\x1b[33m${level}\x1b[0m`;
+        meta = `\x1b[35m${meta}\x1b[0m`;
+    }
+    console.log(`${hhMMTime} [${level}]: ${message} ${meta}`);
+}
+function storeInDB(level, message, meta) {
+    if (!conn) {
+        console.error(`\x1b[31m[Logger DB Error] Logger not initialized. Call createLogger() first.\x1b[0m`);
+        return;
+    }
+    if (!meta)
+        meta = "";
+    // Use the logger's dedicated connection pool
+    conn.query((0, mysql_1.sql) `
+        INSERT INTO \`logs\` (\`level\`, \`message\`, \`meta\`, \`timestamp\`)
+        VALUES (${level}, ${message}, ${JSON.stringify(meta)}, NOW())
+    `).catch(err => {
+        // Log connection errors to console only, don't crash
+        console.error(`\x1b[31m[Logger DB Error] Failed to store log in DB:\x1b[0m ${err.message}`);
+        // Optionally check if it's a connection error vs. other query error
+        if (err.code && (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND' || err.code === 'ETIMEDOUT')) {
+            console.warn(`\x1b[33m[Logger DB Warning] Logger DB connection failed (${err.code}). Is the DB ready?\x1b[0m`);
+        }
+    });
+}
+function createLogger(config) {
+    initializeConnection(config);
+    const logger = {
+        info: (message, meta) => {
+            log("info", message, meta);
+            storeInDB("info", message, meta);
+        },
+        error: (message, meta) => {
+            if (message.message && message.stack) {
+                // Pass the error message string, not the whole object, to storeInDB
+                storeInDB("error", message.message, meta);
+                return log("error", message.message, {
+                    stack: message.stack,
+                    ...meta,
+                });
+            }
+            // If message is not an Error object, check if it's another type of object
+            const messageString = typeof message === 'object' && message !== null && !Array.isArray(message)
+                ? (0, fast_safe_stringify_1.default)(message) // Stringify if it's a plain object
+                : String(message); // Otherwise, convert to string as before
+            log("error", messageString, meta);
+            // Store the original message or its stringified form in DB
+            storeInDB("error", typeof message === 'object' ? (0, fast_safe_stringify_1.default)(message) : message, meta);
+        },
+        errorEnriched: (message, error, meta) => {
+            const enrichedMessage = `${message}: ${error.message}`;
+            if (error.message && error.stack) {
+                // Store the combined error message in the DB
+                storeInDB("error", enrichedMessage, meta);
+                return log("error", enrichedMessage, {
+                    stack: error.stack,
+                    ...meta,
+                });
+            }
+            log("error", String(message), meta);
+            storeInDB("error", message, meta);
+        },
+        warn: (message, meta) => {
+            log("warn", message, meta);
+            storeInDB("warn", message, meta);
+        },
+        // do not store debug logs in DB
+        debug: (message, meta) => {
+            log("debug", message, meta);
+        },
+    };
+    const fastifyLogger = {
+        // Stringify potential objects passed to info/warn
+        info: (msg) => {
+            const messageString = typeof msg === 'object' ? (0, fast_safe_stringify_1.default)(msg) : String(msg);
+            log("info", messageString);
+            // storeInDB("info", messageString); // Keep commented out as original
+        },
+        error: (message, meta) => {
+            const errorMessage = (message && message.message) ? message.message : String(message);
+            log("error", errorMessage, meta);
+            // Ensure string is passed to storeInDB
+            storeInDB("error", typeof message === 'object' ? (0, fast_safe_stringify_1.default)(message) : errorMessage, meta);
+        },
+        warn: (msg) => {
+            const messageString = typeof msg === 'object' ? (0, fast_safe_stringify_1.default)(msg) : String(msg);
+            log("warn", messageString);
+            storeInDB("warn", messageString); // Pass stringified message
+        },
+        // do not store debug logs in DB
+        debug: (msg) => {
+            log("debug", msg);
+        },
+        fatal: (msg) => {
+            log("error", msg);
+            storeInDB("error", msg);
+            process.exit(1);
+        },
+        trace: (msg) => { },
+        child: (meta) => {
+            return fastifyLogger;
+        },
+    };
+    // Set up uncaught exception handler
+    process.on("uncaughtException", function (err) {
+        logger.errorEnriched("UncaughtException processing: %s", err);
+    });
+    return { logger, fastifyLogger };
+}
+exports.createLogger = createLogger;

package/dist/types.d.ts

@@ -0,0 +1,28 @@
+export interface LoggerConfig {
+    mysql: {
+        host: string;
+        port: number;
+        user: string;
+        password: string;
+        database?: string;
+    };
+}
+export interface LogMetadata {
+    [key: string]: any;
+}
+export interface Logger {
+    info: (message: string, meta?: LogMetadata) => void;
+    error: (message: string | Error | any, meta?: LogMetadata) => void;
+    errorEnriched: (message: string, error: Error | any, meta?: LogMetadata) => void;
+    warn: (message: string, meta?: LogMetadata) => void;
+    debug: (message: string, meta?: LogMetadata) => void;
+}
+export interface FastifyLogger {
+    info: (msg: any) => void;
+    error: (message: string | Error | any, meta?: LogMetadata) => void;
+    warn: (msg: any) => void;
+    debug: (msg: any) => void;
+    fatal: (msg: any) => void;
+    trace: (msg: any) => void;
+    child: (meta: any) => FastifyLogger;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/example.ts

@@ -0,0 +1,41 @@
+import { createLogger, LoggerConfig } from './src/index';
+
+// Example configuration
+const config: LoggerConfig = {
+  mysql: {
+    host: 'localhost',
+    port: 3306,
+    user: 'root',
+    password: 'test',
+    database: 'logs' // optional, defaults to 'logs'
+  }
+};
+
+// Create logger instances
+const { logger, fastifyLogger } = createLogger(config);
+
+// Example usage
+logger.info('Application started successfully');
+logger.debug('Debug information', { userId: 123, action: 'login' });
+logger.warn('Low memory warning', { available: '100MB', threshold: '200MB' });
+
+// Error logging examples
+try {
+  throw new Error('Something went wrong');
+} catch (err) {
+  logger.error(err); // Logs with stack trace
+}
+
+// Enriched error logging
+try {
+  // Some database operation
+  throw new Error('Connection timeout');
+} catch (err) {
+  logger.errorEnriched('Database query failed', err, { 
+    query: 'SELECT * FROM users',
+    timeout: 5000 
+  });
+}
+
+// Object error logging
+logger.error({ code: 'AUTH_FAILED', user: 'john@example.com' });

package/migrations/001-create-logs-table.sql

@@ -0,0 +1,11 @@
+-- Create the logs database
+CREATE DATABASE IF NOT EXISTS `logs`;
+
+-- Create the logs table within the 'logs' database
+CREATE TABLE IF NOT EXISTS `logs`.`logs` (
+    `id`        int auto_increment primary key,
+    `level`     varchar(16)   not null,
+    `message`   varchar(2048) not null,
+    `meta`      varchar(2048) not null,
+    `timestamp` datetime      not null
+);

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@gratheon/log-lib",
+  "version": "1.0.0",
+  "description": "Logging library with console and MySQL database persistence",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "logging",
+    "logger",
+    "mysql",
+    "typescript"
+  ],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@databases/mysql": "^6.0.0",
+    "fast-safe-stringify": "^2.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.11",
+    "typescript": "^4.9.4"
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { createLogger } from './logger';
+export { LoggerConfig, Logger, FastifyLogger, LogMetadata } from './types';

package/src/logger.ts

@@ -0,0 +1,153 @@
+import createConnectionPool, { sql, ConnectionPool } from "@databases/mysql";
+import jsonStringify from "fast-safe-stringify";
+import { LoggerConfig, Logger, FastifyLogger, LogMetadata } from "./types";
+
+let conn: ConnectionPool;
+
+function initializeConnection(config: LoggerConfig) {
+  const database = config.mysql.database || 'logs';
+  conn = createConnectionPool(
+    `mysql://${config.mysql.user}:${config.mysql.password}@${config.mysql.host}:${config.mysql.port}/${database}`,
+  );
+}
+
+function log(level: string, message: string, meta?: any) {
+  let time = new Date().toISOString();
+  let hhMMTime = time.slice(11, 19);
+  // colorize time to have ansi blue color
+  hhMMTime = `\x1b[34m${hhMMTime}\x1b[0m`;
+
+  // colorize level to have ansi red color for errors
+  meta = meta ? jsonStringify(meta) : "";
+
+  if (level === "error") {
+    level = `\x1b[31m${level}\x1b[0m`;
+    meta = `\x1b[35m${meta}\x1b[0m`;
+  } else if (level === "info") {
+    level = `\x1b[32m${level}\x1b[0m`;
+    meta = `\x1b[35m${meta}\x1b[0m`;
+  } else if (level === "debug") {
+    level = `\x1b[90m${level}\x1b[0m`;
+    message = `\x1b[90m${message}\x1b[0m`;
+    meta = `\x1b[90m${meta}\x1b[0m`;
+  } else if (level === "warn") {
+    level = `\x1b[33m${level}\x1b[0m`;
+    meta = `\x1b[35m${meta}\x1b[0m`;
+  }
+
+  console.log(`${hhMMTime} [${level}]: ${message} ${meta}`);
+}
+
+function storeInDB(level: string, message: string, meta?: any) {
+  if (!conn) {
+    console.error(`\x1b[31m[Logger DB Error] Logger not initialized. Call createLogger() first.\x1b[0m`);
+    return;
+  }
+  
+  if (!meta) meta = "";
+  // Use the logger's dedicated connection pool
+  conn.query(sql`
+        INSERT INTO \`logs\` (\`level\`, \`message\`, \`meta\`, \`timestamp\`)
+        VALUES (${level}, ${message}, ${JSON.stringify(meta)}, NOW())
+    `).catch(err => {
+      // Log connection errors to console only, don't crash
+      console.error(`\x1b[31m[Logger DB Error] Failed to store log in DB:\x1b[0m ${err.message}`);
+      // Optionally check if it's a connection error vs. other query error
+      if (err.code && (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND' || err.code === 'ETIMEDOUT')) {
+          console.warn(`\x1b[33m[Logger DB Warning] Logger DB connection failed (${err.code}). Is the DB ready?\x1b[0m`);
+      }
+    });
+}
+
+export function createLogger(config: LoggerConfig): { logger: Logger; fastifyLogger: FastifyLogger } {
+  initializeConnection(config);
+
+  const logger: Logger = {
+    info: (message: string, meta?: LogMetadata) => {
+      log("info", message, meta);
+      storeInDB("info", message, meta);
+    },
+    error: (message: string | Error | any, meta?: LogMetadata) => {
+      if (message.message && message.stack) {
+        // Pass the error message string, not the whole object, to storeInDB
+        storeInDB("error", message.message, meta);
+        return log("error", message.message, {
+          stack: message.stack,
+          ...meta,
+        });
+      }
+      // If message is not an Error object, check if it's another type of object
+      const messageString = typeof message === 'object' && message !== null && !Array.isArray(message)
+        ? jsonStringify(message) // Stringify if it's a plain object
+        : String(message);      // Otherwise, convert to string as before
+      log("error", messageString, meta);
+      // Store the original message or its stringified form in DB
+      storeInDB("error", typeof message === 'object' ? jsonStringify(message) : message, meta);
+    },
+    errorEnriched: (message: string, error: Error | any, meta?: LogMetadata) => {
+      const enrichedMessage = `${message}: ${error.message}`;
+      if (error.message && error.stack) {
+        // Store the combined error message in the DB
+        storeInDB("error", enrichedMessage, meta);
+        return log("error", enrichedMessage, {
+          stack: error.stack,
+          ...meta,
+        });
+      }
+      log("error", String(message), meta);
+      storeInDB("error", message, meta);
+    },
+    warn: (message: string, meta?: LogMetadata) => {
+      log("warn", message, meta);
+      storeInDB("warn", message, meta);
+    },
+
+    // do not store debug logs in DB
+    debug: (message: string, meta?: LogMetadata) => {
+      log("debug", message, meta);
+    },
+  };
+
+  const fastifyLogger: FastifyLogger = {
+    // Stringify potential objects passed to info/warn
+    info: (msg) => {
+      const messageString = typeof msg === 'object' ? jsonStringify(msg) : String(msg);
+      log("info", messageString);
+      // storeInDB("info", messageString); // Keep commented out as original
+    },
+    error: (message: string | Error | any, meta?: LogMetadata) => {
+      const errorMessage = (message && message.message) ? message.message : String(message);
+      log("error", errorMessage, meta);
+      // Ensure string is passed to storeInDB
+      storeInDB("error", typeof message === 'object' ? jsonStringify(message) : errorMessage, meta);
+    },
+    warn: (msg) => {
+      const messageString = typeof msg === 'object' ? jsonStringify(msg) : String(msg);
+      log("warn", messageString);
+      storeInDB("warn", messageString); // Pass stringified message
+    },
+
+    // do not store debug logs in DB
+    debug: (msg) => {
+      log("debug", msg);
+    },
+
+    fatal: (msg) => {
+      log("error", msg);
+      storeInDB("error", msg);
+      process.exit(1);
+    },
+
+    trace: (msg) => {},
+    child: (meta: any) => {
+      return fastifyLogger;
+    },
+  };
+
+  // Set up uncaught exception handler
+  process.on("uncaughtException", function (err) {
+    logger.errorEnriched("UncaughtException processing: %s", err);
+  });
+
+  return { logger, fastifyLogger };
+}

package/src/types.ts

@@ -0,0 +1,31 @@
+export interface LoggerConfig {
+  mysql: {
+    host: string;
+    port: number;
+    user: string;
+    password: string;
+    database?: string; // defaults to 'logs'
+  };
+}
+
+export interface LogMetadata {
+  [key: string]: any;
+}
+
+export interface Logger {
+  info: (message: string, meta?: LogMetadata) => void;
+  error: (message: string | Error | any, meta?: LogMetadata) => void;
+  errorEnriched: (message: string, error: Error | any, meta?: LogMetadata) => void;
+  warn: (message: string, meta?: LogMetadata) => void;
+  debug: (message: string, meta?: LogMetadata) => void;
+}
+
+export interface FastifyLogger {
+  info: (msg: any) => void;
+  error: (message: string | Error | any, meta?: LogMetadata) => void;
+  warn: (msg: any) => void;
+  debug: (msg: any) => void;
+  fatal: (msg: any) => void;
+  trace: (msg: any) => void;
+  child: (meta: any) => FastifyLogger;
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}