cht-conf 4.1.2 → 4.2.0

package/src/lib/hierarchy-operations/index.js

@@ -0,0 +1,186 @@
+const lineageManipulation = require('./lineage-manipulation');
+const LineageConstraints = require('./lineage-constraints');
+const { trace, info } = require('../log');
+
+const JsDocs = require('./jsdocFolder');
+const DataSource = require('./hierarchy-data-source');
+
+async function moveHierarchy(db, options, sourceIds, destinationId) {
+  JsDocs.prepareFolder(options);
+  trace(`Fetching contact details: ${destinationId}`);
+  const constraints = await LineageConstraints(db, options);
+  const destinationDoc = await DataSource.getContact(db, destinationId);
+  const sourceDocs = await DataSource.getContactsByIds(db, sourceIds);
+  constraints.assertNoHierarchyErrors(Object.values(sourceDocs), destinationDoc);
+
+  let affectedContactCount = 0;
+  let affectedReportCount = 0;
+  const replacementLineage = lineageManipulation.createLineageFromDoc(destinationDoc);
+  for (const sourceId of sourceIds) {
+    const sourceDoc = sourceDocs[sourceId];
+    const descendantsAndSelf = await DataSource.getContactWithDescendants(db, sourceId);
+    const moveContext = {
+      sourceId,
+      destinationId,
+      descendantsAndSelf,
+      replacementLineage,
+      merge: !!options.merge,
+    };
+
+    await constraints.assertNoPrimaryContactViolations(sourceDoc, destinationDoc, descendantsAndSelf);
+    
+    if (options.merge) {
+      JsDocs.writeDoc(options, {
+        _id: sourceDoc._id,
+        _rev: sourceDoc._rev,
+        _deleted: true,
+      });
+    }
+        
+    const prettyPrintDocument = doc => `'${doc.name}' (${doc._id})`;
+    trace(`Considering lineage updates to ${descendantsAndSelf.length} descendant(s) of contact ${prettyPrintDocument(sourceDoc)}.`);
+    const updatedDescendants = replaceLineageInContacts(moveContext);
+    
+    const ancestors = await DataSource.getAncestorsOf(db, sourceDoc);
+    trace(`Considering primary contact updates to ${ancestors.length} ancestor(s) of contact ${prettyPrintDocument(sourceDoc)}.`);
+    const updatedAncestors = replaceLineageInAncestors(descendantsAndSelf, ancestors);
+    
+    minifyLineageAndWriteToDisk(options, [...updatedDescendants, ...updatedAncestors]);
+    
+    const movedReportsCount = await updateReports(db, options, moveContext);
+    trace(`${movedReportsCount} report(s) created by these affected contact(s) will be updated`);
+
+    affectedContactCount += updatedDescendants.length + updatedAncestors.length;
+    affectedReportCount += movedReportsCount;
+
+    info(`Staged updates to ${prettyPrintDocument(sourceDoc)}. ${updatedDescendants.length} contact(s) and ${movedReportsCount} report(s).`);
+  }
+
+  info(`Staged changes to lineage information for ${affectedContactCount} contact(s) and ${affectedReportCount} report(s).`);
+}
+
+async function updateReports(db, options, moveContext) {
+  const descendantIds = moveContext.descendantsAndSelf.map(contact => contact._id);
+
+  let skip = 0;
+  let reportDocsBatch;
+  do {
+    info(`Processing ${skip} to ${skip + DataSource.BATCH_SIZE} report docs`);
+    const createdAtId = options.merge && moveContext.sourceId;
+    reportDocsBatch = await DataSource.getReportsForContacts(db, descendantIds, createdAtId, skip);
+
+    const lineageUpdates = replaceLineageOfReportCreator(reportDocsBatch, moveContext);
+    const reassignUpdates = reassignReports(reportDocsBatch, moveContext);
+    const updatedReports = reportDocsBatch.filter(doc => lineageUpdates.has(doc._id) || reassignUpdates.has(doc._id));
+
+    minifyLineageAndWriteToDisk(options, updatedReports);
+
+    skip += reportDocsBatch.length;
+  } while (reportDocsBatch.length >= DataSource.BATCH_SIZE);
+
+  return skip;
+}
+
+function reassignReportSubjects(report, { sourceId, destinationId }) {
+  const SUBJECT_IDS = ['patient_id', 'patient_uuid', 'place_id', 'place_uuid'];
+  let updated = false;
+  for (const subjectId of SUBJECT_IDS) {
+    if (report[subjectId] === sourceId) {
+      report[subjectId] = destinationId;
+      updated = true;
+    }
+
+    if (report.fields[subjectId] === sourceId) {
+      report.fields[subjectId] = destinationId;
+      updated = true;
+    }
+  }
+  
+  return updated;
+}
+
+function reassignReports(reports, moveContext) {
+  const updated = new Set();
+  if (!moveContext.merge) {
+    return updated;
+  }
+
+  for (const report of reports) {
+    const isUpdated = reassignReportSubjects(report, moveContext);
+    if (isUpdated) {
+      updated.add(report._id);
+    }
+  }
+
+  return updated;
+}
+
+// This ensures all documents written are fully minified. Some docs in CouchDB are not minified to start with.
+function minifyLineageAndWriteToDisk(options, docs) {
+  docs.forEach(doc => {
+    lineageManipulation.minifyLineagesInDoc(doc);
+    JsDocs.writeDoc(options, doc);
+  });
+}
+
+function replaceLineageOfReportCreator(reports, moveContext) {
+  const replaceContactLineage = doc => lineageManipulation.replaceContactLineage(doc, {
+    replaceWith: moveContext.replacementLineage,
+    startingFromId: moveContext.sourceId,
+    merge: moveContext.merge,
+  });
+    
+  const updatedReportIds = reports
+    .filter(replaceContactLineage)
+    .map(({ _id }) => _id);
+  return new Set(updatedReportIds);
+}
+
+function replaceLineageInAncestors(descendantsAndSelf, ancestors) {
+  const updatedAncestors = [];
+  for (const ancestor of ancestors) {
+    const primaryContact = descendantsAndSelf.find(descendant => descendant._id === ancestor.contact?._id);
+    if (primaryContact) {
+      ancestor.contact = lineageManipulation.createLineageFromDoc(primaryContact);
+      updatedAncestors.unshift(ancestor);
+    }
+  }
+
+  return updatedAncestors;
+}
+
+function replaceLineageInSingleContact(doc, moveContext) {
+  const docIsSource = doc._id === moveContext.sourceId;
+  if (docIsSource && moveContext.merge) {
+    return;
+  }
+
+  const startingFromId = moveContext.merge || !docIsSource ? moveContext.sourceId : undefined;
+  const replaceLineageOptions = {
+    replaceWith: moveContext.replacementLineage,
+    startingFromId,
+    merge: moveContext.merge,
+  };
+  const parentWasUpdated = lineageManipulation.replaceParentLineage(doc, replaceLineageOptions);
+
+  replaceLineageOptions.startingFromId = moveContext.sourceId;
+  const contactWasUpdated = lineageManipulation.replaceContactLineage(doc, replaceLineageOptions);
+  if (parentWasUpdated || contactWasUpdated) {
+    return doc;
+  }
+}
+
+function replaceLineageInContacts(moveContext) {
+  return moveContext.descendantsAndSelf
+    .map(descendant => replaceLineageInSingleContact(descendant, moveContext))
+    .filter(Boolean);
+}
+
+module.exports = (db, options) => {
+  return {
+    HIERARCHY_ROOT: DataSource.HIERARCHY_ROOT,
+    move: (sourceIds, destinationId) => moveHierarchy(db, { ...options, merge: false }, sourceIds, destinationId),
+    merge: (sourceIds, destinationId) => moveHierarchy(db, { ...options, merge: true }, sourceIds, destinationId),
+  };
+};
+

