feat(verification): add regulatory adapters registry and router

src/verification/adapters/implementations/eu.adapter.ts

@@ -0,0 +1,125 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { RegulatoryAdapterImplementation } from '../regulatory-adapter.decorator';
+import { RegulatoryAdapter } from '../regulatory-adapter.interface';
+import { VerificationResult } from '../../contracts/verification-result.interface';
+import { Region } from '../../../verify/providers/region-inference-provider/region.enums';
+import { NormalizedProduct } from '../../../verify/providers/region-inference-provider/interface/normalized-product.interface';
+
+@RegulatoryAdapterImplementation()
+@Injectable()
+export class EUAdapter implements RegulatoryAdapter {
+  readonly region = Region.EU;
+
+  private readonly logger = new Logger(EUAdapter.name);
+
+  async verifyProduct(product: NormalizedProduct): Promise<VerificationResult> {
+    const verificationStartedAt = new Date();
+
+    try {
+      const labels = this.normalizeStringArray(product.labels);
+      const languages = this.normalizeStringArray(product.languages);
+      const manufacturingCountries = this.normalizeStringArray(
+        product.manufacturingCountries,
+      );
+
+      const hasEuropeanSignal =
+        labels.some((value) => value.includes('eu')) ||
+        labels.some((value) => value.includes('european')) ||
+        manufacturingCountries.some((value) => this.isEuropeanCountryToken(value));
+
+      this.logger.log(
+        JSON.stringify({
+          msg: 'regulatory_verification_attempt',
+          regulator: 'EU',
+          barcode: product.barcode,
+          hasEuropeanSignal,
+        }),
+      );
+
+      if (!hasEuropeanSignal) {
+        return {
+          verified: false,
+          status: 'NOT_FOUND',
+          regulator: 'EU',
+          region: Region.EU,
+          confidence: 0.25,
+          warnings: ['no_eu_signals_detected'],
+          metadata: {
+            signals: {
+              labels: labels.length,
+              languages: languages.length,
+              manufacturingCountries: manufacturingCountries.length,
+            },
+          },
+          verifiedAt: verificationStartedAt.toISOString(),
+        };
+      }
+
+      const hasMultipleLanguages = new Set(languages).size >= 2;
+      const warnings = hasMultipleLanguages ? ['multi_language_packaging'] : [];
+
+      return {
+        verified: true,
+        status: 'VERIFIED',
+        regulator: 'EU',
+        region: Region.EU,
+        confidence: 0.65,
+        warnings: warnings.length > 0 ? warnings : undefined,
+        metadata: {
+          verificationMethod: 'heuristic_precheck',
+        },
+        verifiedAt: verificationStartedAt.toISOString(),
+      };
+    } catch (error) {
+      const errorObject = error as Error;
+      this.logger.error(
+        JSON.stringify({
+          msg: 'regulatory_verification_failed',
+          regulator: 'EU',
+          barcode: product.barcode,
+          errorName: errorObject?.name,
+          errorMessage: errorObject?.message,
+        }),
+      );
+
+      return {
+        verified: false,
+        status: 'ERROR',
+        regulator: 'EU',
+        region: Region.EU,
+        metadata: {
+          errorName: errorObject?.name,
+          errorMessage: errorObject?.message,
+        },
+        verifiedAt: verificationStartedAt.toISOString(),
+      };
+    }
+  }
+
+  private normalizeStringArray(values: readonly string[]): string[] {
+    if (!Array.isArray(values)) return [];
+    return values
+      .filter((value) => typeof value === 'string')
+      .map((value) => value.trim().toLowerCase())
+      .filter((value) => value.length > 0);
+  }
+
+  private isEuropeanCountryToken(value: string): boolean {
+    const europeanCountryTokens = [
+      'france',
+      'germany',
+      'spain',
+      'italy',
+      'netherlands',
+      'belgium',
+      'portugal',
+      'poland',
+      'sweden',
+      'finland',
+      'denmark',
+      'ireland',
+      'austria',
+    ];
+    return europeanCountryTokens.some((token) => value.includes(token));
+  }
+}

src/verification/adapters/implementations/fda.adapter.ts

