@dhyasama/totem-merge 7.1.2 → 7.1.3

package/lib/customerMergeGuard.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const { Types: { ObjectId } } = require('mongoose');
+
+// Use Organization's own connection, including for callers that have not
+// registered the additive Customer model. Never filter on active/premium:
+// inactive tenant identities must remain protected too.
+module.exports = function customerMergeGuard(Organization, target, source, cb) {
+  const blocked = () => new Error('Customer organizations cannot be merged');
+  if ([target, source].some(org => org && org.customer && org.customer.totemUrl)) {
+    return cb(blocked(), null);
+  }
+
+  let lookup;
+  try {
+    const ids = [target, source].map(org => {
+      const id = org && (org._id || org.id);
+      if (!id || !/^[a-f0-9]{24}$/i.test(String(id))) {
+        throw new Error('A valid organization ID is required before merging');
+      }
+      return new ObjectId(String(id));
+    });
+    lookup = Organization.db.collection('customers').findOne({
+      $or: [{ _id: { $in: ids } }, { organization: { $in: ids } }]
+    }, { projection: { _id: 1 } });
+  } catch (err) {
+    return cb(err, null);
+  }
+  // Separate success and rejection handlers so a consumer callback exception
+  // cannot cause a second callback invocation.
+  return Promise.resolve(lookup).then(
+    customer => cb(customer ? blocked() : null, null),
+    err => cb(err, null)
+  );
+};

package/lib/organizations.js

@@ -5,6 +5,7 @@ let _ = require('underscore');
 let helpers = require('./helpers');
 let mongoose = require('mongoose');
 let ObjectId = mongoose.Types.ObjectId;
