Hosting a highly available inexpensive static site

❯ hugo
Start building sites … 

                   | EN  
-------------------+-----
  Pages            | 22  
  Paginator pages  |  0  
  Non-page files   |  1  
  Static files     |  0  
  Processed images |  0  
  Aliases          |  0  
  Sitemaps         |  1  
  Cleaned          |  0  

Total in 53 ms

name: Build Hugo Static Site
on:
  push:
    branches: [ master ]
  pull_request:
    branches: [ master ]
  workflow_dispatch:

jobs:
  check-spelling:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
      with:
        ref: ${{ github.head_ref }}
    - name: Check Spelling
      uses: rojopolis/[email protected]
  deploy:
    needs: [check-spelling]
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
      with:
        submodules: true
        fetch-depth: 0

    - name: Hugo setup
      uses: peaceiris/[email protected]
      with:
        extended: true
    - name: Hugo version
      run: hugo env
    - name: Build
      run: hugo --minify
    - name: Backblaze B2 Sync
      uses: earendildev/[email protected]
      env:
        SOURCE_DIR: './public'
        B2_BUCKET_PATH: 'b2://${{ secrets.B2_BUCKET }}/'
        B2_APPKEY_ID: ${{ secrets.B2_APPKEY_ID }}
        B2_APPKEY: ${{ secrets.B2_APPKEY }}

'use strict';
const b2Domains = [''];
const b2Bucket = '';
const b2UrlPath = `/file/${b2Bucket}/`;

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

// define the file extensions we wish to add basic access control headers to
const corsFileTypes = ['png', 'jpg', 'gif', 'jpeg', 'webp'];

// backblaze returns some additional headers that are useful for debugging, but unnecessary in production. We can remove these to save some size
const removeHeaders = [
	'x-bz-content-sha1',
	'x-bz-file-id',
	'x-bz-file-name',
	'x-bz-info-src_last_modified_millis',
	'X-Bz-Upload-Timestamp',
	'Expires'
];
const expiration = 31536000; // override browser cache for images - 1 year

function fixHeaders(url, status, headers){
	let newHdrs = new Headers(headers);
	// add basic cors headers for images
	if(corsFileTypes.includes(url.pathname.split('.').pop())){
		newHdrs.set('Access-Control-Allow-Origin', '*');
	}
	// override browser cache for files when 200
	if(status === 200){
		newHdrs.set('Cache-Control', "public, max-age=" + expiration);
	}else{
		// only cache other things for 5 minutes
		newHdrs.set('Cache-Control', 'public, max-age=300');
	}
	// set ETag for efficient caching where possible
	const ETag = newHdrs.get('x-bz-content-sha1') || newHdrs.get('x-bz-info-src_last_modified_millis') || newHdrs.get('x-bz-file-id');
	if(ETag){
		newHdrs.set('ETag', ETag);
	}
	// remove unnecessary headers
	removeHeaders.forEach(header => {
		newHdrs.delete(header);
	});
	return newHdrs;
};

async function fixUrl(url) {
  if(b2Domains.includes(url.host)) {
    const path = url.pathname;
    if (path.includes(b2UrlPath)) {
        return;
    }
    if (path.includes('404.html')) {
        url.pathname = b2UrlPath + url.pathname;
        return;
    }
    if(path.endsWith('/')) {
      url.pathname = b2UrlPath + url.pathname + 'index.html';
    } else if(path.slice(-5).includes('.')) {
      url.pathname = b2UrlPath + url.pathname;
    } else {
      url.pathname = b2UrlPath + url.pathname + '/' + 'index.html';
    }
	}
}

async function fetchAndStreamNotFoundPage(resp, base_domain) {
  const { status, statusText } = resp;
  const { readable, writable } = new TransformStream();

  const response = await fetch(`${base_domain}${b2UrlPath}404.html`);
  const { headers } = response;

  response.body.pipeTo(writable)

  return new Response(readable, {
    status,
    statusText,
    headers
  });
}

async function handleRequest(event){
	const cache = caches.default; // Cloudflare edge caching
	let url = new URL(event.request.url);

	await fixUrl(url);

	let response = await cache.match(url); // try to find match for this request in the edge cache
	if(response) {
		// use cache found on Cloudflare edge. Set X-Worker-Cache header for helpful debug
		let newHdrs = fixHeaders(url, response.status, response.headers);
		newHdrs.set('X-Worker-Cache', "true");
		return new Response(response.body, {
			status: response.status,
      statusText: response.statusText,
			headers: newHdrs
		});
	}

	// no cache, fetch request, apply Cloudflare lossless compression
	response = await fetch(url);
    let newHdrs = fixHeaders(url, response.status, response.headers);
    if(response.status === 404) {
      response = await fetchAndStreamNotFoundPage(response, url.origin);
      return response;
    }
	
	response = new Response(response.body, {
		status: response.status,
		statusText: response.statusText,
		headers: newHdrs
	});

	event.waitUntil(cache.put(url, response.clone()));
	return response;
}