@@ -0,0 +1,113 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { RegulatoryAdapterImplementation } from '../regulatory-adapter.decorator';
+import { RegulatoryAdapter } from '../regulatory-adapter.interface';
+import { VerificationResult } from '../../contracts/verification-result.interface';
+import { Region } from '../../../verify/providers/region-inference-provider/region.enums';
+import { NormalizedProduct } from '../../../verify/providers/region-inference-provider/interface/normalized-product.interface';
+
+@RegulatoryAdapterImplementation()
+@Injectable()
+export class FDAAdapter implements RegulatoryAdapter {
+  readonly region = Region.USA;
+
+  private readonly logger = new Logger(FDAAdapter.name);
+
+  async verifyProduct(product: NormalizedProduct): Promise<VerificationResult> {
+    const verificationStartedAt = new Date();
+
+    try {
+      const manufacturingCountries = this.normalizeStringArray(
+        product.manufacturingCountries,
+      );
+      const purchaseCountries = this.normalizeStringArray(
+        product.purchaseCountries,
+      );
+      const labels = this.normalizeStringArray(product.labels);
+
+      const hasUnitedStatesSignal =
+        manufacturingCountries.some((value) => this.containsUnitedStates(value)) ||
+        purchaseCountries.some((value) => this.containsUnitedStates(value)) ||
+        labels.some((value) => value.includes('fda'));
+
+      this.logger.log(
+        JSON.stringify({
+          msg: 'regulatory_verification_attempt',
+          regulator: 'FDA',
+          barcode: product.barcode,
+          hasUnitedStatesSignal,
+        }),
+      );
+
+      if (!hasUnitedStatesSignal) {
+        return {
+          verified: false,
+          status: 'NOT_FOUND',
+          regulator: 'FDA',
+          region: Region.USA,
+          confidence: 0.3,
+          warnings: ['no_us_signals_detected'],
+          metadata: {
+            signals: {
+              manufacturingCountries: manufacturingCountries.length,
+              purchaseCountries: purchaseCountries.length,
+              labels: labels.length,
+            },
+          },
+          verifiedAt: verificationStartedAt.toISOString(),
+        };
+      }
+
+      return {
+        verified: true,
+        status: 'VERIFIED',
+        regulator: 'FDA',
+        region: Region.USA,
+        confidence: 0.75,
+        metadata: {
+          verificationMethod: 'heuristic_precheck',
+        },
+        verifiedAt: verificationStartedAt.toISOString(),
+      };
+    } catch (error) {
+      const errorObject = error as Error;
+      this.logger.error(
+        JSON.stringify({
+          msg: 'regulatory_verification_failed',
+          regulator: 'FDA',
+          barcode: product.barcode,
+          errorName: errorObject?.name,
+          errorMessage: errorObject?.message,
+        }),
+      );
+
+      return {
+        verified: false,
+        status: 'ERROR',
+        regulator: 'FDA',
+        region: Region.USA,
+        metadata: {
+          errorName: errorObject?.name,
+          errorMessage: errorObject?.message,
+        },
+        verifiedAt: verificationStartedAt.toISOString(),
+      };
+    }
+  }
+
+  private normalizeStringArray(values: readonly string[]): string[] {
+    if (!Array.isArray(values)) return [];
+    return values
+      .filter((value) => typeof value === 'string')
+      .map((value) => value.trim().toLowerCase())
+      .filter((value) => value.length > 0);
+  }
+
+  private containsUnitedStates(value: string): boolean {
+    return (
+      value.includes('united states') ||
+      value === 'usa' ||
+      value === 'us' ||
+      value.includes('u.s.')
+    );
+  }
+}

src/verification/adapters/implementations/nafdac.adapter.ts

