PHP download

PHP code example of nimblephp / authorization

1. Go to this page and download the library: Download nimblephp/authorization library. Choose the download type require.

2. Extract the ZIP file and open the index.php.

3. Add this code to the index.php.

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

nimblephp / authorization example snippets


use NimblePHP\Authorization\Config;

// Ustawienia typu autoryzacji
Config::$authType = 'email'; // lub 'username'

// Wymaganie aktywacji konta
Config::$
    'username' => 'login',
    'email' => 'email_address',
    'password' => 'hashed_password',
    'active' => 'is_active'
];


use NimblePHP\Authorization\Config;

// Włączenie/wyłączenie rate limitingu (domyślnie: true)
Config::$rateLimitEnabled = true;

// Maksymalna liczba nieudanych prób (domyślnie: 5)
Config::$rateLimitMaxAttempts = 5;

// Czas blokady w sekundach (domyślnie: 900 = 15 minut)
Config::$rateLimitLockoutDuration = 900;


use NimblePHP\Authorization\Authorization;
use NimblePHP\Authorization\Exceptions\RateLimitExceededException;

$auth = new Authorization();

try {
    $loggedIn = $auth->login('[email protected]', 'password123');
    if ($loggedIn) {
        echo "Zalogowano pomyślnie!";
    } else {
        echo "Nieprawidłowe dane logowania!";
    }
} catch (RateLimitExceededException $e) {
    echo "Konto tymczasowo zablokowane z powodu zbyt wielu nieudanych prób logowania.";
    echo "Spróbuj ponownie za " . $e->getRemainingLockoutTime() . " sekund.";
    // Zwróć HTTP 429 (Too Many Requests)
    http_response_code(429);
}


use NimblePHP\Authorization\Interfaces\PasswordHasher;

class MyCustomHasher implements PasswordHasher
{
    /**
     * Hashuje hasło
     */
    public function hash(string $password): string
    {
        // Twoja implementacja hashowania
        return hash('sha256', $password . 'moja_sól');
    }

    /**
     * Weryfikuje hasło przeciwko skrótowi
     */
    public function verify(string $hash, string $password): bool
    {
        return hash_equals($hash, $this->hash($password));
    }

    /**
     * Sprawdza czy skrót wymaga rehash'u (dla algorytmów obsługujących aktualizację)
     */
    public function needsRehash(string $hash): bool
    {
        // Zwróć true jeśli hash wymaga aktualizacji
        return false;
    }
}


use NimblePHP\Authorization\Config;
use MyCustomHasher;

// Zarejestruj swój hasher
Config::setPasswordHasher(new MyCustomHasher());


use NimblePHP\Authorization\Config;
use NimblePHP\Authorization\Hashers\BcryptPasswordHasher;
use NimblePHP\Authorization\Hashers\ArgonPasswordHasher;

// Użyj Bcrypt
Config::setPasswordHasher(new BcryptPasswordHasher());

// Lub Argon2id (najbezpieczniejszy)
Config::setPasswordHasher(new ArgonPasswordHasher());


// Jeśli zmienisz algorytm hasherowania, wszystkie hasła zostaną automatycznie
// zaktualizowane przy następnym logowaniu użytkownika
try {
    $loggedIn = $auth->login('[email protected]', 'password123');
    // Hasło zostało automatycznie rehash'owane jeśli było potrzebne
} catch (RateLimitExceededException $e) {
    // Obsłuż rate limit
}


use NimblePHP\Authorization\Config;
use NimblePHP\Authorization\Providers\TOTPProvider;
use NimblePHP\Authorization\Providers\EmailProvider;

// Zarejestruj TOTP provider (Google Authenticator)
Config::registerTwoFactorProvider('totp', new TOTPProvider('Moja Aplikacja'));

// Zarejestruj Email provider
$emailProvider = new EmailProvider();
$emailProvider->setEmailCallback(function($email, $code) {
    // Wyślij kod na email użytkownika
    mail($email, 'Twój kod weryfikacyjny', "Kod: $code");
});
Config::registerTwoFactorProvider('email', $emailProvider);


