@contrast/route-coverage 1.23.1 → 1.25.0

package/lib/index.d.ts

@@ -15,9 +15,9 @@
 
 import { Installable, Messages, RouteInfo } from '@contrast/common';
 import { Config } from '@contrast/config';
+import { DepHooks } from '@contrast/dep-hooks';
 import { Logger } from '@contrast/logger';
 import { Patcher } from '@contrast/patcher';
-import RequireHook from '@contrast/require-hook';
 import { Scopes } from '@contrast/scopes';
 
 export { RouteInfo };
@@ -32,7 +32,7 @@ export interface RouteCoverage extends Installable {
 
 export interface Core {
   readonly config: Config;
-  readonly depHooks: RequireHook;
+  readonly depHooks: DepHooks;
   readonly logger: Logger;
   readonly messages: Messages;
   readonly patcher: Patcher;

package/lib/install/fastify.js

@@ -14,8 +14,8 @@
  */
 'use strict';
 
-const { StringPrototypeToLowerCase, isString } = require('@contrast/common');
-const { getFastifyMethods } = require('./../utils/methods');
+const { getFastifyMethods } = require('../utils/methods');
+const { StringPrototypeToLowerCase } = require('@contrast/common');
 const { patchType } = require('./../utils/route-info');
 
 // Spec: https://contrast.atlassian.net/wiki/spaces/NOD/pages/3454861621/Node.js+Agent+Route+Signatures#Fastify
@@ -28,19 +28,14 @@ module.exports = function init(core) {
   We need a way to keep track of which routes were fully declared using .route
   So, we instrument the route method below and add identifying info to this array
  */
-  const fullyDeclaredRoutes = [];
   const { patcher, depHooks, routeCoverage } = core;
 
-  const isFullyDeclared = (method, url) => isString(method) && fullyDeclaredRoutes.includes(method + url);
-  function fullyDeclare(method, url) {
-    if (isString(method)) {
-      fullyDeclaredRoutes.push(method + url);
-      if (method === 'GET') fullyDeclaredRoutes.push(`HEAD${url}`);
-    }
+  function getPrefix(route) {
+    const kRoutePrefix = Object.getOwnPropertySymbols(route).find((s) => s.description === 'fastify.routePrefix');
+    return route?.[kRoutePrefix];
   }
 
-  function createRouteInfo(method, url, routePath) {
-    const fullyDeclared = isFullyDeclared(method, routePath);
+  function createRouteInfo(method, url, fullyDeclared) {
     method = StringPrototypeToLowerCase.call(method);
 
     const signature = fullyDeclared
@@ -57,67 +52,122 @@ module.exports = function init(core) {
     return routeInfo;
   }
 
+  function patchHandler(route, handle, routeInfo) {
+    const pre = ({ args }) => {
+      const [req] = args;
+      const method = StringPrototypeToLowerCase.call(req.raw?.method);
+      const [url] = req.url.split(/\?/);
+      routeCoverage.observe({ ...routeInfo, url, method });
+    };
+
+    const name = `fastify.route.${handle}`;
+    if (route[handle]) {
+      patcher.patch(route, handle, {
+        name,
+        patchType,
+        pre
+      });
+    } else {
+      const idx = handle === 'options' ? 2 : handle === 'handler' ? 3 : null;
+      if (idx) route[idx] = patcher.patch(route[idx], {
+        name,
+        patchType,
+        pre
+      });
+    }
+  }
+
+  function discoverAndPatch(method, path, handler, handle, methods, fullyDeclared) {
+    if (Array.isArray(method)) {
+      // If all valid methods are included in `method` then .all shorthand was most likely used
+      if (methods.every(m => method.includes(m))) {
+        const routeInfo = createRouteInfo('all', path, fullyDeclared);
+        routeCoverage.discover(routeInfo);
+        patchHandler(handler, handle, routeInfo);
+      } else {
+        method.forEach((verb) => {
+          const routeInfo = createRouteInfo(verb, path, fullyDeclared);
+          routeCoverage.discover(routeInfo);
+          patchHandler(handler, handle, routeInfo);
+        });
+      }
+    } else {
+      const routeInfo = createRouteInfo(method, path, fullyDeclared);
+      routeCoverage.discover(routeInfo);
+      patchHandler(handler, handle, routeInfo);
+    }
+  }
+
   return core.routeCoverage.fastify = {
     install() {
-      // The routePath property used below was introduced in 3.2.0
-      return depHooks.resolve({ name: 'fastify', version: '>=3.2.0' }, (fastify) => patcher.patch(fastify, {
-        name: 'fastify',
-        patchType,
-        post({ result: server }) {
-          patcher.patch(server, 'route', {
-            name: 'server.route',
+      /**
+       * There are some subtle differences between fastify minor versions the instrumentation must account for
+       * >=3 <4.1.0 the route options are passed in as regular args i.e. route(method, url, options, handler)
+       *    and prepareRoute(method, url, options, handler)
+       * >= 4.1.0 the route options are passed in as an object i.e. route({ method, url, options, handler })
+       *    and prepareRoute({ options: { method, url, options, handler }})
+       */
+      [
+        { version: '>=3 <4.1.0', routeObj: false },
+        { version: '>=4.1.0 <4.4.0', routeObj: true },
+        { version: '>=4.4.0', routeObj: true }
+      ].forEach(({ version, routeObj }) => {
+        // See ../utils/methods
+        // Using .all shorthand uses all valid methods but those change after version 4.4.0
+        const FASTIFY_METHODS = getFastifyMethods(version);
+        depHooks.resolve({ name: 'fastify', version, file: 'lib/route.js' }, (Route) => {
+          patcher.patch(Route, 'buildRouting', {
+            name: 'fastify.Route.buildRouting',
             patchType,
-            pre({ args }) {
-              const [{ method, url }] = args;
-              if (!isString(url)) return;
-
-              if (Array.isArray(method)) {
-                method.forEach((verb) => {
-                  fullyDeclare(verb, url);
-                });
-              } else {
-                fullyDeclare(method, url);
-              }
-            }
-          });
-          server.addHook('onRoute', (routeOptions) => {
-            if (!routeOptions) return;
-
-            const { method, url, routePath } = routeOptions;
-            if (!method || !url || !routePath || !isString(routePath)) return;
-
-            let routeInfo;
-            const FASTIFY_METHODS = getFastifyMethods(server.version);
-            if (Array.isArray(method)) {
-              // If a route was defined using .all this method property will be an
-              // array of all methods supported by Fastify
-              if (FASTIFY_METHODS.every(m => method.includes(m))) {
-                routeInfo = createRouteInfo('all', url, routePath);
-                routeCoverage.discover(routeInfo);
-              } else {
-                method.forEach((verb) => {
-                  routeInfo = createRouteInfo(verb, url, routePath);
-                  routeCoverage.discover(routeInfo);
-                });
-              }
-            } else {
-              routeInfo = createRouteInfo(method, url, routePath);
-              routeCoverage.discover(routeInfo);
-            }
+            post(data) {
+
+              // Handles routes defined through fastify.<method> shorthand
+              patcher.patch(data.result, 'prepareRoute', {
+                name: 'prepareRoute',
+                patchType,
+                pre(data) {
+                  if (!data.args.length) return;
+
+                  let method, url, options, handler;
+                  if (routeObj) {
+                    [{ method, url, options, handler }] = data.args;
+                  } else {
+                    [method, url, options, handler] = data.args;
+                  }
+
+                  if (!method || !url || !(options || handler)) return;
 
-            patcher.patch(routeOptions, 'handler', {
-              name: 'fastify.routeOptions.handler',
-              patchType,
-              pre({ args }) {
-                const [req] = args;
-                const method = StringPrototypeToLowerCase.call(req.raw?.method);
-                const [url] = req.url.split(/\?/);
-                routeCoverage.observe({ ...routeInfo, url, method });
-              },
-            });
+                  const prefix = getPrefix(data.obj);
+                  const path = prefix ? prefix + url : url;
+
+                  // See lib/route.js: prepareRoute
+                  let handle = 'handler';
+                  if (!handler && typeof options === 'function') handle = 'options';
+
+                  discoverAndPatch(method, path, routeObj ? data.args[0] : data.args, handle, FASTIFY_METHODS, false);
+                }
+              });
+
+              // Handles routes defined fully fastify.route({})
+              patcher.patch(data.result, 'route', {
+                name: 'route',
+                patchType,
+                pre(data) {
+
+                  if (!data.args.length) return;
+                  const routeArgs = routeObj ? data.args[0]?.options : data.args[0];
+                  const { url, method, handler } = routeArgs;
+                  if (!method || !url || !handler) return;
+
+                  const prefix = getPrefix(data.obj);
+                  const path = prefix ? prefix + url : url;
+                  discoverAndPatch(method, path, routeArgs, 'handler', FASTIFY_METHODS, true);
+                }
+              });
+            }
           });
-        }
-      }));
+        });
+      });
     }
   };
 };

package/lib/install/fastify.test.js

@@ -7,191 +7,212 @@ const patcher = require('@contrast/patcher');
 const mocks = require('@contrast/test/mocks');
 const { getFastifyMethods } = require('../utils/methods');
 
-describe('route-coverage fastify', function () {
-  let core, serverMock, framework;
-
-  beforeEach(function () {
-    core = mocks.core();
-    core.logger = mocks.logger();
-    core.routeCoverage = mocks.routeCoverage();
-    core.scopes = scopes(core);
-    core.depHooks = mocks.depHooks();
-    core.patcher = patcher(core);
-
-    serverMock = {
-      addHook: sinon.stub(),
-      route: sinon.stub(),
-      version: '4.4.0'
-    };
-
-    let fastify;
-    framework = 'fastify';
-    core.depHooks.resolve.callsFake((desc, cb) => {
-      fastify = cb(() => serverMock);
+[
+  { version: '>=3 <4.1.0', routeObj: false },
+  { version: '>=4.1.0 <4.4.0', routeObj: true },
+  { version: '>=4.4.0', routeObj: true }
+].forEach(({ version, routeObj }) => {
+  describe(`route-coverage fastify (${version})`, function () {
+    const FASTIFY_METHODS = getFastifyMethods(version);
+    let core, RouteMock, framework, routing, fn;
+
+    function routeOptions(options, fullyDeclared, routeObj) {
+      if (fullyDeclared && routeObj) {
+        return [{ options }];
+      } else if ((fullyDeclared && !routeObj) || (!fullyDeclared && routeObj)) {
+        return [options];
+      } else if (!fullyDeclared && !routeObj) {
+        return Object.values(options);
+      }
+    }
+
+    beforeEach(function () {
+      core = mocks.core();
+      core.logger = mocks.logger();
+      core.routeCoverage = mocks.routeCoverage();
+      core.scopes = scopes(core);
+      core.depHooks = mocks.depHooks();
+      core.patcher = patcher(core);
+      sinon.spy(core.patcher, 'patch');
+
+      RouteMock = {
+        buildRouting: () => ({
+          prepareRoute: sinon.stub(),
+          route: sinon.stub()
+        })
+      };
+
+      framework = 'fastify';
+      core.depHooks.resolve
+        .withArgs({ name: 'fastify', version, file: 'lib/route.js' })
+        .yields(RouteMock);
+
+      require('./fastify')(core).install();
+
+      routing = RouteMock.buildRouting();
+      fn = sinon.stub();
     });
 
-    require('./fastify')(core).install();
-
-    fastify();
-  });
-
-  it('skips instrumenting if route options does not exist', function () {
-    serverMock.addHook.withArgs('onRoute').yield();
-    expect(core.routeCoverage.discover).not.to.have.been.called;
-  });
-
-  it('skips instrumenting if there is no method provided', function () {
-    serverMock.addHook.withArgs('onRoute').yield({});
-    expect(core.routeCoverage.discover).not.to.have.been.called;
-  });
-
-  it('skips instrumenting if there is no url provided', function () {
-    serverMock.addHook.withArgs('onRoute').yield({ method: 'GET' });
-    expect(core.routeCoverage.discover).not.to.have.been.called;
-  });
-
-  it('discovers a route with a single method', function () {
-    serverMock.addHook
-      .withArgs('onRoute')
-      .yield({ method: 'GET', url: '/test/route', routePath: '/test/route' });
-
-    expect(core.routeCoverage.discover).to.have.been.calledWith({
-      signature: "fastify.get('/test/route', [Function])",
-      url: '/test/route',
-      normalizedUrl: '/test/route',
-      method: 'get',
-      framework
+    [
+      { method: 'prepareRoute', fullyDefined: false },
+      { method: 'route', fullyDefined: true },
+    ].forEach(({ method, fullyDefined }) => {
+      describe(`.${method} base cases`, function() {
+        it('skips instrumenting if nothing is provided', function () {
+          routing[method]();
+          expect(core.routeCoverage.discover).not.to.have.been.called;
+        });
+
+        it('skips instrumenting if there is no method provided', function () {
+          routing[method](...routeOptions({ url: '/test/route', handler: fn }, fullyDefined, routeObj));
+          expect(core.routeCoverage.discover).not.to.have.been.called;
+        });
+
+        it('skips instrumenting if there is no url provided', function () {
+          routing[method](...routeOptions({ method: 'GET', handler: fn }, fullyDefined, routeObj));
+          expect(core.routeCoverage.discover).not.to.have.been.called;
+        });
+
+        it('skips instrumenting if there is no handler is provided', function () {
+          routing[method](...routeOptions({ method: 'GET', url: '/test/route' }, fullyDefined, routeObj));
+          expect(core.routeCoverage.discover).not.to.have.been.called;
+        });
+      });
     });
-    expect(core.routeCoverage.discover).to.have.been.called;
-    expect(core.routeCoverage.discover).to.have.callCount(1);
-  });
 
-  it('discovers a fully declared (.route) route with a single method', function () {
-    serverMock.route({ method: 'GET', url: '/test/route' });
-    serverMock.addHook
-      .withArgs('onRoute')
-      .yield({ method: 'GET', url: '/test/route', routePath: '/test/route' });
-
-    expect(core.routeCoverage.discover).to.have.been.calledWith({
-      signature: "fastify.route({ method: 'get', url: '/test/route', handler: [Function] })",
-      url: '/test/route',
-      normalizedUrl: '/test/route',
-      method: 'get',
-      framework
+    it('discovers a route with a single method', function () {
+      routing.prepareRoute(...routeOptions({ method: 'GET', url: '/test/route', handler: fn }, false, routeObj));
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: "fastify.get('/test/route', [Function])",
+        url: '/test/route',
+        normalizedUrl: '/test/route',
+        method: 'get',
+        framework
+      });
+      expect(core.routeCoverage.discover).to.have.been.called;
+      expect(core.routeCoverage.discover).to.have.callCount(1);
     });
-    expect(core.routeCoverage.discover).to.have.been.called;
-    expect(core.routeCoverage.discover).to.have.callCount(1);
-  });
 
-  it('discovers a route with multiple methods', function () {
-    serverMock.addHook.withArgs('onRoute').yield({
-      method: ['GET', 'POST'],
-      url: '/test/route',
-      routePath: '/test/route'
+    it('discovers a route with a prefixed path', function () {
+      routing[Symbol('fastify.routePrefix')] = '/prefix';
+      routing.prepareRoute(...routeOptions({ method: 'GET', url: '/test/route', handler: fn }, false, routeObj));
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: "fastify.get('/prefix/test/route', [Function])",
+        url: '/prefix/test/route',
+        normalizedUrl: '/prefix/test/route',
+        method: 'get',
+        framework
+      });
+      expect(core.routeCoverage.discover).to.have.been.called;
+      expect(core.routeCoverage.discover).to.have.callCount(1);
     });
 
-    expect(core.routeCoverage.discover).to.have.been.calledWith({
-      signature: "fastify.get('/test/route', [Function])",
-      url: '/test/route',
-      normalizedUrl: '/test/route',
-      method: 'get',
-      framework
+    it('discovers a fully declared (.route) with a prefixed path', function () {
+      routing[Symbol('fastify.routePrefix')] = '/prefix';
+      routing.route(...routeOptions({ method: 'GET', url: '/test/route', handler: fn }, true, routeObj));
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: "fastify.route({ method: 'get', url: '/prefix/test/route', handler: [Function] })",
+        url: '/prefix/test/route',
+        normalizedUrl: '/prefix/test/route',
+        method: 'get',
+        framework
+      });
+      expect(core.routeCoverage.discover).to.have.been.called;
+      expect(core.routeCoverage.discover).to.have.callCount(1);
     });
 
-    expect(core.routeCoverage.discover).to.have.been.calledWith({
-      signature: "fastify.post('/test/route', [Function])",
-      url: '/test/route',
-      normalizedUrl: '/test/route',
-      method: 'post',
-      framework
+    it('discovers a fully declared (.route) route with a single method', function () {
+      routing.route(...routeOptions({ method: 'GET', url: '/test/route', handler: fn }, true, routeObj));
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: "fastify.route({ method: 'get', url: '/test/route', handler: [Function] })",
+        url: '/test/route',
+        normalizedUrl: '/test/route',
+        method: 'get',
+        framework
+      });
+      expect(core.routeCoverage.discover).to.have.been.called;
+      expect(core.routeCoverage.discover).to.have.callCount(1);
     });
 
-    expect(core.routeCoverage.discover).to.have.callCount(2);
-  });
-
-  it('discovers a route with all methods', function () {
-    const FASTIFY_METHODS = getFastifyMethods('4.4.0');
-    serverMock.addHook.withArgs('onRoute').yield({
-      method: FASTIFY_METHODS,
-      url: '/test/route',
-      routePath: '/test/route'
+    it('discovers a route with multiple methods', function () {
+      routing.prepareRoute(...routeOptions({ method: ['GET', 'POST'], url: '/test/route', handler: fn }, false, routeObj));
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: "fastify.get('/test/route', [Function])",
+        url: '/test/route',
+        normalizedUrl: '/test/route',
+        method: 'get',
+        framework
+      });
+
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: "fastify.post('/test/route', [Function])",
+        url: '/test/route',
+        normalizedUrl: '/test/route',
+        method: 'post',
+        framework
+      });
+
+      expect(core.routeCoverage.discover).to.have.callCount(2);
     });
 
-    expect(core.routeCoverage.discover).to.have.been.calledWith({
-      signature: "fastify.all('/test/route', [Function])",
-      url: '/test/route',
-      normalizedUrl: '/test/route',
-      method: 'all',
-      framework
+    it('discovers a route with all methods', function () {
+      routing.prepareRoute(...routeOptions({ method: FASTIFY_METHODS, url: '/test/route', handler: fn }, false, routeObj));
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: "fastify.all('/test/route', [Function])",
+        url: '/test/route',
+        normalizedUrl: '/test/route',
+        method: 'all',
+        framework
+      });
     });
-  });
-
-  it('discovers a fully declared route (.route) with multiple methods', function () {
-    serverMock.route({ method: ['GET', 'POST'], url: '/test/route' });
 
-    serverMock.addHook.withArgs('onRoute').yield({
-      method: ['GET', 'POST'],
-      url: '/test/route',
-      routePath: '/test/route'
+    it('discovers a fully declared route (.route) with multiple methods', function () {
+      routing.route(...routeOptions({ method: ['GET', 'POST'], url: '/test/route', handler: fn }, true, routeObj));
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: "fastify.route({ method: 'get', url: '/test/route', handler: [Function] })",
+        url: '/test/route',
+        normalizedUrl: '/test/route',
+        method: 'get',
+        framework
+      });
+
+      expect(core.routeCoverage.discover).to.have.been.calledWith({
+        signature: "fastify.route({ method: 'post', url: '/test/route', handler: [Function] })",
+        url: '/test/route',
+        normalizedUrl: '/test/route',
+        method: 'post',
+        framework
+      });
+
+      expect(core.routeCoverage.discover).to.have.callCount(2);
     });
 
-    expect(core.routeCoverage.discover).to.have.been.calledWith({
-      signature: "fastify.route({ method: 'get', url: '/test/route', handler: [Function] })",
-      url: '/test/route',
-      normalizedUrl: '/test/route',
-      method: 'get',
-      framework
+    it('observes a route when the route handler is called', function () {
+      routing.prepareRoute(...routeOptions({ method: 'GET', url: '/test/route', handler: fn }, false, routeObj));
+      const patchedFn = core.patcher.patch.getCall(3).returnValue;
+      const handler = routeObj ? patchedFn.handler : patchedFn;
+      handler({ raw: { method: 'GET' }, url: '/test/route' });
+      expect(core.routeCoverage.observe).to.have.been.calledWith({
+        signature: "fastify.get('/test/route', [Function])",
+        url: '/test/route',
+        method: 'get',
+        normalizedUrl: '/test/route',
+        framework: 'fastify'
+      });
     });
 
-    expect(core.routeCoverage.discover).to.have.been.calledWith({
-      signature: "fastify.route({ method: 'post', url: '/test/route', handler: [Function] })",
-      url: '/test/route',
-      normalizedUrl: '/test/route',
-      method: 'post',
-      framework
+    it('removes query string from url before reporting observation', function () {
+      routing.prepareRoute(...routeOptions({ method: 'GET', url: '/test/route', handler: fn }, false, routeObj));
+      const patchedFn = core.patcher.patch.getCall(3).returnValue;
+      const handler = routeObj ? patchedFn.handler : patchedFn;
+      handler({ raw: { method: 'GET' }, url: '/test/route' });
+      expect(core.routeCoverage.observe).to.have.been.calledWith({
+        signature: "fastify.get('/test/route', [Function])",
+        url: '/test/route',
+        method: 'get',
+        normalizedUrl: '/test/route',
+        framework: 'fastify'
+      });
     });
-
-    expect(core.routeCoverage.discover).to.have.callCount(2);
   });
-
-  it('observes a route when the route handler is called', function () {
-    const routeOptions = {
-      method: 'GET',
-      url: '/test/route',
-      routePath: '/test/route',
-      handler: sinon.stub(),
-    };
-
-    serverMock.addHook.withArgs('onRoute').yield(routeOptions);
-    routeOptions.handler({ raw: { method: 'GET' }, url: '/test/route' });
-
-    expect(core.routeCoverage.observe).to.have.been.calledWith({
-      signature: "fastify.get('/test/route', [Function])",
-      url: '/test/route',
-      method: 'get',
-      normalizedUrl: '/test/route',
-      framework: 'fastify'
-    });
-  });
-
-  it('removes query string from url before reporting observation', function () {
-    const routeOptions = {
-      method: 'GET',
-      url: '/test/route',
-      routePath: '/test/route',
-      handler: sinon.stub(),
-    };
-
-    serverMock.addHook.withArgs('onRoute').yield(routeOptions);
-    routeOptions.handler({ raw: { method: 'GET' }, url: '/test/route?input=foo' });
-
-    expect(core.routeCoverage.observe).to.have.been.calledWith({
-      signature: "fastify.get('/test/route', [Function])",
-      url: '/test/route',
-      method: 'get',
-      normalizedUrl: '/test/route',
-      framework: 'fastify'
-    });
-  });
-
 });

package/lib/utils/methods.js

@@ -18,7 +18,7 @@
 const semver = require('semver');
 const { METHODS } = require('http');
 
-function getFastifyMethods(version) {
+function getFastifyMethods(range) {
   return [
     'DELETE',
     'GET',
@@ -27,7 +27,7 @@ function getFastifyMethods(version) {
     'POST',
     'PUT',
     'OPTIONS',
-    ...semver.gte(version, '4.4.0') ?
+    ...semver.subset(range, '>=4.4.0') ?
         [
           'PROPFIND',
           'PROPPATCH',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrast/route-coverage",
-  "version": "1.23.1",
+  "version": "1.25.0",
   "description": "Handles route discovery and observation",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Contrast Security <nodejs@contrastsecurity.com> (https://www.contrastsecurity.com)",
@@ -17,12 +17,12 @@
     "test": "../scripts/test.sh"
   },
   "dependencies": {
-    "@contrast/common": "1.24.0",
-    "@contrast/config": "1.31.0",
-    "@contrast/dep-hooks": "1.3.4",
+    "@contrast/common": "1.25.0",
+    "@contrast/config": "1.33.0",
+    "@contrast/dep-hooks": "1.5.0",
     "@contrast/fn-inspect": "^4.3.0",
-    "@contrast/logger": "1.8.5",
-    "@contrast/patcher": "1.7.5",
-    "@contrast/scopes": "1.4.2"
+    "@contrast/logger": "1.10.0",
+    "@contrast/patcher": "1.9.0",
+    "@contrast/scopes": "1.6.0"
   }
 }