@browserless.io/browserless 2.0.0-beta-1 → 2.0.0-beta-4

package/build/config.d.ts

@@ -2,37 +2,37 @@
 /// <reference types="node" />
 import { EventEmitter } from 'events';
 export declare class Config extends EventEmitter {
-    private readonly debug;
-    private readonly host;
-    private readonly external;
-    private readonly isWin;
-    private port;
-    private downloadsDir;
-    private dataDir;
-    private metricsJSONPath;
-    private createDataDir;
-    private createDownloadsDir;
-    private routes;
-    private token;
-    private concurrent;
-    private queued;
-    private timeout;
-    private static;
-    private retries;
-    private allowFileProtocol;
-    private allowGet;
-    private allowCors;
-    private corsMethods;
-    private corsOrigin;
-    private corsMaxAge;
-    private maxCpu;
-    private maxMemory;
-    private healthCheck;
-    private failedHealthURL;
-    private queueAlertURL;
-    private rejectAlertURL;
-    private timeoutAlertURL;
-    private errorAlertURL;
+    protected readonly debug: string;
+    protected readonly host: string;
+    protected readonly external: string | undefined;
+    protected readonly isWin: boolean;
+    protected port: number;
+    protected downloadsDir: string;
+    protected dataDir: string;
+    protected metricsJSONPath: string;
+    protected createDataDir: boolean;
+    protected createDownloadsDir: boolean;
+    protected routes: string;
+    protected token: string | null;
+    protected concurrent: number;
+    protected queued: number;
+    protected timeout: number;
+    protected static: string;
+    protected retries: number;
+    protected allowFileProtocol: boolean;
+    protected allowGet: boolean;
+    protected allowCors: boolean;
+    protected corsMethods: string;
+    protected corsOrigin: string;
+    protected corsMaxAge: number;
+    protected maxCpu: number;
+    protected maxMemory: number;
+    protected healthCheck: boolean;
+    protected failedHealthURL: string | null;
+    protected queueAlertURL: string | null;
+    protected rejectAlertURL: string | null;
+    protected timeoutAlertURL: string | null;
+    protected errorAlertURL: string | null;
     getRoutes: () => string;
     getHost: () => string;
     getPort: () => number;

package/build/exports.d.ts

@@ -8,8 +8,10 @@ export * from './limiter.js';
 export * from './metrics.js';
 export * from './mime-types.js';
 export * from './monitoring.js';
+export * from './router.js';
 export * from './server.js';
 export * from './shim.js';
+export * from './token.js';
 export * from './types.js';
 export * from './utils.js';
 export * from './webhooks.js';

package/build/exports.js

@@ -9,8 +9,10 @@ export * from './limiter.js';
 export * from './metrics.js';
 export * from './mime-types.js';
 export * from './monitoring.js';
+export * from './router.js';
 export * from './server.js';
 export * from './shim.js';
+export * from './token.js';
 export * from './types.js';
 export * from './utils.js';
 export * from './webhooks.js';

package/build/file-system.d.ts

@@ -1,7 +1,7 @@
 import { Config } from '@browserless.io/browserless';
 export declare class FileSystem {
-    private config;
-    private fsMap;
+    protected config: Config;
+    protected fsMap: Map<string, string[]>;
     constructor(config: Config);
     /**
      * Appends contents to a file-path for persistance. File contents are

package/build/limiter.d.ts

@@ -1,20 +1,42 @@
+/// <reference types="debug" />
 import { Config, Metrics, Monitoring, WebHooks } from '@browserless.io/browserless';
 import q from 'queue';
 export type LimitFn<TArgs extends unknown[], TResult> = (...args: TArgs) => Promise<TResult>;
 export type ErrorFn<TArgs extends unknown[]> = (...args: TArgs) => void;
+interface Job {
+    (): Promise<unknown>;
+    args: unknown[];
+    onTimeoutFn: (job: Job) => unknown;
+    start: number;
+    timeout: number;
+}
 export declare class Limiter extends q {
-    private config;
-    private metrics;
-    private monitor;
-    private webhooks;
-    private queued;
-    private debug;
+    protected config: Config;
+    protected metrics: Metrics;
+    protected monitor: Monitoring;
+    protected webhooks: WebHooks;
+    protected queued: number;
+    protected debug: import("debug").Debugger;
     constructor(config: Config, metrics: Metrics, monitor: Monitoring, webhooks: WebHooks);
-    private handleEnd;
-    private handleSuccess;
-    private handleJobTimeout;
-    private handleFail;
-    private logQueue;
+    protected handleEnd(): void;
+    protected handleSuccess({ detail: { job } }: {
+        detail: {
+            job: Job;
+        };
+    }): void;
+    protected handleJobTimeout({ detail: { next, job }, }: {
+        detail: {
+            job: Job;
+            next: Job;
+        };
+    }): void;
+    protected handleFail({ detail: { error, job }, }: {
+        detail: {
+            error: unknown;
+            job: Job;
+        };
+    }): void;
+    protected logQueue(message: string): void;
     get executing(): number;
     get waiting(): number;
     get willQueue(): boolean;
@@ -22,3 +44,4 @@ export declare class Limiter extends q {
     get hasCapacity(): boolean;
     limit: <TArgs extends unknown[], TResult>(limitFn: LimitFn<TArgs, TResult>, overCapacityFn: ErrorFn<TArgs>, onTimeoutFn: ErrorFn<TArgs>, timeoutOverrideFn: (...args: TArgs) => number | undefined) => LimitFn<TArgs, unknown>;
 }
+export {};

package/build/metrics.d.ts

@@ -1,15 +1,15 @@
 import { IBrowserlessStats } from '@browserless.io/browserless';
 export declare class Metrics {
-    private sessionTimes;
-    private successful;
-    private queued;
-    private rejected;
-    private unauthorized;
-    private concurrent;
-    private timedout;
-    private running;
-    private unhealthy;
-    private error;
+    protected sessionTimes: number[];
+    protected successful: number;
+    protected queued: number;
+    protected rejected: number;
+    protected unauthorized: number;
+    protected concurrent: number;
+    protected timedout: number;
+    protected running: number;
+    protected unhealthy: number;
+    protected error: number;
     addSuccessful: (sessionTime: number) => number;
     addTimedout: (sessionTime: number) => number;
     addError: (sessionTime: number) => number;
@@ -20,5 +20,11 @@ export declare class Metrics {
     addRunning: () => number;
     get: () => Omit<IBrowserlessStats, 'cpu' | 'memory'>;
     reset: () => void;
-    private calculateStats;
+    protected calculateStats(sessionTimes: number[]): {
+        maxTime: number;
+        meanTime: number;
+        minTime: number;
+        totalTime: number;
+        units: number;
+    };
 }

package/build/monitoring.d.ts

@@ -1,7 +1,8 @@
+/// <reference types="debug" />
 import { Config, IResourceLoad } from '@browserless.io/browserless';
 export declare class Monitoring {
-    private config;
-    private log;
+    protected config: Config;
+    protected log: import("debug").Debugger;
     constructor(config: Config);
     getMachineStats: () => Promise<IResourceLoad>;
     overloaded: () => Promise<{

package/build/router.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="debug" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { BrowserHTTPRoute, BrowserManager, BrowserWebsocketRoute, Config, HTTPRoute, Limiter, Request, Response, WebSocketRoute } from '@browserless.io/browserless';
+import stream from 'stream';
+export declare class Router {
+    protected config: Config;
+    protected browserManager: BrowserManager;
+    protected limiter: Limiter;
+    protected log: import("debug").Debugger;
+    protected verbose: import("debug").Debugger;
+    protected httpRoutes: Array<HTTPRoute | BrowserHTTPRoute>;
+    protected webSocketRoutes: Array<WebSocketRoute | BrowserWebsocketRoute>;
+    constructor(config: Config, browserManager: BrowserManager, limiter: Limiter);
+    protected getTimeout(req: Request): number | undefined;
+    protected onQueueFullHTTP: (_req: Request, res: Response) => void;
+    protected onQueueFullWebSocket: (_req: Request, socket: stream.Duplex) => void;
+    protected onHTTPTimeout: (_req: Request, res: Response) => void;
+    protected onWebsocketTimeout: (_req: Request, socket: stream.Duplex) => void;
+    protected wrapHTTPHandler: (route: HTTPRoute | BrowserHTTPRoute, handler: HTTPRoute['handler'] | BrowserHTTPRoute['handler']) => (req: Request, res: Response) => Promise<unknown>;
+    protected wrapWebSocketHandler: (route: WebSocketRoute | BrowserWebsocketRoute, handler: WebSocketRoute['handler'] | BrowserWebsocketRoute['handler']) => (req: Request, socket: stream.Duplex, head: Buffer) => Promise<unknown>;
+    registerHTTPRoute(route: HTTPRoute | BrowserHTTPRoute): HTTPRoute | BrowserHTTPRoute;
+    registerWebSocketRoute(route: WebSocketRoute | BrowserWebsocketRoute): WebSocketRoute | BrowserWebsocketRoute;
+    teardown(): Promise<void>;
+    getStaticHandler(): HTTPRoute;
+    getRouteForHTTPRequest(req: Request): Promise<HTTPRoute | BrowserHTTPRoute | null>;
+    getRouteForWebSocketRequest(req: Request): Promise<WebSocketRoute | BrowserWebsocketRoute | undefined>;
+}

package/build/router.js

@@ -0,0 +1,138 @@
+import { HTTPManagementRoutes, contentTypes, createLogger, isConnected, writeResponse, } from '@browserless.io/browserless';
+import micromatch from 'micromatch';
+export class Router {
+    config;
+    browserManager;
+    limiter;
+    log = createLogger('router');
+    verbose = createLogger('router:verbose');
+    httpRoutes = [];
+    webSocketRoutes = [];
+    constructor(config, browserManager, limiter) {
+        this.config = config;
+        this.browserManager = browserManager;
+        this.limiter = limiter;
+    }
+    getTimeout(req) {
+        const timer = req.parsed.searchParams.get('timeout');
+        return timer ? +timer : undefined;
+    }
+    onQueueFullHTTP = (_req, res) => {
+        this.log(`Queue is full, sending 429 response`);
+        return writeResponse(res, 429, 'Too many requests');
+    };
+    onQueueFullWebSocket = (_req, socket) => {
+        this.log(`Queue is full, sending 429 response`);
+        return writeResponse(socket, 429, 'Too many requests');
+    };
+    onHTTPTimeout = (_req, res) => {
+        this.log(`HTTP job has timedout, sending 429 response`);
+        return writeResponse(res, 408, 'Request has timed out');
+    };
+    onWebsocketTimeout = (_req, socket) => {
+        this.log(`Websocket job has timedout, sending 429 response`);
+        return writeResponse(socket, 408, 'Request has timed out');
+    };
+    wrapHTTPHandler = (route, handler) => async (req, res) => {
+        if (!isConnected(res)) {
+            this.log(`HTTP Request has closed prior to running`);
+            return Promise.resolve();
+        }
+        if (route.browser) {
+            const browser = await this.browserManager.getBrowserForRequest(req, route);
+            if (!isConnected(res)) {
+                this.log(`HTTP Request has closed prior to running`);
+                this.browserManager.complete(browser);
+                return Promise.resolve();
+            }
+            if (!browser) {
+                return writeResponse(res, 500, `Error loading the browser.`);
+            }
+            if (!isConnected(res)) {
+                this.log(`HTTP Request has closed prior to running`);
+                return Promise.resolve();
+            }
+            try {
+                this.verbose(`Running found HTTP handler.`);
+                return await handler(req, res, browser);
+            }
+            finally {
+                this.verbose(`HTTP Request handler has finished.`);
+                this.browserManager.complete(browser);
+            }
+        }
+        return handler(req, res);
+    };
+    wrapWebSocketHandler = (route, handler) => async (req, socket, head) => {
+        if (!isConnected(socket)) {
+            this.log(`WebSocket Request has closed prior to running`);
+            return Promise.resolve();
+        }
+        if (route.browser) {
+            const browser = await this.browserManager.getBrowserForRequest(req, route);
+            if (!isConnected(socket)) {
+                this.log(`WebSocket Request has closed prior to running`);
+                this.browserManager.complete(browser);
+                return Promise.resolve();
+            }
+            if (!browser) {
+                return writeResponse(socket, 500, `Error loading the browser.`);
+            }
+            try {
+                this.verbose(`Running found WebSocket handler.`);
+                await handler(req, socket, head, browser);
+            }
+            finally {
+                this.verbose(`WebSocket Request handler has finished.`);
+                this.browserManager.complete(browser);
+            }
+            return;
+        }
+        return handler(req, socket, head);
+    };
+    registerHTTPRoute(route) {
+        this.verbose(`Registering HTTP ${route.method.toUpperCase()} ${route.path}`);
+        route.getBrowserManager = () => this.browserManager;
+        const bound = route.handler.bind(route);
+        const wrapped = this.wrapHTTPHandler(route, bound);
+        route.handler = route.concurrency
+            ? this.limiter.limit(wrapped, this.onQueueFullHTTP, this.onHTTPTimeout, this.getTimeout)
+            : wrapped;
+        this.httpRoutes.push(route);
+        return route;
+    }
+    registerWebSocketRoute(route) {
+        this.verbose(`Registering WebSocket "${route.path}"`);
+        route.getBrowserManager = () => this.browserManager;
+        const bound = route.handler.bind(route);
+        const wrapped = this.wrapWebSocketHandler(route, bound);
+        route.handler = route.concurrency
+            ? this.limiter.limit(wrapped, this.onQueueFullWebSocket, this.onWebsocketTimeout, this.getTimeout)
+            : wrapped;
+        this.webSocketRoutes.push(route);
+        return route;
+    }
+    teardown() {
+        this.httpRoutes = [];
+        this.webSocketRoutes = [];
+        return this.browserManager.stop();
+    }
+    getStaticHandler() {
+        return this.httpRoutes.find((route) => route.path === HTTPManagementRoutes.static);
+    }
+    async getRouteForHTTPRequest(req) {
+        const accepts = (req.headers['accept']?.toLowerCase() || '*/*').split(',');
+        const contentType = req.headers['content-type']?.toLowerCase();
+        return (this.httpRoutes.find((r) => micromatch.isMatch(req.parsed.pathname, r.path) &&
+            r.method === req.method?.toLocaleLowerCase() &&
+            (accepts.some((a) => a.startsWith('*/*')) ||
+                r.contentTypes.some((contentType) => accepts.includes(contentType))) &&
+            ((!contentType && r.accepts.includes(contentTypes.any)) ||
+                r.accepts.includes(contentType))) ||
+            (req.method?.toLowerCase() === 'get' ? this.getStaticHandler() : null));
+    }
+    async getRouteForWebSocketRequest(req) {
+        const { pathname } = req.parsed;
+        return this.webSocketRoutes.find((r) => micromatch.isMatch(pathname, r.path));
+    }
+}