use NimblePHP\Authorization\Authorization;

$auth = new Authorization();

// Sprawdź że użytkownik jest zalogowany
if ($auth->isAuthorized()) {
    // Pobierz TOTP provider
    $totp = Config::getTwoFactorProvider('totp');
    
    // Włącz 2FA i zwróć informacje o QR kodzie
    $result = $auth->enableTwoFactorAuth($totp);
    
    echo "Secret: " . $result['secret'];
    echo "QR Code URL: " . $result['qr_code'];
    echo "Provider: " . $result['provider'];
}


// W szablonie HTML
<img src=" echo htmlspecialchars($qrCodeUrl);


use NimblePHP\Authorization\Authorization;
use NimblePHP\Authorization\Exceptions\PendingTwoFactorException;
use NimblePHP\Authorization\Exceptions\TwoFactorException;

$auth = new Authorization();

try {
    // Logowanie z hasłem
    $loggedIn = $auth->login('[email protected]', 'password123');
    
    if ($loggedIn && !$auth->isTwoFactorEnabled($auth->getAuthorizedId())) {
        // 2FA nie jest włączone, zalogowanie ukończone
        echo "Zalogowano pomyślnie!";
    }
} catch (PendingTwoFactorException $e) {
    // Użytkownik ma 2FA - potrzebna weryfikacja
    $userId = $e->getUserId();
    $provider = $e->getProvider();
    
    // Przekieruj do strony weryfikacji 2FA
    // Przechowaj userId w sesji jeśli potrzebne
    echo "Proszę wpisać kod z Twojej aplikacji authenticatora";
} catch (RateLimitExceededException $e) {
    // Obsłuż rate limit
    echo "Zbyt wiele prób. Spróbuj za " . $e->getRemainingTime() . " sekund.";
}

// Na stronie weryfikacji 2FA:
try {
    $verified = $auth->verifyTwoFactorCode($_POST['2fa_code']);
    
    if ($verified) {
        echo "Zalogowano pomyślnie!";
    }
} catch (TwoFactorException $e) {
    echo "Nieprawidłowy kod: " . $e->getMessage();
}


use NimblePHP\Authorization\Config;
use NimblePHP\Authorization\Providers\EmailProvider;

$emailProvider = new EmailProvider(6, 600); // 6-cyfrowy kod, ważny 10 minut

// Ustaw funkcję do wysyłania emaili
$emailProvider->setEmailCallback(function($email, $code) {
    // Użyj Twojego systemu wysyłania emaili
    sendEmail($email, 'Kod weryfikacyjny', "Twój kod: $code");
});

Config::registerTwoFactorProvider('email', $emailProvider);


$emailProvider = Config::getTwoFactorProvider('email');

// Wyślij kod na email użytkownika
$code = $emailProvider->generateCode('[email protected]');


if ($auth->isAuthorized()) {
    if ($auth->isTwoFactorEnabled()) {
        $auth->disableTwoFactorAuth();
        echo "2FA wyłączone";
    }
}


$totp = Config::getTwoFactorProvider('totp');
$secret = 'JBSWY3DPEBLW64TMMQ'; // Sekret użytkownika

// Generuj kody odzyskania
$recoveryCodes = $totp->getRecoveryCodes($secret, 10); // Generuj 10 kodów

// Wyświetl użytkownikowi - powinien je zapisać w bezpiecznym miejscu
foreach ($recoveryCodes as $code) {
    echo $code . "\n";
}

// Weryfikacja kodu odzyskania podczas logowania
if ($totp->verifyRecoveryCode($secret, $_POST['recovery_code'])) {
    // Kod jest ważny - zaloguj użytkownika
    $auth->verifyTwoFactorCode($_POST['recovery_code']);
}


use NimblePHP\Authorization\Config;

