@dainamite/cpq 0.4.0 → 0.6.0

package/src/modules/cpq/services/__tests__/cpqQuotingService.arc.test.ts

@@ -1,5 +1,11 @@
 import { DefaultCpqQuotingService } from '../cpqQuotingService'
 import { createMockEm, TEST_SCOPE as SCOPE } from './_helpers/mockEm'
+import { SalesQuote, SalesQuoteLine } from '@open-mercato/core/modules/sales/data/entities'
+import {
+  CpqProductOffering,
+  CpqQuoteConfiguration,
+  CpqQuoteLineConfiguration,
+} from '../../data/entities'
 
 /**
  * XD-250 ARC unit tests for cpqQuotingService — focused on the
@@ -141,3 +147,234 @@ describe('transitionStatus → validateArcQuote hook', () => {
     expect(em.findOne).toHaveBeenCalledTimes(4)
   })
 })
+
+// ─── Amend mirror-line pricing on recalculation ──────────────────
+
+
+function makePricedService() {
+  const em = Object.assign(createMockEm(), {
+    assign: jest.fn((entity: Record<string, unknown>, updates: Record<string, unknown>) =>
+      Object.assign(entity, updates),
+    ),
+    fork: jest.fn(),
+  })
+  em.fork.mockReturnValue(em)
+  const pricingService = { resolveProductCharges: jest.fn() }
+  const validationService = {
+    validateOfferingConfiguration: jest.fn().mockResolvedValue({ valid: true, errors: [] }),
+    validateRelationships: jest.fn().mockResolvedValue([]),
+  }
+  const service = new DefaultCpqQuotingService({
+    em: em as never,
+    cpqPricingService: pricingService as never,
+    cpqValidationService: validationService as never,
+    cpqProductService: {} as never,
+    salesDocumentNumberGenerator: {} as never,
+  })
+  return { em, pricingService, service }
+}
+
+function mrcCharge(price: number) {
+  return {
+    chargeCode: 'monthly_port_fee',
+    chargeName: 'Monthly Port Fee',
+    chargeType: 'mrc',
+    pricingMethod: 'flat',
+    unitPrice: price,
+    quantity: 1,
+    totalPrice: price,
+    currencyCode: 'USD',
+    adjustments: [],
+  }
+}
+
+function amendFixture(configuration: Record<string, unknown>) {
+  const cpqConfig = { ...ARC_QUOTE_BASE, quoteType: 'amend', organizationId: SCOPE.organizationId, tenantId: SCOPE.tenantId }
+  const lineConfig = {
+    id: 'lc-1',
+    quoteLineId: 'ql-1',
+    quoteConfigurationId: 'cpq-1',
+    offeringId: 'off-1',
+    productId: 'prod-1',
+    specId: null,
+    action: 'modify',
+    parentLineId: null,
+    startDate: null,
+    termMonths: null,
+    endDate: null,
+    configuration,
+    quantity: 1,
+    charges: [mrcCharge(100)],
+    nrcTotal: '0',
+    mrcTotal: '100',
+    usageEstimates: null,
+    usageTotalEstimated: null,
+    validationErrors: null,
+    isConfigured: true,
+    targetSubscriptionId: 'sub-1',
+    sourceSubscriptionItemId: 'item-1',
+  }
+  return { cpqConfig, lineConfig }
+}
+
+function routeEm(
+  em: ReturnType<typeof makePricedService>['em'],
+  cpqConfig: Record<string, unknown>,
+  lineConfig: Record<string, unknown>,
+) {
+  em.findOne.mockImplementation(async (entity: unknown) => {
+    if (entity === CpqQuoteConfiguration) return cpqConfig
+    if (entity === SalesQuote) return { id: 'sq-1', currencyCode: 'USD', quoteNumber: 'Q-001' }
+    if (entity === SalesQuoteLine) return { id: 'ql-1' }
+    if (entity === CpqProductOffering) return { id: 'off-1', name: 'GIX Access Port', offeringType: 'simple' }
+    if (entity === CpqQuoteLineConfiguration) return lineConfig
+    return null
+  })
+  em.find.mockImplementation(async (entity: unknown) => {
+    if (entity === CpqQuoteLineConfiguration) return [lineConfig]
+    return []
+  })
+}
+
+describe('recalculate → Amend mirror lines', () => {
+  it('re-prices a legacy Amend mirror line (created before the frozen marker) at the current standard price', async () => {
+    const { em, pricingService, service } = makePricedService()
+    const { cpqConfig, lineConfig } = amendFixture({
+      port_size: '1G',
+      _arcMirroredFromItemId: 'item-1',
+      _arcMirroredName: 'GIX Access Port',
+    })
+    routeEm(em, cpqConfig, lineConfig)
+    pricingService.resolveProductCharges.mockResolvedValue([mrcCharge(120)])
+
+    await service.recalculate('cpq-1', { save: true }, SCOPE)
+
+    expect(pricingService.resolveProductCharges).toHaveBeenCalledTimes(1)
+    expect(lineConfig.mrcTotal).toBe('120')
+  })
+
+  it('keeps a frozen Amend mirror line at its stored price without calling the pricing engine', async () => {
+    const { em, pricingService, service } = makePricedService()
+    const { cpqConfig, lineConfig } = amendFixture({
+      port_size: '1G',
+      _arcMirroredFromItemId: 'item-1',
+      _arcMirroredName: 'GIX Access Port',
+      _arcPriceFrozen: true,
+    })
+    routeEm(em, cpqConfig, lineConfig)
+    pricingService.resolveProductCharges.mockResolvedValue([mrcCharge(120)])
+
+    const result = await service.recalculate('cpq-1', { save: true }, SCOPE)
+
+    expect(pricingService.resolveProductCharges).not.toHaveBeenCalled()
+    expect(lineConfig.mrcTotal).toBe('100')
+    expect(result.lines[0].mrcTotal).toBe(100)
+  })
+})
+
+describe('updateQuoteItem → frozen Amend mirror lines', () => {
+  const FROZEN_CFG = {
+    port_size: '1G',
+    _arcMirroredFromItemId: 'item-1',
+    _arcMirroredName: 'GIX Access Port',
+    _arcPriceFrozen: true,
+  }
+
+  it('stays frozen when the UI resubmits an unchanged configuration', async () => {
+    const { em, pricingService, service } = makePricedService()
+    const { cpqConfig, lineConfig } = amendFixture({ ...FROZEN_CFG })
+    routeEm(em, cpqConfig, lineConfig)
+    pricingService.resolveProductCharges.mockResolvedValue([mrcCharge(120)])
+
+    await service.updateQuoteItem('cpq-1', 'ql-1', { configuration: { port_size: '1G' }, quantity: 1 }, SCOPE)
+
+    expect(pricingService.resolveProductCharges).not.toHaveBeenCalled()
+    expect(lineConfig.configuration).toMatchObject({ _arcPriceFrozen: true, _arcMirroredFromItemId: 'item-1' })
+    expect(lineConfig.mrcTotal).toBe('100')
+  })
+
+  it('unfreezes and re-prices when the configuration changes', async () => {
+    const { em, pricingService, service } = makePricedService()
+    const { cpqConfig, lineConfig } = amendFixture({ ...FROZEN_CFG })
+    routeEm(em, cpqConfig, lineConfig)
+    pricingService.resolveProductCharges.mockResolvedValue([mrcCharge(150)])
+
+    await service.updateQuoteItem('cpq-1', 'ql-1', { configuration: { port_size: '10G' } }, SCOPE)
+
+    expect(pricingService.resolveProductCharges).toHaveBeenCalled()
+    expect((lineConfig.configuration as Record<string, unknown>)._arcPriceFrozen).toBeUndefined()
+    expect(lineConfig.configuration).toMatchObject({ port_size: '10G', _arcMirroredFromItemId: 'item-1' })
+    expect(lineConfig.mrcTotal).toBe('150')
+  })
+
+  it('unfreezes and re-prices when the quantity changes', async () => {
+    const { em, pricingService, service } = makePricedService()
+    const { cpqConfig, lineConfig } = amendFixture({ ...FROZEN_CFG })
+    routeEm(em, cpqConfig, lineConfig)
+    pricingService.resolveProductCharges.mockResolvedValue([mrcCharge(110)])
+
+    await service.updateQuoteItem('cpq-1', 'ql-1', { configuration: { port_size: '1G' }, quantity: 2 }, SCOPE)
+
+    expect(pricingService.resolveProductCharges).toHaveBeenCalled()
+    expect(lineConfig.mrcTotal).toBe('220')
+  })
+
+  it('unfreezes and marks the line re-priced when the UI echoes the stored markers with a changed attribute', async () => {
+    const { em, pricingService, service } = makePricedService()
+    const { cpqConfig, lineConfig } = amendFixture({ ...FROZEN_CFG })
+    routeEm(em, cpqConfig, lineConfig)
+    pricingService.resolveProductCharges.mockResolvedValue([mrcCharge(150)])
+
+    // The quote page sends back the configuration it loaded — markers included.
+    await service.updateQuoteItem('cpq-1', 'ql-1', { configuration: { ...FROZEN_CFG, port_size: '10G' }, quantity: 1 }, SCOPE)
+
+    const stored = lineConfig.configuration as Record<string, unknown>
+    expect(pricingService.resolveProductCharges).toHaveBeenCalled()
+    expect(stored._arcPriceFrozen).toBeUndefined()
+    expect(stored._arcRepriced).toBe(true)
+    expect(stored._arcMirroredFromItemId).toBe('item-1')
+    expect(lineConfig.mrcTotal).toBe('150')
+  })
+
+  it('stays frozen when the UI echoes the stored markers unchanged', async () => {
+    const { em, pricingService, service } = makePricedService()
+    const { cpqConfig, lineConfig } = amendFixture({ ...FROZEN_CFG })
+    routeEm(em, cpqConfig, lineConfig)
+
+    await service.updateQuoteItem('cpq-1', 'ql-1', { configuration: { ...FROZEN_CFG }, quantity: 1 }, SCOPE)
+
+    expect(pricingService.resolveProductCharges).not.toHaveBeenCalled()
+    expect((lineConfig.configuration as Record<string, unknown>)._arcRepriced).toBeUndefined()
+  })
+
+  it('never lets a client set the freeze marker', async () => {
+    const { em, pricingService, service } = makePricedService()
+    const { cpqConfig, lineConfig } = amendFixture({ port_size: '1G', _arcMirroredFromItemId: 'item-1', _arcMirroredName: 'GIX Access Port' })
+    routeEm(em, cpqConfig, lineConfig)
+    pricingService.resolveProductCharges.mockResolvedValue([mrcCharge(120)])
+
+    await service.updateQuoteItem('cpq-1', 'ql-1', { configuration: { port_size: '1G', _arcPriceFrozen: true } }, SCOPE)
+
+    expect(pricingService.resolveProductCharges).toHaveBeenCalled()
+    expect((lineConfig.configuration as Record<string, unknown>)._arcPriceFrozen).toBeUndefined()
+  })
+})
+
+describe('recalculate → freeze marker outside Amend mirror lines', () => {
+  it('ignores the freeze marker on a line of a new (non-ARC) quote', async () => {
+    const { em, pricingService, service } = makePricedService()
+    const { cpqConfig, lineConfig } = amendFixture({
+      port_size: '1G',
+      _arcMirroredFromItemId: 'item-1',
+      _arcPriceFrozen: true,
+    })
+    cpqConfig.quoteType = 'new'
+    routeEm(em, cpqConfig, lineConfig)
+    pricingService.resolveProductCharges.mockResolvedValue([mrcCharge(120)])
+
+    await service.recalculate('cpq-1', { save: true }, SCOPE)
+
+    expect(pricingService.resolveProductCharges).toHaveBeenCalledTimes(1)
+    expect(lineConfig.mrcTotal).toBe('120')
+  })
+})

package/src/modules/cpq/services/__tests__/cpqQuotingService.test.ts

@@ -1,7 +1,9 @@
+import { LockMode } from '@mikro-orm/core'
 import { DefaultCpqQuotingService, QuotingError } from '../cpqQuotingService'
 import type { TenantScope } from '../types'
 
 interface MockEm {
+  transactional: jest.MockedFunction<(callback: (em: MockEm) => Promise<unknown>) => Promise<unknown>>
   findOne: jest.MockedFunction<(entity: unknown, where: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>>
   find: jest.MockedFunction<
     (entity: unknown, where: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown[]>
@@ -32,8 +34,9 @@ interface MockNumberGenerator {
 
 function createMockEm(): MockEm {
   const em: MockEm = {
+    transactional: jest.fn(),
     findOne: jest.fn(),
-    find: jest.fn(),
+    find: jest.fn().mockResolvedValue([]),
     create: jest.fn().mockImplementation((_e, data: Record<string, unknown>) => ({ ...data, id: data.id ?? 'gen-id' })),
     persist: jest.fn(),
     assign: jest.fn().mockImplementation((entity: Record<string, unknown>, updates: Record<string, unknown>) => {
@@ -43,6 +46,7 @@ function createMockEm(): MockEm {
     flush: jest.fn().mockResolvedValue(undefined),
     fork: jest.fn(),
   }
+  em.transactional.mockImplementation((callback) => callback(em))
   em.fork.mockReturnValue(em)
   return em
 }
@@ -584,7 +588,7 @@ describe('DefaultCpqQuotingService.recalculate', () => {
     expect(em.flush).not.toHaveBeenCalled()
   })
 
-  it('forks the EM when save=true (write path uses isolated UoW)', async () => {
+  it('locks the quote in a transaction when save=true', async () => {
     const { em, service } = makeService()
     em.findOne
       .mockResolvedValueOnce({
@@ -604,7 +608,9 @@ describe('DefaultCpqQuotingService.recalculate', () => {
 
     await service.recalculate('cpq-1', { save: true }, SCOPE)
 
-    expect(em.fork).toHaveBeenCalledTimes(1)
+    expect(em.transactional).toHaveBeenCalledTimes(1)
+    expect(em.fork).toHaveBeenCalledWith({ clear: true, useContext: false })
+    expect(em.findOne.mock.calls[0][2]).toMatchObject({ lockMode: LockMode.PESSIMISTIC_WRITE })
   })
 
   it('marks status "new" when no lines exist (auto-managed status)', async () => {
@@ -655,4 +661,53 @@ describe('DefaultCpqQuotingService.recalculate', () => {
 
     expect(cpqConfig.cpqStatus).toBe('with_customer') // unchanged
   })
+
+  it.each(['accepted', 'rejected', 'cancelled'])(
+    'rejects a saved recalculation on a %s (terminal) quote with 409 and persists nothing',
+    async (cpqStatus) => {
+      const { em, service } = makeService()
+      em.findOne.mockResolvedValueOnce({
+        id: 'cpq-1',
+        quoteId: 'sq-1',
+        cpqStatus,
+        customerId: 'cust',
+        currencyCode: 'USD',
+        version: 1,
+        parentQuoteId: null,
+        validationResult: null,
+        pricingSummary: null,
+        quoteContext: null,
+      })
+
+      await expect(service.recalculate('cpq-1', { save: true }, SCOPE)).rejects.toMatchObject({
+        status: 409,
+        message: `Cannot recalculate quote in '${cpqStatus}' status`,
+      })
+      expect(em.flush).not.toHaveBeenCalled()
+    },
+  )
+
+  it('still allows a read-only (save=false) recalculation on an accepted quote', async () => {
+    const { em, service } = makeService()
+    em.findOne
+      .mockResolvedValueOnce({
+        id: 'cpq-1',
+        quoteId: 'sq-1',
+        cpqStatus: 'accepted',
+        customerId: 'cust',
+        currencyCode: 'USD',
+        version: 1,
+        parentQuoteId: null,
+        validationResult: null,
+        pricingSummary: null,
+        quoteContext: null,
+      })
+      .mockResolvedValueOnce({ id: 'sq-1', currencyCode: 'USD', quoteNumber: 'Q-0001' })
+    em.find.mockResolvedValueOnce([])
+
+    const result = await service.recalculate('cpq-1', { save: false }, SCOPE)
+
+    expect(result.cpqStatus).toBe('accepted')
+    expect(em.flush).not.toHaveBeenCalled()
+  })
 })

package/src/modules/cpq/services/__tests__/errorBrands.test.ts

@@ -0,0 +1,72 @@
+/**
+ * QuotingError / OrderError must be recognisable across duplicate copies of
+ * their module. In a production Next build the page layer and the route layer
+ * each bundle @dainamite/cpq, and the DI container is shared via globalThis,
+ * so a route handler can catch an error built from the *other* copy. With
+ * `instanceof` that silently turned a typed 404 into a 500.
+ *
+ * `jest.isolateModules` loads a second, independent copy of each module —
+ * the same condition the bundler creates.
+ */
+import { QuotingError, isQuotingError } from '../cpqQuotingService'
+import { OrderError, isOrderError } from '../cpqOrderService'
+
+type QuotingModule = typeof import('../cpqQuotingService')
+type OrderModule = typeof import('../cpqOrderService')
+
+function loadIsolated<T>(load: () => T): T {
+  let mod: T | undefined
+  jest.isolateModules(() => {
+    mod = load()
+  })
+  if (!mod) throw new Error('[internal] isolated module failed to load')
+  return mod
+}
+
+describe('isQuotingError', () => {
+  it('recognises an error thrown by a separate copy of the module', () => {
+    const other = loadIsolated<QuotingModule>(() => require('../cpqQuotingService'))
+    const err = new other.QuotingError(404, 'Quote not found')
+
+    // The precondition the guard exists for: the class identities differ.
+    expect(other.QuotingError).not.toBe(QuotingError)
+    expect(err instanceof QuotingError).toBe(false)
+
+    expect(isQuotingError(err)).toBe(true)
+    if (isQuotingError(err)) expect(err.status).toBe(404)
+  })
+
+  it('accepts a same-copy error', () => {
+    expect(isQuotingError(new QuotingError(409, 'conflict'))).toBe(true)
+  })
+
+  it.each([
+    ['a plain Error', new Error('x')],
+    ['an OrderError', new OrderError(404, 'x')],
+    ['a look-alike with the same name and status', Object.assign(new Error('x'), { name: 'QuotingError', status: 404 })],
+    ['null', null],
+    ['a string', 'QuotingError'],
+  ])('rejects %s', (_label, value) => {
+    expect(isQuotingError(value)).toBe(false)
+  })
+})
+
+describe('isOrderError', () => {
+  it('recognises an error thrown by a separate copy of the module', () => {
+    const other = loadIsolated<OrderModule>(() => require('../cpqOrderService'))
+    const err = new other.OrderError(404, 'Order not found')
+
+    expect(other.OrderError).not.toBe(OrderError)
+    expect(err instanceof OrderError).toBe(false)
+
+    expect(isOrderError(err)).toBe(true)
+  })
+
+  it.each([
+    ['a plain Error', new Error('x')],
+    ['a QuotingError', new QuotingError(404, 'x')],
+    ['undefined', undefined],
+  ])('rejects %s', (_label, value) => {
+    expect(isOrderError(value)).toBe(false)
+  })
+})

