@parcel/core/lib/RequestTracker.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.generateRequestId = generateRequestId;
exports.RequestRunner = exports.default = exports.RequestGraph = void 0;

var _assert = _interopRequireDefault(require("assert"));

var _nullthrows = _interopRequireDefault(require("nullthrows"));

var _utils = require("@parcel/utils");

var _Graph = _interopRequireDefault(require("./Graph"));

var _utils2 = require("./utils");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

const nodeFromFilePath = filePath => ({
  id: filePath,
  type: 'file',
  value: {
    filePath
  }
});

const nodeFromGlob = glob => ({
  id: glob,
  type: 'glob',
  value: glob
});

const nodeFromRequest = request => ({
  id: request.id,
  type: 'request',
  value: request
});

class RequestGraph extends _Graph.default {
  constructor(...args) {
    super(...args);

    _defineProperty(this, "invalidNodeIds", new Set());

    _defineProperty(this, "incompleteNodeIds", new Set());

    _defineProperty(this, "globNodeIds", new Set());

    _defineProperty(this, "unpredicatableNodeIds", new Set());
  }

  // $FlowFixMe
  static deserialize(opts) {
    let deserialized = new RequestGraph(opts);
    deserialized.invalidNodeIds = opts.invalidNodeIds;
    deserialized.incompleteNodeIds = opts.incompleteNodeIds;
    deserialized.globNodeIds = opts.globNodeIds;
    deserialized.unpredicatableNodeIds = opts.unpredicatableNodeIds; // $FlowFixMe

    return deserialized;
  } // $FlowFixMe


  serialize() {
    return _objectSpread({}, super.serialize(), {
      invalidNodeIds: this.invalidNodeIds,
      incompleteNodeIds: this.incompleteNodeIds,
      globNodeIds: this.globNodeIds,
      unpredicatableNodeIds: this.unpredicatableNodeIds
    });
  }

  addNode(node) {
    if (!this.hasNode(node.id)) {
      if (node.type === 'glob') {
        this.globNodeIds.add(node.id);
      }
    }

    return super.addNode(node);
  }

  removeNode(node) {
    this.invalidNodeIds.delete(node.id);
    this.incompleteNodeIds.delete(node.id);

    if (node.type === 'glob') {
      this.globNodeIds.delete(node.id);
    }

    return super.removeNode(node);
  } // TODO: deprecate


  addRequest(request) {
    let requestNode = nodeFromRequest(request);

    if (!this.hasNode(requestNode.id)) {
      this.addNode(requestNode);
    } else {
      requestNode = this.getNode(requestNode.id);
    }

    return requestNode;
  }

  getRequestNode(id) {
    let node = (0, _nullthrows.default)(this.getNode(id));
    (0, _assert.default)(node.type === 'request');
    return node;
  }

  completeRequest(request) {
    this.invalidNodeIds.delete(request.id);
    this.incompleteNodeIds.delete(request.id);
  }

  replaceSubrequests(requestId, subrequestNodes) {
    let requestNode = this.getRequestNode(requestId);

    if (!this.hasNode(requestId)) {
      this.addNode(requestNode);
    }

    for (let subrequestNode of subrequestNodes) {
      this.invalidNodeIds.delete(subrequestNode.id);
    }

    this.replaceNodesConnectedTo(requestNode, subrequestNodes, null, 'subrequest');
  }

  invalidateNode(node) {
    (0, _assert.default)(node.type === 'request');

    if (this.hasNode(node.id)) {
      this.invalidNodeIds.add(node.id);
      this.clearInvalidations(node);
      let parentNodes = this.getNodesConnectedTo(node, 'subrequest');

      for (let parentNode of parentNodes) {
        this.invalidateNode(parentNode);
      }
    }
  }

  invalidateUnpredictableNodes() {
    for (let nodeId of this.unpredicatableNodeIds) {
      let node = (0, _nullthrows.default)(this.getNode(nodeId));
      (0, _assert.default)(node.type !== 'file' && node.type !== 'glob');
      this.invalidateNode(node);
    }
  }

  invalidateOnFileUpdate(requestId, filePath) {
    let requestNode = this.getRequestNode(requestId);
    let fileNode = nodeFromFilePath(filePath);

    if (!this.hasNode(fileNode.id)) {
      this.addNode(fileNode);
    }

    if (!this.hasEdge(requestNode.id, fileNode.id, 'invalidated_by_update')) {
      this.addEdge(requestNode.id, fileNode.id, 'invalidated_by_update');
    }
  }

  invalidateOnFileDelete(requestId, filePath) {
    let requestNode = this.getRequestNode(requestId);
    let fileNode = nodeFromFilePath(filePath);

    if (!this.hasNode(fileNode.id)) {
      this.addNode(fileNode);
    }

    if (!this.hasEdge(requestNode.id, fileNode.id, 'invalidated_by_delete')) {
      this.addEdge(requestNode.id, fileNode.id, 'invalidated_by_delete');
    }
  }

  invalidateOnFileCreate(requestId, glob) {
    let requestNode = this.getRequestNode(requestId);
    let globNode = nodeFromGlob(glob);

    if (!this.hasNode(globNode.id)) {
      this.addNode(globNode);
    }

    if (!this.hasEdge(requestNode.id, globNode.id, 'invalidated_by_create')) {
      this.addEdge(requestNode.id, globNode.id, 'invalidated_by_create');
    }
  }

  invalidateOnStartup(requestId) {
    let requestNode = this.getRequestNode(requestId);
    this.unpredicatableNodeIds.add(requestNode.id);
  }

