@open-mercato/core 0.6.8-develop.6925.1.cefa200fa4 → 0.6.8-develop.6931.1.4a1e1c786b

package/src/modules/eudr/lib/reference-data.ts

@@ -0,0 +1,128 @@
+import type { EudrCommodity } from '../data/validators'
+
+/**
+ * EUDR reference data.
+ *
+ * Source: Commission Implementing Regulation (EU) 2025/1093 country
+ * benchmarking (22 May 2025; in force — the July 2025 EP objection was
+ * non-binding — subject to the Commission's 2026 review), the Commission
+ * Green Forum country-classification list (cross-checked against independent
+ * reproductions; 141 low-risk + 4 high-risk entries), EUDR application dates,
+ * and Annex-I/Appendix-I HS data. Effective as of 2026-07. Keep this file as
+ * the single update point when the legal reference data changes. Unlisted
+ * countries (~48 standard-risk, e.g. BR, ID, MY, and IL per corroborated
+ * sources) default to `standard` so full due diligence remains the
+ * conservative fallback. Note: CD (DR Congo) is standard; CG (Congo) is low.
+ */
+
+export type EudrCountryRiskTier = 'low' | 'standard' | 'high' | 'unknown'
+
+export const EUDR_HIGH_RISK_COUNTRIES = ['BY', 'KP', 'MM', 'RU'] as const
+
+export const EUDR_LOW_RISK_COUNTRIES = [
+  'AD', 'AE', 'AF', 'AG', 'AL', 'AM', 'AT', 'AU', 'AZ', 'BA', 'BB', 'BD',
+  'BE', 'BG', 'BH', 'BI', 'BN', 'BS', 'BT', 'CA', 'CF', 'CG', 'CH', 'CL',
+  'CN', 'CR', 'CU', 'CV', 'CY', 'CZ', 'DE', 'DJ', 'DK', 'DM', 'DO', 'DZ',
+  'EE', 'EG', 'ES', 'FI', 'FJ', 'FM', 'FR', 'GA', 'GB', 'GD', 'GE', 'GH',
+  'GR', 'GY', 'HR', 'HU', 'IE', 'IN', 'IQ', 'IR', 'IS', 'IT', 'JM', 'JO',
+  'JP', 'KE', 'KG', 'KI', 'KM', 'KN', 'KR', 'KW', 'KZ', 'LA', 'LB', 'LC',
+  'LI', 'LK', 'LS', 'LT', 'LU', 'LV', 'LY', 'MA', 'MC', 'MD', 'ME', 'MG',
+  'MH', 'MK', 'ML', 'MN', 'MT', 'MU', 'MV', 'NL', 'NO', 'NP', 'NR', 'NZ',
+  'OM', 'PG', 'PH', 'PL', 'PS', 'PT', 'PW', 'QA', 'RO', 'RS', 'RW', 'SA',
+  'SB', 'SC', 'SE', 'SG', 'SI', 'SK', 'SM', 'SR', 'SS', 'ST', 'SY', 'SZ',
+  'TG', 'TH', 'TJ', 'TL', 'TM', 'TN', 'TO', 'TR', 'TT', 'TV', 'UA', 'UG',
+  'US', 'UY', 'UZ', 'VC', 'VN', 'VU', 'WS', 'YE', 'ZA',
+] as const
+
+export function getCountryRiskTier(code: string | null | undefined): EudrCountryRiskTier {
+  const normalized = code?.trim().toUpperCase() ?? ''
+  if (!/^[A-Z]{2}$/.test(normalized)) return 'unknown'
+  if ((EUDR_HIGH_RISK_COUNTRIES as readonly string[]).includes(normalized)) return 'high'
+  if ((EUDR_LOW_RISK_COUNTRIES as readonly string[]).includes(normalized)) return 'low'
+  return 'standard'
+}
+
+export const EUDR_APPLICATION_DATES = {
+  largeAndMedium: '2026-12-30',
+  microAndSmallNonTimber: '2027-06-30',
+} as const
+
+export const EUDR_SUPPLEMENTARY_UNIT_HS_PREFIXES = [
+  '4011',
+  '4013',
+  '4104',
+  '4403',
+  '4406',
+  '4408',
+  '4410',
+  '4411',
+  '4412',
+  '4413',
+  '4701',
+  '4702',
+  '4704',
+  '4705',
+] as const
+
+export const EUDR_ANNEX1_HS_PREFIXES: Record<EudrCommodity, readonly string[]> = {
+  cattle: ['0102', '0201', '0202', '0206', '1602'],
+  cocoa: ['1801', '1802', '1803', '1804', '1805', '1806'],
+  coffee: ['0901', '2101'],
+  oil_palm: ['1511', '1513', '2306', '1207', '3823', '2905'],
+  rubber: ['4001', '4005', '4006', '4007', '4008', '4009', '4010', '4011', '4012', '4013', '4015', '4016', '4017'],
+  soya: ['1201', '1208', '1507', '2304'],
+  wood: [
+    '4401',
+    '4402',
+    '4403',
+    '4404',
+    '4405',
+    '4406',
+    '4407',
+    '4408',
+    '4409',
+    '4410',
+    '4411',
+    '4412',
+    '4413',
+    '4414',
+    '4415',
+    '4416',
+    '4417',
+    '4418',
+    '4419',
+    '4420',
+    '4421',
+    '9401',
+    '9403',
+    '9406',
+    '44',
+    '47',
+    '48',
+  ],
+} as const
+
+export function suggestCommodityForHsCode(hsCode: string | null | undefined): EudrCommodity | null {
+  const digits = hsCode?.replace(/\D/g, '') ?? ''
+  if (digits.length === 0) return null
+
+  let match: { commodity: EudrCommodity; prefixLength: number } | null = null
+  for (const [commodity, prefixes] of Object.entries(EUDR_ANNEX1_HS_PREFIXES) as Array<[EudrCommodity, readonly string[]]>) {
+    for (const prefix of prefixes) {
+      if (!digits.startsWith(prefix)) continue
+      if (match !== null && prefix.length <= match.prefixLength) continue
+      match = { commodity, prefixLength: prefix.length }
+    }
+  }
+
+  return match?.commodity ?? null
+}
+
+export const EUDR_RISK_CRITERIA_GROUPS = [
+  { key: 'country', criteria: ['deforestation_trend', 'environmental_governance', 'corruption_land_use'] },
+  { key: 'supply_chain', criteria: ['chain_complexity', 'intermediaries_count', 'mixing_risk', 'prior_noncompliance'] },
+  { key: 'plot_supplier', criteria: ['land_title_permits', 'indigenous_rights', 'protected_areas', 'labor_human_rights', 'plot_deforestation_history'] },
+  { key: 'documentation', criteria: ['document_completeness', 'document_verifiability', 'supplier_transparency'] },
+] as const
+
+export const EUDR_RISK_CRITERIA_KEYS: readonly string[] = EUDR_RISK_CRITERIA_GROUPS.flatMap((group) => [...group.criteria])