// Domyślnie autoryzacja NIE jest wymagana (tradycyjne podejście)
Config::$


use NimblePHP\Authorization\Attributes\RequireAuth;
use NimblePHP\Authorization\Config;

// Konfiguracja
Config::$   return "Informacje publiczne";
    }

    // Metoda chroniona - wymaga autoryzacji
    #[RequireAuth]
    public function profile() {
        return "Profil użytkownika";
    }

    // Metoda chroniona - wymaga autoryzacji
    #[RequireAuth]
    public function settings() {
        return "Ustawienia użytkownika";
    }
}


use NimblePHP\Authorization\Attributes\NoAuth;
use NimblePHP\Authorization\Config;

// Konfiguracja
Config::$ login() {
        return "Formularz logowania";
    }

    // Metoda publiczna - wyłączenie autoryzacji
    #[NoAuth]
    public function register() {
        return "Formularz rejestracji";
    }

    // Metoda chroniona - domyślnie wymaga autoryzacji
    public function profile() {
        return "Profil użytkownika";
    }

    // Metoda chroniona - domyślnie wymaga autoryzacji
    public function settings() {
        return "Ustawienia użytkownika";
    }
}


use NimblePHP\Authorization\Attributes\HasRole;
use NimblePHP\Authorization\Attributes\HasPermission;
use NimblePHP\Authorization\Attributes\HasAnyRole;
use NimblePHP\Authorization\Attributes\HasAllRoles;
use NimblePHP\Authorization\Attributes\HasAnyPermission;

class AdminController
{
    // Podstawowe sprawdzenia
    #[HasRole('admin')]
    public function dashboard()
    {
        return "Panel administratora - tylko dla adminów";
    }

    #[HasPermission('users.edit')]
    public function editUser($userId)
    {
        return "Edycja użytkownika: " . $userId;
    }

    // Zaawansowane sprawdzenia wielu ról/uprawnień
    #[HasAnyRole('admin', 'moderator')]
    public function moderateContent()
    {
        return "Moderacja treści - dla adminów lub moderatorów";
    }

    #[HasAllRoles('admin', 'editor')]
    public function manageAllContent()
    {
        return "Zarządzanie całą treścią - tylko dla adminów którzy są też edytorami";
    }

    #[HasAnyPermission('content.edit', 'content.delete')]
    public function modifyContent($contentId)
    {
        return "Modyfikacja treści: " . $contentId;
    }

    // Wielokrotne atrybuty (każdy musi być spełniony)
    #[HasRole('admin')]
    #[HasPermission('system.settings')]
    public function systemSettings()
    {
        return "Ustawienia systemu - wymaga roli admin i uprawnienia system.settings";
    }
}


use NimblePHP\Authorization\Authorization;

$auth = new Authorization();


use NimblePHP\Authorization\Config;

// Konfiguracja dla username
Config::$authType = 'username';

try {
    $success = $auth->register('jan_kowalski', 'bezpieczne_haslo123');
    if ($success) {
        echo "Użytkownik został pomyślnie zarejestrowany!";
    }
} catch (InvalidArgumentException $e) {
    echo "Błąd rejestracji: " . $e->getMessage();
}


use NimblePHP\Authorization\Config;

// Konfiguracja dla email
Config::$authType = 'email';

try {
    $success = $auth->register('jan_kowalski', 'bezpieczne_haslo123', '[email protected]');
    if ($success) {
        echo "Użytkownik został pomyślnie zarejestrowany!";
    }
} catch (InvalidArgumentException $e) {
    echo "Błąd rejestracji: " . $e->getMessage();
}


try {
    // Dla username autoryzacji
    if (Config::$authType === 'username') {
        $loggedIn = $auth->login('jan_kowalski', 'bezpieczne_haslo123');
    }
    // Dla email autoryzacji
    else {
        $loggedIn = $auth->login('[email protected]', 'bezpieczne_haslo123');
    }

    if ($loggedIn) {
        echo "Zalogowano pomyślnie!";
    } else {
        echo "Nieprawidłowe dane logowania!";
    }
} catch (InvalidArgumentException $e) {
    echo "Błąd logowania: " . $e->getMessage();
}


