Allow passing an alternative public endpoint for Firebase and handle destination rewrites (#33)

* Allow passing an alternative public endpoint for Firebase

* Fix assigning publicEndpoint

* Improve globs parsing by using picomatch and parse destinations rewrites

* Rewrite matched destination URLs

* Move jest config to file and setup environment

* Add license to package.json

* Add picomatch declaration file and update usage

* Add tests for firebase

* Add more tests

* Ensure reserved URLs are not rewritten

Author: jpreynat

.nvmrc

@@ -0,0 +1 @@
+14.15.1

jest.config.js

@@ -0,0 +1,12 @@
+module.exports = {
+    roots: ['<rootDir>/src'],
+    moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+    transform: {
+        '^.+\\.tsx?$': 'ts-jest'
+    },
+    testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.tsx?$',
+    // testEnvironment: 'jsdom',
+    setupFiles: [
+        './jest.setup.js'
+    ]
+};

jest.setup.js

@@ -0,0 +1,4 @@
+// Setup mocks for Request/Response
+const makeServiceWorkerEnv = require('service-worker-mock');
+
+Object.assign(global, makeServiceWorkerEnv());

package.json

@@ -1,15 +1,19 @@
 {
     "name": "proxies-on-cloudflare",
     "main": "./dist/index.js",
+    "license": "Apache-2.0",
     "version": "0.3.4",
-    "dependencies": {},
+    "dependencies": {
+        "picomatch": "^2.3.0"
+    },
     "files": [
         "dist/*"
     ],
     "devDependencies": {
         "@types/jest": "^23.3.11",
         "jest": "^23.6.0",
         "prettier": "^1.15.3",
+        "service-worker-mock": "^2.0.5",
         "ts-jest": "^23.10.5",
         "tslint": "^5.20.0",
         "tslint-config-prettier": "^1.17.0",
@@ -18,24 +22,7 @@
     },
     "scripts": {
         "prepare": "tsc",
-        "test": "jest",
+        "test": "jest --config=jest.config.js",
         "lint": "tslint ./src/**/*.ts"
-    },
-    "jest": {
-        "roots": [
-            "<rootDir>/src"
-        ],
-        "transform": {
-            "^.+\\.tsx?$": "ts-jest"
-        },
-        "testRegex": "(/__tests__/.*|(\\.|/)(test|spec))\\.tsx?$",
-        "moduleFileExtensions": [
-            "ts",
-            "tsx",
-            "js",
-            "jsx",
-            "json",
-            "node"
-        ]
     }
 }

src/__tests__/firebase.ts

@@ -0,0 +1,123 @@
+import { Firebase } from '../firebase';
+
+const firebase = new Firebase(
+  'firebase-project',
+  {
+    rewrites: [
+      {
+        source: '/function-with-glob/**',
+        function: 'glob-function'
+      },
+      {
+        source: '/exact-path',
+        function: 'exact-function'
+      },
+      {
+        source: '**/!(*.js)',
+        destination: '/index.html'
+      }
+    ]
+  },
+  {
+    headers: {
+      'Some-Header': 'My-Firebase-Header'
+    },
+    publicEndpoint: new URL('https://my-endpoint.com/public')
+  }
+);
+
+describe('getEndpoint', () => {
+  it('should return the function URL that match a glob with a path', async () => {
+    const endpointURL = firebase.getEndpoint(
+      new Request('https://myapp.com/function-with-glob/with/path')
+    );
+
+    expect(endpointURL.toString()).toBe(
+      'https://us-central1-firebase-project.cloudfunctions.net/glob-function'
+    );
+  });
+
+  it('should return the function URL that match a glob without a path', async () => {
+    const endpointURL = firebase.getEndpoint(
+      new Request('https://myapp.com/function-with-glob')
+    );
+
+    expect(endpointURL.toString()).toBe(
+      'https://us-central1-firebase-project.cloudfunctions.net/glob-function'
+    );
+  });
+
+  it('should return the function URL that has an exact match', async () => {
+    const endpointURL = firebase.getEndpoint(
+      new Request('https://myapp.com/exact-path')
+    );
+
+    expect(endpointURL.toString()).toBe(
+      'https://us-central1-firebase-project.cloudfunctions.net/exact-function'
+    );
+  });
+
+  it('should return the public endpoint URL when not an exact match', async () => {
+    const endpointURL = firebase.getEndpoint(
+      new Request('https://myapp.com/exact-path/with/more')
+    );
+
+    expect(endpointURL.toString()).toBe('https://my-endpoint.com/public');
+  });
+
+  it('should return the default Firebase hosting endpoint for reserved requests', async () => {
+    const endpointURL = firebase.getEndpoint(
+      new Request('https://myapp.com/__/some/firebase/request')
+    );
+
+    expect(endpointURL.toString()).toBe(
+      'https://firebase-project.firebaseapp.com/'
+    );
+  });
+
+  it('should return the public endpoint URL for any other request', async () => {
+    const endpointURL = firebase.getEndpoint(
+      new Request('https://myapp.com/some/file.js')
+    );
+
+    expect(endpointURL.toString()).toBe('https://my-endpoint.com/public');
+  });
+});
+
+describe('rewriteURL', () => {
+  it('should not rewrite an URL that matches a rewrite rule', async () => {
+    const finalURL = firebase.rewriteURL(
+      new URL('https://myapp.com/some/js-file.js')
+    );
+
+    expect(finalURL.toString()).toBe('https://myapp.com/some/js-file.js');
+  });
+
+  it('should rewrite an URL that has a rewrite rule', async () => {
+    const finalURL = firebase.rewriteURL(
+      new URL('https://myapp.com/some/non-js-file.html')
+    );
+
+    expect(finalURL.toString()).toBe('https://myapp.com/index.html');
+  });
+
+  it('should not rewrite Firebase reserved requests', async () => {
+    const finalURL = firebase.rewriteURL(
+      new URL('https://myapp.com/__/some/firebase/request')
+    );
+
+    expect(finalURL.toString()).toBe(
+      'https://myapp.com/__/some/firebase/request'
+    );
+  });
+
+  it('should not rewrite an URL that matches a function', async () => {
+    const finalURL = firebase.rewriteURL(
+      new URL('https://myapp.com/function-with-glob/and/path')
+    );
+
+    expect(finalURL.toString()).toBe(
+      'https://myapp.com/function-with-glob/and/path'
+    );
+  });
+});

src/firebase/index.ts

@@ -12,6 +12,8 @@ interface ExtraOptions {
   // Seed (string) of our cache hash
   // changing the seed will invalidate all previous entries
   seed?: string;
+  // Custom endpoint to fetch public files from instead of Firebase hosting
+  publicEndpoint?: URL;
 }
 interface HeaderOptions {
   [key: string]: string | null;
@@ -29,9 +31,10 @@ export default function firebase(
   return fbase.serve.bind(fbase);
 }
 
-class Firebase {
+export class Firebase {
   public matcher: Matcher;
   public projectID: string;
+  public publicEndpoint: URL;
   public hostingEndpoint: URL;
   public globalHeaders: HeaderOptions;
   public proxy: ServeFunction;
@@ -44,12 +47,22 @@ class Firebase {
     this.matcher = new Matcher(config.rewrites);
     // Static Hosting endpoint
     this.hostingEndpoint = fbhostingEndpoint(projectID);
+    // Endpoint for public files in hosting, can be overriden in extra options
+    this.publicEndpoint =
+      extra && extra.publicEndpoint
+        ? extra.publicEndpoint
+        : this.hostingEndpoint;
     // Custom headers
     this.globalHeaders = extra && extra.headers ? extra.headers : {};
     // Cache seed
     this.seed = extra && extra.seed ? extra.seed : '42';
     // Proxy
-    this.proxy = cache(customProxy(req => this.getEndpoint(req!)), this.seed);
+    this.proxy = cache(
+      customProxy(req => this.getEndpoint(req!), {
+        rewriteURL: url => this.rewriteURL(url)
+      }),
+      this.seed
+    );
   }
 
   public async serve(event: FetchEvent): Promise<Response> {
@@ -71,18 +84,44 @@ class Firebase {
     const url = new URL(request.url);
     const pathname = url.pathname;
 
+    // If reserved, pass through to the original FirebaseHosting application endpoint
+    if (isReserved(pathname)) {
+      return this.hostingEndpoint;
+    }
+
     // Get cloud func for path
-    const funcname = this.matcher.match(pathname);
+    const match = this.matcher.match(pathname);
+    // If no func matched, we're looking for a public file in Firebase hosting, pass through
+    if (!match || !('function' in match)) {
+      return this.publicEndpoint;
+    }
 
-    // Is this URL part of Firebase's reserved /__/* namespace
-    const isReserved = pathname.startsWith('/__/');
+    // Route to specific cloud function
+    return cloudfuncEndpoint(this.projectID, match.function);
+  }
 
-    // If no func matched or reserved, pass through to FirebaseHosting
-    if (isReserved || !funcname) {
-      return this.hostingEndpoint;
+  /**
+   * Rewrite URL's pathname to match configured destination
+   */
+  public rewriteURL(url: URL): URL {
+    // If reserved, we never modify the request
+    if (isReserved(url.pathname)) {
+      return url;
     }
 
-    // Route to specific cloud function
-    return cloudfuncEndpoint(this.projectID, funcname);
+    const match = this.matcher.match(url.pathname);
+    if (!match || !('destination' in match)) {
+      return url;
+    }
+
+    url.pathname = match.destination;
+    return url;
   }
 }
+
+/**
+ * Is this URL part of Firebase's reserved /__/* namespace
+ */
+function isReserved(pathname: string): boolean {
+  return pathname.startsWith('/__/');
+}

src/firebase/picomatch.ts

@@ -0,0 +1,3 @@
+declare module 'picomatch' {
+  export function isMatch(str: string, glob: string): boolean;
+}

src/firebase/rewrites.ts

@@ -1,13 +1,25 @@
-import { globToRegex, isGlob } from '../globs';
+import * as pm from 'picomatch';
+import { isGlob } from '../globs';
 import { FirebaseRewrites } from './types';
 
-interface GlobMatch {
-  regex: RegExp;
+interface FunctionMatch {
   function: string;
 }
 
+interface DestinationMatch {
+  destination: string;
+}
+
+type RewriteMatch = FunctionMatch | DestinationMatch;
+
+interface GlobMatch {
+  // Matcher for a path
+  matcher: (path: string) => boolean;
+  match: RewriteMatch;
+}
+
 interface ExactMatches {
-  [key: string]: string;
+  [path: string]: RewriteMatch;
 }
 
 export class Matcher {
@@ -19,40 +31,40 @@ export class Matcher {
     this.globs = rewrites
       .filter(r => isGlob(r.source))
       .map(r => ({
-        regex: globToRegex(pathGlob(r.source)),
-        function: r.function
+        matcher: (path: string) => pm.isMatch(path, r.source),
+        match:
+          'function' in r
+            ? { function: r.function }
+            : { destination: r.destination }
       }));
 
     // Dict of exact matches
     this.exacts = rewrites
       .filter(r => !isGlob(r.source))
       .reduce<ExactMatches>((accu, r) => {
-        accu[r.source] = r.function;
+        accu[r.source] =
+          'function' in r
+            ? { function: r.function }
+            : { destination: r.destination };
         return accu;
       }, {});
   }
 
   // Matching function, converting path to func name, null if no match
-  public match(path: string): string | null {
+  public match(path: string): RewriteMatch | null {
     // Try exact match
     if (path in this.exacts) {
       return this.exacts[path];
     }
 
     // Globs
     for (const glob of this.globs) {
-      if (glob.regex.test(path)) {
-        return glob.function;
+      if (glob.matcher(path)) {
+        return glob.match;
       }
     }
 
     // No function found
     return null;
   }
 }
-
-// pathGlob ensure that all path glob expressions start with a /
-function pathGlob(expr: string): string {
-  // Ensure path starts with '/'
-  return expr.replace(/^\/?/, '/');
-}

src/firebase/types.ts

@@ -4,7 +4,16 @@ export interface FirebaseConfig {
 
 export interface FirebaseRewrites extends Array<FirebaseRewrite> {}
 
-export interface FirebaseRewrite {
+export interface FirebaseFunctionRewrite {
   source: string;
   function: string;
 }
+
+export interface FirebaseDestinationRewrite {
+  source: string;
+  destination: string;
+}
+
+export type FirebaseRewrite =
+  | FirebaseFunctionRewrite
+  | FirebaseDestinationRewrite;