package/src/modules/cpq/services/__tests__/orderPricingSummary.test.ts

@@ -0,0 +1,50 @@
+import { summarizeOrderPricing } from '../orderPricingSummary'
+
+const charge = (chargeType: 'nrc' | 'mrc', list: number, offer: number, standard = offer) => ({
+  chargeCode: `${chargeType}-fee`,
+  chargeName: `${chargeType} fee`,
+  chargeType,
+  pricingMethod: 'flat',
+  unitPrice: offer,
+  quantity: 1,
+  totalPrice: offer,
+  listUnitPrice: list,
+  listTotalPrice: list,
+  standardUnitPrice: standard,
+  standardTotalPrice: standard,
+  currencyCode: 'USD',
+})
+
+describe('summarizeOrderPricing', () => {
+  it('reproduces the quote figures: list totals, deal value over the term and total depth', () => {
+    const summary = summarizeOrderPricing([
+      { lineId: 'l1', quantity: 1, termMonths: 12, configuration: {}, charges: [charge('nrc', 890, 0), charge('mrc', 1200, 1050)] },
+    ], 'new', 'USD')
+
+    expect(summary.listNrcTotal).toBe(890)
+    expect(summary.listMrcTotal).toBe(1200)
+    expect(summary.dealValue).toEqual({ list: 890 + 1200 * 12, standard: 1050 * 12, offer: 1050 * 12 })
+    expect(summary.discountDepth.total).toBeCloseTo(1 - 12600 / 15290)
+    expect(summary).not.toHaveProperty('snapshotHash')
+    expect(summary).not.toHaveProperty('hasTimeBasedAdjustments')
+  })
+
+  it('leaves ARC mirror lines out of deal value, as on the quote', () => {
+    const summary = summarizeOrderPricing([
+      { lineId: 'kept', quantity: 1, termMonths: 12, configuration: { _arcMirroredFromItemId: 'item-1' }, charges: [charge('mrc', 400, 400)] },
+      { lineId: 'new', quantity: 1, termMonths: 12, configuration: {}, charges: [charge('mrc', 1200, 1050)] },
+    ], 'amend', 'USD')
+
+    expect(summary.dealValue.offer).toBe(1050 * 12)
+    expect(summary.listMrcTotal).toBe(1600)
+  })
+
+  it('tolerates legacy stored charges without code, type or waterfall fields', () => {
+    const summary = summarizeOrderPricing([
+      { lineId: 'l1', quantity: 2, termMonths: null, configuration: null, charges: [{ unitPrice: 50, totalPrice: 50 }] },
+    ], 'new', 'USD')
+
+    expect(summary.listMrcTotal).toBe(100)
+    expect(summary.dealValue.offer).toBe(50 * 2 * 12)
+  })
+})

