initial commit

Author: jamieecarrasquillo

.gitignore

@@ -0,0 +1,119 @@
+import { serve, ServeInit } from "https://deno.land/[email protected]/http/server.ts";
+import { Handler } from "./handler.ts";
+import {CatchFunc, HandleFunc, Matcher} from "./types.ts";
+import { Request as RoarterRequest } from "./request.ts";
+
+export class Application {
+  handlers: Handler[] = [];
+  catchFunc: CatchFunc = () => {
+    throw new Error("Not Implemented");
+  };
+
+  match(custom: Matcher): Handler {
+    const handler = new Handler().match(custom);
+    this.handlers.push(handler);
+    return handler;
+  }
+
+  get get(): Handler {
+    const handler = new Handler().get;
+    this.handlers.push(handler);
+    return handler;
+  }
+
+  get post(): Handler {
+    const handler = new Handler().post;
+    this.handlers.push(handler);
+    return handler;
+  }
+
+  get put(): Handler {
+    const handler = new Handler().put;
+    this.handlers.push(handler);
+    return handler;
+  }
+
+  get delete(): Handler {
+    const handler = new Handler().delete;
+    this.handlers.push(handler);
+    return handler;
+  }
+
+  get patch(): Handler {
+    const handler = new Handler().patch;
+    this.handlers.push(handler);
+    return handler;
+  }
+
+  path(path: string): Handler {
+    const handler = new Handler().path(path);
+    this.handlers.push(handler);
+    return handler;
+  }
+
+  queries(queries: string[]): Handler {
+    const handler = new Handler().queries(queries);
+    this.handlers.push(handler);
+    return handler;
+  }
+
+  handle(handler: HandleFunc | Application): Handler {
+    const h = new Handler().handle(handler);
+    this.handlers.push(h);
+    return h;
+  }
+
+  catch(fn: CatchFunc) {
+    this.catchFunc = fn;
+  }
+
+  // Handler runs all the registered handlers and returns the first
+  // response it finds. After returning the first response, it runs
+  // the remaining handlers. The purpose of this is to support middleware
+  // after a response has been sent.
+  async runHandlers(req: RoarterRequest): Promise<Response> {
+    let runRemaining = true
+    let i = 0;
+    try {
+      try {
+        for (i; i < this.handlers.length; i++) {
+          const handler = this.handlers[i];
+          const response = await handler.run(req);
+          if (response) {
+            i++;
+            return response;
+          }
+        }
+      } catch (e) {
+        // If an error occurs, we wan't to skip all handlers and run the catchFunc
+        runRemaining = false
+        return await this.catchFunc(req, e);
+      }
+      // If after running all the handlers there is no response, throw the error
+      throw new Error(
+        `No Response was sent for ${req.method} ${req.url}`,
+      );
+    } finally {
+      if (runRemaining) {
+        // Since at this point we have already returned a response,
+        // we run the remaining handlers ignoring their response and errors
+        for (i; i < this.handlers.length; i++) {
+          const handler = this.handlers[i];
+          handler.run(req).catch(e => {
+            this.catchFunc(req, e)
+          })
+        }
+      }
+    }
+  }
+
+  async handler(domReq: Request): Promise<Response> {
+    const req = new RoarterRequest(domReq);
+    return this.runHandlers(req)
+  }
+
+  async serve(options?: ServeInit) {
+    this.handler = this.handler.bind(this);
+    await serve(this.handler, options);
+  }
+}

.idea/.gitignore

@@ -0,0 +1,83 @@
+import { HandleFunc, Matcher } from "./types.ts";
+import {
+  buildPathMatcher,
+  buildQueryMatcher,
+  deleteMatcher,
+  getMatcher,
+  patchMatcher,
+  postMatcher,
+  putMatcher,
+} from "./matchers.ts";
+import { Response } from "./response.ts";
+import { Request } from "./request.ts";
+import {Application} from "./application.ts";
+
+export class Handler {
+  matchers: Matcher[] = [];
+  handler: (HandleFunc | Application) | null = null;
+
+  private isHandlerASubRouter(): boolean {
+    return this.handler instanceof Application
+  }
+
+  runMatchers(req: Request): boolean {
+    for (let i = 0; i < this.matchers.length; i++) {
+      const matcher: Matcher = this.matchers[i];
+      if (!matcher(req, this.isHandlerASubRouter())) return false;
+    }
+    return true;
+  }
+
+  async runHandler(req: Request) {
+    if (!this.handler) return;
+    if (this.isHandlerASubRouter()) {
+      return (this.handler as Application).runHandlers(req)
+    } else {
+      return (this.handler as HandleFunc)(req);
+    }
+  }
+
+  match(custom: Matcher): Handler {
+    this.matchers.push(custom);
+    return this;
+  }
+
+  get get(): Handler {
+    return this.match(getMatcher);
+  }
+
+  get post(): Handler {
+    return this.match(postMatcher);
+  }
+
+  get put(): Handler {
+    return this.match(putMatcher);
+  }
+
+  get delete(): Handler {
+    return this.match(deleteMatcher);
+  }
+
+  get patch(): Handler {
+    return this.match(patchMatcher);
+  }
+
+  path(urlPath: string): Handler {
+    return this.match(buildPathMatcher(urlPath));
+  }
+
+  queries(queries: string[]): Handler {
+    return this.match(buildQueryMatcher(queries));
+  }
+
+  handle(handler: HandleFunc | Application) {
+    this.handler = handler;
+    return this;
+  }
+
+  async run(req: Request) {
+    if (this.runMatchers(req)) {
+      return this.runHandler(req);
+    }
+  }
+}