@dainamite/cpq 0.2.2

package/src/modules/cpq/api/product-specifications/route.ts

@@ -0,0 +1,325 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { resolveCpqRouteContext } from '../context'
+import { CpqProductSpecification, CpqProductAttribute, CpqProductOffering, CpqProductRelationship, CpqBundleSlot } from '../../data/entities'
+import { cpqProductSpecificationCreateSchema, cpqProductSpecificationUpdateSchema } from '../../data/validators'
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['cpq.specifications.view'] },
+  POST: { requireAuth: true, requireFeatures: ['cpq.specifications.manage'] },
+  PUT: { requireAuth: true, requireFeatures: ['cpq.specifications.manage'] },
+  DELETE: { requireAuth: true, requireFeatures: ['cpq.specifications.manage'] },
+}
+
+export async function GET(req: Request) {
+  try {
+    const ctx = await resolveCpqRouteContext(req)
+    if (!ctx.auth) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+
+    const url = new URL(req.url)
+    const scope = { organizationId: ctx.organizationId, tenantId: ctx.tenantId, deletedAt: null }
+
+    // Detail view — load spec with related entities
+    const id = url.searchParams.get('id')
+    if (id) {
+      const spec = await ctx.em.findOne(CpqProductSpecification, { id, ...scope })
+      if (!spec) return NextResponse.json({ error: 'Not found' }, { status: 404 })
+
+      const [attributes, offerings, relationships, bundleSlots] = await Promise.all([
+        ctx.em.find(CpqProductAttribute, { specId: spec.id, ...scope }, { orderBy: { sortOrder: 'asc' } }),
+        ctx.em.find(CpqProductOffering, { specId: spec.id, ...scope }, { orderBy: { createdAt: 'asc' } }),
+        ctx.em.find(CpqProductRelationship, {
+          $or: [{ sourceSpecId: spec.id }, { targetSpecId: spec.id }],
+          ...scope,
+        }),
+        spec.specType === 'bundle'
+          ? ctx.em.find(CpqBundleSlot, { specId: spec.id, ...scope }, { orderBy: { sortOrder: 'asc' } })
+          : Promise.resolve([]),
+      ])
+
+      // Resolve target specs for slots
+      let slotsWithTargetSpec: Array<Record<string, unknown>> = []
+      if (bundleSlots.length > 0) {
+        const targetSpecIds = [...new Set(bundleSlots.map((s) => s.targetSpecId))]
+        const targetSpecs = await ctx.em.find(CpqProductSpecification, { id: { $in: targetSpecIds }, ...scope })
+        const specMap = new Map(targetSpecs.map((s) => [s.id, s]))
+        slotsWithTargetSpec = bundleSlots.map((s) => {
+          const ts = specMap.get(s.targetSpecId)
+          return {
+            id: s.id,
+            componentGroup: s.componentGroup,
+            name: s.name,
+            description: s.description,
+            targetSpecId: s.targetSpecId,
+            targetSpec: ts ? { id: ts.id, code: ts.code, name: ts.name, specType: ts.specType } : null,
+            cardinalityMin: s.cardinalityMin,
+            cardinalityMax: s.cardinalityMax,
+            sortOrder: s.sortOrder,
+            isActive: s.isActive,
+          }
+        })
+      }
+
+      return NextResponse.json({
+        id: spec.id,
+        productId: spec.productId,
+        code: spec.code,
+        name: spec.name,
+        description: spec.description,
+        specType: spec.specType,
+        isAssetizable: spec.isAssetizable,
+        lifecycleStatus: spec.lifecycleStatus,
+        version: spec.version,
+        effectiveFrom: spec.effectiveFrom,
+        effectiveTo: spec.effectiveTo,
+        metadata: spec.metadata,
+        isActive: spec.isActive,
+        createdAt: spec.createdAt,
+        updatedAt: spec.updatedAt,
+        attributes: attributes.map((a) => ({
+          id: a.id,
+          code: a.code,
+          name: a.name,
+          attributeType: a.attributeType,
+          resolutionTime: a.resolutionTime,
+          options: a.options,
+          constraints: a.constraints,
+          referenceEntity: a.referenceEntity,
+          referenceFilter: a.referenceFilter,
+          dependsOn: a.dependsOn,
+          defaultValue: a.defaultValue,
+          helpText: a.helpText,
+          sortOrder: a.sortOrder,
+          isRequired: a.isRequired,
+          isActive: a.isActive,
+        })),
+        offerings: offerings.map((o) => ({
+          id: o.id,
+          code: o.code,
+          name: o.name,
+          offeringType: o.offeringType,
+          designTimeValues: o.designTimeValues,
+          lifecycleStatus: o.lifecycleStatus,
+          isActive: o.isActive,
+        })),
+        relationships: relationships.map((r) => ({
+          id: r.id,
+          sourceSpecId: r.sourceSpecId,
+          targetSpecId: r.targetSpecId,
+          relationshipType: r.relationshipType,
+          cardinalityMin: r.cardinalityMin,
+          cardinalityMax: r.cardinalityMax,
+          condition: r.condition,
+          isActive: r.isActive,
+        })),
+        ...(spec.specType === 'bundle' ? { slots: slotsWithTargetSpec } : {}),
+      })
+    }
+
+    // List view
+    const page = Math.max(1, Number(url.searchParams.get('page') ?? '1'))
+    const pageSize = Math.min(100, Math.max(1, Number(url.searchParams.get('pageSize') ?? '50')))
+
+    const filters: Record<string, unknown> = { ...scope }
+    const productId = url.searchParams.get('productId')
+    if (productId) filters.productId = productId
+    const lifecycleStatus = url.searchParams.get('lifecycleStatus')
+    if (lifecycleStatus) filters.lifecycleStatus = lifecycleStatus
+    const code = url.searchParams.get('code')
+    if (code) filters.code = code
+    const specType = url.searchParams.get('specType')
+    if (specType) filters.specType = specType
+    const isActiveParam = url.searchParams.get('isActive')
+    if (isActiveParam === 'true') filters.isActive = true
+    else if (isActiveParam === 'false') filters.isActive = false
+    const isAssetizableParam = url.searchParams.get('isAssetizable')
+    if (isAssetizableParam === 'true') filters.isAssetizable = true
+    else if (isAssetizableParam === 'false') filters.isAssetizable = false
+
+    // Free-text search across code, name, description (case-insensitive)
+    const search = url.searchParams.get('search')?.trim()
+    if (search) {
+      filters.$or = [
+        { code: { $ilike: `%${search}%` } },
+        { name: { $ilike: `%${search}%` } },
+        { description: { $ilike: `%${search}%` } },
+      ]
+    }
+
+    // Configurable sort
+    const ALLOWED_SORT_FIELDS = ['createdAt', 'updatedAt', 'code', 'name', 'lifecycleStatus', 'specType', 'version'] as const
+    const sortFieldParam = url.searchParams.get('sortField') ?? ''
+    const sortField = (ALLOWED_SORT_FIELDS as readonly string[]).includes(sortFieldParam)
+      ? (sortFieldParam as (typeof ALLOWED_SORT_FIELDS)[number])
+      : 'createdAt'
+    const sortDir = url.searchParams.get('sortDir') === 'asc' ? 'asc' : 'desc'
+
+    const [items, total] = await ctx.em.findAndCount(CpqProductSpecification, filters, {
+      limit: pageSize,
+      offset: (page - 1) * pageSize,
+      orderBy: { [sortField]: sortDir },
+    })
+
+    return NextResponse.json({
+      items: items.map((item) => ({
+        id: item.id,
+        productId: item.productId,
+        code: item.code,
+        name: item.name,
+        description: item.description,
+        specType: item.specType,
+        isAssetizable: item.isAssetizable,
+        lifecycleStatus: item.lifecycleStatus,
+        version: item.version,
+        effectiveFrom: item.effectiveFrom,
+        effectiveTo: item.effectiveTo,
+        isActive: item.isActive,
+        createdAt: item.createdAt,
+        updatedAt: item.updatedAt,
+      })),
+      total,
+      page,
+      pageSize,
+      totalPages: Math.ceil(total / pageSize),
+    })
+  } catch (err) {
+    console.error('[cpq/product-specifications.GET]', err)
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 })
+  }
+}
+
+export async function POST(req: Request) {
+  try {
+    const ctx = await resolveCpqRouteContext(req)
+    if (!ctx.auth) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+
+    const body = cpqProductSpecificationCreateSchema.parse(await req.json())
+    const scope = { organizationId: ctx.organizationId, tenantId: ctx.tenantId }
+
+    let productId = body.productId
+    if (!productId) {
+      // Auto-create or reuse a CatalogProduct from the specification properties
+      const { CatalogProduct } = await import('@open-mercato/core/modules/catalog/data/entities')
+      const handle = body.code.toLowerCase().replace(/[^a-z0-9_-]/g, '-')
+      const sku = body.code.toUpperCase().replace(/[^A-Z0-9_-]/g, '-')
+
+      // Check if a product with this handle or SKU already exists
+      const existing = await ctx.em.findOne(CatalogProduct, {
+        ...scope,
+        $or: [{ handle }, { sku }],
+        deletedAt: null,
+      })
+
+      if (existing) {
+        productId = existing.id
+      } else {
+        const product = ctx.em.create(CatalogProduct, {
+          ...scope,
+          title: body.name,
+          sku,
+          handle,
+          description: body.description ?? null,
+          productType: 'configurable',
+          isConfigurable: true,
+          isActive: true,
+        })
+        ctx.em.persist(product)
+        await ctx.em.flush()
+        productId = product.id
+      }
+    }
+
+    const entity = ctx.em.create(CpqProductSpecification, { ...body, productId, ...scope })
+    await ctx.em.flush()
+
+    return NextResponse.json(
+      {
+        id: entity.id,
+        productId: entity.productId,
+        code: entity.code,
+        name: entity.name,
+        description: entity.description,
+        specType: entity.specType,
+        isAssetizable: entity.isAssetizable,
+        lifecycleStatus: entity.lifecycleStatus,
+        version: entity.version,
+        effectiveFrom: entity.effectiveFrom,
+        effectiveTo: entity.effectiveTo,
+        metadata: entity.metadata,
+        isActive: entity.isActive,
+        createdAt: entity.createdAt,
+        updatedAt: entity.updatedAt,
+      },
+      { status: 201 },
+    )
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      return NextResponse.json({ error: 'Validation error', details: err.issues }, { status: 400 })
+    }
+    console.error('[cpq/product-specifications.POST]', err)
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 })
+  }
+}
+
+export async function PUT(req: Request) {
+  try {
+    const ctx = await resolveCpqRouteContext(req)
+    if (!ctx.auth) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+
+    const body = cpqProductSpecificationUpdateSchema.parse(await req.json())
+    const { id, ...updates } = body
+    const scope = { organizationId: ctx.organizationId, tenantId: ctx.tenantId, deletedAt: null }
+
+    const entity = await ctx.em.findOne(CpqProductSpecification, { id, ...scope })
+    if (!entity) return NextResponse.json({ error: 'Not found' }, { status: 404 })
+
+    ctx.em.assign(entity, updates)
+    await ctx.em.flush()
+
+    return NextResponse.json({
+      id: entity.id,
+      productId: entity.productId,
+      code: entity.code,
+      name: entity.name,
+      description: entity.description,
+      specType: entity.specType,
+      isAssetizable: entity.isAssetizable,
+      lifecycleStatus: entity.lifecycleStatus,
+      version: entity.version,
+      effectiveFrom: entity.effectiveFrom,
+      effectiveTo: entity.effectiveTo,
+      metadata: entity.metadata,
+      isActive: entity.isActive,
+      createdAt: entity.createdAt,
+      updatedAt: entity.updatedAt,
+    })
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      return NextResponse.json({ error: 'Validation error', details: err.issues }, { status: 400 })
+    }
+    console.error('[cpq/product-specifications.PUT]', err)
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 })
+  }
+}
+
+export async function DELETE(req: Request) {
+  try {
+    const ctx = await resolveCpqRouteContext(req)
+    if (!ctx.auth) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+
+    const { id } = (await req.json()) as { id?: string }
+    if (!id) return NextResponse.json({ error: 'Missing id' }, { status: 400 })
+
+    const scope = { organizationId: ctx.organizationId, tenantId: ctx.tenantId, deletedAt: null }
+    const entity = await ctx.em.findOne(CpqProductSpecification, { id, ...scope })
+    if (!entity) return NextResponse.json({ error: 'Not found' }, { status: 404 })
+
+    entity.deletedAt = new Date()
+    await ctx.em.flush()
+
+    return NextResponse.json({ success: true })
+  } catch (err) {
+    console.error('[cpq/product-specifications.DELETE]', err)
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 })
+  }
+}

