@palmares/logging
Version:
Palmares logging interface so you can log it to the console or other places as well
317 lines (309 loc) • 9.07 kB
JavaScript
var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
// src/adapter.ts
function loggingAdapter(args) {
const ModifiedClass = class extends LoggingAdapter {
static {
__name(this, "ModifiedClass");
}
log = args.log;
debug = args.debug;
info = args.info;
warn = args.warn;
error = args.error;
};
return ModifiedClass;
}
__name(loggingAdapter, "loggingAdapter");
var LoggingAdapter = class {
static {
__name(this, "LoggingAdapter");
}
/**
* Log level log message.
*
* See: https://developer.mozilla.org/en-US/docs/Web/API/console/log
*
* @example
* ```ts
* logger.log('Hello World');
* ```
*
* @param _message - The message to be logged.
*/
log(_message) {
return void 0;
}
/**
* Log level debug message.
*
* See: https://developer.mozilla.org/en-US/docs/Web/API/console/debug
*
* @example
* ```ts
* logger.debug('Hello World');
* ```
*
* @param _message - The message to be logged.
*/
debug(_message) {
return void 0;
}
/**
* Log level warn message.
*
* See: https://developer.mozilla.org/en-US/docs/Web/API/console/warn
*
* @example
* ```ts
* logger.warn('Hello World');
* ```
*
* @param _message - The message to be logged.
*/
warn(_message) {
return void 0;
}
/**
* Log level error message.
*
* See: https://developer.mozilla.org/en-US/docs/Web/API/console/error
*
* @example
* ```ts
* logger.error('Hello World');
* ```
*
* @param _message - The message to be logged.
*/
error(_message) {
return void 0;
}
/**
* Log level info message.
*
* See: https://developer.mozilla.org/en-US/docs/Web/API/console/info
*
* @example
* ```ts
* logger.info('Hello World');
* ```
*
* @param _message - The message to be logged.
*/
info(_message) {
return void 0;
}
};
// src/config.ts
function setLoggerAtLevel(level, logger) {
if (typeof globalThis.$PLogging !== "object") globalThis.$PLogging = {};
if (globalThis.$PLogging[level]) globalThis.$PLogging[level].push(logger);
else globalThis.$PLogging[level] = [
logger
];
}
__name(setLoggerAtLevel, "setLoggerAtLevel");
function getLoggersAtLevel(level) {
return globalThis.$PLogging?.[level];
}
__name(getLoggersAtLevel, "getLoggersAtLevel");
// src/constants.ts
var FRAMEWORK_NAME = "palmares";
var stringByMessageType = {
debug: "\x1B[35mDEBUG\x1B[0m",
log: "\x1B[32mLOG\x1B[0m",
info: "\x1B[36mINFO\x1B[0m",
warn: "\x1B[33mWARN\x1B[0m",
error: "\x1B[31mERROR\x1B[0m"
};
// src/defaults.ts
function getDefaultFormattedMessage(args) {
return `\x1B[32m[${args.frameworkName}]\x1B[0m \x1B[33m${args.created}\x1B[0m \x1B[1m[${args.domain}]\x1B[0m${args.name && args.name.length > 0 ? ` \x1B[4m[${args.name}]\x1B[0m ` : " "}${stringByMessageType[args.logLevel.toLowerCase()]} ${args.message}`;
}
__name(getDefaultFormattedMessage, "getDefaultFormattedMessage");
// src/logger.ts
var Logger = class _Logger {
static {
__name(this, "Logger");
}
name = "";
domainName = "";
loggingMessages;
constructor(args, loggingMessages) {
this.domainName = args.domainName || "";
this.name = args.name || "";
this.loggingMessages = loggingMessages;
}
/**
* Retrieve a child logger from the current logger.
*
* @example
* ```ts
* const logger = new Logger({ domainName: 'my-custom-package' });
* const childLogger = logger.getChildLogger('migrations');
* ```
*
* @param name - The name of the child logger.
*
* @returns A new logger instance with the given name.
*/
getChildLogger(name, loggingMessages) {
const concatenatedLoggingMessages = this.loggingMessages && loggingMessages ? {
...this.loggingMessages,
...loggingMessages
} : this.loggingMessages ? this.loggingMessages : loggingMessages;
return new _Logger({
domainName: this.domainName,
name
}, concatenatedLoggingMessages);
}
/**
* If you don't use the `loggingMessages` property in the constructor, you can use this method to add logging
* messages to the logger.
*
* On here you are only able to add logging messages one by one. So you need to call this method for each
* logging message you want to add.
* This will work as a builder pattern so you can append as many logging messages as you want.
*
* @example
* ```ts
* const logger = new Logger({ name: 'my-logger' })
* .appendLogMessage('my-logging-message', {
* category: 'debug',
* handler: (args: { databaseName: string }) => `Hello World! ${args.databasename}`,
* });
*
* logger.logMessage('my-logging-message', { databaseName: 'my-database' });
* ```
*
* @param name - The name of the logging message.
* @param log - The logging function that will be called when the `logMessage` method is called.
*
* @returns - The current logger instance.
*/
appendLogMessage(name, log) {
this.loggingMessages[name] = log;
return this;
}
/**
* This will log the message that was added to the logger using the `appendLogMessage` method or the
* `loggingMessages` property in the constructor.
*
* @example
* ```ts
* const logger = new Logger({ name: 'my-logger' }, {
* 'my-logging-message': {
* category: 'debug',
* handler: (args: { databaseName: string }) => `Hello World! ${args.databasename}`,
* },
* });
*
* logger.logMessage('my-logging-message', { databaseName: 'my-database' });
* ```
*
* @param name - The name of the logging message.
* @param args - The arguments that will be passed to the handler function.
*/
logMessage(name, args) {
if (this.loggingMessages?.[name]) this.#log(this.loggingMessages[name].handler(args), this.loggingMessages[name].category);
}
/**
* This is the main logging method. This will log the message to the console or to a file or a database,
* or even an api.
*
* With this method we can reuse the same logic over and over again on each logging type.
*
* @param message - The message to be logged.
* @param level - The level of the message to be logged.
*
* @private
*/
#log(message, level) {
const data = {
message,
created: (/* @__PURE__ */ new Date()).toISOString(),
domain: this.domainName,
name: this.name,
frameworkName: FRAMEWORK_NAME,
logLevel: level.toUpperCase()
};
const loggers = getLoggersAtLevel(level);
if (!Array.isArray(loggers)) return;
for (const logger of loggers) {
const shouldLog = logger.filter ? logger.filter(data) : true;
if (!shouldLog) continue;
const formattedMessage = logger.formatter ? logger.formatter(data) : getDefaultFormattedMessage(data);
if (Array.isArray(logger.logger)) return logger.logger.forEach((logger2) => logger2.log(formattedMessage));
else return logger.logger.log(formattedMessage);
}
}
log(message) {
this.#log(message, "log");
}
info(message) {
this.#log(message, "info");
}
debug(message) {
this.#log(message, "debug");
}
warn(message) {
this.#log(message, "warn");
}
error(message) {
this.#log(message, "error");
}
};
// src/utils.ts
function removeColorsFormatting(message) {
return message.replace(/\x1b\[\d+m/g, "");
}
__name(removeColorsFormatting, "removeColorsFormatting");
// src/domain.ts
import { domain } from "@palmares/core";
var loggingDomain = domain("@palmares/logging", "", {
load: /* @__PURE__ */ __name(async (settings) => {
if (settings?.logger) {
if (settings.logger instanceof Promise || Array.isArray(settings.logger) === false) {
const logger = settings.logger instanceof Promise ? (await settings.logger).default : settings.logger;
const loggerData = {
logger: new logger()
};
setLoggerAtLevel("debug", loggerData);
setLoggerAtLevel("log", loggerData);
setLoggerAtLevel("info", loggerData);
setLoggerAtLevel("warn", loggerData);
setLoggerAtLevel("error", loggerData);
} else if (Array.isArray(settings.logger)) {
for (const logger of settings.logger) {
const initializedLogger = Array.isArray(logger.logger) ? logger.logger.map((loggerConstructor) => {
console.log(loggerConstructor);
return new loggerConstructor();
}) : new logger.logger();
logger.logger = initializedLogger;
const loggingLevels = Array.isArray(logger.level) ? logger.level : typeof logger.level === "string" ? [
logger.level
] : [
"debug",
"log",
"info",
"warn",
"error"
];
for (const level of loggingLevels) setLoggerAtLevel(level, {
logger: logger.logger
});
}
}
settings.__logger = Logger;
}
}, "load")
});
export {
Logger,
LoggingAdapter,
loggingDomain as default,
loggingAdapter,
loggingDomain,
removeColorsFormatting
};