@open-mercato/core 0.4.8-develop-d16e2f51dc → 0.4.8-develop-4b58cde65d

package/src/modules/sales/components/documents/ReturnDialog.tsx

@@ -0,0 +1,216 @@
+"use client"
+
+import * as React from 'react'
+import { Dialog, DialogContent, DialogHeader, DialogTitle } from '@open-mercato/ui/primitives/dialog'
+import { Input } from '@open-mercato/ui/primitives/input'
+import { Textarea } from '@open-mercato/ui/primitives/textarea'
+import { Label } from '@open-mercato/ui/primitives/label'
+import { Button } from '@open-mercato/ui/primitives/button'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { apiCallOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
+import { flash } from '@open-mercato/ui/backend/FlashMessages'
+import { useGuardedMutation } from '@open-mercato/ui/backend/injection/useGuardedMutation'
+
+export type ReturnOrderLine = {
+  id: string
+  title: string
+  lineNumber: number | null
+  quantity: number
+  returnedQuantity: number
+  thumbnail?: string | null
+}
+
+type ReturnDialogProps = {
+  open: boolean
+  orderId: string
+  lines: ReturnOrderLine[]
+  onClose: () => void
+  onSaved: () => Promise<void>
+}
+
+const normalizeNumber = (value: unknown): number => {
+  if (typeof value === 'number' && Number.isFinite(value)) return value
+  if (typeof value === 'string' && value.trim().length) {
+    const parsed = Number(value)
+    if (Number.isFinite(parsed)) return parsed
+  }
+  return 0
+}
+
+export function ReturnDialog({ open, orderId, lines, onClose, onSaved }: ReturnDialogProps) {
+  const t = useT()
+  const { runMutation } = useGuardedMutation({ contextId: `sales-returns-${orderId}` })
+  const [reason, setReason] = React.useState('')
+  const [notes, setNotes] = React.useState('')
+  const [quantities, setQuantities] = React.useState<Record<string, string>>({})
+  const [saving, setSaving] = React.useState(false)
+
+  const availableLines = React.useMemo(() => {
+    return lines
+      .map((line) => {
+        const available = Math.max(0, line.quantity - line.returnedQuantity)
+        return { ...line, available }
+      })
+      .filter((line) => line.available > 0)
+  }, [lines])
+
+  React.useEffect(() => {
+    if (!open) return
+    setReason('')
+    setNotes('')
+    setQuantities({})
+  }, [open])
+
+  const submit = React.useCallback(async () => {
+    if (saving) return
+    let hasInvalidQuantity = false
+    const linesForRequest: Array<{ orderLineId: string; quantity: string }> = []
+    availableLines.forEach((line) => {
+      const raw = quantities[line.id]
+      const qty = normalizeNumber(raw)
+      if (!Number.isFinite(qty) || qty <= 0) return
+      if (qty - 1e-6 > line.available) {
+        hasInvalidQuantity = true
+        return
+      }
+      linesForRequest.push({ orderLineId: line.id, quantity: qty.toString() })
+    })
+
+    if (hasInvalidQuantity) {
+      flash(t('sales.returns.errors.quantityExceeded', 'Cannot return more than available quantity.'), 'error')
+      return
+    }
+
+    if (!linesForRequest.length) {
+      flash(t('sales.returns.errors.linesRequired', 'Select at least one line to return.'), 'error')
+      return
+    }
+
+    setSaving(true)
+    try {
+      await runMutation({
+        context: { kind: 'order', record: { id: orderId } },
+        mutationPayload: { orderId, lines: linesForRequest, reason, notes },
+        operation: async () => {
+          const response = await apiCallOrThrow<{ id: string | null }>(
+            '/api/sales/returns',
+            {
+              method: 'POST',
+              headers: { 'content-type': 'application/json' },
+              body: JSON.stringify({
+                orderId,
+                lines: linesForRequest,
+                ...(reason.trim().length ? { reason: reason.trim() } : {}),
+                ...(notes.trim().length ? { notes: notes.trim() } : {}),
+              }),
+            },
+            { errorMessage: t('sales.returns.errors.create', 'Failed to create return.') },
+          )
+          return response.result?.id ?? null
+        },
+      })
+      flash(t('sales.returns.created', 'Return created.'), 'success')
+      onClose()
+      await onSaved()
+    } catch {
+      flash(t('sales.returns.errors.create', 'Failed to create return.'), 'error')
+    } finally {
+      setSaving(false)
+    }
+  }, [availableLines, notes, onClose, onSaved, orderId, quantities, reason, runMutation, saving, t])
+
+  const onKeyDown = React.useCallback(
+    (e: React.KeyboardEvent) => {
+      if (e.key === 'Escape') onClose()
+      if ((e.key === 'Enter' || e.key === 'NumpadEnter') && (e.metaKey || e.ctrlKey)) {
+        e.preventDefault()
+        submit()
+      }
+    },
+    [onClose, submit],
+  )
+
+  return (
+    <Dialog open={open} onOpenChange={(next) => (!next ? onClose() : undefined)}>
+      <DialogContent onKeyDown={onKeyDown} className="max-w-2xl">
+        <DialogHeader>
+          <DialogTitle>{t('sales.returns.create.title', 'Create return')}</DialogTitle>
+        </DialogHeader>
+
+        <div className="space-y-4">
+          <div className="space-y-2">
+            <div className="text-sm font-medium">{t('sales.returns.create.lines', 'Lines')}</div>
+            {!availableLines.length ? (
+              <div className="text-sm text-muted-foreground">{t('sales.returns.empty.available', 'No items available to return.')}</div>
+            ) : (
+              <div className="max-h-[280px] overflow-auto rounded-md border">
+                <div className="divide-y">
+                  {availableLines.map((line) => {
+                    const value = quantities[line.id] ?? ''
+                    return (
+                      <div key={line.id} className="flex items-center gap-3 p-3">
+                        <div className="min-w-0 flex-1">
+                          <div className="truncate text-sm font-medium">
+                            {line.lineNumber ? `#${line.lineNumber} · ` : ''}
+                            {line.title}
+                          </div>
+                          <div className="text-xs text-muted-foreground">
+                            {t('sales.returns.available', 'Available')}: {line.available}
+                          </div>
+                        </div>
+                        <div className="w-32">
+                          <Label className="sr-only" htmlFor={`return-qty-${line.id}`}>
+                            {t('sales.returns.quantity', 'Quantity')}
+                          </Label>
+                          <Input
+                            id={`return-qty-${line.id}`}
+                            inputMode="decimal"
+                            placeholder="0"
+                            value={value}
+                            onChange={(e) => setQuantities((prev) => ({ ...prev, [line.id]: e.target.value }))}
+                          />
+                        </div>
+                      </div>
+                    )
+                  })}
+                </div>
+              </div>
+            )}
+          </div>
+
+          <div className="grid grid-cols-1 gap-4 md:grid-cols-2">
+            <div className="space-y-1.5">
+              <Label htmlFor="return-reason">{t('sales.returns.reason', 'Reason')}</Label>
+              <Input
+                id="return-reason"
+                value={reason}
+                onChange={(e) => setReason(e.target.value)}
+                placeholder={t('sales.returns.reason.placeholder', 'Optional')}
+              />
+            </div>
+            <div className="space-y-1.5 md:col-span-2">
+              <Label htmlFor="return-notes">{t('sales.returns.notes', 'Notes')}</Label>
+              <Textarea
+                id="return-notes"
+                value={notes}
+                onChange={(e) => setNotes(e.target.value)}
+                placeholder={t('sales.returns.notes.placeholder', 'Optional')}
+                rows={3}
+              />
+            </div>
+          </div>
+
+          <div className="flex items-center justify-end gap-2">
+            <Button type="button" variant="outline" onClick={onClose} disabled={saving}>
+              {t('common.cancel', 'Cancel')}
+            </Button>
+            <Button type="button" onClick={submit} disabled={saving || !availableLines.length}>
+              {saving ? t('common.saving', 'Saving…') : t('sales.returns.create.submit', 'Create return')}
+            </Button>
+          </div>
+        </div>
+      </DialogContent>
+    </Dialog>
+  )
+}
+

package/src/modules/sales/components/documents/ReturnsSection.tsx

@@ -0,0 +1,270 @@
+"use client"
+
+import * as React from 'react'
+import { Undo2, Plus } from 'lucide-react'
+import { Button } from '@open-mercato/ui/primitives/button'
+import { Badge } from '@open-mercato/ui/primitives/badge'
+import { ErrorMessage, LoadingMessage, TabEmptyState } from '@open-mercato/ui/backend/detail'
+import { apiCall } from '@open-mercato/ui/backend/utils/apiCall'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import {
+  emitSalesDocumentTotalsRefresh,
+  subscribeSalesDocumentTotalsRefresh,
+} from '@open-mercato/core/modules/sales/lib/frontend/documentTotalsEvents'
+import { formatMoney, normalizeNumber } from './lineItemUtils'
+import { ReturnDialog, type ReturnOrderLine } from './ReturnDialog'
+
+type ReturnRow = {
+  id: string
+  returnNumber: string
+  status: string | null
+  returnedAt: string | null
+  totalNetAmount: number | null
+  totalGrossAmount: number | null
+}
+
+type SalesReturnsSectionProps = {
+  orderId: string
+  currencyCode?: string | null
+}
+
+function formatDisplayDate(value: string | null | undefined): string | null {
+  if (!value) return null
+  const date = new Date(value)
+  if (Number.isNaN(date.getTime())) return null
+  return new Intl.DateTimeFormat(undefined, { dateStyle: 'medium' }).format(date)
+}
+
+export function SalesReturnsSection({ orderId, currencyCode }: SalesReturnsSectionProps) {
+  const t = useT()
+  const [returns, setReturns] = React.useState<ReturnRow[]>([])
+  const [lines, setLines] = React.useState<ReturnOrderLine[]>([])
+  const [loading, setLoading] = React.useState(false)
+  const [error, setError] = React.useState<string | null>(null)
+  const [dialogOpen, setDialogOpen] = React.useState(false)
+
+  const loadLines = React.useCallback(async () => {
+    const params = new URLSearchParams({ page: '1', pageSize: '100', orderId })
+    const response = await apiCall<{ items?: Array<Record<string, unknown>> }>(
+      `/api/sales/order-lines?${params.toString()}`,
+      undefined,
+      { fallback: { items: [] } },
+    )
+    const items = Array.isArray(response.result?.items) ? response.result?.items ?? [] : []
+    const mapped: ReturnOrderLine[] = items
+      .map((item) => {
+        const map = item as Record<string, unknown>
+        const id = typeof map.id === 'string' ? map.id : null
+        if (!id) return null
+        const snapshot = map['catalog_snapshot']
+        const snapshotName =
+          snapshot && typeof snapshot === 'object' && !Array.isArray(snapshot)
+            ? (snapshot as Record<string, unknown>)['name']
+            : null
+        const name =
+          typeof map.name === 'string'
+            ? map.name
+            : typeof snapshotName === 'string'
+              ? snapshotName
+              : null
+        const lineNumber =
+          typeof map['line_number'] === 'number'
+            ? (map['line_number'] as number)
+            : typeof map.lineNumber === 'number'
+              ? (map.lineNumber as number)
+              : null
+        const quantity =
+          typeof map.quantity === 'number'
+            ? (map.quantity as number)
+            : typeof map.quantity === 'string'
+              ? Number(map.quantity)
+              : 0
+        const returnedQuantity =
+          typeof map['returned_quantity'] === 'number'
+            ? (map['returned_quantity'] as number)
+            : typeof map.returnedQuantity === 'number'
+              ? (map.returnedQuantity as number)
+              : typeof map['returned_quantity'] === 'string'
+                ? Number(map['returned_quantity'])
+                : typeof map.returnedQuantity === 'string'
+                  ? Number(map.returnedQuantity)
+                  : 0
+        return {
+          id,
+          title: name ?? id,
+          lineNumber,
+          quantity: Number.isFinite(quantity) ? quantity : 0,
+          returnedQuantity: Number.isFinite(returnedQuantity) ? returnedQuantity : 0,
+        }
+      })
+      .filter((entry): entry is ReturnOrderLine => Boolean(entry?.id))
+    setLines(mapped)
+  }, [orderId])
+
+  const loadReturns = React.useCallback(async () => {
+    setLoading(true)
+    setError(null)
+    try {
+      const params = new URLSearchParams({ page: '1', pageSize: '100', orderId })
+      const response = await apiCall<{ items?: Array<Record<string, unknown>> }>(
+        `/api/sales/returns?${params.toString()}`,
+        undefined,
+        { fallback: { items: [] } },
+      )
+      const items = Array.isArray(response.result?.items) ? response.result?.items ?? [] : []
+      const mapped: ReturnRow[] = items
+        .map((item) => {
+          const map = item as Record<string, unknown>
+          const id = typeof map.id === 'string' ? map.id : null
+          if (!id) return null
+          const returnNumber =
+            typeof map['return_number'] === 'string'
+              ? (map['return_number'] as string)
+              : typeof map.returnNumber === 'string'
+                ? (map.returnNumber as string)
+                : id
+          const returnedAt =
+            typeof map['returned_at'] === 'string'
+              ? (map['returned_at'] as string)
+              : typeof map.returnedAt === 'string'
+                ? (map.returnedAt as string)
+                : null
+          const totalNetAmount =
+            typeof map['total_net_amount'] === 'number'
+              ? (map['total_net_amount'] as number)
+              : typeof map.totalNetAmount === 'number'
+                ? (map.totalNetAmount as number)
+                : null
+          const totalGrossAmount =
+            typeof map['total_gross_amount'] === 'number'
+              ? (map['total_gross_amount'] as number)
+              : typeof map.totalGrossAmount === 'number'
+                ? (map.totalGrossAmount as number)
+                : null
+          return {
+            id,
+            returnNumber,
+            status: typeof map.status === 'string' ? (map.status as string) : null,
+            returnedAt,
+            totalNetAmount,
+            totalGrossAmount,
+          }
+        })
+        .filter((entry): entry is ReturnRow => Boolean(entry?.id))
+      setReturns(mapped)
+      await loadLines()
+    } catch {
+      setError(t('sales.returns.errors.load', 'Failed to load returns.'))
+    } finally {
+      setLoading(false)
+    }
+  }, [loadLines, orderId, t])
+
+  React.useEffect(() => {
+    loadReturns()
+  }, [loadReturns])
+
+  React.useEffect(() => {
+    return subscribeSalesDocumentTotalsRefresh((detail) => {
+      if (detail.documentId !== orderId) return
+      loadReturns()
+    })
+  }, [loadReturns, orderId])
+
+  const emptyState = React.useMemo(
+    () => ({
+      title: t('sales.returns.empty.title', 'No returns yet.'),
+      description: t('sales.returns.empty.description', 'Create a return to generate credit adjustments for returned items.'),
+    }),
+    [t],
+  )
+
+  const rows = React.useMemo(() => {
+    return returns.map((ret) => {
+      const total = normalizeNumber(ret.totalGrossAmount ?? ret.totalNetAmount ?? 0, 0)
+      return {
+        ...ret,
+        total,
+      }
+    })
+  }, [returns])
+
+  if (loading) return <LoadingMessage label={t('sales.returns.loading', 'Loading returns…')} />
+  if (error) return <ErrorMessage label={error} />
+
+  if (!rows.length) {
+    return (
+      <div className="space-y-4">
+        <TabEmptyState
+          title={emptyState.title}
+          description={emptyState.description}
+          action={{
+            label: t('sales.returns.create', 'Create return'),
+            icon: <Plus className="mr-2 h-4 w-4" aria-hidden />,
+            onClick: () => setDialogOpen(true),
+          }}
+        />
+        <ReturnDialog
+          open={dialogOpen}
+          orderId={orderId}
+          lines={lines}
+          onClose={() => setDialogOpen(false)}
+          onSaved={async () => {
+            emitSalesDocumentTotalsRefresh({ documentId: orderId, kind: 'order' })
+            await loadReturns()
+          }}
+        />
+      </div>
+    )
+  }
+
+  return (
+    <div className="space-y-4">
+      <div className="flex items-center justify-end">
+        <Button type="button" onClick={() => setDialogOpen(true)}>
+          <Plus className="mr-2 h-4 w-4" aria-hidden />
+          {t('sales.returns.create', 'Create return')}
+        </Button>
+      </div>
+
+      <div className="overflow-hidden rounded-md border">
+        <div className="grid grid-cols-[1fr_auto_auto] gap-3 border-b bg-muted/30 px-4 py-2 text-xs font-medium text-muted-foreground">
+          <div>{t('sales.returns.returnNumber', 'Return')}</div>
+          <div className="text-right">{t('sales.returns.returnedAt', 'Returned at')}</div>
+          <div className="text-right">{t('sales.returns.total', 'Total')}</div>
+        </div>
+        <div className="divide-y">
+          {rows.map((ret) => (
+            <div key={ret.id} className="grid grid-cols-[1fr_auto_auto] items-center gap-3 px-4 py-3">
+              <div className="min-w-0">
+                <div className="flex items-center gap-2">
+                  <Undo2 className="h-4 w-4 text-muted-foreground" aria-hidden />
+                  <div className="truncate text-sm font-medium">{ret.returnNumber}</div>
+                  {ret.status ? <Badge variant="secondary">{ret.status}</Badge> : null}
+                </div>
+              </div>
+              <div className="whitespace-nowrap text-right text-sm text-muted-foreground">
+                {formatDisplayDate(ret.returnedAt) ?? t('sales.returns.notSet', 'Not set')}
+              </div>
+              <div className="whitespace-nowrap text-right text-sm font-medium">
+                {formatMoney(ret.total, currencyCode ?? null)}
+              </div>
+            </div>
+          ))}
+        </div>
+      </div>
+
+      <ReturnDialog
+        open={dialogOpen}
+        orderId={orderId}
+        lines={lines}
+        onClose={() => setDialogOpen(false)}
+        onSaved={async () => {
+          emitSalesDocumentTotalsRefresh({ documentId: orderId, kind: 'order' })
+          await loadReturns()
+        }}
+      />
+    </div>
+  )
+}
+

package/src/modules/sales/data/entities.ts

@@ -9,13 +9,13 @@ import {
   Property,
   Unique,
 } from '@mikro-orm/core'
-import { DEFAULT_ORDER_NUMBER_FORMAT, DEFAULT_QUOTE_NUMBER_FORMAT } from '../lib/documentNumberTokens'
+import { DEFAULT_ORDER_NUMBER_FORMAT, DEFAULT_QUOTE_NUMBER_FORMAT, type SalesDocumentNumberKind } from '../lib/documentNumberTokens'
 import type { ShipmentItemSnapshot } from '../lib/shipments/types'
 import type { SalesLineUomSnapshot } from '../lib/types'
 
 export type SalesDocumentKind = 'order' | 'quote' | 'invoice' | 'credit_memo'
 export type SalesLineKind = 'product' | 'service' | 'shipping' | 'discount' | 'adjustment'
-export const DEFAULT_SALES_ADJUSTMENT_KINDS = ['discount', 'tax', 'shipping', 'surcharge', 'custom'] as const
+export const DEFAULT_SALES_ADJUSTMENT_KINDS = ['discount', 'tax', 'shipping', 'surcharge', 'return', 'custom'] as const
 export type SalesAdjustmentKind = (typeof DEFAULT_SALES_ADJUSTMENT_KINDS)[number] | string
 
 @Entity({ tableName: 'sales_channels' })
@@ -813,7 +813,7 @@ export class SalesDocumentSequence {
   tenantId!: string
 
   @Property({ name: 'document_kind', type: 'text' })
-  documentKind!: SalesDocumentKind
+  documentKind!: SalesDocumentNumberKind
 
   @Property({ name: 'current_value', type: 'integer', default: 0 })
   currentValue: number = 0
@@ -1289,6 +1289,102 @@ export class SalesShipmentItem {
   metadata?: Record<string, unknown> | null
 }
 
+@Entity({ tableName: 'sales_returns' })
+@Index({ name: 'sales_returns_scope_idx', properties: ['order', 'organizationId', 'tenantId'] })
+@Index({ name: 'sales_returns_status_idx', properties: ['organizationId', 'tenantId', 'status'] })
+@Unique({ name: 'sales_returns_number_unique', properties: ['organizationId', 'tenantId', 'returnNumber'] })
+export class SalesReturn {
+  [OptionalProps]?: 'createdAt' | 'updatedAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @ManyToOne(() => SalesOrder, { fieldName: 'order_id' })
+  order!: SalesOrder
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'return_number', type: 'text' })
+  returnNumber!: string
+
+  @Property({ name: 'status_entry_id', type: 'uuid', nullable: true })
+  statusEntryId?: string | null
+
+  @Property({ name: 'status', type: 'text', nullable: true })
+  status?: string | null
+
+  @Property({ name: 'reason', type: 'text', nullable: true })
+  reason?: string | null
+
+  @Property({ name: 'notes', type: 'text', nullable: true })
+  notes?: string | null
+
+  @Property({ name: 'returned_at', type: Date, nullable: true })
+  returnedAt?: Date | null
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+
+  @Property({ name: 'deleted_at', type: Date, nullable: true })
+  deletedAt?: Date | null
+
+  @OneToMany(() => SalesReturnLine, (line) => line.salesReturn)
+  lines = new Collection<SalesReturnLine>(this)
+}
+
+@Entity({ tableName: 'sales_return_lines' })
+@Index({ name: 'sales_return_lines_return_idx', properties: ['salesReturn', 'organizationId', 'tenantId'] })
+@Index({ name: 'sales_return_lines_order_line_idx', properties: ['orderLine', 'organizationId', 'tenantId'] })
+export class SalesReturnLine {
+  [OptionalProps]?: 'createdAt' | 'updatedAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @ManyToOne(() => SalesReturn, { fieldName: 'return_id' })
+  salesReturn!: SalesReturn
+
+  @ManyToOne(() => SalesOrderLine, { fieldName: 'order_line_id' })
+  orderLine!: SalesOrderLine
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'quantity_returned', type: 'numeric', precision: 18, scale: 4, default: '0' })
+  quantityReturned: string = '0'
+
+  @Property({ name: 'unit_price_net', type: 'numeric', precision: 18, scale: 4, default: '0' })
+  unitPriceNet: string = '0'
+
+  @Property({ name: 'unit_price_gross', type: 'numeric', precision: 18, scale: 4, default: '0' })
+  unitPriceGross: string = '0'
+
+  @Property({ name: 'total_net_amount', type: 'numeric', precision: 18, scale: 4, default: '0' })
+  totalNetAmount: string = '0'
+
+  @Property({ name: 'total_gross_amount', type: 'numeric', precision: 18, scale: 4, default: '0' })
+  totalGrossAmount: string = '0'
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+
+  @Property({ name: 'deleted_at', type: Date, nullable: true })
+  deletedAt?: Date | null
+}
+
 @Entity({ tableName: 'sales_invoices' })
 @Index({ name: 'sales_invoices_scope_idx', properties: ['order', 'organizationId', 'tenantId'] })
 @Index({ name: 'sales_invoices_status_idx', properties: ['organizationId', 'tenantId', 'status'] })

