@percy/core 1.0.0-beta.7 → 1.0.0-beta.73

package/dist/config.js

@@ -3,35 +3,35 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.schema = void 0;
-// Common options used in Percy commands
-const schema = {
+exports.configMigration = configMigration;
+exports.snapshotDOMSchema = exports.schemas = exports.migrations = exports.configSchema = void 0;
+exports.snapshotMigration = snapshotMigration;
+exports.snapshotSchema = void 0;
+// Common config options used in Percy commands
+const configSchema = {
   snapshot: {
     type: 'object',
     additionalProperties: false,
     properties: {
       widths: {
         type: 'array',
+        default: [375, 1280],
         items: {
-          type: 'integer'
-        },
-        default: [375, 1280]
+          type: 'integer',
+          maximum: 2000,
+          minimum: 10
+        }
       },
       minHeight: {
         type: 'integer',
-        default: 1024
+        default: 1024,
+        maximum: 2000,
+        minimum: 10
       },
       percyCSS: {
         type: 'string',
         default: ''
       },
-      requestHeaders: {
-        type: 'object',
-        additionalProperties: {
-          type: 'string'
-        },
-        default: {}
-      },
       enableJavaScript: {
         type: 'boolean'
       }
@@ -43,27 +43,316 @@ const schema = {
     properties: {
       allowedHostnames: {
         type: 'array',
+        default: [],
         items: {
-          type: 'string'
-        },
-        default: []
+          type: 'string',
+          allOf: [{
+            not: {
+              pattern: '[^/]/'
+            },
+            error: 'must not include a pathname'
+          }, {
+            not: {
+              pattern: '^([a-zA-Z]+:)?//'
+            },
+            error: 'must not include a protocol'
+          }]
+        }
       },
       networkIdleTimeout: {
         type: 'integer',
-        default: 100
+        default: 100,
+        maximum: 750,
+        minimum: 1
+      },
+      disableCache: {
+        type: 'boolean'
+      },
+      requestHeaders: {
+        type: 'object',
+        normalize: false,
+        additionalProperties: {
+          type: 'string'
+        }
       },
-      disableAssetCache: {
-        type: 'boolean',
-        default: false
+      authorization: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          username: {
+            type: 'string'
+          },
+          password: {
+            type: 'string'
+          }
+        }
+      },
+      cookies: {
+        anyOf: [{
+          type: 'object',
+          normalize: false,
+          additionalProperties: {
+            type: 'string'
+          }
+        }, {
+          type: 'array',
+          normalize: false,
+          items: {
+            type: 'object',
+            required: ['name', 'value'],
+            properties: {
+              name: {
+                type: 'string'
+              },
+              value: {
+                type: 'string'
+              }
+            }
+          }
+        }]
+      },
+      userAgent: {
+        type: 'string'
       },
       concurrency: {
         type: 'integer',
-        default: 5
+        minimum: 1
       },
       launchOptions: {
-        type: 'object'
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          executable: {
+            type: 'string'
+          },
+          timeout: {
+            type: 'integer'
+          },
+          args: {
+            type: 'array',
+            items: {
+              type: 'string'
+            }
+          },
+          headless: {
+            type: 'boolean'
+          }
+        }
       }
     }
   }
