PHPackages                             azaharizaman/nexus-sanctions - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Utility & Helpers](/categories/utility)
4. /
5. azaharizaman/nexus-sanctions

ActiveLibrary[Utility & Helpers](/categories/utility)

azaharizaman/nexus-sanctions
============================

Regulatory screening engine for sanctions lists (OFAC, UN, EU, UK HMT) and PEP detection with fuzzy matching

v0.1.0-alpha1(1mo ago)02↓100%MITPHPPHP ^8.3

Since May 5Pushed 1mo agoCompare

[ Source](https://github.com/azaharizaman/nexus-sanctions)[ Packagist](https://packagist.org/packages/azaharizaman/nexus-sanctions)[ RSS](/packages/azaharizaman-nexus-sanctions/feed)WikiDiscussions main Synced 1w ago

READMEChangelogDependencies (4)Versions (2)Used By (0)

Nexus\\Sanctions
================

[](#nexussanctions)

**Production-ready international sanctions screening and Politically Exposed Person (PEP) detection for financial compliance.**

[![PHP Version](https://camo.githubusercontent.com/ef0054230522e542bc1f908ac005c6c75888dea255bac910f9015e12095e31d7/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f7068702d253545382e332d626c7565)](https://www.php.net/)[![License](https://camo.githubusercontent.com/f8df3091bbe1149f398a5369b2c39e896766f9f6efba3477c63e9b4aa940ef14/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f6c6963656e73652d4d49542d677265656e)](LICENSE)[![FATF Compliant](https://camo.githubusercontent.com/54115df1b3d69d974c92ab738f42396838f197703fa80f9bd77740483445f0c0/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f464154462d436f6d706c69616e742d73756363657373)](https://www.fatf-gafi.org/)

---

Table of Contents
-----------------

[](#table-of-contents)

- [Overview](#overview)
- [Features](#features)
- [Installation](#installation)
- [Quick Start](#quick-start)
- [Core Concepts](#core-concepts)
- [Usage Examples](#usage-examples)
    - [Sanctions Screening](#sanctions-screening)
    - [PEP Detection](#pep-detection)
    - [Periodic Re-Screening](#periodic-re-screening)
- [Available Interfaces](#available-interfaces)
- [Enums Reference](#enums-reference)
- [Value Objects](#value-objects)
- [Exception Handling](#exception-handling)
- [Integration Guide](#integration-guide)
- [Architecture](#architecture)
- [License](#license)

---

Overview
--------

[](#overview)

Nexus\\Sanctions is a truly atomic, framework-agnostic PHP package that provides enterprise-grade sanctions screening and PEP detection capabilities. Designed for financial institutions, compliance teams, and ERP systems, it implements FATF (Financial Action Task Force) guidelines and OFAC requirements.

---

Features
--------

[](#features)

### Sanctions Screening

[](#sanctions-screening)

- ✅ **Multi-list screening** - OFAC, UN, EU, UK HMT, AU DFAT, CA OSFI, JP METI, CH SECO
- ✅ **Advanced fuzzy matching** - Levenshtein distance, Soundex, Metaphone, token-based
- ✅ **Configurable thresholds** - Similarity threshold tuning (default: 85%)
- ✅ **Batch processing** - Screen multiple parties efficiently
- ✅ **Alias support** - Screen against known aliases

### PEP Detection

[](#pep-detection)

- ✅ **FATF-compliant** - Implements Financial Action Task Force guidelines
- ✅ **Risk-level classification** - HIGH, MEDIUM, LOW, NONE
- ✅ **Family & associates** - Identify related persons with PEP exposure
- ✅ **Former PEP detection** - 40% risk reduction after 12 months rule
- ✅ **Enhanced Due Diligence** - Automatic EDD requirement determination

### Periodic Re-Screening

[](#periodic-re-screening)

- ✅ **Risk-based frequency** - REAL\_TIME, DAILY, WEEKLY, MONTHLY, QUARTERLY, SEMI\_ANNUAL, ANNUAL
- ✅ **Batch execution** - Process scheduled screenings efficiently
- ✅ **Schedule management** - Update, cancel, and query schedules
- ✅ **Retry logic** - Exponential backoff for failed screenings

### Architecture

[](#architecture)

- ✅ **Framework agnostic** - Pure PHP 8.3+, works with Laravel, Symfony, or any framework
- ✅ **Interface-based** - Define contracts, consumers provide implementations
- ✅ **Zero circular dependencies** - Only depends on `azaharizaman/nexus-common` and PSR interfaces
- ✅ **Immutable value objects** - Type-safe, validated domain objects
- ✅ **Comprehensive logging** - PSR-3 compatible logging

---

Installation
------------

[](#installation)

```
composer require azaharizaman/nexus-sanctions
```

**Requirements:**

- PHP 8.3 or higher
- `azaharizaman/nexus-common` ^1.0
- `psr/log` ^3.0

---

Quick Start
-----------

[](#quick-start)

```
use Nexus\Sanctions\Services\SanctionsScreener;
use Nexus\Sanctions\Enums\SanctionsList;

// Create screener with your repository implementation
$screener = new SanctionsScreener($sanctionsRepository);

// Screen a party against multiple sanctions lists
$result = $screener->screen(
    party: $party,
    lists: [SanctionsList::OFAC, SanctionsList::UN, SanctionsList::EU],
    options: ['similarity_threshold' => 0.85]
);

// Check results
if ($result->requiresBlocking) {
    // Block transaction immediately
}

if ($result->requiresReview) {
    // Queue for compliance review
}
```

---

Core Concepts
-------------

[](#core-concepts)

### Sanctions Lists

[](#sanctions-lists)

The package supports 8 major international sanctions lists:

ListAuthorityDescription`OFAC`US TreasurySpecially Designated Nationals (SDN) List`UN`United NationsSecurity Council Consolidated List`EU`European UnionConsolidated Financial Sanctions List`UK_HMT`UK TreasuryOffice of Financial Sanctions (OFSI)`AU_DFAT`AustraliaDepartment of Foreign Affairs and Trade`CA_OSFI`CanadaOffice of the Superintendent of Financial Institutions`JP_METI`JapanMinistry of Economy, Trade and Industry`CH_SECO`SwitzerlandState Secretariat for Economic Affairs### Match Strength

[](#match-strength)

Matches are classified by confidence level:

StrengthSimilarityAction`EXACT`100%Block transaction immediately`HIGH`85-99%Requires immediate compliance review`MEDIUM`70-84%Requires thorough investigation`LOW`50-69%Manual verification recommended`NONE`<50%No action required### PEP Risk Levels

[](#pep-risk-levels)

Based on FATF guidelines:

LevelDescriptionEDD Required`HIGH`Heads of state, senior politicians, military officialsYes + Senior Management Approval`MEDIUM`Mid-level government officials, regional figuresYes`LOW`Former PEPs (>12 months), honorary positionsStandard DD may suffice`NONE`No political exposureStandard CDD applies---

Usage Examples
--------------

[](#usage-examples)

### Sanctions Screening

[](#sanctions-screening-1)

#### Basic Screening

[](#basic-screening)

```
use Nexus\Sanctions\Services\SanctionsScreener;
use Nexus\Sanctions\Enums\SanctionsList;

$screener = new SanctionsScreener($repository, $logger);

// Screen against all major lists
$result = $screener->screen(
    party: $party,
    lists: [
        SanctionsList::OFAC,
        SanctionsList::UN,
        SanctionsList::EU,
        SanctionsList::UK_HMT,
    ],
    options: [
        'similarity_threshold' => 0.85,
        'phonetic_matching' => true,
        'token_based' => true,
        'include_aliases' => true,
    ]
);

// Analyze results
echo "Matches found: " . $result->getMatchesCount() . "\n";
echo "Risk level: " . $result->overallRiskLevel . "\n";
echo "Processing time: " . $result->processingTimeMs . "ms\n";

if ($result->requiresBlocking) {
    throw new TransactionBlockedException('Sanctions match detected');
}
```

#### Batch Screening

[](#batch-screening)

```
// Screen multiple parties efficiently
$results = $screener->screenMultiple(
    parties: [$party1, $party2, $party3],
    lists: [SanctionsList::OFAC, SanctionsList::UN],
    options: ['similarity_threshold' => 0.80]
);

foreach ($results as $partyId => $result) {
    if ($result->hasMatches) {
        $this->notifyCompliance($partyId, $result);
    }
}
```

#### Screen Single Name

[](#screen-single-name)

```
// Screen a single name against specific list
$matches = $screener->screenName(
    name: 'John Smith',
    list: SanctionsList::OFAC,
    options: ['threshold' => 0.85]
);

foreach ($matches as $match) {
    echo "Match: {$match->matchedName}\n";
    echo "Score: {$match->similarityScore}%\n";
    echo "List: {$match->list->getName()}\n";
    echo "Action: {$match->matchStrength->getRecommendedAction()}\n";
}
```

#### Calculate Similarity

[](#calculate-similarity)

```
// Calculate similarity between two names
$similarity = $screener->calculateSimilarity(
    name1: 'Mohammed Ali',
    name2: 'Muhammad Ali'
);

echo "Similarity: " . ($similarity * 100) . "%\n"; // ~92%
```

### PEP Detection

[](#pep-detection-1)

#### Basic PEP Screening

[](#basic-pep-screening)

```
use Nexus\Sanctions\Services\PepScreener;
use Nexus\Sanctions\Enums\PepLevel;

$pepScreener = new PepScreener($repository, $logger);

// Screen for PEP status
$pepProfiles = $pepScreener->screenForPep(
    party: $party,
    options: [
        'include_family' => true,
        'include_associates' => true,
        'include_former' => true,
        'min_risk_level' => 'low',
    ]
);

foreach ($pepProfiles as $profile) {
    echo "PEP: {$profile->name}\n";
    echo "Position: {$profile->position}\n";
    echo "Country: {$profile->country}\n";
    echo "Level: {$profile->level->value}\n";
    echo "Active: " . ($profile->isActive() ? 'Yes' : 'No') . "\n";
    echo "Risk Score: {$profile->getRiskScore()}\n";
}
```

#### Assess Risk Level

[](#assess-risk-level)

```
// Determine overall PEP risk level
$riskLevel = $pepScreener->assessRiskLevel($party, $pepProfiles);

echo "Risk Level: {$riskLevel->value}\n";

// Get EDD requirements
$eddRequirements = $riskLevel->getEddRequirements();
if ($eddRequirements['senior_management_approval']) {
    $this->requestSeniorApproval($party);
}
```

#### Check EDD Requirement

[](#check-edd-requirement)

```
// Check if Enhanced Due Diligence is required
if ($pepScreener->requiresEdd($party, $pepProfiles)) {
    $this->initiateEddWorkflow($party, [
        'source_of_wealth' => true,
        'source_of_funds' => true,
        'ongoing_monitoring' => 'monthly',
    ]);
}
```

#### Check Related Persons

[](#check-related-persons)

```
// Find family members and close associates
$relatedProfiles = $pepScreener->checkRelatedPersons($party);

foreach ($relatedProfiles as $related) {
    echo "Related PEP: {$related->name}\n";
    echo "Relationship: " . ($related->additionalInfo['relationship'] ?? 'Unknown') . "\n";
}
```

### Periodic Re-Screening

[](#periodic-re-screening-1)

#### Schedule Screening

[](#schedule-screening)

```
use Nexus\Sanctions\Services\PeriodicScreeningManager;
use Nexus\Sanctions\Enums\ScreeningFrequency;

$manager = new PeriodicScreeningManager($screener, $logger);

// Schedule based on risk level
$schedule = $manager->scheduleScreening(
    partyId: 'party-123',
    frequency: ScreeningFrequency::MONTHLY,
    options: [
        'lists' => [SanctionsList::OFAC, SanctionsList::UN],
        'start_date' => new DateTimeImmutable(),
        'metadata' => ['risk_tier' => 'medium'],
    ]
);

echo "Next screening: " . $schedule['next_screening_date']->format('Y-m-d') . "\n";
```

#### Execute Scheduled Screenings

[](#execute-scheduled-screenings)

```
// Execute all due screenings
$summary = $manager->executeScheduledScreenings(
    asOfDate: new DateTimeImmutable(),
    options: [
        'batch_size' => 100,
        'continue_on_error' => true,
    ]
);

echo "Executed: {$summary['total_executed']}\n";
echo "Successful: {$summary['successful']}\n";
echo "Failed: {$summary['failed']}\n";
echo "Matches found: {$summary['total_matches']}\n";
```

#### Update Frequency

[](#update-frequency)

```
// Increase frequency for higher risk party
$manager->updateScreeningFrequency(
    partyId: 'party-123',
    newFrequency: ScreeningFrequency::WEEKLY
);

// Cancel screening when relationship ends
$manager->cancelScheduledScreening('party-123');
```

---

Available Interfaces
--------------------

[](#available-interfaces)

### SanctionsScreenerInterface

[](#sanctionsscreenerinterface)

Primary interface for sanctions screening operations.

```
interface SanctionsScreenerInterface
{
    public function screen(
        PartyInterface $party,
        array $lists,
        array $options = []
    ): ScreeningResult;

    public function screenMultiple(
        array $parties,
        array $lists,
        array $options = []
    ): array;

    public function screenName(
        string $name,
        SanctionsList $list,
        array $options = []
    ): array;

    public function calculateSimilarity(string $name1, string $name2): float;
}
```

### PepScreenerInterface

[](#pepscreenerinterface)

Interface for PEP detection and risk assessment.

```
interface PepScreenerInterface
{
    public function screenForPep(
        PartyInterface $party,
        array $options = []
    ): array;

    public function checkRelatedPersons(PartyInterface $party): array;

    public function assessRiskLevel(
        PartyInterface $party,
        array $pepProfiles
    ): PepLevel;

    public function requiresEdd(
        PartyInterface $party,
        array $pepProfiles
    ): bool;
}
```

### PeriodicScreeningManagerInterface

[](#periodicscreeningmanagerinterface)

Interface for managing periodic re-screening schedules.

```
interface PeriodicScreeningManagerInterface
{
    public function scheduleScreening(
        string $partyId,
        ScreeningFrequency $frequency,
        array $options = []
    ): array;

    public function executeScheduledScreenings(
        DateTimeImmutable $asOfDate,
        array $options = []
    ): array;

    public function updateScreeningFrequency(
        string $partyId,
        ScreeningFrequency $newFrequency
    ): void;

    public function cancelScheduledScreening(string $partyId): void;
}
```

### SanctionsRepositoryInterface

[](#sanctionsrepositoryinterface)

Interface for data access - must be implemented by consuming application.

```
interface SanctionsRepositoryInterface
{
    public function findByName(
        string $name,
        SanctionsList $list,
        float $similarityThreshold = 0.85
    ): array;

    public function findById(string $entryId, SanctionsList $list): ?array;

    public function findPepByName(
        string $name,
        float $similarityThreshold = 0.85
    ): array;

    public function findPepById(string $pepId): ?array;

    public function getRelatedPersons(string $pepId): array;

    public function isListAvailable(SanctionsList $list): bool;
}
```

### PartyInterface

[](#partyinterface)

Interface for party data required for screening.

```
interface PartyInterface
{
    public function getId(): string;
    public function getName(): string;
    public function getType(): string; // 'INDIVIDUAL' or 'ORGANIZATION'
    public function getDateOfBirth(): ?DateTimeImmutable;
    public function getNationality(): ?string;
    public function getCountryOfIncorporation(): ?string;
    public function getAliases(): array;
    public function getIdentificationDocuments(): array;
}
```

---

Enums Reference
---------------

[](#enums-reference)

### SanctionsList

[](#sanctionslist)

```
enum SanctionsList: string
{
    case OFAC = 'ofac';          // US Treasury
    case UN = 'un';              // United Nations
    case EU = 'eu';              // European Union
    case UK_HMT = 'uk_hmt';      // UK Treasury
    case AU_DFAT = 'au_dfat';    // Australia
    case CA_OSFI = 'ca_osfi';    // Canada
    case JP_METI = 'jp_meti';    // Japan
    case CH_SECO = 'ch_seco';    // Switzerland

    public function getName(): string;
    public function getAuthority(): string;
}
```

### MatchStrength

[](#matchstrength)

```
enum MatchStrength: string
{
    case EXACT = 'exact';    // 100% match
    case HIGH = 'high';      // 85-99% match
    case MEDIUM = 'medium';  // 70-84% match
    case LOW = 'low';        // 50-69% match
    case NONE = 'none';      // 12 months ago
    public function requiresEdd(): bool;
    public function requiresSeniorApproval(): bool;
    public function getRiskScore(): int;  // 40% reduction for former PEPs
    public function getEddRequirements(): array;
    public function getMonitoringFrequencyDays(): int;
    public function getTenureDays(): ?int;
    public function getYearsSinceEnd(): ?float;
}
```

---

Exception Handling
------------------

[](#exception-handling)

### Exception Hierarchy

[](#exception-hierarchy)

```
SanctionsException (base)
├── InvalidPartyException
├── ScreeningFailedException
└── SanctionsListUnavailableException

```

### InvalidPartyException

[](#invalidpartyexception)

Thrown when party data is invalid for screening.

```
use Nexus\Sanctions\Exceptions\InvalidPartyException;

try {
    $screener->screen($party, $lists);
} catch (InvalidPartyException $e) {
    $errors = $e->getValidationErrors();
    $required = $e->getRequiredFields();
    $this->logger->warning('Invalid party data', [
        'errors' => $errors,
        'required' => $required,
    ]);
}
```

Factory methods:

- `missingRequiredFields(string $partyId, array $missingFields)`
- `invalidName(string $partyId, string $name, string $reason)`
- `invalidDateOfBirth(string $partyId, string $dob, string $reason)`
- `invalidNationality(string $partyId, string $nationality)`

### ScreeningFailedException

[](#screeningfailedexception)

Thrown when screening operation fails.

```
use Nexus\Sanctions\Exceptions\ScreeningFailedException;

try {
    $screener->screen($party, $lists);
} catch (ScreeningFailedException $e) {
    $this->logger->error('Screening failed', [
        'message' => $e->getMessage(),
        'code' => $e->getCode(),
    ]);
}
```

Factory methods:

- `apiTimeout(string $partyId, SanctionsList $list, int $timeoutSeconds)`
- `networkError(string $partyId, SanctionsList $list, string $error)`
- `invalidListData(SanctionsList $list, string $reason)`
- `screeningFailed(string $partyId, string $reason)`

### SanctionsListUnavailableException

[](#sanctionslistunavailableexception)

Thrown when a sanctions list is unavailable.

```
use Nexus\Sanctions\Exceptions\SanctionsListUnavailableException;

try {
    $screener->screen($party, [SanctionsList::OFAC]);
} catch (SanctionsListUnavailableException $e) {
    $list = $e->getSanctionsList();
    $this->alertOperations("List {$list->value} unavailable");
}
```

---

Integration Guide
-----------------

[](#integration-guide)

### 1. Implement SanctionsRepositoryInterface

[](#1-implement-sanctionsrepositoryinterface)

```
namespace App\Repositories;

use Nexus\Sanctions\Contracts\SanctionsRepositoryInterface;
use Nexus\Sanctions\Enums\SanctionsList;

final readonly class EloquentSanctionsRepository implements SanctionsRepositoryInterface
{
    public function findByName(
        string $name,
        SanctionsList $list,
        float $similarityThreshold = 0.85
    ): array {
        // Query your database or external API
        return SanctionsEntry::query()
            ->where('list', $list->value)
            ->whereRaw('SIMILARITY(name, ?) > ?', [$name, $similarityThreshold])
            ->get()
            ->toArray();
    }

    public function findPepByName(
        string $name,
        float $similarityThreshold = 0.85
    ): array {
        // Query PEP database
        return PepEntry::query()
            ->whereRaw('SIMILARITY(name, ?) > ?', [$name, $similarityThreshold])
            ->get()
            ->toArray();
    }

    public function isListAvailable(SanctionsList $list): bool
    {
        return Cache::remember(
            "sanctions_list_{$list->value}_available",
            3600,
            fn() => $this->checkListAvailability($list)
        );
    }

    // ... implement other methods
}
```

### 2. Implement PartyInterface Adapter

[](#2-implement-partyinterface-adapter)

```
namespace App\Adapters;

use Nexus\Sanctions\Contracts\PartyInterface;
use App\Models\Customer;

final readonly class CustomerPartyAdapter implements PartyInterface
{
    public function __construct(
        private Customer $customer
    ) {}

    public function getId(): string
    {
        return $this->customer->id;
    }

    public function getName(): string
    {
        return $this->customer->legal_name ?? $this->customer->name;
    }

    public function getType(): string
    {
        return $this->customer->is_company ? 'ORGANIZATION' : 'INDIVIDUAL';
    }

    public function getDateOfBirth(): ?\DateTimeImmutable
    {
        return $this->customer->date_of_birth
            ? new \DateTimeImmutable($this->customer->date_of_birth)
            : null;
    }

    public function getNationality(): ?string
    {
        return $this->customer->nationality;
    }

    public function getAliases(): array
    {
        return $this->customer->aliases ?? [];
    }

    // ... implement other methods
}
```

### 3. Register in Service Container (Laravel)

[](#3-register-in-service-container-laravel)

```
// AppServiceProvider.php
use Nexus\Sanctions\Contracts\SanctionsRepositoryInterface;
use Nexus\Sanctions\Contracts\SanctionsScreenerInterface;
use Nexus\Sanctions\Contracts\PepScreenerInterface;
use Nexus\Sanctions\Services\SanctionsScreener;
use Nexus\Sanctions\Services\PepScreener;

public function register(): void
{
    $this->app->singleton(
        SanctionsRepositoryInterface::class,
        EloquentSanctionsRepository::class
    );

    $this->app->singleton(SanctionsScreenerInterface::class, function ($app) {
        return new SanctionsScreener(
            $app->make(SanctionsRepositoryInterface::class),
            $app->make(LoggerInterface::class)
        );
    });

    $this->app->singleton(PepScreenerInterface::class, function ($app) {
        return new PepScreener(
            $app->make(SanctionsRepositoryInterface::class),
            $app->make(LoggerInterface::class)
        );
    });
}
```

### 4. Use in Application Services

[](#4-use-in-application-services)

```
namespace App\Services;

use Nexus\Sanctions\Contracts\SanctionsScreenerInterface;
use Nexus\Sanctions\Contracts\PepScreenerInterface;
use Nexus\Sanctions\Enums\SanctionsList;

final readonly class CustomerOnboardingService
{
    public function __construct(
        private SanctionsScreenerInterface $sanctionsScreener,
        private PepScreenerInterface $pepScreener,
    ) {}

    public function screenCustomer(Customer $customer): OnboardingResult
    {
        $party = new CustomerPartyAdapter($customer);

        // Screen against sanctions lists
        $sanctionsResult = $this->sanctionsScreener->screen(
            party: $party,
            lists: [SanctionsList::OFAC, SanctionsList::UN, SanctionsList::EU],
        );

        if ($sanctionsResult->requiresBlocking) {
            return OnboardingResult::blocked('Sanctions match detected');
        }

        // Screen for PEP status
        $pepProfiles = $this->pepScreener->screenForPep($party);

        if ($this->pepScreener->requiresEdd($party, $pepProfiles)) {
            return OnboardingResult::requiresEdd($pepProfiles);
        }

        return OnboardingResult::approved();
    }
}
```

---

Architecture
------------

[](#architecture-1)

### Package Structure

[](#package-structure)

```
packages/Sanctions/
├── src/
│   ├── Contracts/
│   │   ├── PartyInterface.php
│   │   ├── PepScreenerInterface.php
│   │   ├── PeriodicScreeningManagerInterface.php
│   │   ├── SanctionsRepositoryInterface.php
│   │   └── SanctionsScreenerInterface.php
│   ├── Enums/
│   │   ├── MatchStrength.php
│   │   ├── PepLevel.php
│   │   ├── SanctionsList.php
│   │   └── ScreeningFrequency.php
│   ├── Exceptions/
│   │   ├── InvalidPartyException.php
│   │   ├── SanctionsException.php
│   │   ├── SanctionsListUnavailableException.php
│   │   └── ScreeningFailedException.php
│   ├── Services/
│   │   ├── PepScreener.php
│   │   ├── PeriodicScreeningManager.php
│   │   └── SanctionsScreener.php
│   └── ValueObjects/
│       ├── PepProfile.php
│       ├── SanctionsMatch.php
│       └── ScreeningResult.php
├── tests/
├── composer.json
└── README.md

```

### Atomic Architecture Principles

[](#atomic-architecture-principles)

- **Zero Circular Dependencies**: Only depends on `azaharizaman/nexus-common` and PSR interfaces
- **Interface-Based**: Package provides contracts, consuming applications implement
- **Independently Testable**: Can be unit tested without database or framework
- **Framework Agnostic**: Pure PHP 8.3+, works with any framework
- **Stateless Services**: All services are `final readonly` with no mutable state

---

License
-------

[](#license)

MIT License. See [LICENSE](LICENSE) for details.

---

**Maintained by:** Nexus Architecture Team
**Last Updated:** December 2025

###  Health Score

35

—

LowBetter than 77% of packages

Maintenance93

Actively maintained with recent releases

Popularity3

Limited adoption so far

Community6

Small or concentrated contributor base

Maturity34

Early-stage or recently created project

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Unknown

Total

1

Last Release

36d ago

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/117408?v=4)[Azahari Zaman](/maintainers/azaharizaman)[@azaharizaman](https://github.com/azaharizaman)

---

Top Contributors

[![azaharizaman](https://avatars.githubusercontent.com/u/117408?v=4)](https://github.com/azaharizaman "azaharizaman (8 commits)")

---

Tags

amlcompliancepepfinancial-crimesanctionsscreeningregulatoryOFAC

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/azaharizaman-nexus-sanctions/health.svg)

```
[![Health](https://phpackages.com/badges/azaharizaman-nexus-sanctions/health.svg)](https://phpackages.com/packages/azaharizaman-nexus-sanctions)
```

###  Alternatives

[symfony/lock

Creates and manages locks, a mechanism to provide exclusive access to a shared resource

515135.1M619](/packages/symfony-lock)[matomo/matomo

Matomo is the leading Free/Libre open analytics platform

21.6k38.2k](/packages/matomo-matomo)[phpro/soap-client

A general purpose SoapClient library

8955.9M52](/packages/phpro-soap-client)[ecotone/ecotone

Enterprise architecture layer for Laravel and Symfony — CQRS, Event Sourcing, Durable Workflows (Sagas, Orchestrators), Projections, and Outbox messaging via PHP attributes.

562565.8k41](/packages/ecotone-ecotone)[civicrm/civicrm-core

Open source constituent relationship management for non-profits, NGOs and advocacy organizations.

744284.3k34](/packages/civicrm-civicrm-core)[illuminate/broadcasting

The Illuminate Broadcasting package.

7126.9M199](/packages/illuminate-broadcasting)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)