package/src/modules/cpq/api/quotes/[quoteId]/cancel-meta/route.ts

@@ -0,0 +1,77 @@
+import { NextResponse } from 'next/server'
+import { resolveCpqRouteContext } from '../../../context'
+import { cpqCancelMetaSchema } from '../../../../data/validators'
+import { resolveQuotingService } from '../../../resolveQuotingService'
+import { handleArcError } from '../../../_helpers/handleArcError'
+
+/**
+ * POST /api/cpq/quotes/[quoteId]/cancel-meta
+ *
+ * Stamp ETF + reason on a `quote_type='cancel'` quote. Required before the
+ * quote can transition through the approval lifecycle (validateArcQuote).
+ */
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['cpq.arc.cancel.manage'] },
+}
+
+export async function POST(
+  req: Request,
+  { params }: { params: Promise<{ quoteId: string }> },
+) {
+  try {
+    const ctx = await resolveCpqRouteContext(req)
+    if (!ctx.auth) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    const { quoteId } = await params
+    const body = cpqCancelMetaSchema.parse(await req.json())
+    const scope = { organizationId: ctx.organizationId, tenantId: ctx.tenantId }
+    const service = resolveQuotingService(ctx)
+    const result = await service.setCancelMeta(
+      quoteId,
+      {
+        reasonCode: body.reasonCode,
+        reasonText: body.reasonText ?? null,
+        etfAmount: body.etfAmount ?? null,
+        etfCurrency: body.etfCurrency ?? null,
+      },
+      scope,
+    )
+    return NextResponse.json(result)
+  } catch (err) {
+    return handleArcError(err, 'cpq/quotes/[quoteId]/cancel-meta.POST')
+  }
+}
+
+export const openApi = {
+  '/api/cpq/quotes/{quoteId}/cancel-meta': {
+    parameters: [
+      { name: 'quoteId', in: 'path', required: true, schema: { type: 'string', format: 'uuid' } },
+    ],
+    post: {
+      tags: ['CPQ ARC'],
+      summary: 'Stamp ETF + reason on a cancel quote',
+      requestBody: {
+        required: true,
+        content: {
+          'application/json': {
+            schema: {
+              type: 'object',
+              required: ['reasonCode'],
+              properties: {
+                reasonCode: { type: 'string' },
+                reasonText: { type: 'string' },
+                etfAmount: { type: 'string' },
+                etfCurrency: { type: 'string', maxLength: 3 },
+              },
+            },
+          },
+        },
+      },
+      responses: {
+        '200': { description: 'Cancel meta stamped' },
+        '400': { description: 'Validation error' },
+        '404': { description: 'Quote not found' },
+        '409': { description: 'Quote not cancel-type or no longer editable' },
+      },
+    },
+  },
+}