-};
-exports.schema = schema;
+}; // Common per-snapshot capture options
+
+exports.configSchema = configSchema;
+const snapshotSchema = {
+  $id: '/snapshot',
+  type: 'object',
+  required: ['url'],
+  additionalProperties: false,
+  $refs: {
+    exec: {
+      oneOf: [{
+        oneOf: [{
+          type: 'string'
+        }, {
+          instanceof: 'Function'
+        }]
+      }, {
+        type: 'array',
+        items: {
+          $ref: '#/$refs/exec/oneOf/0'
+        }
+      }]
+    }
+  },
+  properties: {
+    url: {
+      type: 'string'
+    },
+    name: {
+      type: 'string'
+    },
+    widths: {
+      $ref: '/config/snapshot#/properties/widths'
+    },
+    minHeight: {
+      $ref: '/config/snapshot#/properties/minHeight'
+    },
+    percyCSS: {
+      $ref: '/config/snapshot#/properties/percyCSS'
+    },
+    enableJavaScript: {
+      $ref: '/config/snapshot#/properties/enableJavaScript'
+    },
+    discovery: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        allowedHostnames: {
+          $ref: '/config/discovery#/properties/allowedHostnames'
+        },
+        requestHeaders: {
+          $ref: '/config/discovery#/properties/requestHeaders'
+        },
+        authorization: {
+          $ref: '/config/discovery#/properties/authorization'
+        },
+        disableCache: {
+          $ref: '/config/discovery#/properties/disableCache'
+        },
+        userAgent: {
+          $ref: '/config/discovery#/properties/userAgent'
+        }
+      }
+    },
+    waitForSelector: {
+      type: 'string'
+    },
+    waitForTimeout: {
+      type: 'integer',
+      minimum: 1,
+      maximum: 30000
+    },
+    execute: {
+      oneOf: [{
+        $ref: '/snapshot#/$refs/exec'
+      }, {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          afterNavigation: {
+            $ref: '/snapshot#/$refs/exec'
+          },
+          beforeResize: {
+            $ref: '/snapshot#/$refs/exec'
+          },
+          afterResize: {
+            $ref: '/snapshot#/$refs/exec'
+          },
+          beforeSnapshot: {
+            $ref: '/snapshot#/$refs/exec'
+          }
+        }
+      }]
+    },
+    additionalSnapshots: {
+      type: 'array',
+      items: {
+        type: 'object',
+        additionalProperties: false,
+        oneOf: [{
+          required: ['name']
+        }, {
+          anyOf: [{
+            required: ['prefix']
+          }, {
+            required: ['suffix']
+          }]
+        }],
+        properties: {
+          prefix: {
+            type: 'string'
+          },
+          suffix: {
+            type: 'string'
+          },
+          name: {
+            $ref: '/snapshot#/properties/name'
+          },
+          waitForTimeout: {
+            $ref: '/snapshot#/properties/waitForTimeout'
+          },
+          waitForSelector: {
+            $ref: '/snapshot#/properties/waitForSelector'
+          },
+          execute: {
+            $ref: '/snapshot#/$refs/exec'
+          }
+        },
+        errors: {
+          oneOf: ({
+            params
+          }) => params.passingSchemas ? 'prefix & suffix are ignored when a name is provided' : 'missing required name, prefix, or suffix'
+        }
+      }
+    }
+  }
+}; // Disallow capture options for dom snapshots
+
+exports.snapshotSchema = snapshotSchema;
+const snapshotDOMSchema = {
+  $id: '/snapshot/dom',
+  type: 'object',
+  additionalProperties: false,
+  required: ['url', 'domSnapshot'],
+  disallowed: ['additionalSnapshots', 'waitForTimeout', 'waitForSelector', 'execute'],
+  errors: {
+    disallowed: 'not accepted with DOM snapshots'
+  },
+  properties: {
+    domSnapshot: {
+      type: 'string'
+    },
+    // schemas have no concept of inheritance, but we can leverage JS for brevity
+    ...snapshotSchema.properties
+  }
+}; // Grouped schemas for easier registration
+
+exports.snapshotDOMSchema = snapshotDOMSchema;
+const schemas = [configSchema, snapshotSchema, snapshotDOMSchema]; // Config migrate function
+
+exports.schemas = schemas;
+
+function configMigration(config, util) {
+  /* eslint-disable curly */
+  if (config.version < 2) {
+    // discovery options have moved
+    util.map('agent.assetDiscovery.allowedHostnames', 'discovery.allowedHostnames');
+    util.map('agent.assetDiscovery.networkIdleTimeout', 'discovery.networkIdleTimeout');
+    util.map('agent.assetDiscovery.cacheResponses', 'discovery.disableCache', v => !v);
+    util.map('agent.assetDiscovery.requestHeaders', 'discovery.requestHeaders');
+    util.map('agent.assetDiscovery.pagePoolSizeMax', 'discovery.concurrency');
+    util.del('agent');
+  } else {
+    let notice = {
+      type: 'config',
+      until: '1.0.0'
+    }; // snapshot discovery options have moved
+
+    util.deprecate('snapshot.authorization', {
+      map: 'discovery.authorization',
+      ...notice
+    });
+    util.deprecate('snapshot.requestHeaders', {
+      map: 'discovery.requestHeaders',
+      ...notice
+    });
+  }
+} // Snapshot option migrate function
+
+
+function snapshotMigration(config, util) {
+  let notice = {
+    type: 'snapshot',
+    until: '1.0.0',
+    warn: true
+  }; // discovery options have moved
+
+  util.deprecate('authorization', {
+    map: 'discovery.authorization',
+    ...notice
+  });
+  util.deprecate('requestHeaders', {
+    map: 'discovery.requestHeaders',
+    ...notice
+  }); // snapshots option was renamed
+
+  util.deprecate('snapshots', {
+    map: 'additionalSnapshots',
+    ...notice
+  });
+} // Grouped migrations for easier registration
+
+
+const migrations = [['/config', configMigration], ['/snapshot', snapshotMigration]];
+exports.migrations = migrations;

package/dist/discovery.js