package/src/modules/eudr/lib/species.ts

@@ -0,0 +1,12 @@
+import type { EudrCommodity } from '../data/validators'
+
+export const WOOD_COMMODITY = 'wood' satisfies EudrCommodity
+
+export function hasMissingSpecies(mapping: {
+  commodity: string
+  speciesScientificName?: string | null
+  speciesCommonName?: string | null
+}): boolean {
+  if (mapping.commodity !== WOOD_COMMODITY) return false
+  return !mapping.speciesScientificName?.trim() || !mapping.speciesCommonName?.trim()
+}

package/src/modules/eudr/lib/statement-lifecycle.ts

@@ -0,0 +1,109 @@
+import type { EudrStatementStatus } from '../data/validators'
+import { getCountryRiskTier } from './reference-data'
+
+export const EUDR_STATEMENT_TRANSITIONS: Record<EudrStatementStatus, readonly EudrStatementStatus[]> = {
+  draft: ['submitted', 'archived'],
+  submitted: ['draft', 'available', 'archived'],
+  available: ['withdrawn', 'archived'],
+  withdrawn: ['archived'],
+  archived: [],
+}
+
+export function canTransition(from: EudrStatementStatus, to: EudrStatementStatus): boolean {
+  return EUDR_STATEMENT_TRANSITIONS[from].includes(to)
+}
+
+export const EUDR_AMEND_GUARDED_FIELDS = [
+  'commodity',
+  'quantityKg',
+  'supplementaryUnit',
+  'supplementaryQuantity',
+  'referencedStatements',
+  'orderId',
+] as const
+
+export const EUDR_AMEND_WINDOW_MS = 72 * 60 * 60 * 1000
+
+export function isAmendWindowOpen(referenceIssuedAt: Date | null | undefined, now: Date = new Date()): boolean {
+  if (referenceIssuedAt == null) return false
+  const issuedAtMs = referenceIssuedAt.getTime()
+  if (Number.isNaN(issuedAtMs)) return false
+  const elapsedMs = now.getTime() - issuedAtMs
+  return elapsedMs >= 0 && elapsedMs <= EUDR_AMEND_WINDOW_MS
+}
+
+export type GateSubmissionView = { status: string; completenessScore: number; originCountry: string | null }
+export type GateAssessmentView = {
+  conclusion: string
+  countryRisks: Array<{ country: string; tier: string }>
+  reviewDueAt: Date | string | null
+  hasConcernAnswers: boolean
+  hasCompletedMitigation: boolean
+} | null
+export type GateResult = { allowed: boolean; reasons: string[] }
+
+function normalizeCountry(value: string | null): string | null {
+  const normalized = value?.trim().toUpperCase() ?? ''
+  return normalized.length > 0 ? normalized : null
+}
+
+function parseDate(value: Date | string | null): Date | null {
+  if (value == null) return null
+  const date = value instanceof Date ? value : new Date(value)
+  return Number.isNaN(date.getTime()) ? null : date
+}
+
+function hasSameCountries(left: Set<string>, right: Set<string>): boolean {
+  if (left.size !== right.size) return false
+  for (const country of left) {
+    if (!right.has(country)) return false
+  }
+  return true
+}
+
+export function evaluateSubmissionGate(input: {
+  actorRole: string | null
+  referencedStatementsCount: number
+  submissions: GateSubmissionView[]
+  latestAssessment: GateAssessmentView
+  now?: Date
+}): GateResult {
+  const reasons: string[] = []
+
+  if (input.actorRole === 'sme_trader') {
+    if (input.referencedStatementsCount < 1) reasons.push('referencedStatementsRequired')
+    return { allowed: reasons.length === 0, reasons }
+  }
+
+  if (input.submissions.length === 0) reasons.push('noSubmissions')
+  if (input.submissions.some((submission) => submission.status !== 'verified' || submission.completenessScore !== 100)) {
+    reasons.push('submissionsNotReady')
+  }
+  if (input.submissions.some((submission) => normalizeCountry(submission.originCountry) === null)) {
+    reasons.push('originCountryMissing')
+  }
+
+  const currentCountries = new Set(
+    input.submissions
+      .map((submission) => normalizeCountry(submission.originCountry))
+      .filter((country): country is string => country !== null),
+  )
+  const allCountriesPresent = input.submissions.length > 0 && input.submissions.every((submission) => normalizeCountry(submission.originCountry) !== null)
+  const tiers = [...currentCountries].map((country) => getCountryRiskTier(country))
+  const simplifiedDueDiligenceSatisfied = allCountriesPresent && tiers.length > 0 && tiers.every((tier) => tier === 'low')
+
+  if (!simplifiedDueDiligenceSatisfied) {
+    const assessment = input.latestAssessment
+    if (assessment == null || assessment.conclusion !== 'negligible') reasons.push('riskConclusionMissing')
+    if (assessment != null) {
+      const assessedCountries = new Set(assessment.countryRisks.map((risk) => risk.country.trim().toUpperCase()).filter((country) => country.length > 0))
+      if (!hasSameCountries(currentCountries, assessedCountries)) reasons.push('riskAssessmentStale')
+
+      const reviewDueAt = parseDate(assessment.reviewDueAt)
+      if (reviewDueAt !== null && reviewDueAt.getTime() < (input.now ?? new Date()).getTime()) reasons.push('riskReviewOverdue')
+      if (assessment.hasConcernAnswers && !assessment.hasCompletedMitigation) reasons.push('mitigationIncomplete')
+    }
+  }
+
+  return { allowed: reasons.length === 0, reasons }
+}

