@fastly/expressly 2.1.0 → 2.2.0

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# v2.1.1 (Thu Oct 19 2023)
+
+#### ⚠️ Pushed to `main`
+
+- Delete src/.DS_Store ([@doramatadora](https://github.com/doramatadora))
+
+#### Authors: 1
+
+- Dora Militaru ([@doramatadora](https://github.com/doramatadora))

package/dist/lib/routing/error-middleware.d.ts

@@ -1,10 +1,11 @@
 import { EReq } from "./request";
 import { ERes } from "./response";
-export type ErrorMiddlewareCallback = (err: Error, req: EReq, res: ERes) => Promise<any>;
-export declare class ErrorMiddleware {
+import { EErr } from "./errors";
+export type ErrorMiddlewareCallback<Err extends EErr = EErr, Req extends EReq = EReq, Res extends ERes = ERes> = (err: Err, req: Req, res: Res) => Promise<any> | void;
+export declare class ErrorMiddleware<Err extends EErr = EErr, Req extends EReq = EReq, Res extends ERes = ERes> {
     private matchFn;
     private callback;
     constructor(matchFn: Function, callback: ErrorMiddlewareCallback);
-    check(event: EReq): 0 | 404 | string[];
-    run(err: Error, req: EReq, res: ERes): Promise<any>;
+    check(event: Req): 0 | 404 | string[];
+    run(err: Err, req: Req, res: Res): Promise<any>;
 }

package/dist/lib/routing/errors.d.ts

@@ -1,8 +1,12 @@
-export declare class ErrorNotFound extends Error {
+export declare class EErr extends Error {
+    status: number;
+    constructor(message?: string);
+}
+export declare class ErrorNotFound extends EErr {
     status: number;
     constructor();
 }
-export declare class ErrorMethodNotAllowed extends Error {
+export declare class ErrorMethodNotAllowed extends EErr {
     status: number;
     allow: string;
     constructor(allowedMethods: string[]);

package/dist/lib/routing/errors.js

@@ -1,11 +1,18 @@
-export class ErrorNotFound extends Error {
+export class EErr extends Error {
+    constructor(message) {
+        super(message);
+        this.status = 500;
+        Object.setPrototypeOf(this, EErr.prototype);
+    }
+}
+export class ErrorNotFound extends EErr {
     constructor() {
         super("Not Found");
         this.status = 404;
         Object.setPrototypeOf(this, ErrorNotFound.prototype);
     }
 }
-export class ErrorMethodNotAllowed extends Error {
+export class ErrorMethodNotAllowed extends EErr {
     constructor(allowedMethods) {
         super("Method Not Allowed");
         this.status = 405;

package/dist/lib/routing/router.d.ts

@@ -1,16 +1,25 @@
 import { EConfig, Method } from ".";
 import { RequestHandler, RequestHandlerCallback } from "./request-handler";
 import { ErrorMiddleware, ErrorMiddlewareCallback } from "./error-middleware";
+import { EErr } from "./errors";
 import { EReq } from "./request";
 import { ERes } from "./response";
-export declare class Router<Req extends EReq = EReq, Res extends ERes = ERes> {
-    requestHandlers: Array<RequestHandler>;
-    errorHandlers: Array<ErrorMiddleware>;
+export declare class Router<Req extends EReq = EReq, Res extends ERes = ERes, Err extends EErr = EErr> {
+    requestHandlers: Array<RequestHandler<Req, Res>>;
+    errorHandlers: Array<ErrorMiddleware<Err, Req, Res>>;
     config: EConfig;
     constructor(config?: EConfig);
     listen(): void;
     private handler;
-    use(path: string | RequestHandlerCallback<Req, Res> | ErrorMiddlewareCallback, callback?: RequestHandlerCallback<Req, Res> | ErrorMiddlewareCallback): void;
+    private defaultErrorHandler;
+    /**
+     * Handles preflight requests from trusted origins configured by the user when initializing a router.
+     * Note that the wildcard value "*" will fail if the request is sent with credentials (see: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin#directives)
+     * @param autoCorsPreflight the object containing CORS preflight option of trustedOrigins, an array of trusted origins.
+     * @returns 200 if the preflight request succeeds, 403 if it fails
+     */
+    private preflightHandler;
+    use(path: string | RequestHandlerCallback<Req, Res> | ErrorMiddlewareCallback<Err, Req, Res>, callback?: RequestHandlerCallback<Req, Res> | ErrorMiddlewareCallback<Err, Req, Res>): void;
     route(methods: Method[], pattern: string, callback: RequestHandlerCallback<Req, Res>): void;
     all(pattern: string, callback: RequestHandlerCallback<Req, Res>): void;
     get(pattern: string, callback: RequestHandlerCallback<Req, Res>): void;

package/dist/lib/routing/router.js

@@ -5,49 +5,6 @@ import { ErrorNotFound, ErrorMethodNotAllowed } from "./errors";
 import { ERequest } from "./request";
 import { EResponse } from "./response";
 const pathMatcherCache = new Map();
-const defaultErrorHandler = (auto405) => async (err, req, res) => {
-    if (err instanceof ErrorNotFound || (err instanceof ErrorMethodNotAllowed && !auto405)) {
-        return res.sendStatus(404);
-    }
-    else if (err instanceof ErrorMethodNotAllowed) {
-        res.headers.set("Allow", err.allow);
-        return res.sendStatus(405);
-    }
-    console.error(err);
-    res.withStatus(500).json({ error: err.message });
-};
-/**
- * Handles preflight requests from trusted origins configured by the user when initializing a router.
- * Note that the wildcard value "*" will fail if the request is sent with credentials (see: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin#directives)
- * @param autoCorsPreflight the object containing CORS preflight option of trustedOrigins, an array of trusted origins.
- * @returns 200 if the preflight request succeeds, 403 if it fails
- */
-const preflightHandler = (autoCorsPreflight) => async (req, res) => {
-    if (autoCorsPreflight.trustedOrigins.length === 0) {
-        return res.sendStatus(403);
-    }
-    let originHeaderValue = null;
-    if (autoCorsPreflight.trustedOrigins.length === 1 && autoCorsPreflight.trustedOrigins[0] === "*") {
-        originHeaderValue = "*";
-    }
-    else if (req.headers.has("origin")) {
-        const origin = req.headers.get("origin").toLowerCase();
-        if (autoCorsPreflight.trustedOrigins.some((trustedOrigin) => trustedOrigin.toLowerCase() === origin)) {
-            originHeaderValue = origin;
-        }
-    }
-    if (!originHeaderValue) {
-        return res.sendStatus(403);
-    }
-    if (req.headers.has("access-control-request-method")) {
-        res.headers.set("access-control-allow-methods", req.headers.get("access-control-request-method"));
-    }
-    if (req.headers.has("access-control-request-headers")) {
-        res.headers.set("access-control-allow-headers", req.headers.get("access-control-request-headers"));
-    }
-    res.headers.set("access-control-allow-origin", originHeaderValue);
-    return res.sendStatus(200);
-};
 export class Router {
     constructor(config) {
         this.requestHandlers = [];
@@ -63,7 +20,7 @@ export class Router {
             ...config
         };
         if (this.config.autoCorsPreflight) {
-            this.options("*", preflightHandler(this.config.autoCorsPreflight));
+            this.options("*", this.preflightHandler);
         }
     }
     listen() {
@@ -78,12 +35,55 @@ export class Router {
         }
         catch (err) {
             // Add default error handler.
-            this.use(defaultErrorHandler(this.config.auto405));
+            this.use(this.defaultErrorHandler);
             // Run error handler stack.
             await this.runErrorHandlers(err, req, res);
         }
         return Router.serializeResponse(res);
     }
+    async defaultErrorHandler(err, req, res) {
+        if (err instanceof ErrorNotFound || (err instanceof ErrorMethodNotAllowed && !this.config.auto405)) {
+            return res.sendStatus(404);
+        }
+        else if (err instanceof ErrorMethodNotAllowed) {
+            res.headers.set("Allow", err.allow);
+            return res.sendStatus(405);
+        }
+        console.error(err);
+        res.withStatus(500).json({ error: err.message });
+    }
+    /**
+     * Handles preflight requests from trusted origins configured by the user when initializing a router.
+     * Note that the wildcard value "*" will fail if the request is sent with credentials (see: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin#directives)
+     * @param autoCorsPreflight the object containing CORS preflight option of trustedOrigins, an array of trusted origins.
+     * @returns 200 if the preflight request succeeds, 403 if it fails
+     */
+    async preflightHandler(req, res) {
+        if (this.config.autoCorsPreflight.trustedOrigins.length === 0) {
+            return res.sendStatus(403);
+        }
+        let originHeaderValue = null;
+        if (this.config.autoCorsPreflight.trustedOrigins.includes("*")) {
+            originHeaderValue = "*";
+        }
+        else if (req.headers.has("origin")) {
+            const origin = req.headers.get("origin").toLowerCase();
+            if (this.config.autoCorsPreflight.trustedOrigins.some((trustedOrigin) => trustedOrigin.toLowerCase() === origin)) {
+                originHeaderValue = origin;
+            }
+        }
+        if (!originHeaderValue) {
+            return res.sendStatus(403);
+        }
+        if (req.headers.has("access-control-request-method")) {
+            res.headers.set("access-control-allow-methods", req.headers.get("access-control-request-method"));
+        }
+        if (req.headers.has("access-control-request-headers")) {
+            res.headers.set("access-control-allow-headers", req.headers.get("access-control-request-headers"));
+        }
+        res.headers.set("access-control-allow-origin", originHeaderValue);
+        return res.sendStatus(200);
+    }
     // Middleware attach point.
     use(path, callback) {
         const cb = path instanceof Function ? path : callback;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastly/expressly",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Express-style router for Fastly's Compute@Edge.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/test-d/error-test-d.ts

@@ -0,0 +1,34 @@
+import { expectType } from 'tsd';
+import { Router } from "../dist";
+import { EReq } from "../dist/lib/routing/request";
+import { ERes } from '../dist/lib/routing/response';
+import { EErr } from "../dist/lib/routing/errors";
+
+// Default Err types
+{
+  const router = new Router();
+  router.use(async (err, _, res) => {
+    expectType<EErr>(err)
+  });
+}
+
+// Custom Req and Res types
+{
+  interface MeowErr extends EErr {
+    meow(): string
+  }
+
+  interface WoofErr extends EErr {
+    woof(): string
+  }
+
+  interface MyErr extends MeowErr, WoofErr { }
+
+  const router = new Router<EReq,ERes,MyErr>();
+  router.use(async (err, _, res) => {
+    expectType<MyErr>(err)
+    err.meow()
+    err.woof()
+  });
+
+}