CDN Proxy

'use strict';

// TODO: Replace with your Optimizely Account ID
const ACCOUNT_ID = '12345';
// TODO: Replace with your Performance Edge Project ID
const PROJECT_ID = '67890';

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

/**
 * @param {Request} request
 * @returns {Promise.<Response>}
 *        Response from the Edge Decider, containing the microsnippet.
 */
async function handleRequest(request) {
  try {
    const url = `https://optimizely-edge.com/edge-client/v1/${ACCOUNT_ID}/${PROJECT_ID}`;
    const headers = new Headers(request.headers);

    // Required for IP Address and Location targeting
    headers.set(
      'X-Forwarded-For',
      updateXForwardedFor(
        headers.get('X-Forwarded-For'),
        headers.get('CF-Connecting-IP')
      )
    );

    // Forward headers and cookies, to assist with experiment targeting.
    // For more information, see the Edge Decider API documentation.
    const filteredHeaders = filterHeaders(headers);
    if (filteredHeaders.has('Cookie')) {
      filteredHeaders.set(
        'Cookie',
        filteredHeaders
          .get('Cookie')
          .split(/; */)
          .filter(isOkCookie)
          .join('; ')
      );
    }

    const response = await fetch(
      new Request(
        url,
        new Request(url, { ...request, headers: filteredHeaders })
      )
    );
    return response;
  } catch (e) {
    console.log(e);
    return new Response(e || e.stack);
  }
}

/**
 * @param {String|undefined}
 *        Current value of an 'X-Forwarded-For' header.
 * @param {String} remoteAddr
 *        IP address of the requester.
 * @returns {String}
 *        The given 'X-Forwarded-For', updated to include the given remote address.
 */
function updateXForwardedFor(currentValue, remoteAddr) {
  return currentValue ? `${currentValue}, ${remoteAddr}` : remoteAddr;
}

/**
 * @param {Headers} headers
 * @returns {Headers}
 *        A reduced set of headers to send to the Edge Decider.
 */
function filterHeaders(headers) {
  // Populate this header blacklist as desired.
  // Do NOT add the following to the blacklist:
  //   - Cookie (use the `isOkCookie` function below to filter cookies)
  //   - Referer
  //   - X-Forwarded-For
  // For rationale, see the Edge Decider API documentation.
  const blacklist = [];
  const blacklistLowerCase = new Set(blacklist.map(s => s.toLowerCase()));

  return Array.from(headers.entries())
    .filter(([name]) => !blacklistLowerCase.has(name))
    .reduce((result, [name, value]) => {
      result.set(name, value);
      return result;
    }, new Headers());
}

/**
 * @param {String} cookie
 *        A string like `${name}=${value}`.
 * @returns {Boolean}
 *        Whether to send this cookie to the Edge Decider.
 */
function isOkCookie(cookie) {
  // TODO: Replace with your preferred cookie filtering logic for your app
  if (/session/i.test(cookie)) {
    // Remove any "session" cookies
    return false;
  }
  return true;
}

'use strict';

const https = require('https');

// TODO: Replace with your Optimizely Account ID
const ACCOUNT_ID = '12345';
// TODO: Replace with your Performance Edge Project ID
const PROJECT_ID = '67890';

// Headers from the Edge Decider response that should be included in the CloudFront viewer response.
// Make sure this doesn't include any blacklisted headers!
// See: https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-requirements-limits.html#lambda-blacklisted-headers
const RESPONSE_HEADER_WHITELIST = [
  'cache-control',
  'content-type',
  'set-cookie',
  'content-encoding',
];

/**
 * An object that Lambda@Edge passes to a function when it's handling a CloudFront viewer request.
 * See https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html#lambda-event-structure-request
 * @typedef {Object} CloudFrontRequestEvent
 */

/**
 * The object returned from a Lambda@Edge function that creates an HTTP response.
 * See https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-generating-http-responses-in-requests.html#lambda-generating-http-responses-object
 * @typedef {Object} CloudFrontResponse
 */

/**
 * The Lambda entry point.
 *
 * @param {CloudFrontRequestEvent} event
 * @returns {Promise.<CloudFrontResponse>}
 *        Always fulfills.
 */
