@natyapp/meta 1.6.6 → 1.7.0

package/dist/useCases/messages/index.d.ts

@@ -1,10 +1,10 @@
-import { MessageEntity } from "../../Entities/messages";
-import { Response } from "../../Errors";
+import { LogsEntity } from "../../entities/Logs";
+import { Either } from "../../errors";
 import { getAllProps, getAllReturn } from "../../types/requestTypes";
 declare class Messages {
-    getSingle: (id: string) => Promise<Response<"", MessageEntity>>;
-    getAll: (props: getAllProps) => Promise<Response<"", getAllReturn<MessageEntity>>>;
-    searchOne: (key: string, value: string) => Promise<Response<"", MessageEntity>>;
+    getSingle: (id: string) => Promise<Either<string, LogsEntity>>;
+    getAll: (props: getAllProps) => Promise<Either<string, getAllReturn<LogsEntity>>>;
+    searchOne: (key: string, value: string) => Promise<Either<string, LogsEntity>>;
 }
 declare const _default: Messages;
 export default _default;

package/dist/useCases/messages/index.js

@@ -4,9 +4,72 @@ const messages_1 = require("../../services/mutations/messages");
 const utils_1 = require("../../utils");
 class Messages {
     constructor() {
-        this.getSingle = (id) => (0, utils_1.Try)(messages_1.messagesMutations.getSingle, id);
-        this.getAll = (props) => (0, utils_1.Try)(messages_1.messagesMutations.getAll, props);
-        this.searchOne = (key, value) => (0, utils_1.Try)(messages_1.messagesMutations.searchOne, key, value);
+        this.getSingle = async (id) => {
+            utils_1.logger.debug("Fetching message", {
+                operation: (0, utils_1.getMethodContext)("Messages", "getSingle"),
+                messageId: id,
+            });
+            const result = await (0, utils_1.Try)(messages_1.messagesMutations.getSingle, id);
+            if (result.isError) {
+                utils_1.logger.error("Failed to fetch message", {
+                    operation: (0, utils_1.getMethodContext)("Messages", "getSingle"),
+                    messageId: id,
+                    error: (0, utils_1.parseError)(result.isError),
+                });
+                return result;
+            }
+            utils_1.logger.info("Message fetched successfully", {
+                operation: (0, utils_1.getMethodContext)("Messages", "getSingle"),
+                messageId: result.isSuccess.id,
+            });
+            return result;
+        };
+        this.getAll = async (props) => {
+            utils_1.logger.debug("Fetching all messages", {
+                operation: (0, utils_1.getMethodContext)("Messages", "getAll"),
+                companyId: props.companyId,
+                limit: props.limit,
+                page: props.page,
+            });
+            const result = await (0, utils_1.Try)(messages_1.messagesMutations.getAll, props);
+            if (result.isError) {
+                utils_1.logger.error("Failed to fetch messages", {
+                    operation: (0, utils_1.getMethodContext)("Messages", "getAll"),
+                    companyId: props.companyId,
+                    error: (0, utils_1.parseError)(result.isError),
+                });
+                return result;
+            }
+            utils_1.logger.info("Messages fetched successfully", {
+                operation: (0, utils_1.getMethodContext)("Messages", "getAll"),
+                companyId: props.companyId,
+                count: result.isSuccess.length,
+            });
+            return result;
+        };
+        this.searchOne = async (key, value) => {
+            utils_1.logger.debug("Searching for message", {
+                operation: (0, utils_1.getMethodContext)("Messages", "searchOne"),
+                searchKey: key,
+                searchValue: key.toLowerCase().includes("phone") || key === "to" || key === "from"
+                    ? (0, utils_1.sanitizePhoneNumber)(value)
+                    : value,
+            });
+            const result = await (0, utils_1.Try)(messages_1.messagesMutations.searchOne, key, value);
+            if (result.isError) {
+                utils_1.logger.error("Message search failed", {
+                    operation: (0, utils_1.getMethodContext)("Messages", "searchOne"),
+                    searchKey: key,
+                    error: (0, utils_1.parseError)(result.isError),
+                });
+                return result;
+            }
+            utils_1.logger.info("Message found", {
+                operation: (0, utils_1.getMethodContext)("Messages", "searchOne"),
+                messageId: result.isSuccess.id,
+            });
+            return result;
+        };
     }
 }
 exports.default = new Messages();

