@percy/core 1.27.7 → 1.28.0-beta.0

package/dist/api.js

@@ -5,6 +5,7 @@ import logger from '@percy/logger';
 import { normalize } from '@percy/config/utils';
 import { getPackageJSON, Server, percyAutomateRequestHandler, percyBuildEventHandler } from './utils.js';
 import WebdriverUtils from '@percy/webdriver-utils';
+import { handleSyncJob } from './snapshot.js';
 // need require.resolve until import.meta.resolve can be transpiled
 export const PERCY_DOM = createRequire(import.meta.url).resolve('@percy/dom');
 
@@ -99,16 +100,29 @@ export function createPercyServer(percy, port) {
   })
   // post one or more snapshots, optionally async
   .route('post', '/percy/snapshot', async (req, res) => {
-    let snapshot = percy.snapshot(req.body);
+    let data;
+    const snapshotPromise = {};
+    const snapshot = percy.snapshot(req.body, snapshotPromise);
     if (!req.url.searchParams.has('async')) await snapshot;
+    if (percy.syncMode(req.body)) data = await handleSyncJob(snapshotPromise[req.body.name], percy, 'snapshot');
     return res.json(200, {
-      success: true
+      success: true,
+      data: data
     });
   })
   // post one or more comparisons, optionally waiting
   .route('post', '/percy/comparison', async (req, res) => {
-    let upload = percy.upload(req.body);
-    if (req.url.searchParams.has('await')) await upload;
+    let data;
+    if (percy.syncMode(req.body)) {
+      const snapshotPromise = new Promise((resolve, reject) => percy.upload(req.body, {
+        resolve,
+        reject
+      }));
+      data = await handleSyncJob(snapshotPromise, percy, 'comparison');
+    } else {
+      let upload = percy.upload(req.body);
+      if (req.url.searchParams.has('await')) await upload;
+    }
 
     // generate and include one or more redirect links to comparisons
     let link = ({
@@ -126,22 +140,38 @@ export function createPercyServer(percy, port) {
         snake: true
       }))].join('');
     };
-    return res.json(200, Object.assign({
-      success: true
-    }, req.body ? Array.isArray(req.body) ? {
-      links: req.body.map(link)
-    } : {
-      link: link(req.body)
-    } : {}));
+    const response = {
+      success: true,
+      data: data
+    };
+    if (req.body) {
+      if (Array.isArray(req.body)) {
+        response.links = req.body.map(link);
+      } else {
+        response.link = link(req.body);
+      }
+    }
+    return res.json(200, response);
   })
   // flushes one or more snapshots from the internal queue
   .route('post', '/percy/flush', async (req, res) => res.json(200, {
     success: await percy.flush(req.body).then(() => true)
   })).route('post', '/percy/automateScreenshot', async (req, res) => {
+    let data;
     percyAutomateRequestHandler(req, percy);
-    percy.upload(await WebdriverUtils.automateScreenshot(req.body));
+    let comparisonData = await WebdriverUtils.automateScreenshot(req.body);
+    if (percy.syncMode(comparisonData)) {
+      const snapshotPromise = new Promise((resolve, reject) => percy.upload(comparisonData, {
+        resolve,
+        reject
+      }));
+      data = await handleSyncJob(snapshotPromise, percy, 'comparison');
+    } else {
+      percy.upload(comparisonData);
+    }
     res.json(200, {
-      success: true
+      success: true,
+      data: data
     });
   })
   // Recieves events from sdk's.

package/dist/config.js

@@ -68,6 +68,9 @@ export const configSchema = {
           }
         }
       },
