@dhyasama/totem-merge 7.1.4 → 7.2.0

package/docs/transactional-lead-merges.md

@@ -0,0 +1,77 @@
+# Transactional company and person merges
+
+Status: 7.2.0 release candidate, 2026-10-24. No consumer enables this path yet.
+Publishing this package does not activate its transactional merge option.
+
+## First-rollout scope
+
+The owner's first rollout covers Customer settings (already completed), Lead,
+Tag and Valuation. Notes, Documents and custom fields remain on their existing
+records. `transactionalPrivateData: true` opts into the transaction and native
+Lead/Tag/Valuation handling only; it does not activate the deferred migrations.
+
+Both document and ID entry points reload the source and target on every retry.
+Source deletion, target save, existing reference updates, Lead/Tag/Valuation
+updates and their legacy mirrors commit together. Company merges union distinct
+leads per customer with no count limit. Person merges replace the source Person
+and deduplicate assignments. Tags combine groups/items per owner. Every valuation
+occurrence and database ID survives; conflicting legacy IDs block the merge.
+
+The path requires a replica set, models on one connection, uniqueness indexes on
+Lead/Tag/Valuation, and the existing open customer-settings control record. Its
+transaction fence coordinates with lifecycle admission and private-data writers.
+No write pause or queue/schedule hold is introduced. Missing additive Leads can
+be initialized from chairs; Tags and Valuations must already be reconciled.
+Invalid owners, blocking lifecycle jobs, missing people and destination drift
+fail the whole transaction. A committed retry is recognized by merged history.
+
+## Deferred fields stay in legacy storage
+
+The CustomField collection is neither read nor written, and its index is not a
+merge prerequisite. Embedded Organization custom fields remain embedded. Their
+values are combined per customer, preserving zero/false/null and disjoint keys;
+conflicts stop the merge for review. This prevents the old generic array merger
+from dropping entries without subdocument IDs. Fund/LP/Deal values are unchanged.
+
+Note/Document legacy parent links are combined on the surviving Organization or
+Person. Existing Document.organization references to a merged company are
+retargeted in the same transaction, preserving extraction behavior. Attachment
+ownership, lifecycle and cross-tenant LP checks still apply to these legacy links.
+Content, IDs and storage keys remain intact. Hidden conflicting legacy Document
+company links block the merge.
+
+No Note.entities or Document.entities arrays are created, consumed, updated or
+used to synthesize parent links. Existing deferred native data is left intact;
+future attachment/CustomField reconciliation must account for merged identities
+before any later activation. It must not replay an obsolete source plan.
+
+Reference queues run serially in the transaction. The draft also propagates queue
+errors, scopes Deal/Document/Note updates to each record's owner, and preserves
+Person source/referrer metadata on the default path. Those changes still require
+release review; they are separate from enabling new-store authority.
+
+## Validation and release gates
+
+42 targeted tests pass, including synthetic replica-set merges against the web
+consumer's published models 17.0.0. Coverage includes unlimited Leads, tenant
+isolation, transaction rollback/retries, concurrent fenced edits, committed replay,
+Tag drift, valuation identity, embedded custom-field preservation/conflicts,
+untouched native CustomFields/entities, legacy attachment links and lifecycle
+checks. Merges work without a CustomField uniqueness index and never initialize
+attachment entities. Tests use a uniquely named disposable local database.
+
+Before adoption: review/release the package, complete Lead/Tag/Valuation writer
+coverage and reconciliation, test production-sized transaction cost, and verify
+all consumers, caches and Pentest behavior. The narrowed preparation completed a clean 423-Customer production comparison
+on 2026-10-24; repeat live parity checks before activation. Native attachment and CustomField consumers
+must remain disabled. This draft is not readiness to cut over or remove fields.
+
+## 7.2.0 release review
+
+The current consumer baseline is models 17.0.0, including Account.customer and
+retired Interaction/activity-list models. The 42 focused merge/security tests
+pass against that exact dependency. The default constructor remains opt-out.
+Adoption also includes the reviewed default-path fixes above; it is not a claim
+that every legacy merge behavior is identical. Before transactional activation,
+finish writer deployment and production-scale cost checks. Once enabled, rollback
+must retain native/legacy mirroring rather than reverting to an unfenced merger.

