semola 0.5.3 → 0.5.4

package/dist/lib/logging/index.d.mts

@@ -1,7 +1,108 @@
-import { LogDataType, LogLevel, LogLevelType, LogMessageType } from "../../logging/core/types.mjs";
-import { DateFmtFnType } from "../../logging/formatter/types.mjs";
-import { BaseFormatter, Formatter, JSONFormatter, dmyFormat, isoDateFormat, isoDateTimeFormat, mdyFormat } from "../../logging/formatter/index.mjs";
-import { FileProviderOptions, ProviderOptions, SizeBasedPolicyType, TimeBasedPolicyType } from "../../logging/provider/types.mjs";
-import { ConsoleProvider, FileProvider, LoggerProvider } from "../../logging/provider/index.mjs";
-import { AbstractLogger, Logger } from "../../logging/core/index.mjs";
+//#region src/lib/logging/core/types.d.ts
+declare const LogLevel: {
+  readonly debug: 10;
+  readonly info: 20;
+  readonly warning: 30;
+  readonly error: 40;
+  readonly critical: 50;
+};
+type LogLevelType = keyof typeof LogLevel;
+type LogMessageType = string | object | number | boolean;
+type LogDataType = {
+  prefix: string;
+  level: LogLevelType;
+  msg: LogMessageType;
+  row?: string;
+  column?: string;
+  fileName?: string;
+  method?: string;
+};
+//#endregion
+//#region src/lib/logging/formatter/types.d.ts
+type DateFmtFnType = () => string;
+//#endregion
+//#region src/lib/logging/formatter/index.d.ts
+declare abstract class Formatter {
+  protected dateFmt: DateFmtFnType;
+  constructor(dateFmt: DateFmtFnType);
+  abstract format(logData: LogDataType): string;
+  abstract formatError(logData: LogDataType, error: Error): string;
+}
+declare class BaseFormatter extends Formatter {
+  constructor(dateFmt?: DateFmtFnType);
+  format(logData: LogDataType): string;
+  formatError(logData: LogDataType, error: Error): string;
+}
+declare class JSONFormatter extends Formatter {
+  constructor(dateFmt?: DateFmtFnType);
+  format(logData: LogDataType): string;
+  formatError(logData: LogDataType, error: Error): string;
+}
+declare function isoDateTimeFormat(): string;
+declare function isoDateFormat(): string;
+declare function dmyFormat(): string;
+declare function mdyFormat(): string;
+//#endregion
+//#region src/lib/logging/provider/types.d.ts
+type ProviderOptions = {
+  level?: LogLevelType;
+  formatter?: Formatter;
+};
+interface SizeBasedPolicyType {
+  type: "size";
+  maxSize?: number;
+}
+interface TimeBasedPolicyType {
+  type: "time";
+  instant: "hour" | "day" | "week" | "month";
+  duration: number;
+}
+type FileProviderOptions = ProviderOptions & {
+  policy?: SizeBasedPolicyType | TimeBasedPolicyType;
+};
+//#endregion
+//#region src/lib/logging/provider/index.d.ts
+declare abstract class LoggerProvider {
+  protected options: ProviderOptions;
+  constructor(options?: ProviderOptions);
+  abstract execute(data: LogDataType): void;
+  getLogLevel(): number;
+}
+declare class FileProvider extends LoggerProvider {
+  private readonly filePath;
+  private counter;
+  private file;
+  private policy?;
+  constructor(file: string, options?: FileProviderOptions);
+  execute(data: LogDataType): void;
+  private canRollFile;
+  private getFileSize;
+  private isJSONFile;
+  private createNewFileName;
+}
+declare class ConsoleProvider extends LoggerProvider {
+  execute(data: LogDataType): void;
+}
+//#endregion
+//#region src/lib/logging/core/index.d.ts
+declare abstract class AbstractLogger {
+  protected providers: LoggerProvider[];
+  protected prefix: string;
+  constructor(prefix: string, providers: [LoggerProvider, ...LoggerProvider[]]);
+  abstract debug(msg: LogMessageType): void;
+  abstract info(msg: LogMessageType): void;
+  abstract warning(msg: LogMessageType): void;
+  abstract error(msg: LogMessageType): void;
+  abstract critical(msg: LogMessageType): void;
+  protected createLogData(level: LogLevelType, msg: LogMessageType, prefix: string): LogDataType;
+}
+declare class Logger extends AbstractLogger {
+  debug(msg: LogMessageType): void;
+  info(msg: LogMessageType): void;
+  warning(msg: LogMessageType): void;
+  error(msg: LogMessageType): void;
+  critical(msg: LogMessageType): void;
+  private run;
+}
+//#endregion
 export { AbstractLogger, BaseFormatter, ConsoleProvider, type DateFmtFnType, FileProvider, type FileProviderOptions, Formatter, JSONFormatter, type LogDataType, LogLevel, type LogLevelType, type LogMessageType, Logger, LoggerProvider, type ProviderOptions, type SizeBasedPolicyType, type TimeBasedPolicyType, dmyFormat, isoDateFormat, isoDateTimeFormat, mdyFormat };

