@dainamite/cpq 0.5.0 → 0.6.0

package/src/modules/cpq/migrations/Migration20261110213052.ts

@@ -0,0 +1,22 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20261110213052 extends Migration {
+
+  override name = 'Migration20261110213052';
+
+  override up(): void | Promise<void> {
+    this.addSql(`create table "cpq_quote_price_adjustments" ("id" uuid not null default gen_random_uuid(), "organization_id" uuid not null, "tenant_id" uuid not null, "quote_configuration_id" uuid not null, "quote_id" uuid not null, "quote_line_id" uuid not null, "level" text not null, "charge_code" text null, "charge_type_filter" text null, "adjustment_type" text not null, "value" numeric(18, 4) not null, "currency_code" text null, "window_kind" text not null default 'relative', "from_month" int not null default 1, "to_month" int null, "reason_code" text not null, "reason_note" text null, "created_by_user_id" uuid not null, "updated_by_user_id" uuid null, "is_active" boolean not null default true, "created_at" timestamptz not null, "updated_at" timestamptz not null, "deleted_at" timestamptz null, primary key ("id"));`);
+    this.addSql(`create index "cpq_qpa_quote_idx" on "cpq_quote_price_adjustments" ("organization_id", "tenant_id", "quote_id");`);
+    this.addSql(`create index "cpq_qpa_quote_line_idx" on "cpq_quote_price_adjustments" ("organization_id", "tenant_id", "quote_line_id");`);
+    this.addSql(`create index "cpq_qpa_quote_config_idx" on "cpq_quote_price_adjustments" ("organization_id", "tenant_id", "quote_configuration_id");`);
+
+    this.addSql(`alter table "cpq_quote_configurations" add "pricing_revision" int not null default 0;`);
+  }
+
+  override down(): void | Promise<void> {
+    this.addSql(`drop table if exists "cpq_quote_price_adjustments" cascade;`);
+
+    this.addSql(`alter table "cpq_quote_configurations" drop column "pricing_revision";`);
+  }
+
+}

package/src/modules/cpq/services/__tests__/_helpers/mockEm.ts