@@ -0,0 +1,130 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRequestFailedHandler = createRequestFailedHandler;
+exports.createRequestFinishedHandler = createRequestFinishedHandler;
+exports.createRequestHandler = createRequestHandler;
+
+var _logger = _interopRequireDefault(require("@percy/logger"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const MAX_RESOURCE_SIZE = 15 * 1024 ** 2; // 15MB
+
+const ALLOWED_STATUSES = [200, 201, 301, 302, 304, 307, 308];
+const ALLOWED_RESOURCES = ['Document', 'Stylesheet', 'Image', 'Media', 'Font', 'Other'];
+
+function createRequestHandler(network, {
+  disableCache,
+  getResource
+}) {
+  let log = (0, _logger.default)('core:discovery');
+  return async request => {
+    let url = request.url;
+    let meta = { ...network.meta,
+      url
+    };
+
+    try {
+      log.debug(`Handling request: ${url}`, meta);
+      let resource = getResource(url);
+
+      if (resource !== null && resource !== void 0 && resource.root) {
+        log.debug('- Serving root resource', meta);
+        await request.respond(resource);
+      } else if (resource && !disableCache) {
+        log.debug('- Resource cache hit', meta);
+        await request.respond(resource);
+      } else {
+        await request.continue();
+      }
+    } catch (error) {
+      log.debug(`Encountered an error handling request: ${url}`, meta);
+      log.debug(error);
+      /* istanbul ignore next: race condition */
+
+      await request.abort(error).catch(e => log.debug(e, meta));
+    }
+  };
+}
+
+function createRequestFinishedHandler(network, {
+  enableJavaScript,
+  allowedHostnames,
+  disableCache,
+  getResource,
+  saveResource
+}) {
+  let log = (0, _logger.default)('core:discovery');
+  return async request => {
+    let origin = request.redirectChain[0] || request;
+    let url = (0, _utils.normalizeURL)(origin.url);
+    let meta = { ...network.meta,
+      url
+    };
+
+    try {
+      var _resource;
+
+      let resource = getResource(url); // process and cache the response and resource
+
+      if (!((_resource = resource) !== null && _resource !== void 0 && _resource.root) && (!resource || disableCache)) {
+        let response = request.response;
+        let capture = response && (0, _utils.hostnameMatches)(allowedHostnames, url);
+        let body = capture && (await response.buffer());
+        log.debug(`Processing resource: ${url}`, meta);
+        /* istanbul ignore next: sanity check */
+
+        if (!response) {
+          return log.debug('- Skipping no response', meta);
+        } else if (!capture) {
+          return log.debug('- Skipping remote resource', meta);
+        } else if (!body.length) {
+          return log.debug('- Skipping empty response', meta);
+        } else if (body.length > MAX_RESOURCE_SIZE) {
+          return log.debug('- Skipping resource larger than 15MB', meta);
+        } else if (!ALLOWED_STATUSES.includes(response.status)) {
+          return log.debug(`- Skipping disallowed status [${response.status}]`, meta);
+        } else if (!enableJavaScript && !ALLOWED_RESOURCES.includes(request.type)) {
+          return log.debug(`- Skipping disallowed resource type [${request.type}]`, meta);
+        }
+
+        resource = (0, _utils.createResource)(url, body, response.mimeType, {
+          status: response.status,
+          // 'Network.responseReceived' returns headers split by newlines, however
+          // `Fetch.fulfillRequest` (used for cached responses) will hang with newlines.
+          headers: Object.entries(response.headers).reduce((norm, [key, value]) => Object.assign(norm, {
+            [key]: value.split('\n')
+          }), {})
+        });
+        log.debug(`- sha: ${resource.sha}`, meta);
+        log.debug(`- mimetype: ${resource.mimetype}`, meta);
+      }
+
+      saveResource(resource);
+    } catch (error) {
+      log.debug(`Encountered an error processing resource: ${url}`, meta);
+      log.debug(error);
+    }
+  };
+}
+
+function createRequestFailedHandler(network) {
+  let log = (0, _logger.default)('core:discovery');
+  return ({
+    url,
+    error
+  }) => {
+    // do not log generic failures since the real error was most likely
+    // already logged from elsewhere
+    if (error !== 'net::ERR_FAILED') {
+      log.debug(`Request failed for ${url}: ${error}`, { ...network.meta,
+        url
+      });
+    }
+  };
+}

package/dist/index.js

@@ -1,29 +1,15 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _exportNames = {};
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function () {
-    return _percy.default;
-  }
-});
+const PercyConfig = require('@percy/config');
 
-var _percy = _interopRequireDefault(require("./percy"));
+const CoreConfig = require('./config');
 
-var _resources = require("./utils/resources");
+const {
+  Percy
+} = require('./percy');
 
-Object.keys(_resources).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _resources[key];
-    }
-  });
-});
+PercyConfig.addSchema(CoreConfig.schemas);
+PercyConfig.addMigration(CoreConfig.migrations); // export the Percy class with commonjs compatibility
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+module.exports = Percy;
+module.exports.Percy = Percy;