@browserless.io/browserless 2.3.0-beta-1 → 2.3.0-beta-2

package/scripts/build-open-api.js

@@ -3,17 +3,21 @@
 'use strict';
 
 import { join, parse } from 'path';
-import { Config } from '../build/config.js';
 import { dirname } from 'path';
-import { errorCodes } from '../build/http.js';
 import { fileURLToPath } from 'url';
 import fs from 'fs/promises';
-import { getRouteFiles } from '../build/utils.js';
 import { marked } from 'marked';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const moduleMain = import.meta.url.endsWith(process.argv[1]);
 const swaggerJSONPath = join(__dirname, '..', 'static', 'docs', 'swagger.json');
+const swaggerJSONMinimal = join(
+  __dirname,
+  '..',
+  'static',
+  'docs',
+  'swagger.min.json',
+);
 const packageJSONPath = join(__dirname, '..', 'package.json');
 
 const readFileOrNull = async (path) => {
@@ -42,17 +46,18 @@ const sortSwaggerRequiredAlpha = (prop, otherProp) => {
   return Number(otherProp.required) - Number(prop.required);
 };
 
-const routeIsDisabled = (Route, DisabledRoutes) => {
-  const stringified = Route.toString();
-  return DisabledRoutes.some((r) => r.toString() === stringified);
-};
-
 const buildOpenAPI = async (
   externalHTTPRoutes = [],
   externalWebSocketRoutes = [],
-  DisabledRoutes = [],
+  disabledRoutes = [],
 ) => {
-  const packageJSON = await fs.readFile(packageJSONPath);
+  const [{ getRouteFiles }, { Config }, { errorCodes }, packageJSON] =
+    await Promise.all([
+      import('../build/utils.js'),
+      import('../build/config.js'),
+      import('../build/http.js'),
+      fs.readFile(packageJSONPath),
+    ]);
 
   const isWin = process.platform === 'win32';
   const readme = (await fs.readFile('README.md').catch(() => '')).toString();
@@ -65,8 +70,6 @@ const buildOpenAPI = async (
     customSiteTitle: 'Browserless Documentation',
     definitions: {},
     info: {
-      // Concatenation necessary for Changelog to show up in sidebar
-      description: readme + `\n# Changelog\n` + changelog,
       title: 'Browserless',
       version: JSON.parse(packageJSON.toString()).version,
       'x-logo': {
@@ -93,14 +96,14 @@ const buildOpenAPI = async (
         const routeImport = `${isWin ? 'file:///' : ''}${routeModule}`;
         const { default: Route } = await import(routeImport);
         if (!Route) {
-          throw new Error(
-            `Invalid route file found while building OpenAPI JSON: "${routeModule}"`,
-          );
+          throw new Error(`Invalid route file to import docs ${routeModule}`);
         }
-        if (routeIsDisabled(Route, DisabledRoutes)) {
+        const route = new Route();
+
+        if (disabledRoutes.includes(route.name)) {
           return null;
         }
-        const route = new Route();
+
         const { name } = parse(routeModule);
         const body = routeModule.replace('.js', '.body.json');
         const query = routeModule.replace('.js', '.query.json');
@@ -108,7 +111,7 @@ const buildOpenAPI = async (
         const isWebSocket = routeModule.includes('/ws/') || name.endsWith('ws');
         const path = Array.isArray(route.path)
           ? route.path.join(' ')
-          : [route.path];
+          : route.path;
         const {
           tags,
           description,
@@ -135,149 +138,155 @@ const buildOpenAPI = async (
           tags,
           title,
         };
-      })
-      .filter((r) => r !== null),
+      }),
   );
 
-  const paths = routeMetaData.reduce((accum, r) => {
-    const swaggerRoute = {
-      definitions: {},
-      description: r.description,
-      parameters: [],
-      requestBody: {
-        content: {},
-      },
-      responses: {
-        ...errorCodes,
-      },
-      summary: r.path,
-      tags: r.tags,
-    };
+  const paths = routeMetaData
+    .filter((_) => !!_)
+    .reduce((accum, r) => {
+      const swaggerRoute = {
+        definitions: {},
+        description: r.description,
+        parameters: [],
+        requestBody: {
+          content: {},
+        },
+        responses: {
+          ...errorCodes,
+        },
+        summary: r.path,
+        tags: r.tags,
+      };
 
-    r.method = r.isWebSocket ? 'get' : r.method;
+      r.method = r.isWebSocket ? 'get' : r.method;
 
-    // Find all the swagger definitions and merge them into the
-    // definitions object
-    const allDefs = {
-      ...(r?.body?.definitions || {}),
-      ...(r?.query?.definitions || {}),
-      ...(r?.response?.definitions || {}),
-    };
+      // Find all the swagger definitions and merge them into the
+      // definitions object
+      const allDefs = {
+        ...(r?.body?.definitions || {}),
+        ...(r?.query?.definitions || {}),
+        ...(r?.response?.definitions || {}),
+      };
 
-    Object.entries(allDefs).forEach(([defName, definition]) => {
-      // @ts-ignore
-      swaggerJSON.definitions[defName] =
+      Object.entries(allDefs).forEach(([defName, definition]) => {
         // @ts-ignore
-        swaggerJSON.definitions[defName] ?? definition;
-    });
-
-    if (r.isWebSocket) {
-      swaggerRoute.responses['101'] = {
-        description: 'Indicates successful WebSocket upgrade.',
-      };
-    }
+        swaggerJSON.definitions[defName] =
+          // @ts-ignore
+          swaggerJSON.definitions[defName] ?? definition;
+      });
 
-    // Does a best-attempt at configuring multiple response types
-    // Won't figure out APIs that return mixed response types like
-    // JSON and binary blobs
-    if (r.response) {
-      if (r.contentTypes.length === 1) {
-        const [type] = r.contentTypes;
-        swaggerRoute.responses['200'] = {
-          content: {
-            [type]: {
-              schema: r.response,
-            },
-          },
-          description: r.response.description,
+      if (r.isWebSocket) {
+        swaggerRoute.responses['101'] = {
+          description: 'Indicates successful WebSocket upgrade.',
         };
-      } else {
-        const okResponses = r.contentTypes.reduce(
-          (accum, c) => {
-            // @ts-ignore
-            accum.content[c] = {
-              schema: {
-                type: 'text',
+      }
+
+      // Does a best-attempt at configuring multiple response types
+      // Won't figure out APIs that return mixed response types like
+      // JSON and binary blobs
+      if (r.response) {
+        if (r.contentTypes.length === 1) {
+          const [type] = r.contentTypes;
+          swaggerRoute.responses['200'] = {
+            content: {
+              [type]: {
+                schema: r.response,
               },
-            };
-            return accum;
-          },
-          {
-            content: {},
+            },
             description: r.response.description,
-          },
-        );
-        swaggerRoute.responses['200'] = okResponses;
+          };
+        } else {
+          const okResponses = r.contentTypes.reduce(
+            (accum, c) => {
+              // @ts-ignore
+              accum.content[c] = {
+                schema: {
+                  type: 'text',
+                },
+              };
+              return accum;
+            },
+            {
+              content: {},
+              description: r.response.description,
+            },
+          );
+          swaggerRoute.responses['200'] = okResponses;
+        }
       }
-    }
 
-    // Does a best-attempt at configuring multiple body types and
-    // ignores the "accepts" properties on routes since we can't
-    // yet correlate the accepted types to the proper body
-    if (r.body) {
-      const { properties, type, anyOf } = r.body;
-      if (anyOf) {
-        // @ts-ignore
-        anyOf.forEach((anyType) => {
-          if (anyType.type === 'string') {
-            const type = r.accepts.filter(
-              // @ts-ignore
-              (accept) => accept !== 'application/json',
-            );
-            swaggerRoute.requestBody.content[type] = {
-              schema: {
-                type: 'string',
-              },
-            };
-          }
+      // Does a best-attempt at configuring multiple body types and
+      // ignores the "accepts" properties on routes since we can't
+      // yet correlate the accepted types to the proper body
+      if (r.body) {
+        const { properties, type, anyOf } = r.body;
+        if (anyOf) {
+          // @ts-ignore
+          anyOf.forEach((anyType) => {
+            if (anyType.type === 'string') {
+              const type = r.accepts.filter(
+                // @ts-ignore
+                (accept) => accept !== 'application/json',
+              );
+              swaggerRoute.requestBody.content[type] = {
+                schema: {
+                  type: 'string',
+                },
+              };
+            }
 
-          if (anyType['$ref']) {
-            swaggerRoute.requestBody.content['application/json'] = {
-              schema: {
-                $ref: anyType['$ref'],
-              },
-            };
-          }
-        });
-      }
+            if (anyType['$ref']) {
+              swaggerRoute.requestBody.content['application/json'] = {
+                schema: {
+                  $ref: anyType['$ref'],
+                },
+              };
+            }
+          });
+        }
 
-      // Handle JSON
-      if (type === 'object') {
-        swaggerRoute.requestBody.content['application/json'] = {
-          schema: {
-            properties,
-            type: 'object',
-          },
-        };
+        // Handle JSON
+        if (type === 'object') {
+          swaggerRoute.requestBody.content['application/json'] = {
+            schema: {
+              properties,
+              type: 'object',
+            },
+          };
+        }
       }
-    }
 
-    // Queries are easy in comparison, but still have to be iterated
-    // over and made open-api-able
-    if (r.query) {
-      const { properties, required } = r.query;
-      const props = Object.keys(properties || {});
-      if (props.length) {
-        swaggerRoute.parameters = props
-          .map((prop) => ({
-            in: 'query',
-            name: prop,
-            required: required?.includes(prop),
-            schema: properties[prop],
-          }))
-          .sort(sortSwaggerRequiredAlpha);
+      // Queries are easy in comparison, but still have to be iterated
+      // over and made open-api-able
+      if (r.query) {
+        const { properties, required } = r.query;
+        const props = Object.keys(properties || {});
+        if (props.length) {
+          swaggerRoute.parameters = props
+            .map((prop) => ({
+              in: 'query',
+              name: prop,
+              required: required?.includes(prop),
+              schema: properties[prop],
+            }))
+            .sort(sortSwaggerRequiredAlpha);
+        }
       }
-    }
 
-    // @ts-ignore
-    accum[r.path] = accum[r.path] || {};
-    // @ts-ignore
-    accum[r.path][r.method] = swaggerRoute;
+      // @ts-ignore
+      accum[r.path] = accum[r.path] || {};
+      // @ts-ignore
+      accum[r.path][r.method] = swaggerRoute;
 
-    return accum;
-  }, {});
+      return accum;
+    }, {});
   swaggerJSON.paths = paths;
-  fs.writeFile(swaggerJSONPath, JSON.stringify(swaggerJSON, null, '  '));
+  await fs.writeFile(
+    swaggerJSONMinimal,
+    JSON.stringify(swaggerJSON, null, '  '),
+  );
+  swaggerJSON.info.description = readme + `\n# Changelog\n` + changelog;
+  await fs.writeFile(swaggerJSONPath, JSON.stringify(swaggerJSON, null, '  '));
 };
 
 export default buildOpenAPI;

package/scripts/build-schemas.js

@@ -2,8 +2,6 @@
 /* global console, process */
 'use strict';
 
-import { getRouteFiles, tsExtension } from '../build/utils.js';
-import { Config } from '../build/config.js';
 import TJS from 'typescript-json-schema';
 import fs from 'fs/promises';
 import path from 'path';
@@ -14,6 +12,8 @@ const buildSchemas = async (
   externalHTTPRoutes = [],
   externalWebSocketRoutes = [],
 ) => {
+  const { getRouteFiles, tsExtension } = await import('../build/utils.js');
+
   const schemas = ['BodySchema', 'QuerySchema', 'ResponseSchema'];
   const settings = {
     ignoreErrors: true,
@@ -25,6 +25,7 @@ const buildSchemas = async (
     await fs.readFile('tsconfig.json', 'utf-8'),
   );
 
+  const { Config } = await import('../build/config.js');
   const [httpRoutes, wsRoutes] = await getRouteFiles(new Config());
 
   // Depending on if we're parsing an external projects routes,

package/src/browserless.ts

@@ -36,11 +36,11 @@ type Implements<T> = {
   new (...args: unknown[]): T;
 };
 
-type RouteTypes =
-  | typeof HTTPRoute
-  | typeof BrowserHTTPRoute
-  | typeof WebSocketRoute
-  | typeof BrowserWebsocketRoute;
+type routeInstances =
+  | HTTPRoute
+  | BrowserHTTPRoute
+  | WebSocketRoute
+  | BrowserWebsocketRoute;
 
 export class Browserless {
   protected debug: debug.Debugger = createLogger('index');
@@ -54,7 +54,7 @@ export class Browserless {
   protected token: Token;
   protected webhooks: WebHooks;
 
-  DisabledRoutes: RouteTypes[] = [];
+  disabledRouteNames: string[] = [];
   webSocketRouteFiles: string[] = [];
   httpRouteFiles: string[] = [];
   server?: HTTPServer;
@@ -145,13 +145,12 @@ export class Browserless {
     );
   };
 
-  private routeIsDisabled(Route: RouteTypes) {
-    const Stringified = Route.toString();
-    return this.DisabledRoutes.some((r) => r.toString() === Stringified);
+  private routeIsDisabled(route: routeInstances) {
+    return this.disabledRouteNames.some((name) => name === route.name);
   }
 
-  public disableRoute(Route: RouteTypes) {
-    this.DisabledRoutes.push(Route);
+  public disableRoutes(...routeNames: string[]) {
+    this.disabledRouteNames.push(...routeNames);
   }
 
   public addHTTPRoute(httpRouteFilePath: string) {
@@ -220,15 +219,16 @@ export class Browserless {
           default: Route,
         }: { default: Implements<HTTPRoute> | Implements<BrowserHTTPRoute> } =
           await import(routeImport + `?cb=${Date.now()}`);
-        if (!this.routeIsDisabled(Route)) {
-          const route = new Route(
-            this.browserManager,
-            this.config,
-            this.fileSystem,
-            logger,
-            this.metrics,
-            this.monitoring,
-          );
+        const route = new Route(
+          this.browserManager,
+          this.config,
+          this.fileSystem,
+          logger,
+          this.metrics,
+          this.monitoring,
+        );
+
+        if (!this.routeIsDisabled(route)) {
           route.bodySchema = safeParse(bodySchema);
           route.querySchema = safeParse(querySchema);
           route.config = () => this.config;
@@ -270,15 +270,16 @@ export class Browserless {
             | Implements<WebSocketRoute>
             | Implements<BrowserWebsocketRoute>;
         } = await import(wsImport + `?cb=${Date.now()}`);
-        if (!this.routeIsDisabled(Route)) {
-          const route = new Route(
-            this.browserManager,
-            this.config,
-            this.fileSystem,
-            logger,
-            this.metrics,
-            this.monitoring,
-          );
+        const route = new Route(
+          this.browserManager,
+          this.config,
+          this.fileSystem,
+          logger,
+          this.metrics,
+          this.monitoring,
+        );
+
+        if (!this.routeIsDisabled(route)) {
           route.querySchema = safeParse(querySchema);
           route.config = () => this.config;
           route.metrics = () => this.metrics;
@@ -291,8 +292,9 @@ export class Browserless {
       }
     }
 
+    const allRoutes = [...httpRoutes, ...wsRoutes];
     // Validate that we have the browsers they are asking for
-    [...httpRoutes, ...wsRoutes].forEach((route) => {
+    allRoutes.forEach((route) => {
       if (
         'browser' in route &&
         route.browser &&
@@ -305,6 +307,17 @@ export class Browserless {
       }
     });
 
+    const duplicateNamedRoutes = allRoutes
+      .filter((e, i, a) => a.findIndex((r) => r.name === e.name) !== i)
+      .map((r) => r.name);
+
+    if (duplicateNamedRoutes.length) {
+      this.debug(
+        `Found duplicate routing names. Route names must be unique:`,
+        duplicateNamedRoutes,
+      );
+    }
+
     httpRoutes.forEach((r) => this.router.registerHTTPRoute(r));
     wsRoutes.forEach((r) => this.router.registerWebSocketRoute(r));
 

package/src/browsers/chrome.cdp.ts

@@ -5,6 +5,6 @@ import {
 import { ChromiumCDP } from './chromium.cdp.js';
 
 export class ChromeCDP extends ChromiumCDP {
-  protected executablePath = chromeExecutablePath;
+  protected executablePath = chromeExecutablePath();
   protected debug = createLogger('browsers:chrome:cdp');
 }

package/src/browsers/chrome.playwright.ts

@@ -5,6 +5,6 @@ import {
 import { ChromiumPlaywright } from './chromium.playwright.js';
 
 export class ChromePlaywright extends ChromiumPlaywright {
-  protected executablePath = chromeExecutablePath;
+  protected executablePath = chromeExecutablePath();
   protected debug = createLogger('browsers:chrome:playwright');
 }

package/src/browsers/index.ts

@@ -63,6 +63,10 @@ export class BrowserManager {
     }
   };
 
+  protected onNewPage = async (req: Request, page: unknown) => {
+    await pageHook({ meta: req.parsed, page });
+  };
+
   /**
    * Returns the /json/protocol API contents from Chromium or Chrome, whichever is installed,
    * and modifies URLs to set them to the appropriate addresses configured.
@@ -466,7 +470,7 @@ export class BrowserManager {
     await browserHook({ browser, meta: req.parsed });
 
     browser.on('newPage', async (page) => {
-      await pageHook({ meta: req.parsed, page });
+      await this.onNewPage(req, page);
       (router.onNewPage || noop)(req.parsed || '', page);
     });
 

package/src/exports.ts

@@ -1,49 +1,25 @@
-// Core
-export * from './exports.core.js';
-
-// Chrome
-export { default as ChromeContentPostRoute } from './routes/chrome/http/content.post.js';
-export { default as ChromeDownloadPostRoute } from './routes/chrome/http/download.post.js';
-export { default as ChromeFunctionPostRoute } from './routes/chrome/http/function.post.js';
-export { default as ChromeJSONListGetRoute } from './routes/chrome/http/json-list.get.js';
-export { default as ChromeJSONNewPutRoute } from './routes/chrome/http/json-new.put.js';
-export { default as ChromeJSONProtocolGetRoute } from './routes/chrome/http/json-protocol.get.js';
-export { default as ChromeJSONVersionGetRoute } from './routes/chrome/http/json-version.get.js';
-export { default as ChromePDFPostRoute } from './routes/chrome/http/pdf.post.js';
-export { default as ChromePerformancePostRoute } from './routes/chrome/http/performance.post.js';
-export { default as ChromeScrapePostRoute } from './routes/chrome/http/scrape.post.js';
-export { default as ChromeScreenshotPostRoute } from './routes/chrome/http/screenshot.post.js';
-export { default as ChromeBrowserWebSocketRoute } from './routes/chrome/ws/browser.js';
-export { default as ChromeCDPWebSocketRoute } from './routes/chrome/ws/cdp.js';
-export { default as ChromePageWebSocketRoute } from './routes/chrome/ws/page.js';
-export { default as ChromePlaywrightWebSocketRoute } from './routes/chrome/ws/playwright.js';
-
-// Chromium
-export { default as ChromiumContentPostRoute } from './routes/chromium/http/content.post.js';
-export { default as ChromiumDownloadPostRoute } from './routes/chromium/http/download.post.js';
-export { default as ChromiumFunctionPostRoute } from './routes/chromium/http/function.post.js';
-export { default as ChromiumJSONListGetRoute } from './routes/chromium/http/json-list.get.js';
-export { default as ChromiumJSONNewPutRoute } from './routes/chromium/http/json-new.put.js';
-export { default as ChromiumJSONProtocolGetRoute } from './routes/chromium/http/json-protocol.get.js';
-export { default as ChromiumJSONVersionGetRoute } from './routes/chromium/http/json-version.get.js';
-export { default as ChromiumPDFPostRoute } from './routes/chromium/http/pdf.post.js';
-export { default as ChromiumPerformancePostRoute } from './routes/chromium/http/performance.post.js';
-export { default as ChromiumScrapePostRoute } from './routes/chromium/http/scrape.post.js';
-export { default as ChromiumScreenshotPostRoute } from './routes/chromium/http/screenshot.post.js';
-export { default as ChromiumBrowserWebSocketRoute } from './routes/chromium/ws/browser.js';
-export { default as ChromiumCDPWebSocketRoute } from './routes/chromium/ws/cdp.js';
-export { default as ChromiumPageWebSocketRoute } from './routes/chromium/ws/page.js';
-export { default as ChromiumPlaywrightWebSocketRoute } from './routes/chromium/ws/playwright.js';
-
-// Firefox
-export { default as FirefoxPlaywrightWebSocketRoute } from './routes/firefox/ws/playwright.js';
-
-// WebKit
-export { default as WebKitPlaywrightWebSocketRoute } from './routes/webkit/ws/playwright.js';
-
-// Management
-export { default as ConfigGetRoute } from './routes/management/http/config.get.js';
-export { default as MetricsTotalGetRoute } from './routes/management/http/metrics-total.get.js';
-export { default as MetricsGetRoute } from './routes/management/http/metrics.get.js';
-export { default as SessionsGetGetRoute } from './routes/management/http/sessions.get.js';
-export { default as StaticGetRoute } from './routes/management/http/static.get.js';
+// Export all them goods...
+export * from './browserless.js';
+export * from './config.js';
+export * from './constants.js';
+export * from './file-system.js';
+export * from './hooks.js';
+export * from './http.js';
+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';
+export * from './browsers/index.js';
+export * from './browsers/chrome.cdp.js';
+export * from './browsers/chrome.playwright.js';
+export * from './browsers/chromium.cdp.js';
+export * from './browsers/chromium.playwright.js';
+export * from './browsers/firefox.playwright.js';
+export * from './browsers/webkit.playwright.js';