@dainamite/cpq 0.2.2

package/src/modules/cpq/api/quotes/validate-relationships/route.ts

@@ -0,0 +1,100 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { resolveCpqRouteContext } from '../../context'
+import { cpqValidateRelationshipsSchema } from '../../../data/validators'
+import { DefaultCpqValidationService } from '../../../services/cpqValidationService'
+import {
+  CpqProductOffering,
+  CpqProductSpecification,
+  CpqProductRelationship,
+} from '../../../data/entities'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['cpq.quotes.view'] },
+}
+
+export async function POST(req: Request) {
+  try {
+    const ctx = await resolveCpqRouteContext(req)
+    if (!ctx.auth) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+
+    const body = cpqValidateRelationshipsSchema.parse(await req.json())
+    const scope = { organizationId: ctx.organizationId, tenantId: ctx.tenantId }
+    const dbScope = { ...scope, deletedAt: null }
+
+    // Resolve offerings -> specs
+    const offerings = await ctx.em.find(CpqProductOffering, {
+      id: { $in: body.offeringIds },
+      ...dbScope,
+    })
+
+    const specIds = [...new Set(offerings.map((o) => o.specId))]
+
+    // Build mock lines for relationship validation
+    const lines = offerings.map((o, i) => ({
+      lineId: `mock-${i}`,
+      specId: o.specId,
+      parentLineId: null as string | null,
+    }))
+
+    // Apply parent-child pairs
+    if (body.parentChildPairs) {
+      for (const pair of body.parentChildPairs) {
+        const parentOffering = offerings.find((o) => o.id === pair.parentOfferingId)
+        const childLine = lines.find((l) => {
+          const off = offerings.find((o) => o.specId === l.specId && o.id === pair.childOfferingId)
+          return !!off
+        })
+        const parentLine = lines.find((l) => {
+          const off = offerings.find((o) => o.specId === l.specId && o.id === pair.parentOfferingId)
+          return !!off
+        })
+        if (childLine && parentLine) {
+          childLine.parentLineId = parentLine.lineId
+        }
+      }
+    }
+
+    const validationService = ctx.container.resolve('cpqValidationService') as DefaultCpqValidationService
+    const errors = await validationService.validateRelationships({ lines, scope })
+
+    // Load allowed child specs
+    const parentChildRels = await ctx.em.find(CpqProductRelationship, {
+      sourceSpecId: { $in: specIds },
+      relationshipType: 'parent_child',
+      isActive: true,
+      ...dbScope,
+    })
+
+    const childSpecIds = [...new Set(parentChildRels.map((r) => r.targetSpecId))]
+    const childSpecs = childSpecIds.length > 0
+      ? await ctx.em.find(CpqProductSpecification, { id: { $in: childSpecIds }, ...dbScope })
+      : []
+
+    const allowedChildSpecs = parentChildRels.map((rel) => {
+      const spec = childSpecs.find((s) => s.id === rel.targetSpecId)
+      const currentCount = lines.filter((l) => l.specId === rel.targetSpecId).length
+      return {
+        specId: rel.targetSpecId,
+        code: spec?.code ?? '',
+        name: spec?.name ?? '',
+        productId: spec?.productId ?? '',
+        cardinalityMin: rel.cardinalityMin,
+        cardinalityMax: rel.cardinalityMax ?? null,
+        currentCount,
+      }
+    })
+
+    return NextResponse.json({
+      valid: errors.length === 0,
+      errors,
+      allowedChildSpecs,
+    })
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      return NextResponse.json({ error: 'Validation error', details: err.issues }, { status: 400 })
+    }
+    console.error('[cpq/quotes/validate-relationships.POST]', err)
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 })
+  }
+}

package/src/modules/cpq/api/resolveQuotingService.ts

@@ -0,0 +1,11 @@
+import type { CpqRouteContext } from './context'
+import type { DefaultCpqQuotingService } from '../services/cpqQuotingService'
+
+/**
+ * Resolve CpqQuotingService from the DI container.
+ * All sub-services (pricing, validation, product) are registered as scoped in di.ts,
+ * ensuring they share the same request-scoped EntityManager.
+ */
+export function resolveQuotingService(ctx: CpqRouteContext): DefaultCpqQuotingService {
+  return ctx.container.resolve('cpqQuotingService') as DefaultCpqQuotingService
+}

package/src/modules/cpq/api/wizards/resolve/route.ts

@@ -0,0 +1,39 @@
+import { NextResponse } from 'next/server'
+import { resolveCpqRouteContext } from '../../context'
+import { DefaultCpqWizardService } from '../../../services/cpqWizardService'
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['cpq.wizards.view'] },
+}
+
+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 surface = url.searchParams.get('surface')
+    if (!surface || !['backend', 'portal'].includes(surface)) {
+      return NextResponse.json({ error: 'Missing or invalid surface parameter' }, { status: 400 })
+    }
+
+    const scope = { organizationId: ctx.organizationId, tenantId: ctx.tenantId }
+    const service = new DefaultCpqWizardService(ctx.em)
+
+    const result = await service.resolveWizard(
+      {
+        surface: surface as 'backend' | 'portal',
+        specCode: url.searchParams.get('specCode') ?? undefined,
+        offeringCode: url.searchParams.get('offeringCode') ?? undefined,
+        customerSegment: url.searchParams.get('customerSegment') ?? undefined,
+      },
+      scope,
+    )
+
+    if (!result) return NextResponse.json({ error: 'Not found' }, { status: 404 })
+    return NextResponse.json(result)
+  } catch (err) {
+    console.error('[cpq/wizards/resolve.GET]', err)
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 })
+  }
+}

