request-iframe 0.0.6 → 0.1.0

package/esm/utils/debug.js

@@ -0,0 +1,521 @@
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.object.get-own-property-descriptors.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/es.map.js";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { MessageType, getStatusText, Messages } from '../constants';
+
+/**
+ * Debug log prefix
+ */
+var DEBUG_PREFIX = '[request-iframe]';
+
+/**
+ * Format log output
+ * - Prefix: bold
+ * - info: message text in blue
+ */
+function log(level, message, data) {
+  var timestamp = new Date().toISOString();
+  var prefix = `${DEBUG_PREFIX} [${timestamp}] [${level.toUpperCase()}]`;
+  var prefixStyle = 'font-weight:bold';
+  var messageStyle = level === 'info' ? 'color: #1976d2' : '';
+  if (data !== undefined) {
+    console[level](`%c${prefix}%c ${message}`, prefixStyle, messageStyle, data);
+  } else {
+    console[level](`%c${prefix}%c ${message}`, prefixStyle, messageStyle);
+  }
+}
+
+/**
+ * Format message data for logging (remove sensitive data if needed)
+ */
+function formatMessageData(data) {
+  if (!data) return data;
+  var formatted = _objectSpread({}, data);
+
+  // Limit body size in logs
+  if (formatted.body && typeof formatted.body === 'object') {
+    var bodyStr = JSON.stringify(formatted.body);
+    if (bodyStr.length > 500) {
+      formatted.body = bodyStr.substring(0, 500) + '... (truncated)';
+    }
+  }
+
+  // Limit data size in logs
+  if (formatted.data && typeof formatted.data === 'object') {
+    var dataStr = JSON.stringify(formatted.data);
+    if (dataStr.length > 500) {
+      formatted.data = dataStr.substring(0, 500) + '... (truncated)';
+    }
+  }
+  return formatted;
+}
+
+/**
+ * Register debug interceptors for client
+ */
+export function setupClientDebugInterceptors(client) {
+  // Request interceptor: log request start
+  client.interceptors.request.use(config => {
+    log('info', Messages.DEBUG_CLIENT_REQUEST_START, formatMessageData({
+      path: config.path,
+      body: config.body,
+      headers: config.headers,
+      cookies: config.cookies,
+      ackTimeout: config.ackTimeout,
+      timeout: config.timeout,
+      asyncTimeout: config.asyncTimeout,
+      requestId: config.requestId
+    }));
+    return config;
+  });
+
+  // Response interceptor: log response success
+  client.interceptors.response.use(response => {
+    var logData = {
+      requestId: response.requestId,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    };
+
+    // Check if response.data is a File or Blob
+    if (response.data instanceof File || response.data instanceof Blob) {
+      var file = response.data;
+      var fileName = file instanceof File ? file.name : undefined;
+      var mimeType = file.type || undefined;
+      var contentLength = file.size;
+      logData.fileData = {
+        fileName,
+        mimeType,
+        contentLength
+      };
+      log('info', Messages.DEBUG_CLIENT_REQUEST_SUCCESS_FILE, formatMessageData(logData));
+    } else if (response.stream) {
+      logData.stream = {
+        streamId: response.stream.streamId,
+        type: response.stream.type
+      };
+      log('info', Messages.DEBUG_CLIENT_REQUEST_SUCCESS_STREAM, formatMessageData(logData));
+    } else {
+      logData.data = response.data;
+      log('info', Messages.DEBUG_CLIENT_REQUEST_SUCCESS, formatMessageData(logData));
+    }
+    return response;
+  }, error => {
+    log('error', Messages.DEBUG_CLIENT_REQUEST_FAILED, formatMessageData({
+      requestId: error.requestId,
+      code: error.code,
+      message: error.message,
+      config: error.config,
+      response: error.response
+    }));
+    return Promise.reject(error);
+  });
+
+  // Hook into client's internal message handling via server's message dispatcher
+  // This requires accessing internal properties, so we use type assertion
+  var clientImpl = client;
+  if (clientImpl.server && clientImpl.server.messageDispatcher) {
+    setupClientMessageDebugging(clientImpl);
+  }
+}
+
+/**
+ * Setup message-level debugging for client
+ */
+function setupClientMessageDebugging(clientImpl) {
+  var _server$_registerPend, _server$messageDispat;
+  var server = clientImpl.server;
+
+  // Store original _registerPendingRequest
+  var originalRegister = (_server$_registerPend = server._registerPendingRequest) === null || _server$_registerPend === void 0 ? void 0 : _server$_registerPend.bind(server);
+  if (originalRegister) {
+    server._registerPendingRequest = function (requestId, resolve, reject, origin) {
+      // Wrap resolve to log incoming messages
+      var wrappedResolve = data => {
+        if (data.type === MessageType.ACK) {
+          log('info', Messages.DEBUG_CLIENT_RECEIVED_ACK, formatMessageData({
+            requestId: data.requestId,
+            path: data.path
+          }));
+        } else if (data.type === MessageType.ASYNC) {
+          log('info', Messages.DEBUG_CLIENT_RECEIVED_ASYNC, formatMessageData({
+            requestId: data.requestId,
+            path: data.path
+          }));
+        } else if (data.type === MessageType.STREAM_START) {
+          var streamBody = data.body;
+          log('info', Messages.DEBUG_CLIENT_RECEIVED_STREAM_START, formatMessageData({
+            requestId: data.requestId,
+            streamId: streamBody === null || streamBody === void 0 ? void 0 : streamBody.streamId,
+            streamType: streamBody === null || streamBody === void 0 ? void 0 : streamBody.type,
+            chunked: streamBody === null || streamBody === void 0 ? void 0 : streamBody.chunked,
+            autoResolve: streamBody === null || streamBody === void 0 ? void 0 : streamBody.autoResolve,
+            metadata: streamBody === null || streamBody === void 0 ? void 0 : streamBody.metadata
+          }));
+        } else if (data.type === MessageType.STREAM_DATA) {
+          var _streamBody$data;
+          var _streamBody = data.body;
+          log('info', Messages.DEBUG_CLIENT_RECEIVED_STREAM_DATA, formatMessageData({
+            requestId: data.requestId,
+            streamId: _streamBody === null || _streamBody === void 0 ? void 0 : _streamBody.streamId,
+            done: _streamBody === null || _streamBody === void 0 ? void 0 : _streamBody.done,
+            dataLength: (_streamBody === null || _streamBody === void 0 || (_streamBody$data = _streamBody.data) === null || _streamBody$data === void 0 ? void 0 : _streamBody$data.length) || 0
+          }));
+        } else if (data.type === MessageType.STREAM_END) {
+          var _streamBody2 = data.body;
+          log('info', Messages.DEBUG_CLIENT_RECEIVED_STREAM_END, formatMessageData({
+            requestId: data.requestId,
+            streamId: _streamBody2 === null || _streamBody2 === void 0 ? void 0 : _streamBody2.streamId
+          }));
+        } else if (data.type === MessageType.RESPONSE) {
+          log('info', Messages.DEBUG_CLIENT_RECEIVED_RESPONSE, formatMessageData({
+            requestId: data.requestId,
+            status: data.status,
+            statusText: data.statusText,
+            requireAck: data.requireAck
+          }));
+        } else if (data.type === MessageType.ERROR) {
+          log('error', Messages.DEBUG_CLIENT_RECEIVED_ERROR, formatMessageData({
+            requestId: data.requestId,
+            status: data.status,
+            statusText: data.statusText,
+            error: data.error
+          }));
+        }
+        resolve(data);
+      };
+
+      // Wrap reject to log timeouts
+      var wrappedReject = () => {
+        log('warn', Messages.DEBUG_CLIENT_REQUEST_TIMEOUT, {
+          requestId,
+          origin
+        });
+        reject();
+      };
+      return originalRegister(requestId, wrappedResolve, wrappedReject, origin);
+    };
+  }
+
+  // Log when messages are sent
+  var originalSendMessage = (_server$messageDispat = server.messageDispatcher) === null || _server$messageDispat === void 0 || (_server$messageDispat = _server$messageDispat.sendMessage) === null || _server$messageDispat === void 0 ? void 0 : _server$messageDispat.bind(server.messageDispatcher);
+  if (originalSendMessage) {
+    server.messageDispatcher.sendMessage = function (target, targetOrigin, type, requestId, data) {
+      if (type === MessageType.REQUEST) {
+        log('info', Messages.DEBUG_CLIENT_SENDING_REQUEST, formatMessageData({
+          requestId,
+          path: data === null || data === void 0 ? void 0 : data.path,
+          body: data === null || data === void 0 ? void 0 : data.body,
+          headers: data === null || data === void 0 ? void 0 : data.headers
+        }));
+      } else if (type === MessageType.PING) {
+        log('info', Messages.DEBUG_CLIENT_SENDING_PING, {
+          requestId
+        });
+      } else if (type === MessageType.RECEIVED) {
+        log('info', Messages.DEBUG_CLIENT_SENDING_RECEIVED_ACK, {
+          requestId
+        });
+      }
+      return originalSendMessage(target, targetOrigin, type, requestId, data);
+    };
+  }
+}
+
+/**
+ * Register debug listeners for server
+ * Use middleware to log requests and responses
+ */
+export function setupServerDebugListeners(server) {
+  var serverImpl = server;
+  var startTimes = new Map();
+
+  // Use global middleware to log requests
+  server.use((req, res, next) => {
+    var _res$sendStream;
+    var startTime = Date.now();
+    startTimes.set(req.requestId, startTime);
+    log('info', Messages.DEBUG_SERVER_RECEIVED_REQUEST, formatMessageData({
+      requestId: req.requestId,
+      path: req.path,
+      body: req.body,
+      origin: req.origin,
+      headers: req.headers,
+      cookies: req.cookies,
+      method: 'POST' // iframe requests are always POST-like
+    }));
+
+    // Store original send methods
+    var originalSend = res.send.bind(res);
+    var originalJson = res.json.bind(res);
+    var originalSendFile = res.sendFile.bind(res);
+    var originalSendStream = (_res$sendStream = res.sendStream) === null || _res$sendStream === void 0 ? void 0 : _res$sendStream.bind(res);
+    var originalStatus = res.status.bind(res);
+    var originalSetHeader = res.setHeader.bind(res);
+
+    // Track status code changes
+    res.status = function (code) {
+      log('info', Messages.DEBUG_SERVER_SETTING_STATUS_CODE, {
+        requestId: req.requestId,
+        path: req.path,
+        statusCode: code
+      });
+      return originalStatus(code);
+    };
+
+    // Track header changes
+    res.setHeader = function (name, value) {
+      log('info', Messages.DEBUG_SERVER_SETTING_HEADER, {
+        requestId: req.requestId,
+        path: req.path,
+        header: name,
+        value: Array.isArray(value) ? value.join(', ') : String(value)
+      });
+      return originalSetHeader(name, value);
+    };
+
+    // Override send method
+    res.send = /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(data, options) {
+        var duration;
+        return _regeneratorRuntime.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              duration = Date.now() - (startTimes.get(req.requestId) || startTime);
+              startTimes.delete(req.requestId);
+              log('info', Messages.DEBUG_SERVER_SENDING_RESPONSE, formatMessageData({
+                requestId: req.requestId,
+                path: req.path,
+                status: res.statusCode,
+                statusText: getStatusText(res.statusCode),
+                requireAck: options === null || options === void 0 ? void 0 : options.requireAck,
+                headers: res.headers,
+                data,
+                duration: `${duration}ms`
+              }));
+              return _context.abrupt("return", originalSend(data, options));
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      return function (_x, _x2) {
+        return _ref.apply(this, arguments);
+      };
+    }();
+
+    // Override json method
+    res.json = /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(data, options) {
+        var duration;
+        return _regeneratorRuntime.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              duration = Date.now() - (startTimes.get(req.requestId) || startTime);
+              startTimes.delete(req.requestId);
+              log('info', Messages.DEBUG_SERVER_SENDING_JSON_RESPONSE, formatMessageData({
+                requestId: req.requestId,
+                path: req.path,
+                status: res.statusCode,
+                statusText: getStatusText(res.statusCode),
+                requireAck: options === null || options === void 0 ? void 0 : options.requireAck,
+                headers: res.headers,
+                data,
+                duration: `${duration}ms`
+              }));
+              return _context2.abrupt("return", originalJson(data, options));
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      return function (_x3, _x4) {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+
+    // Override sendFile method
+    res.sendFile = /*#__PURE__*/function () {
+      var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(content, options) {
+        var duration;
+        return _regeneratorRuntime.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              duration = Date.now() - (startTimes.get(req.requestId) || startTime);
+              startTimes.delete(req.requestId);
+              log('info', Messages.DEBUG_SERVER_SENDING_FILE, formatMessageData({
+                requestId: req.requestId,
+                path: req.path,
+                status: res.statusCode,
+                statusText: getStatusText(res.statusCode),
+                fileName: options === null || options === void 0 ? void 0 : options.fileName,
+                mimeType: options === null || options === void 0 ? void 0 : options.mimeType,
+                contentLength: typeof content === 'string' ? content.length : (content === null || content === void 0 ? void 0 : content.size) || 0,
+                duration: `${duration}ms`
+              }));
+              return _context3.abrupt("return", originalSendFile(content, options));
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3);
+      }));
+      return function (_x5, _x6) {
+        return _ref3.apply(this, arguments);
+      };
+    }();
+
+    // Override sendStream method if exists
+    if (originalSendStream) {
+      res.sendStream = /*#__PURE__*/function () {
+        var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(stream) {
+          var duration;
+          return _regeneratorRuntime.wrap(function (_context4) {
+            while (1) switch (_context4.prev = _context4.next) {
+              case 0:
+                duration = Date.now() - (startTimes.get(req.requestId) || startTime);
+                startTimes.delete(req.requestId);
+                log('info', Messages.DEBUG_SERVER_SENDING_STREAM, formatMessageData({
+                  requestId: req.requestId,
+                  path: req.path,
+                  status: res.statusCode,
+                  statusText: getStatusText(res.statusCode),
+                  streamId: stream === null || stream === void 0 ? void 0 : stream.streamId,
+                  duration: `${duration}ms`
+                }));
+                return _context4.abrupt("return", originalSendStream(stream));
+              case 1:
+              case "end":
+                return _context4.stop();
+            }
+          }, _callee4);
+        }));
+        return function (_x7) {
+          return _ref4.apply(this, arguments);
+        };
+      }();
+    }
+    next();
+  });
+
+  // Hook into server's message dispatcher for more detailed logging
+  if (serverImpl.messageDispatcher) {
+    setupServerMessageDebugging(serverImpl);
+  }
+}
+
+/**
+ * Setup message-level debugging for server
+ */
+function setupServerMessageDebugging(serverImpl) {
+  var _dispatcher$sendMessa, _serverImpl$handleReq, _serverImpl$runMiddle;
+  var dispatcher = serverImpl.messageDispatcher;
+
+  // Log when messages are sent
+  var originalSendMessage = (_dispatcher$sendMessa = dispatcher.sendMessage) === null || _dispatcher$sendMessa === void 0 ? void 0 : _dispatcher$sendMessa.bind(dispatcher);
+  if (originalSendMessage) {
+    dispatcher.sendMessage = function (target, targetOrigin, type, requestId, data) {
+      if (type === MessageType.ACK) {
+        log('info', Messages.DEBUG_SERVER_SENDING_ACK, formatMessageData({
+          requestId,
+          path: data === null || data === void 0 ? void 0 : data.path
+        }));
+      } else if (type === MessageType.ASYNC) {
+        log('info', Messages.DEBUG_SERVER_SENDING_ASYNC, formatMessageData({
+          requestId,
+          path: data === null || data === void 0 ? void 0 : data.path
+        }));
+      } else if (type === MessageType.STREAM_START) {
+        var streamBody = (data === null || data === void 0 ? void 0 : data.body) || {};
+        log('info', Messages.DEBUG_SERVER_SENDING_STREAM_START, formatMessageData({
+          requestId,
+          streamId: streamBody.streamId,
+          streamType: streamBody.type,
+          chunked: streamBody.chunked,
+          autoResolve: streamBody.autoResolve,
+          metadata: streamBody.metadata
+        }));
+      } else if (type === MessageType.STREAM_DATA) {
+        var _streamBody3$data;
+        var _streamBody3 = (data === null || data === void 0 ? void 0 : data.body) || {};
+        log('info', Messages.DEBUG_SERVER_SENDING_STREAM_DATA, formatMessageData({
+          requestId,
+          streamId: _streamBody3.streamId,
+          done: _streamBody3.done,
+          dataLength: ((_streamBody3$data = _streamBody3.data) === null || _streamBody3$data === void 0 ? void 0 : _streamBody3$data.length) || 0
+        }));
+      } else if (type === MessageType.STREAM_END) {
+        var _streamBody4 = (data === null || data === void 0 ? void 0 : data.body) || {};
+        log('info', Messages.DEBUG_SERVER_SENDING_STREAM_END, formatMessageData({
+          requestId,
+          streamId: _streamBody4.streamId
+        }));
+      } else if (type === MessageType.ERROR) {
+        log('error', Messages.DEBUG_SERVER_SENDING_ERROR, formatMessageData({
+          requestId,
+          status: data === null || data === void 0 ? void 0 : data.status,
+          statusText: data === null || data === void 0 ? void 0 : data.statusText,
+          error: data === null || data === void 0 ? void 0 : data.error,
+          path: data === null || data === void 0 ? void 0 : data.path
+        }));
+      } else if (type === MessageType.RESPONSE) {
+        log('info', Messages.DEBUG_SERVER_SENDING_RESPONSE_VIA_DISPATCHER, formatMessageData({
+          requestId,
+          status: data === null || data === void 0 ? void 0 : data.status,
+          statusText: data === null || data === void 0 ? void 0 : data.statusText,
+          requireAck: data === null || data === void 0 ? void 0 : data.requireAck,
+          path: data === null || data === void 0 ? void 0 : data.path
+        }));
+      }
+      return originalSendMessage(target, targetOrigin, type, requestId, data);
+    };
+  }
+
+  // Log when requests are received (before handler)
+  var originalHandleRequest = (_serverImpl$handleReq = serverImpl.handleRequest) === null || _serverImpl$handleReq === void 0 ? void 0 : _serverImpl$handleReq.bind(serverImpl);
+  if (originalHandleRequest) {
+    serverImpl.handleRequest = function (data, context) {
+      log('info', Messages.DEBUG_SERVER_HANDLING_REQUEST, formatMessageData({
+        requestId: data.requestId,
+        path: data.path,
+        origin: context === null || context === void 0 ? void 0 : context.origin,
+        role: data.role,
+        creatorId: data.creatorId
+      }));
+      return originalHandleRequest(data, context);
+    };
+  }
+
+  // Log handler execution
+  var originalRunMiddlewares = (_serverImpl$runMiddle = serverImpl.runMiddlewares) === null || _serverImpl$runMiddle === void 0 ? void 0 : _serverImpl$runMiddle.bind(serverImpl);
+  if (originalRunMiddlewares) {
+    serverImpl.runMiddlewares = function (req, res, callback) {
+      var handlerStartTime = Date.now();
+      log('info', Messages.DEBUG_SERVER_EXECUTING_MIDDLEWARE_CHAIN, {
+        requestId: req.requestId,
+        path: req.path
+      });
+      return originalRunMiddlewares(req, res, () => {
+        var handlerDuration = Date.now() - handlerStartTime;
+        log('info', Messages.DEBUG_SERVER_MIDDLEWARE_CHAIN_COMPLETED, {
+          requestId: req.requestId,
+          path: req.path,
+          duration: `${handlerDuration}ms`
+        });
+        callback();
+      });
+    };
+  }
+}

package/esm/utils/error.js

@@ -0,0 +1,27 @@
+/**
+ * Custom Error class for request-iframe errors
+ * Extends native Error with additional error response fields
+ */
+export class RequestIframeError extends Error {
+  /** Error code */
+
+  /** Request configuration */
+
+  /** Response data (if available) */
+
+  /** Request ID */
+
+  constructor(error) {
+    super(error.message);
+    this.name = 'RequestIframeError';
+    this.code = error.code;
+    this.config = error.config;
+    this.response = error.response;
+    this.requestId = error.requestId;
+
+    // Maintain proper stack trace for where our error was thrown (only available on V8)
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, RequestIframeError);
+    }
+  }
+}