tango-app-api-payment-subscription 3.5.30 → 3.5.31

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tango-app-api-payment-subscription",
-    "version": "3.5.30",
+    "version": "3.5.31",
     "description": "paymentSubscription",
     "main": "index.js",
     "type": "module",

package/src/controllers/invoice.controller.js

@@ -15,7 +15,7 @@ import * as basepricingService from '../services/basePrice.service.js';
 import * as paymentAccountService from '../services/paymentAccount.service.js';
 import { symbolFor, roundAmount, wordFor } from '../utils/currency.js';
 import { invoiceStatusEnum } from '../dtos/validation.dtos.js';
-import { findOneApplicationDefault } from '../services/applicationDefault.service.js';
+import { findOneApplicationDefault, nextCounterValue } from '../services/applicationDefault.service.js';
 import * as assignedStoreService from '../services/assignedStore.service.js';
 import * as bankTransactionService from '../services/bankTransaction.service.js';
 import { getInrRate, getAdditionalProducts } from './brandsBilling.controller.js';
@@ -3252,15 +3252,29 @@ async function transitionInvoiceStatus( req, res, fromStatus, toStatus ) {
     if ( fromStatus === 'pendingFinance' && String( invoice.invoice || '' ).startsWith( 'DRAFT-' ) ) {
       const FY = getCurrentFinancialYear();
       const prefix = invoicePrefixFor( invoice.advanceInvoice, invoice.advancePeriod );
-      const previous = await invoiceService.findandsort(
+      // Reserve the next number ATOMICALLY. Bulk finance-approval fires many
+      // requests in parallel; the old read-max-then-write approach let them all
+      // read the same max and mint the SAME number. nextCounterValue uses an
+      // atomic $inc on a per-series counter, so simultaneous callers each get a
+      // distinct number. The counter is lazily seeded (once, on first use) from
+      // the current DB max of this prefix+FY series so existing numbers are
+      // never reused.
+      // Numeric max of existing invoiceIndex for this series. invoiceIndex is a
+      // STRING in the schema and historical values are zero-padded ('00569'),
+      // so a Mongo sort would compare lexically — compute the true numeric max
+      // in JS instead. Used only to seed the counter on its first use.
+      const previous = await invoiceService.find(
           { invoice: { $regex: `^${prefix}${FY}-` } },
-          {},
-          { invoiceIndex: -1 },
+          { invoiceIndex: 1 },
       );
-      let realNo = 1;
-      if ( previous && previous.length > 0 && previous[0].invoiceIndex != null ) {
-        realNo = Number( previous[0].invoiceIndex ) + 1;
+      let dbMax = 0;
+      for ( const p of ( previous || [] ) ) {
+        const n = Number( p.invoiceIndex );
+        if ( !Number.isNaN( n ) && n > dbMax ) {
+          dbMax = n;
+        }
       }
+      const realNo = await nextCounterValue( 'invoiceCounter', `${prefix}${FY}`, dbMax );
       update.invoice = `${prefix}${FY}-${String( realNo ).padStart( 5, '0' )}`;
       update.invoiceIndex = realNo;
       update.tempIndex = null;

package/src/services/applicationDefault.service.js

@@ -11,3 +11,32 @@ export async function upsertApplicationDefault( query, payload ) {
       { new: true, upsert: true },
   );
 }
+
+// Atomically reserve the next value for a named counter and return it.
+// Uses a single findOneAndUpdate($inc) — MongoDB serialises concurrent
+// increments on the same document, so simultaneous callers (e.g. bulk invoice
+// finance-approval) each get a distinct number, eliminating the read-max-then-
+// write race that produced duplicate invoice numbers.
+//
+// `subType` scopes the counter (e.g. 'INV-26-27'). `seedFrom` is the current
+// real-world max (e.g. the highest existing invoiceIndex for that series); it
+// initialises the counter ONLY on first creation via $setOnInsert, so existing
+// numbers are never re-used. Returns the reserved integer.
+export async function nextCounterValue( type, subType, seedFrom = 0 ) {
+  // Two-step, both atomic:
+  // 1) Ensure the counter doc exists, seeded to the current max WITHOUT
+  //    incrementing (upsert + $setOnInsert). If it already exists this is a
+  //    no-op and never lowers a counter that has moved past the seed.
+  await model.applicationDefaultModel.updateOne(
+      { type, subType },
+      { $setOnInsert: { type, subType, data: { seq: Number( seedFrom ) || 0 } } },
+      { upsert: true },
+  );
+  // 2) Atomically claim the next value.
+  const doc = await model.applicationDefaultModel.findOneAndUpdate(
+      { type, subType },
+      { $inc: { 'data.seq': 1 } },
+      { new: true },
+  );
+  return doc?.data?.seq;
+}