@@ -0,0 +1,122 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { RegulatoryAdapterImplementation } from '../regulatory-adapter.decorator';
+import { RegulatoryAdapter } from '../regulatory-adapter.interface';
+import { VerificationResult } from '../../contracts/verification-result.interface';
+import { Region } from '../../../verify/providers/region-inference-provider/region.enums';
+import { NormalizedProduct } from '../../../verify/providers/region-inference-provider/interface/normalized-product.interface';
+
+@RegulatoryAdapterImplementation()
+@Injectable()
+export class NAFDACAdapter implements RegulatoryAdapter {
+  readonly region = Region.NIGERIA;
+
+  private readonly logger = new Logger(NAFDACAdapter.name);
+
+  async verifyProduct(product: NormalizedProduct): Promise<VerificationResult> {
+    const verificationStartedAt = new Date();
+
+    try {
+      const labels = this.normalizeStringArray(product.labels);
+      const traces = this.normalizeStringArray(product.traces);
+      const ingredients = this.normalizeStringArray(product.ingredients);
+      const manufacturingCountries = this.normalizeStringArray(
+        product.manufacturingCountries,
+      );
+
+      const hasNigeriaSignal =
+        manufacturingCountries.some((value) => value.includes('nigeria')) ||
+        labels.some((value) => value.includes('nafdac')) ||
+        traces.some((value) => value.includes('nafdac'));
+
+      this.logger.log(
+        JSON.stringify({
+          msg: 'regulatory_verification_attempt',
+          regulator: 'NAFDAC',
+          barcode: product.barcode,
+          hasNigeriaSignal,
+        }),
+      );
+
+      if (!hasNigeriaSignal) {
+        return {
+          verified: false,
+          status: 'NOT_FOUND',
+          regulator: 'NAFDAC',
+          region: Region.NIGERIA,
+          confidence: 0.3,
+          warnings: ['no_ng_signals_detected'],
+          metadata: {
+            signals: {
+              labels: labels.length,
+              traces: traces.length,
+              ingredients: ingredients.length,
+            },
+          },
+          verifiedAt: verificationStartedAt.toISOString(),
+        };
+      }
+
+      const potentiallyNonCompliant = ingredients.some((value) =>
+        value.includes('chloramphenicol'),
+      );
+
+      if (potentiallyNonCompliant) {
+        return {
+          verified: false,
+          status: 'PENDING',
+          regulator: 'NAFDAC',
+          region: Region.NIGERIA,
+          confidence: 0.6,
+          warnings: ['manual_review_recommended'],
+          metadata: {
+            reason: 'ingredient_requires_manual_review',
+          },
+          verifiedAt: verificationStartedAt.toISOString(),
+        };
+      }
+
+      return {
+        verified: true,
+        status: 'VERIFIED',
+        regulator: 'NAFDAC',
+        region: Region.NIGERIA,
+        confidence: 0.7,
+        metadata: {
+          verificationMethod: 'heuristic_precheck',
+        },
+        verifiedAt: verificationStartedAt.toISOString(),
+      };
+    } catch (error) {
+      const errorObject = error as Error;
+      this.logger.error(
+        JSON.stringify({
+          msg: 'regulatory_verification_failed',
+          regulator: 'NAFDAC',
+          barcode: product.barcode,
+          errorName: errorObject?.name,
+          errorMessage: errorObject?.message,
+        }),
+      );
+
+      return {
+        verified: false,
+        status: 'ERROR',
+        regulator: 'NAFDAC',
+        region: Region.NIGERIA,
+        metadata: {
+          errorName: errorObject?.name,
+          errorMessage: errorObject?.message,
+        },
+        verifiedAt: verificationStartedAt.toISOString(),
+      };
+    }
+  }
+
+  private normalizeStringArray(values: readonly string[]): string[] {
+    if (!Array.isArray(values)) return [];
+    return values
+      .filter((value) => typeof value === 'string')
+      .map((value) => value.trim().toLowerCase())
+      .filter((value) => value.length > 0);
+  }
+}

src/verification/adapters/regulatory-adapter.decorator.ts

@@ -0,0 +1,8 @@
+export const REGULATORY_ADAPTER_METADATA_KEY = 'REGULATORY_ADAPTER_METADATA_KEY';
+
+export function RegulatoryAdapterImplementation(): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata(REGULATORY_ADAPTER_METADATA_KEY, true, target);
+  };
+}
+

src/verification/adapters/regulatory-adapter.interface.ts

@@ -0,0 +1,9 @@
+import { Region } from '../../verify/providers/region-inference-provider/region.enums';
+import { NormalizedProduct } from '../../verify/providers/region-inference-provider/interface/normalized-product.interface';
+import { VerificationResult } from '../contracts/verification-result.interface';
+
+export interface RegulatoryAdapter {
+  readonly region: Region;
+
+  verifyProduct(product: NormalizedProduct): Promise<VerificationResult>;
+}

src/verification/adapters/regulatory-adapter.tokens.ts

@@ -0,0 +1,2 @@
+export const REGULATORY_ADAPTERS = 'REGULATORY_ADAPTERS';
+