package/src/lib/hierarchy-operations/jsdocFolder.js

@@ -0,0 +1,37 @@
+const path = require('path');
+const userPrompt = require('../user-prompt');
+const fs = require('../sync-fs');
+const { warn, trace } = require('../log');
+
+function prepareFolder({ docDirectoryPath, force }) {
+  if (!fs.exists(docDirectoryPath)) {
+    fs.mkdir(docDirectoryPath);
+  } else if (!force && fs.recurseFiles(docDirectoryPath).length > 0) {
+    deleteAfterConfirmation(docDirectoryPath);
+  }
+}
+
+function writeDoc({ docDirectoryPath }, doc) {
+  const destinationPath = path.join(docDirectoryPath, `${doc._id}.doc.json`);
+  if (fs.exists(destinationPath)) {
+    warn(`File at ${destinationPath} already exists and is being overwritten.`);
+  }
+
+  trace(`Writing updated document to ${destinationPath}`);
+  fs.writeJson(destinationPath, doc);
+}
+
+function deleteAfterConfirmation(docDirectoryPath) {
+  warn(`The document folder '${docDirectoryPath}' already contains files. It is recommended you start with a clean folder. Do you want to delete the contents of this folder and continue?`);
+  if (!userPrompt.keyInYN()) {
+    throw new Error('User aborted execution.');
+  }
+  
+  fs.deleteFilesInFolder(docDirectoryPath);
+}
+
+module.exports = {
+  prepareFolder,
+  writeDoc,
+};
+