exports.optimizelyEdge = event => {
  const { request } = event.Records[0].cf;
  const headers = Object.entries(
    request.headers
  ).reduce((acc, [name, [{ value }]]) => {
    acc[name] = value;
    return acc;
  }, {});

  // Required for IP Address and Location targeting
  headers['x-forwarded-for'] = updateXForwardedFor(
    headers['x-forwarded-for'],
    request.clientIp
  );

  // Forward headers and cookies, to assist with experiment targeting.
  // For more information, see the Edge Decider API documentation.
  const filteredHeaders = filterHeaders(headers);
  if (filteredHeaders.cookie) {
    filteredHeaders.cookie = filteredHeaders.cookie
      .split(/; */)
      .filter(isOkCookie)
      .join('; ');
  }

  return nodeRequest({
    host: 'optimizely-edge.com',
    path: `/edge-client/v1/${ACCOUNT_ID}/${PROJECT_ID}`,
    method: 'GET',
    headers: filteredHeaders
  });
};

/**
 * @param {Object} headers
 * @returns {Object}
 *        A reduced set of headers to send to the Edge Decider.
 */
function filterHeaders(headers) {
  // Populate this header blacklist as desired.
  // Do NOT add the following to the blacklist:
  //   - Cookie (use the `isOkCookie` function below to filter cookies)
  //   - Referer
  //   - X-Forwarded-For
  // For rationale, see the Edge Decider API documentation.
  const blacklist = new Set(
    [
      // DON'T remove this; leave it to `nodeRequest` to populate the Host header in the
      // request to the Edge Decider
      'Host',
    ].map(s => s.toLowerCase())
  );

  return Object.entries(headers).reduce((result, [name, value]) => {
    if (!blacklist.has(name)) {
      result[name] = value;
    }
    return result;
  }, {});
}

/**
 * @param {String|undefined}
 *        Current value of an 'X-Forwarded-For' header.
 * @param {String} remoteAddr
 *        IP address of the requester.
 * @returns {String}
 *        The given 'X-Forwarded-For', updated to include the given remote address.
 */
function updateXForwardedFor(currentValue, remoteAddr) {
  return currentValue ? `${currentValue}, ${remoteAddr}` : remoteAddr;
}

/**
 * @param {String} cookie
 *        A string like `${name}=${value}`.
 * @returns {Boolean}
 *        Whether to send this cookie to the Edge Decider.
 */
function isOkCookie(cookie) {
  // TODO: Replace with your preferred cookie filtering logic for your app
  if (/session/i.test(cookie)) {
    // Remove any "session" cookies
    return false;
  }
  return true;
}

/**
 * Node.js' `https.request`, adapted to the Cloudfront programming model
 * and promisified.
 *
 * @param {Object} options
 *        Options to Node.js' `https.request` (https://nodejs.org/docs/latest-v12.x/api/https.html#https_https_request_options_callback)
 * @returns {Promise.<CloudFrontResponse>}
 *        Surely fulfills.
 */
function nodeRequest(options) {
  return new Promise(resolve => {
    let data = [];
    const req = https.request(options, res => {
      let binary = false;
      if (res.headers['content-encoding']) {
        binary = true;
      }
      
      res.setEncoding(binary ? 'binary' : 'utf8');  

      res.on('data', chunk => {
        data.push(Buffer.from(chunk, 'binary'));
      });

      res.on('end', () => {
        const body = Buffer.concat(data);
        resolve(httpToLambdaResp(res, body.toString('base64'), 'base64'));
      });
    });

    req.on('error', e => {
      resolve(errorResponse(e));
    });

    req.end();
  });
}

/**
 * @param {Error} e
 * @param {Number} statusCode
 * @returns {Promise.<CloudFrontResponse>}
 */
function errorResponse(e, statusCode = 500) {
  return Promise.resolve({
    status: 200,
    body: `// Error getting snippet response ${statusCode}: ${e.message}`,
    headers: {
      'content-type': [
        {
          key: 'Content-Type',
          value: 'application/javascript'
        }
      ]
    }
  });
}

/**
 * Format a Node.js response and body content for CloudFront consumption
 *
 * @param {http.ServerResponse} response
 *       See https://nodejs.org/docs/latest-v12.x/api/http.html#http_class_http_serverresponse
 * @param {String} body
 *       Contents of the response body
 * @param {String} bodyEncoding
 *       Encoding of the response body
 * @returns {CloudFrontResponse}
 */
function httpToLambdaResp(response, body, bodyEncoding) {
  const resp = {
    status: response.statusCode,
    body,
    bodyEncoding,
    headers: {}
  };

  let headerVal;
  for (let headerName of RESPONSE_HEADER_WHITELIST) {
    headerVal = response.headers[headerName];
    if (headerVal) {
      if (!Array.isArray(headerVal)) {
        headerVal = [headerVal];
      }
      resp.headers[headerName] = headerVal.map(eachVal => ({
        value: eachVal
      }));
    }
  }
  return resp;
}