package/src/modules/cpq/api/quotes/[quoteId]/clone/route.ts

@@ -0,0 +1,28 @@
+import { NextResponse } from 'next/server'
+import { resolveCpqRouteContext } from '../../../context'
+import { QuotingError } from '../../../../services/cpqQuotingService'
+import { resolveQuotingService } from '../../../resolveQuotingService'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['cpq.quotes.manage'] },
+}
+
+export async function POST(req: Request, { params }: { params: Promise<{ quoteId: string }> }) {
+  try {
+    const ctx = await resolveCpqRouteContext(req)
+    if (!ctx.auth) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+
+    const { quoteId } = await params
+    const scope = { organizationId: ctx.organizationId, tenantId: ctx.tenantId }
+
+    const service = resolveQuotingService(ctx)
+    const result = await service.cloneQuote(quoteId, scope)
+    return NextResponse.json(result, { status: 201 })
+  } catch (err) {
+    if (err instanceof QuotingError) {
+      return NextResponse.json({ error: err.message }, { status: err.status })
+    }
+    console.error('[cpq/quotes/[quoteId]/clone.POST]', err)
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 })
+  }
+}

package/src/modules/cpq/api/quotes/[quoteId]/items/[lineId]/route.ts

@@ -0,0 +1,55 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { resolveCpqRouteContext } from '../../../../context'
+import { cpqUpdateQuoteItemSchema } from '../../../../../data/validators'
+import { QuotingError } from '../../../../../services/cpqQuotingService'
+import { resolveQuotingService } from '../../../../resolveQuotingService'
+
+export const metadata = {
+  PUT: { requireAuth: true, requireFeatures: ['cpq.quotes.manage'] },
+  DELETE: { requireAuth: true, requireFeatures: ['cpq.quotes.manage'] },
+}
+
+export async function PUT(req: Request, { params }: { params: Promise<{ quoteId: string; lineId: string }> }) {
+  try {
+    const ctx = await resolveCpqRouteContext(req)
+    if (!ctx.auth) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+
+    const { quoteId, lineId } = await params
+    const body = cpqUpdateQuoteItemSchema.parse(await req.json())
+    const scope = { organizationId: ctx.organizationId, tenantId: ctx.tenantId }
+
+    const service = resolveQuotingService(ctx)
+    const result = await service.updateQuoteItem(quoteId, lineId, body, scope)
+    return NextResponse.json(result)
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      return NextResponse.json({ error: 'Validation error', details: err.issues }, { status: 400 })
+    }
+    if (err instanceof QuotingError) {
+      return NextResponse.json({ error: err.message }, { status: err.status })
+    }
+    console.error('[cpq/quotes/[quoteId]/items/[lineId].PUT]', err)
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 })
+  }
+}
+
+export async function DELETE(req: Request, { params }: { params: Promise<{ quoteId: string; lineId: string }> }) {
+  try {
+    const ctx = await resolveCpqRouteContext(req)
+    if (!ctx.auth) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+
+    const { quoteId, lineId } = await params
+    const scope = { organizationId: ctx.organizationId, tenantId: ctx.tenantId }
+
+    const service = resolveQuotingService(ctx)
+    const result = await service.removeQuoteItem(quoteId, lineId, scope)
+    return NextResponse.json(result)
+  } catch (err) {
+    if (err instanceof QuotingError) {
+      return NextResponse.json({ error: err.message }, { status: err.status })
+    }
+    console.error('[cpq/quotes/[quoteId]/items/[lineId].DELETE]', err)
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 })
+  }
+}

