documentation-hub 5.7.2

package/dist/electron/PowerAutomateApiService-LfW09ZGr.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const electron = require("electron");
+const main = require("./main-CXkNtyv-.js");
+const log = main.logger.namespace("PowerAutomateApi");
+async function callPowerAutomateApi(apiUrl, payload, timeoutMs = 3e4) {
+  const jsonPayload = JSON.stringify(payload);
+  const startTime = Date.now();
+  log.info("═══════════════════════════════════════════════════════════════════");
+  log.info("[MainProcess] Starting Power Automate HTTP Request");
+  log.info("═══════════════════════════════════════════════════════════════════");
+  log.info(`[MainProcess] Timestamp: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  log.info(`[MainProcess] URL: ${apiUrl}`);
+  log.info(`[MainProcess] Lookup IDs: ${payload.Lookup_ID.length}`);
+  log.info(`[MainProcess] IDs: ${payload.Lookup_ID.join(", ")}`);
+  log.info(`[MainProcess] Timeout: ${timeoutMs}ms`);
+  log.info("───────────────────────────────────────────────────────────────────");
+  return new Promise((resolve) => {
+    log.info("[MainProcess] Sending request via Electron net.request...");
+    const timeoutHandle = setTimeout(() => {
+      const duration = Date.now() - startTime;
+      log.error("═══════════════════════════════════════════════════════════════════");
+      log.error("[MainProcess] REQUEST TIMEOUT");
+      log.error(`[MainProcess] Timeout after ${timeoutMs}ms`);
+      log.error("═══════════════════════════════════════════════════════════════════");
+      resolve({
+        success: false,
+        error: `Request timeout after ${timeoutMs}ms`,
+        duration
+      });
+    }, timeoutMs);
+    try {
+      const netRequest = electron.net.request({
+        method: "POST",
+        url: apiUrl,
+        session: electron.session.defaultSession
+      });
+      netRequest.setHeader("Content-Type", "application/json; charset=utf-8");
+      netRequest.setHeader("User-Agent", "DocHub/1.0");
+      netRequest.setHeader("Accept", "application/json");
+      let responseData = "";
+      netRequest.on("response", (response) => {
+        log.info(`[MainProcess] Response received: ${response.statusCode} ${response.statusMessage}`);
+        response.on("data", (chunk) => {
+          responseData += chunk.toString();
+        });
+        response.on("end", () => {
+          clearTimeout(timeoutHandle);
+          const duration = Date.now() - startTime;
+          log.info(`[MainProcess] Response complete in ${duration}ms`);
+          if (response.statusCode && response.statusCode >= 200 && response.statusCode < 300) {
+            try {
+              const data = JSON.parse(responseData);
+              log.info("═══════════════════════════════════════════════════════════════════");
+              log.info("[MainProcess] API Call SUCCESS");
+              log.info(`[MainProcess] Results: ${data?.Results?.length || 0} items`);
+              log.info("═══════════════════════════════════════════════════════════════════");
+              resolve({
+                success: true,
+                statusCode: response.statusCode,
+                data,
+                duration
+              });
+            } catch (parseError) {
+              log.error("[MainProcess] Failed to parse response JSON:", parseError);
+              resolve({
+                success: false,
+                statusCode: response.statusCode,
+                error: "Failed to parse API response",
+                rawResponse: responseData,
+                duration
+              });
+            }
+          } else {
+            log.error("═══════════════════════════════════════════════════════════════════");
+            log.error("[MainProcess] API Call FAILED");
+            log.error(`[MainProcess] Status: ${response.statusCode}`);
+            log.error(`[MainProcess] Response: ${responseData.substring(0, 500)}`);
+            log.error("═══════════════════════════════════════════════════════════════════");
+            resolve({
+              success: false,
+              statusCode: response.statusCode,
+              error: `API returned status ${response.statusCode}`,
+              rawResponse: responseData,
+              duration
+            });
+          }
+        });
+        response.on("error", (error) => {
+          clearTimeout(timeoutHandle);
+          const duration = Date.now() - startTime;
+          log.error("[MainProcess] Response error:", error);
+          resolve({
+            success: false,
+            error: error.message,
+            duration
+          });
+        });
+      });
+      netRequest.on("error", (error) => {
+        clearTimeout(timeoutHandle);
+        const duration = Date.now() - startTime;
+        log.error("[MainProcess] Request error:", error);
+        resolve({
+          success: false,
+          error: error.message,
+          duration
+        });
+      });
+      netRequest.write(jsonPayload);
+      netRequest.end();
+    } catch (error) {
+      clearTimeout(timeoutHandle);
+      const duration = Date.now() - startTime;
+      log.error("[MainProcess] Exception creating request:", error);
+      resolve({
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+        duration
+      });
+    }
+  });
+}
+async function callPowerAutomateApiWithRetry(apiUrl, payload, options = {}) {
+  const { timeout = 3e4, maxRetries = 3, retryDelay = 1e3 } = options;
+  let lastError = null;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    if (attempt > 0) {
+      const delay = Math.pow(2, attempt) * retryDelay;
+      log.info(`[MainProcess] Retry attempt ${attempt + 1} of ${maxRetries} (waiting ${delay}ms)`);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    const response = await callPowerAutomateApi(apiUrl, payload, timeout);
+    if (response.success) {
+      return response;
+    }
+    lastError = response;
+    if (response.error?.includes("timeout")) {
+      log.error("[MainProcess] Timeout detected, not retrying");
+      break;
+    }
+  }
+  log.error(`[MainProcess] All ${maxRetries} attempts failed`);
+  return lastError || { success: false, error: "API request failed after retries" };
+}
+exports.callPowerAutomateApi = callPowerAutomateApi;
+exports.callPowerAutomateApiWithRetry = callPowerAutomateApiWithRetry;