10439270686

Committed 18 Aug 2024 08:46AM UTC coverage: 73.913% (-0.02%) from 73.928%

Build # 10439270686

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #427 from fastrodev/dev

update default headers for send

Run Details

86 of 114 branches covered (75.44%)

Branch coverage included in aggregate %.

9 of 12 new or added lines in 1 file covered. (75.0%)

1 existing line in 1 file now uncovered.

764 of 1036 relevant lines covered (73.75%)

21.64 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.04

/http/server/mod.ts

// deno-lint-ignore-file no-explicit-any
import {
  contentType,
  encodeHex,
  extname,
  JSX,
  STATUS_CODE,
  STATUS_TEXT,
} from "./deps.ts";
import { Render } from "./render.ts";
import {
  Context,
  Fastro,
  FunctionComponent,
  Handler,
  HttpRequest,
  ListenHandler,
  Middleware,
  ModuleFunction,
  Page,
  Static,
} from "./types.ts";
import { EsbuildMod } from "../build/esbuildMod.ts";

export function checkReferer(req: Request) {
  const referer = req.headers.get("referer");
  const host = req.headers.get("host") as string;
  if (!referer || !referer?.includes(host)) {
    return new Response(STATUS_TEXT[STATUS_CODE.NotFound], {
      status: STATUS_CODE.NotFound,
    });
  }
}

export const BUILD_ID = Deno.env.get("DENO_DEPLOYMENT_ID") || encodeHex(
  new Uint8Array(
    await crypto.subtle.digest(
      "sha-1",
      new TextEncoder().encode(crypto.randomUUID()),
    ),
  ),
);

export const getDevelopment = () => {
  return Deno.env.get("ENV") === "DEVELOPMENT";
};

const parseBody = (req: Request) => {
  return async <T>() => {
    const text = await req.text();
    return JSON.parse(text) as T;
  };
};

const createResponse = (
  res: any,
  status = 200,
  headers?: Headers,
): Response => {
  const h = headers ? headers : new Headers({
    "Content-Type": "application/json",
  });
  if (typeof res === "string") return new Response(res, { status, headers: h });
  if (res instanceof Response) return res;
  if (
    typeof res === "number" || typeof res === "bigint" ||
    typeof res === "boolean" || typeof res === "undefined"
  ) return new Response(JSON.stringify(res), { status, headers: h });
  try {
    return Response.json(res, { status, headers: h });
  } catch (error) {
    throw error;
  }
};

export default class Server implements Fastro {
  constructor(options?: Record<string, any>) {
    this.serverOptions = options ?? {};
    this.#handler = this.#createHandler();
    this.#addPropsEndpoint();
  }
  getNonce(): string {
    if (this.#nonce === "") {
      this.#nonce = crypto.randomUUID().replace(/-/g, "");
    }
    return this.#nonce;
  }
  get(
    path: string,
    ...handler: Array<Handler>
  ): Fastro {
    return this.add("GET", path, ...handler);
  }
  post(
    path: string,
    ...handler: Array<Handler>
  ): Fastro {
    return this.add("POST", path, ...handler);
  }
  put(
    path: string,
    ...handler: Array<Handler>
  ): Fastro {
    return this.add("PUT", path, ...handler);
  }
  patch(
    path: string,
    ...handler: Array<Handler>
  ): Fastro {
    return this.add("PATCH", path, ...handler);
  }
  delete(
    path: string,
    ...handler: Array<Handler>
  ): Fastro {
    return this.add("DELETE", path, ...handler);
  }
  options(
    path: string,
    ...handler: Array<Handler>
  ): Fastro {
    return this.add("OPTIONS", path, ...handler);
  }
  head(
    path: string,
    handler: Handler,
    ...middleware: Array<Handler>
  ): Fastro {
    return this.add("HEAD", path, handler, ...middleware);
  }
  page<T = any>(
    path: string,
    page: Page<T>,
    ...middleware: Array<Handler>
  ): Fastro {
    return this.#addPage(path, page, ...middleware);
  }
  use(...handlers: Handler[]): Fastro {
    for (let index = 0; index < handlers.length; index++) {
      const element = handlers[index];
      const middleware: Middleware = {
        path: undefined,
        method: undefined,
        handler: element,
      };
      this.#middleware.push(middleware);
    }
    return this;
  }

  static(
    path: string,
    options?: { maxAge?: number; folder?: string; referer?: boolean },
  ) {
    this.#staticUrl = path;
    if (options?.folder) this.#staticFolder = options?.folder;
    if (options?.referer) this.#staticReferer = options.referer;
    if (options?.maxAge) this.#maxAge = options.maxAge;
    return this;
  }