use NimblePHP\Authorization\Authorization;

$auth = new Authorization();

try {
    if ($auth->authenticateHttpBasic()) {
        echo "Autoryzacja HTTP Basic się powiodła";
        $userId = $auth->getAuthorizedId();
    }
} catch (InvalidArgumentException $e) {
    echo "Błąd formatu Authorization nagłówka: " . $e->getMessage();
    http_response_code(400);
} catch (RateLimitExceededException $e) {
    echo "Zbyt wiele prób logowania";
    http_response_code(429);
}


if ($auth->isAuthorized()) {
    $userId = $auth->getAuthorizedId();
    $userData = $auth->getCurrentUser();
    echo "Witaj, użytkownik o ID: " . $userId;
} else {
    echo "Użytkownik nie jest zalogowany.";
}


$auth->logout();
echo "Użytkownik został wylogowany.";


use NimblePHP\Authorization\Account;

$account = new Account();
$userData = $account->getAccount();

if ($account->usernameExists('jan_kowalski')) {
    echo "Ta nazwa użytkownika jest już zajęta.";
}


use NimblePHP\Authorization\Config;

// Dostosowanie nazw kolumn
Config::$columns = [
    'id' => 'user_id',
    'username' => 'login_name',
    'email' => 'user_email',
    'password' => 'password_hash',
    'created_at' => 'registration_date',
    'status' => 'user_status'
];

// Ustawienie niestandardowej nazwy tabeli
Config::$tableName = 'users';

// Ustawienie niestandardowego klucza sesji
Config::$sessionKey = 'user_session_id';

// Teraz wszystkie operacje będą używać nowych nazw
$userData = $auth->getCurrentUser();

// Ustawienie niestandardowej nazwy tabeli użytkowników
Config::$tableName = 'my_custom_accounts';

// Ustawienie niestandardowych nazw tabel RBAC
Config::$rolesTableName = 'my_roles';
Config::$permissionsTableName = 'my_permissions';
Config::$userRolesTableName = 'my_user_roles';
Config::$rolePermissionsTableName = 'my_role_permissions';


use NimblePHP\Authorization\Account;

// Utworzenie instancji konta dla zalogowanego użytkownika
$account = new Account();

// Zmiana hasła
$account->changePassword('nowe_bezpieczne_haslo');

// Aktualizacja danych konta
$account->update([
    'email' => '[email protected]',
    'updated_at' => date('Y-m-d H:i:s')
]);

// Pobranie ID konta
$userId = $account->getId();

// Ustawienie konkretnego ID konta
$account->setId(123);


use NimblePHP\Authorization\Config;

// Włączenie wymagania aktywacji
Config::${
    echo "Aktywacja kont jest wymagana";
}


use NimblePHP\Authorization\Authorization;
use NimblePHP\Authorization\Config;

// Włączenie aktywacji
Config::$'jan_kowalski', 'bezpieczne_haslo123', '[email protected]');

if ($success) {
    echo "Użytkownik zarejestrowany. Wymagana aktywacja konta.";
}

// Próba logowania przed aktywacją zakończy się niepowodzeniem
$loginResult = $auth->login('jan_kowalski', 'bezpieczne_haslo123');
// $loginResult będzie false


use NimblePHP\Authorization\Account;

$account = new Account();

// Sprawdzenie czy konto jest aktywne
$userId = 123;
if ($account->isActive($userId)) {
    echo "Konto jest aktywne";
} else {
    echo "Konto wymaga aktywacji";
}

// Aktywacja konta
$account->setId($userId);
$success = $account->activate();
if ($success) {
    echo "Konto zostało aktywowane";
}

// Dezaktywacja konta
$success = $account->deactivate($userId);
if ($success) {
    echo "Konto zostało dezaktywowane";
}

