cht-conf 4.1.3 → 4.2.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [4.2.0](https://github.com/medic/cht-conf/compare/v4.1.3...v4.2.0) (2024-12-11)
+
+
+### Features
+
+* **#373:** merge-contacts action ([#647](https://github.com/medic/cht-conf/issues/647)) ([006554c](https://github.com/medic/cht-conf/commit/006554cf3a414d9577e05c6dfaef3bbd59849403)), closes [#373](https://github.com/medic/cht-conf/issues/373)
+
 ## [4.1.3](https://github.com/medic/cht-conf/compare/v4.1.2...v4.1.3) (2024-11-13)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cht-conf",
-  "version": "4.1.3",
+  "version": "4.2.0",
   "description": "Configure CHT deployments",
   "main": "./src/lib/main.js",
   "engines": {

package/src/fn/edit-contacts.js

@@ -105,69 +105,89 @@ function getIDs(csv, docType) {
   return rows.map((item) => idPrefix + item[index]);
 }
 
-function processDocs(docType, csv, documentDocs, args) {
-  const { rows, cols } = fs.readCsv(csv);
-  const uuidIndex = cols.indexOf(DOCUMENT_ID);
-  const colNames = args.colNames;
-  let toIncludeColumns, toIncludeIndex;
-  if (!colNames.length) {
-    warn(' No columns specified, the script will add all the columns in the CSV!');
-    toIncludeColumns = cols;
-    toIncludeIndex = [];
-
-  } else {
-    if (!columnsAreValid(cols,colNames)) {
-      throw Error('The column name(s) specified do not exist.');
-    }
-
-    toIncludeColumns = cols.filter(column => colNames.includes(column.split(':')[0]));
-    toIncludeIndex = toIncludeColumns.map(column => cols.indexOf(column));
-
-    if (toIncludeColumns.includes(DOCUMENT_ID)) {
-      toIncludeIndex.splice(toIncludeColumns.indexOf(DOCUMENT_ID),1);
-    }
-  }
-
-  if (toIncludeColumns.includes(DOCUMENT_ID)) {
-    toIncludeColumns.splice(toIncludeColumns.indexOf(DOCUMENT_ID),1);
-  }
-  return rows
-    .map(r => processCsv(docType, toIncludeColumns, r, uuidIndex, toIncludeIndex, documentDocs));
-}
-
 function columnsAreValid(csvColumns, toIncludeColumns) {
   const splitCsvColumns = csvColumns.map(column => column && column.split(':')[0]);
   return toIncludeColumns.every(column => splitCsvColumns.includes(column));    
 }
+const parseColName = colName => colName.split(':')[0];
+const getColNamesToInclude = (csvColNames, targetColNames) => {
+  const filteredCsvColNames = csvColNames.filter(colName => colName !== DOCUMENT_ID);
+  if (!targetColNames.length) {
+    warn(' No columns specified, the script will add all the columns in the CSV!');
+    return filteredCsvColNames;
+  }
+  
+  if (!columnsAreValid(filteredCsvColNames, targetColNames)) {
+    throw Error('The column name(s) specified do not exist.');
+  }
+
+  return filteredCsvColNames.filter(column => targetColNames.includes(parseColName(column)));
+};
 
-function processCsv(docType, cols, row, uuidIndex, toIncludeIndex, documentDocs) {
+const getCsvColNameIndex = csvColNames => colName => csvColNames.indexOf(colName);
+const mapColNamesToCsvIndex = (csvColNames, toIncludeColumns) => toIncludeColumns.map(getCsvColNameIndex(csvColNames));
+
+
+const getDocIdForCsvRow = (docType, uuidIndex) => row => {
   const documentId = row[uuidIndex];
   const idPrefix =  docType === 'contact' ? '' : 'org.couchdb.user:';
-  const doc = documentDocs[idPrefix + documentId];
+  return `${idPrefix}${documentId}`;
+};
 
+const getCsvRowFilterFn = (uuidIndex, toIncludeIndex) => {
   if (toIncludeIndex.length > 0) {
-    row = toIncludeIndex.map(index => row[index]);
-  } else {
-    row.splice(uuidIndex,1);
+    return row => toIncludeIndex.map(index => row[index]);
   }
 
-  for(let i=0; i<cols.length; ++i) {
-    const { col, val, excluded } = toDocs.parseColumn(cols[i], row[i]);
+  return row => {
+    const updatedRow = [...row];
+    updatedRow.splice(uuidIndex, 1);
+    return updatedRow;
+  };
+};
+
+const isColNameProtected = col => EDIT_RESERVED_COL_NAMES.includes(col.split('.')[0]);
+const processCsvColumn = (doc, row) => (colName, index) => {
+  const { col, val, excluded } = toDocs.parseColumn(colName, row[index]);
     
-    if (EDIT_RESERVED_COL_NAMES.includes(col.split('.')[0])) {
-      throw new Error(`Cannot set property defined by column '${col}' - this property name is protected.`);
-    }
+  if (isColNameProtected(col)) {
+    throw new Error(`Cannot set property defined by column '${col}' - this property name is protected.`);
+  }
 
-    toDocs.setCol(doc, col, val);
-    if (excluded) { 
-      model.exclusions.push({
-        doc: doc,
-        propertyName: col,
-      });
-    }
+  toDocs.setCol(doc, col, val);
+  if (excluded) { 
+    model.exclusions.push({
+      doc,
+      propertyName: col,
+    });
   }
-  return doc;
-}
+};
+const processCsvRow = colNames => ([doc, row]) => colNames.forEach(processCsvColumn(doc, row));
+
+const getColIndexesToInclude = (colNames, cols, toIncludeColumns) => {
+  if(colNames.length) {
+    return mapColNamesToCsvIndex(cols, toIncludeColumns);
+  } 
+  return [];
+};
+
+const processDocs = (docType, csv, documentDocs, args) => {
+  const { rows, cols } = fs.readCsv(csv);
+  const uuidIndex = cols.indexOf(DOCUMENT_ID);
+  const colNamesToInclude = getColNamesToInclude(cols, args.colNames);
+  const colIndexesToInclude = getColIndexesToInclude(args.colNames, cols, colNamesToInclude);
+  const getFilteredCsvRow = getCsvRowFilterFn(uuidIndex, colIndexesToInclude);
+
+  const rowDocs = rows
+    .map(getDocIdForCsvRow(docType, uuidIndex))
+    .map(id => documentDocs[id]);
+
+  rows
+    .map(getFilteredCsvRow)
+    .map((row, index) => [rowDocs[index], row])
+    .map(processCsvRow(colNamesToInclude));
+  return rowDocs;
+};
 
 const processDocuments =  async (docType, csv, ids, db, args) => {
   const documentDocs = await fetchDocumentList(db, ids, args);
@@ -196,4 +216,4 @@ const parseExtraArgs = (projectDir, extraArgs = []) => {
 module.exports = {
   requiresInstance: true,
   execute
-};
+};

package/src/fn/merge-contacts.js

@@ -0,0 +1,69 @@
+const minimist = require('minimist');
+const path = require('path');
+
+const environment = require('../lib/environment');
+const pouch = require('../lib/db');
+const { info } = require('../lib/log');
+
+const HierarchyOperations = require('../lib/hierarchy-operations');
+
+module.exports = {
+  requiresInstance: true,
+  execute: () => {
+    const args = parseExtraArgs(environment.pathToProject, environment.extraArgs);
+    const db = pouch();
+    const options = {
+      docDirectoryPath: args.docDirectoryPath,
+      force: args.force,
+    };
+    return HierarchyOperations(db, options).merge(args.sourceIds, args.destinationId);
+  }
+};
+
+// Parses extraArgs and asserts if required parameters are not present
+const parseExtraArgs = (projectDir, extraArgs = []) => {
+  const args = minimist(extraArgs, { boolean: true });
+
+  const sourceIds = (args.sources || args.source || '')
+    .split(',')
+    .filter(Boolean);
+
+  if (!args.destination) {
+    usage();
+    throw Error(`Action "merge-contacts" is missing required contact ID ${bold('--destination')}. Other contacts will be merged into this contact.`);
+  }
+
+  if (sourceIds.length === 0) {
+    usage();
+    throw Error(`Action "merge-contacts" is missing required contact ID(s) ${bold('--sources')}. These contacts will be merged into the contact specified by ${bold('--destination')}`);
+  }
+
+  return {
+    destinationId: args.destination,
+    sourceIds,
+    docDirectoryPath: path.resolve(projectDir, args.docDirectoryPath || 'json_docs'),
+    force: !!args.force,
+  };
+};
+
+const bold = text => `\x1b[1m${text}\x1b[0m`;
+const usage = () => {
+  info(`
+${bold('cht-conf\'s merge-contacts action')}
+When combined with 'upload-docs' this action moves all of the contacts and reports under ${bold('sources')} to be under ${bold('destination')}.
+The top-level ${bold('source contact(s)')} are deleted and no data from this document is merged or preserved.
+
+${bold('USAGE')}
+cht --local merge-contacts -- --destination=<destination_id> --sources=<source_id1>,<source_id2>
+
+${bold('OPTIONS')}
+--destination=<destination_id>
+  Specifies the ID of the contact that should receive the moving contacts and reports.
+
+--sources=<source_id1>,<source_id2>
+  A comma delimited list of IDs of contacts which will be deleted. The hierarchy of contacts and reports under it will be moved to be under the destination contact.
+
+--docDirectoryPath=<path to stage docs>
+  Specifies the folder used to store the documents representing the changes in hierarchy.
+`);
+};

package/src/fn/move-contacts.js

@@ -1,105 +1,34 @@
 const minimist = require('minimist');
 const path = require('path');
-const userPrompt = require('../lib/user-prompt');
 
 const environment = require('../lib/environment');
-const fs = require('../lib/sync-fs');
-const lineageManipulation = require('../lib/lineage-manipulation');
-const lineageConstraints = require('../lib/lineage-constraints');
 const pouch = require('../lib/db');
-const { warn, trace, info } = require('../lib/log');
+const { info } = require('../lib/log');
 
-const HIERARCHY_ROOT = 'root';
-const BATCH_SIZE = 10000;
+const HierarchyOperations = require('../lib/hierarchy-operations');
 
 module.exports = {
   requiresInstance: true,
   execute: () => {
     const args = parseExtraArgs(environment.pathToProject, environment.extraArgs);
     const db = pouch();
-    prepareDocumentDirectory(args);
-    return updateLineagesAndStage(args, db);
+    const options = {
+      docDirectoryPath: args.docDirectoryPath,
+      force: args.force,
+    };
+    return HierarchyOperations(db, options).move(args.sourceIds, args.destinationId);
   }
 };
 
-const prettyPrintDocument = doc => `'${doc.name}' (${doc._id})`;
-const updateLineagesAndStage = async (options, db) => {
-  trace(`Fetching contact details for parent: ${options.parentId}`);
-  const parentDoc = await fetch.contact(db, options.parentId);
-
-  const constraints = await lineageConstraints(db, parentDoc);
-  const contactDocs = await fetch.contactList(db, options.contactIds);
-  await validateContacts(contactDocs, constraints);
-
-  let affectedContactCount = 0, affectedReportCount = 0;
-  const replacementLineage = lineageManipulation.createLineageFromDoc(parentDoc);
-  for (let contactId of options.contactIds) {
-    const contactDoc = contactDocs[contactId];
-    const descendantsAndSelf = await fetch.descendantsOf(db, contactId);
-
-    // Check that primary contact is not removed from areas where they are required
-    const invalidPrimaryContactDoc = await constraints.getPrimaryContactViolations(contactDoc, descendantsAndSelf);
-    if (invalidPrimaryContactDoc) {
-      throw Error(`Cannot remove contact ${prettyPrintDocument(invalidPrimaryContactDoc)} from the hierarchy for which they are a primary contact.`);
-    }
-
-    trace(`Considering lineage updates to ${descendantsAndSelf.length} descendant(s) of contact ${prettyPrintDocument(contactDoc)}.`);
-    const updatedDescendants = replaceLineageInContacts(descendantsAndSelf, replacementLineage, contactId);
-
-    const ancestors = await fetch.ancestorsOf(db, contactDoc);
-    trace(`Considering primary contact updates to ${ancestors.length} ancestor(s) of contact ${prettyPrintDocument(contactDoc)}.`);
-    const updatedAncestors = replaceLineageInAncestors(descendantsAndSelf, ancestors);
-
-    minifyLineageAndWriteToDisk([...updatedDescendants, ...updatedAncestors], options);
-
-    const movedReportsCount = await moveReports(db, descendantsAndSelf, options, replacementLineage, contactId);
-    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(contactDoc)}. ${updatedDescendants.length} contact(s) and ${movedReportsCount} report(s).`);
-  }
-
-  info(`Staged changes to lineage information for ${affectedContactCount} contact(s) and ${affectedReportCount} report(s).`);
-};
-
-/*
-Checks for any errors which this will create in the hierarchy (hierarchy schema, circular hierarchies)
-Confirms the list of contacts are possible to move
-*/
-const validateContacts = async (contactDocs, constraints) => {
-  Object.values(contactDocs).forEach(doc => {
-    const hierarchyError = constraints.getHierarchyErrors(doc);
-    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 = Object.keys(contactDocs);
-  Object.values(contactDocs)
-    .forEach(doc => {
-      const parentIdsOfDoc = (doc.parent && 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}'`);
-      }
-    });
-};
-
 // Parses extraArgs and asserts if required parameters are not present
 const parseExtraArgs = (projectDir, extraArgs = []) => {
   const args = minimist(extraArgs, { boolean: true });
 
-  const contactIds = (args.contacts || args.contact || '')
+  const sourceIds = (args.contacts || args.contact || '')
     .split(',')
     .filter(id => id);
 
-  if (contactIds.length === 0) {
+  if (sourceIds.length === 0) {
     usage();
     throw Error('Action "move-contacts" is missing required list of contacts to be moved');
   }
@@ -110,28 +39,15 @@ const parseExtraArgs = (projectDir, extraArgs = []) => {
   }
 
   return {
-    parentId: args.parent,
-    contactIds,
+    destinationId: args.parent,
+    sourceIds,
     docDirectoryPath: path.resolve(projectDir, args.docDirectoryPath || 'json_docs'),
     force: !!args.force,
   };
 };
 
-const prepareDocumentDirectory = ({ docDirectoryPath, force }) => {
-  if (!fs.exists(docDirectoryPath)) {
-    fs.mkdir(docDirectoryPath);
-  } else if (!force && fs.recurseFiles(docDirectoryPath).length > 0) {
-    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()) {
-      fs.deleteFilesInFolder(docDirectoryPath);
-    } else {
-      throw new Error('User aborted execution.');
-    }
-  }
-};
-
+const bold = text => `\x1b[1m${text}\x1b[0m`;
 const usage = () => {
-  const bold = text => `\x1b[1m${text}\x1b[0m`;
   info(`
 ${bold('cht-conf\'s move-contacts action')}
 When combined with 'upload-docs' this action effectively moves a contact from one place in the hierarchy to another.
@@ -144,148 +60,9 @@ ${bold('OPTIONS')}
   A comma delimited list of ids of contacts to be moved.
 
 --parent=<parent_id>
-  Specifies the ID of the new parent. Use '${HIERARCHY_ROOT}' to identify the top of the hierarchy (no parent).
+  Specifies the ID of the new parent. Use '${HierarchyOperations.HIERARCHY_ROOT}' to identify the top of the hierarchy (no parent).
 
 --docDirectoryPath=<path to stage docs>
   Specifies the folder used to store the documents representing the changes in hierarchy.
 `);
 };