package/src/lib/hierarchy-operations/lineage-constraints.js

@@ -0,0 +1,170 @@
+const log = require('../log');
+const { HIERARCHY_ROOT } = require('./hierarchy-data-source');
+const { trace } = log;
+
+const lineageManipulation = require('./lineage-manipulation');
+
+module.exports = async (db, options) => {
+  const mapTypeToAllowedParents = await fetchAllowedParents(db);
+
+  return {
+    assertNoPrimaryContactViolations: async (sourceDoc, destinationDoc, descendantDocs) => {
+      const invalidPrimaryContactDoc = await getPrimaryContactViolations(db, sourceDoc, destinationDoc, descendantDocs);
+      if (invalidPrimaryContactDoc) {
+        throw Error(`Cannot remove contact '${invalidPrimaryContactDoc?.name}' (${invalidPrimaryContactDoc?._id}) from the hierarchy for which they are a primary contact.`);
+      }
+    },
+    assertNoHierarchyErrors: (sourceDocs, destinationDoc) => {
+
+      sourceDocs.forEach(sourceDoc => {
+        const commonViolations = getCommonViolations(sourceDoc, destinationDoc);
+        const specificViolation = options.merge ?
+          getMergeViolations(sourceDoc, destinationDoc)
+          : getMovingViolations(mapTypeToAllowedParents, sourceDoc, destinationDoc);
+
+        const hierarchyError = commonViolations || specificViolation;
+        if (hierarchyError) {
+          throw Error(`Hierarchy Constraints: ${hierarchyError}`);
+        }
+      });
+  
+      /*
+      It is nice that the tool can move lists of contacts as one operation, but strange things happen when two contactIds are in the same lineage.
+      For example, moving a district_hospital and moving a contact under that district_hospital to a new clinic causes multiple colliding writes to the same json file.
+      */
+      const contactIds = sourceDocs.map(doc => doc._id);
+      sourceDocs
+        .forEach(doc => {
+          const parentIdsOfDoc = lineageManipulation.pluckIdsFromLineage(doc.parent);
+          const violatingParentId = parentIdsOfDoc.find(parentId => contactIds.includes(parentId));
+          if (violatingParentId) {
+            throw Error(`Unable to move two documents from the same lineage: '${doc._id}' and '${violatingParentId}'`);
+          }
+        });
+    }    
+  };
+};
+
+/*
+Enforce the list of allowed parents for each contact type
+Ensure we are not creating a circular hierarchy
+*/
+const getMovingViolations = (mapTypeToAllowedParents, sourceDoc, destinationDoc) => {
+  const contactTypeError = getMovingContactTypeError(mapTypeToAllowedParents, sourceDoc, destinationDoc);
+  const circularHierarchyError = findCircularHierarchyErrors(sourceDoc, destinationDoc);
+  return contactTypeError || circularHierarchyError;
+};
+
+function getMovingContactTypeError(mapTypeToAllowedParents, sourceDoc, destinationDoc) {
+  const sourceContactType = getContactType(sourceDoc);
+  const destinationType = getContactType(destinationDoc);
+  const rulesForContact = mapTypeToAllowedParents[sourceContactType];
+  if (!rulesForContact) {
+    return `cannot move contact with unknown type '${sourceContactType}'`;
+  }
+
+  const isPermittedMoveToRoot = !destinationDoc && rulesForContact.length === 0;
+  if (!isPermittedMoveToRoot && !rulesForContact.includes(destinationType)) {
+    return `contacts of type '${sourceContactType}' cannot have parent of type '${destinationType}'`;
+  }
+}
+
+function findCircularHierarchyErrors(sourceDoc, destinationDoc) {
+  if (!destinationDoc) {
+    return;
+  }
+
+  const parentAncestry = lineageManipulation.pluckIdsFromLineage(destinationDoc);
+  if (parentAncestry.includes(sourceDoc._id)) {
+    return `Circular hierarchy: Cannot set parent of contact '${sourceDoc._id}' as it would create a circular hierarchy.`;
+  }
+}
+
+const getCommonViolations = (sourceDoc, destinationDoc) => {
+  if (!sourceDoc) {
+    return `source doc cannot be found`;
+  }
+
+  const sourceContactType = getContactType(sourceDoc);
+  const destinationContactType = getContactType(destinationDoc);
+  if (!sourceContactType) {
+    return `source contact "${sourceDoc._id}" required attribute "type" is undefined`;
+  }
+
+  if (destinationDoc && !destinationContactType) {
+    return `destination contact "${destinationDoc._id}" required attribute "type" is undefined`;
+  }
+
+  if (sourceDoc._id === destinationDoc?._id) {
+    return `cannot move or merge contact that is itself`;
+  }
+};
+
+const getMergeViolations = (sourceDoc, destinationDoc) => {
+  if (!destinationDoc) {
+    return `destination doc cannot be found`;
+  }
+
+  if ([sourceDoc._id, destinationDoc._id].includes(HIERARCHY_ROOT)) {
+    return `cannot merge using id: "${HIERARCHY_ROOT}"`;
+  }
+
+  const sourceContactType = getContactType(sourceDoc);
+  const destinationContactType = getContactType(destinationDoc);
+  if (sourceContactType !== destinationContactType) {
+    return `source and destinations must have the same type. Source is "${sourceContactType}" while destination is "${destinationContactType}".`;
+  }
+};
+
+/*
+A place's primary contact must be a descendant of that place.
+
+1. Check to see which part of the contact's lineage will be removed
+2. For each removed part of the contact's lineage, confirm that place's primary contact isn't being removed.
+*/
+const getPrimaryContactViolations = async (db, contactDoc, destinationDoc, descendantDocs) => {
+  const contactsLineageIds = lineageManipulation.pluckIdsFromLineage(contactDoc?.parent);
+  const parentsLineageIds = lineageManipulation.pluckIdsFromLineage(destinationDoc);
+
+  const docIdsRemovedFromContactLineage = contactsLineageIds.filter(value => !parentsLineageIds.includes(value));
+  const docsRemovedFromContactLineage = await db.allDocs({
+    keys: docIdsRemovedFromContactLineage,
+    include_docs: true,
+  });
+
+  const primaryContactIds = docsRemovedFromContactLineage.rows
+    .map(row => row?.doc?.contact?._id)
+    .filter(Boolean);
+  
+  return descendantDocs.find(descendant => primaryContactIds.some(primaryId => descendant._id === primaryId));
+};
+
+const getContactType = doc => doc && (doc.type === 'contact' ? doc.contact_type : doc.type);
+
+async function fetchAllowedParents(db) {
+  try {
+    const { settings: { contact_types } } = await db.get('settings');
+
+    if (Array.isArray(contact_types)) {
+      trace('Found app_settings.contact_types. Configurable hierarchy constraints will be enforced.');
+      const parentDict = {};
+      contact_types
+        .filter(Boolean)
+        .forEach(({ id, parents }) => parentDict[id] = parents);
+      return parentDict;
+    }
+  } catch (err) {
+    if (err.status !== 404) {
+      throw err;
+    }
+  }
+
+  trace('Default hierarchy constraints will be enforced.');
+  return {
+    district_hospital: [],
+    health_center: ['district_hospital'],
+    clinic: ['health_center'],
+    person: ['district_hospital', 'health_center', 'clinic'],
+  };
+}
+