// Aktywacja bez ustawiania ID (używa bieżącego zalogowanego użytkownika)
$account->activate();


use NimblePHP\Authorization\Authorization;
use NimblePHP\Authorization\Config;

Config::$niem
$loginResult = $auth->login('jan_kowalski', 'bezpieczne_haslo123');
if (!$loginResult) {
    echo "Logowanie nieudane. Sprawdź czy konto jest aktywowane.";
}


use NimblePHP\Authorization\Config;

// Wyłączenie aktywacji (domyślnie)
Config::$i true


use NimblePHP\Authorization\Role;
use NimblePHP\Authorization\Permission;

// Tworzenie roli administratora
$role = new Role();
$role->create('admin', 'Administrator systemu');

// Tworzenie uprawnień
$permission = new Permission();
$permission->create('users.manage', 'Zarządzanie użytkownikami', 'users');
$permission->create('content.publish', 'Publikacja treści', 'content');
$permission->create('system.settings', 'Ustawienia systemu', 'system');


use NimblePHP\Authorization\Role;

// Znajdź rolę administratora
$role = new Role();
$roleData = $role->findByName('admin');
$role->setId($roleData['roles']['id']);

// Dodaj uprawnienia do roli
$role->addPermission(1); // users.manage
$role->addPermission(2); // content.publish
$role->addPermission(3); // system.settings


use NimblePHP\Authorization\Authorization;
use NimblePHP\Authorization\Account;

$auth = new Authorization();
$account = new Account();

// Po zalogowaniu administratora
$userId = $auth->getAuthorizedId();

// Przypisz rolę administratora użytkownikowi
$account->setId($userId);
$account->assignRole('admin');

// Sprawdź czy użytkownik ma rolę
if ($auth->hasRole('admin')) {
    echo "Użytkownik jest administratorem";
}

// Sprawdź czy użytkownik ma uprawnienie
if ($auth->hasPermission('users.manage')) {
    echo "Użytkownik może zarządzać użytkownikami";
}


use NimblePHP\Authorization\Authorization;

$auth = new Authorization();

// Sprawdź czy użytkownik ma którąkolwiek z ról
if ($auth->hasAnyRole(['admin', 'moderator'])) {
    echo "Użytkownik ma uprawnienia moderatora lub wyższe";
}

// Sprawdź czy użytkownik ma wszystkie wymienione role
if ($auth->hasAllRoles(['admin', 'editor'])) {
    echo "Użytkownik jest adminem i edytorem";
}

// Sprawdź czy użytkownik ma którekolwiek z uprawnień
if ($auth->hasAnyPermission(['content.edit', 'content.delete'])) {
    echo "Użytkownik może edytować lub usuwać treści";
}

// Bardziej złożone warunki
$roles = ['admin', 'moderator', 'editor'];
$permissions = ['users.view', 'users.edit'];

// Sprawdź czy użytkownik ma którąkolwiek rolę LUB którekolwiek uprawnienie
if ($auth->hasAnyRole($roles) || $auth->hasAnyPermission($permissions)) {
    echo "Użytkownik ma odpowiednie uprawnienia";
}

// Sprawdź czy użytkownik ma którąkolwiek rolę ORAZ którekolwiek uprawnienie
if ($auth->hasAnyRole($roles) && $auth->hasAnyPermission($permissions)) {
    echo "Użytkownik ma rolę i uprawnienia";
}


use NimblePHP\Authorization\Authorization;

$auth = new Authorization();

// Pobierz wszystkie role użytkownika
$userRoles = $auth->getUserRoles();
foreach ($userRoles as $role) {
    echo "Rola: " . $role['roles']['name'] . "\n";
}

// Pobierz wszystkie uprawnienia użytkownika
$userPermissions = $auth->getUserPermissions();
foreach ($userPermissions as $permission) {
    echo "Uprawnienie: " . $permission['permissions']['name'] . "\n";
}