-
-const moveReports = async (db, descendantsAndSelf, writeOptions, replacementLineage, contactId) => {
-  const contactIds = descendantsAndSelf.map(contact => contact._id);
-
-  let skip = 0;
-  let reportDocsBatch;
-  do {
-    info(`Processing ${skip} to ${skip + BATCH_SIZE} report docs`);
-    reportDocsBatch = await fetch.reportsCreatedBy(db, contactIds, skip);
-
-    const updatedReports = replaceLineageInReports(reportDocsBatch, replacementLineage, contactId);
-    minifyLineageAndWriteToDisk(updatedReports, writeOptions);
-
-    skip += reportDocsBatch.length;
-  } while (reportDocsBatch.length >= BATCH_SIZE);
-
-  return skip;
-};
-
-const minifyLineageAndWriteToDisk = (docs, parsedArgs) => {
-  docs.forEach(doc => {
-    lineageManipulation.minifyLineagesInDoc(doc);
-    writeDocumentToDisk(parsedArgs, doc);
-  });
-};
-
-const writeDocumentToDisk = ({ 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);
-};
-
-const fetch = {
-  /*
-  Fetches all of the documents associated with the "contactIds" and confirms they exist.
-  */
-  contactList: async (db, ids) => {
-    const contactDocs = await db.allDocs({
-      keys: ids,
-      include_docs: true,
-    });
-
-    const missingContactErrors = contactDocs.rows.filter(row => !row.doc).map(row => `Contact with id '${row.key}' could not be found.`);
-    if (missingContactErrors.length > 0) {
-      throw Error(missingContactErrors);
-    }
-
-    return contactDocs.rows.reduce((agg, curr) => Object.assign(agg, { [curr.doc._id]: curr.doc }), {});
-  },
-
-  contact: async (db, id) => {
-    try {
-      if (id === HIERARCHY_ROOT) {
-        return undefined;
-      }
-
-      return await db.get(id);
-    } catch (err) {
-      if (err.name !== 'not_found') {
-        throw err;
-      }
-
-      throw Error(`Contact with id '${id}' could not be found`);
-    }
-  },
-
-  /*
-  Given a contact's id, obtain the documents of all descendant contacts
-  */
-  descendantsOf: async (db, contactId) => {
-    const descendantDocs = await db.query('medic/contacts_by_depth', {
-      key: [contactId],
-      include_docs: true,
-    });
-
-    return descendantDocs.rows
-      .map(row => row.doc)
-      /* We should not move or update tombstone documents */
-      .filter(doc => doc && doc.type !== 'tombstone');
-  },
-
-  reportsCreatedBy: async (db, contactIds, skip) => {
-    const reports = await db.query('medic-client/reports_by_freetext', {
-      keys: contactIds.map(id => [`contact:${id}`]),
-      include_docs: true,
-      limit: BATCH_SIZE,
-      skip: skip,
-    });
-
-    return reports.rows.map(row => row.doc);
-  },
-
-  ancestorsOf: async (db, contactDoc) => {
-    const ancestorIds = lineageManipulation.pluckIdsFromLineage(contactDoc.parent);
-    const ancestors = await db.allDocs({
-      keys: ancestorIds,
-      include_docs: true,
-    });
-
-    const ancestorIdsNotFound = ancestors.rows.filter(ancestor => !ancestor.doc).map(ancestor => ancestor.key);
-    if (ancestorIdsNotFound.length > 0) {
-      throw Error(`Contact '${prettyPrintDocument(contactDoc)} has parent id(s) '${ancestorIdsNotFound.join(',')}' which could not be found.`);
-    }
-
-    return ancestors.rows.map(ancestor => ancestor.doc);
-  },
-};
-
-const replaceLineageInReports = (reportsCreatedByDescendants, replaceWith, startingFromIdInLineage) => reportsCreatedByDescendants.reduce((agg, doc) => {
-  if (lineageManipulation.replaceLineage(doc, 'contact', replaceWith, startingFromIdInLineage)) {
-    agg.push(doc);
-  }
-  return agg;
-}, []);
-
-const replaceLineageInContacts = (descendantsAndSelf, replacementLineage, contactId) => descendantsAndSelf.reduce((agg, doc) => {
-  const startingFromIdInLineage = doc._id === contactId ? undefined : contactId;
-  const parentWasUpdated = lineageManipulation.replaceLineage(doc, 'parent', replacementLineage, startingFromIdInLineage);
-  const contactWasUpdated = lineageManipulation.replaceLineage(doc, 'contact', replacementLineage, contactId);
-  if (parentWasUpdated || contactWasUpdated) {
-    agg.push(doc);
-  }
-  return agg;
-}, []);
-
-const replaceLineageInAncestors = (descendantsAndSelf, ancestors) => ancestors.reduce((agg, ancestor) => {
-  let result = agg;
-  const primaryContact = descendantsAndSelf.find(descendant => ancestor.contact && descendant._id === ancestor.contact._id);
-  if (primaryContact) {
-    ancestor.contact = lineageManipulation.createLineageFromDoc(primaryContact);
-    result = [ancestor, ...result];
-  }
-
-  return result;
-}, []);

