@fastly/expressly 1.0.1-0 → 1.1.0

package/.nvmrc

@@ -1 +1 @@
-16
+18

package/README.md

@@ -53,4 +53,3 @@ This will start your service on [http://localhost:7676](http://localhost:7676).
 ## Examples
 
 Check out the JavaScript code examples for Compute@Edge on Fastly's [Developer Hub](https://developer.fastly.com/solutions/examples/javascript/).
-ß

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

@@ -1,11 +1,11 @@
-/// <reference types="@fastly/js-compute" />
-export declare class ECommonObject {
-    headers: Headers;
-    set(headerNameOrObject: string | {
-        [key: string]: string;
-    }, value?: string): void;
-    private appendHeader;
-    append(headerNameOrObject: string | {
-        [key: string]: string | string[];
-    }, value?: string | string[]): void;
-}
+export declare function addCommonMethods<T extends new (...args: any[]) => any>(Base: T): {
+    new (...args: any[]): {
+        [x: string]: any;
+        set(headerNameOrObject: string | {
+            [key: string]: string;
+        }, value?: string): void;
+        append(headerNameOrObject: string | {
+            [key: string]: string | string[];
+        }, value?: string | string[]): void;
+    };
+} & T;

package/dist/lib/routing/common.js

@@ -1,36 +1,35 @@
-export class ECommonObject {
-    constructor() {
-        this.headers = new Headers();
-    }
-    // Header helpers.
-    set(headerNameOrObject, value) {
-        if (typeof headerNameOrObject === "string") {
-            this.headers.set(headerNameOrObject, value);
+export function addCommonMethods(Base) {
+    return class extends Base {
+        // Header helpers.
+        set(headerNameOrObject, value) {
+            if (typeof headerNameOrObject === "string") {
+                this.headers.set(headerNameOrObject, value);
+            }
+            else {
+                Object.keys(headerNameOrObject).forEach((headerName) => {
+                    this.headers.set(headerName, headerNameOrObject[headerName]);
+                });
+            }
         }
-        else {
-            Object.keys(headerNameOrObject).forEach((headerName) => {
-                this.headers.set(headerName, headerNameOrObject[headerName]);
-            });
+        append(headerNameOrObject, value) {
+            const appendHeader = (headerName, headerValue) => {
+                if (typeof headerValue === "string") {
+                    this.headers.append(headerName, headerValue);
+                }
+                else if (Array.isArray(headerValue)) {
+                    headerValue.forEach((v) => {
+                        this.headers.append(headerName, v);
+                    });
+                }
+            };
+            if (typeof headerNameOrObject === "string") {
+                appendHeader(headerNameOrObject, value);
+            }
+            else {
+                Object.keys(headerNameOrObject).forEach((headerName) => {
+                    appendHeader(headerName, headerNameOrObject[headerName]);
+                });
+            }
         }
-    }
-    appendHeader(headerName, headerValue) {
-        if (typeof headerValue === "string") {
-            this.headers.append(headerName, headerValue);
-        }
-        else if (Array.isArray(headerValue)) {
-            headerValue.forEach((v) => {
-                this.headers.append(headerName, v);
-            });
-        }
-    }
-    append(headerNameOrObject, value) {
-        if (typeof headerNameOrObject === "string") {
-            this.appendHeader(headerNameOrObject, value);
-        }
-        else {
-            Object.keys(headerNameOrObject).forEach((headerName) => {
-                this.appendHeader(headerName, headerNameOrObject[headerName]);
-            });
-        }
-    }
+    };
 }

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

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

package/dist/lib/routing/request/index.d.ts

@@ -1,14 +1,11 @@
 /// <reference types="@fastly/js-compute" />
-import { ECommonObject } from "../common";
 import { CookieMap } from "./cookie-map";
 import { EConfig } from "..";
-export declare class ERequest extends ECommonObject {
+declare class ERequestBase extends Request {
     private config;
-    private event;
+    private readonly event;
     readonly clientInfo: ClientInfo;
-    readonly method: string;
-    headers: Headers;
-    url: URL;
+    urlObj: URL;
     query: URLSearchParams;
     params: {
         [key: string]: string;
@@ -21,7 +18,17 @@ export declare class ERequest extends ECommonObject {
     get secure(): boolean;
     get subdomains(): Array<string>;
     get hostname(): string;
-    json(): Promise<any>;
-    text(): Promise<string>;
-    arrayBuffer(): Promise<ArrayBuffer>;
 }
+export declare const ERequest: {
+    new (...args: any[]): {
+        [x: string]: any;
+        set(headerNameOrObject: string | {
+            [key: string]: string;
+        }, value?: string): void;
+        append(headerNameOrObject: string | {
+            [key: string]: string | string[];
+        }, value?: string | string[]): void;
+    };
+} & typeof ERequestBase;
+export type EReq = InstanceType<typeof ERequest>;
+export {};

package/dist/lib/routing/request/index.js

@@ -1,16 +1,19 @@
-import { ECommonObject } from "../common";
+import { addCommonMethods } from "../common";
 import { CookieMap } from "./cookie-map";
-export class ERequest extends ECommonObject {
+class ERequestBase extends Request {
     constructor(config, event) {
-        super();
+        super(event.request);
         this.config = config;
         this.event = event;
         this.params = {};
-        this.clientInfo = event.client;
-        this.method = event.request.method;
-        this.url = new URL(event.request.url);
-        this.query = this.url.searchParams;
-        this.headers = event.request.headers;
+        this.clientInfo = this.event.client;
+        this.urlObj = new URL(this.url);
+        this.query = this.urlObj.searchParams;
+        Object.defineProperty(this, 'url', {
+            get() {
+                return this.urlObj.toString();
+            }
+        });
         // Parse cookies.
         if (this.config.parseCookie) {
             this.cookies = new CookieMap(this.headers);
@@ -18,30 +21,22 @@ export class ERequest extends ECommonObject {
     }
     // Express-like URL helpers.
     get path() {
-        return this.url.pathname;
+        return this.urlObj.pathname;
     }
     get ip() {
         return this.clientInfo.address;
     }
     get protocol() {
-        return this.url.protocol;
+        return this.urlObj.protocol;
     }
     get secure() {
-        return this.url.protocol === "https";
+        return this.urlObj.protocol === "https";
     }
     get subdomains() {
-        return this.url.hostname.split(".").slice(0, -2);
+        return this.urlObj.hostname.split(".").slice(0, -2);
     }
     get hostname() {
-        return this.url.hostname;
-    }
-    async json() {
-        return await this.event.request.json();
-    }
-    async text() {
-        return await this.event.request.text();
-    }
-    async arrayBuffer() {
-        return await this.event.request.arrayBuffer();
+        return this.urlObj.hostname;
     }
 }
+export const ERequest = addCommonMethods(ERequestBase);

package/dist/lib/routing/request-handler.d.ts

@@ -1,10 +1,10 @@
-import { ERequest } from "./request";
-import { EResponse } from "./response";
-export declare type RequestHandlerCallback = (req: ERequest, res: EResponse) => Promise<any>;
+import { EReq } from "./request";
+import { ERes } from "./response";
+export type RequestHandlerCallback = (req: EReq, res: ERes) => Promise<any>;
 export declare class RequestHandler {
     private matchFn;
     private callback;
     constructor(matchFn: Function, callback: RequestHandlerCallback);
-    check(event: ERequest): 0 | 404 | string[];
-    run(req: ERequest, res: EResponse): Promise<any>;
+    check(event: EReq): 0 | 404 | string[];
+    run(req: EReq, res: ERes): Promise<any>;
 }

package/dist/lib/routing/response/headers.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="@fastly/js-compute" />
+export declare class EHeaders extends Headers {
+    cookies: Map<string, string>;
+    constructor();
+    private setCookie;
+    set(name: string, value: string): void;
+    append(name: string, value: string): void;
+    delete(name: string): void;
+}

package/dist/lib/routing/response/headers.js

@@ -0,0 +1,29 @@
+export class EHeaders extends Headers {
+    constructor() {
+        super();
+        this.cookies = new Map();
+    }
+    setCookie(value) {
+        const [cookieName] = value.split("=");
+        this.cookies.set(cookieName, value);
+    }
+    set(name, value) {
+        if (/^Set-Cookie$/i.test(name)) {
+            this.cookies.clear();
+            this.setCookie(value);
+        }
+        super.set(name, value);
+    }
+    append(name, value) {
+        if (/^Set-Cookie$/i.test(name)) {
+            this.setCookie(value);
+        }
+        super.append(name, value);
+    }
+    delete(name) {
+        if (/^Set-Cookie$/i.test(name)) {
+            this.cookies.clear();
+        }
+        super.delete(name);
+    }
+}

package/dist/lib/routing/response/index.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="@fastly/js-compute" />
-import { ECommonObject } from "../common";
 import { SurrogateKeys } from "./surrogate-keys";
+import { EHeaders } from "./headers";
 import { CookieOptions, EConfig } from "..";
-export declare class EResponse extends ECommonObject {
+declare class EResponseBase {
     private config;
-    headers: Headers;
+    headers: EHeaders;
     status: number;
     body: BodyInit;
     hasEnded: boolean;
@@ -22,3 +22,16 @@ export declare class EResponse extends ECommonObject {
     text(data: string): void;
     html(data: string, charset?: string): void;
 }
+export declare const EResponse: {
+    new (...args: any[]): {
+        [x: string]: any;
+        set(headerNameOrObject: string | {
+            [key: string]: string;
+        }, value?: string): void;
+        append(headerNameOrObject: string | {
+            [key: string]: string | string[];
+        }, value?: string | string[]): void;
+    };
+} & typeof EResponseBase;
+export type ERes = InstanceType<typeof EResponse>;
+export {};

package/dist/lib/routing/response/index.js

@@ -1,12 +1,12 @@
 import cookie from "cookie";
-import { ECommonObject } from "../common";
+import { addCommonMethods } from "../common";
 import { statusText } from "./status-codes";
 import { SurrogateKeys } from "./surrogate-keys";
-export class EResponse extends ECommonObject {
+import { EHeaders } from "./headers";
+class EResponseBase {
     constructor(config) {
-        super();
         this.config = config;
-        this.headers = new Headers();
+        this.headers = new EHeaders();
         this.status = 0;
         this.body = null;
         this.hasEnded = false;
@@ -25,7 +25,7 @@ export class EResponse extends ECommonObject {
     clearCookie(key, options = {}) {
         if (this.hasEnded)
             return;
-        this.headers.append("Set-Cookie", cookie.serialize(key, "", { ...options, expires: "Thu, 01 Jan 1970 00:00:00 GMT" }));
+        this.cookie(key, "", { ...options, expires: new Date("Thu, 01 Jan 1970 00:00:00 GMT") });
     }
     // Response lifecycle methods.
     send(response) {
@@ -33,8 +33,10 @@ export class EResponse extends ECommonObject {
             return;
         if (response instanceof Response) {
             this.body = response.body;
-            this.headers = response.headers;
-            this.status = response.status;
+            // Append, rather than overwrite headers.
+            response.headers.forEach((value, key) => this.headers.append(key, value));
+            // Do not overwrite user-defined status.
+            this.status = this.status || response.status;
         }
         else {
             this.body = response;
@@ -99,3 +101,4 @@ export class EResponse extends ECommonObject {
         this.send(data);
     }
 }
+export const EResponse = addCommonMethods(EResponseBase);

package/dist/lib/routing/router.js

@@ -13,7 +13,40 @@ const defaultErrorHandler = (auto405) => async (err, req, res) => {
         res.headers.set("Allow", err.allow);
         return res.sendStatus(405);
     }
-    res.withStatus(500).json({ error: err });
+    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) {
@@ -23,12 +56,15 @@ export class Router {
             parseCookie: true,
             auto405: true,
             extractRequestParameters: true,
-            autoContentType: false
+            autoContentType: false,
         };
         this.config = {
             ...this.config,
             ...config
         };
+        if (this.config.autoCorsPreflight) {
+            this.options("*", preflightHandler(this.config.autoCorsPreflight));
+        }
     }
     listen() {
         addEventListener("fetch", (event) => event.respondWith(this.handler(event)));
@@ -140,7 +176,7 @@ export class Router {
                     pathMatcherCache.set(pattern, match(pattern, { decode: decodeURIComponent }));
                 }
                 // Match on pathname.
-                let { path, params } = pathMatcherCache.get(pattern)(req.url.pathname) || {};
+                let { path, params } = pathMatcherCache.get(pattern)(req.urlObj.pathname) || {};
                 if (path) {
                     if (this.config.extractRequestParameters) {
                         req.params = params;
@@ -153,13 +189,16 @@ export class Router {
         };
     }
     static serializeResponse(res) {
-        // Default to 200 / 204 if no status was set by middleware / route handler.
-        if (res.status === 0) {
-            res.status = Boolean(res.body) ? 200 : 204;
-        }
-        return new Response(res.body, {
+        const response = new Response(res.body, {
             headers: res.headers,
-            status: res.status,
+            // Default to 200 / 204 if no status was set by middleware / route handler.
+            status: res.status ? res.status : Boolean(res.body) ? 200 : 204,
         });
+        if (res.headers.cookies.size) {
+            // Loop cookies manually to work around this issue: https://github.com/fastly/js-compute-runtime/issues/47
+            response.headers.delete("Set-Cookie");
+            res.headers.cookies.forEach((c) => response.headers.append("Set-Cookie", c));
+        }
+        return response;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastly/expressly",
-  "version": "1.0.1-0",
+  "version": "1.1.0",
   "description": "Express-style router for Fastly's Compute@Edge.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,7 +14,7 @@
   "scripts": {
     "build": "tsc",
     "prepublish": "tsc",
-    "dev": "nodemon --exec \"tsc\""
+    "dev": "tsc --watch"
   },
   "keywords": [
     "fastly",
@@ -24,26 +24,25 @@
     "router"
   ],
   "engines": {
-    "node": "^16"
+    "node": ">=18"
   },
   "author": "oss@fastly.com",
   "license": "MIT",
   "devDependencies": {
-    "@types/node": "^17.0.40",
-    "auto": "^10.37.1",
-    "husky": "^8.0.1",
-    "nodemon": "^2.0.16",
-    "prettier": "^2.6.2",
+    "@types/node": "^18.11.18",
+    "auto": "^10.37.6",
+    "husky": "^8.0.3",
+    "prettier": "^2.8.2",
     "pretty-quick": "^3.1.3",
-    "ts-loader": "^9.3.0",
-    "typescript": "^4.7.3",
-    "webpack": "^5.73.0",
-    "webpack-cli": "^4.9.2"
+    "ts-loader": "^9.4.2",
+    "typescript": "^4.9.4",
+    "webpack": "^5.75.0",
+    "webpack-cli": "^5.0.1"
   },
   "dependencies": {
-    "@fastly/js-compute": "^0.2.4",
+    "@fastly/js-compute": "^1.1.0",
     "cookie": "^0.5.0",
-    "core-js": "^3.22.8",
+    "core-js": "^3.27.1",
     "path-to-regexp": "^6.2.1"
   },
   "auto": {

package/tsconfig.json

@@ -16,5 +16,8 @@
     "forceConsistentCasingInFileNames": true,
     "declaration": true
   },
-  "exclude": ["dist/", ".dora", "docs/"]
+  "exclude": ["node_modules"],
+  "include": [
+    "src/**/*.ts"
+  ]
 }