package/src/modules/cpq/api/wizards/route.ts

@@ -0,0 +1,127 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import { resolveCpqRouteContext } from '../context'
+import { cpqWizardDefinitionCreateSchema, cpqWizardDefinitionUpdateSchema } from '../../data/validators'
+import { DefaultCpqWizardService } from '../../services/cpqWizardService'
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['cpq.wizards.view'] },
+  POST: { requireAuth: true, requireFeatures: ['cpq.wizards.manage'] },
+  PUT: { requireAuth: true, requireFeatures: ['cpq.wizards.manage'] },
+  DELETE: { requireAuth: true, requireFeatures: ['cpq.wizards.manage'] },
+}
+
+function resolveWizardService(ctx: { em: import('@mikro-orm/postgresql').EntityManager }) {
+  return new DefaultCpqWizardService(ctx.em)
+}
+
+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 }
+    const service = resolveWizardService(ctx)
+
+    // Detail view
+    const id = url.searchParams.get('id')
+    const code = url.searchParams.get('code')
+    if (id || code) {
+      const result = await service.getDefinition((id ?? code)!, scope)
+      if (!result) return NextResponse.json({ error: 'Not found' }, { status: 404 })
+      return NextResponse.json(result)
+    }
+
+    // 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 surface = url.searchParams.get('surface') ?? undefined
+    const isActiveParam = url.searchParams.get('isActive')
+    const isActive = isActiveParam !== null ? isActiveParam === 'true' : undefined
+    const search = url.searchParams.get('search') ?? undefined
+
+    const ALLOWED_SORT_FIELDS = ['createdAt', 'updatedAt', 'name', 'code', 'surface'] 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])
+      : undefined
+    const sortDir = url.searchParams.get('sortDir') === 'asc' ? 'asc' : 'desc'
+
+    return NextResponse.json(
+      await service.listDefinitions(
+        { surface, isActive, search, sortField, sortDir },
+        scope,
+        page,
+        pageSize,
+      ),
+    )
+  } catch (err) {
+    console.error('[cpq/wizards.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 = cpqWizardDefinitionCreateSchema.parse(await req.json())
+    const scope = { organizationId: ctx.organizationId, tenantId: ctx.tenantId }
+    const service = resolveWizardService(ctx)
+
+    const result = await service.createDefinition(body, scope)
+    return NextResponse.json(result, { status: 201 })
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      return NextResponse.json({ error: 'Validation error', details: err.issues }, { status: 400 })
+    }
+    console.error('[cpq/wizards.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 = cpqWizardDefinitionUpdateSchema.parse(await req.json())
+    const { id, ...updates } = body
+    const scope = { organizationId: ctx.organizationId, tenantId: ctx.tenantId }
+    const service = resolveWizardService(ctx)
+
+    const result = await service.updateDefinition(id, updates, scope)
+    if (!result) return NextResponse.json({ error: 'Not found' }, { status: 404 })
+
+    return NextResponse.json(result)
+  } catch (err) {
+    if (err instanceof z.ZodError) {
+      return NextResponse.json({ error: 'Validation error', details: err.issues }, { status: 400 })
+    }
+    console.error('[cpq/wizards.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 }
+    const service = resolveWizardService(ctx)
+
+    const deleted = await service.deleteDefinition(id, scope)
+    if (!deleted) return NextResponse.json({ error: 'Not found' }, { status: 404 })
+
+    return NextResponse.json({ success: true })
+  } catch (err) {
+    console.error('[cpq/wizards.DELETE]', err)
+    return NextResponse.json({ error: 'Internal error' }, { status: 500 })
+  }
+}

package/src/modules/cpq/backend/cpq/inventory/AssetsTable.tsx

@@ -0,0 +1,166 @@
+"use client"
+import * as React from 'react'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { useRouter } from 'next/navigation'
+import type { ColumnDef } from '@tanstack/react-table'
+import { DataTable } from '@open-mercato/ui/backend/DataTable'
+import { RowActions } from '@open-mercato/ui/backend/RowActions'
+import type { FilterDef, FilterValues } from '@open-mercato/ui/backend/FilterBar'
+import { useCpqListData } from '../../../components/CpqListView'
+import { useCpqRowActions } from '../../../components/useCpqRowActions'
+import { StatusBadge, formatCurrency } from './shared'
+
+type Asset = {
+  id: string
+  code: string
+  name: string
+  status: string
+  assetType: string
+  purchasePrice: number
+  currencyCode: string
+  createdAt: string
+}
+
+const PAGE_SIZE = 50
+
+const ASSET_STATUS_OPTIONS = [
+  { value: 'pending', label: 'Pending' },
+  { value: 'delivered', label: 'Delivered' },
+  { value: 'active', label: 'Active' },
+  { value: 'returned', label: 'Returned' },
+  { value: 'cancelled', label: 'Cancelled' },
+] as const
+
+function buildFilterParams(values: FilterValues, params: URLSearchParams) {
+  if (typeof values.status === 'string' && values.status) {
+    params.set('status', values.status)
+  }
+  if (typeof values.assetType === 'string' && values.assetType.trim()) {
+    params.set('assetType', values.assetType.trim())
+  }
+}
+
+export function AssetsTable() {
+  const t = useT()
+  const router = useRouter()
+
+  const data = useCpqListData<Asset>({
+    endpoint: '/api/cpq/inventory/assets',
+    pageSize: PAGE_SIZE,
+    buildFilterParams,
+    loadErrorMessage: t('cpq.inventory.assets.error.load', 'Failed to load assets'),
+  })
+
+  // Assets follow a `delivered → active → returned` lifecycle; deletion only
+  // makes sense before the asset is provisioned, so gate by status.
+  const rowActionsApi = useCpqRowActions<Asset>({
+    endpoint: '/api/cpq/inventory/assets',
+    entityName: t('cpq.inventory.assets.entityName', 'asset'),
+    editHref: (row) => `/backend/cpq/inventory/assets/${row.id}`,
+    onReload: data.reload,
+    canDelete: (row) => row.status === 'pending' || row.status === 'cancelled',
+  })
+
+  const filters = React.useMemo<FilterDef[]>(
+    () => [
+      {
+        id: 'status',
+        label: t('cpq.inventory.filters.status', 'Status'),
+        type: 'select',
+        options: [...ASSET_STATUS_OPTIONS],
+      },
+      {
+        id: 'assetType',
+        label: t('cpq.inventory.filters.assetType', 'Asset Type'),
+        type: 'text',
+      },
+    ],
+    [t],
+  )
+
+  const columns = React.useMemo<ColumnDef<Asset>[]>(
+    () => [
+      {
+        accessorKey: 'code',
+        header: t('cpq.inventory.assets.table.code', 'Code'),
+        cell: ({ row }) => <span className="text-muted-foreground">{row.original.code}</span>,
+      },
+      {
+        accessorKey: 'name',
+        header: t('cpq.inventory.assets.table.name', 'Name'),
+        cell: ({ row }) => <span className="font-medium text-primary">{row.original.name}</span>,
+      },
+      {
+        accessorKey: 'assetType',
+        header: t('cpq.inventory.assets.table.type', 'Type'),
+      },
+      {
+        accessorKey: 'status',
+        header: t('cpq.inventory.assets.table.status', 'Status'),
+        cell: ({ row }) => <StatusBadge status={row.original.status} />,
+      },
+      {
+        accessorKey: 'purchasePrice',
+        header: t('cpq.inventory.assets.table.price', 'Price'),
+        cell: ({ row }) => (
+          <span className="font-mono">
+            {formatCurrency(row.original.purchasePrice, row.original.currencyCode || 'USD')}
+          </span>
+        ),
+      },
+      {
+        accessorKey: 'createdAt',
+        header: t('cpq.inventory.assets.table.created', 'Created'),
+        cell: ({ row }) => (
+          <span>
+            {row.original.createdAt ? new Date(row.original.createdAt).toLocaleDateString() : '—'}
+          </span>
+        ),
+      },
+    ],
+    [t],
+  )
+
+  return (
+    <>
+      {rowActionsApi.ConfirmDialogElement}
+      <DataTable<Asset>
+      title={t('cpq.inventory.assets', 'Assets')}
+      refreshButton={{
+        label: t('cpq.inventory.actions.refresh', 'Refresh'),
+        onRefresh: data.reload,
+        isRefreshing: data.isLoading,
+      }}
+      columns={columns}
+      data={data.rows}
+      searchValue={data.search}
+      onSearchChange={data.setSearch}
+      searchPlaceholder={t('cpq.inventory.assets.search.placeholder', 'Search assets...')}
+      filters={filters}
+      filterValues={data.filterValues}
+      onFiltersApply={data.setFilterValues}
+      onFiltersClear={data.clearFilters}
+      sorting={data.sorting}
+      onSortingChange={data.setSorting}
+      onRowClick={(row) => router.push(`/backend/cpq/inventory/assets/${row.id}`)}
+      rowActions={(row) => <RowActions items={rowActionsApi.buildItems(row)} />}
+      perspective={{ tableId: 'cpq.inventory.assets.list' }}
+      columnChooser={{ auto: true }}
+      pagination={{
+        page: data.page,
+        pageSize: PAGE_SIZE,
+        total: data.total,
+        totalPages: data.totalPages,
+        onPageChange: data.setPage,
+        durationMs: data.durationMs,
+      }}
+      isLoading={data.isLoading}
+      emptyState={
+        <div className="rounded-lg border bg-card p-6 text-center text-sm text-muted-foreground">
+          {t('cpq.inventory.assets.empty', 'No assets found.')}
+        </div>
+      }
+    />
+    </>
+  )
+}