package/dist/useCases/sdk/index.d.ts

@@ -1,11 +1,12 @@
-import { Response } from "../../Errors/ErrorHandling";
-import { ConnectErrors, ConnectProps, ISdk } from "../../interfaces/ISdk";
+import { Either } from "../../errors/Either";
+import { ConnectProps, ISdk } from "../../interfaces/ISdk";
 import Connection from "../connection";
 import Message from "../message";
 import Webhook from "../webhook";
 import Log from "../log";
 import { Express } from "express";
 import { NatyEvents } from "../events/NatyEvents";
+import type { ILogger } from "../../interfaces/ILogger";
 export declare class NatyMeta extends NatyEvents implements ISdk {
     connected: boolean;
     Connection: typeof Connection;
@@ -13,7 +14,10 @@ export declare class NatyMeta extends NatyEvents implements ISdk {
     Webhook: typeof Webhook;
     Log: typeof Log;
     app: Express;
-    constructor(app?: Express);
-    connect({ appToken, pathname, app, }: ConnectProps): Promise<Response<ConnectErrors, boolean>>;
+    constructor(config?: {
+        app?: Express;
+        logger: ILogger;
+    });
+    connect({ appToken, pathname, app, logger, }: ConnectProps): Promise<Either<string, boolean>>;
     initializeRoutes(path?: string): void;
 }

package/dist/useCases/sdk/index.js

@@ -13,18 +13,38 @@ const webhook_1 = __importDefault(require("../webhook"));
 const log_1 = __importDefault(require("../log"));
 const routes_1 = require("../../routes");
 const NatyEvents_1 = require("../events/NatyEvents");
+//import { consoleLogger } from "../../utils/consoleLogger";
+const loggerContext_1 = require("../../utils/loggerContext");
+const utils_1 = require("../../utils");
 class NatyMeta extends NatyEvents_1.NatyEvents {
-    constructor(app) {
-        super();
+    constructor(config) {
+        const logger = (config === null || config === void 0 ? void 0 : config.logger) || utils_1.consoleLogger;
+        super(logger);
         this.connected = false;
-        if (app) {
-            this.app = app;
+        // Set global logger for use in other parts of the SDK
+        (0, loggerContext_1.setGlobalLogger)(logger);
+        this.logger.info("NatyMeta SDK initialized", {
+            operation: (0, utils_1.getMethodContext)("NatyMeta", "constructor"),
+            hasApp: !!(config === null || config === void 0 ? void 0 : config.app),
+            customLogger: !!(config === null || config === void 0 ? void 0 : config.logger),
+        });
+        if (config === null || config === void 0 ? void 0 : config.app) {
+            this.app = config.app;
             this.connect({ appToken: "" });
         }
     }
-    async connect({ appToken, pathname, app, }) {
+    async connect({ appToken, pathname, app, logger, }) {
+        this.logger.info("Connecting to Naty API", {
+            operation: (0, utils_1.getMethodContext)("NatyMeta", "connect"),
+            hasAppToken: !!appToken,
+        });
         if (app)
             this.app = app;
+        // Update logger if provided
+        if (logger) {
+            this.logger = logger;
+            (0, loggerContext_1.setGlobalLogger)(logger);
+        }
         const confirmAppToken = await (0, tryCatch_1.Try)(validations_1.middlewares.confirmAppToken, `${appToken}`);
         // this.emit("connection", {companyId:''});
         if (confirmAppToken.isSuccess) {
@@ -34,15 +54,27 @@ class NatyMeta extends NatyEvents_1.NatyEvents {
             this.Message = message_1.default;
             this.Webhook = webhook_1.default;
             this.Log = log_1.default;
+            this.logger.info("Successfully connected to Naty API", {
+                operation: (0, utils_1.getMethodContext)("NatyMeta", "connect"),
+            });
         }
         else {
             this.connected = false;
+            this.logger.error("Failed to connect to Naty API", {
+                operation: (0, utils_1.getMethodContext)("NatyMeta", "connect"),
+                error: confirmAppToken.isError,
+            });
         }
         this.initializeRoutes(pathname);
         return confirmAppToken;
     }
     initializeRoutes(path) {
-        this.app.use(path || "/", (0, routes_1.principalRoute)(this));
+        const routePath = path || "/";
+        this.logger.debug("Initializing routes", {
+            operation: (0, utils_1.getMethodContext)("NatyMeta", "initializeRoutes"),
+            path: routePath,
+        });
+        this.app.use(routePath, (0, routes_1.principalRoute)(this));
     }
 }
 exports.NatyMeta = NatyMeta;

package/dist/useCases/webhook/index.d.ts

@@ -1,15 +1,15 @@
-import { WebhooksEntity } from "../../Entities/webhooks";
-import { Either } from "../../Errors";
+import { WebhooksEntity } from "../../entities/webhooks";
+import { Either } from "../../errors";
 import { IWebhook } from "../../interfaces";
 import { getAllProps, getAllReturn } from "../../types/requestTypes";
 declare class Webhooks implements IWebhook {
-    getSingle: (id: string) => Promise<Either<"", WebhooksEntity>>;
-    getAll: (props: getAllProps) => Promise<Either<"", getAllReturn<WebhooksEntity>>>;
-    searchOne: (key: string, value: string) => Promise<Either<"", WebhooksEntity>>;
-    insert: (connection: Partial<WebhooksEntity>) => Promise<Either<"", WebhooksEntity>>;
-    update: (id: string, connection: Partial<WebhooksEntity>) => Promise<Either<"", WebhooksEntity>>;
-    updateMany: (webhooks: Partial<WebhooksEntity>[]) => Promise<Either<"", WebhooksEntity[]>>;
-    deleteOne: (id: string) => Promise<Either<"", WebhooksEntity>>;
+    getSingle: (id: string) => Promise<Either<string, WebhooksEntity>>;
+    getAll: (props: getAllProps) => Promise<Either<string, getAllReturn<WebhooksEntity>>>;
+    searchOne: (key: string, value: string) => Promise<Either<string, WebhooksEntity>>;
+    insert: (connection: Partial<WebhooksEntity>) => Promise<Either<string, WebhooksEntity>>;
+    update: (id: string, connection: Partial<WebhooksEntity>) => Promise<Either<string, WebhooksEntity>>;
+    updateMany: (webhooks: Partial<WebhooksEntity>[]) => Promise<Either<string, WebhooksEntity[]>>;
+    deleteOne: (id: string) => Promise<Either<string, WebhooksEntity>>;
 }
 declare const _default: Webhooks;
 export default _default;

package/dist/useCases/webhook/index.js

@@ -4,13 +4,160 @@ const services_1 = require("../../services");
 const utils_1 = require("../../utils");
 class Webhooks {
     constructor() {
-        this.getSingle = (id) => (0, utils_1.Try)(services_1.webhooksMutations.getSingle, id);
-        this.getAll = (props) => (0, utils_1.Try)(services_1.webhooksMutations.getAll, props);
-        this.searchOne = (key, value) => (0, utils_1.Try)(services_1.webhooksMutations.searchOne, key, value);
-        this.insert = (connection) => (0, utils_1.Try)(services_1.webhooksMutations.insert, connection);
-        this.update = (id, connection) => (0, utils_1.Try)(services_1.webhooksMutations.update, id, connection);
-        this.updateMany = (webhooks) => (0, utils_1.Try)(services_1.webhooksMutations.updateMany, webhooks);
-        this.deleteOne = (id) => (0, utils_1.Try)(services_1.webhooksMutations.deleteOne, id);
+        this.getSingle = async (id) => {
+            utils_1.logger.debug("Fetching webhook", {
+                operation: (0, utils_1.getMethodContext)("Webhooks", "getSingle"),
+                webhookId: id,
+            });
+            const result = await (0, utils_1.Try)(services_1.webhooksMutations.getSingle, id);
+            if (result.isError) {
+                utils_1.logger.error("Failed to fetch webhook", {
+                    operation: (0, utils_1.getMethodContext)("Webhooks", "getSingle"),
+                    webhookId: id,
+                    error: (0, utils_1.parseError)(result.isError),
+                });
+                return result;
+            }
+            utils_1.logger.debug("Webhook fetched successfully", {
+                operation: (0, utils_1.getMethodContext)("Webhooks", "getSingle"),
+                webhookId: result.isSuccess.id,
+                companyId: result.isSuccess.companyId,
+            });
+            return result;
+        };
+        this.getAll = async (props) => {
+            utils_1.logger.debug("Fetching all webhooks", {
+                operation: (0, utils_1.getMethodContext)("Webhooks", "getAll"),
+                companyId: props.companyId,
+                limit: props.limit,
+                page: props.page,
+            });
+            const result = await (0, utils_1.Try)(services_1.webhooksMutations.getAll, props);
+            if (result.isError) {
+                utils_1.logger.error("Failed to fetch webhooks", {
+                    operation: (0, utils_1.getMethodContext)("Webhooks", "getAll"),
+                    companyId: props.companyId,
+                    error: (0, utils_1.parseError)(result.isError),
+                });
+                return result;
+            }
+            utils_1.logger.debug("Webhooks fetched successfully", {
+                operation: (0, utils_1.getMethodContext)("Webhooks", "getAll"),
+                companyId: props.companyId,
+                count: result.isSuccess.length,
+            });
+            return result;
+        };
+        this.searchOne = async (key, value) => {
+            utils_1.logger.debug("Searching for webhook", {
+                operation: (0, utils_1.getMethodContext)("Webhooks", "searchOne"),
+                searchKey: key,
+                searchValue: value,
+            });
+            const result = await (0, utils_1.Try)(services_1.webhooksMutations.searchOne, key, value);
+            if (result.isError) {
+                utils_1.logger.error("Webhook search failed", {
+                    operation: (0, utils_1.getMethodContext)("Webhooks", "searchOne"),
+                    searchKey: key,
+                    error: (0, utils_1.parseError)(result.isError),
+                });
+                return result;
+            }
+            utils_1.logger.debug("Webhook found", {
+                operation: (0, utils_1.getMethodContext)("Webhooks", "searchOne"),
+                webhookId: result.isSuccess.id,
+                companyId: result.isSuccess.companyId,
+            });
+            return result;
+        };
+        this.insert = async (connection) => {
+            utils_1.logger.info("Creating new webhook", {
+                operation: (0, utils_1.getMethodContext)("Webhooks", "insert"),
+                companyId: connection.companyId,
+            });
+            const result = await (0, utils_1.Try)(services_1.webhooksMutations.insert, connection);
+            if (result.isError) {
+                utils_1.logger.error("Failed to create webhook", {
+                    operation: (0, utils_1.getMethodContext)("Webhooks", "insert"),
+                    companyId: connection.companyId,
+                    error: (0, utils_1.parseError)(result.isError),
+                });
+                return result;
+            }
+            utils_1.logger.info("Webhook created successfully", {
+                operation: (0, utils_1.getMethodContext)("Webhooks", "insert"),
+                webhookId: result.isSuccess.id,
+                companyId: result.isSuccess.companyId,
+            });
+            return result;
+        };
+        this.update = async (id, connection) => {
+            const updatedFields = Object.keys(connection).filter((key) => key !== "id" && key !== "_id");
+            utils_1.logger.info("Updating webhook", {
+                operation: (0, utils_1.getMethodContext)("Webhooks", "update"),
+                webhookId: id,
+                companyId: connection.companyId,
+                updatedFields,
+            });
+            const result = await (0, utils_1.Try)(services_1.webhooksMutations.update, id, connection);
+            if (result.isError) {
+                utils_1.logger.error("Failed to update webhook", {
+                    operation: (0, utils_1.getMethodContext)("Webhooks", "update"),
+                    webhookId: id,
+                    companyId: connection.companyId,
+                    error: (0, utils_1.parseError)(result.isError),
+                });
+                return result;
+            }
+            utils_1.logger.info("Webhook updated successfully", {
+                operation: (0, utils_1.getMethodContext)("Webhooks", "update"),
+                webhookId: result.isSuccess.id,
+                companyId: result.isSuccess.companyId,
+                updatedFields,
+            });
+            return result;
+        };
+        this.updateMany = async (webhooks) => {
+            utils_1.logger.info("Updating multiple webhooks", {
+                operation: (0, utils_1.getMethodContext)("Webhooks", "updateMany"),
+                count: webhooks.length,
+            });
+            const result = await (0, utils_1.Try)(services_1.webhooksMutations.updateMany, webhooks);
+            if (result.isError) {
+                utils_1.logger.error("Failed to update multiple webhooks", {
+                    operation: (0, utils_1.getMethodContext)("Webhooks", "updateMany"),
+                    count: webhooks.length,
+                    error: (0, utils_1.parseError)(result.isError),
+                });
+                return result;
+            }
+            utils_1.logger.info("Multiple webhooks updated successfully", {
+                operation: (0, utils_1.getMethodContext)("Webhooks", "updateMany"),
+                count: result.isSuccess.length,
+            });
+            return result;
+        };
+        this.deleteOne = async (id) => {
+            utils_1.logger.info("Deleting webhook", {
+                operation: (0, utils_1.getMethodContext)("Webhooks", "deleteOne"),
+                webhookId: id,
+            });
+            const result = await (0, utils_1.Try)(services_1.webhooksMutations.deleteOne, id);
+            if (result.isError) {
+                utils_1.logger.error("Failed to delete webhook", {
+                    operation: (0, utils_1.getMethodContext)("Webhooks", "deleteOne"),
+                    webhookId: id,
+                    error: (0, utils_1.parseError)(result.isError),
+                });
+                return result;
+            }
+            utils_1.logger.info("Webhook deleted successfully", {
+                operation: (0, utils_1.getMethodContext)("Webhooks", "deleteOne"),
+                webhookId: result.isSuccess.id,
+                companyId: result.isSuccess.companyId,
+            });
+            return result;
+        };
     }
 }
 exports.default = new Webhooks();

package/dist/utils/consoleLogger.d.ts

@@ -0,0 +1,20 @@
+import type { ILogger } from "../interfaces/ILogger";
+/**
+ * Default console-based logger implementation
+ *
+ * This logger is used as a fallback when no custom logger is provided.
+ * It formats messages with timestamps and pretty-prints metadata.
+ */
+export declare class ConsoleLogger implements ILogger {
+    private formatTimestamp;
+    private formatMeta;
+    debug(message: string, meta?: Record<string, any>): void;
+    info(message: string, meta?: Record<string, any>): void;
+    warn(message: string, meta?: Record<string, any>): void;
+    error(message: string, meta?: Record<string, any>): void;
+}
+/**
+ * Singleton instance of the console logger
+ * Used as default logger when no custom logger is provided
+ */
+export declare const consoleLogger: ILogger;

package/dist/utils/consoleLogger.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consoleLogger = exports.ConsoleLogger = void 0;
+/**
+ * Default console-based logger implementation
+ *
+ * This logger is used as a fallback when no custom logger is provided.
+ * It formats messages with timestamps and pretty-prints metadata.
+ */
+class ConsoleLogger {
+    formatTimestamp() {
+        return new Date().toISOString();
+    }
+    formatMeta(meta) {
+        if (!meta || Object.keys(meta).length === 0) {
+            return "";
+        }
+        try {
+            return " " + JSON.stringify(meta, null, 2);
+        }
+        catch (error) {
+            return " [Circular or non-serializable metadata]";
+        }
+    }
+    debug(message, meta) {
+        const timestamp = this.formatTimestamp();
+        const formattedMeta = this.formatMeta(meta);
+        console.debug(`[${timestamp}] [DEBUG] ${message}${formattedMeta}`);
+    }
+    info(message, meta) {
+        const timestamp = this.formatTimestamp();
+        const formattedMeta = this.formatMeta(meta);
+        console.log(`[${timestamp}] [INFO] ${message}${formattedMeta}`);
+    }
+    warn(message, meta) {
+        const timestamp = this.formatTimestamp();
+        const formattedMeta = this.formatMeta(meta);
+        console.warn(`[${timestamp}] [WARN] ${message}${formattedMeta}`);
+    }
+    error(message, meta) {
+        const timestamp = this.formatTimestamp();
+        const formattedMeta = this.formatMeta(meta);
+        console.error(`[${timestamp}] [ERROR] ${message}${formattedMeta}`);
+    }
+}
+exports.ConsoleLogger = ConsoleLogger;
+/**
+ * Singleton instance of the console logger
+ * Used as default logger when no custom logger is provided
+ */
+exports.consoleLogger = new ConsoleLogger();

package/dist/utils/index.d.ts

@@ -1 +1,7 @@
 export * from "./tryCatch";
+export * from "./consoleLogger";
+export * from "./loggerContext";
+export * from "./pinoAdapter";
+export * from "./sanitize";
+export * from "./parseError";
+export * from "./methodContext";

package/dist/utils/index.js

@@ -15,3 +15,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./tryCatch"), exports);
+__exportStar(require("./consoleLogger"), exports);
+__exportStar(require("./loggerContext"), exports);
+__exportStar(require("./pinoAdapter"), exports);
+__exportStar(require("./sanitize"), exports);
+__exportStar(require("./parseError"), exports);
+__exportStar(require("./methodContext"), exports);

package/dist/utils/loggerContext.d.ts

@@ -0,0 +1,57 @@
+import type { ILogger } from "../interfaces/ILogger";
+/**
+ * LoggerContext Singleton
+ *
+ * Provides a global logger instance for the entire SDK.
+ * The logger can be set once during SDK initialization and accessed from anywhere.
+ *
+ * @example
+ * ```typescript
+ * // Using the global logger instance
+ * import { logger } from './utils/loggerContext';
+ *
+ * logger.info('Message sent', { to: phoneNumber });
+ * logger.error('Failed to send', { error: err.message });
+ *
+ * // Setting a custom logger
+ * import { setGlobalLogger } from './utils/loggerContext';
+ *
+ * setGlobalLogger(myPinoLogger);
+ * ```
+ */
+declare class LoggerContext implements ILogger {
+    private static instance;
+    private _logger;
+    private constructor();
+    /**
+     * Get the singleton instance
+     */
+    static getInstance(): LoggerContext;
+    /**
+     * Set the global logger instance
+     * This is called during NatyMeta initialization
+     *
+     * @param logger - The logger instance to use globally
+     */
+    setLogger(logger: ILogger): void;
+    /**
+     * Get the current logger instance
+     *
+     * @returns The active logger instance
+     */
+    getLogger(): ILogger;
+    /**
+     * Reset the logger to the default console logger
+     * Useful for testing
+     */
+    reset(): void;
+    debug(message: string, meta?: Record<string, any>): void;
+    info(message: string, meta?: Record<string, any>): void;
+    warn(message: string, meta?: Record<string, any>): void;
+    error(message: string, meta?: Record<string, any>): void;
+}
+export declare const logger: LoggerContext;
+export declare const setGlobalLogger: (loggerInstance: ILogger) => void;
+export declare const getGlobalLogger: () => ILogger;
+export declare const resetGlobalLogger: () => void;
+export {};

package/dist/utils/loggerContext.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetGlobalLogger = exports.getGlobalLogger = exports.setGlobalLogger = exports.logger = void 0;
+const consoleLogger_1 = require("./consoleLogger");
+/**
+ * LoggerContext Singleton
+ *
+ * Provides a global logger instance for the entire SDK.
+ * The logger can be set once during SDK initialization and accessed from anywhere.
+ *
+ * @example
+ * ```typescript
+ * // Using the global logger instance
+ * import { logger } from './utils/loggerContext';
+ *
+ * logger.info('Message sent', { to: phoneNumber });
+ * logger.error('Failed to send', { error: err.message });
+ *
+ * // Setting a custom logger
+ * import { setGlobalLogger } from './utils/loggerContext';
+ *
+ * setGlobalLogger(myPinoLogger);
+ * ```
+ */
+class LoggerContext {
+    constructor() {
+        this._logger = consoleLogger_1.consoleLogger;
+    }
+    /**
+     * Get the singleton instance
+     */
+    static getInstance() {
+        if (!LoggerContext.instance) {
+            LoggerContext.instance = new LoggerContext();
+        }
+        return LoggerContext.instance;
+    }
+    /**
+     * Set the global logger instance
+     * This is called during NatyMeta initialization
+     *
+     * @param logger - The logger instance to use globally
+     */
+    setLogger(logger) {
+        this._logger = logger;
+    }
+    /**
+     * Get the current logger instance
+     *
+     * @returns The active logger instance
+     */
+    getLogger() {
+        return this._logger;
+    }
+    /**
+     * Reset the logger to the default console logger
+     * Useful for testing
+     */
+    reset() {
+        this._logger = consoleLogger_1.consoleLogger;
+    }
+    // ILogger implementation - delegates to internal logger
+    debug(message, meta) {
+        this._logger.debug(message, meta);
+    }
+    info(message, meta) {
+        this._logger.info(message, meta);
+    }
+    warn(message, meta) {
+        this._logger.warn(message, meta);
+    }
+    error(message, meta) {
+        this._logger.error(message, meta);
+    }
+}
+// Export singleton instance
+exports.logger = LoggerContext.getInstance();
+// Export legacy functions for backward compatibility
+const setGlobalLogger = (loggerInstance) => {
+    exports.logger.setLogger(loggerInstance);
+};
+exports.setGlobalLogger = setGlobalLogger;
+const getGlobalLogger = () => {
+    return exports.logger.getLogger();
+};
+exports.getGlobalLogger = getGlobalLogger;
+const resetGlobalLogger = () => {
+    exports.logger.reset();
+};
+exports.resetGlobalLogger = resetGlobalLogger;

package/dist/utils/methodContext.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Utility for generating consistent method context strings for logging.
+ *
+ * @module methodContext
+ * @example
+ * ```typescript
+ * import { getMethodContext } from '../utils';
+ *
+ * logger.info("Operation started", {
+ *   operation: getMethodContext("WhatsappResponse", "send_text_message"),
+ *   // ... other metadata
+ * });
+ * // Logs: operation: "WhatsappResponse.send_text_message"
+ * ```
+ */
+/**
+ * Generates a standardized method context string for logging.
+ *
+ * @param className - The name of the class or module (e.g., "WhatsappResponse", "Webhooks")
+ * @param methodName - The name of the method (e.g., "send_text_message", "getSingle")
+ * @returns A formatted string in the format "ClassName.methodName"
+ *
+ * @throws {Error} If className or methodName is empty or whitespace-only
+ *
+ * @example
+ * ```typescript
+ * getMethodContext("WhatsappResponse", "send_text_message")
+ * // Returns: "WhatsappResponse.send_text_message"
+ *
+ * getMethodContext("Webhooks", "getSingle")
+ * // Returns: "Webhooks.getSingle"
+ * ```
+ */
+export declare function getMethodContext(className: string, methodName: string): string;