package/src/modules/cpq/services/__tests__/pricingSnapshot.test.ts

@@ -0,0 +1,62 @@
+import { computeWaterfallSummary, type SnapshotLine } from '../priceAdjustments/pricingSnapshot'
+import { resolveManualAdjustments } from '../priceAdjustments/resolveManualAdjustments'
+import type { PriceAdjustment } from '../../data/price-adjustments'
+const line: SnapshotLine = {
+  lineId: 'line', quantity: 2, termMonths: 3,
+  charges: [{ chargeCode: 'mrc', chargeName: 'MRC', chargeType: 'mrc', pricingMethod: 'flat', currencyCode: 'USD', quantity: 1,
+    listUnitPrice: 100, listTotalPrice: 100, standardUnitPrice: 90, standardTotalPrice: 90, unitPrice: 80, totalPrice: 80,
+    adjustments: [
+      { origin: 'rule', ruleCode: 'rule', ruleName: 'Rule', ruleType: 'discount_absolute', value: 10, unitPriceBefore: 100, unitPriceAfter: 90, delta: -10 },
+      { origin: 'manual', ruleCode: 'manual', ruleName: 'Manual', ruleType: 'discount_absolute', value: 10, unitPriceBefore: 90, unitPriceAfter: 80, delta: -10 },
+    ] }],
+}
+const row: PriceAdjustment = { id: 'a', quoteLineId: 'line', level: 'charge', chargeCode: 'mrc', adjustmentType: 'price_override', value: 80, currencyCode: 'USD', reasonCode: 'competitive_match' }
+it('includes line quantity, term horizon and separate rule/manual totals', () => {
+  const summary = computeWaterfallSummary([line], [row], 'USD')
+  expect(summary).toMatchObject({ listMrcTotal: 200, standardMrcTotal: 180, ruleDiscountTotal: 20, manualDiscountTotal: 20, dealValue: { list: 600, standard: 540, offer: 480 } })
+  expect(summary.discountDepth.manual).toBeCloseTo(1 - 480 / 540)
+  expect(summary.discountDepth.total).toBeCloseTo(0.2)
+})
+it('counts NRC once and excludes usage even over a long horizon', () => {
+  const nrc = { ...line.charges[0], chargeType: 'nrc' as const }
+  const usage = { ...line.charges[0], chargeType: 'usage' as const }
+  expect(computeWaterfallSummary([{ ...line, termMonths: 24, charges: [nrc, usage] }], [], 'USD').dealValue).toEqual({ list: 200, standard: 180, offer: 160 })
+})
+it('uses 12 months without a term; excludes unchanged ARC mirrors from deal value', () => {
+  expect(computeWaterfallSummary([{ ...line, termMonths: null }], [], 'USD').dealValue.list).toBe(2400)
+  expect(computeWaterfallSummary([{ ...line, includeInDeal: false }], [], 'USD').dealValue).toEqual({ list: 0, standard: 0, offer: 0 })
+})
+it('represents zero baselines by null and rule markups by negative depth', () => {
+  expect(computeWaterfallSummary([], [], 'USD').discountDepth).toEqual({ rule: null, manual: null, total: null, maxLineManual: null })
+  const marked = { ...line.charges[0], standardTotalPrice: 110, totalPrice: 110 }
+  expect(computeWaterfallSummary([{ ...line, charges: [marked] }], [], 'USD').discountDepth.rule).toBeCloseTo(-0.1)
+})
+it('hash ignores ordering, reason notes and authors but tracks price, quantity, horizon and adjustment changes', () => {
+  const other = { ...line, lineId: 'other' }
+  const initial = computeWaterfallSummary([line, other], [row], 'USD').snapshotHash
+  expect(computeWaterfallSummary([other, line], [{ ...row, reasonNote: 'Edited', reasonCode: 'other', createdByUserId: 'user' }], 'USD').snapshotHash).toBe(initial)
+  for (const changed of [{ ...line, quantity: 3 }, { ...line, termMonths: 6 }, { ...line, charges: [{ ...line.charges[0], totalPrice: 70 }] }]) {
+    expect(computeWaterfallSummary([changed, other], [row], 'USD').snapshotHash).not.toBe(initial)
+  }
+  expect(computeWaterfallSummary([line, other], [{ ...row, value: 70 }], 'USD').snapshotHash).not.toBe(initial)
+})
+it('normalizes legacy waterfall fields to the same hash and never changes legacy discountTotal', () => {
+  const legacy = { ...line.charges[0] }
+  delete legacy.listUnitPrice; delete legacy.listTotalPrice; delete legacy.standardUnitPrice; delete legacy.standardTotalPrice
+  const result = computeWaterfallSummary([{ ...line, charges: [legacy] }], [row], 'USD')
+  expect(result.snapshotHash).toBe(computeWaterfallSummary([line], [row], 'USD').snapshotHash)
+  expect(result).not.toHaveProperty('discountTotal')
+})
+it('stable hash and money after repeated resolver passes', () => {
+  const input = [{ ...line, parentLineId: null, enginePriced: true, mirrored: false }]
+  const first = resolveManualAdjustments(input, [row], 'USD')
+  const second = resolveManualAdjustments(first.lines, [row], 'USD')
+  expect(computeWaterfallSummary(first.lines.map((priced) => ({ ...priced, quantity: 2 })), [row], 'USD')).toEqual(computeWaterfallSummary(second.lines.map((priced) => ({ ...priced, quantity: 2 })), [row], 'USD'))
+})
+it('hash tracks deal eligibility and normalizes omitted eligibility to true', () => {
+  const baseline = computeWaterfallSummary([line], [], 'USD')
+  expect(computeWaterfallSummary([{ ...line, includeInDeal: true }], [], 'USD').snapshotHash).toBe(baseline.snapshotHash)
+  const excluded = computeWaterfallSummary([{ ...line, includeInDeal: false }], [], 'USD')
+  expect(excluded.dealValue.offer).toBe(0)
+  expect(excluded.snapshotHash).not.toBe(baseline.snapshotHash)
+})

