Custom Domain

/**
 * Cloudflare Worker for Custom Domain Routing
 */

// Your Vercel deployment URL
const VERCEL_URL = typeof VERCEL_DEPLOYMENT_URL !== 'undefined' ? VERCEL_DEPLOYMENT_URL : 'https://www.prometora.com';
const API_BASE_URL = `${VERCEL_URL}/api`;

addEventListener('fetch', event => {
  event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
  const url = new URL(request.url);
  const hostname = url.hostname;

  // Skip for workers.dev domain (use for testing)
  if (hostname.endsWith('.workers.dev')) {
    return new Response('Cloudflare Worker is running! This is used for custom domain routing.', {
      headers: { 'content-type': 'text/plain' }
    });
  }

  try {
    // Check if this is a static asset request
    const isStaticAsset = url.pathname.startsWith('/_next/') ||
                          url.pathname.startsWith('/static/') ||
                          url.pathname.startsWith('/favicon.ico') ||
                          url.pathname.startsWith('/images/') ||
                          url.pathname.match(/\.(js|css|png|jpg|jpeg|gif|svg|ico|woff|woff2|ttf|eot)$/);

    // Check if this is an API request
    const isApiRequest = url.pathname.startsWith('/api/');

    // For static assets or API requests, proxy directly WITHOUT rewriting path
    if (isStaticAsset || isApiRequest) {
      const newUrl = new URL(request.url);
      newUrl.hostname = new URL(VERCEL_URL).hostname;
      newUrl.protocol = 'https:';

      const headers = new Headers(request.headers);

      // For API requests, add the custom domain header so middleware knows which store
      if (isApiRequest) {
        headers.set('X-Custom-Domain', hostname);
      }

      const response = await fetch(new Request(newUrl.toString(), {
        method: request.method,
        headers: headers,
        body: request.body,
        redirect: 'manual'
      }));
      return rewriteRedirectResponse(response, hostname);
    }

    // Step 1: Look up which store owns this domain (only for non-API requests)
    const storeSlug = await getStoreByDomain(hostname);

    if (!storeSlug) {
      return new Response('Store not found for this domain', {
        status: 404,
        headers: { 'content-type': 'text/plain' }
      });
    }

    // Step 2: Rewrite URL to custom-domain path on Vercel
    const newUrl = new URL(request.url);
    newUrl.hostname = new URL(VERCEL_URL).hostname;
    newUrl.protocol = 'https:';
    if (url.pathname === '/') {
      newUrl.pathname = `/custom-domain`;
    } else {
      newUrl.pathname = `/custom-domain${url.pathname}`;
    }

    // Step 3: Create modified request with custom headers
    const headers = new Headers(request.headers);
    headers.set('X-Custom-Domain', hostname);
    headers.set('X-Store-Slug', storeSlug);
    headers.set('X-Forwarded-Host', hostname);

    const response = await fetch(new Request(newUrl.toString(), {
      method: request.method,
      headers: headers,
      body: request.body,
      redirect: 'manual'
    }));
    return rewriteRedirectResponse(response, hostname);

  } catch (error) {
    console.error('Worker error:', error);
    return new Response(`Error: ${error.message}`, {
      status: 500,
      headers: { 'content-type': 'text/plain' }
    });
  }
}

/**
 * Rewrite redirect responses to use the custom domain
 */
function rewriteRedirectResponse(response, customHostname) {
  const modifiedResponse = new Response(response.body, response);
  modifiedResponse.headers.set('X-Served-By', 'Cloudflare-Worker');

  if (modifiedResponse.headers.has('location')) {
    let location = modifiedResponse.headers.get('location');
    const vercelHostname = new URL(VERCEL_URL).hostname;
    if (location.includes(vercelHostname)) {
      location = location.replace(vercelHostname, customHostname);
    }
    location = location.replace('/custom-domain/', '/');
    location = location.replace('/custom-domain', '/');
    if (location.startsWith('/')) {
      location = `https://${customHostname}${location}`;
    }
    modifiedResponse.headers.set('location', location);
  }

  return modifiedResponse;
}

async function getStoreByDomain(domain) {
  try {
    const response = await fetch(`${API_BASE_URL}/stores/lookup?domain=${encodeURIComponent(domain)}`, {
      headers: {
        'Content-Type': 'application/json'
      }
    });

    if (!response.ok) {
      console.error('Store lookup failed:', response.status);
      return null;
    }

    const data = await response.json();
    return data.slug || null;

  } catch (error) {
    console.error('Error looking up store:', error);
    return null;
  }
}