Utility Functions

/**
 * Validates if an object is a logger instance
 * @param {*} logger - Object to validate
 * @returns {boolean} True if object is a valid logger
 */
function isLogger(logger);

const isLogger = require("log/is-logger");
const log = require("log");

// Valid logger instances
console.log(isLogger(log));              // true
console.log(isLogger(log.error));        // true
console.log(isLogger(log.get("app")));   // true

// Invalid objects
console.log(isLogger(null));            // false
console.log(isLogger({}));              // false
console.log(isLogger("log"));           // false
console.log(isLogger(console.log));     // false

// Function checks
function processLogger(logger) {
  if (isLogger(logger)) {
    logger.info("Processing with valid logger");
  } else {
    console.error("Invalid logger provided");
  }
}

/**
 * Validates logger or throws TypeError if invalid
 * @param {*} logger - Object to validate
 * @returns {Logger} The validated logger instance
 * @throws {TypeError} If object is not a valid logger
 */
function ensureLogger(logger);

const ensureLogger = require("log/ensure-logger");
const log = require("log");

// Valid logger - returns the logger
const validLogger = ensureLogger(log);
console.log(validLogger === log); // true

// Valid namespaced logger
const appLogger = ensureLogger(log.get("app"));
appLogger.info("Validated logger works");

// Invalid object - throws TypeError
try {
  ensureLogger("not a logger");
} catch (error) {
  console.log(error instanceof TypeError); // true
  console.log(error.message); // "'not a logger' is not a logger"
}

try {
  ensureLogger(null);
} catch (error) {
  console.log(error.message); // "null is not a logger"
}

// Usage in function parameters
function logWithValidation(logger, message) {
  const validLogger = ensureLogger(logger);
  validLogger.info(message);
}

// Safe usage
logWithValidation(log, "This works");           // ✓ Success
logWithValidation(log.error, "This works too"); // ✓ Success

// Unsafe usage
try {
  logWithValidation({}, "This fails");          // ✗ Throws TypeError
} catch (error) {
  console.log("Validation failed:", error.message);
}

// 1. Must be a plain function (callable)
typeof logger === 'function' && logger.constructor === Function

// 2. Must have a 'level' property that is a string
typeof logger.level === 'string'

// 3. Must have an 'isNamespaceInitialized' method that is a function
typeof logger.isNamespaceInitialized === 'function'

const isLogger = require("log/is-logger");

// Valid logger characteristics
const log = require("log");

console.log(typeof log);                           // "function"
console.log(typeof log.level);                     // "string"
console.log(typeof log.isNamespaceInitialized);    // "function"
console.log(isLogger(log));                        // true

// Invalid objects and why they fail:

// Not a function
const notFunction = { level: "info", isNamespaceInitialized: () => {} };
console.log(isLogger(notFunction)); // false - not a function

// Missing level property  
const noLevel = function() {};
noLevel.isNamespaceInitialized = () => {};
console.log(isLogger(noLevel)); // false - no level property

// Level is not a string
const badLevel = function() {};
badLevel.level = 123;
badLevel.isNamespaceInitialized = () => {};
console.log(isLogger(badLevel)); // false - level not string

// Missing isNamespaceInitialized method
const noMethod = function() {};
noMethod.level = "info";
console.log(isLogger(noMethod)); // false - missing method

const ensureLogger = require("log/ensure-logger");

class DatabaseConnection {
  constructor(config, logger) {
    this.config = config;
    this.logger = ensureLogger(logger); // Ensures valid logger
  }
  
  connect() {
    this.logger.info("Connecting to database...");
    // Connection logic
  }
  
  query(sql) {
    this.logger.debug("Executing query: %s", sql);
    // Query logic
  }
}

// Usage with validation
const log = require("log");
const db = new DatabaseConnection(config, log.get("database")); // ✓ Valid

try {
  const badDb = new DatabaseConnection(config, console); // ✗ Throws
} catch (error) {
  console.log("Invalid logger provided to DatabaseConnection");
}

const isLogger = require("log/is-logger");

function createLoggingMiddleware(logger) {
  if (!isLogger(logger)) {
    throw new Error("Logging middleware requires a valid logger instance");
  }
  
  return function loggingMiddleware(req, res, next) {
    logger.info("%s %s", req.method, req.url);
    next();
  };
}

// Usage
const log = require("log");
const middleware = createLoggingMiddleware(log.get("http")); // ✓ Valid

try {
  const badMiddleware = createLoggingMiddleware(console.log); // ✗ Throws
} catch (error) {
  console.log("Middleware creation failed");
}

const isLogger = require("log/is-logger");

function processData(data, logger) {
  // Use provided logger or create default
  const log = isLogger(logger) ? logger : require("log").get("processor");
  
  log.info("Processing %d items", data.length);
  
  // Processing logic
  data.forEach((item, index) => {
    log.debug("Processing item %d: %j", index, item);
  });
  
  log.info("Processing complete");
}

// Usage with logger
processData(items, log.get("custom")); // Uses custom logger

// Usage without logger  
processData(items); // Uses default logger

// Usage with invalid logger
processData(items, "invalid"); // Uses default logger (graceful fallback)

const ensureLogger = require("log/ensure-logger");

function setupApplication(config) {
  // Validate logger configuration
  if (config.logger) {
    try {
      config.logger = ensureLogger(config.logger);
    } catch (error) {
      throw new Error(`Invalid logger in configuration: ${error.message}`);
    }
  } else {
    // Provide default logger
    config.logger = require("log").get("app");
  }
  
  // Application setup continues with validated logger
  config.logger.info("Application setup complete");
}

// Usage
const log = require("log");

setupApplication({ 
  logger: log.get("myapp")  // ✓ Valid logger
});

try {
  setupApplication({ 
    logger: { fake: "logger" }  // ✗ Invalid logger
  });
} catch (error) {
  console.log("Configuration validation failed");
}