123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408
import { serve, Server, ServerRequest, decode } from "../deps.ts";
/** * Fastro class *  *  *      const server = new Fastro() */export class Fastro {  /**    * Listen    *         *      server.listen({ port: 8000 })   **/  listen = async (    options?: ListenOptions,    callback?: (error: Error | undefined, address: string | undefined) => void,  ): Promise<void> => {    try {      let opt = options ? options : { port: 8080 };      this.#server = serve(opt);      if (!callback) console.info(opt);      else callback(undefined, opt as any);      // creates a loop iterating over async iterable objects      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of      for await (const req of this.#server) {        await this.requestHandler(req);      }    } catch (error) {      const errStr = "SERVER_LISTEN_ERROR";      if (callback) callback(FastroError(errStr, error), undefined);      else throw FastroError(errStr, error);    }  };
  private loadPlugin(fastro: Fastro, request: Request) {    this.#plugins.forEach((plugin) => {      plugin(fastro, request);    });  }
  /**   * Register plugin   *           *        const plugin = function (fastro: Fastro, request: Request) {   *           fastro.decorate((instance) => {   *              instance.hello = "hello";   *            });   *           request.ok = "ok";   *        };   *    *       server.register(plugin)   * @param plugin   */  register(plugin: Plugin) {    this.#plugins.push(plugin);    return this;  }
  /**   * Add route   *    *      server.route({   *        url: "/hello",   *        method: "GET",   *        handler: (req) => {   *          req.send("hello");   *        },   *       });   *    * @param router Router   *    **/  route(router: Router) {    try {      const filteredRoutes = this.#router.filter((value) => {        return this.checkUrl(router.url, value.url) &&          router.method === value.method;      });      if (filteredRoutes.length > 0) {        const [route] = filteredRoutes;        const errStr = `Duplicate route: ${          JSON.stringify(route)        } already added.`;        throw FastroError("SERVER_ROUTE_ERROR", new Error(errStr));      }      this.#router.push(router);      return this;    } catch (error) {      throw FastroError("SERVER_ROUTE_ERROR", error);    }  }
  /**   *    * @param url    * @param handler    */  all(url: string, handler: Handler) {    this.route({ method: "GET", url, handler });    this.route({ method: "POST", url, handler });    this.route({ method: "HEAD", url, handler });    this.route({ method: "PATCH", url, handler });    this.route({ method: "OPTIONS", url, handler });    this.route({ method: "PUT", url, handler });    this.route({ method: "DELETE", url, handler });  }
  /**   * GET route shorthand declaration   *    *       server.get('/', (req) => req.send('hello'))   *    * @param url    * @param handler    */  get(url: string, handler: Handler) {    return this.route({ method: "GET", url, handler });  }
  /**   * POST route shorthand declaration   *    *       server.post('/', (req) => {   *          const payload = req.payload;   *          req.send(payload);   *       })   *    * @param url    * @param handler    */  post(url: string, handler: Handler) {    return this.route({ method: "POST", url, handler });  }
  /**   * HEAD route shorthand declaration   * @param url    * @param handler    */  head(url: string, handler: Handler) {    return this.route({ method: "HEAD", url, handler });  }
  /**   * PATCH route shorthand declaration   * @param url    * @param handler    */  patch(url: string, handler: Handler) {    return this.route({ method: "PATCH", url, handler });  }
  /**   * PUT route shorthand declaration   * @param url    * @param handler    */  put(url: string, handler: Handler) {    return this.route({ method: "PUT", url, handler });  }
  /**   * OPTIONS route shorthand declaration   * @param url    * @param handler    */  options(url: string, handler: Handler) {    return this.route({ method: "OPTIONS", url, handler });  }
  /**   * DELETE shorthand declaration   * @param url    * @param handler    */  delete(url: string, handler: Handler) {    return this.route({ method: "DELETE", url, handler });  }
  /** Close server */  async close(): Promise<void> {    if (this.#server) {      this.#server.close();    }  }
  /**   * Add new property or function to Fastro instance   *    *      const middleware = function (instance: Fastro) {   *        instance.hello = function () {   *          console.log("hello");   *        };   *      };   *   *      server.decorate(middleware);   *      server.hello();   *    * @param instance    */  decorate(instance: { (instance: Fastro): void }) {    instance(this);    return this;  }
  /**   * Add plugin   *    *      server.use((req) => {   *        console.log(req.headers.get("token"));   *      });   * @param plugin   */  use(handler: Handler): Fastro;  use(url: string, handler: Handler): Fastro;  use(handlerOrUrl: string | Handler, handler?: Handler) {    if (typeof handlerOrUrl !== "string") {      this.#middlewares.push({ url: "/", handler: handlerOrUrl });    }    if (handler && (typeof handlerOrUrl === "string")) {      this.#middlewares.push({ url: handlerOrUrl, handler });    }    return this;  }
  private mutateRequest(req: Request) {    const plugins = this.#middlewares.filter((p) => {      if (p.url === "/") return p;      return p.url && this.checkUrl(req.url, p.url);    });    let mutates = 0;    let mutate = false;    const [plugin] = plugins;    plugins.forEach((p) => {      mutate = p.handler(req, () => {});      if (mutates > 0) {        throw new Error(          "`req.send()` has been called. It can only be run once in a request.",        );      }      if (mutate) mutates++;    });    if (plugin.url) req.parameter = this.getParameter(req.url, plugin.url);    this.routeHandler(req, mutate);  }
  private requestHandler = async (req: ServerRequest) => {    try {      const request = req as Request;      request.payload = decode(await Deno.readAll(req.body));      request.send = (payload, status, headers): boolean => {        return this.send(payload, status, headers, req);      };      this.loadPlugin(this, request);      if (this.#middlewares.length > 0) this.mutateRequest(request);      else this.routeHandler(request);    } catch (error) {      throw FastroError("SERVER_REQUEST_HANDLER_ERROR", error);    }  };
  private routeHandler = async (    req: Request,    mutate?: boolean,  ) => {    try {      if (mutate) return;      const [route] = this.#router.filter((value) => {        return this.checkUrl(req.url, value.url) &&          (req.method == value.method);      });      if (!route) {        return req.respond({ body: `${req.url} not found`, status: 404 });      }      req.parameter = this.getParameter(req.url, route.url);      return route.handler(req, () => {});    } catch (error) {      throw FastroError("SERVER_ROUTE_HANDLER_ERROR", error);    }  };
  private send<T>(    payload: string | T,    status: number | undefined = 200,    headers: Headers | undefined = new Headers(),    req: ServerRequest,  ) {    try {      let body: any;      headers.set("X-Powered-By", "fastro");      if (typeof payload === "string") body = payload;      else body = JSON.stringify(payload);      req.respond({ status, headers, body });      return true; // this is used for request mutation flag    } catch (error) {      throw FastroError("SERVER_SEND_ERROR", error);    }  }
  private checkUrl(incoming: string, registered: string): boolean {    try {      const incomingSplit = incoming.substr(1, incoming.length).split("/");      const registeredSplit = registered.substr(1, registered.length).split(        "/",      );      const filtered = registeredSplit        .filter((value, idx) => {          if (value.startsWith(":")) return incomingSplit[idx];          return value === incomingSplit[idx];        });      return incomingSplit.length === filtered.length;    } catch (error) {      throw FastroError("CHECK_URL_ERROR", error);    }  }
  private getParameter(incoming: string, registered: string) {    try {      const incomingSplit = incoming.substr(1, incoming.length).split("/");      const registeredSplit = registered.substr(1, registered.length).split(        "/",      );      const param: Parameter = {};      registeredSplit        .map((path, idx) => {          return { path, idx };        })        .filter((value) => value.path.startsWith(":"))        .map((value) => {          const name = value.path.substr(1, value.path.length);          param[name] = incomingSplit[value.idx];        });      return param;    } catch (error) {      throw FastroError("GET_URL_PARAMETER_ERROR", error);    }  }
  [key: string]: any  // definite assignment assertion  // https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html  #server!: Server;  #router: Router[] = [];  #middlewares: Middleware[] = [];  #plugins: Plugin[] = [];}
export class Request extends ServerRequest {  /** URL parameter */  parameter!: Parameter;  /** Payload */  payload!: string;  /**   * Send payload   *         *      // send basic message, default http status 200   *      send('ok')   *    *      // send json object   *      send({ message: 'Hello' })   *    *      // send message with custom http status   *      send('not found', 404)   *    *      // send message with custom status & headers   *      const headers = new Headers()   *      headers.set('Authorization', `Bearer ${your_token}`)   *      send({ login: true }, 200, headers)   *    * @param payload    * @param status   * @param headers    *    */  send!: {    <T>(payload: string | T, status?: number, headers?: Headers): boolean;  };  [key: string]: any}
interface Router {  method: string;  url: string;  handler(req: Request, callback: Function): any;}interface ListenOptions {  port: number;  hostname?: string;}interface Middleware {  url?: string;  handler(req: Request, callback: Function): any;}interface Plugin {  (fastro: Fastro, request: Request): any;}interface Handler {  (req: Request, callback: Function): any;}interface Parameter {  [key: string]: string;}function FastroError(title: string, error: Error) {  error.name = title;  return error;}