@natyapp/meta 1.6.6 → 1.7.0

package/dist/elements/textTemplate.js

@@ -2,17 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TextTemplate = void 0;
 class TextTemplate {
-    constructor({ template, language, to }) {
+    constructor({ template, language, to, bodyParameters }) {
         this.messaging_product = "whatsapp";
         this.recipient_type = "individual";
         this.to = to;
         this.type = "template";
-        this.template = {
-            name: template,
-            language: {
+        const components = [];
+        if (bodyParameters && bodyParameters.length > 0) {
+            components.push({
+                type: "body",
+                parameters: bodyParameters.map(param => ({
+                    type: param.type,
+                    text: param.text
+                }))
+            });
+        }
+        this.template = Object.assign({ name: template, language: {
                 code: language,
-            },
-        };
+            } }, (components.length > 0 && { components }));
     }
 }
 exports.TextTemplate = TextTemplate;

package/dist/index.d.ts

@@ -3,6 +3,11 @@ import { WhatsappResponse } from "./useCases/message/whatsappResponse";
 import { Button as CadastroIncorporado } from "./ui/Button";
 import * as interfaces from "./interfaces";
 import * as types from "./types";
-import * as entities from "./Entities";
+import * as entities from "./entities";
 import * as elements from "./elements";
-export { NatyMeta as default, WhatsappResponse, entities, elements, Connection, Message, Webhook, Log, interfaces, types, CadastroIncorporado, };
+import * as utils from "./utils";
+export type { ILogger, LogLevel } from "./interfaces/ILogger";
+export { consoleLogger } from "./utils/consoleLogger";
+export { createPinoAdapter } from "./utils/pinoAdapter";
+export { logger, setGlobalLogger } from "./utils/loggerContext";
+export { NatyMeta as default, WhatsappResponse, entities, elements, Connection, Message, Webhook, Log, interfaces, types, utils, CadastroIncorporado, };

package/dist/index.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CadastroIncorporado = exports.types = exports.interfaces = exports.Log = exports.Webhook = exports.Message = exports.Connection = exports.elements = exports.entities = exports.WhatsappResponse = exports.default = void 0;
+exports.CadastroIncorporado = exports.utils = exports.types = exports.interfaces = exports.Log = exports.Webhook = exports.Message = exports.Connection = exports.elements = exports.entities = exports.WhatsappResponse = exports.default = exports.setGlobalLogger = exports.logger = exports.createPinoAdapter = exports.consoleLogger = void 0;
 const useCases_1 = require("./useCases");
 Object.defineProperty(exports, "default", { enumerable: true, get: function () { return useCases_1.NatyMeta; } });
 Object.defineProperty(exports, "Log", { enumerable: true, get: function () { return useCases_1.Log; } });
@@ -38,7 +38,16 @@ const interfaces = __importStar(require("./interfaces"));
 exports.interfaces = interfaces;
 const types = __importStar(require("./types"));
 exports.types = types;
-const entities = __importStar(require("./Entities"));
+const entities = __importStar(require("./entities"));
 exports.entities = entities;
 const elements = __importStar(require("./elements"));
 exports.elements = elements;
+const utils = __importStar(require("./utils"));
+exports.utils = utils;
+var consoleLogger_1 = require("./utils/consoleLogger");
+Object.defineProperty(exports, "consoleLogger", { enumerable: true, get: function () { return consoleLogger_1.consoleLogger; } });
+var pinoAdapter_1 = require("./utils/pinoAdapter");
+Object.defineProperty(exports, "createPinoAdapter", { enumerable: true, get: function () { return pinoAdapter_1.createPinoAdapter; } });
+var loggerContext_1 = require("./utils/loggerContext");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return loggerContext_1.logger; } });
+Object.defineProperty(exports, "setGlobalLogger", { enumerable: true, get: function () { return loggerContext_1.setGlobalLogger; } });

package/dist/interfaces/IConnection.d.ts

