graphql-paper/es/events/dispatch.mjs

A flexible in-memory store based on a GraphQL Schema

import { allDocuments } from '../store/all-documents.mjs';
import { findDocument } from '../store/find-document.mjs';
import { getDocumentKey } from '../document/get-document-key.mjs';
import { CreateEvent } from './create.mjs';
import { RemoveEvent } from './remove.mjs';
import { diff } from 'just-diff';
import { ModifyEvent } from './modify-document.mjs';
function extractChanges(current, previous) {
  var currentKeys = allDocuments(current).map(document => getDocumentKey(document));
  var previousKeys = allDocuments(previous).map(document => getDocumentKey(document));
  var created = currentKeys.filter(key => !previousKeys.includes(key));
  var removed = previousKeys.filter(key => !currentKeys.includes(key));
  var existing = currentKeys.filter(key => !created.includes(key));
  var modifiedDocuments = existing
  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
  .map(key => ({
    current: findDocument(current, key),
    previous: findDocument(previous, key)
  })).map(_ref => {
    var {
      current,
      previous
    } = _ref;
    var differences = diff(current, previous);
    var changes = differences.reduce((documentChange, _ref2) => {
      var {
        path
      } = _ref2;
      var [property] = path;
      documentChange[property] = {
        propertyName: property.toString(),
        value: current[property],
        previousValue: previous[property]
      };
      return documentChange;
    }, {});
    var hasChanges = Object.keys(changes).length > 0;
    return hasChanges ? {
      document: current,
      changes
    } : undefined;
  }).filter(Boolean);
  var createdDocuments = created.map(key => ({
    document: findDocument(current, key)
  }));
  var removedDocuments = removed.map(key => ({
    document: findDocument(previous, key)
  }));
  return {
    createdDocuments: createdDocuments,
    removedDocuments,
    modifiedDocuments
  };
}
// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
function createStoreEvents(previous, store) {
  var {
    createdDocuments,
    removedDocuments,
    modifiedDocuments
  } = extractChanges(store, previous);
  var createdEvents = createdDocuments.map(_ref3 => {
    var {
      document
    } = _ref3;
    return new CreateEvent({
      document,
      store
    });
  });
  var modifiedEvents = modifiedDocuments.map(_ref4 => {
    var {
      changes,
      document
    } = _ref4;
    return new ModifyEvent({
      document,
      store,
      changes
    });
  });
  var removedEvents = removedDocuments.map(_ref5 => {
    var {
      document
    } = _ref5;
    return new RemoveEvent({
      document,
      store
    });
  });
  return [...createdEvents, ...modifiedEvents, ...removedEvents];
}
export { createStoreEvents };
//# sourceMappingURL=dispatch.mjs.map