  #addPage = (path: string, page: Page, ...middlewares: Handler[]) => {
    const key = path;
    this.#routePage[key] = page;
    if (middlewares.length > 0) {
      this.#pushPageMiddleware(path, ...middlewares);
    }
    return this;
  };

  #pushPageMiddleware = (
    path: string,
    ...middlewares: Array<Handler>
  ) => {
    for (let index = 0; index < middlewares.length; index++) {
      const handler = middlewares[index];
      this.#pageMiddleware.push({
        method: undefined,
        path,
        handler,
      });
    }
  };

  add = (
    method: string,
    path: string,
    ...handler: Handler[]
  ) => {
    const key = method + "-" + path;
    if (handler.length === 1) {
      this.#routeHandler[key] = handler[0];
      return this;
    }

    this.#push(method, path, ...handler);
    return this;
  };

  #push = (
    method: any,
    path: any,
    ...handlers: Array<Handler>
  ) => {
    for (let index = 0; index < handlers.length - 1; index++) {
      const handler = handlers[index];
      this.#middleware.push({
        method,
        path,
        handler,
      });
    }
    const key = method + "-" + path;
    this.#routeHandler[key] = handlers[handlers.length - 1];
  };

  #build = async () => {
    // deno-lint-ignore no-deprecated-deno-api
    if (Deno.run === undefined) {
      return [];
    }
    for (const [_key, page] of Object.entries(this.#routePage)) {
      await this.#createHydrate(page);
      const result = await this.#buildPageComponent(page);
      if (
        Deno.env.get("ENV") === "DEVELOPMENT" && result && result.outputFiles
      ) {
        for (const out of result.outputFiles) {
          const fc = page.component as FunctionComponent;
          const decoder = new TextDecoder();
          const str = decoder.decode(out.contents);
          const path =
            `/js/${fc.name.toLocaleLowerCase()}.${this.getNonce()}.js`;
          this.add(
            "GET",
            path,
            () => {
              return new Response(str, {
                headers: { "content-type": "application/javascript" },
              });
            },
          );
        }
      }
    }
    return Deno.args.filter((v) => v === "--build");
  };

  #createHydrate = async (c: Page) => {
    if (typeof c.component != "function") return;
    const name = c.component.name.toLocaleLowerCase();
    const folder = c.folder ? c.folder + "/" : "";
    const [d] = Deno.args.filter((v) => v === "--debug");
    const debug = !d ? "" : `import "preact/debug";
`;
    const str = `${debug}import { h, hydrate } from "preact";
import app from "../${folder}${name}.page.tsx";
async function fetchProps(root: HTMLElement) {
  try {
    const parsedUrl = new URL(window.location.href);
    const key = parsedUrl.pathname === "/" ? "" : parsedUrl.pathname;
    const url = "/__/props" + key; 
    const response = await fetch(url);
    const data = await response.json();
    if (!data) throw new Error("undefined");
    hydrate(h(app, { data }), root);
  } catch (error) {
    setTimeout(() => {
      fetchProps(root);
    }, 500);
  }
}
const root = document.getElementById("root");
if (root) fetchProps(root);
`;

    const dir = Deno.cwd() + "/.fastro";
    try {
      Deno.readDirSync(dir);
    } catch {
      Deno.mkdirSync(dir);
    }

    const path = dir + "/" + name + ".hydrate.tsx";
    await Deno.writeTextFile(path, str);
  };

  async #buildPageComponent(c: Page) {
    if (typeof c.component == "function") {
      const str = c.component.name.toLocaleLowerCase() +
        ".page.tsx";
      console.log(
        `%cBuild: %c${str}`,
        "color: blue",
        "color: white",
      );

      const es = new EsbuildMod(c);
      return await es.build();
    }
  }

  #getParamsHandler<T extends Record<string, Handler>>(
    req: Request,
    data: T,
  ): [Handler, Record<string, string | undefined> | undefined] | undefined {
    for (const [key, handler] of Object.entries(data)) {
      const [method, path] = key.split("-");
      const pattern = new URLPattern({ pathname: path });
      if (key.includes(":") && pattern.test(req.url) && req.method === method) {
        const exec = pattern.exec(req.url);
        const params = exec?.pathname.groups;
        return [handler, params];
      }
    }
  }

  #getParamsPage<T extends Record<string, Page>>(
    req: Request,
    data: T,
  ): [Page, Record<string, string | undefined> | undefined] | undefined {
    for (const [path, page] of Object.entries(data)) {
      const pattern = new URLPattern({ pathname: path });
      if (path.includes(":") && pattern.test(req.url)) {
        const match = pattern.exec(req.url);
        const params = match?.pathname.groups;
        return [page, params];
      }
    }
  }

  #handleStaticFile = async (req: Request) => {
    const s = (await this.#findStaticFiles(
      this.#staticUrl,
      req.url,
      this.getNonce(),
    )) as Static;
    if (s) {
      const ref = checkReferer(req);
      if (ref && this.#staticReferer) return ref;
      return new Response(s.file, {
        headers: {
          "Content-Type": s.contentType,
          "Cache-Control": `max-age=${this.#maxAge}`,
        },
      });
    }

    const b = await this.#handleBinary(this.#staticUrl, req.url);
    if (b) return b;

    return new Response(STATUS_TEXT[STATUS_CODE.NotFound], {
      status: STATUS_CODE.NotFound,
    });
  };

  #addPropsEndpoint = () => {
    const path = "/__/props/:key*";
    this.add("GET", path, (req, _ctx) => {
      const ref = checkReferer(req);
      if (!getDevelopment() && ref) return ref;
      const data = this.serverOptions[req.url];
      return new Response(JSON.stringify(data), {
        headers: new Headers({
          "Content-Type": "application/json",
          "Access-Control-Allow-Origin": "null",
          "Access-Control-Allow-Methods": "GET",
          "Access-Control-Allow-Headers": "Content-Type",
        }),
      });
    });
  };

  #handlePage = (
    req: Request,
    info: Deno.ServeHandlerInfo,
  ) => {
    const url = new URL(req.url);
    let key = url.pathname;
    let page: Page = this.#routePage[key];
    let params: Record<string, string | undefined> | undefined = undefined;
    if (!page) {
      const res = this.#getParamsPage(req, this.#routePage);
      if (res) {
        const [pg, prm] = res;
        page = pg;
        params = prm;
      }
    }
    if (!page) return [];
    const ctx = this.serverOptions as Context;
    ctx.render = <T>(data: T, headers?: Headers) => {
      const r = new Render(this);
      key = key === "/" ? "" : key;
      key = url.origin + "/__/props" + key;
      return r.render(key, page, data, this.getNonce(), headers);
    };
    ctx.info = info;
    ctx.next = () => {};
    ctx.url = new URL(req.url);
    ctx.server = this;
    ctx.send = <T>(data: T, status = 200, headers?: Headers) => {
      return createResponse(data, status, headers);
    };
    ctx.kv = this.serverOptions["kv"];
    ctx.options = this.serverOptions;
    return [page, ctx, params, url];
  };

  #findMatch(
    m: Middleware,
    id: string,
    url: string,
    method: string,
    page?: boolean,
  ) {
    const r = this.#record[id];
    if (r) return r as URLPatternResult;

    const pattern = m.path
      ? new URLPattern({ pathname: m.path })
      : new URLPattern({ pathname: "/*" });

    const result = pattern.exec(url);
    if (!result) return undefined;
    if (!page && (m.path !== undefined) && (m.method !== method)) {
      return undefined;
    }

    return this.#record[id] = result;
  }

  #handlePageMiddleware = (
    req: Request,
    info: Deno.ServeHandlerInfo,
  ) => {
    const page = true;
    return this.#handleMiddleware(req, info, page);
  };

  #handleMiddleware = async (
    req: Request,
    info: Deno.ServeHandlerInfo,
    page?: boolean,
  ) => {
    const mid = !page ? this.#middleware : this.#pageMiddleware;
    if (mid.length === 0) return undefined;
    const method: string = req.method, url: string = req.url;
    const u = new URL(url);
    for (let index = 0; index < mid.length; index++) {
      const m = mid[index];
      const id = method + m.method + m.path + url;
      const match = !page
        ? this.#findMatch(m, id, url, method)
        : this.#findMatch(m, id, url, method, true);

      if (!match) continue;
      const x = await m.handler(
        this.#transformRequest(req, match?.pathname.groups, u),
        this.#transformCtx(info, u, this.serverOptions),
      ) as any;

      if (x instanceof Response) {
        return x;
      }
    }
  };

  #iterableToRecord(
    params: URLSearchParams,
  ) {
    const record: Record<string, string> = {};
    params.forEach((v, k) => (record[k] = v));
    return record;
  }

  #transformRequest = (
    req: Request,
    params?: Record<string, string | undefined>,
    url?: URL,
  ) => {
    const u = url ?? new URL(req.url);
    const r = req as HttpRequest;
    r.params = params;
    r.parseBody = parseBody(req);
    r.query = this.#iterableToRecord(u.searchParams);
    return r;
  };

  #transformCtx = (
    info: Deno.ServeHandlerInfo,
    url: URL,
    options: Record<string, any>,
  ) => {
    const ctx = options as Context;
    const r = new Render(this);
    ctx.render = <T>(jsx: T) => {
      return r.renderJsx(jsx as JSX.Element);
    };
    ctx.send = <T>(data: T, status = 200) => {
      return createResponse(data, status);
    };
    ctx.info = info;
    ctx.next = () => {};
    ctx.url = url;
    ctx.server = this;
    ctx.kv = this.serverOptions["kv"];
    return ctx;
  };

  #handleRequest = (req: Request, info: Deno.ServeHandlerInfo) => {
    const id = req.method + req.url;
    if (this.#record[id]) return this.#record[id];
    const url = new URL(req.url);
    const key = req.method + "-" + url.pathname;
    let handler = this.#routeHandler[key];
    let params: Record<string, string | undefined> | undefined;
    if (!handler) {
      const res = this.#getParamsHandler(req, this.#routeHandler);
      if (res) {
        const [h, p] = res;
        handler = h;
        params = p;
      }
    }

    const ctx = this.#transformCtx(info, url, this.serverOptions);
    return this.#record[id] = { handler, ctx, params, url };
  };

  #createHandler = () => {
    return async (req: Request, info: Deno.ServeHandlerInfo) => {
      const m = await this.#handleMiddleware(req, info);
      if (m) return m;

      const r = this.#handleRequest(req, info);
      if (r.handler) {
        const tr = this.#transformRequest(req, r.params, r.url);
        const res = await r.handler(tr, r.ctx);
        return createResponse(res);
      }

      const pm = await this.#handlePageMiddleware(req, info);
      if (pm) return pm;

      const [page, pageCtx, pageParams, pageUrl] = this.#handlePage(
        req,
        info,
      ) as any;
      if (page) {
        return page.handler(
          this.#transformRequest(req, pageParams, pageUrl),
          pageCtx,
        ) as Promise<Response>;
      }

      return this.#handleStaticFile(req);
    };
  };

  #normalizeStaticUrl = (url: string, reqUrl: string) => {
    const staticUrl = url === "/" ? "" : url;
    const pathname = `${staticUrl}/*`;
    const id = `${pathname}${reqUrl}`;
    return [id, pathname];
  };

  #findStaticFiles = async (url: string, initReqUrl: string, nonce: string) => {
    let reqUrl = "";
    if (initReqUrl.endsWith(`${nonce}.js`)) {
      const [script] = initReqUrl.split(nonce);
      reqUrl = script + "js";
    }
    const [id, pathname] = this.#normalizeStaticUrl(url, reqUrl);
    if (this.#record[id]) return this.#record[id];

    const pattern = new URLPattern({ pathname });
    const match = pattern.exec(reqUrl);
    if (!match) return this.#record[id] = null;

    const input = match?.pathname.groups["0"];
    const filePath = `${this.#staticFolder}/${input}`;
    const ct = contentType(extname(filePath)) || "application/octet-stream";

    const binary = ["png", "jpeg", "jpg", "gif", "pdf", "aac", "ico"];
    const b = binary.filter((v) => ct.includes(v));
    if (b.length > 0) return this.#record[id] = null;

    let file;
    try {
      file = await Deno.readTextFile(`./${filePath}`);
    } catch {
      return this.#record[id] = null;
    }

    return this.#record[id] = { contentType: ct, file };
  };

  #handleBinary = async (url: string, reqUrl: string) => {
    const [id, pathname] = this.#normalizeStaticUrl(url, reqUrl);
    try {
      const match = new URLPattern({ pathname }).exec(reqUrl);
      const filePath = `${this.#staticFolder}/${match?.pathname.groups["0"]}`;
      const ct = contentType(extname(filePath)) || "application/octet-stream";
      if (filePath.endsWith("/")) {
        return this.#record[id] = null;
      }
      const file = await Deno.open(`./${filePath}`, { read: true });
      return new Response(file.readable, {
        headers: {
          "Content-Type": ct,
          "Cache-Control": `max-age=${this.#maxAge}`,
        },
      });
    } catch {
      return this.#record[id] = null;
    }
  };

  group = (mf: ModuleFunction) => {
    return Promise.resolve(mf(this));
  };

  serve = async (options?: { port?: number; onListen?: ListenHandler }) => {
    const [s] = await this.#build();
    if (s) return Deno.exit();

    this.#server = Deno.serve({
      port: options && options.port ? options.port : 8000,
      handler: this.#handler,
      signal: this.#ac.signal,
      onListen: options && options.onListen ? options.onListen : undefined,
    });
  };

  shutdown = async () => {
    if (this.#server) {
      this.#server.finished.then(() => console.log("Server closed"));
      console.log("Closing server...");
      this.#ac.abort();
      await this.#server.shutdown();
    }
  };

  getPages(): Record<string, Page> {
    return this.#routePage;
  }

  getRoutes(): Record<string, Handler> {
    return this.#routeHandler;
  }

  #server: Deno.HttpServer | undefined;
  #ac: AbortController = new AbortController();
  #handler: (
    req: Request,
    info: Deno.ServeHandlerInfo,
  ) => Response | Promise<Response>;
  #routeHandler: Record<string, Handler> = {};
  #routePage: Record<string, Page> = {};
  #record: Record<string, any> = {};
  #middleware: Middleware[] = [];
  #pageMiddleware: Middleware[] = [];
  #staticFolder = "static";
  #staticUrl = "/";
  #staticReferer = false;
  #maxAge = 0;
  #nonce = "";
  serverOptions: Record<string, any> = {};
}

