Framer & MailerLite - The Integration You Were Waiting For

/*
  This script defines a Cloudflare Worker that acts as an API gateway.
  It handles subscriber data requests, ensures security with CORS and API keys,
  and processes incoming data from clients before forwarding to MailerLite.
*/

const ALLOWED_ORIGIN = "https://www.your-domain.com"; // Restrict API access to a specific origin

export default {
  async fetch(request, env) {
    console.log("Request process start.");
    // Create a new URL object from the incoming request
    // This allows us to extract query parameters and path information
    const url = new URL(request.url);
    
    // Extract the pathname from the URL
    // This is used to determine which API endpoint the request is targeting
    const path = url.pathname;
    
    const SECRET_KEY = env.SECRET_KEY; // Secret key for authentication
    const secret = url.searchParams.get("key"); // Retrieve secret key from query params
    
    // Define CORS headers to allow cross-origin requests only from ALLOWED_ORIGIN
    const CORS_HEADERS = {
      "Access-Control-Allow-Origin": ALLOWED_ORIGIN,
      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
      "Access-Control-Allow-Headers": "Content-Type",
    };

    console.log("Cors set.");

    // Block requests if ALLOWED_ORIGIN is not set (security measure)
    if (!ALLOWED_ORIGIN) {
      console.log("Forbidden origin.");
      return new Response(JSON.stringify({ error: "Forbidden" }), {
        status: 403,
        headers: CORS_HEADERS,
      });
    }
    console.log("Request passed origin challenge.");

    // Handle CORS preflight requests
    if (request.method === "OPTIONS") {
      return new Response(null, { headers: CORS_HEADERS });
    }

    // Block unauthorized requests missing the correct secret key
    if (secret !== SECRET_KEY) {
      return new Response(JSON.stringify({ error: "Unauthorized" }), {
        status: 403,
        headers: { "Content-Type": "application/json" }
      });
    }

    console.log("Request passed secret key challenge.");

    // Retrieve API key and base URL for MailerLite API
    const API_KEY = env.API_KEY;
    const BASE_URL = env.BASE_URL;

    // Handle different API routes
    if (request.method === "GET" && path === "/subscribers") {
      return fetchSubscribers(API_KEY, BASE_URL);
    } else if (request.method === "POST" && path === "/subscribe") {
      return addOrUpdateSubscriber(request, API_KEY, BASE_URL);
    } else {
      return new Response(JSON.stringify({ error: "Invalid route" }), {
        status: 404,
        headers: { "Content-Type": "application/json" }
      });
    }
  }
};

console.log("Request passed route options.");

/*
  Function to fetch subscribers from MailerLite API
  Uses an API key for authentication and limits response to 100 records
*/
async function fetchSubscribers(apiKey, baseUrl) {
  try {
    const response = await fetch(`${baseUrl}?limit=100`, {
      method: "GET",
      headers: {
        "Authorization": `Bearer ${apiKey}`,
        "Content-Type": "application/json"
      }
    });
    const data = await response.json();
    return new Response(JSON.stringify(data), {
      status: response.status,
      headers: { "Content-Type": "application/json" }
    });
  } catch (error) {
    return new Response(JSON.stringify({ error: "Failed to fetch subscribers" }), {
      status: 500,
      headers: { "Content-Type": "application/json" }
    });
  }
}

/*
  Function to add or update a subscriber in MailerLite
  Uses an API key for authentication
*/
async function addOrUpdateSubscriber(request, apiKey, baseUrl) {
  try {
    let requestBody;
    const contentType = request.headers.get("Content-Type");
    console.log("Received Content-Type:", contentType);

    if (contentType.includes("application/json")) {
      requestBody = await request.json();
      console.log("Received JSON Body:", JSON.stringify(requestBody, null, 2));
    } else {
      console.error("Unsupported Content-Type:", contentType);
      return new Response(JSON.stringify({ error: "Unsupported content type" }), {
        status: 400,
        headers: { "Content-Type": "application/json" }
      });
    }

// Ensure correct data format before sending to MailerLite API
    requestBody = {
      email: requestBody.email || requestBody.Email,
      fields: { name: requestBody.name || requestBody.Name || "" },
      groups: [requestBody.groups || requestBody.Groups || "",]
    };
    
    if (!requestBody.email) {
      console.error("Missing email in request body:", requestBody);
      return new Response(JSON.stringify({ error: "Email is required" }), {
        status: 400,
        headers: { "Content-Type": "application/json" }
      });
    }

    console.log("Sending data to MailerLite:", requestBody);

   // Send subscription request to MailerLite
    const response = await fetch(baseUrl, {
      method: "POST",
      headers: {
        "Authorization": `Bearer ${apiKey}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify(requestBody)
    });

    const responseData = await response.json();
    console.log("MailerLite Response:", responseData);

    return new Response(JSON.stringify(responseData), {
      status: response.status,
      headers: { "Content-Type": "application/json" }
    });

  } catch (error) {
    console.error("Error processing subscription:", error);
    return new Response(JSON.stringify({ error: "Failed to process subscription" }), {
      status: 500,
      headers: { "Content-Type": "application/json" }
    });
  }
}