package/dist/lib/logging/index.mjs

@@ -1,5 +1,374 @@
-import { BaseFormatter, Formatter, JSONFormatter, dmyFormat, isoDateFormat, isoDateTimeFormat, mdyFormat } from "../../logging/formatter/index.mjs";
-import { AbstractLogger, Logger } from "../../logging/core/index.mjs";
-import { LogLevel } from "../../logging/core/types.mjs";
-import { ConsoleProvider, FileProvider, LoggerProvider } from "../../logging/provider/index.mjs";
+import { mightThrowSync } from "../errors/index.mjs";
+import { basename, dirname, extname, join } from "node:path";
+import { appendFileSync, existsSync, mkdirSync, statSync } from "node:fs";
+//#region src/lib/logging/formatter/index.ts
+var Formatter = class {
+	dateFmt;
+	constructor(dateFmt) {
+		this.dateFmt = dateFmt;
+	}
+};
+var BaseFormatter = class extends Formatter {
+	constructor(dateFmt = isoDateTimeFormat) {
+		super(dateFmt);
+	}
+	format(logData) {
+		let { prefix, level, msg, fileName, row, column, method } = logData;
+		const timestamp = this.dateFmt();
+		const levelType = level.toUpperCase();
+		if (typeof msg === "object") msg = JSON.stringify(msg);
+		const fileData = `${prefix}/${fileName}:${row}:${column}`;
+		let header = `[${levelType}]`;
+		if (method) header = `${header}\t[${method}]\t[${fileData}]`;
+		else header = `${header}\t[${fileData}]`;
+		return `${timestamp}  ${header} : ${msg}`;
+	}
+	formatError(logData, error) {
+		const { prefix, fileName, row, column, method } = logData;
+		const timestamp = this.dateFmt();
+		const fileData = `${prefix}/${fileName}:${row}:${column}`;
+		let errorMsg = `Error name="${error.name}" Error message="${error.message}"`;
+		let header = "[ERROR]";
+		if (method) header = `${header}\t[${method}]\t[${fileData}]`;
+		else header = `${header}\t[${fileData}]`;
+		if (error.cause) errorMsg = `${errorMsg}\n\tError cause="${error.cause}"`;
+		if (error.stack) errorMsg = `${errorMsg}\n\tStack trace="${error.stack}"`;
+		return `${timestamp}  ${header} : ${errorMsg}`;
+	}
+};
+var JSONFormatter = class extends Formatter {
+	constructor(dateFmt = isoDateTimeFormat) {
+		super(dateFmt);
+	}
+	format(logData) {
+		const { prefix, level, msg, fileName, row, column, method } = logData;
+		const timestamp = this.dateFmt();
+		const levelType = level.toUpperCase();
+		let position = {};
+		if (method) position = { method };
+		position = {
+			...position,
+			fileName,
+			row,
+			column
+		};
+		return JSON.stringify({
+			timestamp,
+			level: levelType,
+			prefix,
+			position,
+			msg
+		});
+	}
+	formatError(logData, error) {
+		const { prefix, fileName, row, column, method } = logData;
+		const timestamp = this.dateFmt();
+		let errorMsg = {
+			errorName: error.name,
+			errorMessage: error.message
+		};
+		let position = {};
+		if (method) position = { method };
+		position = {
+			...position,
+			fileName,
+			row,
+			column
+		};
+		if (error.cause) errorMsg = {
+			...errorMsg,
+			errorCause: error.cause
+		};
+		if (error.stack) errorMsg = {
+			...errorMsg,
+			stackTrace: error.stack
+		};
+		return JSON.stringify({
+			timestamp,
+			level: "ERROR",
+			prefix,
+			position,
+			msg: errorMsg
+		});
+	}
+};
+function isoDateTimeFormat() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+function isoDateFormat() {
+	const date = isoDateTimeFormat().split("T")[0];
+	if (!date) return "";
+	return date;
+}
+function dmyFormat() {
+	const isoDate = isoDateFormat();
+	if (!isoDate) return "";
+	const info = isoDate.split("-");
+	return `${info[2]}-${info[1]}-${info[0]}`;
+}
+function mdyFormat() {
+	const isoDate = isoDateFormat();
+	if (!isoDate) return "";
+	const info = isoDate.split("-");
+	return `${info[1]}-${info[2]}-${info[0]}`;
+}
+//#endregion
+//#region src/lib/logging/core/index.ts
+const PROVIDER_OPTION_DEFAULT = {
+	formatter: new BaseFormatter(),
+	level: "debug"
+};
+const STACK_FRAME_IDX = 1;
+var StackData = class {
+	stack = [];
+	constructor(fn) {
+		const oldStackTrace = Error.prepareStackTrace;
+		const [stackTraceError] = mightThrowSync(() => {
+			Error.prepareStackTrace = (_, stack) => {
+				return stack.map((callSite) => {
+					return {
+						fileName: callSite.getFileName(),
+						column: callSite.getColumnNumber(),
+						row: callSite.getLineNumber(),
+						functionCall: callSite.getFunctionName()
+					};
+				});
+			};
+			Error.captureStackTrace(this, fn);
+			this.stack;
+		});
+		Error.prepareStackTrace = oldStackTrace;
+		if (stackTraceError) this.stack = [];
+	}
+	retrieveFrame() {
+		if (this.stack.length === 0) return void 0;
+		return this.stack[STACK_FRAME_IDX];
+	}
+};
+var AbstractLogger = class {
+	providers;
+	prefix;
+	constructor(prefix, providers) {
+		this.prefix = prefix;
+		this.providers = providers;
+	}
+	createLogData(level, msg, prefix) {
+		const logCall = new StackData(this.createLogData).retrieveFrame();
+		let logData = {
+			level,
+			msg,
+			prefix
+		};
+		if (!logCall) return logData;
+		const { column, fileName, functionCall, row } = logCall;
+		if (fileName) logData = {
+			...logData,
+			fileName: basename(fileName)
+		};
+		if (column) logData = {
+			...logData,
+			column: String(column)
+		};
+		if (row) logData = {
+			...logData,
+			row: String(row)
+		};
+		if (functionCall) logData = {
+			...logData,
+			method: functionCall
+		};
+		return logData;
+	}
+};
+var Logger = class extends AbstractLogger {
+	debug(msg) {
+		const data = this.createLogData("debug", msg, this.prefix);
+		this.run(data);
+	}
+	info(msg) {
+		const data = this.createLogData("info", msg, this.prefix);
+		this.run(data);
+	}
+	warning(msg) {
+		const data = this.createLogData("warning", msg, this.prefix);
+		this.run(data);
+	}
+	error(msg) {
+		const data = this.createLogData("error", msg, this.prefix);
+		this.run(data);
+	}
+	critical(msg) {
+		const data = this.createLogData("critical", msg, this.prefix);
+		this.run(data);
+	}
+	run(data) {
+		for (let i = 0; i < this.providers.length; i++) this.providers[i]?.execute(data);
+	}
+};
+//#endregion
+//#region src/lib/logging/core/types.ts
+const LogLevel = {
+	debug: 10,
+	info: 20,
+	warning: 30,
+	error: 40,
+	critical: 50
+};
+//#endregion
+//#region src/lib/logging/provider/index.ts
+const DEFAULT_MAX_SIZE = 4 * 1024;
+const DurationUnit = {
+	hour: 1e3 * 60 * 60,
+	day: 1e3 * 60 * 60 * 24,
+	week: 1e3 * 60 * 60 * 24 * 7,
+	month: 1e3 * 60 * 60 * 24 * 7 * 4.345
+};
+var LoggerProvider = class {
+	options;
+	constructor(options = PROVIDER_OPTION_DEFAULT) {
+		this.options = {
+			...PROVIDER_OPTION_DEFAULT,
+			...options
+		};
+	}
+	getLogLevel() {
+		if (!this.options.level) return LogLevel.debug;
+		return LogLevel[this.options.level];
+	}
+};
+const FILE_PROVIDER_OPTION_DEFAULT = {
+	...PROVIDER_OPTION_DEFAULT,
+	policy: { type: "size" }
+};
+var FileProvider = class extends LoggerProvider {
+	filePath;
+	counter;
+	file;
+	policy;
+	constructor(file, options = FILE_PROVIDER_OPTION_DEFAULT) {
+		super({
+			formatter: options.formatter ?? PROVIDER_OPTION_DEFAULT.formatter,
+			level: options.level ?? PROVIDER_OPTION_DEFAULT.level
+		});
+		this.policy = options.policy ?? FILE_PROVIDER_OPTION_DEFAULT.policy;
+		this.filePath = file;
+		this.counter = 0;
+		this.file = this.createNewFileName();
+	}
+	execute(data) {
+		if (this.getLogLevel() > LogLevel[data.level]) return;
+		const [error, formattedMessage] = mightThrowSync(() => {
+			if (this.isJSONFile()) return JSON.stringify({
+				timestamp: isoDateTimeFormat(),
+				level: data.level,
+				message: data.msg
+			});
+			const { formatter } = this.options;
+			return formatter?.format(data) ?? "";
+		});
+		const [fsError] = mightThrowSync(() => {
+			if (error && error instanceof Error) {
+				const { formatter } = this.options;
+				const errorMsg = formatter?.formatError(data, error);
+				appendFileSync(this.file, `${errorMsg}\n`);
+			}
+			if (this.canRollFile()) {
+				this.counter += 1;
+				this.file = this.createNewFileName();
+			}
+			if (error || !formattedMessage) return;
+			appendFileSync(this.file, `${formattedMessage}\n`);
+		});
+		if (fsError && fsError instanceof Error) throw fsError;
+	}
+	canRollFile() {
+		if (!this.policy) return false;
+		switch (this.policy.type) {
+			case "size":
+				if (this.policy.maxSize) return this.getFileSize() >= this.policy.maxSize;
+				return this.getFileSize() >= DEFAULT_MAX_SIZE;
+			case "time": {
+				if (!existsSync(this.file)) return false;
+				const { duration, instant } = this.policy;
+				const { birthtime } = statSync(this.file);
+				const creationTimeMs = birthtime.getTime();
+				const currenTimeMs = Date.now();
+				const diffMs = currenTimeMs - creationTimeMs;
+				switch (instant) {
+					case "hour": return Math.floor(diffMs / DurationUnit.hour) >= duration;
+					case "day": return Math.floor(diffMs / DurationUnit.day) >= duration;
+					case "week": return Math.floor(diffMs / DurationUnit.week) >= duration;
+					case "month": {
+						const currentDate = new Date(currenTimeMs);
+						const monthsDiff = (currentDate.getFullYear() - birthtime.getFullYear()) * 12 + (currentDate.getMonth() - birthtime.getMonth());
+						return (currentDate.getDate() >= birthtime.getDate() ? monthsDiff : monthsDiff - 1) >= duration;
+					}
+				}
+			}
+		}
+	}
+	getFileSize() {
+		if (!existsSync(this.file)) return 0;
+		const [statError, size] = mightThrowSync(() => {
+			const { size } = statSync(this.file);
+			return size;
+		});
+		if (statError && statError instanceof Error) return 0;
+		if (!size) return 0;
+		return size;
+	}
+	isJSONFile() {
+		return extname(this.filePath) === ".json";
+	}
+	createNewFileName() {
+		const fileName = basename(this.filePath);
+		const directory = dirname(this.filePath);
+		if (!existsSync(directory)) mkdirSync(directory, { recursive: true });
+		const fileInfo = fileName.split(".");
+		const extension = fileInfo.pop();
+		return join(directory, [
+			...fileInfo,
+			this.counter,
+			extension
+		].join("."));
+	}
+};
+var ConsoleProvider = class extends LoggerProvider {
+	execute(data) {
+		const level = this.getLogLevel();
+		const userLevel = LogLevel[data.level];
+		if (level > userLevel) return;
+		const [error, formattedMessage] = mightThrowSync(() => {
+			const { formatter } = this.options;
+			return formatter?.format(data) ?? "";
+		});
+		if (error && error instanceof Error) {
+			const { formatter } = this.options;
+			console.error(formatter?.formatError(data, error));
+			return;
+		}
+		if (!formattedMessage) return;
+		switch (userLevel) {
+			case LogLevel.debug:
+				console.debug(formattedMessage);
+				break;
+			case LogLevel.info:
+				console.info(formattedMessage);
+				break;
+			case LogLevel.warning:
+				console.warn(formattedMessage);
+				break;
+			case LogLevel.error:
+				console.error(formattedMessage);
+				break;
+			case LogLevel.critical:
+				console.error(formattedMessage);
+				break;
+			default:
+				console.debug(formattedMessage);
+				break;
+		}
+	}
+};
+//#endregion
 export { AbstractLogger, BaseFormatter, ConsoleProvider, FileProvider, Formatter, JSONFormatter, LogLevel, Logger, LoggerProvider, dmyFormat, isoDateFormat, isoDateTimeFormat, mdyFormat };