@dhyasama/totem-merge 7.2.0 → 7.3.0

package/lib/leadMerge.js

@@ -9,7 +9,6 @@ function id(value) {
 }
 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
@@ -25,18 +24,6 @@ async function prepare(db, session, kind, target, source) {
   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) {
@@ -44,7 +31,8 @@ async function prepare(db, session, kind, target, source) {
     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');
+    if (group.lead || people.length !== lead.people.length) throw Error('Duplicate Lead record or person');
+    group.people = people;
     group.lead = lead; owners.add(customer);
   }
   if (leads.some(lead => !companies.some(company => id(company) === id(lead.organization)))) throw Error('Lead company is missing');

package/lib/privateRecordMerge.js

@@ -11,24 +11,12 @@ function groups(entries) {
   }
   return result;
 }
-function tagValue(entries) {
-  return [...groups(entries)].map(([name, entry]) => [name, [...entry.items].sort()]).sort((a, b) => a[0].localeCompare(b[0]));
-}
 function valuationValue(entry) {
   // Stored values only. Do not fill absent values using schema defaults.
   const result = {};
   for (const key of ['date', 'valuation', 'pricePerShare', 'method']) if (own(entry, key)) result[key] = entry[key];
   return result;
 }
-function sameEntries(actual, expected) {
-  const unmatched = [...expected];
-  for (const entry of actual) {
-    const position = unmatched.findIndex(candidate => equal(candidate, entry));
-    if (position < 0) return false;
-    unmatched.splice(position, 1);
-  }
-  return unmatched.length === 0;
-}
 async function prepare(db, session, kind, target, source) {
   const ids = [target._id, source._id], targetId = id(target._id), ownerIds = [];
   const plan = { targetId, kind, records: [], mirrors: {} };
@@ -48,26 +36,6 @@ async function prepare(db, session, kind, target, source) {
       if (!entities.has(entity)) entities.set(entity, []);
       entities.get(entity).push(row);
     }
-    if (kind === 'Organization') {
-      for (const parent of parents) {
-        const legacy = array(parent[field]), entity = id(parent._id);
-        const customers = new Set(legacy.map(entry => id(entry.customer)));
-        for (const [customer, entities] of buckets) if (entities.has(entity)) customers.add(customer);
-        for (const customer of customers) {
-          const old = legacy.filter(entry => id(entry.customer) === customer);
-          const current = buckets.get(customer)?.get(entity) || [];
-          let matches;
-          if (collection === 'tags') matches = current.length === 1 && equal(tagValue(current[0].groups), tagValue(old));
-          else matches = sameEntries(current.map(valuationValue), old.map(valuationValue));
-          if (!matches) throw Error('Private merge requires reconciled ' + collection);
-          // A legacy valuation ID is part of its identity, not just its value.
-          if (collection === 'valuations' && current.some(row => row.legacyId &&
-              !old.some(entry => entry._id && id(entry._id) === id(row.legacyId) && equal(valuationValue(entry), valuationValue(row))))) {
-            throw Error('Valuation legacy identity mismatch');
-          }
-        }
-      }
-    }
     const mirror = [];
     for (const [customer, entities] of buckets) {
       const targetRows = entities.get(targetId) || [], sourceRows = entities.get(id(source._id)) || [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhyasama/totem-merge",
-  "version": "7.2.0",
+  "version": "7.3.0",
   "description": "Org and person merging package",
   "main": "index.js",
   "scripts": {

package/test/atomic-lead-merge.mongo.test.js

@@ -67,12 +67,18 @@ const uri = process.env.ATOMIC_MERGE_TEST_URI;
     assert.equal(chairs.filter(chair => String(chair.customer) === String(tenant)).length, 2);
     const before = await state(); await call('organizations'); assert.deepEqual(await state(), before);
   });
-  it('initializes missing additive groups without losing unlimited legacy leads', async () => {
+  it('does not resurrect legacy leads when native groups are absent', async () => {
     await db.collection('leads').deleteMany({});
     await call('organizations');
-    const lead = await db.collection('leads').findOne({ customer: tenant, organization: target });
-    assert.deepEqual(lead.people.map(String).sort(), people.slice(0, 4).map(String).sort());
-    assert.deepEqual((await db.collection('leads').findOne({ customer: other })).people, [people[4]]);
+    assert.equal(await db.collection('leads').countDocuments({}), 0);
+    assert.deepEqual((await db.collection('organizations').findOne({ _id: target })).chairs, []);
+  });
+  it('merges native lead edits without restoring people from stale mirrors', async () => {
+    await db.collection('leads').updateOne({ customer: tenant, organization: source }, { $set: { people: [] } });
+    const expected = await db.collection('leads').findOne({ customer: tenant, organization: target });
+    await call('organizations');
+    const actual = await db.collection('leads').findOne({ customer: tenant, organization: target });
+    assert.deepEqual(actual.people, expected.people);
   });
   it('preserves zero-lead groups without introducing a placeholder person', async () => {
     await db.collection('organizations').updateMany({}, { $set: { chairs: [] } });
@@ -112,9 +118,9 @@ const uri = process.env.ATOMIC_MERGE_TEST_URI;
     }
     assert.equal(String((await db.collection('documents').findOne({})).createdBy), String(people[0]));
   });
-  it('blocks destination drift, deletion receipts and tenant identity merges before source deletion', async () => {
+  it('blocks deletion receipts and tenant identity merges before source deletion', async () => {
     await db.collection('leads').updateOne({ customer: tenant, organization: source }, { $set: { people: [] } });
-    let before = await state(); await assert.rejects(call('organizations'), /reconciled/); assert.deepEqual(await state(), before);
+    let before;
     await db.collection('leads').updateOne({ customer: tenant, organization: source }, { $set: { people: [people[1], people[2], people[3]] } });
     await db.collection('deletions').insertOne({ _id: tenant, kind: 'job', operation: 'delete', status: 'completed' });
     before = await state(); await assert.rejects(call('organizations'), /lifecycle/); assert.deepEqual(await state(), before);
@@ -193,7 +199,7 @@ const uri = process.env.ATOMIC_MERGE_TEST_URI;
     assert(parent.customFields.some(entry => Array.isArray(entry.fields.sourceOnly)));
     assert(parent.customFields.some(entry => String(entry.customer) === String(other)));
   });
-  it('ignores deferred CustomField drift but still rejects unreconciled Tags', async () => {
+  it('ignores deferred CustomField drift', async () => {
     await privateFixture();
     await db.collection('customfields').updateOne({ customer: tenant, 'entity.id': source }, { $set: { 'fields.shared': 999 } });
     const original = await db.collection('customfields').find({}).sort({ _id: 1 }).toArray();
@@ -206,11 +212,23 @@ const uri = process.env.ATOMIC_MERGE_TEST_URI;
     const before = await state();
     await assert.rejects(call('organizations'), /Conflicting embedded custom fields/); assert.deepEqual(await state(), before);
   });
-  it('blocks unreconciled Tags without modifying any record', async () => {
+  it('does not resurrect stale Tag mirrors during a merge', async () => {
     await privateFixture();
     await db.collection('tags').updateOne({ customer: tenant, 'entity.id': source }, { $set: { groups: [] } });
-    const before = await state();
-    await assert.rejects(call('organizations'), /reconciled tags/); assert.deepEqual(await state(), before);
+    const expected = await db.collection('tags').findOne({ customer: tenant, 'entity.id': target });
+    await call('organizations');
+    assert.deepEqual((await db.collection('tags').findOne({ customer: tenant, 'entity.id': target })).groups, expected.groups);
+  });
+  it('retains native valuation edits when mirrors contain stale amounts', async () => {
+    await privateFixture();
+    await db.collection('valuations').updateMany({ organization: source }, { $set: { valuation: 12345 } });
+    const expected = await db.collection('valuations').find({ organization: source }).toArray();
+    await call('organizations');
+    for (const row of expected) {
+      const actual = await db.collection('valuations').findOne({ _id: row._id });
+      assert.equal(actual.valuation, 12345);
+      assert.equal(String(actual.organization), String(target));
+    }
   });
   it('blocks colliding valuation identities rather than losing an occurrence', async () => {
     await privateFixture();