package/src/modules/cpq/api/quotes/[quoteId]/items/route.ts

@@ -0,0 +1,26 @@
+import { NextResponse } from 'next/server'
+import { resolveCpqRouteContext } from '../../../context'
+import { cpqAddQuoteItemSchema } from '../../../../data/validators'
+import { resolveQuotingService } from '../../../resolveQuotingService'
+import { handleArcError } from '../../../_helpers/handleArcError'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['cpq.quotes.manage'] },
+}
+
+export async function POST(req: Request, { params }: { params: Promise<{ quoteId: string }> }) {
+  try {
+    const ctx = await resolveCpqRouteContext(req)
+    if (!ctx.auth) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+
+    const { quoteId } = await params
+    const body = cpqAddQuoteItemSchema.parse(await req.json())
+    const scope = { organizationId: ctx.organizationId, tenantId: ctx.tenantId }
+
+    const service = resolveQuotingService(ctx)
+    const result = await service.addQuoteItem(quoteId, body, scope)
+    return NextResponse.json(result, { status: 201 })
+  } catch (err) {
+    return handleArcError(err, 'cpq/quotes/[quoteId]/items.POST')
+  }
+}

package/src/modules/cpq/api/quotes/[quoteId]/merge-meta/route.ts

@@ -0,0 +1,78 @@
+import { NextResponse } from 'next/server'
+import { resolveCpqRouteContext } from '../../../context'
+import { cpqMergeMetaSchema } from '../../../../data/validators'
+import { resolveQuotingService } from '../../../resolveQuotingService'
+import { handleArcError } from '../../../_helpers/handleArcError'
+
+/**
+ * POST /api/cpq/quotes/[quoteId]/merge-meta
+ *
+ * Stamp the new contract term + optional code/name on a renew quote that
+ * has entered merge mode (≥2 absorb targets). Required before activation.
+ */
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['cpq.arc.renew.manage'] },
+}
+
+export async function POST(
+  req: Request,
+  { params }: { params: Promise<{ quoteId: string }> },
+) {
+  try {
+    const ctx = await resolveCpqRouteContext(req)
+    if (!ctx.auth) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+    const { quoteId } = await params
+    const body = cpqMergeMetaSchema.parse(await req.json())
+    const scope = { organizationId: ctx.organizationId, tenantId: ctx.tenantId }
+    const service = resolveQuotingService(ctx)
+    const result = await service.setMergeMeta(
+      quoteId,
+      {
+        newTermStart: body.newTermStart,
+        newTermEnd: body.newTermEnd,
+        newTermMonths: body.newTermMonths ?? null,
+        newSubCode: body.newSubCode ?? null,
+        newSubName: body.newSubName ?? null,
+      },
+      scope,
+    )
+    return NextResponse.json(result)
+  } catch (err) {
+    return handleArcError(err, 'cpq/quotes/[quoteId]/merge-meta.POST')
+  }
+}
+
+export const openApi = {
+  '/api/cpq/quotes/{quoteId}/merge-meta': {
+    parameters: [
+      { name: 'quoteId', in: 'path', required: true, schema: { type: 'string', format: 'uuid' } },
+    ],
+    post: {
+      tags: ['CPQ ARC'],
+      summary: 'Stamp the new contract term + optional code/name on a merge-renew quote',
+      requestBody: {
+        required: true,
+        content: {
+          'application/json': {
+            schema: {
+              type: 'object',
+              required: ['newTermStart', 'newTermEnd'],
+              properties: {
+                newTermStart: { type: 'string' },
+                newTermEnd: { type: 'string' },
+                newTermMonths: { type: 'integer', minimum: 1 },
+                newSubCode: { type: 'string' },
+                newSubName: { type: 'string' },
+              },
+            },
+          },
+        },
+      },
+      responses: {
+        '200': { description: 'Merge meta stamped' },
+        '404': { description: 'Quote not found' },
+        '409': { description: 'Quote not renew-type or no longer editable' },
+      },
+    },
+  },
+}