package/index.js

@@ -7,6 +7,7 @@ var Logger = require('@dhyasama/totem-logger');
 // Constructor
 var Merge = function(mongoose, config) {
 
+  this.transactionalPrivateData = config.transactionalPrivateData === true;
   this.env = process.env.NODE_ENV || 'development';
   this.logger = new Logger(config.logentries);
   this.CapTable = mongoose.model('CapTable');
@@ -30,11 +31,15 @@ var Merge = function(mongoose, config) {
 //////////////////////////////////////////////
 
 Merge.prototype.organizations = function(target, source, user, customerId, cb) {
+
+  if (this.transactionalPrivateData) return require('./lib/atomicMerge')(this, 'Organization', target, source, user, customerId).then(result => cb(null, result), error => cb(error, null));
   organizations.merge(this, target, source, user, customerId, cb);
 };
 
 Merge.prototype.organizationsById = function(targetId, sourceId, user, customerId, cb) {
 
+  if (this.transactionalPrivateData) return require('./lib/atomicMerge')(this, 'Organization', targetId, sourceId, user, customerId).then(result => cb(null, result), error => cb(error, null));
+
   var self = this;
 
   self.logger.writeToInfoLog('Merge org ' + sourceId + ' into ' + targetId);
@@ -63,11 +68,15 @@ Merge.prototype.organizationsById = function(targetId, sourceId, user, customerI
 };
 
 Merge.prototype.people = function(target, source, user, customerId, cb) {
+
+  if (this.transactionalPrivateData) return require('./lib/atomicMerge')(this, 'Person', target, source, user, customerId).then(result => cb(null, result), error => cb(error, null));
   people.merge(this, target, source, user, customerId, cb);
 };
 
 Merge.prototype.peopleById = function(targetId, sourceId, user, customerId, cb) {
 
+  if (this.transactionalPrivateData) return require('./lib/atomicMerge')(this, 'Person', targetId, sourceId, user, customerId).then(result => cb(null, result), error => cb(error, null));
+
   var self = this;
 
   self.logger.writeToInfoLog('Merge person ' + sourceId + ' into ' + targetId);

package/lib/atomicMerge.js

@@ -0,0 +1,53 @@
+'use strict';
+const scopedContext = require('./transactionContext');
+const leads = require('./leadMerge');
+const privateRecords = require('./privateRecordMerge');
+const attachments = require('./attachmentMerge');
+const gate = require('./controls/customer-settings-gate');
+const implementations = { Organization: require('./organizations'), Person: require('./people') };
+module.exports = async function atomicMerge(context, kind, targetId, sourceId, user, customerId) {
+  const Model = context[kind], connection = Model.db, db = connection.db;
+  if (Object.values(context).some(value => value?.modelName && value.db !== connection)) throw Error('Merge models must share one connection');
+  const id = value => {
+    const text = String(value?._id || value || '');
+    if (!/^[a-f0-9]{24}$/i.test(text)) throw Error('Invalid merge ID');
+    return new Model.base.Types.ObjectId(text);
+  };
+  targetId = id(targetId); sourceId = id(sourceId);
+  if (String(targetId) === String(sourceId)) throw Error('Cannot merge an entity into itself');
+  for (const [collection, key, partial] of [
+    ['leads', { customer: 1, organization: 1 }],
+    ['tags', { customer: 1, 'entity.model': 1, 'entity.id': 1 }],
+    ['valuations', { customer: 1, organization: 1, legacyId: 1 }, { legacyId: { $type: 'objectId' } }]
+  ]) {
+    const indexes = await db.collection(collection).indexes();
+    if (!indexes.some(index => index.unique && !index.sparse &&
+        JSON.stringify(index.partialFilterExpression) === JSON.stringify(partial) &&
+        JSON.stringify(index.key) === JSON.stringify(key))) throw Error(collection + ' unique index is required');
+  }
+  const session = await connection.startSession();
+  try {
+    return await session.withTransaction(async () => {
+      await gate.writer(db, session, 'customer');
+      // Fresh documents on every retry. Never merge a stale, tenant-filtered
+      // caller object or retain mutated documents across transaction attempts.
+      const target = await Model.findById(targetId).session(session);
+      const source = await Model.findById(sourceId).session(session);
+      if (!target) throw Error('Merge target not found');
+      if (!source) {
+        if ((target.merged || []).some(value => String(value) === String(sourceId))) return target;
+        throw Error('Merge source not found');
+      }
+      const plan = await leads.prepare(db, session, kind, target, source);
+      const privatePlan = await privateRecords.prepare(db, session, kind, target, source);
+      const attachmentPlan = await attachments.prepare(db, session, kind, target, source);
+      const contextInTransaction = scopedContext(context, session);
+      await new Promise((resolve, reject) => implementations[kind].merge(contextInTransaction, target, source, user, customerId,
+        (error, result) => error ? reject(error) : resolve(result)));
+      await leads.apply(db, session, plan);
+      await privateRecords.apply(db, session, privatePlan);
+      await attachments.apply(db, session, attachmentPlan);
+      return Model.findById(targetId).session(session);
+    }, { readConcern: { level: 'snapshot' }, writeConcern: { w: 'majority' } });
+  } finally { await session.endSession(); }
+};

package/lib/attachmentMerge.js

@@ -0,0 +1,65 @@
+'use strict';
+const { id, oid, array, owners } = require('./privateMergeChecks');
+const parentCollections = { Organization: 'organizations', Person: 'people', LimitedPartner: 'limitedpartners' };
+async function prepare(db, session, kind, target, source) {
+  const targetId = id(target._id), sourceId = id(source._id), ids = [target._id, source._id];
+  const parents = await db.collection(parentCollections[kind]).find({ _id: { $in: ids } },
+    { session, projection: { notes: 1, documents: 1 } }).toArray();
+  const records = [], mirrors = {}, ownerIds = [];
+  for (const collection of ['notes', 'documents']) {
+    const parentIds = [...new Set(parents.flatMap(parent => array(parent[collection]).map(id)))];
+    // First rollout preserves legacy links only; native entities are deferred.
+    const predicates = [{ _id: { $in: parentIds.map(oid) } }];
+    if (kind === 'Organization' && collection === 'documents') predicates.push({ organization: { $in: ids } });
+    const attachments = await db.collection(collection).find({ $or: predicates }, { session }).toArray();
+    if (parentIds.some(value => !attachments.some(attachment => id(attachment._id) === value))) throw Error('Missing attachment on merge parent');
+    const attachmentIds = attachments.map(attachment => attachment._id);
+    // Recover every legacy parent, not just the merging pair. This catches a
+    // second company hidden in a legacy array and preserves all Note links.
+    const reverse = [];
+    for (const [model, name] of Object.entries(parentCollections)) {
+      for (const parent of await db.collection(name).find({ [collection]: { $in: attachmentIds } },
+        { session, projection: { [collection]: 1, customer: 1 } }).toArray()) reverse.push({ model, parent });
+    }
+    mirrors[collection] = [];
+    for (const attachment of attachments) {
+      const customer = id(attachment.customer), entities = new Map();
+      ownerIds.push(customer);
+      function add(model, ref) {
+        if (!parentCollections[model]) throw Error('Invalid attachment entity model');
+        let value = id(ref);
+        if (model === kind && value === sourceId) value = targetId;
+        entities.set(model + '/' + value, { model, id: oid(value) });
+      }
+      for (const { model, parent } of reverse) if (array(parent[collection]).some(ref => id(ref) === id(attachment._id))) {
+        if (model === 'LimitedPartner' && id(parent.customer) !== customer) throw Error('Cross-customer attachment association');
+        add(model, parent._id);
+      }
+      if (collection === 'documents' && attachment.organization != null) add('Organization', attachment.organization);
+      const next = [...entities.values()], companies = next.filter(entity => entity.model === 'Organization');
+      if (collection === 'documents' && companies.length > 1) throw Error('Document has conflicting company associations');
+      for (const entity of next) {
+        const parent = await db.collection(parentCollections[entity.model]).findOne({ _id: entity.id }, { session, projection: { customer: 1 } });
+        if (!parent) throw Error('Missing attachment entity');
+        if (entity.model === 'LimitedPartner' && id(parent.customer) !== customer) throw Error('Cross-customer attachment association');
+      }
+      // Keep only existing legacy ownership references current during a merge.
+      // Do not initialize entities or infer a new Document.organization value.
+      if (kind === 'Organization' && collection === 'documents' && attachment.organization != null && id(attachment.organization) === sourceId) {
+        records.push({ collection, attachment, set: { organization: oid(targetId) } });
+      }
+      if (parentIds.includes(id(attachment._id))) mirrors[collection].push(attachment._id);
+    }
+  }
+  await owners(db, session, ownerIds);
+  return { records, mirrors, kind, targetId };
+}
+async function apply(db, session, plan) {
+  for (const { collection, attachment, set } of plan.records) {
+    const result = await db.collection(collection).updateOne({ _id: attachment._id, customer: attachment.customer }, { $set: set, $inc: { __v: 1 } }, { session });
+    if (result.matchedCount !== 1) throw Error('Attachment changed during merge');
+  }
+  const result = await db.collection(parentCollections[plan.kind]).updateOne({ _id: oid(plan.targetId) }, { $set: plan.mirrors }, { session });
+  if (result.matchedCount !== 1) throw Error('Attachment merge target changed');
+}
+module.exports = { prepare, apply };

package/lib/controls/customer-settings-gate.js

@@ -0,0 +1,79 @@
+'use strict';
+
+// Customer-only runtime fencing. Missing or obsolete controls fail closed.
+const KEY = 'customer-settings-v1';
+const collection = db => db.collection('migrationcontrols');
+const sources = new Set(['customer']);
+const drained = { $or: [{ activeLifecycle: { $exists: false } }, { activeLifecycle: { $size: 0 } }] };
+function check(expected) {
+  if (!expected || !Number.isSafeInteger(expected.epoch) || expected.epoch < 0 ||
+      expected.rolling === true || !sources.has(expected.source) || !['open', 'paused'].includes(expected.state)) {
+    throw Error('Invalid settings gate expectation');
+  }
+}
+async function initialize(db) {
+  await collection(db).updateOne({ _id: KEY }, { $setOnInsert: {
+    state: 'paused', source: 'customer', epoch: 0, fence: 0, activeLifecycle: []
+  } }, { upsert: true, writeConcern: { w: 'majority' } });
+  return collection(db).findOne({ _id: KEY });
+}
+async function transition(db, expected, next) {
+  check(expected);
+  if (!next || !sources.has(next.source) || !['open', 'paused'].includes(next.state) ||
+      (next.source !== expected.source && (expected.state !== 'paused' || next.state !== 'paused'))) {
+    throw Error('Source changes require a paused settings gate');
+  }
+  const result = await collection(db).updateOne({ _id: KEY, epoch: expected.epoch,
+    source: expected.source, state: expected.state,
+    ...(expected.state === 'paused' && (next.state === 'open' || next.source !== expected.source) ? drained : {}) }, {
+    $set: { state: next.state, source: next.source }, $inc: { epoch: 1, fence: 1 }
+  }, { writeConcern: { w: 'majority' } });
+  if (result.matchedCount !== 1) throw Error('Settings gate changed or lifecycle work has not drained');
+  return { ...next, epoch: expected.epoch + 1 };
+}
+async function fence(db, session, expected) {
+  check(expected);
+  if (!session?.inTransaction()) throw Error('Settings gate requires a transaction');
+  const result = await collection(db).updateOne({ _id: KEY, epoch: expected.epoch,
+    state: expected.state, source: expected.source, ...(expected.state === 'paused' ? drained : {}) }, { $inc: { fence: 1 } }, { session });
+  if (result.matchedCount !== 1) throw Error('Settings writes paused, gate changed or lifecycle work has not drained');
+}
+// Writers read the current epoch inside their transaction, then write the row.
+// A simultaneous pause either waits for this transaction or forces its retry.
+async function writer(db, session, source) {
+  if (!sources.has(source)) throw Error('Invalid settings source');
+  const current = await collection(db).findOne({ _id: KEY }, { session });
+  if (!current || current.state !== 'open' || current.source !== source) throw Error('Settings writes paused or source mismatch');
+  await fence(db, session, current);
+}
+// Lifecycle operations share the Customer settings transaction fence.
+// Admission and the job insert/claim must commit in the same transaction.
+async function admit(db, session) {
+  if (!session?.inTransaction()) throw Error('Lifecycle admission requires a transaction');
+  const current = await collection(db).findOne({ _id: KEY }, { session });
+  if (!current) throw Error('Settings gate is not installed');
+  check(current);
+  if (current.activeLifecycle !== undefined && !Array.isArray(current.activeLifecycle)) throw Error('Invalid lifecycle drain state');
+  if (current.state !== 'open') throw Object.assign(Error('Lifecycle admission paused'), { code: 'SETTINGS_PAUSED' });
+  await fence(db, session, current);
+  return current;
+}
+function token(value) {
+  if (typeof value !== 'string' || !/^[a-zA-Z0-9-]{1,100}$/.test(value)) throw Error('Invalid lifecycle token');
+}
+async function holdLifecycle(db, session, owner) {
+  token(owner);
+  await admit(db, session);
+  await collection(db).updateOne({ _id: KEY }, { $addToSet: { activeLifecycle: owner } }, { session });
+}
+// No timeout expiry: a stale heartbeat is not proof an external operation ended.
+// Worker calls this only after a clean completion/yield. Failure/crash tokens
+// require operator evidence that the invocation and outstanding work have ended.
+async function releaseLifecycle(db, owner) {
+  token(owner);
+  const result = await collection(db).updateOne({ _id: KEY }, {
+    $pull: { activeLifecycle: owner }, $inc: { fence: 1 }
+  }, { writeConcern: { w: 'majority' } });
+  if (result.matchedCount !== 1) throw Error('Settings gate is not installed');
+}
+module.exports = { KEY, initialize, transition, fence, writer, admit, holdLifecycle, releaseLifecycle };

package/lib/leadMerge.js

@@ -0,0 +1,100 @@
+'use strict';
+const crypto = require('node:crypto');
+const { Types: { ObjectId } } = require('mongoose');
+const text = value => String(value?._id || value || '').toLowerCase();
+function id(value) {
+  const result = text(value);
+  if (!/^[a-f0-9]{24}$/.test(result)) throw Error('Invalid lead merge reference');
+  return result;
+}
+const oid = value => new ObjectId(id(value));
+const unique = values => [...new Set(values.map(id))];
+const equal = (a, b) => JSON.stringify([...a].sort()) === JSON.stringify([...b].sort());
+const key = (customer, organization) => customer + '/' + organization;
+
+// Capture/validate before source deletion. The caller holds the same transaction
+// fence as Lead writers and customer deletion/downgrade admission throughout.
+async function prepare(db, session, kind, target, source) {
+  const targetId = id(target), sourceId = id(source);
+  const companyFilter = kind === 'Organization' ? { _id: { $in: [oid(targetId), oid(sourceId)] } } :
+    { $or: ['first', 'second'].map(slot => ({ ['chairs.' + slot]: { $in: [oid(targetId), oid(sourceId)] } })) };
+  const leadFilter = kind === 'Organization' ? { organization: { $in: [oid(targetId), oid(sourceId)] } } :
+    { people: { $in: [oid(targetId), oid(sourceId)] } };
+  const leads = await db.collection('leads').find(leadFilter, { session }).toArray();
+  const companyIds = leads.map(lead => oid(lead.organization));
+  const companies = await db.collection('organizations').find({ $or: [companyFilter, { _id: { $in: companyIds } }] },
+    { session, projection: { chairs: 1 } }).toArray();
+  const groups = new Map(), owners = new Set();
+  for (const company of companies) {
+    if (company.chairs != null && !Array.isArray(company.chairs)) throw Error('Malformed legacy lead array');
+    for (const chair of company.chairs || []) {
+      const customer = id(chair.customer), organization = id(company);
+      if (Object.keys(chair).some(field => !['_id', 'customer', 'first', 'second'].includes(field))) throw Error('Unknown legacy lead fields');
+      const groupKey = key(customer, organization);
+      if (!groups.has(groupKey)) groups.set(groupKey, { customer, organization, people: [], lead: null });
+      const group = groups.get(groupKey);
+      group.people = unique([...group.people, ...[chair.first, chair.second].filter(value => value != null)]);
+      owners.add(customer);
+    }
+  }
+  // Read all groups on affected companies, including empty/new Lead records.
+  const existing = await db.collection('leads').find({ organization: { $in: companies.map(company => company._id) } }, { session }).toArray();
+  for (const lead of existing) {
+    const customer = id(lead.customer), organization = id(lead.organization), groupKey = key(customer, organization);
+    if (typeof lead.customer === 'string' || typeof lead.organization === 'string' || !Array.isArray(lead.people)) throw Error('Malformed Lead storage');
+    if (!groups.has(groupKey)) groups.set(groupKey, { customer, organization, people: [], lead: null });
+    const group = groups.get(groupKey), people = unique(lead.people);
+    if (group.lead || people.length !== lead.people.length || !equal(group.people, people)) throw Error('Lead merge requires reconciled stores');
+    group.lead = lead; owners.add(customer);
+  }
+  if (leads.some(lead => !companies.some(company => id(company) === id(lead.organization)))) throw Error('Lead company is missing');
+  for (const customer of owners) {
+    const tenant = await db.collection('customers').findOne({ _id: oid(customer) }, { session, projection: { organization: 1 } });
+    if (!tenant || id(tenant.organization) !== customer) throw Error('Customer identity mismatch');
+    const variants = [oid(customer), customer];
+    const jobs = await db.collection('deletions').find({ kind: 'job', $or: [{ _id: { $in: variants } }, { customerId: { $in: variants } }] }, { session }).toArray();
+    if (jobs.some(job => job.operation === 'delete' || !['completed', 'scheduled'].includes(job.status))) throw Error('Customer lifecycle blocks lead merge');
+  }
+  return { kind, targetId, sourceId, groups, companies };
+}
+
+async function apply(db, session, plan) {
+  const output = new Map();
+  for (const group of plan.groups.values()) {
+    const organization = plan.kind === 'Organization' ? plan.targetId : group.organization;
+    const people = plan.kind === 'Person' ? unique(group.people.map(person => person === plan.sourceId ? plan.targetId : person)) : group.people;
+    const groupKey = key(group.customer, organization);
+    if (!output.has(groupKey)) output.set(groupKey, { customer: group.customer, organization, people: [], originals: [] });
+    const next = output.get(groupKey);
+    next.people = unique([...next.people, ...people]); next.originals.push(group);
+  }
+  for (const group of output.values()) {
+    const peopleFound = await db.collection('people').countDocuments({ _id: { $in: group.people.map(oid) } }, { session });
+    if (peopleFound !== group.people.length) throw Error('Lead Person is missing after merge');
+    const keep = group.originals.find(original => original.organization === group.organization && original.lead)?.lead || group.originals.find(original => original.lead)?.lead;
+    for (const original of group.originals) {
+      if (original.lead && original.lead !== keep) await db.collection('leads').deleteOne({ _id: original.lead._id }, { session });
+    }
+    if (keep) {
+      const result = await db.collection('leads').updateOne({ _id: keep._id }, { $set: {
+        organization: oid(group.organization), people: group.people.map(oid)
+      }, $inc: { __v: 1 } }, { session });
+      if (result.matchedCount !== 1) throw Error('Lead changed during merge');
+    } else {
+      const stable = crypto.createHash('sha256').update(`customer-data-v1:${group.customer}/organizations/${group.organization}/chairs`).digest('hex').slice(0, 24);
+      await db.collection('leads').insertOne({ _id: new ObjectId(stable), customer: oid(group.customer), organization: oid(group.organization),
+        people: group.people.map(oid), __v: 0 }, { session });
+    }
+  }
+  const organizations = plan.kind === 'Organization' ? [plan.targetId] : plan.companies.map(id);
+  for (const organization of organizations) {
+    const chairs = [];
+    for (const group of output.values()) if (group.organization === organization) {
+      for (let i = 0; i < group.people.length; i += 2) chairs.push({ _id: new ObjectId(), customer: oid(group.customer), first: oid(group.people[i]),
+        ...(group.people[i + 1] ? { second: oid(group.people[i + 1]) } : {}) });
+    }
+    const result = await db.collection('organizations').updateOne({ _id: oid(organization) }, { $set: { chairs } }, { session });
+    if (result.matchedCount !== 1) throw Error('Lead company changed during merge');
+  }
+}
+module.exports = { prepare, apply };

package/lib/organizations.js

@@ -136,7 +136,7 @@ var updateReferences = function updateReferences(context, target, source, merged
   // Do not update cap tables, financials or rounds as these are complicated
   // and get cleaned and updated on each pull anyway
 
-  async.parallel([
+  (context.mergeSession ? async.series : async.parallel)([
     updateCapTables.bind(context, newOrgId, oldOrgId),
     updateDeals.bind(context, newOrgId, oldOrgId, customerId),
     updateFinancials.bind(context, newOrgId, oldOrgId),
@@ -153,6 +153,7 @@ var updateCapTables = function updateCapTables(newOrgId, oldOrgId, cb) {
   logger.writeToInfoLog('  Updating cap tables...');
 
   var self = this;
+  cb = _.once(cb);
 
   // Get all cap tables for this org
   self.CapTable.collection.find({ 'organization': oldOrgId }).toArray().then(function(items) {
@@ -165,6 +166,7 @@ var updateCapTables = function updateCapTables(newOrgId, oldOrgId, cb) {
     _.each(items, function(item) {
       tasks.push({
         id: item._id,
+        customer: item.customer,
         update: { $set: { organization: newOrgId } }
       });
     });
@@ -177,8 +179,9 @@ var updateCapTables = function updateCapTables(newOrgId, oldOrgId, cb) {
         if (result) { updated.push(result); }
         return callback(null, result);
       }, function(err) { return callback(err, null); });
-    }, 8);
+    }, self.mergeSession ? 1 : 8);
 
+    queue.error = function(err) { queue.kill(); cb(err, null); };
     queue.drain = function() { return cb(null, updated); };
 
     queue.push(tasks);
@@ -192,6 +195,7 @@ var updateDeals = function updateDeals(newOrgId, oldOrgId, customerId, cb) {
   logger.writeToInfoLog('  Updating deals...');
 
   var self = this;
+  cb = _.once(cb);
 
   // Get all deals for this org
   self.Deal.collection.find({ 'organization': oldOrgId }).toArray().then(function(items) {
@@ -204,6 +208,7 @@ var updateDeals = function updateDeals(newOrgId, oldOrgId, customerId, cb) {
     _.each(items, function(item) {
       tasks.push({
         id: item._id,
+        customer: item.customer,
         update: { $set: { organization: newOrgId } }
       });
     });
@@ -212,13 +217,14 @@ var updateDeals = function updateDeals(newOrgId, oldOrgId, customerId, cb) {
 
     var queue = async.queue(function(task, callback) {
 
-      self.Deal.modifyById(task.id, task.update, { CUSTOMER_ID: customerId }, function(err, result) {
+      self.Deal.modifyById(task.id, task.update, { CUSTOMER_ID: task.customer }, function(err, result) {
         if (err) { return callback(err, null); }
         else if (result) { updated.push(result); }
         return callback(null, result);
       });
-    }, 8);
+    }, self.mergeSession ? 1 : 8);
 
+    queue.error = function(err) { queue.kill(); cb(err, null); };
     queue.drain = function() { return cb(null, updated); };
 
     queue.push(tasks);
@@ -232,6 +238,7 @@ var updateFinancials = function updateFinancials(newOrgId, oldOrgId, cb) {
   logger.writeToInfoLog('  Updating financials...');
 
   var self = this;
+  cb = _.once(cb);
 
   // Get all financials for this org
   self.Financials.collection.find({ 'organization': oldOrgId }).toArray().then(function(items) {
@@ -244,6 +251,7 @@ var updateFinancials = function updateFinancials(newOrgId, oldOrgId, cb) {
     _.each(items, function(item) {
       tasks.push({
         id: item._id,
+        customer: item.customer,
         update: { $set: { organization: newOrgId } }
       });
     });
@@ -256,8 +264,9 @@ var updateFinancials = function updateFinancials(newOrgId, oldOrgId, cb) {
         if (result) { updated.push(result); }
         return callback(null, result);
       }, function(err) { return callback(err, null); });
-    }, 8);
+    }, self.mergeSession ? 1 : 8);
 
+    queue.error = function(err) { queue.kill(); cb(err, null); };
     queue.drain = function() { return cb(null, updated); };
 
     queue.push(tasks);
@@ -271,6 +280,7 @@ var updateMessages = function updateMessages(newOrgId, oldOrgId, cb) {
   logger.writeToInfoLog('  Updating messages...');
 
   var self = this;
+  cb = _.once(cb);
 
   self.Message.collection.find({ 'organization': oldOrgId }).toArray().then(function(items) {
 
@@ -282,6 +292,7 @@ var updateMessages = function updateMessages(newOrgId, oldOrgId, cb) {
     _.each(items, function(item) {
       tasks.push({
         id: item._id,
+        customer: item.customer,
         update: { $set: { organization: newOrgId } }
       });
     });
@@ -294,8 +305,9 @@ var updateMessages = function updateMessages(newOrgId, oldOrgId, cb) {
         else if (result) { updated.push(result); }
         return callback(null, result);
       });
-    }, 8);
+    }, self.mergeSession ? 1 : 8);
 
+    queue.error = function(err) { queue.kill(); cb(err, null); };
     queue.drain = function() { return cb(null, updated); };
 
     queue.push(tasks);
@@ -309,6 +321,7 @@ var updateNews = function updateNews(newOrgId, oldOrgId, cb) {
   logger.writeToInfoLog('  Updating news...');
 
   var self = this;
+  cb = _.once(cb);
 
   self.News.collection.find({ 'org': oldOrgId }).toArray().then(function(items) {
 
@@ -320,6 +333,7 @@ var updateNews = function updateNews(newOrgId, oldOrgId, cb) {
     _.each(items, function(item) {
       tasks.push({
         id: item._id,
+        customer: item.customer,
         update: { $set: { org: newOrgId } }
       });
     });
@@ -332,8 +346,9 @@ var updateNews = function updateNews(newOrgId, oldOrgId, cb) {
         else if (result) { updated.push(result); }
         return callback(null, result);
       });
-    }, 8);
+    }, self.mergeSession ? 1 : 8);
 
+    queue.error = function(err) { queue.kill(); cb(err, null); };
     queue.drain = function() { return cb(null, updated); };
 
     queue.push(tasks);
@@ -347,6 +362,7 @@ var updateOrganizations = function updateOrganizations(newOrgId, oldOrgId, cb) {
   logger.writeToInfoLog('  Updating orgs...');
 
   var self = this;
+  cb = _.once(cb);
 
   self.Organization.collection.find({ $or: [{ 'merged': oldOrgId }, { 'operating.acquired.public.by': oldOrgId }, { 'operating.acquired.private.by': oldOrgId }, { 'related': oldOrgId }] }).toArray().then(function(items) {
 
@@ -377,6 +393,7 @@ var updateOrganizations = function updateOrganizations(newOrgId, oldOrgId, cb) {
 
       tasks.push({
         id: item._id,
+        customer: item.customer,
         update: {
           $set: setObj
         }
@@ -392,8 +409,9 @@ var updateOrganizations = function updateOrganizations(newOrgId, oldOrgId, cb) {
         else if (result) { updated.push(result); }
         return callback(null, result);
       });
-    }, 8);
+    }, self.mergeSession ? 1 : 8);
 
+    queue.error = function(err) { queue.kill(); cb(err, null); };
     queue.drain = function() { return cb(null, updated); };
 
     queue.push(tasks);
@@ -407,6 +425,7 @@ var updateRounds = function updateRounds(newOrgId, oldOrgId, cb) {
   logger.writeToInfoLog('  Updating rounds...');
 
   var self = this;
+  cb = _.once(cb);
 
   // Get all rounds for this org
   self.Round.collection.find({ 'organization': oldOrgId }).toArray().then(function(items) {
@@ -419,6 +438,7 @@ var updateRounds = function updateRounds(newOrgId, oldOrgId, cb) {
     _.each(items, function(item) {
       tasks.push({
         id: item._id,
+        customer: item.customer,
         update: { $set: { organization: newOrgId } }
       });
     });
@@ -431,8 +451,9 @@ var updateRounds = function updateRounds(newOrgId, oldOrgId, cb) {
         if (result) { updated.push(result); }
         return callback(null, result);
       }, function(err) { return callback(err, null); });
-    }, 8);
+    }, self.mergeSession ? 1 : 8);
 
+    queue.error = function(err) { queue.kill(); cb(err, null); };
     queue.drain = function() { return cb(null, updated); };
 
     queue.push(tasks);