package/src/modules/sales/data/validators.ts

@@ -618,6 +618,21 @@ export const shipmentUpdateSchema = z
   })
   .merge(shipmentCreateSchema.partial())
 
+export const returnCreateSchema = scoped.extend({
+  orderId: uuid(),
+  reason: z.string().trim().max(4000).optional(),
+  notes: z.string().trim().max(4000).optional(),
+  returnedAt: z.coerce.date().optional(),
+  lines: z
+    .array(
+      z.object({
+        orderLineId: uuid(),
+        quantity: decimal({ min: 0 }),
+      })
+    )
+    .min(1),
+})
+
 export const invoiceCreateSchema = scoped.extend({
   orderId: uuid().optional(),
   invoiceNumber: z.string().trim().min(1).max(191),
@@ -815,6 +830,7 @@ export type QuoteAdjustmentCreateInput = z.infer<typeof quoteAdjustmentCreateSch
 export type QuoteAdjustmentUpdateInput = z.infer<typeof quoteAdjustmentUpdateSchema>
 export type ShipmentCreateInput = z.infer<typeof shipmentCreateSchema>
 export type ShipmentUpdateInput = z.infer<typeof shipmentUpdateSchema>
+export type ReturnCreateInput = z.infer<typeof returnCreateSchema>
 export type InvoiceCreateInput = z.infer<typeof invoiceCreateSchema>
 export type InvoiceUpdateInput = z.infer<typeof invoiceUpdateSchema>
 export type CreditMemoCreateInput = z.infer<typeof creditMemoCreateSchema>

package/src/modules/sales/events.ts

@@ -36,6 +36,11 @@ const events = [
   { id: 'sales.shipment.updated', label: 'Shipment Updated', entity: 'shipment', category: 'crud' },
   { id: 'sales.shipment.deleted', label: 'Shipment Deleted', entity: 'shipment', category: 'crud' },
 
+  // Returns
+  { id: 'sales.return.created', label: 'Return Created', entity: 'return', category: 'crud' },
+  { id: 'sales.return.updated', label: 'Return Updated', entity: 'return', category: 'crud' },
+  { id: 'sales.return.deleted', label: 'Return Deleted', entity: 'return', category: 'crud' },
+
   // Notes
   { id: 'sales.note.created', label: 'Note Created', entity: 'note', category: 'crud' },
   { id: 'sales.note.updated', label: 'Note Updated', entity: 'note', category: 'crud' },