package/src/lib/hierarchy-operations/lineage-manipulation.js

@@ -0,0 +1,63 @@
+const { replaceContactLineage, replaceParentLineage } = require('./replace-lineage');
+
+/*
+Function borrowed from shared-lib/lineage
+*/
+const minifyLineagesInDoc = doc => {
+  const minifyLineage = lineage => {
+    if (!lineage?._id) {
+      return;
+    }
+
+    return {
+      _id: lineage._id,
+      parent: minifyLineage(lineage.parent),
+    };
+  };
+
+  if (!doc) {
+    return;
+  }
+  
+  if ('parent' in doc) {
+    doc.parent = minifyLineage(doc.parent);
+  }
+  
+  if ('contact' in doc) {
+    doc.contact = minifyLineage(doc.contact);
+  }
+
+  if (doc.type === 'data_record') {
+    delete doc.patient;
+  }
+};
+
+const createLineageFromDoc = doc => {
+  if (!doc) {
+    return undefined;
+  }
+
+  return {
+    _id: doc._id,
+    parent: doc.parent || undefined,
+  };
+};
+
+/*
+Given a lineage, return the ids therein
+*/
+const pluckIdsFromLineage = (lineage, results = []) => {
+  if (!lineage) {
+    return results;
+  }
+
+  return pluckIdsFromLineage(lineage.parent, [...results, lineage._id]);
+};
+
+module.exports = {
+  createLineageFromDoc,
+  minifyLineagesInDoc,
+  pluckIdsFromLineage,
+  replaceParentLineage,
+  replaceContactLineage,
+};