package/src/modules/cpq/services/__tests__/quoteAdjustmentLifecycle.test.ts

@@ -0,0 +1,35 @@
+import { cloneQuoteAdjustments, removeQuoteLineTree } from '../priceAdjustments/quoteAdjustmentLifecycle'
+import { CpqQuoteLineConfiguration, CpqQuotePriceAdjustment } from '../../data/entities'
+import { SalesQuoteLine } from '@open-mercato/core/modules/sales/data/entities'
+const scope = { tenantId: 'tenant', organizationId: 'org' }
+it('clones rows with new ids and remapped lines without changing reasons or the source', async () => {
+  const source = { id: 'adjustment', quoteLineId: 'old-line', level: 'charge', chargeCode: 'fee', adjustmentType: 'price_override', value: '80', currencyCode: 'USD', reasonCode: 'inactive_reason', createdByUserId: 'author', windowKind: 'relative', fromMonth: 1, toMonth: null, isActive: true }
+  const created: Array<Record<string, unknown>> = []
+  const em = { find: jest.fn().mockResolvedValue([source]), create: jest.fn((_entity: unknown, values: Record<string, unknown>) => { created.push(values); return values }), persist: jest.fn() }
+  await cloneQuoteAdjustments(em as never, 'source', { id: 'target', quoteId: 'new-sales' }, new Map([['old-line', 'new-line']]), scope)
+  expect(created[0]).toMatchObject({ quoteLineId: 'new-line', quoteConfigurationId: 'target', quoteId: 'new-sales', reasonCode: 'inactive_reason', createdByUserId: 'author', ...scope })
+  expect(created[0].id).not.toBe(source.id)
+  expect(source.quoteLineId).toBe('old-line')
+  expect(em.find).toHaveBeenCalledWith(CpqQuotePriceAdjustment, expect.objectContaining({ quoteConfigurationId: 'source', ...scope, deletedAt: null }), expect.objectContaining({ limit: 500 }))
+})
+it('keeps missing targets invalid with a fresh orphan id rather than a source-quote pointer', async () => {
+  const source = { id: 'adjustment', quoteLineId: 'missing', reasonCode: 'promotion' }
+  const create = jest.fn((_entity: unknown, values: Record<string, unknown>) => values)
+  await cloneQuoteAdjustments({ find: jest.fn().mockResolvedValue([source]), create, persist: jest.fn() } as never, 'source', { id: 'target', quoteId: 'sales' }, new Map(), scope)
+  expect(create.mock.calls[0][1].quoteLineId).not.toBe('missing')
+})
+it('soft-deletes the whole nested bundle subtree and its adjustments before returning', async () => {
+  const root = { id: 'root-config', quoteLineId: 'root', parentLineId: null, deletedAt: null }
+  const child = { id: 'child-config', quoteLineId: 'child', parentLineId: 'root', deletedAt: null }
+  const grandchild = { id: 'grandchild-config', quoteLineId: 'grandchild', parentLineId: 'child', deletedAt: null }
+  const unrelated = { id: 'other-config', quoteLineId: 'other', parentLineId: null, deletedAt: null }
+  const sales = [{ id: 'root', deletedAt: null }, { id: 'child', deletedAt: null }, { id: 'grandchild', deletedAt: null }]
+  const adjustments = [{ id: 'adjustment', quoteLineId: 'grandchild', deletedAt: null, isActive: true }]
+  const em = { find: jest.fn(async (entity: unknown) => entity === CpqQuoteLineConfiguration ? [root, child, grandchild, unrelated] : entity === SalesQuoteLine ? sales : adjustments), flush: jest.fn().mockResolvedValue(undefined) }
+  await removeQuoteLineTree(em as never, 'quote', root as never, scope)
+  for (const row of [root, child, grandchild, ...sales, ...adjustments]) expect(row.deletedAt).toBeInstanceOf(Date)
+  expect(unrelated.deletedAt).toBe(null)
+  expect(adjustments[0].isActive).toBe(false)
+  expect(em.flush).toHaveBeenCalled()
+  expect(em.find).toHaveBeenCalledWith(CpqQuotePriceAdjustment, expect.objectContaining({ quoteConfigurationId: 'quote', quoteLineId: { $in: ['root', 'child', 'grandchild'] }, ...scope }), expect.anything())
+})