use NimblePHP\Authorization\Attributes\HasRole;
use NimblePHP\Authorization\Attributes\HasPermission;

class AdminController
{
    #[HasRole('admin')]
    public function adminDashboard()
    {
        return "Panel administratora - tylko dla adminów";
    }

    #[HasRole('moderator')]
    public function moderateUsers()
    {
        return "Moderacja użytkowników";
    }

    #[HasPermission('users.edit')]
    public function editUser($userId)
    {
        return "Edycja użytkownika {$userId}";
    }

    #[HasPermission('content.delete')]
    public function deleteContent($contentId)
    {
        return "Usunięcie treści {$contentId}";
    }
}


use NimblePHP\Authorization\Role;
use NimblePHP\Authorization\Account;

// Tworzenie nowej roli
$role = new Role();
$role->create('editor', 'Edytor treści');

// Przypisywanie roli do użytkownika
$account = new Account($userId);
$account->assignRole('editor');

// Usuwanie roli od użytkownika
$account->removeRole('editor');

// Pobieranie wszystkich użytkowników z rolą
$role = new Role();
$roleData = $role->findByName('editor');
$role->setId($roleData['roles']['id']);
$usersWithRole = $role->getUsersWithRole();


use NimblePHP\Authorization\Config;

Config::$columns = [
    'id' => 'user_id',
    'username' => 'login_name',
    'email' => 'user_email',
    'password' => 'password_hash',
    'active' => 'is_active'
];


use NimblePHP\Authorization\Authorization;
use NimblePHP\Authorization\Providers\GitHubProvider;

$auth = new Authorization();

// Rejestracja providera
$githubProvider = new GitHubProvider(
    'YOUR_CLIENT_ID',
    'YOUR_CLIENT_SECRET'
);

\NimblePHP\Authorization\Config::registerOAuthProvider('github', $githubProvider);


// W kontrolerze - przekieruj użytkownika do GitHub
$auth = new Authorization();
$redirectUri = 'https://twoja-domena.com/oauth/github/callback';
$authUrl = $auth->initiateOAuthLogin('github', $redirectUri);

header('Location: ' . $authUrl);


// W kontrolerze callback'u (np. /oauth/github/callback)
$auth = new Authorization();

try {
    $code = $_GET['code'] ?? null;
    
    if (!$code) {
        throw new \Exception('Brak kodu autoryzacyjnego');
    }
    
    // Obsługa callbacku i pobieranie danych użytkownika
    $redirectUri = 'https://twoja-domena.com/oauth/github/callback';
    $userData = $auth->handleOAuthCallback($code, 'github');
    
    // Logowanie użytkownika (tworzy konto jeśli nie istnieje)
    if ($auth->loginWithOAuth($userData)) {
        header('Location: /dashboard');
        exit;
    }
} catch (\Exception $e) {
    echo 'Błąd autoryzacji: ' . $e->getMessage();
}


[
    'oauth_id' => '12345678',        // GitHub user ID
    'oauth_provider' => 'github',     // Dostawca OAuth
    'username' => 'octocat',          // GitHub login
    'email' => '[email protected]',  // Email użytkownika
    'name' => 'The Octocat',          // Imię i nazwisko
    'avatar' => 'https://...',        // Avatar URL
    'profile_url' => 'https://...'    // URL profilu GitHub
]




namespace MyApp\OAuth;

use NimblePHP\Authorization\Interfaces\OAuthProvider;

class GoogleProvider implements OAuthProvider
{
    private string $clientId;
    private string $clientSecret;
    
    public function __construct(string $clientId, string $clientSecret)
    {
        $this->clientId = $clientId;
        $this->clientSecret = $clientSecret;
    }
    
    public function getAuthorizationUrl(string $state): string
    {
        return 'https://accounts.google.com/o/oauth2/v2/auth?' . http_build_query([
            'client_id' => $this->clientId,
            'redirect_uri' => 'https://twoja-domena.com/oauth/google/callback',
            'response_type' => 'code',
            'scope' => 'openid profile email',
            'state' => $state,
        ]);
    }
    