package/build/routes/chromium/http/content-post.body.json

@@ -398,14 +398,14 @@
                 "length": {
                   "type": "number"
                 },
-                "__@toStringTag@10721": {
+                "__@toStringTag@10725": {
                   "type": "string",
                   "const": "Uint8Array"
                 }
               },
               "required": [
                 "BYTES_PER_ELEMENT",
-                "__@toStringTag@10721",
+                "__@toStringTag@10725",
                 "buffer",
                 "byteLength",
                 "byteOffset",
@@ -440,13 +440,13 @@
         "byteLength": {
           "type": "number"
         },
-        "__@toStringTag@10721": {
+        "__@toStringTag@10725": {
           "type": "string"
         }
       },
       "additionalProperties": false,
       "required": [
-        "__@toStringTag@10721",
+        "__@toStringTag@10725",
         "byteLength"
       ]
     },
@@ -456,18 +456,18 @@
         "byteLength": {
           "type": "number"
         },
-        "__@species@10822": {
+        "__@species@10826": {
           "$ref": "#/definitions/SharedArrayBuffer"
         },
-        "__@toStringTag@10721": {
+        "__@toStringTag@10725": {
           "type": "string",
           "const": "SharedArrayBuffer"
         }
       },
       "additionalProperties": false,
       "required": [
-        "__@species@10822",
-        "__@toStringTag@10721",
+        "__@species@10826",
+        "__@toStringTag@10725",
         "byteLength"
       ]
     },

