@aj-archipelago/cortex/helper-apps/cortex-file-handler/src/helper.js

Cortex is a GraphQL API for AI. It provides a simple, extensible interface for using AI services from OpenAI, Azure and others.

import fs from "fs";
import http from "http";
import https from "https";
import path from "path";

import { ACCEPTED_MIME_TYPES, isAcceptedMimeType } from "./constants.js";

export async function deleteTempPath(path) {
  try {
    if (!path) {
      console.log("Temporary path is not defined.");
      return;
    }
    if (!fs.existsSync(path)) {
      console.log(`Temporary path ${path} does not exist.`);
      return;
    }
    const stats = fs.statSync(path);
    if (stats.isFile()) {
      fs.unlinkSync(path);
      console.log(`Temporary file ${path} deleted successfully.`);
    } else if (stats.isDirectory()) {
      fs.rmSync(path, { recursive: true });
      console.log(
        `Temporary folder ${path} and its contents deleted successfully.`,
      );
    }
  } catch (err) {
    console.error("Error occurred while deleting the temporary path:", err);
  }
}

// Get the first extension for a given mime type
export function getExtensionForMimeType(mimeType) {
  if (!mimeType) return "";
  const cleanMimeType = mimeType.split(";")[0].trim();
  const extensions = ACCEPTED_MIME_TYPES[cleanMimeType];
  return extensions ? extensions[0] : "";
}

// Ensure a filename has the correct extension based on its mime type
export function ensureFileExtension(filename, mimeType) {
  if (!mimeType) return filename;

  const extension = getExtensionForMimeType(mimeType);
  if (!extension) return filename;

  // If filename already has this extension, return as is
  if (filename.toLowerCase().endsWith(extension)) {
    return filename;
  }

  // Get the current extension if any
  const currentExt = path.extname(filename);

  // If there's no current extension, just append the new one
  if (!currentExt) {
    return `${filename}${extension}`;
  }

  // Replace the current extension with the new one
  return filename.slice(0, -currentExt.length) + extension;
}

export function ensureEncoded(url) {
  try {
    return decodeURIComponent(url) !== url ? url : encodeURI(url);
  } catch (error) {
    console.error("Error encoding URL:", error);
    return url;
  }
}

export async function urlExists(url) {
  if (!url) return false;

  try {
    // Basic URL validation
    const urlObj = new URL(url);
    if (!["http:", "https:"].includes(urlObj.protocol)) {
      throw new Error("Invalid protocol - only HTTP and HTTPS are supported");
    }

    const httpModule = urlObj.protocol === "https:" ? https : http;

    return new Promise((resolve) => {
      const request = httpModule.request(
        url,
        { method: "HEAD" },
        function (response) {
          if (response.statusCode >= 200 && response.statusCode < 400) {
            const contentType = response.headers["content-type"];
            const cleanContentType = contentType
              ? contentType.split(";")[0].trim()
              : "";
            // Check if the content type is one we accept
            if (cleanContentType && isAcceptedMimeType(cleanContentType)) {
              resolve({ valid: true, contentType: cleanContentType });
            } else {
              console.log(`Unsupported content type: ${contentType}`);
              resolve({ valid: false });
            }
          } else {
            resolve({ valid: false });
          }
        },
      );

      request.on("error", function (err) {
        console.error("URL validation error:", err.message);
        resolve({ valid: false });
      });

      request.end();
    });
  } catch (error) {
    console.error("URL validation error:", error.message);
    return { valid: false };
  }
}