@@ -15,6 +15,8 @@ import type { TenantScope } from '../../types'
  * pre-existing tests that only inspect `em.create.mock.calls` are unaffected.
  */
 export interface MockEm {
+  fork: jest.MockedFunction<() => MockEm>
+  transactional: jest.MockedFunction<(callback: (em: MockEm) => Promise<unknown>) => Promise<unknown>>
   findOne: jest.MockedFunction<(entity: unknown, where: Record<string, unknown>) => Promise<unknown>>
   find: jest.MockedFunction<
     (
@@ -39,9 +41,11 @@ export interface MockEm {
 let __syntheticIdSequence = 0
 
 export function createMockEm(): MockEm {
-  return {
+  const em: MockEm = {
+    fork: jest.fn(),
+    transactional: jest.fn(),
     findOne: jest.fn(),
-    find: jest.fn(),
+    find: jest.fn().mockResolvedValue([]),
     findAndCount: jest.fn(),
     count: jest.fn().mockResolvedValue(0),
     create: jest.fn().mockImplementation((_e, data: Record<string, unknown>) => ({
@@ -51,6 +55,9 @@ export function createMockEm(): MockEm {
     persist: jest.fn(),
     flush: jest.fn().mockResolvedValue(undefined),
   }
+  em.fork.mockReturnValue(em)
+  em.transactional.mockImplementation((callback) => callback(em))
+  return em
 }
 
 export const TEST_SCOPE: TenantScope = {

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

@@ -0,0 +1,183 @@
+import { CpqAdjustmentService } from '../priceAdjustments/adjustmentService'
+import { CpqOrderConfiguration, CpqQuoteConfiguration, CpqQuoteLineConfiguration, CpqQuotePriceAdjustment } from '../../data/entities'
+import { Dictionary, DictionaryEntry } from '@open-mercato/core/modules/dictionaries/data/entities'
+import { adjustmentInput } from '../priceAdjustments/adjustmentService'
+import { resolveManualAdjustments } from '../priceAdjustments/resolveManualAdjustments'
+import type { PriceAdjustmentInput, PriceAdjustment } from '../../data/price-adjustments'
+const scope = { tenantId: '11111111-1111-4111-8111-111111111111', organizationId: '22222222-2222-4222-8222-222222222222' }
+const quoteId = '33333333-3333-4333-8333-333333333333', lineId = '44444444-4444-4444-8444-444444444444', actor = '55555555-5555-4555-8555-555555555555'
+const input: PriceAdjustmentInput = { level: 'charge', quoteLineId: lineId, chargeCode: 'fee', adjustmentType: 'price_override', value: 80, currencyCode: 'USD', reasonCode: 'competitive_match' }
+function setup() {
+  const quote = { id: quoteId, quoteId, ...scope, cpqStatus: 'ready', pricingRevision: 0, quoteType: 'new' }
+  const rows: CpqQuotePriceAdjustment[] = []
+  const state = { enabled: true, order: false, reason: true, target: true, mirrored: false }
+  const em = {
+    fork: jest.fn(), transactional: jest.fn(), flush: jest.fn().mockResolvedValue(undefined),
+    assign: jest.fn((entity: object, values: object) => Object.assign(entity, values)),
+    create: jest.fn((_entity: unknown, values: object) => ({ fromMonth: 1, toMonth: null, windowKind: 'relative', isActive: true, deletedAt: null, createdAt: new Date(), updatedAt: new Date(), ...values })),
+    persist: jest.fn((row: CpqQuotePriceAdjustment) => { if (!rows.includes(row)) rows.push(row) }),
+    find: jest.fn(async (entity: unknown) => entity === DictionaryEntry ? [{ value: 'competitive_match', label: 'Competitive match' }] : rows.filter((row) => !row.deletedAt)),
+    count: jest.fn(async () => rows.filter((row) => !row.deletedAt).length),
+    findOne: jest.fn(async (entity: unknown, where: Record<string, unknown>) => {
+      if (entity === CpqQuoteConfiguration) return quote
+      if (entity === CpqOrderConfiguration) return state.order ? { id: 'order' } : null
+      if (entity === CpqQuoteLineConfiguration) return state.target ? { offeringId: 'offer', configuration: state.mirrored ? { _arcMirroredFromItemId: 'item' } : {} } : null
+      if (entity === Dictionary) return { id: 'dictionary' }
+      if (entity === DictionaryEntry) return state.reason ? { value: where.value } : null
+      if (entity === CpqQuotePriceAdjustment) return rows.find((row) => row.id === where.id && (where.deletedAt === undefined || row.deletedAt === null)) ?? null
+      return null
+    }),
+  }
+  em.fork.mockReturnValue(em)
+  em.transactional.mockImplementation(async (execute: (tx: typeof em) => Promise<unknown>) => execute(em))
+  const recalculateLockedQuote = jest.fn(async (_em?: unknown, _quote?: unknown, _scope?: unknown, _save?: boolean, draft?: PriceAdjustment[]) => {
+    const resolved = resolveManualAdjustments([{ lineId, parentLineId: null, enginePriced: true, mirrored: false,
+      charges: [{ chargeCode: 'fee', chargeName: 'Fee', chargeType: 'mrc', pricingMethod: 'flat', currencyCode: 'USD', unitPrice: 100, totalPrice: 100, quantity: 1 }] }],
+      draft ?? rows.filter((row) => !row.deletedAt).map((row) => ({ ...adjustmentInput(row), id: row.id })), 'USD')
+    return { id: quoteId, adjustmentErrors: resolved.errors, lines: resolved.lines }
+  })
+  const service = new CpqAdjustmentService({ em: em as never, quotingService: { recalculateLockedQuote } as never,
+    featureTogglesService: { getBoolConfig: async () => ({ ok: true, value: state.enabled }) } as never })
+  return { service, em, quote, rows, state, recalculateLockedQuote }
+}
+it('creates a negotiated price and undoes it under the same pricing lock', async () => {
+  const { service, rows, quote, em } = setup()
+  const created = await service.create(quoteId, { ...input, expectedRevision: 0 }, actor, scope)
+  expect(created.before).toBe(null)
+  expect(created.adjustment).toMatchObject({ value: 80, quoteConfigurationId: quoteId, createdByUserId: actor, ...scope })
+  expect(quote.pricingRevision).toBe(1)
+  await service.undo(quoteId, created.adjustment.id, null, created.adjustment, actor, scope)
+  expect(rows[0].deletedAt).toBeInstanceOf(Date)
+  expect(quote.pricingRevision).toBe(2)
+  expect(em.fork).toHaveBeenCalledWith({ clear: true, useContext: false })
+})
+it('updates and restores previous values, accepting reordered JSON undo keys', async () => {
+  const { service, rows } = setup()
+  const created = await service.create(quoteId, input, actor, scope)
+  const updated = await service.update(quoteId, created.adjustment.id, { value: 70 }, actor, scope)
+  const reordered = Object.fromEntries(Object.entries(updated.adjustment).reverse()) as typeof updated.adjustment
+  await service.undo(quoteId, updated.adjustment.id, updated.before, reordered, actor, scope)
+  expect(rows[0].value).toBe('80')
+})
+it('deletes and restores a row, preserving its original reason even if no longer selectable', async () => {
+  const { service, rows, state } = setup()
+  const created = await service.create(quoteId, input, actor, scope)
+  state.reason = false
+  const removed = await service.remove(quoteId, created.adjustment.id, actor, scope)
+  expect(rows[0].isActive).toBe(false)
+  await service.undo(quoteId, removed.adjustment.id, removed.before, removed.adjustment, actor, scope)
+  expect(rows[0].isActive).toBe(true)
+  expect(rows[0].deletedAt).toBe(null)
+})
+it.each(['in_approval', 'accepted', 'cancelled', 'with_customer'])('refuses create and undo in locked status %s', async (status) => {
+  const { service, quote } = setup()
+  const created = await service.create(quoteId, input, actor, scope)
+  quote.cpqStatus = status
+  await expect(service.create(quoteId, input, actor, scope)).rejects.toMatchObject({ status: 409, message: 'ADJUSTMENT_LOCKED' })
+  await expect(service.undo(quoteId, created.adjustment.id, null, created.adjustment, actor, scope)).rejects.toMatchObject({ status: 409 })
+})
+it('refuses writes when converted or disabled', async () => {
+  const { service, state, em } = setup()
+  state.enabled = false
+  await expect(service.create(quoteId, input, actor, scope)).rejects.toMatchObject({ status: 403 })
+  expect(em.transactional).not.toHaveBeenCalled()
+  state.enabled = true; state.order = true
+  await expect(service.create(quoteId, input, actor, scope)).rejects.toMatchObject({ status: 409 })
+})
+it('rejects invalid prices, missing reasons, overlaps and stale revisions', async () => {
+  const { service, state } = setup()
+  await expect(service.create(quoteId, { ...input, value: 120 }, actor, scope)).rejects.toMatchObject({ status: 422, message: 'ABOVE_STANDARD' })
+  state.reason = false
+  await expect(service.create(quoteId, input, actor, scope)).rejects.toMatchObject({ status: 422, message: 'REASON_NOT_FOUND' })
+  const clean = setup()
+  await clean.service.create(quoteId, input, actor, scope)
+  await expect(clean.service.create(quoteId, input, actor, scope)).rejects.toMatchObject({ status: 422, message: 'ADJUSTMENT_OVERLAP' })
+  await expect(clean.service.create(quoteId, { ...input, expectedRevision: 0 }, actor, scope)).rejects.toMatchObject({ status: 409, message: 'STALE_REVISION' })
+})
+it('allows deleting an invalid adjustment while submitted', async () => {
+  const { service, rows, quote } = setup()
+  const created = await service.create(quoteId, input, actor, scope)
+  rows[0].value = '120'; quote.cpqStatus = 'in_approval'
+  await service.remove(quoteId, created.adjustment.id, actor, scope)
+  expect(rows[0].deletedAt).toBeInstanceOf(Date)
+})
+it('refuses undo if the row changed afterward or the stored tenant is wrong', async () => {
+  const { service, rows } = setup()
+  const created = await service.create(quoteId, input, actor, scope)
+  rows[0].value = '70'
+  await expect(service.undo(quoteId, created.adjustment.id, null, created.adjustment, actor, scope)).rejects.toMatchObject({ status: 409 })
+  await expect(service.undo(quoteId, created.adjustment.id, null, { ...created.adjustment, tenantId: actor }, actor, scope)).rejects.toMatchObject({ status: 403 })
+})
+it('rejects missing/out-of-scope and ARC mirror targets before persisting', async () => {
+  const { service, state, quote, em } = setup()
+  quote.quoteType = 'amend'
+  state.target = false
+  await expect(service.create(quoteId, input, actor, scope)).rejects.toMatchObject({ status: 404 })
+  state.target = true; state.mirrored = true
+  await expect(service.create(quoteId, input, actor, scope)).rejects.toMatchObject({ status: 422, message: 'LINE_NOT_ELIGIBLE' })
+  expect(em.persist).not.toHaveBeenCalled()
+})
+it('scopes and paginates reads while reporting the revision and toggle state', async () => {
+  const { service, em } = setup()
+  await service.create(quoteId, input, actor, scope)
+  const listed = await service.list(quoteId, scope, 1, 25)
+  expect(listed).toMatchObject({ total: 1, page: 1, pageSize: 25, pricingRevision: 1, enabled: true })
+  expect(listed.reasons).toEqual([{ value: 'competitive_match', label: 'Competitive match' }])
+  expect(em.find).toHaveBeenCalledWith(CpqQuotePriceAdjustment, expect.objectContaining({ quoteConfigurationId: quoteId, ...scope, deletedAt: null, isActive: true }), { limit: 25, offset: 0, orderBy: { createdAt: 'asc', id: 'asc' } })
+})
+it('previews a draft without persisting rows, revision, or any flush', async () => {
+  const { service, em, quote, rows, recalculateLockedQuote } = setup()
+  const preview = await service.preview(quoteId, input, undefined, scope)
+  expect(preview.errors).toEqual([])
+  expect(preview.quote.lines[0].charges[0].totalPrice).toBe(80)
+  expect(rows).toEqual([])
+  expect(quote.pricingRevision).toBe(0)
+  expect(em.flush).not.toHaveBeenCalled()
+  expect(em.persist).not.toHaveBeenCalled()
+  expect(em.transactional).not.toHaveBeenCalled()
+  expect(recalculateLockedQuote).toHaveBeenCalledWith(em, quote, scope, false, expect.any(Array))
+})
+it('returns invalid draft errors without saving and refuses a nonexistent replacement', async () => {
+  const { service, em } = setup()
+  const preview = await service.preview(quoteId, { ...input, value: 120 }, undefined, scope)
+  expect(preview.errors).toEqual([expect.objectContaining({ code: 'ABOVE_STANDARD' })])
+  await expect(service.preview(quoteId, input, actor, scope)).rejects.toMatchObject({ status: 404 })
+  expect(em.flush).not.toHaveBeenCalled()
+})
+it('allows a new quote cloned from an ARC mirror to negotiate its engine price', async () => {
+  const { service, state } = setup()
+  state.mirrored = true
+  const result = await service.create(quoteId, input, actor, scope)
+  expect(result.adjustment.value).toBe(80)
+})
+it('refuses an overlapping adjustment at write time, even when the stored one is currently invalid', async () => {
+  const { service, rows, quote } = setup()
+  // 120 > standard 100 → ABOVE_STANDARD would reject it; store it directly as a pre-existing invalid row.
+  rows.push({ id: '66666666-6666-4666-8666-666666666666', quoteConfigurationId: quoteId, quoteId, ...scope, level: 'charge', quoteLineId: lineId,
+    chargeCode: 'fee', chargeTypeFilter: null, adjustmentType: 'price_override', value: '120', currencyCode: 'USD', reasonCode: 'competitive_match',
+    reasonNote: null, windowKind: 'relative', fromMonth: 1, toMonth: null, createdByUserId: actor, isActive: true, deletedAt: null,
+    createdAt: new Date(), updatedAt: new Date() } as unknown as CpqQuotePriceAdjustment)
+  await expect(service.create(quoteId, input, actor, scope)).rejects.toMatchObject({ status: 422, message: 'ADJUSTMENT_OVERLAP' })
+  expect(rows).toHaveLength(1)
+  expect(quote.pricingRevision).toBe(1) // bumped in the rolled-back transaction only
+})
+it('allows a recurring and a one-time line discount side by side, but not two covering all charges', async () => {
+  const { adjustmentsOverlap } = await import('../priceAdjustments/adjustmentService')
+  const base = { level: 'line', quoteLineId: 'l1', chargeCode: null }
+  expect(adjustmentsOverlap({ ...base, id: 'a', chargeTypeFilter: 'mrc' }, { ...base, id: 'b', chargeTypeFilter: 'nrc' })).toBe(false)
+  expect(adjustmentsOverlap({ ...base, id: 'a', chargeTypeFilter: 'mrc' }, { ...base, id: 'b', chargeTypeFilter: null })).toBe(true)
+  expect(adjustmentsOverlap({ ...base, id: 'a', chargeTypeFilter: null }, { ...base, id: 'a', chargeTypeFilter: null })).toBe(false)
+  expect(adjustmentsOverlap({ id: 'a', level: 'charge', quoteLineId: 'l1', chargeCode: 'fee' }, { id: 'b', level: 'charge', quoteLineId: 'l1', chargeCode: 'setup' })).toBe(false)
+  expect(adjustmentsOverlap({ id: 'a', level: 'charge', quoteLineId: 'l1', chargeCode: 'fee' }, { id: 'b', level: 'line', quoteLineId: 'l1' })).toBe(false)
+})
+it('refuses to undo a delete when a rep has since added an overlapping adjustment', async () => {
+  const { service, rows } = setup()
+  const first = await service.create(quoteId, input, actor, scope)
+  await service.remove(quoteId, first.adjustment.id, actor, scope)
+  expect(rows[0].isActive).toBe(false)
+  await service.create(quoteId, { ...input, value: 70 }, actor, scope)
+  const deletedSnapshot = { ...first.adjustment, deletedAt: rows[0].deletedAt!.toISOString(), isActive: false, updatedAt: rows[0].updatedAt.toISOString() }
+  await expect(service.undo(quoteId, first.adjustment.id, first.adjustment, deletedSnapshot, actor, scope))
+    .rejects.toMatchObject({ status: 422, message: 'ADJUSTMENT_OVERLAP' })
+  expect(rows.filter((row) => row.isActive)).toHaveLength(1)
+})

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

@@ -0,0 +1,109 @@
+import {
+  collectLineSubtree,
+  isArcCancelledLine,
+  planArcLineRemoval,
+  planArcLineRestore,
+  removalCancelsItem,
+  type ArcRemovalLine,
+} from '../arcLineRemoval'
+
+const mirror = (quoteLineId: string, parentLineId: string | null = null, action = 'modify'): ArcRemovalLine => ({
+  quoteLineId,
+  parentLineId,
+  action,
+  configuration: { _arcMirroredFromItemId: `item-${quoteLineId}`, _arcMirroredName: quoteLineId },
+})
+const added = (quoteLineId: string, parentLineId: string | null = null): ArcRemovalLine => ({
+  quoteLineId,
+  parentLineId,
+  action: 'add',
+  configuration: { port_speed: '10G' },
+})
+
+describe('removalCancelsItem', () => {
+  it.each(['amend', 'renew'])('is true for a mirror line on a %s quote', (quoteType) => {
+    expect(removalCancelsItem(mirror('a'), quoteType)).toBe(true)
+  })
+
+  it('is false for a line the quote added', () => {
+    expect(removalCancelsItem(added('a'), 'amend')).toBe(false)
+  })
+
+  it.each(['new', 'cancel', null])('is false on a %s quote', (quoteType) => {
+    expect(removalCancelsItem(mirror('a'), quoteType)).toBe(false)
+  })
+})
+
+describe('isArcCancelledLine', () => {
+  it('is true for a cancel line on an Amend / Renew quote', () => {
+    expect(isArcCancelledLine({ action: 'cancel' }, 'amend')).toBe(true)
+    expect(isArcCancelledLine({ action: 'cancel' }, 'renew')).toBe(true)
+  })
+
+  it('is false on a Cancel quote, where every line is a cancel line and keeps its price', () => {
+    expect(isArcCancelledLine({ action: 'cancel' }, 'cancel')).toBe(false)
+  })
+
+  it('is false for modify / add lines', () => {
+    expect(isArcCancelledLine({ action: 'modify' }, 'amend')).toBe(false)
+    expect(isArcCancelledLine({ action: 'add' }, 'amend')).toBe(false)
+  })
+})
+
+describe('collectLineSubtree', () => {
+  it('returns the root and every descendant, root first', () => {
+    const lines = [mirror('root'), mirror('child', 'root'), mirror('grandchild', 'child'), mirror('other')]
+    expect(collectLineSubtree(lines[0], lines).map((l) => l.quoteLineId)).toEqual(['root', 'child', 'grandchild'])
+  })
+
+  it('terminates on a parent cycle', () => {
+    const a = mirror('a', 'b')
+    const b = mirror('b', 'a')
+    expect(collectLineSubtree(a, [a, b]).map((l) => l.quoteLineId)).toEqual(['a', 'b'])
+  })
+})
+
+describe('planArcLineRemoval', () => {
+  it('cancels a single mirror line and deletes nothing', () => {
+    const line = mirror('port')
+    expect(planArcLineRemoval(line, [line, added('new-port')], 'amend')).toEqual({ cancel: [line], removeRoots: [] })
+  })
+
+  it('cancels mirrored components with their bundle and deletes components this quote added', () => {
+    const bundle = mirror('bundle')
+    const existingComponent = mirror('comp-1', 'bundle')
+    const newComponent = added('comp-2', 'bundle')
+    const newGrandchild = added('comp-2a', 'comp-2')
+    const plan = planArcLineRemoval(bundle, [bundle, existingComponent, newComponent, newGrandchild], 'amend')
+    expect(plan.cancel.map((l) => l.quoteLineId)).toEqual(['bundle', 'comp-1'])
+    // Only the subtree root is deleted — removing it takes its descendants with it.
+    expect(plan.removeRoots.map((l) => l.quoteLineId)).toEqual(['comp-2'])
+  })
+
+  it('leaves components that are already cancelled alone', () => {
+    const bundle = mirror('bundle')
+    const cancelled = mirror('comp-1', 'bundle', 'cancel')
+    expect(planArcLineRemoval(bundle, [bundle, cancelled], 'amend').cancel).toEqual([bundle])
+  })
+})
+
+describe('planArcLineRestore', () => {
+  it('restores the line and its cancelled mirrored components', () => {
+    const bundle = mirror('bundle', null, 'cancel')
+    const component = mirror('comp-1', 'bundle', 'cancel')
+    const plan = planArcLineRestore(bundle, [bundle, component], 'amend')
+    expect(plan).toEqual({ ok: true, restore: [bundle, component] })
+  })
+
+  it('is blocked while the parent item is still marked for removal', () => {
+    const bundle = mirror('bundle', null, 'cancel')
+    const component = mirror('comp-1', 'bundle', 'cancel')
+    expect(planArcLineRestore(component, [bundle, component], 'amend')).toEqual({ ok: false, reason: 'parent_cancelled' })
+  })
+
+  it('restores a component on its own when the parent stays', () => {
+    const bundle = mirror('bundle')
+    const component = mirror('comp-1', 'bundle', 'cancel')
+    expect(planArcLineRestore(component, [bundle, component], 'amend')).toEqual({ ok: true, restore: [component] })
+  })
+})

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

@@ -0,0 +1,141 @@
+import {
+  ARC_PRICE_FROZEN_KEY,
+  arcPricingInputsChanged,
+  buildArcMirrorConfiguration,
+  ARC_REPRICED_KEY,
+  isArcPriceFrozen,
+  isFrozenAmendMirrorLine,
+  stripArcMarkers,
+  stripQuoteOnlyArcMarkers,
+} from '../arcPriceFreeze'
+
+const ITEM = { id: 'item-1', name: 'GIX Access Port' }
+
+describe('buildArcMirrorConfiguration', () => {
+  it('freezes Amend mirror lines and keeps the item configuration', () => {
+    const cfg = buildArcMirrorConfiguration({ port_size: '1G' }, ITEM, 'amend')
+    expect(cfg).toEqual({
+      port_size: '1G',
+      _arcMirroredFromItemId: 'item-1',
+      _arcMirroredName: 'GIX Access Port',
+      [ARC_PRICE_FROZEN_KEY]: true,
+    })
+    expect(isArcPriceFrozen(cfg)).toBe(true)
+  })
+
+  it.each(['renew', 'cancel'] as const)('does not freeze %s mirror lines', (quoteType) => {
+    const cfg = buildArcMirrorConfiguration({ port_size: '1G' }, ITEM, quoteType)
+    expect(isArcPriceFrozen(cfg)).toBe(false)
+    expect(cfg._arcMirroredFromItemId).toBe('item-1')
+  })
+
+  it('never inherits stale ARC markers from the item configuration', () => {
+    const stale = { port_size: '1G', _arcPriceFrozen: true, _arcMirroredFromItemId: 'old-item', _arcMirroredName: 'Old' }
+    const renew = buildArcMirrorConfiguration(stale, ITEM, 'renew')
+    expect(isArcPriceFrozen(renew)).toBe(false)
+    expect(renew).toEqual({ port_size: '1G', _arcMirroredFromItemId: 'item-1', _arcMirroredName: 'GIX Access Port' })
+  })
+
+  it('handles an item without configuration', () => {
+    expect(buildArcMirrorConfiguration(null, ITEM, 'amend')).toMatchObject({ _arcMirroredName: 'GIX Access Port' })
+  })
+})
+
+describe('isArcPriceFrozen', () => {
+  it('is false for missing or non-boolean markers', () => {
+    expect(isArcPriceFrozen(null)).toBe(false)
+    expect(isArcPriceFrozen({})).toBe(false)
+    expect(isArcPriceFrozen({ [ARC_PRICE_FROZEN_KEY]: 'true' })).toBe(false)
+  })
+})
+
+describe('arcPricingInputsChanged', () => {
+  const before = {
+    configuration: { port_size: '1G', data_centre: 'ld5', _arcMirroredFromItemId: 'item-1', [ARC_PRICE_FROZEN_KEY]: true },
+    quantity: 2,
+    termMonths: 12,
+    startDate: new Date('2027-01-01T00:00:00.000Z'),
+    endDate: null,
+    usageEstimates: [{ chargeCode: 'overage', estimatedQuantity: 10 }],
+  }
+
+  it('is false for an unchanged resubmission (markers stripped, key order differs, fields omitted)', () => {
+    expect(arcPricingInputsChanged(before, { configuration: { data_centre: 'ld5', port_size: '1G' } })).toBe(false)
+  })
+
+  it('is false when unchanged values are resubmitted explicitly', () => {
+    expect(
+      arcPricingInputsChanged(before, {
+        configuration: { port_size: '1G', data_centre: 'ld5' },
+        quantity: 2,
+        termMonths: 12,
+        startDate: '2027-01-01',
+        usageEstimates: [{ chargeCode: 'overage', estimatedQuantity: 10 }],
+      }),
+    ).toBe(false)
+  })
+
+  it('detects a configuration change', () => {
+    expect(arcPricingInputsChanged(before, { configuration: { port_size: '10G', data_centre: 'ld5' } })).toBe(true)
+  })
+
+  it('detects an added configuration key', () => {
+    expect(
+      arcPricingInputsChanged(before, { configuration: { port_size: '1G', data_centre: 'ld5', cloud_provider: 'aws' } }),
+    ).toBe(true)
+  })
+
+  it.each([
+    ['quantity', { quantity: 3 }],
+    ['termMonths', { termMonths: 24 }],
+    ['startDate', { startDate: '2027-02-01' }],
+    ['endDate', { endDate: '2028-01-01' }],
+    ['usageEstimates', { usageEstimates: [{ chargeCode: 'overage', estimatedQuantity: 20 }] }],
+  ])('detects a %s change', (_field, change) => {
+    expect(arcPricingInputsChanged(before, { configuration: { port_size: '1G', data_centre: 'ld5' }, ...change })).toBe(true)
+  })
+})
+
+describe('isFrozenAmendMirrorLine', () => {
+  const mirrored = { port_size: '1G', _arcMirroredFromItemId: 'item-1', [ARC_PRICE_FROZEN_KEY]: true }
+
+  it('is true only for a flagged mirror line on an Amend quote', () => {
+    expect(isFrozenAmendMirrorLine(mirrored, 'amend')).toBe(true)
+  })
+
+  it.each(['new', 'renew', 'cancel', null, undefined])('ignores the flag on a %s quote', (quoteType) => {
+    expect(isFrozenAmendMirrorLine(mirrored, quoteType)).toBe(false)
+  })
+
+  it('ignores the flag on a line that is not a mirror line', () => {
+    expect(isFrozenAmendMirrorLine({ port_size: '1G', [ARC_PRICE_FROZEN_KEY]: true }, 'amend')).toBe(false)
+  })
+})
+
+describe('stripArcMarkers', () => {
+  it('removes every _arc* key and keeps the rest', () => {
+    expect(
+      stripArcMarkers({ port_size: '1G', _arcMirroredFromItemId: 'item-1', [ARC_PRICE_FROZEN_KEY]: true, [ARC_REPRICED_KEY]: true }),
+    ).toEqual({ port_size: '1G' })
+    expect(stripArcMarkers(null)).toEqual({})
+  })
+})
+
+describe('stripQuoteOnlyArcMarkers', () => {
+  it('removes the freeze and re-priced flags and keeps the descriptive markers', () => {
+    expect(
+      stripQuoteOnlyArcMarkers({
+        port_size: '1G',
+        _arcMirroredFromItemId: 'item-1',
+        [ARC_PRICE_FROZEN_KEY]: true,
+        [ARC_REPRICED_KEY]: true,
+      }),
+    ).toEqual({ port_size: '1G', _arcMirroredFromItemId: 'item-1' })
+  })
+
+  it('returns the input untouched when there is no quote-only marker', () => {
+    const cfg = { port_size: '1G' }
+    expect(stripQuoteOnlyArcMarkers(cfg)).toBe(cfg)
+    expect(stripQuoteOnlyArcMarkers(null)).toBeNull()
+  })
+})

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

@@ -0,0 +1,28 @@
+import { withChargeWaterfall, withoutChargeWaterfall } from '../priceAdjustments/chargeWaterfall'
+import type { ResolvedCharge } from '../types'
+
+const base: ResolvedCharge = {
+  chargeCode: 'fee', chargeName: 'Fee', chargeType: 'mrc', pricingMethod: 'per_unit',
+  unitPrice: 20, quantity: 4, totalPrice: 80, currencyCode: 'USD',
+}
+const rule = { ruleCode: 'volume', ruleName: 'Volume', ruleType: 'discount_percent', value: 20, unitPriceBefore: 25, unitPriceAfter: 20, delta: -5 }
+it('derives pre-rule and standard money from legacy adjustments without mutating the snapshot', () => {
+  const input = { ...base, adjustments: [rule] }
+  const result = withChargeWaterfall(input)
+  expect(result).toMatchObject({ listUnitPrice: 25, listTotalPrice: 100, standardUnitPrice: 20, standardTotalPrice: 80 })
+  expect(result.adjustments?.[0].origin).toBe('rule')
+  expect(input.adjustments[0]).not.toHaveProperty('origin')
+  expect(result.unitPrice).toBe(base.unitPrice)
+  expect(result.totalPrice).toBe(base.totalPrice)
+})
+it('preserves exact tier totals and null usage totals', () => {
+  const tier = { ...base, unitPrice: 1 / 3, quantity: 3, totalPrice: 1 }
+  expect(withChargeWaterfall(tier).standardTotalPrice).toBe(1)
+  expect(withChargeWaterfall({ ...base, chargeType: 'usage', quantity: null, totalPrice: null })).toMatchObject({ listTotalPrice: null, standardTotalPrice: null })
+})
+it('keeps explicitly captured zero values', () => {
+  expect(withChargeWaterfall({ ...base, listUnitPrice: 0, listTotalPrice: 0 })).toMatchObject({ listUnitPrice: 0, listTotalPrice: 0 })
+})
+it('removes internal waterfall fields from the default public calculation response', () => {
+  expect(withoutChargeWaterfall(withChargeWaterfall(base))).toEqual(base)
+})

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

@@ -1,7 +1,10 @@
+import { CpqOrderLineConfiguration } from '../../data/entities'
 import { DefaultCpqOrderService, OrderError } from '../cpqOrderService'
 import type { TenantScope } from '../types'
 
 interface MockEm {
+  fork: jest.MockedFunction<() => MockEm>
+  transactional: jest.MockedFunction<(callback: (em: MockEm) => Promise<unknown>) => Promise<unknown>>
   findOne: jest.MockedFunction<(entity: unknown, where: Record<string, unknown>) => Promise<unknown>>
   find: jest.MockedFunction<
     (entity: unknown, where: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown[]>
@@ -24,14 +27,19 @@ interface MockNumberGenerator {
 }
 
 function createMockEm(): MockEm {
-  return {
+  const em: MockEm = {
+    fork: jest.fn(),
+    transactional: jest.fn(),
     findOne: jest.fn(),
-    find: jest.fn(),
+    find: jest.fn().mockResolvedValue([]),
     findAndCount: jest.fn(),
     create: jest.fn().mockImplementation((_e, data: Record<string, unknown>) => ({ ...data })),
     persist: jest.fn(),
     flush: jest.fn().mockResolvedValue(undefined),
   }
+  em.fork.mockReturnValue(em)
+  em.transactional.mockImplementation((callback) => callback(em))
+  return em
 }
 
 function createService(): {
@@ -601,3 +609,28 @@ describe('DefaultCpqOrderService.getOrder', () => {
     expect(result.lines[0].offeringType).toBeNull()
   })
 })
+
+
+describe('conversion stored-adjustment baseline', () => {
+  it.each([false, true])('converts valid stored offers and refuses invalid snapshots (invalid=%s)', async (invalid) => {
+    const { em, service } = createService()
+    const charges = [{ chargeCode: 'fee', chargeType: 'mrc', pricingMethod: 'flat', quantity: 1, unitPrice: 80, totalPrice: 80,
+      listUnitPrice: 120, listTotalPrice: 120, standardUnitPrice: 100, standardTotalPrice: 100, currencyCode: 'USD',
+      adjustmentErrors: invalid ? [{ adjustmentId: 'a', quoteLineId: 'line', code: 'ABOVE_STANDARD' }] : [] }]
+    em.findOne.mockResolvedValueOnce({ id: 'quote', quoteId: 'sales', cpqStatus: 'accepted', currencyCode: 'USD', customerId: 'customer', pricingSummary: { nrcTotal: 0, mrcTotal: 80 } })
+      .mockResolvedValueOnce(null) // no existing order
+    em.find.mockResolvedValueOnce([{ quoteLineId: 'line', quantity: 1, action: 'add', nrcTotal: '0', mrcTotal: '80', charges,
+      configuration: { _arcPriceFrozen: true, _arcRepriced: true }, offeringId: null }]).mockResolvedValueOnce([])
+    em.create.mockImplementation((_entity, values: Record<string, unknown>) => ({ createdAt: new Date(), ...values }))
+    if (invalid) {
+      await expect(service.convertQuoteToOrder('quote', SCOPE)).rejects.toMatchObject({ status: 422, message: 'ADJUSTMENT_INVALID', details: { lineId: 'line', code: 'ABOVE_STANDARD' } })
+      expect(em.create).not.toHaveBeenCalled()
+      return
+    }
+    await service.convertQuoteToOrder('quote', SCOPE)
+    expect(em.create).toHaveBeenCalledWith(CpqOrderLineConfiguration, expect.objectContaining({ charges, mrcTotal: '80' }))
+    const orderLine = em.create.mock.calls.find(([entity]) => entity === CpqOrderLineConfiguration)?.[1]
+    expect(orderLine?.configuration).not.toHaveProperty('_arcPriceFrozen')
+    expect(orderLine?.configuration).not.toHaveProperty('_arcRepriced')
+  })
+})

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

@@ -1181,3 +1181,60 @@ describe('DefaultCpqPricingService — price rules application', () => {
     expect(result.totalPrice).toBeNull()
   })
 })
+
+/** Pin legacy money calculations before adding the list/standard waterfall. */
+describe('negotiated-pricing baseline — all rule types across charge models', () => {
+  const models = ['flat', 'per_unit', 'volume', 'tiered'] as const
+  const rules = [
+    { type: 'discount_percent', value: 10, total: 90 },
+    { type: 'discount_absolute', value: 20, total: 80 },
+    { type: 'surcharge_percent', value: 10, total: 110 },
+    { type: 'surcharge_absolute', value: 20, total: 120 },
+    { type: 'price_override', value: 20, total: 80 },
+    { type: 'discount_absolute', value: 200, total: 0 },
+    { type: 'discount_percent', value: 100, total: 0 },
+  ]
+  it.each(models.flatMap((model) => rules.map((rule) => ({ model, ...rule }))))(
+    '$model with $type $value preserves existing money and adjustment arithmetic',
+    async ({ model, type, value, total }) => {
+      const em = createMockEm()
+      const charge = {
+        ...makeCharge({ code: 'fee', name: 'Fee', chargeType: 'mrc', pricingMethod: 'fixed' }),
+        chargeModel: model,
+        fixedPrice: model === 'flat' ? '100' : '25',
+        quantityAttributeCode: 'units',
+        ...(model === 'volume' || model === 'tiered'
+          ? { pricingMethod: 'table', pricingTableId: 'prices', priceColumnKey: 'rate' } : {}),
+      }
+      em.findOne.mockResolvedValue({ id: 'prices', dimensions: [] })
+      em.find.mockImplementation(async (entity) => {
+        if (entity === CpqProductCharge) return [charge]
+        if (entity === CpqPricingTableEntry) return [
+          { tierNumber: 0, rangeFrom: '1', rangeTo: '2', prices: { rate: 30 }, dimensionValues: {}, currencyCode: 'USD' },
+          { tierNumber: 1, rangeFrom: '3', rangeTo: null, prices: { rate: model === 'tiered' ? 20 : 25 }, dimensionValues: {}, currencyCode: 'USD' },
+        ]
+        return [{ code: 'rule', name: 'Rule', ruleType: type, value: String(value) }]
+      })
+      const service = new DefaultCpqPricingService(em as unknown as never)
+      const [result] = await service.resolveProductCharges({ offeringId: 'offer', configuration: { units: 4 }, currencyCode: 'USD', ...SCOPE })
+      const quantity = model === 'flat' ? 1 : 4
+      const expectedTotal = type === 'price_override' && model === 'flat' ? 20 : total
+      expect(Math.round((result.totalPrice ?? 0) * 100)).toBe(expectedTotal * 100)
+      expect(Math.round(result.unitPrice * quantity * 100)).toBe(expectedTotal * 100)
+      expect(result.quantity).toBe(quantity)
+      expect(result.currencyCode).toBe('USD')
+      expect(result.listTotalPrice).toBe(100)
+      expect(result.listUnitPrice).toBe(100 / quantity)
+      expect(Math.round((result.standardTotalPrice ?? 0) * 100)).toBe(expectedTotal * 100)
+      expect(result.standardUnitPrice).toBe(result.unitPrice)
+      expect(result.adjustments?.[0].origin).toBe('rule')
+      expect(result.adjustments).toHaveLength(1)
+      expect(result.adjustments?.[0]).toMatchObject({ ruleCode: 'rule', ruleName: 'Rule', ruleType: type, value })
+      expect(Math.round((result.adjustments?.[0].unitPriceBefore ?? 0) * quantity * 100)).toBe(10000)
+      expect(Math.round((result.adjustments?.[0].delta ?? 0) * quantity * 100)).toBe((expectedTotal - 100) * 100)
+      if (model === 'tiered') {
+        expect(result.breakdown?.tiers.map((tier) => Math.round(tier.subtotal * 100))).toEqual([6000, 4000])
+      }
+    },
+  )
+})