123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384
/// <reference lib="dom.iterable" />import {  match,  pathToRegexp,} from "https://deno.land/x/path_to_regexp@v6.2.0/index.ts";import {  Status,  STATUS_TEXT,} from "https://deno.land/std@0.85.0/http/http_status.ts";import { inMemoryCache } from "https://deno.land/x/httpcache@0.1.2/in_memory.ts";import { render } from "https://x.lcas.dev/preact@10.5.12/ssr.js";import {  contentType,  lookup,} from "https://raw.githubusercontent.com/usesift/media_types/34656bf398c81f2687fa5010e56844dac4e7a2e9/mod.ts";import type { VNode } from "https://x.lcas.dev/preact@10.5.12/mod.d.ts";
export * from "https://x.lcas.dev/preact@10.5.12/mod.js";
const globalCache = inMemoryCache(20);
let routes: Routes = { 404: defaultNotFoundPage };
export interface PathParams {  [key: string]: string | string[];}
export type Handler = (  request: Request,  params: PathParams,) => Response | Promise<Response>;
export interface Routes {  [path: string]: Handler;}
/** serve() registers "fetch" event listener and invokes the provided route * handler for the route with the request as first argument and processed path * params as the second. * * @example * ```ts * serve({ *  "/": (request: Request) => new Response("Hello World!"), *  404: (request: Request) => new Response("not found") * }) * ``` * * The route handler declared for `404` will be used to serve all * requests that do not have a route handler declared. */export function serve(userRoutes: Routes): void {  routes = { ...routes, ...userRoutes };  // deno-lint-ignore no-explicit-any  addEventListener("fetch", (event: any) => {    event.respondWith(handleRequest(event.request, routes));  });}
function newResponse(  res: Response,  headers: Record<string, string>,): Response {  const oldResponseHeaders = Object.fromEntries(res.headers.entries());  // GitHub provides a CSP header which embeding  // content. This is a bad and temperory solution  // until deploy has a solid static assets offering.  if (oldResponseHeaders["x-github-request-id"]) {    delete oldResponseHeaders["content-security-policy"];  }  return new Response(res.body, {    headers: {      ...oldResponseHeaders,      ...headers,    },    status: res.status,    statusText: res.statusText,  });}
async function handleRequest(  request: Request,  routes: Routes,): Promise<Response> {  const { search, pathname } = new URL(request.url);
  try {    const startTime = Date.now();    let response = await globalCache.match(request);    if (response === undefined) {      for (const route of Object.keys(routes)) {        if (pathToRegexp(route).test(pathname)) {          const getParams = match(route);          const { params = {} } = getParams(pathname) as {            params: { [key: string]: string };          };          try {            response = await routes[route](request, params);          } catch (error) {            console.error("Error serving request:", error);            response = json({ error: error.message }, { status: 500 });          }          if (!(response instanceof Response)) {            response = jsx(response);          }          break;        }      }    } else {      response = newResponse(response, {        "x-function-cache-hit": "true",      });    }
    // return not found page if no handler is found.    if (response === undefined) {      response = await routes["404"](request, {});    }
    // method path+params timeTaken status    console.log(      `${request.method} ${pathname + search} ${        response.headers.has("x-function-cache-hit")          ? String.fromCodePoint(0x26a1)          : ""      }${Date.now() - startTime}ms ${response.status}`,    );
    return response;  } catch (error) {    console.error("Error serving request:", error);    return json({ error: error.message }, { status: 500 });  }}
function defaultNotFoundPage() {  return new Response("<h1 align=center>page not found</h1>", {    status: 404,    headers: { "Content-Type": "text/html; charset=utf-8" },  });}
export interface ServeStaticOptions {  /** The base to be used for the construction of absolute URL. */  baseUrl: string;  /** A function to modify the response before it's served to the request.   * For example, set appropriate content-type header. */  intervene?: (    request: Request,    response: Response,  ) => Promise<Response> | Response;  /** Disable caching of the responses. */  cache?: boolean;}
/** Serve static files hosted on the internet or relative to your source code. * * Be default, up to 20 static assets that are less than 10MB are cached. You * can disable caching by setting `cache: false` in the options object. * * @example * ``` * import { serve, serveStatic } from "https://deno.land/x/sift/mod.ts" * * serve({ *  // It is required that the path ends with `:filename+` *  "/:filename+": serveStatic("public", { baseUrl: import.meta.url }), * }) * ``` */export function serveStatic(  relativePath: string,  { baseUrl, intervene, cache = true }: ServeStaticOptions,): Handler {  return async (request: Request, params: PathParams): Promise<Response> => {    let filePath = relativePath;    if (params && params.filename) {      if (Array.isArray(params.filename)) {        params.filename = params.filename.join("/");      }      filePath = relativePath.endsWith("/")        ? relativePath + params.filename        : relativePath + "/" + params.filename;    }
    const fileUrl = new URL(filePath, baseUrl).toString();    let response;    if (cache === true) {      response = await globalCache.match(request);    }
    if (response === undefined) {      response = await fetch(new Request(fileUrl, request));      if (response.status == 404) {        return routes[404](request, {});      }
      const cType = contentType(String(lookup(filePath)));      if (cType) {        response = newResponse(response, { "content-type": cType });      }
      if (typeof intervene === "function") {        response = await intervene(request, response);      }
      // We don't want to cache if the resource size if greater than 10MB.      // The size is arbitrary choice.      const TEN_MB = 1024 * 1024 * 10;      if (        cache === true &&        Number(response.headers.get("content-length")) < TEN_MB      ) {        await globalCache.put(request, response);        response = (await globalCache.match(request)) as Response;      }    } else {      response = newResponse(response, {        "x-function-cache-hit": "true",      });    }
    return response;  };}
/** Converts an object literal to a JSON string and returns * a Response with `application/json` as the `content-type`. * * @example * ```js * import { serve, json } from "https://deno.land/x/sift/mod.ts" * * serve({ *  "/": () => json({ message: "hello world"}), * }) *``` * */export function json(  // deno-lint-ignore no-explicit-any  jsobj: any,  init?: ResponseInit,): Response {  return new Response(JSON.stringify(jsobj) + "\n", {    statusText: init?.statusText ?? STATUS_TEXT.get(init?.status ?? Status.OK),    status: init?.status ?? Status.OK,    headers: {      "Content-Type": "application/json; charset=utf-8",      ...init?.headers,    },  });}
/** Renders JSX components to HTML and returns a Response with `text/html` * as the `content-type.` * * @example * ```jsx * import { serve, jsx, h } from "https://deno.land/x/sift/mod.ts" * * const Greet = ({name}) => <div>Hello, {name}</div>; * * serve({ *  "/": () => jsx(<html><Greet name="Sift" /></html), * }) * ``` * * Make sure your file extension is either `.tsx` or `.jsx` and you've `h` imported * when using this function. */export function jsx(jsx: VNode, init?: ResponseInit): Response {  return new Response(render(jsx), {    statusText: init?.statusText ?? STATUS_TEXT.get(init?.status ?? Status.OK),    status: init?.status ?? Status.OK,    headers: {      "Content-Type": "text/html; charset=utf-8",      ...init?.headers,    },  });}
// This is very naive and accepts only the field names to validate if// the specified field exists at the specified place.// FIXME(@satyarohith): do better.export interface RequestTerms {  [key: string]: {    headers?: string[];    body?: string[];    params?: string[];  };}
/** * Validate whether the incoming request meets the provided terms. */export async function validateRequest(  request: Request,  terms: RequestTerms,): Promise<{  error?: { message: string; status: number };  body?: { [key: string]: unknown };}> {  let body = {};
  // Validate the method.  if (!terms[request.method]) {    return {      error: {        message: `method ${request.method} is not allowed for the URL`,        status: Status.MethodNotAllowed,      },    };  }
  // Validate the params if defined in the terms.  if (    terms[request.method]?.params &&    terms[request.method].params!.length > 0  ) {    const { searchParams } = new URL(request.url);    const requestParams = [];    for (const param of searchParams.keys()) {      requestParams.push(param);    }
    for (const param of terms[request.method].params!) {      if (!requestParams.includes(param)) {        return {          error: {            message: `param '${param}' is required to process the request`,            status: Status.BadRequest,          },        };      }    }  }
  // Validate the headers if defined in the terms.  if (    terms[request.method].headers &&    terms[request.method].headers!.length > 0  ) {    // Collect the headers into an array.    const requestHeaderKeys = [];    for (const header of request.headers.keys()) {      requestHeaderKeys.push(header);    }
    // Loop through the headers defined in the terms and check if they    // are present in the request.    for (const header of terms[request.method].headers!) {      if (!requestHeaderKeys.includes(header.toLowerCase())) {        return {          error: {            message: `header '${header}' not available`,            status: Status.BadRequest,          },        };      }    }  }
  // Validate the body of the request if defined in the terms.  if (terms[request.method].body && terms[request.method].body!.length > 0) {    const requestBody = await request.json();    const bodyKeys = Object.keys(requestBody);    for (const key of terms[request.method].body!) {      if (!bodyKeys.includes(key)) {        return {          error: {            message: `field '${key}' is not available in the body`,            status: Status.BadRequest,          },        };      }    }
    // We store and return the body as once the request.json() is called    // the user cannot call request.json() again.    body = requestBody;  }
  return { body };}