package/src/modules/eudr/lib/statement-seeding.ts

@@ -0,0 +1,86 @@
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+export type StatementSeedingParams =
+  | { mode: 'duplicate'; id: string; ignoredOrder?: boolean }
+  | { mode: 'order'; id: string }
+  | { mode: 'none'; ignoredOrder?: boolean }
+
+export type StatementSeedSource = {
+  id?: string | null
+  title?: string | null
+  commodity?: string | null
+  activityType?: string | null
+  actorRole?: string | null
+  orderId?: string | null
+  quantityKg?: number | string | null
+  supplementaryUnit?: string | null
+  supplementaryQuantity?: number | string | null
+  notes?: string | null
+}
+
+export type StatementSeedValues = {
+  title: string
+  commodity: string
+  activityType: string
+  actorRole: string
+  orderId: string
+  quantityKg: string
+  supplementaryUnit: string
+  supplementaryQuantity: string
+  notes: string
+}
+
+function validUuid(value: string | null): string | null {
+  if (!value) return null
+  const trimmed = value.trim()
+  return UUID_PATTERN.test(trimmed) ? trimmed : null
+}
+
+function textValue(value: string | null | undefined): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function numberTextValue(value: number | string | null | undefined): string {
+  return typeof value === 'number' || typeof value === 'string' ? String(value) : ''
+}
+
+export function resolveSeedingParams(
+  searchParams: { get(name: string): string | null },
+): StatementSeedingParams {
+  const duplicateId = validUuid(searchParams.get('duplicateFrom'))
+  const orderId = validUuid(searchParams.get('orderId'))
+
+  if (duplicateId) {
+    return orderId
+      ? { mode: 'duplicate', id: duplicateId, ignoredOrder: true }
+      : { mode: 'duplicate', id: duplicateId }
+  }
+  if (orderId) return { mode: 'order', id: orderId }
+  return { mode: 'none' }
+}
+
+export function buildDuplicateSeed(source: StatementSeedSource): Partial<StatementSeedValues> {
+  return {
+    title: textValue(source.title),
+    commodity: textValue(source.commodity),
+    activityType: textValue(source.activityType),
+    actorRole: textValue(source.actorRole),
+    orderId: textValue(source.orderId),
+    quantityKg: numberTextValue(source.quantityKg),
+    supplementaryUnit: textValue(source.supplementaryUnit),
+    supplementaryQuantity: numberTextValue(source.supplementaryQuantity),
+    notes: textValue(source.notes),
+  }
+}
+
+export function pickUnambiguousCommodity(
+  mappings: Array<{ commodity: string; isInScope: boolean }>,
+): string | null {
+  const commodities = new Set<string>()
+  for (const mapping of mappings) {
+    if (!mapping.isInScope) continue
+    const commodity = mapping.commodity.trim()
+    if (commodity) commodities.add(commodity)
+  }
+  return commodities.size === 1 ? Array.from(commodities)[0] : null
+}