    public function exchangeCodeForToken(string $code): array
    {
        // Implementacja wymiany kodu na token
    }
    
    public function getUserData(string $accessToken): array
    {
        // Implementacja pobierania danych użytkownika
    }
    
    public function getName(): string
    {
        return 'google';
    }
    
    public function getClientId(): string
    {
        return $this->clientId;
    }
    
    public function getClientSecret(): string
    {
        return $this->clientSecret;
    }
}


$googleProvider = new \MyApp\OAuth\GoogleProvider('CLIENT_ID', 'CLIENT_SECRET');
\NimblePHP\Authorization\Config::registerOAuthProvider('google', $googleProvider);


// Logowanie bez tworzenia konta jeśli użytkownik nie istnieje
$auth->loginWithOAuth($userData, createIfNotExists: false);


use NimblePHP\Authorization\Config;
use NimblePHP\Authorization\Providers\JWTProvider;

$jwtProvider = new JWTProvider(
    $_ENV['JWT_SECRET'],  // Minimum 32 characters
    'HS256',              // Algorithm
    3600                  // Default expiration (1 hour)
);

Config::registerTokenProvider('jwt', $jwtProvider);


$auth = new Authorization();

if ($auth->login($username, $password)) {
    $token = $auth->generateToken(
        $auth->getAuthorizedId(),
        'jwt',
        ['role' => 'user'],
        3600
    );
    
    echo json_encode(['token' => $token]);
}


$auth = new Authorization();

try {
    $tokenData = $auth->validateToken($authToken, 'jwt');
    $userId = $tokenData['user_id'];
    
    // Token jest ważny
    
} catch (Exception $e) {
    http_response_code(401);
    echo json_encode(['error' => 'Invalid token']);
}


use NimblePHP\Authorization\Config;
use NimblePHP\Authorization\Providers\APIKeyProvider;

$apiKeyProvider = new APIKeyProvider();

Config::registerTokenProvider('api_key', $apiKeyProvider);


$auth = new Authorization();

$apiKey = $auth->generateToken(
    $auth->getAuthorizedId(),
    'api_key',
    [
        'name' => 'My API Key',
        'scopes' => ['read:users', 'write:posts'],
        'rate_limit' => 1000  // Requests per hour
    ],
    365 * 24 * 3600  // 1 year
);

echo $apiKey;  // sk_abcdef1234567890...


$auth = new Authorization();

try {
    $keyData = $auth->validateToken($apiKey, 'api_key');
    $userId = $keyData['user_id'];
    $scopes = $keyData['scopes'];
    
} catch (Exception $e) {
    http_response_code(401);
}


$auth = new Authorization();
$provider = $auth->getTokenProvider('api_key');
$userId = $auth->getAuthorizedId();

// Lista kluczy użytkownika
$keys = $provider->listUserKeys($userId);

// Detale klucza
$key = $provider->getKey($keyId, $userId);

// Aktualizacja klucza
$provider->updateKey($keyId, $userId, [
    'name' => 'Updated Name',
    'rate_limit' => 5000
]);

// Revocation (deaktywacja)
$auth->revokeToken($apiKey, 'api_key');


$provider = $auth->getTokenProvider('api_key');

$rateLimit = $provider->getRateLimit($apiKey);

// Odpowiedź
header('X-RateLimit-Limit: ' . $rateLimit['limit']);
header('X-RateLimit-Used: ' . $rateLimit['used']);
header('X-RateLimit-Remaining: ' . $rateLimit['remaining']);

if ($rateLimit['remaining'] <= 0) {
    http_response_code(429);
    echo json_encode(['error' => 'Rate limit exceeded']);
}

shell
php vendor/bin/nimble project:update

bash
curl -H "Authorization: Basic $(echo -n 'username:password' | base64)" \
     https://example.com/api/protected