package/src/lib/hierarchy-operations/hierarchy-data-source.js

@@ -0,0 +1,103 @@
+const lineageManipulation = require('./lineage-manipulation');
+
+const HIERARCHY_ROOT = 'root';
+const BATCH_SIZE = 10000;
+
+/*
+Fetches all of the documents associated with the "contactIds" and confirms they exist.
+*/
+async function getContactsByIds(db, ids) {
+  const contactDocs = await db.allDocs({
+    keys: ids,
+    include_docs: true,
+  });
+
+  const missingContactErrors = contactDocs.rows.filter(row => !row.doc).map(row => `Contact with id '${row.key}' could not be found.`);
+  if (missingContactErrors.length > 0) {
+    throw Error(missingContactErrors);
+  }
+
+  const contactDict = {};
+  contactDocs.rows.forEach(({ doc }) => contactDict[doc._id] = doc);
+  return contactDict;
+}
+
+async function getContact(db, id) {
+  try {
+    if (id === HIERARCHY_ROOT) {
+      return undefined;
+    }
+
+    return await db.get(id);
+  } catch (err) {
+    if (err.status !== 404) {
+      throw err;
+    }
+
+    throw Error(`Contact with id '${id}' could not be found`);
+  }
+}
+
+/*
+Given a contact's id, obtain the documents of all descendant contacts
+*/
+async function getContactWithDescendants(db, contactId) {
+  const descendantDocs = await db.query('medic/contacts_by_depth', {
+    key: [contactId],
+    include_docs: true,
+  });
+
+  return descendantDocs.rows
+    .map(row => row.doc)
+    // We should not move or update tombstone documents
+    // Not relevant for 4.x cht-core versions, but needed in older versions.
+    .filter(doc => doc && doc.type !== 'tombstone');
+}
+
+async function getReportsForContacts(db, createdByIds, createdAtId, skip) {
+  const createdByKeys = createdByIds.map(id => [`contact:${id}`]);
+  const createdAtKeys = createdAtId ? [
+    [`patient_id:${createdAtId}`],
+    [`patient_uuid:${createdAtId}`],
+    [`place_id:${createdAtId}`],
+    [`place_uuid:${createdAtId}`]
+  ] : [];
+
+  const reports = await db.query('medic-client/reports_by_freetext', {
+    keys: [
+      ...createdByKeys,
+      ...createdAtKeys,
+    ],
+    include_docs: true,
+    limit: BATCH_SIZE,
+    skip,
+  });
+
+  const docsWithId = reports.rows.map(({ doc }) => [doc._id, doc]);
+  return Array.from(new Map(docsWithId).values());
+}
+
+async function getAncestorsOf(db, contactDoc) {
+  const ancestorIds = lineageManipulation.pluckIdsFromLineage(contactDoc.parent);
+  const ancestors = await db.allDocs({
+    keys: ancestorIds,
+    include_docs: true,
+  });
+
+  const ancestorIdsNotFound = ancestors.rows.filter(ancestor => !ancestor.doc).map(ancestor => ancestor.key);
+  if (ancestorIdsNotFound.length > 0) {
+    throw Error(`Contact '${contactDoc?.name}' (${contactDoc?._id}) has parent id(s) '${ancestorIdsNotFound.join(',')}' which could not be found.`);
+  }
+
+  return ancestors.rows.map(ancestor => ancestor.doc);
+}
+
+module.exports = {
+  BATCH_SIZE,
+  HIERARCHY_ROOT,
+  getAncestorsOf,
+  getContactWithDescendants,
+  getContact,
+  getContactsByIds,
+  getReportsForContacts,
+};

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;

