fileserver.gr

// This is a simple Wagi static file server.

import Env from "./lib/env"
import Map from "map"
import Option from "option"
import File from "sys/file"
import String from "string"
import Result from "result"
import Mediatype from "./lib/mediatype"
import Stringutil from "./lib/stringutil"

// Utility wrapper around a Result.expect that ignores the return value
// so we don't need to worry about things returning non-Void types
let validateResult = (msg, res) => {
  ignore(Result.expect(msg, res))
}

let internalError = () => {
  validateResult(
    "Unexpected error when writing Internal Server Error response",
    File.fdWrite(File.stdout, "Status: 500\n\nInternal Server Error"),
  )
}

let notFound = () => {
  validateResult(
    "Unexpected error when writing Not Found response",
    File.fdWrite(File.stdout, "Status: 404\n\nNot Found"),
  )
}

// Pipe output to STDOUT
let rec pipe = (in, out) => {
  let res = File.fdRead(in, 1024)
  match (res) {
    Err(err) => Err(err),
    Ok((d, len)) => {
      let res = File.fdWrite(out, d)
      if (len > 0) {
        pipe(in, out)
      } else {
        res
      }
    },
  }
}

// Determine cache control values.
let cache_duration = (env, mtype) => {
  let default_cache_control = match (Map.get("CACHE_CONTROL", env)) {
    Some(val) => val,
    None => "no-cache",
  }

  if (String.indexOf("image/", mtype) == Some(0)) {
    match (Map.get("IMAGE_CACHE_CONTROL", env)) {
      Some(val) => val,
      None => default_cache_control,
    }
  } else if (String.indexOf("font/", mtype) == Some(0)) {
    match (Map.get("FONT_CACHE_CONTROL", env)) {
      Some(val) => val,
      None => default_cache_control,
    }
  } else if (String.indexOf("text/css", mtype) == Some(0)) {
    match (Map.get("CSS_CACHE_CONTROL", env)) {
      Some(val) => val,
      None => default_cache_control,
    }
  } else if (String.indexOf("text/javascript", mtype) == Some(0)) {
    match (Map.get("JS_CACHE_CONTROL", env)) {
      Some(val) => val,
      None => default_cache_control,
    }
  } else {
    default_cache_control
  }
}

let headers = (env, path) => {
  let mtype = Mediatype.guess(path);
  "Content-Type: " ++ mtype ++ "\nCache-Control: " ++ cache_duration(env, mtype) ++ "\n\n"
}

let serve = (abs_path, env) => {
  // If PATH_PREFIX is set, then the path prefix is prepended onto the incoming path.
  // This allows you to map to a directory that does not match the directory name in the URL.
  let path = match (Map.get("PATH_PREFIX", env)) {
    Some(prefix) => {
      let tmp = String.slice(1, String.length(abs_path), abs_path)
      String.concat(prefix, tmp)
    },
    // If no env var, trim off just the leading /
    None => String.slice(1, String.length(abs_path), abs_path)
  }
  // Explicitly ignoring any Ok or Err that happens on this log
  // The `ignore` can be removed if you don't want to be explicit about this behavior
  ignore(File.fdWrite(File.stderr, "Fileserver: Loading file " ++ path ++ "\n"))

  // Open file
  let result = File.pathOpen(File.pwdfd, [], path, [], [File.FdRead], [], [])

  match (result) {
    Err(_err) => notFound(),
    Ok(input) => {
      validateResult(
        "Unexpected error when writing Content-Type",
        File.fdWrite(
          File.stdout,
          headers(env, path),
        ),
      )

      validateResult(
        "Unexpected error when streaming file body",
        pipe(input, File.stdout),
      )
      // This validation may be able to be removed if it doesn't matter if the fdClose fails
      validateResult("Unexpected error when closing file", File.fdClose(input))
    },
  }
}



let guestpath = env => {
  // Backward compat for an older version of Wagi that had PATH_INFO wrong.
  // X_RELATIVE_PATH was removed before Wagi 0.4
  match (Map.get("X_RELATIVE_PATH", env)) {
    Some(p) => String.concat("/", p),
    None => {
      Option.unwrap(Map.get("PATH_INFO", env))
    },
  }
}

let kv = Env.envMap()
let pathInfo = guestpath(kv)
serve(pathInfo, kv)