  clearInvalidations(node) {
    this.unpredicatableNodeIds.delete(node.id);
    this.replaceNodesConnectedTo(node, [], null, 'invalidated_by_update');
    this.replaceNodesConnectedTo(node, [], null, 'invalidated_by_delete');
    this.replaceNodesConnectedTo(node, [], null, 'invalidated_by_create');
  }

  respondToFSEvents(events) {
    let isInvalid = false;

    for (let {
      path,
      type
    } of events) {
      let node = this.getNode(path); // sometimes mac os reports update events as create events
      // if it was a create event, but the file already exists in the graph,
      // then we can assume it was actually an update event

      if (node && (type === 'create' || type === 'update')) {
        for (let connectedNode of this.getNodesConnectedTo(node, 'invalidated_by_update')) {
          this.invalidateNode(connectedNode);
          isInvalid = true;
        }
      } else if (type === 'create') {
        for (let id of this.globNodeIds) {
          let globNode = this.getNode(id);
          (0, _assert.default)(globNode && globNode.type === 'glob');

          if ((0, _utils.isGlobMatch)(path, globNode.value)) {
            let connectedNodes = this.getNodesConnectedTo(globNode, 'invalidated_by_create');

            for (let connectedNode of connectedNodes) {
              this.invalidateNode(connectedNode);
              isInvalid = true;
            }
          }
        }
      } else if (node && type === 'delete') {
        for (let connectedNode of this.getNodesConnectedTo(node, 'invalidated_by_delete')) {
          this.invalidateNode(connectedNode);
          isInvalid = true;
        }
      }
    }

    return isInvalid;
  }

}

exports.RequestGraph = RequestGraph;

class RequestTracker {
  constructor({
    graph
  }) {
    _defineProperty(this, "graph", void 0);

    this.graph = graph || new RequestGraph();
  }

  isTracked(id) {
    return this.graph.hasNode(id);
  }

  getRequest(id) {
    return (0, _nullthrows.default)(this.graph.getNode(id));
  }

  trackRequest(request) {
    if (this.isTracked(request.id)) {
      return;
    }

    this.graph.incompleteNodeIds.add(request.id);
    let node = nodeFromRequest(request);
    this.graph.addNode(node);
  }

  untrackRequest(id) {
    this.graph.removeById(id);
  }

  hasValidResult(id) {
    return !this.graph.invalidNodeIds.has(id) && !this.graph.incompleteNodeIds.has(id);
  }

  getRequestResult(id) {
    let node = (0, _nullthrows.default)(this.graph.getNode(id));
    (0, _assert.default)(node.type === 'request');
    return node.value.result;
  }

  completeRequest(id) {
    this.graph.invalidNodeIds.delete(id);
    this.graph.incompleteNodeIds.delete(id);
  }

  respondToFSEvents(events) {
    return this.graph.respondToFSEvents(events);
  }

  hasInvalidRequests() {
    return this.graph.invalidNodeIds.size > 0;
  }

  getInvalidRequests() {
    let invalidRequests = [];

    for (let id of this.graph.invalidNodeIds) {
      let node = (0, _nullthrows.default)(this.graph.getNode(id));
      (0, _assert.default)(node.type === 'request');
      invalidRequests.push(node.value);
    }

    return invalidRequests;
  }

  replaceSubrequests(requestId, subrequestNodes) {
    this.graph.replaceSubrequests(requestId, subrequestNodes);
  }

}

exports.default = RequestTracker;

function generateRequestId(type, request) {
  return (0, _utils.md5FromObject)({
    type,
    request
  });
}

class RequestRunner {
  constructor({
    tracker
  }) {
    _defineProperty(this, "type", void 0);

    _defineProperty(this, "tracker", void 0);

    this.tracker = tracker;
  }

  async runRequest(requestDesc, {
    signal
  } = {}) {
    let id = this.generateRequestId(requestDesc);
    let request = {
      id,
      type: this.type,
      request: requestDesc
    };
    let api = this.createAPI(id);
    this.tracker.trackRequest(request);
    let result = this.tracker.hasValidResult(id) ? // $FlowFixMe
    this.tracker.getRequestResult(id) : await this.run(requestDesc, api);
    (0, _utils2.assertSignalNotAborted)(signal); // Request may have been removed by a parent request

    if (!this.tracker.isTracked(id)) {
      return;
    }

    await this.onComplete(requestDesc, result, api);
    this.tracker.completeRequest(id);
    return result;
  } // unused vars are used for types
  // eslint-disable-next-line no-unused-vars


  run(request, api) {
    throw new Error(`RequestRunner for type ${this.type} did not implement run()`);
  } // unused vars are used for types
  // eslint-disable-next-line no-unused-vars


  onComplete(request, result, api) {
    throw new Error(`RequestRunner for type ${this.type} did not implement onComplete()`);
  }

  generateRequestId(request) {
    return (0, _utils.md5FromObject)({
      type: this.type,
      request
    });
  }

  createAPI(requestId) {
    return {
      invalidateOnFileCreate: glob => this.tracker.graph.invalidateOnFileCreate(requestId, glob),
      invalidateOnFileDelete: filePath => this.tracker.graph.invalidateOnFileDelete(requestId, filePath),
      invalidateOnFileUpdate: filePath => this.tracker.graph.invalidateOnFileUpdate(requestId, filePath),
      invalidateOnStartup: () => this.tracker.graph.invalidateOnStartup(requestId),
      replaceSubrequests: subrequestNodes => this.tracker.graph.replaceSubrequests(requestId, subrequestNodes)
    };
  }

}

exports.RequestRunner = RequestRunner;