package/src/lib/lineage-manipulation.js

@@ -1,107 +0,0 @@
-
-/*
-Given a doc, replace the lineage information therein with "replaceWith"
-
-startingFromIdInLineage (optional) - Will result in a partial replacement of the lineage. Only the part of the lineage "after" the parent
-with _id=startingFromIdInLineage will be replaced by "replaceWith"
-*/
-const replaceLineage = (doc, lineageAttributeName, replaceWith, startingFromIdInLineage) => {
-  const handleReplacement = (replaceInDoc, docAttr, replaceWith) => {
-    if (!replaceWith) {
-      const lineageWasDeleted = !!replaceInDoc[docAttr];
-      replaceInDoc[docAttr] = undefined;
-      return lineageWasDeleted;
-    } else if (replaceInDoc[docAttr]) {
-      replaceInDoc[docAttr]._id = replaceWith._id;
-      replaceInDoc[docAttr].parent = replaceWith.parent;
-    } else {
-      replaceInDoc[docAttr] = replaceWith;
-    }
-
-    return true;
-  };
-
-  // Replace the full lineage
-  if (!startingFromIdInLineage) {
-    return handleReplacement(doc, lineageAttributeName, replaceWith);
-  }
-
-  // Replace part of a lineage
-  let currentParent = doc[lineageAttributeName];
-  while (currentParent) {
-    if (currentParent._id === startingFromIdInLineage) {
-      return handleReplacement(currentParent, 'parent', replaceWith);
-    }
-    currentParent = currentParent.parent;
-  }
-
-  return false;
-};
-
-/*
-Function borrowed from shared-lib/lineage
-*/
-const minifyLineagesInDoc = doc => {
-  const minifyLineage = lineage => {
-    if (!lineage || !lineage._id) {
-      return undefined;
-    }
-
-    const result = {
-      _id: lineage._id,
-      parent: minifyLineage(lineage.parent),
-    };
-
-    return result;
-  };
-
-  if (!doc) {
-    return undefined;
-  }
-  
-  if ('parent' in doc) {
-    doc.parent = minifyLineage(doc.parent);
-  }
-  
-  if ('contact' in doc) {
-    doc.contact = minifyLineage(doc.contact);
-    if (doc.contact && !doc.contact.parent) delete doc.contact.parent; // for unit test clarity
-  }
-
-  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 => {
-  const result = [];
-
-  let current = lineage;
-  while (current) {
-    result.push(current._id);
-    current = current.parent;
-  }
-
-  return result;
-};
-
-module.exports = {
-  createLineageFromDoc,
-  minifyLineagesInDoc,
-  pluckIdsFromLineage,
-  replaceLineage,
-};