package/src/lib/hierarchy-operations/replace-lineage.js

@@ -0,0 +1,76 @@
+function replaceLineage(doc, lineageAttributeName, params) {
+  // Replace the full lineage
+  if (!params.startingFromId) {
+    return replaceEntireLineage(doc, lineageAttributeName, params.replaceWith);
+  }
+
+  const selectedFunction = params.merge ? replaceLineageForMerge : replaceLineageForMove;
+  return selectedFunction(doc, lineageAttributeName, params);
+}
+
+function replaceLineageForMove(doc, lineageAttributeName, params) {
+  let currentElement = doc[lineageAttributeName];
+  while (currentElement) {
+    if (currentElement?._id === params.startingFromId) {
+      return replaceEntireLineage(currentElement, 'parent', params.replaceWith);
+    }
+
+    currentElement = currentElement.parent;
+  }
+
+  return false;
+}
+
+function replaceLineageForMerge(doc, lineageAttributeName, params) {
+  let currentElement = doc;
+  let currentAttributeName = lineageAttributeName;
+  while (currentElement) {
+    if (currentElement[currentAttributeName]?._id === params.startingFromId) {
+      return replaceEntireLineage(currentElement, currentAttributeName, params.replaceWith);
+    }
+
+    currentElement = currentElement[currentAttributeName];
+    currentAttributeName = 'parent';
+  }
+
+  return false;
+}
+
+function replaceEntireLineage(replaceInDoc, lineageAttributeName, replaceWith) {
+  if (!replaceWith) {
+    const lineageWasDeleted = !!replaceInDoc[lineageAttributeName];
+    replaceInDoc[lineageAttributeName] = undefined;
+    return lineageWasDeleted;
+  }
+
+  replaceInDoc[lineageAttributeName] = replaceWith;
+  return true;
+}
+
+module.exports = {
+/**
+ * Given a doc, replace the parent's lineage
+ * 
+ * @param {Object} doc A CouchDB document containing a parent lineage (eg. parent.parent._id) 
+ * @param {Object} params 
+ * @param {Object} params.replaceWith The new hierarchy { parent: { _id: 'parent', parent: { _id: 'grandparent' } }
+ * @param {string} params.startingFromId Only the part of the lineage "after" this id will be replaced
+ * @param {boolean} params.merge When true, startingFromId is replaced and when false, startingFromId's parent is replaced 
+ */
+  replaceParentLineage: (doc, params) => {
+    return replaceLineage(doc, 'parent', params);
+  },
+
+/**
+ * Given a doc, replace the contact's lineage
+ * 
+ * @param {Object} doc A CouchDB document containing a contact lineage (eg. contact.parent._id)
+ * @param {Object} params 
+ * @param {Object} params.replaceWith The new hierarchy { parent: { _id: 'parent', parent: { _id: 'grandparent' } }
+ * @param {string} params.startingFromId Only the part of the lineage "after" this id will be replaced
+ * @param {boolean} params.merge When true, startingFromId is replaced and when false, startingFromId's parent is replaced 
+ */
+  replaceContactLineage: (doc, params) => {
+    return replaceLineage(doc, 'contact', params);
+  },
+};

package/src/lib/lineage-constraints.js