package/src/modules/cpq/api/quotes/[quoteId]/recalculate/route.ts

@@ -0,0 +1,34 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { resolveCpqRouteContext } from '../../../context'
+import { cpqRecalculateSchema } from '../../../../data/validators'
+import { QuotingError } from '../../../../services/cpqQuotingService'
+import { resolveQuotingService } from '../../../resolveQuotingService'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['cpq.quotes.view'] },
+}
+
+export async function POST(req: Request, { params }: { params: Promise<{ quoteId: string }> }) {
+  try {
+    const ctx = await resolveCpqRouteContext(req)
+    if (!ctx.auth) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+
+    const { quoteId } = await params
+    const body = cpqRecalculateSchema.parse(await req.json())
+    const scope = { organizationId: ctx.organizationId, tenantId: ctx.tenantId }
+
+    const service = resolveQuotingService(ctx)
+    const result = await service.recalculate(quoteId, body, scope)
+    return NextResponse.json(result)
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      return NextResponse.json({ error: 'Validation error', details: err.issues }, { status: 400 })
+    }
+    if (err instanceof QuotingError) {
+      return NextResponse.json({ error: err.message }, { status: err.status })
+    }
+    console.error('[cpq/quotes/[quoteId]/recalculate.POST]', err)
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 })
+  }
+}