+      sync: {
+        type: 'boolean'
+      },
       fullPage: {
         type: 'boolean',
         onlyAutomate: true
@@ -306,6 +309,9 @@ export const snapshotSchema = {
         enableLayout: {
           $ref: '/config/snapshot#/properties/enableLayout'
         },
+        sync: {
+          $ref: '/config/snapshot#/properties/sync'
+        },
         reshuffleInvalidTags: {
           $ref: '/config/snapshot#/properties/reshuffleInvalidTags'
         },
@@ -704,6 +710,9 @@ export const comparisonSchema = {
     domInfoSha: {
       type: 'string'
     },
+    sync: {
+      type: 'boolean'
+    },
     metadata: {
       type: 'object',
       additionalProperties: false,

package/dist/percy.js

@@ -6,6 +6,7 @@ import { createPercyServer, createStaticServer } from './api.js';
 import { gatherSnapshots, createSnapshotsQueue, validateSnapshotOptions } from './snapshot.js';
 import { discoverSnapshotResources, createDiscoveryQueue } from './discovery.js';
 import { generatePromise, yieldAll, yieldTo } from './utils.js';
+import { WaitForJob } from './wait-for-job.js';
 
 // A Percy instance will create a new build when started, handle snapshot creation, asset discovery,
 // and resource uploads, and will finalize the build when stopped. Snapshots are processed
@@ -150,6 +151,8 @@ export class Percy {
       if (!this.skipDiscovery) yield this.#discovery.start();
       // start a local API server for SDK communication
       if (this.server) yield this.server.listen();
+      const snapshotType = this.client.tokenType() === 'web' ? 'snapshot' : 'comparison';
+      this.syncQueue = new WaitForJob(snapshotType, this);
       // log and mark this instance as started
       this.log.info('Percy has started!');
       this.readyState = 1;
@@ -206,7 +209,7 @@ export class Percy {
     if (!this.readyState && this.browser.isConnected()) {
       await this.browser.close();
     }
-
+    if (this.syncQueue) this.syncQueue.stop();
     // not started or already stopped
     if (!this.readyState || this.readyState > 2) return;
 
@@ -254,14 +257,14 @@ export class Percy {
   // Takes one or more snapshots of a page while discovering resources to upload with the resulting
   // snapshots. Once asset discovery has completed for the provided snapshots, the queued task will
   // resolve and an upload task will be queued separately.
-  snapshot(options) {
+  snapshot(options, snapshotPromise = {}) {
     var _this$build;
     if (this.readyState !== 1) {
       throw new Error('Not running');
     } else if ((_this$build = this.build) !== null && _this$build !== void 0 && _this$build.error) {
       throw new Error(this.build.error);
     } else if (Array.isArray(options)) {
-      return yieldAll(options.map(o => this.yield.snapshot(o)));
+      return yieldAll(options.map(o => this.yield.snapshot(o, snapshotPromise)));
     }
 
     // accept a url for a sitemap or snapshot
@@ -309,6 +312,15 @@ export class Percy {
             config: this.config
           })
         }, snapshot => {
+          // attaching promise resolve reject so to wait for snapshot to complete
+          if (this.syncMode(snapshot)) {
+            snapshotPromise[snapshot.name] = new Promise((resolve, reject) => {
+              Object.assign(snapshot, {
+                resolve,
+                reject
+              });
+            });
+          }
           // push each finished snapshot to the snapshots queue
           this.#snapshots.push(snapshot);
         });
@@ -321,7 +333,7 @@ export class Percy {
   }
 
   // Uploads one or more snapshots directly to the current Percy build
-  upload(options) {
+  upload(options, callback = null) {
     if (this.readyState !== 1) {
       throw new Error('Not running');
     } else if (Array.isArray(options)) {
@@ -353,6 +365,13 @@ export class Percy {
     this.client.addClientInfo(options.clientInfo);
     this.client.addEnvironmentInfo(options.environmentInfo);
 
+    // Sync CLI support, attached resolve, reject promise
+    if (this.syncMode(options)) {
+      Object.assign(options, {
+        ...callback
+      });
+    }
+
     // return an async generator to allow cancelation
     return async function* () {
       try {
@@ -369,5 +388,26 @@ export class Percy {
     }
     return tokenType !== 'web';
   }
+  syncMode(options) {
+    var _this$config, _this$config$snapshot;
+    let syncMode = false;
+    if ((_this$config = this.config) !== null && _this$config !== void 0 && (_this$config$snapshot = _this$config.snapshot) !== null && _this$config$snapshot !== void 0 && _this$config$snapshot.sync) syncMode = true;
+    if (options !== null && options !== void 0 && options.sync) syncMode = true;
+    if ((options === null || options === void 0 ? void 0 : options.sync) === false) syncMode = false;
+    if ((this.skipUploads || this.deferUploads || this.delayUploads) && syncMode) {
+      syncMode = false;
+      options.sync = false;
+      if (this.delayUploads && !this.skipUploads) {
+        this.log.warn('Synchronous CLI functionality is not compatible with the snapshot command. Kindly consider taking screenshots via SDKs to achieve synchronous results instead.');
+      } else {
+        let type = 'deferUploads option';
+        if (this.skipDiscovery && this.deferUploads) type = 'upload command';
+        if (this.skipUploads) type = 'skipUploads option';
+        this.log.warn(`The Synchronous CLI functionality is not compatible with ${type}.`);
+      }
+    }
+    if (syncMode) options.sync = syncMode;
+    return syncMode;
+  }
 }
 export default Percy;

package/dist/snapshot.js

@@ -4,6 +4,7 @@ import micromatch from 'micromatch';
 import { configSchema } from './config.js';
 import Queue from './queue.js';
 import { request, hostnameMatches, yieldTo } from './utils.js';
+import { JobData } from './wait-for-job.js';
 
 // Throw a better error message for missing or invalid urls
 function validURL(url, base) {
@@ -219,6 +220,22 @@ export function validateSnapshotOptions(options) {
     ...migrated
   };
 }
+export async function handleSyncJob(jobPromise, percy, type) {
+  let data;
+  try {
+    const id = await jobPromise;
+    if (type === 'snapshot') {
+      data = await percy.client.getSnapshotDetails(id);
+    } else {
+      data = await percy.client.getComparisonDetails(id);
+    }
+  } catch (e) {
+    data = {
+      error: e.message
+    };
+  }
+  return data;
+}
 
 // Fetches a sitemap and parses it into a list of URLs for taking snapshots. Duplicate URLs,
 // including a trailing slash, are removed from the resulting list.
@@ -411,6 +428,14 @@ export function createSnapshotsQueue(percy) {
     let send = 'tag' in snapshot ? 'sendComparison' : 'sendSnapshot';
     let response = yield percy.client[send](build.id, snapshot);
     if (percy.deferUploads) percy.log.info(`Snapshot uploaded: ${name}`, meta);
+
+    // Pushing to syncQueue, that will check for
+    // snapshot processing status, and will resolve once done
+    if (snapshot.sync) {
+      percy.log.info(`Waiting for snapshot '${name}' to be completed`);
+      const data = new JobData(response.data.id, null, snapshot.resolve, snapshot.reject);
+      percy.syncQueue.push(data);
+    }
     return {
       ...snapshot,
       response
@@ -448,6 +473,7 @@ export function createSnapshotsQueue(percy) {
     }
     percy.log.error(`Encountered an error uploading snapshot: ${name}`, meta);
     percy.log.error(error, meta);
+    if (snapshot.sync) snapshot.reject(error);
     return result;
   });
 }

package/dist/utils.js

@@ -46,6 +46,7 @@ export function percyAutomateRequestHandler(req, percy) {
     ignoreRegionXpaths: (_percy$config$snapsho4 = percy.config.snapshot.ignoreRegions) === null || _percy$config$snapsho4 === void 0 ? void 0 : _percy$config$snapsho4.ignoreRegionXpaths,
     considerRegionSelectors: (_percy$config$snapsho5 = percy.config.snapshot.considerRegions) === null || _percy$config$snapsho5 === void 0 ? void 0 : _percy$config$snapsho5.considerRegionSelectors,
     considerRegionXpaths: (_percy$config$snapsho6 = percy.config.snapshot.considerRegions) === null || _percy$config$snapsho6 === void 0 ? void 0 : _percy$config$snapsho6.considerRegionXpaths,
+    sync: percy.config.snapshot.sync,
     version: 'v2'
   }, camelCasedOptions], (path, prev, next) => {
     switch (path.map(k => k.toString()).join('.')) {

package/dist/wait-for-job.js

@@ -0,0 +1,97 @@
+import logger from '@percy/logger';
+const MIN_POLLING_INTERVAL = 5_000;
+// Poll atleast once in 2 min
+const MAX_POLLING_INTERVAL_SECONDS = 120;
+const THRESHOLD_OPTIMAL_POLL_TIME = 5;
+const JOB_TIMEOUT = Number(process.env.SYNC_TIMEOUT) || 90_000;
+
+// Job is either for snapshot or comparison only
+export class WaitForJob {
+  log = logger('core:wait-for-job');
+  constructor(type, percy) {
+    this.percy = percy;
+    this.jobs = [];
+    if (type !== 'comparison' && type !== 'snapshot') throw new Error('Type should be either comparison or snapshot');
+    this.type = type;
+    this.timer = null;
+    this.exit = false;
+    this.running = false;
+  }
+  push(job) {
+    if (!(job instanceof JobData)) throw new Error('Invalid job passed, use JobData');
+    if (this.type === 'snapshot') job.timeout += 420_000; // For snapshot timeout after 08:30 min
+
+    this.jobs.push(job);
+    if (!this.running) this.run();
+  }
+  run(interval = MIN_POLLING_INTERVAL) {
+    if (this.exit) return;
+    this.running = true;
+    if (interval < MIN_POLLING_INTERVAL) {
+      interval = MIN_POLLING_INTERVAL;
+    }
+    this.log.debug(`Polling for ${this.type} status in ${interval}ms`);
+    this.timer = setTimeout(async () => {
+      let nextPoll = MAX_POLLING_INTERVAL_SECONDS;
+      const jobIds = this.jobs.map(job => job.id);
+      const response = await this.percy.client.getStatus(this.type, jobIds);
+      this.jobs = this.jobs.filter(job => {
+        if (response[job.id]) {
+          const jobStatus = response[job.id];
+          if (jobStatus.status) {
+            job.resolve(job.id);
+            return false;
+          } else if (jobStatus.error != null) {
+            job.reject(jobStatus.error);
+            return false;
+          } else if (Date.now() - job.timeout >= 0) {
+            job.reject(new Error(`Timeout waiting for ${this.type} with id ${job.id}`));
+            return false;
+          } else {
+            job.nextPoll = jobStatus.next_poll;
+          }
+        }
+        nextPoll = Math.min(nextPoll, job.nextPoll);
+        return true;
+      });
+      if (this.jobs.length === 0) {
+        this.running = false;
+        return;
+      }
+      const optimalNextPollTime = this.getOptimalPollTime(nextPoll);
+      this.run(optimalNextPollTime * 1000);
+    }, interval);
+  }
+
+  // If there are other snapshots which can be completed in next
+  // 5 seconds, calling after x seconds will reduce network call
+  getOptimalPollTime(lowestPollTime) {
+    let pollTime = lowestPollTime;
+    this.jobs.forEach(job => {
+      const jobPollTime = job.nextPoll;
+      if (jobPollTime - lowestPollTime <= THRESHOLD_OPTIMAL_POLL_TIME) {
+        pollTime = Math.max(pollTime, jobPollTime);
+      }
+    });
+    return pollTime;
+  }
+  stop() {
+    this.exit = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.jobs.forEach(job => {
+      job.reject(new Error('Unable to process synchronous results as the CLI was exited while awaiting completion of the snapshot.'));
+    });
+  }
+}
+export class JobData {
+  constructor(id, nextPoll, resolve, reject) {
+    this.id = id;
+    this.nextPoll = nextPoll || 60;
+    this.timeout = Date.now() + JOB_TIMEOUT;
+    this.resolve = resolve;
+    this.reject = reject;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@percy/core",
-  "version": "1.27.7",
+  "version": "1.28.0-beta.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -9,7 +9,7 @@
   },
   "publishConfig": {
     "access": "public",
-    "tag": "latest"
+    "tag": "beta"
   },
   "engines": {
     "node": ">=14"
@@ -43,11 +43,11 @@
     "test:types": "tsd"
   },
   "dependencies": {
-    "@percy/client": "1.27.7",
-    "@percy/config": "1.27.7",
-    "@percy/dom": "1.27.7",
-    "@percy/logger": "1.27.7",
-    "@percy/webdriver-utils": "1.27.7",
+    "@percy/client": "1.28.0-beta.0",
+    "@percy/config": "1.28.0-beta.0",
+    "@percy/dom": "1.28.0-beta.0",
+    "@percy/logger": "1.28.0-beta.0",
+    "@percy/webdriver-utils": "1.28.0-beta.0",
     "content-disposition": "^0.5.4",
     "cross-spawn": "^7.0.3",
     "extract-zip": "^2.0.1",
@@ -58,5 +58,5 @@
     "rimraf": "^3.0.2",
     "ws": "^8.0.0"
   },
-  "gitHead": "eba048142b27b317491f15364b34764371fc0670"
+  "gitHead": "d188893f1b45f6e4a1b3196b326a47174340c6ce"
 }