InMemoryTokensRepository.php

<?php


namespace Source\Gateways\Tokens;

use Carbon\Carbon;
use Source\Entities\Token;
use Source\Entities\RawToken;
use Source\Entities\HashedSearchable;
use Source\Exceptions\EntityNotFoundException;

class InMemoryTokensRepository implements TokensRepository
{
    protected static int $idCounter = 100;

    /**
     * @var Token[]
     */
    protected array $tokens = [];

    /** @inheritDoc */
    public function create(Token $token): Token
    {
        if ($token->hasIdOf(0)) {
            $token->setId(static::$idCounter++);
        }

        $this->tokens[] = $token;

        return $token;
    }

    /**
     * @inheritDoc
     */
    public function createLoginToken(string $userId, string $salt): RawToken
    {
        $raw = self::generateTokenString();
        return new RawToken($raw, $this->create(new Token(
            0,
            $userId,
            HashedSearchable::hash($salt, $raw),
            null,
            Carbon::now()->addDay()
        )));
    }

    /**
     * @inheritDoc
     */
    public function update(string $tokenId, Token $token): Token
    {
        foreach ($this->tokens as $key=>$tok) {
            if ($tok->hasIdOf($tokenId)) {
                $this->tokens[$key] = $token;

                return $token;
            }
        }

        throw new EntityNotFoundException();
    }

    /**
     * @param string|null         $userId
     * @param \Carbon\Carbon|null $validAt
     * @return Token[]
     */
    public function filter(?string $userId = null, ?Carbon $validAt = null): array
    {
        return array_values(array_filter($this->tokens, static function (Token $token) use ($userId, $validAt) {
            $include = true;

            if ($validAt) {
                $include = $token->isValidAtTime($validAt);
            }

            if ($userId !== null) {
                $include = $include && $token->hasUserIdOf($userId);
            }

            return $include;
        }));
    }

    /** @inheritDoc */
    public function findValidToken(?HashedSearchable $hash): ?Token
    {
        foreach ($this->tokens as $token) {
            if ($token->matches($hash) && $token->isValidAtTime(Carbon::now())) {
                return $token;
            }
        }

        return null;
    }

    /**
     * @inheritDoc
     */
    public function invalidateToken(?HashedSearchable $hash): void
    {
        $tok = $this->findValidToken($hash);

        if ($tok) {
            $tok->setExpiresAt(Carbon::now());
        }
    }

    /**
     * @inheritDoc
     */
    public static function generateTokenString(): string
    {
        // For now just do what the actual database implementation does
        // We don't need to do anything special
        return DatabaseTokensRepository::generateTokenString();
    }

    /**
     * @inheritDoc
     */
    public function invalidateTokenById(string $tokenId): void
    {
        foreach ($this->tokens as $token) {
            if ($token->hasIdOf($tokenId) && $token->isValid()) {
                $token->setExpiresAt(Carbon::now());
            }
        }
    }

    /**
     * @inheritDoc
     */
    public function get(string $tokenId): ?Token
    {
        foreach ($this->tokens as $token) {
            if ($token->hasIdOf($tokenId)) {
                return $token;
            }
        }

        return null;
    }
}