package/src/modules/cpq/services/__tests__/quoteAdjustmentPricing.test.ts

@@ -0,0 +1,65 @@
+import { DefaultCpqQuotingService } from '../cpqQuotingService'
+import { CpqProductOffering, CpqQuoteConfiguration, CpqQuoteLineConfiguration, CpqQuotePriceAdjustment } from '../../data/entities'
+import { SalesQuote, SalesQuoteLine } from '@open-mercato/core/modules/sales/data/entities'
+const scope = { tenantId: '11111111-1111-4111-8111-111111111111', organizationId: '22222222-2222-4222-8222-222222222222' }
+const ids = { quote: '33333333-3333-4333-8333-333333333333', sales: '44444444-4444-4444-8444-444444444444', line: '55555555-5555-4555-8555-555555555555', adjustment: '66666666-6666-4666-8666-666666666666', user: '77777777-7777-4777-8777-777777777777' }
+function setup() {
+  const quote = { id: ids.quote, quoteId: ids.sales, customerId: 'customer', quoteType: 'new', cpqStatus: 'new', currencyCode: 'USD', pricingRevision: 0, ...scope }
+  const sales = { id: ids.sales, quoteNumber: 'Q-1', currencyCode: 'USD' }
+  const line = { id: 'config', quoteLineId: ids.line, quoteConfigurationId: ids.quote, offeringId: 'offer', productId: null, parentLineId: null, quantity: 2, configuration: {}, nrcTotal: '0', mrcTotal: '200', isConfigured: true, charges: [], usageEstimates: null, ...scope }
+  const salesLine = { id: ids.line, totalNetAmount: '200' }
+  const row = { id: ids.adjustment, quoteConfigurationId: ids.quote, quoteId: ids.sales, quoteLineId: ids.line, level: 'charge', chargeCode: 'fee', chargeTypeFilter: null, adjustmentType: 'discount_absolute', value: '20', currencyCode: 'USD', reasonCode: 'competitive_match', reasonNote: null, windowKind: 'relative', fromMonth: 1, toMonth: null, createdByUserId: ids.user, ...scope }
+  const findOne = jest.fn(async (entity: unknown) => entity === CpqQuoteConfiguration ? quote : entity === SalesQuote ? sales : entity === CpqProductOffering ? { id: 'offer', name: 'Offering', offeringType: 'simple' } : entity === SalesQuoteLine ? salesLine : null)
+  const find = jest.fn(async (entity: unknown) => entity === CpqQuoteLineConfiguration ? [line] : entity === CpqQuotePriceAdjustment ? [row] : [])
+  const tx = { findOne, find, assign: jest.fn((entity: object, updates: object) => Object.assign(entity, updates)), flush: jest.fn().mockResolvedValue(undefined) }
+  const em = { ...tx, fork: jest.fn(), transactional: jest.fn(async (execute: (manager: typeof tx) => Promise<unknown>) => execute(tx)) }
+  em.fork.mockReturnValue(em)
+  const pricing = { resolveProductCharges: jest.fn().mockResolvedValue([{ chargeCode: 'fee', chargeName: 'Fee', chargeType: 'mrc', pricingMethod: 'flat', unitPrice: 100, totalPrice: 100, quantity: 1, currencyCode: 'USD', adjustments: [] }]) }
+  const service = new DefaultCpqQuotingService({ em: em as never, cpqPricingService: pricing as never, cpqValidationService: { validateOfferingConfiguration: async () => ({ errors: [] }), validateRelationships: async () => [] } as never, cpqProductService: {} as never, salesDocumentNumberGenerator: {} as never })
+  return { service, quote, line, row, salesLine, em, tx }
+}
+it('applies stored adjustments to quote/sales totals exactly once and preserves deprecated discountTotal', async () => {
+  const { service, quote, line, salesLine, em } = setup()
+  const first = await service.recalculate(ids.quote, { save: true }, scope)
+  expect(first.lines[0].mrcTotal).toBe(160)
+  expect(first.lines[0].charges[0]).toMatchObject({ listTotalPrice: 100, standardTotalPrice: 100, totalPrice: 80 })
+  expect(first.pricingSummary).toMatchObject({ mrcTotal: 160, manualDiscountTotal: 40, ruleDiscountTotal: 0, discountTotal: 0 })
+  expect(first.pricingRevision).toBe(1)
+  expect(salesLine.totalNetAmount).toBe('160')
+  expect(line.mrcTotal).toBe('160')
+  const second = await service.recalculate(ids.quote, { save: true }, scope)
+  expect(second.lines[0].charges).toEqual(first.lines[0].charges)
+  expect(second.pricingSummary.snapshotHash).toBe(first.pricingSummary.snapshotHash)
+  expect(quote.pricingRevision).toBe(2)
+  expect(em.transactional).toHaveBeenCalledTimes(2)
+})
+it('keeps an invalid row, marks the line and quote incomplete, and charges standard', async () => {
+  const { service, row } = setup()
+  row.chargeCode = 'removed-charge'
+  const result = await service.recalculate(ids.quote, { save: true }, scope)
+  expect(result.cpqStatus).toBe('incomplete')
+  expect(result.lines[0].isConfigured).toBe(false)
+  expect(result.lines[0].mrcTotal).toBe(200)
+  expect(result.lines[0].validationErrors).toEqual([expect.objectContaining({ message: 'ADJUSTMENT_TARGET_MISSING' })])
+  expect(row.chargeCode).toBe('removed-charge')
+})
+it('previews saved adjustments without changing a managed entity, revision or persisted snapshot', async () => {
+  const { service, quote, line, tx, em } = setup()
+  const result = await service.recalculate(ids.quote, { save: false }, scope)
+  expect(result.lines[0].mrcTotal).toBe(160)
+  expect(quote.cpqStatus).toBe('new')
+  expect(quote.pricingRevision).toBe(0)
+  expect(quote).not.toHaveProperty('pricingSummary')
+  expect(line.mrcTotal).toBe('200')
+  expect(line.charges).toEqual([])
+  expect(tx.flush).not.toHaveBeenCalled()
+  expect(tx.assign).not.toHaveBeenCalled()
+  expect(em.transactional).not.toHaveBeenCalled()
+})
+it('loads adjustments only once per recalculation and scopes the query', async () => {
+  const { service, tx } = setup()
+  await service.recalculate(ids.quote, { save: false }, scope)
+  const calls = tx.find.mock.calls.filter(([entity]) => entity === CpqQuotePriceAdjustment)
+  expect(calls).toHaveLength(1)
+  expect(calls[0]).toEqual([CpqQuotePriceAdjustment, expect.objectContaining({ quoteConfigurationId: ids.quote, ...scope, deletedAt: null }), { limit: 500, orderBy: { id: 'asc' } }])
+})