@@ -1,5 +1,5 @@
-import { ConnectionEntity } from "../Entities/connection";
-import { Either } from "../Errors";
+import { ConnectionEntity } from "../entities/connection";
+import { Either } from "../errors";
 import { getAllProps, getAllReturn } from "../types/requestTypes";
 export interface IConnection {
     insert(connection: Partial<ConnectionEntity>): Promise<Either<connectionErrors, ConnectionEntity>>;

package/dist/interfaces/ILog.d.ts

@@ -1,5 +1,5 @@
-import { LogsEntity } from "../Entities/Logs";
-import { Either } from "../Errors";
+import { LogsEntity } from "../entities/Logs";
+import { Either } from "../errors";
 import { getAllProps, getAllReturn } from "../types/requestTypes";
 export interface ILog {
     getSingle(key: string): Promise<Either<logErrors, LogsEntity>>;

package/dist/interfaces/ILogger.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Logger interface for the SDK
+ *
+ * Compatible with popular loggers like Pino, Winston, Bunyan, and console.
+ * Provides separate methods for each log level for better developer experience.
+ *
+ * @example
+ * ```typescript
+ * // Using with Pino
+ * import pino from 'pino';
+ * import { setGlobalLogger } from '@natyapp/meta';
+ *
+ * const pinoLogger = pino({ level: 'info' });
+ * setGlobalLogger({
+ *   debug: (msg, meta) => pinoLogger.debug(meta, msg),
+ *   info: (msg, meta) => pinoLogger.info(meta, msg),
+ *   warn: (msg, meta) => pinoLogger.warn(meta, msg),
+ *   error: (msg, meta) => pinoLogger.error(meta, msg),
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Custom logger implementation
+ * const customLogger: ILogger = {
+ *   debug: (message, meta) => myService.log('debug', message, meta),
+ *   info: (message, meta) => myService.log('info', message, meta),
+ *   warn: (message, meta) => myService.log('warn', message, meta),
+ *   error: (message, meta) => myService.log('error', message, meta),
+ * };
+ * ```
+ */
+export interface ILogger {
+    /**
+     * Log debug-level message (verbose technical details)
+     * @param message - The log message
+     * @param meta - Optional metadata object
+     */
+    debug(message: string, meta?: Record<string, any>): void;
+    /**
+     * Log info-level message (general informational messages)
+     * @param message - The log message
+     * @param meta - Optional metadata object
+     */
+    info(message: string, meta?: Record<string, any>): void;
+    /**
+     * Log warn-level message (warning conditions)
+     * @param message - The log message
+     * @param meta - Optional metadata object
+     */
+    warn(message: string, meta?: Record<string, any>): void;
+    /**
+     * Log error-level message (error conditions)
+     * @param message - The log message
+     * @param meta - Optional metadata object
+     */
+    error(message: string, meta?: Record<string, any>): void;
+}
+/**
+ * @deprecated Use ILogger interface methods directly (debug, info, warn, error)
+ */
+export type LogLevel = "debug" | "info" | "warn" | "error";

package/dist/interfaces/ILogger.js

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

package/dist/interfaces/ISdk.d.ts

@@ -1,8 +1,9 @@
-import { Response } from "../Errors/ErrorHandling";
+import { Either } from "../errors/Either";
 import { Connection, Log, Message, Webhook } from "../useCases";
 import { Express } from "express";
+import { ILogger } from "./ILogger";
 export interface ISdk {
-    connect({ appToken, }: ConnectProps): Promise<Response<ConnectErrors, boolean>>;
+    connect({ appToken }: ConnectProps): Promise<Either<string, boolean>>;
     Connection: typeof Connection;
     Message: typeof Message;
     Webhook: typeof Webhook;
@@ -12,5 +13,6 @@ export type ConnectProps = {
     appToken: string;
     pathname?: string;
     app?: Express;
+    logger?: ILogger;
 };
 export type ConnectErrors = "AppToken inválido";

package/dist/interfaces/IWebhook.d.ts

@@ -1,5 +1,5 @@
-import { WebhooksEntity } from "../Entities/webhooks";
-import { Either } from "../Errors";
+import { WebhooksEntity } from "../entities/webhooks";
+import { Either } from "../errors";
 import { getAllProps, getAllReturn } from "../types/requestTypes";
 export interface IWebhook {
     insert(webhook: Partial<WebhooksEntity>): Promise<Either<webhookErrors, WebhooksEntity>>;

package/dist/interfaces/index.d.ts

@@ -3,3 +3,4 @@ export * from "./IWebhook";
 export * from "./IMessage";
 export * from "./ILog";
 export * from "./ISdk";
+export * from "./ILogger";

package/dist/interfaces/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./IWebhook"), exports);
 __exportStar(require("./IMessage"), exports);
 __exportStar(require("./ILog"), exports);
 __exportStar(require("./ISdk"), exports);
+__exportStar(require("./ILogger"), exports);

package/dist/queue/messageQueue.d.ts

@@ -1,4 +1,4 @@
-import { WhatsappMessage } from "../Entities/whatsappMessage";
+import { WhatsappMessage } from "../entities/whatsappMessage";
 export declare class MessageQueue {
     private queueItems;
     constructor();

package/dist/queue/messageQueue.js

@@ -1,20 +1,65 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MessageQueue = void 0;
+const loggerContext_1 = require("../utils/loggerContext");
+const utils_1 = require("../utils");
 class MessageQueue {
     constructor() {
         this.queueItems = {};
     }
     addQueueItemForTopic(queueItem, topic) {
+        var _a;
+        const queueSizeBefore = ((_a = this.queueItems[topic]) === null || _a === void 0 ? void 0 : _a.length) || 0;
         if (this.queueItems[topic] === undefined) {
             this.queueItems[topic] = [queueItem];
         }
         else {
             this.queueItems[topic].push(queueItem);
         }
+        const queueSizeAfter = this.queueItems[topic].length;
+        loggerContext_1.logger.info("Adding item to queue", {
+            operation: (0, utils_1.getMethodContext)("MessageQueue", "addQueueItemForTopic"),
+            topic,
+            itemId: queueItem.id,
+            queueSize: queueSizeAfter,
+        });
+        loggerContext_1.logger.debug("Queue state after add", {
+            operation: (0, utils_1.getMethodContext)("MessageQueue", "addQueueItemForTopic"),
+            topic,
+            totalItems: queueSizeAfter,
+            addedItems: queueSizeAfter - queueSizeBefore,
+        });
     }
     processSingleItemForQueueTopic(topic, itemId) {
+        var _a, _b, _c;
+        const startTime = Date.now();
+        const queueSizeBefore = ((_a = this.queueItems[topic]) === null || _a === void 0 ? void 0 : _a.length) || 0;
+        const item = (_b = this.queueItems[topic]) === null || _b === void 0 ? void 0 : _b.find((i) => i.id === itemId);
+        if (!item) {
+            loggerContext_1.logger.warn("Queue item not found for processing", {
+                operation: (0, utils_1.getMethodContext)("MessageQueue", "processSingleItemForQueueTopic"),
+                topic,
+                itemId,
+                queueSize: queueSizeBefore,
+            });
+            return;
+        }
+        loggerContext_1.logger.info("Processing queue item", {
+            operation: (0, utils_1.getMethodContext)("MessageQueue", "processSingleItemForQueueTopic"),
+            topic,
+            itemId,
+            queueSize: queueSizeBefore,
+        });
         this.queueItems[topic] = this.queueItems[topic].filter((item) => item.id !== itemId);
+        const duration = Date.now() - startTime;
+        const queueSizeAfter = ((_c = this.queueItems[topic]) === null || _c === void 0 ? void 0 : _c.length) || 0;
+        loggerContext_1.logger.debug("Queue item processed successfully", {
+            operation: (0, utils_1.getMethodContext)("MessageQueue", "processSingleItemForQueueTopic"),
+            topic,
+            itemId,
+            duration,
+            remainingItems: queueSizeAfter,
+        });
     }
 }
 exports.MessageQueue = MessageQueue;

package/dist/routes/webhooks/methods/connection.js

@@ -4,6 +4,9 @@ exports.connectionRouter = void 0;
 const express_1 = require("express");
 const whatsappResponse_1 = require("../../../useCases/message/whatsappResponse");
 const services_1 = require("../../../services");
+const loggerContext_1 = require("../../../utils/loggerContext");
+const parseError_1 = require("../../../utils/parseError");
+const utils_1 = require("../../../utils");
 const connectionRouter = (naty) => {
     const router = (0, express_1.Router)();
     router.post("/", async (req, res) => {
@@ -17,32 +20,96 @@ const connectionRouter = (naty) => {
         if (message === "confirm_connection") {
             try {
                 const connectionId = (_a = (data["hub.verify_token"] || data["verify_token"])) === null || _a === void 0 ? void 0 : _a.split("/")[0];
+                loggerContext_1.logger.info("Webhook connection confirmation", {
+                    operation: (0, utils_1.getMethodContext)("WebhookHandler", "connection"),
+                    companyId,
+                    connectionId,
+                });
                 const getConnections = await services_1.connectionMutations.getAll({
                     page: 0,
                     size: 1000,
                 });
-                if (getConnections.isError)
-                    throw new Error("Não foi possível encontrar a instância");
+                if (getConnections.isError) {
+                    loggerContext_1.logger.error("Connection webhook: Failed to fetch connections", {
+                        operation: (0, utils_1.getMethodContext)("WebhookHandler", "connection"),
+                        companyId,
+                        phoneNumberId: data.phone_number_id,
+                        stage: "fetching_connections",
+                        error: (0, parseError_1.parseError)(getConnections.isError),
+                    });
+                    naty.emit("error", getConnections.isError);
+                    return res.status(500).json({
+                        error: "Não foi possível encontrar a instância"
+                    });
+                }
                 const connectionInfo = (_b = getConnections.isSuccess) === null || _b === void 0 ? void 0 : _b.find((item) => item._id === connectionId);
-                if (!connectionInfo)
-                    throw new Error("Não foi possível encontrar Connection");
+                if (!connectionInfo) {
+                    loggerContext_1.logger.error("Connection webhook: Connection not found", {
+                        operation: (0, utils_1.getMethodContext)("WebhookHandler", "connection"),
+                        companyId,
+                        connectionId,
+                        stage: "finding_connection",
+                    });
+                    return res.status(404).json({
+                        error: "Não foi possível encontrar Connection"
+                    });
+                }
                 dataReturn.connection = connectionInfo;
                 const whatsAppResponse = new whatsappResponse_1.WhatsappResponse(companyId, connectionInfo.phoneNumberId);
-                const accountInfo = await whatsAppResponse.get_account_info();
-                if (!accountInfo)
-                    throw new Error("Não foi possível encontrar Account");
+                const accountInfoResult = await whatsAppResponse.get_account_info();
+                if (accountInfoResult.isError) {
+                    loggerContext_1.logger.error("Connection webhook: Account info not found", {
+                        operation: (0, utils_1.getMethodContext)("WebhookHandler", "connection"),
+                        companyId,
+                        connectionId,
+                        phoneNumberId: connectionInfo.phoneNumberId,
+                        stage: "fetching_account_info",
+                        error: (0, parseError_1.parseError)(accountInfoResult.isError),
+                    });
+                    naty.emit("error", accountInfoResult.isError);
+                    return res.status(500).json({
+                        error: "Não foi possível encontrar Account"
+                    });
+                }
+                const accountInfo = accountInfoResult.isSuccess;
+                if (!accountInfo) {
+                    loggerContext_1.logger.error("Connection webhook: Account info undefined", {
+                        operation: (0, utils_1.getMethodContext)("WebhookHandler", "connection"),
+                        companyId,
+                        connectionId,
+                    });
+                    return res.status(500).json({
+                        error: "Account info is undefined"
+                    });
+                }
                 dataReturn.accountInfo = accountInfo;
+                loggerContext_1.logger.info("Connection confirmed successfully", {
+                    operation: (0, utils_1.getMethodContext)("WebhookHandler", "connection"),
+                    companyId,
+                    connectionId,
+                    phoneNumber: accountInfo.display_phone_number,
+                });
                 naty.emit("connection", dataReturn);
-                res.json({ connection: req.body });
+                return res.json({ connection: req.body });
             }
             catch (err) {
-                console.log(err);
+                const errorDetails = (0, parseError_1.parseError)(err, "Webhook connection error");
+                loggerContext_1.logger.error("Webhook connection error", {
+                    operation: (0, utils_1.getMethodContext)("WebhookHandler", "connection"),
+                    error: errorDetails.message,
+                    code: errorDetails.code,
+                    companyId,
+                });
                 naty.emit("error", err);
-                res.status(500).json({
-                    error: err.message,
+                return res.status(500).json({
+                    error: err.message || "Internal server error",
                 });
             }
         }
+        else {
+            // Handle other message types or return 200 for unhandled messages
+            return res.status(200).json({ message: "Webhook received" });
+        }
     });
     return router;
 };

package/dist/routes/webhooks/methods/messages.js

@@ -2,21 +2,36 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.messagesRouter = void 0;
 const express_1 = require("express");
-const whatsappMessage_1 = require("../../../Entities/whatsappMessage");
+const whatsappMessage_1 = require("../../../entities/whatsappMessage");
 const whatsappResponse_1 = require("../../../useCases/message/whatsappResponse");
+const loggerContext_1 = require("../../../utils/loggerContext");
+const parseError_1 = require("../../../utils/parseError");
+const utils_1 = require("../../../utils");
 const messagesRouter = (naty) => {
     const router = (0, express_1.Router)();
     router.post("/", (req, res) => {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         try {
             const { companyId, data } = req.body;
             const phone_number_id = (_c = (_b = (_a = data.entry[0]) === null || _a === void 0 ? void 0 : _a.changes[0]) === null || _b === void 0 ? void 0 : _b.value.metadata) === null || _c === void 0 ? void 0 : _c.phone_number_id;
             const clientNumber = (_g = (_f = (_e = (_d = data.entry[0]) === null || _d === void 0 ? void 0 : _d.changes[0]) === null || _e === void 0 ? void 0 : _e.value) === null || _f === void 0 ? void 0 : _f.contacts[0]) === null || _g === void 0 ? void 0 : _g.wa_id;
+            loggerContext_1.logger.info("Webhook message received", {
+                operation: (0, utils_1.getMethodContext)("WebhookHandler", "messages"),
+                companyId,
+                phone_number_id,
+                clientNumber,
+            });
             naty.emit("message", new whatsappResponse_1.WhatsappResponse(companyId, phone_number_id, clientNumber, new whatsappMessage_1.WhatsappMessage(data)));
             res.json(true);
         }
         catch (err) {
-            console.log(err);
+            const errorDetails = (0, parseError_1.parseError)(err, "Webhook message processing failed");
+            loggerContext_1.logger.error("Webhook message error", {
+                operation: (0, utils_1.getMethodContext)("WebhookHandler", "messages"),
+                error: errorDetails.message,
+                code: errorDetails.code,
+                companyId: (_h = req.body) === null || _h === void 0 ? void 0 : _h.companyId,
+            });
             naty.emit("error", err);
             res.status(500).json({
                 error: err.message,

package/dist/services/axiosInstances.d.ts

@@ -1,19 +1,28 @@
+import { AxiosInstance } from "axios";
 export declare const newAxiosInstance: ({ url, phone_number_id, accessToken, }: {
     url?: string | undefined;
     phone_number_id?: string | undefined;
     accessToken: string;
-}) => import("axios").AxiosInstance;
+}) => AxiosInstance;
 export declare const axiosInstanceForDownloadMedia: ({ url, accessToken, }: {
     url?: string | undefined;
     accessToken: string;
-}) => import("axios").AxiosInstance;
+}) => AxiosInstance;
 export declare const axiosInstanceGeneral: ({ url, accessToken, }: {
     url?: string | undefined;
     accessToken: string;
-}) => import("axios").AxiosInstance;
-declare const api: import("axios").AxiosInstance;
+}) => AxiosInstance;
+declare const api: AxiosInstance;
 export { api };
 export declare const updateInterceptor: (interceptors: {
     [key: string]: string;
 }, callback?: ((bool: boolean) => void) | undefined) => Promise<number>;
-export declare const newFacebookInstance: () => import("axios").AxiosInstance;
+export declare const newFacebookInstance: () => AxiosInstance;
+/**
+ * Configure logging interceptors for axios instance
+ * Logs all HTTP requests and responses using the global logger
+ *
+ * @param instance - Axios instance to configure
+ * @returns The configured axios instance
+ */
+export declare function configureLoggingInterceptors(instance: AxiosInstance): AxiosInstance;

package/dist/services/axiosInstances.js

@@ -3,36 +3,49 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.newFacebookInstance = exports.updateInterceptor = exports.api = exports.axiosInstanceGeneral = exports.axiosInstanceForDownloadMedia = exports.newAxiosInstance = void 0;
+exports.configureLoggingInterceptors = exports.newFacebookInstance = exports.updateInterceptor = exports.api = exports.axiosInstanceGeneral = exports.axiosInstanceForDownloadMedia = exports.newAxiosInstance = void 0;
 const axios_1 = __importDefault(require("axios"));
 const axiosInterceptors_1 = require("../configs/axiosInterceptors");
-const newAxiosInstance = ({ url = "https://graph.facebook.com/v18.0/", phone_number_id, accessToken, }) => axios_1.default.create({
-    baseURL: url + phone_number_id,
-    headers: {
-        Authorization: `Bearer ${accessToken}`,
-    },
-});
+const loggerContext_1 = require("../utils/loggerContext");
+const utils_1 = require("../utils");
+const newAxiosInstance = ({ url = "https://graph.facebook.com/v18.0/", phone_number_id, accessToken, }) => {
+    const instance = axios_1.default.create({
+        baseURL: url + phone_number_id,
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+        },
+    });
+    return configureLoggingInterceptors(instance);
+};
 exports.newAxiosInstance = newAxiosInstance;
-const axiosInstanceForDownloadMedia = ({ url = "https://graph.facebook.com/v18.0/media/", accessToken, }) => axios_1.default.create({
-    baseURL: url,
-    headers: {
-        Authorization: `Bearer ${accessToken}`,
-    },
-});
+const axiosInstanceForDownloadMedia = ({ url = "https://graph.facebook.com/v18.0/media/", accessToken, }) => {
+    const instance = axios_1.default.create({
+        baseURL: url,
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+        },
+    });
+    return configureLoggingInterceptors(instance);
+};
 exports.axiosInstanceForDownloadMedia = axiosInstanceForDownloadMedia;
-const axiosInstanceGeneral = ({ url = "https://graph.facebook.com/v18.0/", accessToken, }) => axios_1.default.create({
-    baseURL: url,
-    headers: {
-        Authorization: `Bearer ${accessToken}`,
-    },
-    params: { query: { access_token: accessToken }, access_token: accessToken },
-});
+const axiosInstanceGeneral = ({ url = "https://graph.facebook.com/v18.0/", accessToken, }) => {
+    const instance = axios_1.default.create({
+        baseURL: url,
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+        },
+        params: { query: { access_token: accessToken }, access_token: accessToken },
+    });
+    return configureLoggingInterceptors(instance);
+};
 exports.axiosInstanceGeneral = axiosInstanceGeneral;
 const api = axios_1.default.create({
     baseURL: `${process.env.API_META}/v1`,
     headers: axiosInterceptors_1.configInterceptors,
 });
 exports.api = api;
+// Configure logging interceptors for the main API instance
+configureLoggingInterceptors(api);
 const updateInterceptor = async (interceptors, callback) => {
     return api.interceptors.request.use((config) => {
         // if (!config.headers) config.headers = configInterceptors;
@@ -42,7 +55,82 @@ const updateInterceptor = async (interceptors, callback) => {
     });
 };
 exports.updateInterceptor = updateInterceptor;
-const newFacebookInstance = () => axios_1.default.create({
-    baseURL: "https://graph.facebook.com/v18.0/"
-});
+const newFacebookInstance = () => {
+    const instance = axios_1.default.create({
+        baseURL: "https://graph.facebook.com/v18.0/",
+    });
+    return configureLoggingInterceptors(instance);
+};
 exports.newFacebookInstance = newFacebookInstance;
+/**
+ * Sanitize headers to remove sensitive data from logs
+ */
+function sanitizeHeaders(headers) {
+    if (!headers)
+        return {};
+    const sanitized = Object.assign({}, headers);
+    // Remove or mask sensitive headers
+    if (sanitized.Authorization) {
+        sanitized.Authorization = "Bearer [REDACTED]";
+    }
+    if (sanitized["x-access-token"]) {
+        sanitized["x-access-token"] = "[REDACTED]";
+    }
+    return sanitized;
+}
+/**
+ * Configure logging interceptors for axios instance
+ * Logs all HTTP requests and responses using the global logger
+ *
+ * @param instance - Axios instance to configure
+ * @returns The configured axios instance
+ */
+function configureLoggingInterceptors(instance) {
+    // Request interceptor
+    instance.interceptors.request.use((config) => {
+        var _a;
+        loggerContext_1.logger.debug("HTTP Request", {
+            operation: (0, utils_1.getMethodContext)("AxiosInterceptor", "request"),
+            method: (_a = config.method) === null || _a === void 0 ? void 0 : _a.toUpperCase(),
+            url: config.url,
+            baseURL: config.baseURL,
+            headers: sanitizeHeaders(config.headers),
+            hasData: !!config.data,
+        });
+        return config;
+    }, (error) => {
+        loggerContext_1.logger.error("HTTP Request Error", {
+            operation: (0, utils_1.getMethodContext)("AxiosInterceptor", "request.error"),
+            message: error.message,
+            config: error.config,
+        });
+        return Promise.reject(error);
+    });
+    // Response interceptor
+    instance.interceptors.response.use((response) => {
+        loggerContext_1.logger.debug("HTTP Response", {
+            operation: (0, utils_1.getMethodContext)("AxiosInterceptor", "response"),
+            status: response.status,
+            statusText: response.statusText,
+            url: response.config.url,
+            dataType: typeof response.data,
+        });
+        return response;
+    }, (error) => {
+        var _a, _b, _c;
+        const errorDetails = {
+            message: error.message,
+            url: (_a = error.config) === null || _a === void 0 ? void 0 : _a.url,
+            method: (_c = (_b = error.config) === null || _b === void 0 ? void 0 : _b.method) === null || _c === void 0 ? void 0 : _c.toUpperCase(),
+        };
+        if (error.response) {
+            errorDetails.status = error.response.status;
+            errorDetails.statusText = error.response.statusText;
+            errorDetails.data = error.response.data;
+        }
+        loggerContext_1.logger.error("HTTP Response Error", Object.assign({ operation: (0, utils_1.getMethodContext)("AxiosInterceptor", "response.error") }, errorDetails));
+        return Promise.reject(error);
+    });
+    return instance;
+}
+exports.configureLoggingInterceptors = configureLoggingInterceptors;

package/dist/services/middlewares/validations.d.ts

@@ -1,4 +1,4 @@
-import { Response } from "../../Errors/ErrorHandling";
+import { Either } from "../../errors/Either";
 export declare const middlewares: {
-    confirmAppToken: (appToken: string) => Promise<Response<void, boolean>>;
+    confirmAppToken: (appToken: string) => Promise<Either<string, boolean>>;
 };

package/dist/services/middlewares/validations.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.middlewares = void 0;
 const validation_1 = require("../mutations/validation");
-const tryCatch_1 = require("../../utils/tryCatch");
 exports.middlewares = {
-    confirmAppToken: async (appToken) => await (0, tryCatch_1.Try)(validation_1.validateMutations.confirmAppToken, appToken),
+    confirmAppToken: async (appToken) => await validation_1.validateMutations.confirmAppToken(appToken),
 };