1	// deno-lint-ignore-file no-explicit-any	1✔
2	import {	2✔
3	contentType,	2✔
4	encodeHex,	2✔
5	extname,	2✔
6	JSX,
7	STATUS_CODE,	2✔
8	STATUS_TEXT,	2✔
9	} from "./deps.ts";	2✔
10	import { Render } from "./render.ts";	2✔
11	import {
12	Context,
13	Fastro,
14	FunctionComponent,
15	Handler,
16	HttpRequest,
17	ListenHandler,
18	Middleware,
19	ModuleFunction,
20	Page,
21	Static,
22	} from "./types.ts";
23	import { EsbuildMod } from "../build/esbuildMod.ts";	2✔
24
25	export function checkReferer(req: Request) {	2✔
26	const referer = req.headers.get("referer");	3✔
27	const host = req.headers.get("host") as string;	3✔
28	if (!referer \|\| !referer?.includes(host)) {	×
29	return new Response(STATUS_TEXT[STATUS_CODE.NotFound], {	3✔
30	status: STATUS_CODE.NotFound,	3✔
31	});	3✔
32	}	3✔
33	}	3✔
34
35	export const BUILD_ID = Deno.env.get("DENO_DEPLOYMENT_ID") \|\| encodeHex(	2✔
36	new Uint8Array(	2✔
37	await crypto.subtle.digest(	2✔
38	"sha-1",	2✔
39	new TextEncoder().encode(crypto.randomUUID()),	2✔
40	),
41	),
42	);	2✔
43
44	export const getDevelopment = () => {	2✔
45	return Deno.env.get("ENV") === "DEVELOPMENT";	70✔
46	};	2✔
47
48	const parseBody = (req: Request) => {	2✔
49	return async <T>() => {	×
50	const text = await req.text();	×
51	return JSON.parse(text) as T;	×
52	};	×
53	};	2✔
54
55	const createResponse = (	2✔
56	res: any,	2✔
57	status = 200,	2✔
58	headers?: Headers,	2✔
59	): Response => {
NEW 60	const h = headers ? headers : new Headers({	×
61	"Content-Type": "application/json",	34✔
62	});	34✔
63	if (typeof res === "string") return new Response(res, { status, headers: h });	142✔
64	if (res instanceof Response) return res;	34✔
65	if (	34✔
66	typeof res === "number" \|\| typeof res === "bigint" \|\|	34✔
67	typeof res === "boolean" \|\| typeof res === "undefined"	34✔
68	) return new Response(JSON.stringify(res), { status, headers: h });	220✔
69	try {	64✔
70	return Response.json(res, { status, headers: h });	256✔
71	} catch (error) {	×
72	throw error;	×
73	}	×
74	};	2✔
75
76	export default class Server implements Fastro {	2✔
77	constructor(options?: Record<string, any>) {	5✔
78	this.serverOptions = options ?? {};	8✔
79	this.#handler = this.#createHandler();	8✔
80	this.#addPropsEndpoint();	8✔
81	}	8✔
82	getNonce(): string {	5✔
83	if (this.#nonce === "") {	15✔
84	this.#nonce = crypto.randomUUID().replace(/-/g, "");	18✔
85	}	18✔
86	return this.#nonce;	15✔
87	}	15✔
88	get(	5✔
89	path: string,	5✔
90	...handler: Array<Handler>	5✔
91	): Fastro {	5✔
92	return this.add("GET", path, ...handler);	17✔
93	}	17✔
94	post(	5✔
95	path: string,	5✔
96	...handler: Array<Handler>	5✔
97	): Fastro {	5✔
98	return this.add("POST", path, ...handler);	7✔
99	}	7✔
100	put(	5✔
101	path: string,	5✔
102	...handler: Array<Handler>	5✔
103	): Fastro {	5✔
104	return this.add("PUT", path, ...handler);	7✔
105	}	7✔
106	patch(	5✔
107	path: string,	5✔
108	...handler: Array<Handler>	5✔
109	): Fastro {	5✔
110	return this.add("PATCH", path, ...handler);	7✔
111	}	7✔
112	delete(	5✔
113	path: string,	5✔
114	...handler: Array<Handler>	5✔
115	): Fastro {	5✔
116	return this.add("DELETE", path, ...handler);	7✔
117	}	7✔
118	options(	5✔
119	path: string,	5✔
120	...handler: Array<Handler>	5✔
121	): Fastro {	5✔
122	return this.add("OPTIONS", path, ...handler);	7✔
123	}	7✔
124	head(	5✔
125	path: string,	5✔
126	handler: Handler,	5✔
127	...middleware: Array<Handler>	5✔
128	): Fastro {	5✔
129	return this.add("HEAD", path, handler, ...middleware);	7✔
130	}	7✔
131	page<T = any>(	5✔
132	path: string,	5✔
133	page: Page<T>,	5✔
134	...middleware: Array<Handler>	5✔
135	): Fastro {	5✔
136	return this.#addPage(path, page, ...middleware);	8✔
137	}	8✔
138	use(...handlers: Handler[]): Fastro {	5✔
139	for (let index = 0; index < handlers.length; index++) {	6✔
140	const element = handlers[index];	6✔
141	const middleware: Middleware = {	6✔
142	path: undefined,	6✔
143	method: undefined,	6✔
144	handler: element,	6✔
145	};	6✔
146	this.#middleware.push(middleware);	6✔
147	}	6✔
148	return this;	6✔
149	}	6✔
150
151	static(	5✔
152	path: string,	5✔
153	options?: { maxAge?: number; folder?: string; referer?: boolean },	5✔
154	) {	5✔
155	this.#staticUrl = path;	6✔
156	if (options?.folder) this.#staticFolder = options?.folder;	6✔
157	if (options?.referer) this.#staticReferer = options.referer;	×
158	if (options?.maxAge) this.#maxAge = options.maxAge;	6✔
159	return this;	6✔
160	}	6✔
161
162	#addPage = (path: string, page: Page, ...middlewares: Handler[]) => {	5✔
163	const key = path;	8✔
164	this.#routePage[key] = page;	8✔
165	if (middlewares.length > 0) {	8✔
166	this.#pushPageMiddleware(path, ...middlewares);	8✔
167	}	8✔
168	return this;	8✔
169	};	5✔
170
171	#pushPageMiddleware = (	5✔
172	path: string,	5✔
173	...middlewares: Array<Handler>	5✔
174	) => {
175	for (let index = 0; index < middlewares.length; index++) {	8✔
176	const handler = middlewares[index];	8✔
177	this.#pageMiddleware.push({	8✔
178	method: undefined,	8✔
179	path,	8✔
180	handler,	8✔
181	});	8✔
182	}	8✔
183	};	5✔
184
185	add = (	5✔
186	method: string,	5✔
187	path: string,	5✔
188	...handler: Handler[]	5✔
189	) => {
190	const key = method + "-" + path;	49✔
191	if (handler.length === 1) {	49✔
192	this.#routeHandler[key] = handler[0];	92✔
193	return this;	92✔
194	}	92✔
195
196	this.#push(method, path, ...handler);	50✔
197	return this;	50✔
198	};	5✔
199
200	#push = (	5✔
201	method: any,	5✔
202	path: any,	5✔
203	...handlers: Array<Handler>	5✔
204	) => {
205	for (let index = 0; index < handlers.length - 1; index++) {	6✔
206	const handler = handlers[index];	6✔
207	this.#middleware.push({	6✔
208	method,	6✔
209	path,	6✔
210	handler,	6✔
211	});	6✔
212	}	6✔
213	const key = method + "-" + path;	6✔
214	this.#routeHandler[key] = handlers[handlers.length - 1];	6✔
215	};	5✔
216
217	#build = async () => {	5✔
218	// deno-lint-ignore no-deprecated-deno-api	8✔
219	if (Deno.run === undefined) {	×
220	return [];	×
221	}	×
222	for (const [_key, page] of Object.entries(this.#routePage)) {	8✔
223	await this.#createHydrate(page);	11✔
224	const result = await this.#buildPageComponent(page);	11✔
225	if (	11✔
226	Deno.env.get("ENV") === "DEVELOPMENT" && result && result.outputFiles	11✔
227	) {	11✔
228	for (const out of result.outputFiles) {	12✔
229	const fc = page.component as FunctionComponent;	12✔
230	const decoder = new TextDecoder();	12✔
231	const str = decoder.decode(out.contents);	12✔
232	const path =	12✔
233	`/js/${fc.name.toLocaleLowerCase()}.${this.getNonce()}.js`;	12✔
234	this.add(	×
235	"GET",	×
236	path,	×
237	() => {	×
238	return new Response(str, {	×
239	headers: { "content-type": "application/javascript" },	×
240	});	×
241	},	×
242	);
243	}	12✔
244	}	12✔
245	}	11✔
246	return Deno.args.filter((v) => v === "--build");	×
247	};	5✔
248
249	#createHydrate = async (c: Page) => {	5✔
250	if (typeof c.component != "function") return;	8✔
251	const name = c.component.name.toLocaleLowerCase();	10✔
252	const folder = c.folder ? c.folder + "/" : "";	×
253	const [d] = Deno.args.filter((v) => v === "--debug");	×
254	const debug = !d ? "" : `import "preact/debug";	×
255	`;	×
256	const str = `${debug}import { h, hydrate } from "preact";	8✔
257	import app from "../${folder}${name}.page.tsx";	8✔
258	async function fetchProps(root: HTMLElement) {
259	try {
260	const parsedUrl = new URL(window.location.href);
261	const key = parsedUrl.pathname === "/" ? "" : parsedUrl.pathname;
262	const url = "/__/props" + key;
263	const response = await fetch(url);
264	const data = await response.json();
265	if (!data) throw new Error("undefined");
266	hydrate(h(app, { data }), root);
267	} catch (error) {
268	setTimeout(() => {
269	fetchProps(root);
270	}, 500);
271	}
272	}
273	const root = document.getElementById("root");
274	if (root) fetchProps(root);
275	`;	8✔
276
277	const dir = Deno.cwd() + "/.fastro";	8✔
278	try {	8✔
279	Deno.readDirSync(dir);	8✔
280	} catch {	8✔
281	Deno.mkdirSync(dir);	9✔
282	}	9✔
283
284	const path = dir + "/" + name + ".hydrate.tsx";	10✔
285	await Deno.writeTextFile(path, str);	10✔
286	};	5✔
287
288	async #buildPageComponent(c: Page) {	5✔
289	if (typeof c.component == "function") {	8✔
290	const str = c.component.name.toLocaleLowerCase() +	10✔
291	".page.tsx";	10✔
292	console.log(	10✔
293	`%cBuild: %c${str}`,	10✔
294	"color: blue",	10✔
295	"color: white",	10✔
296	);
297
298	const es = new EsbuildMod(c);	10✔
299	return await es.build();	10✔
300	}	10✔
301	}	8✔
302
303	#getParamsHandler<T extends Record<string, Handler>>(	5✔
304	req: Request,	5✔
305	data: T,	5✔
306	): [Handler, Record<string, string \| undefined> \| undefined] \| undefined {
307	for (const [key, handler] of Object.entries(data)) {	20✔
308	const [method, path] = key.split("-");	146✔
309	const pattern = new URLPattern({ pathname: path });	438✔
310	if (key.includes(":") && pattern.test(req.url) && req.method === method) {	146✔
311	const exec = pattern.exec(req.url);	155✔
312	const params = exec?.pathname.groups;	155✔
313	return [handler, params];	620✔
314	}	155✔
315	}	146✔
316	}	20✔
317
318	#getParamsPage<T extends Record<string, Page>>(	5✔
319	req: Request,	5✔
320	data: T,	5✔
321	): [Page, Record<string, string \| undefined> \| undefined] \| undefined {
322	for (const [path, page] of Object.entries(data)) {	10✔
323	const pattern = new URLPattern({ pathname: path });	36✔
324	if (path.includes(":") && pattern.test(req.url)) {	12✔
325	const match = pattern.exec(req.url);	13✔
326	const params = match?.pathname.groups;	13✔
327	return [page, params];	52✔
328	}	13✔
329	}	12✔
330	}	10✔
331
332	#handleStaticFile = async (req: Request) => {	5✔
333	const s = (await this.#findStaticFiles(	9✔
334	this.#staticUrl,	9✔
335	req.url,	9✔
336	this.getNonce(),	9✔
337	)) as Static;
338	if (s) {	×
339	const ref = checkReferer(req);	×
340	if (ref && this.#staticReferer) return ref;	×
341	return new Response(s.file, {	×
342	headers: {	×
343	"Content-Type": s.contentType,	×
344	"Cache-Control": `max-age=${this.#maxAge}`,	×
345	},	×
346	});	×
347	}	×
348
349	const b = await this.#handleBinary(this.#staticUrl, req.url);	9✔
350	if (b) return b;	9✔
351
352	return new Response(STATUS_TEXT[STATUS_CODE.NotFound], {	12✔
353	status: STATUS_CODE.NotFound,	12✔
354	});	12✔
355	};	5✔
356
357	#addPropsEndpoint = () => {	5✔
358	const path = "/__/props/:key*";	8✔
359	this.add("GET", path, (req, _ctx) => {	8✔
360	const ref = checkReferer(req);	9✔
361	if (!getDevelopment() && ref) return ref;	×
362	const data = this.serverOptions[req.url];	9✔
363	return new Response(JSON.stringify(data), {	9✔
364	headers: new Headers({	9✔
365	"Content-Type": "application/json",	9✔
366	"Access-Control-Allow-Origin": "null",	9✔
367	"Access-Control-Allow-Methods": "GET",	9✔
368	"Access-Control-Allow-Headers": "Content-Type",	9✔
369	}),	9✔
370	});	9✔
371	});	8✔
372	};	5✔
373
374	#handlePage = (	5✔
375	req: Request,	5✔
376	info: Deno.ServeHandlerInfo,	5✔
377	) => {
378	const url = new URL(req.url);	12✔
379	let key = url.pathname;	12✔
380	let page: Page = this.#routePage[key];	12✔
381	let params: Record<string, string \| undefined> \| undefined = undefined;	12✔
382	if (!page) {	12✔
383	const res = this.#getParamsPage(req, this.#routePage);	17✔
384	if (res) {	17✔
385	const [pg, prm] = res;	18✔
386	page = pg;	18✔
387	params = prm;	18✔
388	}	18✔
389	}	17✔
390	if (!page) return [];	12✔
391	const ctx = this.serverOptions as Context;	15✔
392	ctx.render = <T>(data: T, headers?: Headers) => {	15✔
393	const r = new Render(this);	18✔
394	key = key === "/" ? "" : key;	18✔
395	key = url.origin + "/__/props" + key;	18✔
396	return r.render(key, page, data, this.getNonce(), headers);	18✔
397	};	15✔
398	ctx.info = info;	15✔
399	ctx.next = () => {};	×
400	ctx.url = new URL(req.url);	15✔
401	ctx.server = this;	15✔
NEW 402	ctx.send = <T>(data: T, status = 200, headers?: Headers) => {	×
NEW 403	return createResponse(data, status, headers);	×
UNCOV 404	};	×
405	ctx.kv = this.serverOptions["kv"];	15✔
406	ctx.options = this.serverOptions;	15✔
407	return [page, ctx, params, url];	90✔
408	};	5✔
409
410	#findMatch(	5✔
411	m: Middleware,	5✔
412	id: string,	5✔
413	url: string,	5✔
414	method: string,	5✔
415	page?: boolean,	5✔
416	) {
417	const r = this.#record[id];	61✔
418	if (r) return r as URLPatternResult;	61✔
419
420	const pattern = m.path	61✔
421	? new URLPattern({ pathname: m.path })	214✔
422	: new URLPattern({ pathname: "/*" });	207✔
423
424	const result = pattern.exec(url);	61✔
425	if (!result) return undefined;	61✔
426	if (!page && (m.path !== undefined) && (m.method !== method)) {	×
427	return undefined;	×
428	}	✔
429
430	return this.#record[id] = result;	89✔
431	}	61✔
432
433	#handlePageMiddleware = (	5✔
434	req: Request,	5✔
435	info: Deno.ServeHandlerInfo,	5✔
436	) => {
437	const page = true;	12✔
438	return this.#handleMiddleware(req, info, page);	12✔
439	};	5✔
440
441	#handleMiddleware = async (	5✔
442	req: Request,	5✔
443	info: Deno.ServeHandlerInfo,	5✔
444	page?: boolean,	5✔
445	) => {
446	const mid = !page ? this.#middleware : this.#pageMiddleware;	46✔
447	if (mid.length === 0) return undefined;	46✔
448	const method: string = req.method, url: string = req.url;	75✔
449	const u = new URL(url);	75✔
450	for (let index = 0; index < mid.length; index++) {	46✔
451	const m = mid[index];	102✔
452	const id = method + m.method + m.path + url;	102✔
453	const match = !page	102✔
454	? this.#findMatch(m, id, url, method)	102✔
455	: this.#findMatch(m, id, url, method, true);	102✔
456
457	if (!match) continue;	102✔
458	const x = await m.handler(	102✔
459	this.#transformRequest(req, match?.pathname.groups, u),	102✔
460	this.#transformCtx(info, u, this.serverOptions),	102✔
461	) as any;
462
463	if (x instanceof Response) {	×
464	return x;	×
465	}	×
466	}	102✔
467	};	5✔
468
469	#iterableToRecord(	5✔
470	params: URLSearchParams,	5✔
471	) {
472	const record: Record<string, string> = {};	64✔
473	params.forEach((v, k) => (record[k] = v));	×
474	return record;	64✔
475	}	64✔
476
477	#transformRequest = (	5✔
478	req: Request,	5✔
479	params?: Record<string, string \| undefined>,	5✔
480	url?: URL,	5✔
481	) => {
482	const u = url ?? new URL(req.url);	×
483	const r = req as HttpRequest;	64✔
484	r.params = params;	64✔
485	r.parseBody = parseBody(req);	64✔
486	r.query = this.#iterableToRecord(u.searchParams);	64✔
487	return r;	64✔
488	};	5✔
489
490	#transformCtx = (	5✔
491	info: Deno.ServeHandlerInfo,	5✔
492	url: URL,	5✔
493	options: Record<string, any>,	5✔
494	) => {
495	const ctx = options as Context;	67✔
496	const r = new Render(this);	67✔
497	ctx.render = <T>(jsx: T) => {	67✔
498	return r.renderJsx(jsx as JSX.Element);	68✔
499	};	67✔
500	ctx.send = <T>(data: T, status = 200) => {	67✔
501	return createResponse(data, status);	73✔
502	};	67✔
503	ctx.info = info;	67✔
504	ctx.next = () => {};	67✔
505	ctx.url = url;	67✔
506	ctx.server = this;	67✔
507	ctx.kv = this.serverOptions["kv"];	67✔
508	return ctx;	67✔
509	};	5✔
510
511	#handleRequest = (req: Request, info: Deno.ServeHandlerInfo) => {	5✔
512	const id = req.method + req.url;	39✔
513	if (this.#record[id]) return this.#record[id];	39✔
514	const url = new URL(req.url);	72✔
515	const key = req.method + "-" + url.pathname;	72✔
516	let handler = this.#routeHandler[key];	72✔
517	let params: Record<string, string \| undefined> \| undefined;	72✔
518	if (!handler) {	39✔
519	const res = this.#getParamsHandler(req, this.#routeHandler);	54✔
520	if (res) {	54✔
521	const [h, p] = res;	63✔
522	handler = h;	63✔
523	params = p;	63✔
524	}	63✔
525	}	54✔
526
527	const ctx = this.#transformCtx(info, url, this.serverOptions);	72✔
528	return this.#record[id] = { handler, ctx, params, url };	432✔
529	};	5✔
530
531	#createHandler = () => {	5✔
532	return async (req: Request, info: Deno.ServeHandlerInfo) => {	8✔
533	const m = await this.#handleMiddleware(req, info);	42✔
534	if (m) return m;	×
535
536	const r = this.#handleRequest(req, info);	42✔
537	if (r.handler) {	42✔
538	const tr = this.#transformRequest(req, r.params, r.url);	69✔
539	const res = await r.handler(tr, r.ctx);	69✔
540	return createResponse(res);	95✔
541	}	95✔
542
543	const pm = await this.#handlePageMiddleware(req, info);	49✔
544	if (pm) return pm;	×
545
546	const [page, pageCtx, pageParams, pageUrl] = this.#handlePage(	49✔
547	req,	49✔
548	info,	49✔
549	) as any;
550	if (page) {	42✔
551	return page.handler(	45✔
552	this.#transformRequest(req, pageParams, pageUrl),	45✔
553	pageCtx,	45✔
554	) as Promise<Response>;
555	}	45✔
556
557	return this.#handleStaticFile(req);	46✔
558	};	8✔
559	};	5✔
560
561	#normalizeStaticUrl = (url: string, reqUrl: string) => {	5✔
562	const staticUrl = url === "/" ? "" : url;	13✔
563	const pathname = `${staticUrl}/*`;	13✔
564	const id = `${pathname}${reqUrl}`;	13✔
565	return [id, pathname];	52✔
566	};	5✔
567
568	#findStaticFiles = async (url: string, initReqUrl: string, nonce: string) => {	5✔
569	let reqUrl = "";	9✔
570	if (initReqUrl.endsWith(`${nonce}.js`)) {	×
571	const [script] = initReqUrl.split(nonce);	×
572	reqUrl = script + "js";	×
573	}	×
574	const [id, pathname] = this.#normalizeStaticUrl(url, reqUrl);	9✔
575	if (this.#record[id]) return this.#record[id];	×
576
577	const pattern = new URLPattern({ pathname });	27✔
578	const match = pattern.exec(reqUrl);	9✔
579	if (!match) return this.#record[id] = null;	9!
580
581	const input = match?.pathname.groups["0"];	×
582	const filePath = `${this.#staticFolder}/${input}`;	9✔
583	const ct = contentType(extname(filePath)) \|\| "application/octet-stream";	×
584
585	const binary = ["png", "jpeg", "jpg", "gif", "pdf", "aac", "ico"];	81✔
586	const b = binary.filter((v) => ct.includes(v));	×
587	if (b.length > 0) return this.#record[id] = null;	×
588
589	let file;	×
590	try {	×
591	file = await Deno.readTextFile(`./${filePath}`);	×
592	} catch {	×
593	return this.#record[id] = null;	×
594	}	×
595
596	return this.#record[id] = { contentType: ct, file };	×
597	};	×
598
599	#handleBinary = async (url: string, reqUrl: string) => {	5✔
600	const [id, pathname] = this.#normalizeStaticUrl(url, reqUrl);	9✔
601	try {	9✔
602	const match = new URLPattern({ pathname }).exec(reqUrl);	27✔
603	const filePath = `${this.#staticFolder}/${match?.pathname.groups["0"]}`;	9✔
604	const ct = contentType(extname(filePath)) \|\| "application/octet-stream";	9✔
605	if (filePath.endsWith("/")) {	×
606	return this.#record[id] = null;	×
607	}	×
608	const file = await Deno.open(`./${filePath}`, { read: true });	27✔
609	return new Response(file.readable, {	10✔
610	headers: {	10✔
611	"Content-Type": ct,	10✔
612	"Cache-Control": `max-age=${this.#maxAge}`,	10✔
613	},	10✔
614	});	10✔
615	} catch {	9✔
616	return this.#record[id] = null;	12✔
617	}	12✔
618	};	5✔
619
620	group = (mf: ModuleFunction) => {	5✔
621	return Promise.resolve(mf(this));	6✔
622	};	5✔
623
624	serve = async (options?: { port?: number; onListen?: ListenHandler }) => {	5✔
625	const [s] = await this.#build();	8✔
626	if (s) return Deno.exit();	×
627
628	this.#server = Deno.serve({	8✔
629	port: options && options.port ? options.port : 8000,	×
630	handler: this.#handler,	8✔
631	signal: this.#ac.signal,	8✔
632	onListen: options && options.onListen ? options.onListen : undefined,	×
633	});	8✔
634	};	5✔
635
636	shutdown = async () => {	5✔
637	if (this.#server) {	8✔
638	this.#server.finished.then(() => console.log("Server closed"));	8✔
639	console.log("Closing server...");	8✔
640	this.#ac.abort();	8✔
641	await this.#server.shutdown();	8✔
642	}	8✔
643	};	5✔
644
645	getPages(): Record<string, Page> {	×
646	return this.#routePage;	×
647	}	×
648
649	getRoutes(): Record<string, Handler> {	×
650	return this.#routeHandler;	×
651	}	×
652
653	#server: Deno.HttpServer \| undefined;	5✔
654	#ac: AbortController = new AbortController();	5✔
655	#handler: (	5✔
656	req: Request,
657	info: Deno.ServeHandlerInfo,
658	) => Response \| Promise<Response>;	5✔
659	#routeHandler: Record<string, Handler> = {};	5✔
660	#routePage: Record<string, Page> = {};	5✔
661	#record: Record<string, any> = {};	5✔
662	#middleware: Middleware[] = [];	5✔
663	#pageMiddleware: Middleware[] = [];	5✔
664	#staticFolder = "static";	5✔
665	#staticUrl = "/";	5✔
666	#staticReferer = false;	5✔
667	#maxAge = 0;	5✔
668	#nonce = "";	5✔
669	serverOptions: Record<string, any> = {};	5✔
670	}	5✔

fastrodev / fastro / 10439270686

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous