@fastly/expressly 1.0.0-alpha.2 → 1.0.0-alpha.5

package/README.md

@@ -17,11 +17,11 @@ First, head over to [developer.fastly.com](https://developer.fastly.com) to get
 Install expressly from the [npm registry](https://www.npmjs.com/package/@fastly/expressly):
 
 ```shell
-npm i @fastly/expressly@1.0.0-alpha.2
+npm i @fastly/expressly
 ```
 
 ```shell
-yarn add @fastly/expressly@1.0.0-alpha.2
+yarn add @fastly/expressly
 ```
 
 ### Your first expressly app

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 declare 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/mixin.d.ts

@@ -0,0 +1 @@
+export declare function applyMixins(derivedConstructor: any, baseConstructors: any[]): void;

package/dist/lib/routing/mixin.js

@@ -0,0 +1,9 @@
+export function applyMixins(derivedConstructor, baseConstructors) {
+    baseConstructors.forEach(baseConstructor => {
+        Object.getOwnPropertyNames(baseConstructor.prototype).forEach(name => {
+            if (name !== 'constructor') {
+                derivedConstructor.prototype[name] = baseConstructor.prototype[name];
+            }
+        });
+    });
+}

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

@@ -1,13 +1,10 @@
 /// <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;
     urlObj: URL;
     query: URLSearchParams;
     params: {
@@ -15,14 +12,23 @@ export declare class ERequest extends ECommonObject {
     };
     cookies: CookieMap;
     constructor(config: EConfig, event: FetchEvent);
-    get url(): string;
     get path(): string;
     get ip(): string;
     get protocol(): string;
     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 declare type EReq = InstanceType<typeof ERequest>;
+export {};

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

@@ -1,25 +1,31 @@
-import { ECommonObject } from "../common";
+import { addCommonMethods } from "../common";
 import { CookieMap } from "./cookie-map";
-export class ERequest extends ECommonObject {
+// Will extend Request correctly after https://github.com/fastly/js-compute-runtime/pull/116 is merged
+// See: https://github.com/fastly/js-compute-runtime/issues/113
+class ERequestBase extends Request {
     constructor(config, event) {
-        super();
+        super(event.request, {
+            headers: event.request.headers,
+            method: event.request.method,
+            body: event.request.body,
+        });
         this.config = config;
         this.event = event;
         this.params = {};
-        this.clientInfo = event.client;
-        this.method = event.request.method;
-        this.urlObj = new URL(event.request.url);
+        this.clientInfo = this.event.client;
+        this.urlObj = new URL(this.url);
         this.query = this.urlObj.searchParams;
-        this.headers = event.request.headers;
+        Object.defineProperty(this, 'url', {
+            get() {
+                return this.urlObj.toString();
+            }
+        });
         // Parse cookies.
         if (this.config.parseCookie) {
             this.cookies = new CookieMap(this.headers);
         }
     }
     // Express-like URL helpers.
-    get url() {
-        return this.urlObj.toString();
-    }
     get path() {
         return this.urlObj.pathname;
     }
@@ -38,13 +44,5 @@ export class ERequest extends ECommonObject {
     get hostname() {
         return this.urlObj.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();
-    }
 }
+export const ERequest = addCommonMethods(ERequestBase);

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

@@ -0,0 +1,9 @@
+/// <reference types="@fastly/js-compute" />
+export declare class CookieMap extends Map {
+    private headers;
+    constructor(headers: Headers);
+    clear(): void;
+    set(key: string, value: string): this;
+    delete(key: string): boolean;
+    private serialize;
+}

package/dist/lib/routing/request/request-url.js

@@ -0,0 +1,37 @@
+import cookie from "cookie";
+export class CookieMap extends Map {
+    constructor(headers) {
+        super();
+        this.headers = headers;
+        if (Boolean(this.headers.get("Cookie"))) {
+            for (const [key, value] of Object.entries(cookie.parse(this.headers.get("Cookie")))) {
+                if (typeof value === "string") {
+                    super.set(key, value);
+                }
+            }
+        }
+    }
+    clear() {
+        this.headers.delete("Cookie");
+        super.clear();
+    }
+    set(key, value) {
+        super.set(key, value);
+        this.serialize();
+        return this;
+    }
+    delete(key) {
+        const deleteResult = super.delete(key);
+        this.serialize();
+        return deleteResult;
+    }
+    serialize() {
+        if (this.size) {
+            const cookies = [];
+            for (const [key, value] of this.entries()) {
+                cookies.push(cookie.serialize(key, value));
+            }
+            this.headers.set("Cookie", cookies.join("; "));
+        }
+    }
+}

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 declare 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/index.d.ts

@@ -1,8 +1,7 @@
 /// <reference types="@fastly/js-compute" />
-import { ECommonObject } from "../common";
 import { SurrogateKeys } from "./surrogate-keys";
 import { CookieOptions, EConfig } from "..";
-export declare class EResponse extends ECommonObject {
+declare class EResponseBase {
     private config;
     headers: Headers;
     status: number;
@@ -22,3 +21,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 declare type ERes = InstanceType<typeof EResponse>;
+export {};

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

@@ -1,16 +1,18 @@
 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 {
+// TODO: extends Response
+// See: https://github.com/fastly/js-compute-runtime/issues/113
+class EResponseBase {
     constructor(config) {
-        super();
         this.config = config;
         this.headers = new Headers();
         this.status = 0;
         this.body = null;
         this.hasEnded = false;
         this.surrogateKeys = new SurrogateKeys(this.headers);
+        // super();
     }
     // Header helpers.
     vary(field) {
@@ -99,3 +101,4 @@ export class EResponse extends ECommonObject {
         this.send(data);
     }
 }
+export const EResponse = addCommonMethods(EResponseBase);

package/dist/lib/routing/router.js

@@ -13,6 +13,7 @@ const defaultErrorHandler = (auto405) => async (err, req, res) => {
         res.headers.set("Allow", err.allow);
         return res.sendStatus(405);
     }
+    console.error(err);
     res.withStatus(500).json({ error: err });
 };
 export class Router {

package/package.json

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

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

@@ -1,10 +0,0 @@
-import ERequest from "./request";
-import EResponse from "./response";
-export declare type MiddlewareCallback = (req: ERequest, res: EResponse, next?: () => void) => Promise<any>;
-export declare class Middleware {
-    private matchFn;
-    private callback;
-    constructor(matchFn: Function, callback: MiddlewareCallback);
-    check(event: ERequest): 0 | 404 | 405;
-    run(req: ERequest, res: EResponse): Promise<any>;
-}

package/dist/lib/routing/middleware.js

@@ -1,13 +0,0 @@
-export class Middleware {
-    constructor(matchFn, callback) {
-        this.matchFn = matchFn;
-        this.callback = callback;
-    }
-    check(event) {
-        return this.matchFn(event);
-    }
-    async run(req, res) {
-        // Supply an empty callback as an equivalent of next() in Express.js.
-        await this.callback(req, res, () => { });
-    }
-}

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

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

package/dist/lib/routing/route.js

@@ -1,12 +0,0 @@
-export class Route {
-    constructor(matchFn, callback) {
-        this.matchFn = matchFn;
-        this.callback = callback;
-    }
-    check(event) {
-        return this.matchFn(event);
-    }
-    async run(req, res) {
-        await this.callback(req, res);
-    }
-}