@@ -1,94 +0,0 @@
-const log = require('./log');
-const { trace } = log;
-
-const { pluckIdsFromLineage } = require('./lineage-manipulation');
-
-const lineageConstraints = async (repository, parentDoc) => {
-  let mapTypeToAllowedParents;
-  try {
-    const { settings } = await repository.get('settings');
-    const { contact_types } = settings;
-
-    if (Array.isArray(contact_types)) {
-      trace('Found app_settings.contact_types. Configurable hierarchy constraints will be enforced.');
-      mapTypeToAllowedParents = contact_types
-        .filter(rule => rule)
-        .reduce((agg, curr) => Object.assign(agg, { [curr.id]: curr.parents }), {});
-    }
-  } catch (err) {
-    if (err.name !== 'not_found') {
-      throw err;
-    }
-  }
-
-  if (!mapTypeToAllowedParents) {
-    trace('Default hierarchy constraints will be enforced.');
-    mapTypeToAllowedParents = {
-      district_hospital: [],
-      health_center: ['district_hospital'],
-      clinic: ['health_center'],
-      person: ['district_hospital', 'health_center', 'clinic'],
-    };
-  }
-
-  return {
-    getHierarchyErrors: contactDoc => getHierarchyViolations(mapTypeToAllowedParents, contactDoc, parentDoc),
-    getPrimaryContactViolations: (contactDoc, descendantDocs) => getPrimaryContactViolations(repository, contactDoc, parentDoc, descendantDocs),
-  };
-};
-
-/*
-Enforce the list of allowed parents for each contact type
-Ensure we are not creating a circular hierarchy
-*/
-const getHierarchyViolations = (mapTypeToAllowedParents, contactDoc, parentDoc) => {
-  const getContactType = doc => doc && (doc.type === 'contact' ? doc.contact_type : doc.type);
-  const contactType = getContactType(contactDoc);
-  const parentType = getContactType(parentDoc);
-  if (!contactType) return 'contact required attribute "type" is undefined';
-  if (parentDoc && !parentType) return `parent contact "${parentDoc._id}" required attribute "type" is undefined`;
-  if (!mapTypeToAllowedParents) return 'hierarchy constraints are undefined';
-
-  const rulesForContact = mapTypeToAllowedParents[contactType];
-  if (!rulesForContact) return `cannot move contact with unknown type '${contactType}'`;
-
-  const isPermittedMoveToRoot = !parentDoc && rulesForContact.length === 0;
-  if (!isPermittedMoveToRoot && !rulesForContact.includes(parentType)) return `contacts of type '${contactType}' cannot have parent of type '${parentType}'`;
-
-  if (parentDoc && contactDoc._id) {
-    const parentAncestry = [parentDoc._id, ...pluckIdsFromLineage(parentDoc.parent)];
-    if (parentAncestry.includes(contactDoc._id)) {
-      return `Circular hierarchy: Cannot set parent of contact '${contactDoc._id}' as it would create a circular hierarchy.`;
-    }
-  }
-};
-
-/*
-A place's primary contact must be a descendant of that place.
-
-1. Check to see which part of the contact's lineage will be removed
-2. For each removed part of the contact's lineage, confirm that place's primary contact isn't being removed.
-*/
-const getPrimaryContactViolations = async (repository, contactDoc, parentDoc, descendantDocs) => {
-  const safeGetLineageFromDoc = doc => doc ? pluckIdsFromLineage(doc.parent) : [];
-  const contactsLineageIds = safeGetLineageFromDoc(contactDoc);
-  const parentsLineageIds = safeGetLineageFromDoc(parentDoc);
-
-  if (parentDoc) {
-    parentsLineageIds.push(parentDoc._id);
-  }
-
-  const docIdsRemovedFromContactLineage = contactsLineageIds.filter(value => !parentsLineageIds.includes(value));
-  const docsRemovedFromContactLineage = await repository.allDocs({
-    keys: docIdsRemovedFromContactLineage,
-    include_docs: true,
-  });
-
-  const primaryContactIds = docsRemovedFromContactLineage.rows
-    .map(row => row.doc && row.doc.contact && row.doc.contact._id)
-    .filter(id => id);
-  
-  return descendantDocs.find(descendant => primaryContactIds.some(primaryId => descendant._id === primaryId));
-};
-
-module.exports = lineageConstraints;