@fastly/expressly 1.0.0--canary.4.2464710183.0

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,16 @@
+---
+name: Bug report
+about: Tell us about a bug to help us improve
+title: ''
+labels: bug
+assignees: doramatadora
+
+---
+
+**Version**
+
+Please provide the version of `expressly` that you're using.
+
+**What happened**
+
+Please describe what you did, what you expected to happen, and what happened instead.

package/.github/workflows/release.yml

@@ -0,0 +1,85 @@
+name: CI
+
+on:
+  - workflow_dispatch
+  - pull_request
+  - push
+
+concurrency:
+  group: ${{ github.ref_name }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: expressly
+    runs-on: ubuntu-latest
+    env:
+      GH_TOKEN: ${{ secrets.AUTO_GH_TOKEN }}
+      NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+      NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
+          cache: yarn
+      - name: Install dependencies
+        run: yarn install --frozen-lockfile --prefer-offline
+      - name: Node modules cache
+        id: node-modules-cache
+        uses: actions/cache@v2
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-expressly-${{ secrets.cache_key_epoch_time }}-${{ hashFiles('yarn.lock') }}
+      - name: Compile expressly
+        run: yarn build
+      - name: Publish
+        if: ${{ github.event_name == 'pull_request' }}
+        run: |
+          git fetch origin 'refs/tags/*:refs/tags/*'
+          yarn auto shipit
+
+  build-docs:
+    name: Docs
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./docs
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
+          cache: yarn
+      - name: Install dependencies
+        run: yarn install --frozen-lockfile --prefer-offline
+      - name: Node modules cache
+        id: node-modules-cache
+        uses: actions/cache@v2
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-expressly-docs-${{ secrets.cache_key_epoch_time }}-${{ hashFiles('yarn.lock') }}
+      - name: Compile docs
+        run: yarn build
+      - name: Install Rust toolchain
+        if: ${{ github.ref_name == 'main' }}
+        uses: actions-rs/toolchain@v1
+        with:
+            toolchain: stable
+            target: wasm32-wasi
+      - name: Deploy docs to Compute@Edge
+        if: ${{ github.ref_name == 'main' }}
+        uses: fastly/compute-actions@main
+        with:
+          project_directory: ./docs/static-host
+        env:
+          FASTLY_API_TOKEN: ${{ secrets.FASTLY_API_TOKEN }}
+      - name: Purge expressly.edgecompute.app
+        if: ${{ github.ref_name == 'main' }}
+        env:
+          FASTLY_API_TOKEN: ${{ secrets.FASTLY_API_TOKEN }}
+        run: |
+          curl -s -H "Fastly-Key: $FASTLY_API_TOKEN" -X POST "https://api.fastly.com/service/44O0OSuWrOWkzVek5Gg4QN/purge_all"
+        

package/.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+yarn pretty-quick --staged

package/.nvmrc

@@ -0,0 +1 @@
+16

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Fastly
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,56 @@
+# expressly
+Express-style router for Fastly's Compute@Edge.
+
+## Using expressly
+
+[Check out the docs](https://expressly.edgecompute.app/).
+
+---
+
+First, head over to [developer.fastly.com](https://developer.fastly.com) to get started with JavaScript on Fastly's Compute@Edge:
+
+1. Learn about Compute@Edge: [developer.fastly.com/learning/compute/](https://developer.fastly.com/learning/compute/)
+2. Create your first JavaScript app: [developer.fastly.com/learning/compute/javascript/](https://developer.fastly.com/learning/compute/javascript/)
+
+### Install expressly
+
+Install expressly from the [npm registry](https://www.npmjs.com/package/@fastly/expressly):
+
+```shell
+npm i @fastly/expressly
+```
+
+```shell
+yarn add @fastly/expressly
+```
+
+### Your first expressly app
+
+Replace the contents of your Compute@Edge app's `src/index.js` with the following:
+
+```javascript
+import { Router } from "@fastly/expressly";
+
+const router = new Router();
+
+router.get("/", async (req, res) => {
+  return res.send("Hello world!");
+});
+
+router.listen();
+```
+
+### Try it out
+
+Start your app locally:
+
+```shell
+fastly compute serve
+```
+
+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/SECURITY.MD

@@ -0,0 +1,9 @@
+## Report a security issue
+
+The project team welcomes security reports and is committed to providing prompt attention to security issues. Security issues should be reported privately via [Fastly’s security issue reporting process](https://www.fastly.com/security/report-security-issue).
+
+## Security advisories
+
+Remediation of security vulnerabilities is prioritized by the project team. The project team endeavors to coordinate remediation with third-party stakeholders, and is committed to transparency in the disclosure process. The team announces security issues via the [expressly security advisories](https://github.com/fastly/expressly/security/advisories) page on a best-effort basis.
+
+Note that communications related to security issues in Fastly-maintained OSS as described here are distinct from [Fastly Security Advisories](https://www.fastly.com/security-advisories).

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { Router } from "./lib/routing/router";
+import { ERequest } from "./lib/routing/request";
+import { EResponse } from "./lib/routing/response";
+export { Router, ERequest, EResponse, };

package/dist/index.js

@@ -0,0 +1,5 @@
+/// <reference types="@fastly/js-compute" />
+import { Router } from "./lib/routing/router";
+import { ERequest } from "./lib/routing/request";
+import { EResponse } from "./lib/routing/response";
+export { Router, ERequest, EResponse, };

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

@@ -0,0 +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;
+}

package/dist/lib/routing/common.js

@@ -0,0 +1,36 @@
+export class ECommonObject {
+    constructor() {
+        this.headers = new Headers();
+    }
+    // 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]);
+            });
+        }
+    }
+    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

@@ -0,0 +1,10 @@
+import { ERequest } from "./request";
+import { EResponse } from "./response";
+export declare type ErrorMiddlewareCallback = (err: Error, req: ERequest, res: EResponse) => 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>;
+}

package/dist/lib/routing/error-middleware.js

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

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

@@ -0,0 +1,9 @@
+export declare class ErrorNotFound extends Error {
+    status: number;
+    constructor();
+}
+export declare class ErrorMethodNotAllowed extends Error {
+    status: number;
+    allow: string;
+    constructor(allowedMethods: string[]);
+}

package/dist/lib/routing/errors.js

@@ -0,0 +1,16 @@
+export class ErrorNotFound extends Error {
+    constructor() {
+        super("Not Found");
+        this.status = 404;
+        Object.setPrototypeOf(this, ErrorNotFound.prototype);
+    }
+}
+export class ErrorMethodNotAllowed extends Error {
+    constructor(allowedMethods) {
+        super("Method Not Allowed");
+        this.status = 405;
+        this.allow = "";
+        Object.setPrototypeOf(this, ErrorMethodNotAllowed.prototype);
+        this.allow = [...new Set(allowedMethods)].join(",");
+    }
+}

package/dist/lib/routing/request/cookie-map.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/cookie-map.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/index.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="@fastly/js-compute" />
+import { ECommonObject } from "../common";
+import { CookieMap } from "./cookie-map";
+import { EConfig } from "..";
+export declare class ERequest extends ECommonObject {
+    private config;
+    private event;
+    readonly clientInfo: ClientInfo;
+    readonly method: string;
+    headers: Headers;
+    url: URL;
+    query: URLSearchParams;
+    params: {
+        [key: string]: string;
+    };
+    cookies: CookieMap;
+    constructor(config: EConfig, event: FetchEvent);
+    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>;
+}

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

@@ -0,0 +1,47 @@
+import { ECommonObject } from "../common";
+import { CookieMap } from "./cookie-map";
+export class ERequest extends ECommonObject {
+    constructor(config, event) {
+        super();
+        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;
+        // Parse cookies.
+        if (this.config.parseCookie) {
+            this.cookies = new CookieMap(this.headers);
+        }
+    }
+    // Express-like URL helpers.
+    get path() {
+        return this.url.pathname;
+    }
+    get ip() {
+        return this.clientInfo.address;
+    }
+    get protocol() {
+        return this.url.protocol;
+    }
+    get secure() {
+        return this.url.protocol === "https";
+    }
+    get subdomains() {
+        return this.url.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();
+    }
+}

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

@@ -0,0 +1,10 @@
+import { ERequest } from "./request";
+import { EResponse } from "./response";
+export declare type RequestHandlerCallback = (req: ERequest, res: EResponse) => 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>;
+}

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

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

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

@@ -0,0 +1,24 @@
+/// <reference types="@fastly/js-compute" />
+import { ECommonObject } from "../common";
+import { SurrogateKeys } from "./surrogate-keys";
+import { CookieOptions, EConfig } from "..";
+export declare class EResponse extends ECommonObject {
+    private config;
+    headers: Headers;
+    status: number;
+    body: BodyInit;
+    hasEnded: boolean;
+    surrogateKeys: SurrogateKeys;
+    constructor(config: EConfig);
+    vary(field: string): void;
+    cookie(key: string, value: string, options?: CookieOptions): void;
+    clearCookie(key: string, options?: CookieOptions): void;
+    send(response: BodyInit | Response): void;
+    end(body?: string): void;
+    sendStatus(status: number): void;
+    redirect(url: string, status?: 301 | 302 | 307 | 308): void;
+    withStatus(status: number): this;
+    json(data: any): void;
+    text(data: string): void;
+    html(data: string, charset?: string): void;
+}

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

@@ -0,0 +1,101 @@
+import cookie from "cookie";
+import { ECommonObject } from "../common";
+import { statusText } from "./status-codes";
+import { SurrogateKeys } from "./surrogate-keys";
+export class EResponse extends ECommonObject {
+    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);
+    }
+    // Header helpers.
+    vary(field) {
+        this.headers.append("Vary", field);
+    }
+    // Cookie helpers.
+    cookie(key, value, options = {}) {
+        if (this.hasEnded)
+            return;
+        this.headers.append("Set-Cookie", cookie.serialize(key, value, options));
+    }
+    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" }));
+    }
+    // Response lifecycle methods.
+    send(response) {
+        if (this.hasEnded)
+            return;
+        if (response instanceof Response) {
+            this.body = response.body;
+            this.headers = response.headers;
+            this.status = response.status;
+        }
+        else {
+            this.body = response;
+        }
+        // EXPERIMENTAL: Content type inference, à la Express.js.
+        if (this.config.autoContentType && !this.headers.has("Content-Type") && Boolean(this.body)) {
+            if (typeof this.body === "string") {
+                this.headers.set("Content-Type", "text/html");
+            }
+            else if (this.body instanceof ArrayBuffer) {
+                this.headers.set("Content-Type", "application/octet-stream");
+            }
+            else {
+                this.headers.set("Content-Type", "application/json");
+            }
+        }
+        this.hasEnded = true;
+    }
+    // End the response process [without any data], à la Express.js.
+    // https://stackoverflow.com/questions/29555290/what-is-the-difference-between-res-end-and-res-send
+    end(body) {
+        if (this.hasEnded)
+            return;
+        this.send(body);
+    }
+    // Send a HTTP status code response and end the response process.
+    sendStatus(status) {
+        if (this.hasEnded)
+            return;
+        this.status = status;
+        this.end(statusText[status] || null);
+    }
+    // Perform a redirect (default: 302 Found).
+    redirect(url, status = 302) {
+        if (this.hasEnded)
+            return;
+        this.headers.set("Location", url);
+        this.sendStatus(status);
+    }
+    // Chainable response status setter.
+    withStatus(status) {
+        this.status = status;
+        return this;
+    }
+    // Response body helpers.
+    json(data) {
+        if (this.hasEnded)
+            return;
+        this.headers.set("Content-Type", "application/json");
+        this.send(JSON.stringify(data));
+    }
+    text(data) {
+        if (this.hasEnded)
+            return;
+        this.headers.set("Content-Type", "text/plain");
+        this.send(data);
+    }
+    html(data, charset) {
+        if (this.hasEnded)
+            return;
+        this.headers.set("Content-Type", `text/html${charset ? `; charset=${charset}` : ""}`);
+        this.send(data);
+    }
+}

package/dist/lib/routing/response/status-codes.d.ts

@@ -0,0 +1,56 @@
+export declare const statusText: {
+    100: string;
+    101: string;
+    103: string;
+    200: string;
+    201: string;
+    202: string;
+    203: string;
+    204: string;
+    205: string;
+    206: string;
+    300: string;
+    301: string;
+    302: string;
+    303: string;
+    304: string;
+    307: string;
+    308: string;
+    400: string;
+    401: string;
+    402: string;
+    403: string;
+    404: string;
+    405: string;
+    406: string;
+    407: string;
+    408: string;
+    409: string;
+    410: string;
+    411: string;
+    412: string;
+    413: string;
+    414: string;
+    415: string;
+    416: string;
+    417: string;
+    418: string;
+    422: string;
+    425: string;
+    426: string;
+    428: string;
+    429: string;
+    431: string;
+    451: string;
+    500: string;
+    501: string;
+    502: string;
+    503: string;
+    504: string;
+    505: string;
+    506: string;
+    507: string;
+    508: string;
+    510: string;
+    511: string;
+};