+let verifyCustomerMerge = require('./customerMergeGuard');
 let logger;
 
 var merge = function merge(context, target, source, mergedBy, customerId, cb) {
@@ -38,7 +39,7 @@ var merge = function merge(context, target, source, mergedBy, customerId, cb) {
 
   async.series([
 
-    verifyOkToMerge.bind(null, target, source),
+    verifyCustomerMerge.bind(null, context.Organization, target, source),
 
     // Merge the source into the target
     mergeSourceIntoTarget.bind(null, target, source),
@@ -113,21 +114,6 @@ var mergeSourceIntoTarget = function mergeEntities(target, source, cb) {
 
 };
 
-var verifyOkToMerge = function verifyOkToMerge(target, source, cb) {
-
-  logger.writeToInfoLog('Verify ok to merge...');
-
-  // Cannot merge if target is a customer
-  if (target && target.customer && target.customer.totemUrl) { return cb(true, null); }
-
-  // Cannot merge if source is a customer
-  else if (source && source.customer && source.customer.totemUrl) { return cb(true, null); }
-
-  // Ok to merge
-  else { return cb(null, null); }
-
-};
-
 var updateReferences = function updateReferences(context, target, source, mergedBy, customerId, cb) {
 
   logger.writeToInfoLog('Update references...');
@@ -455,4 +441,4 @@ var updateRounds = function updateRounds(newOrgId, oldOrgId, cb) {
 
 };
 
-module.exports.merge = merge;
+module.exports.merge = merge;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhyasama/totem-merge",
-  "version": "7.1.2",
+  "version": "7.1.3",
   "description": "Org and person merging package",
   "main": "index.js",
   "scripts": {
@@ -27,7 +27,7 @@
     "mongoose": "^8.24.3"
   },
   "devDependencies": {
-    "@dhyasama/totem-models": "14.0.0",
+    "@dhyasama/totem-models": "15.1.0",
     "mocha": "^12.0.2",
     "mocha-mongoose": "^1.1.1",
     "should": "^8.2.2"

package/test/customer-merge-guard.mongo.test.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const mongoose = require('mongoose');
+const guard = require('../lib/customerMergeGuard');
+const uri = process.env.CUSTOMER_MERGE_TEST_URI;
+
+(uri ? describe : describe.skip)('customer merge guard with MongoDB', function() {
+  let connection, Organization, customers;
+  before(async function() {
+    if (!/^mongodb:\/\/127\.0\.0\.1:\d+\/customer_merge_guard_test(?:\?|$)/.test(uri)) {
+      throw new Error('Only the local customer_merge_guard_test database is allowed');
+    }
+    connection = await mongoose.createConnection(uri).asPromise();
+    Organization = connection.model('MergeGuardOrganization', new mongoose.Schema({ name: String }));
+    customers = connection.collection('customers');
+  });
+  after(async function() { if (connection) await connection.close(); });
+
+  it('blocks either tenant identity including inactive records and permits shared companies', async function() {
+    const target = new Organization({ name: 'Synthetic target' });
+    const source = new Organization({ name: 'Synthetic source' });
+    const run = () => new Promise(resolve => guard(Organization, target, source, resolve));
+    try {
+      assert.equal(await run(), null);
+      for (const org of [source, target]) {
+        await customers.insertOne({ _id: org._id, organization: org._id, settings: { active: false } });
+        assert.match((await run()).message, /cannot be merged/);
+        await customers.deleteOne({ _id: org._id });
+      }
+      assert.equal(await run(), null);
+    } finally {
+      await customers.deleteMany({ _id: { $in: [target._id, source._id] } });
+    }
+  });
+});

package/test/customer-merge-guard.test.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const { Types: { ObjectId } } = require('mongoose');
+const guard = require('../lib/customerMergeGuard');
+const merge = require('../lib/organizations').merge;
+
+function fixture(records = [], failure) {
+  const target = { _id: new ObjectId() };
+  const source = { _id: new ObjectId() };
+  const calls = [];
+  const Organization = { db: { collection(name) {
+    assert.equal(name, 'customers');
+    return { async findOne(query, options) {
+      calls.push(query);
+      assert.deepEqual(options, { projection: { _id: 1 } });
+      if (failure) throw failure;
+      return records.find(record => query.$or.some(clause => {
+        const key = Object.keys(clause)[0];
+        return clause[key].$in.some(id => String(id) === String(record[key]));
+      })) || null;
+    } };
+  } } };
+  const run = () => new Promise(resolve => guard(Organization, target, source, err => resolve(err)));
+  return { target, source, Organization, calls, run, records };
+}
+
+describe('customer organization merge guard', function() {
+  for (const side of ['target', 'source']) {
+    for (const active of [true, false]) {
+      it(`blocks ${active ? 'active' : 'inactive'} Customer on ${side} without legacy settings`, async function() {
+        const f = fixture();
+        f.records.push({ _id: f[side]._id, settings: { active } });
+        assert.match((await f.run()).message, /cannot be merged/);
+      });
+    }
+    it(`preserves the legacy ${side} guard without a database lookup`, async function() {
+      const f = fixture();
+      f[side].customer = { totemUrl: 'fixture' };
+      assert.match((await f.run()).message, /cannot be merged/);
+      assert.equal(f.calls.length, 0);
+    });
+  }
+  it('also protects the organization reference if a Customer id is inconsistent', async function() {
+    const f = fixture();
+    f.records.push({ _id: new ObjectId(), organization: f.source._id });
+    assert.match((await f.run()).message, /cannot be merged/);
+  });
+  it('allows two shared organizations without Customer records', async function() {
+    const f = fixture();
+    assert.equal(await f.run(), null);
+    assert.equal(f.calls.length, 1);
+  });
+  it('fails closed when the lookup fails', async function() {
+    const failure = new Error('Database unavailable');
+    assert.equal(await fixture([], failure).run(), failure);
+  });
+  it('fails closed before querying an invalid identity', async function() {
+    const f = fixture();
+    f.source._id = 'invalid';
+    assert.match((await f.run()).message, /valid organization ID/);
+    assert.equal(f.calls.length, 0);
+  });
+  it('blocks the public merge pipeline before mutation or deletion', async function() {
+    const f = fixture();
+    f.records.push({ _id: f.source._id });
+    const before = JSON.stringify([f.target, f.source]);
+    const context = {
+      Organization: f.Organization,
+      logger: { writeToInfoLog() {} }
+    };
+    const err = await new Promise(resolve => merge(context, f.target, f.source, 'test', new ObjectId(), resolve));
+    assert.match(err.message, /cannot be merged/);
+    assert.equal(JSON.stringify([f.target, f.source]), before);
+  });
+});