package/build/routes/chromium/http/download-post.js

@@ -18,7 +18,7 @@ const route = {
   that are written for execution inside of the browser. Once your script is finished, any
   downloaded files from Chromium are returned back with the appropriate content-type header.`),
     handler: async (req, res, browser) => new Promise(async (resolve, reject) => {
-        const { _config: getConfig, _debug: getDebug } = route;
+        const { getConfig: getConfig, getDebug: getDebug } = route;
         if (!getConfig || !getDebug) {
             return reject(new ServerError(`Couldn't load configuration for request`));
         }

package/build/routes/chromium/http/function-post.js

@@ -15,7 +15,7 @@ const route = {
   Values returned from the function are checked and an appropriate content-type and response is sent back
   to your HTTP call.`),
     handler: async (req, res, browser) => {
-        const { _config: getConfig, _debug: getDebug } = route;
+        const { getConfig: getConfig, getDebug: getDebug } = route;
         if (!getConfig || !getDebug) {
             throw new ServerError(`Couldn't load configuration for request`);
         }

package/build/routes/chromium/http/pdf-post.body.json

@@ -538,14 +538,14 @@
                 "length": {
                   "type": "number"
                 },
-                "__@toStringTag@53453": {
+                "__@toStringTag@42863": {
                   "type": "string",
                   "const": "Uint8Array"
                 }
               },
               "required": [
                 "BYTES_PER_ELEMENT",
-                "__@toStringTag@53453",
+                "__@toStringTag@42863",
                 "buffer",
                 "byteLength",
                 "byteOffset",
@@ -580,13 +580,13 @@
         "byteLength": {
           "type": "number"
         },
-        "__@toStringTag@53453": {
+        "__@toStringTag@42863": {
           "type": "string"
         }
       },
       "additionalProperties": false,
       "required": [
-        "__@toStringTag@53453",
+        "__@toStringTag@42863",
         "byteLength"
       ]
     },
@@ -596,18 +596,18 @@
         "byteLength": {
           "type": "number"
         },
-        "__@species@53554": {
+        "__@species@42964": {
           "$ref": "#/definitions/SharedArrayBuffer"
         },
-        "__@toStringTag@53453": {
+        "__@toStringTag@42863": {
           "type": "string",
           "const": "SharedArrayBuffer"
         }
       },
       "additionalProperties": false,
       "required": [
-        "__@species@53554",
-        "__@toStringTag@53453",
+        "__@species@42964",
+        "__@toStringTag@42863",
         "byteLength"
       ]
     },

package/build/routes/chromium/http/performance.js

@@ -8,7 +8,7 @@ const route = {
     contentTypes: [contentTypes.json],
     description: `Run lighthouse performance audits with a supplied "url" in your JSON payload.`,
     handler: async (req, res, browser) => {
-        const { _config: getConfig } = route;
+        const { getConfig: getConfig } = route;
         if (!req.body) {
             throw new BadRequest(`No JSON body present`);
         }

package/build/routes/chromium/http/scrape-post.body.json

@@ -445,14 +445,14 @@
                 "length": {
                   "type": "number"
                 },
-                "__@toStringTag@107019": {
+                "__@toStringTag@64356": {
                   "type": "string",
                   "const": "Uint8Array"
                 }
               },
               "required": [
                 "BYTES_PER_ELEMENT",
-                "__@toStringTag@107019",
+                "__@toStringTag@64356",
                 "buffer",
                 "byteLength",
                 "byteOffset",
@@ -487,13 +487,13 @@
         "byteLength": {
           "type": "number"
         },
-        "__@toStringTag@107019": {
+        "__@toStringTag@64356": {
           "type": "string"
         }
       },
       "additionalProperties": false,
       "required": [
-        "__@toStringTag@107019",
+        "__@toStringTag@64356",
         "byteLength"
       ]
     },
@@ -503,18 +503,18 @@
         "byteLength": {
           "type": "number"
         },
-        "__@species@107120": {
+        "__@species@64457": {
           "$ref": "#/definitions/SharedArrayBuffer"
         },
-        "__@toStringTag@107019": {
+        "__@toStringTag@64356": {
           "type": "string",
           "const": "SharedArrayBuffer"
         }
       },
       "additionalProperties": false,
       "required": [
-        "__@species@107120",
-        "__@toStringTag@107019",
+        "__@species@64457",
+        "__@toStringTag@64356",
         "byteLength"
       ]
     },

package/build/routes/chromium/http/screenshot-post.body.json

@@ -488,14 +488,14 @@
                 "length": {
                   "type": "number"
                 },
-                "__@toStringTag@85521": {
+                "__@toStringTag@75317": {
                   "type": "string",
                   "const": "Uint8Array"
                 }
               },
               "required": [
                 "BYTES_PER_ELEMENT",
-                "__@toStringTag@85521",
+                "__@toStringTag@75317",
                 "buffer",
                 "byteLength",
                 "byteOffset",
@@ -530,13 +530,13 @@
         "byteLength": {
           "type": "number"
         },
-        "__@toStringTag@85521": {
+        "__@toStringTag@75317": {
           "type": "string"
         }
       },
       "additionalProperties": false,
       "required": [
-        "__@toStringTag@85521",
+        "__@toStringTag@75317",
         "byteLength"
       ]
     },
@@ -546,18 +546,18 @@
         "byteLength": {
           "type": "number"
         },
-        "__@species@85622": {
+        "__@species@75418": {
           "$ref": "#/definitions/SharedArrayBuffer"
         },
-        "__@toStringTag@85521": {
+        "__@toStringTag@75317": {
           "type": "string",
           "const": "SharedArrayBuffer"
         }
       },
       "additionalProperties": false,
       "required": [
-        "__@species@85622",
-        "__@toStringTag@85521",
+        "__@species@75418",
+        "__@toStringTag@75317",
         "byteLength"
       ]
     },

package/build/routes/chromium/utils/function/client.d.ts

@@ -1,11 +1,11 @@
-import { Page } from 'puppeteer-core';
+import { Browser, Page } from 'puppeteer-core';
 type codeHandler = (params: {
     context: unknown;
     page: Page;
 }) => Promise<unknown>;
 export declare class FunctionRunner {
-    private browser?;
-    private page?;
+    protected browser?: Browser;
+    protected page?: Page;
     log: () => {
         (...data: any[]): void;
         (message?: any, ...optionalParams: any[]): void;

package/build/routes/management/http/config-get.js

@@ -7,7 +7,7 @@ const route = {
     contentTypes: [contentTypes.json],
     description: `Returns a JSON payload of the current system configuration.`,
     handler: async (_req, res) => {
-        const { _config: getConfig } = route;
+        const { getConfig: getConfig } = route;
         if (!getConfig) {
             throw new ServerError(`Couldn't locate the config object`);
         }