Merge pull request #632 from shlinkio/develop

Release v2.0.3
Merge pull request #631 from acelaya-forks/feature/permission-denied
2026-03-04 14:23:13 +08:00 · 2020-01-27 11:44:43 +01:00 · 2020-01-27 11:37:37 +01:00 · 2020-01-27 11:31:44 +01:00 · 2020-01-27 11:30:29 +01:00 · 2020-01-26 20:00:47 +01:00
49 changed files with 712 additions and 285 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,81 @@ All notable changes to this project will be documented in this file.

 The format is based on [Keep a Changelog](https://keepachangelog.com), and this project adheres to [Semantic Versioning](https://semver.org).

+## 2.0.3 - 2020-01-27
+
+#### Added
+
+* *Nothing*
+
+#### Changed
+
+* *Nothing*
+
+#### Deprecated
+
+* *Nothing*
+
+#### Removed
+
+* *Nothing*
+
+#### Fixed
+
+* [#624](https://github.com/shlinkio/shlink/issues/624) Fixed order in which headers for remote IP detection are inspected.
+* [#623](https://github.com/shlinkio/shlink/issues/623) Fixed short URLs metadata being impossible to reset.
+* [#628](https://github.com/shlinkio/shlink/issues/628) Fixed `GET /short-urls/{shortCode}` REST endpoint returning a 404 for short URLs which are not enabled.
+* [#621](https://github.com/shlinkio/shlink/issues/621) Fixed permission denied error when updating same GeoLite file version more than once.
+
+
+## 2.0.2 - 2020-01-12
+
+#### Added
+
+* *Nothing*
+
+#### Changed
+
+* *Nothing*
+
+#### Deprecated
+
+* *Nothing*
+
+#### Removed
+
+* *Nothing*
+
+#### Fixed
+
+* [#614](https://github.com/shlinkio/shlink/issues/614) Fixed `OPTIONS` requests including the `Origin` header not always returning an empty body with status 2xx.
+* [#615](https://github.com/shlinkio/shlink/issues/615) Fixed query args with no value being lost from the long URL when users are redirected.
+
+
+## 2.0.1 - 2020-01-10
+
+#### Added
+
+* *Nothing*
+
+#### Changed
+
+* *Nothing*
+
+#### Deprecated
+
+* *Nothing*
+
+#### Removed
+
+* *Nothing*
+
+#### Fixed
+
+* [#607](https://github.com/shlinkio/shlink/issues/607) Added missing info on UPGRADE.md doc.
+* [#610](https://github.com/shlinkio/shlink/issues/610) Fixed use of hardcoded quotes on a database migration which makes it fail on postgres.
+* [#605](https://github.com/shlinkio/shlink/issues/605) Fixed crashes occurring when migrating from old Shlink versions with nullable DB columns that are assigned to non-nullable entity typed props.
+
+
 ## 2.0.0 - 2020-01-08

 #### Added
--- a/UPGRADE.md
+++ b/UPGRADE.md
@@ -2,6 +2,14 @@

 ## From v1.x to v2.x

+### PHP 7.4 required
+
+This new version takes advantage of several new features introduced in PHP 7.4.
+
+Thanks to that, the code is more reliable and robust, and easier to maintain and improve.
+
+However, that means that any previous PHP version is no longer supported.
+
 ### Preview generation

 The ability to generate website previews has been completely removed and has no replacement.
@@ -43,6 +51,16 @@ Endpoints need to provide a version in the path now. Previously, not providing a

 The only exception is the `/rest/health` endpoint, which will continue working without the version.

+### API errors
+
+Shlink v1.21.0 introduced support for API errors using the Problem Details format, as well as the v2 of the API.
+
+For backwards compatibility reasons, requests performed to v1 continued to return the old `error` and `message` properties.
+
+Starting with Shlink v2.0.0, both versions of the API will no longer return those two properties.
+
+As a replacement, use `type` instead of `error`, and `detail` instead of `message`.
+
 ### Changes in models

 The next REST API models have changed:
--- a/composer.json
+++ b/composer.json
@@ -49,8 +49,8 @@
        "pugx/shortid-php": "^0.5",
        "shlinkio/shlink-common": "^2.5",
        "shlinkio/shlink-event-dispatcher": "^1.3",
-        "shlinkio/shlink-installer": "^4.0",
-        "shlinkio/shlink-ip-geolocation": "^1.3",
+        "shlinkio/shlink-installer": "^4.0.1",
+        "shlinkio/shlink-ip-geolocation": "^1.3.1",
        "symfony/console": "^5.0",
        "symfony/filesystem": "^5.0",
        "symfony/lock": "^5.0",
@@ -58,6 +58,7 @@
    },
    "require-dev": {
        "devster/ubench": "^2.0",
+        "dms/phpunit-arraysubset-asserts": "^0.1.0",
        "eaglewu/swoole-ide-helper": "dev-master",
        "infection/infection": "^0.15.0",
        "phpstan/phpstan": "^0.12.3",
@@ -97,7 +98,7 @@
        ],
        "cs": "phpcs",
        "cs:fix": "phpcbf",
-        "stan": "phpstan analyse module/*/src/ module/*/config config docker/config --level=5 -c phpstan.neon",
+        "stan": "phpstan analyse module/*/src/ module/*/config config docker/config --level=6",
        "test": [
            "@test:unit",
            "@test:db",
--- a/config/autoload/client-detection.global.php
+++ b/config/autoload/client-detection.global.php
@@ -7,11 +7,11 @@ return [
    'ip_address_resolution' => [
        'headers_to_inspect' => [
            'CF-Connecting-IP',
-            'True-Client-IP',
-            'X-Real-IP',
-            'Forwarded',
            'X-Forwarded-For',
            'X-Forwarded',
+            'Forwarded',
+            'True-Client-IP',
+            'X-Real-IP',
            'X-Cluster-Client-Ip',
            'Client-Ip',
        ],
--- a/config/autoload/common.local.php.dist
+++ b/config/autoload/common.local.php.dist
@@ -1,4 +1,5 @@
 <?php
+
 declare(strict_types=1);

 use Laminas\ConfigAggregator\ConfigAggregator;
--- a/config/autoload/geolite2.global.php
+++ b/config/autoload/geolite2.global.php
@@ -7,9 +7,7 @@ return [
    'geolite2' => [
        'db_location' => __DIR__ . '/../../data/GeoLite2-City.mmdb',
        'temp_dir' => sys_get_temp_dir(),
-        'download_from' =>
-            'https://download.maxmind.com/app/geoip_download'
-            . '?edition_id=GeoLite2-City&license_key=G4Lm0C60yJsnkdPi&suffix=tar.gz',
+        'license_key' => 'G4Lm0C60yJsnkdPi',
    ],

 ];
--- a/config/autoload/router.local.php.dist
+++ b/config/autoload/router.local.php.dist
@@ -1,9 +1,13 @@
 <?php
+
+declare(strict_types=1);
+
 use Mezzio\Router\FastRouteRouter;

 return [

    'router' => [
+//        'base_path' => '',
        'fastroute' => [
            FastRouteRouter::CONFIG_CACHE_ENABLED => false,
        ],
--- a/config/autoload/swoole.local.php.dist
+++ b/config/autoload/swoole.local.php.dist
@@ -1,8 +1,9 @@
 <?php
+
 declare(strict_types=1);

-use Mezzio\Swoole\HotCodeReload\FileWatcher\InotifyFileWatcher;
 use Laminas\ServiceManager\Factory\InvokableFactory;
+use Mezzio\Swoole\HotCodeReload\FileWatcher\InotifyFileWatcher;

 return [

--- a/data/migrations/Version20200105165647.php
+++ b/data/migrations/Version20200105165647.php
@@ -9,18 +9,35 @@ use Doctrine\DBAL\Schema\Schema;
 use Doctrine\DBAL\Types\Types;
 use Doctrine\Migrations\AbstractMigration;

+use function Functional\some;
+
 final class Version20200105165647 extends AbstractMigration
 {
    private const COLUMNS = ['lat' => 'latitude', 'lon' => 'longitude'];

+    /**
+     * @throws DBALException
+     */
    public function preUp(Schema $schema): void
    {
+        $visitLocations = $schema->getTable('visit_locations');
+        $this->skipIf(some(
+            self::COLUMNS,
+            fn (string $v, string $newColName) => $visitLocations->hasColumn($newColName),
+        ), 'New columns already exist');
+
        foreach (self::COLUMNS as $columnName) {
            $qb = $this->connection->createQueryBuilder();
            $qb->update('visit_locations')
-               ->set($columnName, '"0"')
-               ->where($columnName . '=""')
-               ->orWhere($columnName . ' IS NULL')
+               ->set($columnName, ':zeroValue')
+               ->where($qb->expr()->orX(
+                   $qb->expr()->eq($columnName, ':emptyString'),
+                   $qb->expr()->isNull($columnName),
+               ))
+               ->setParameters([
+                   'zeroValue' => '0',
+                   'emptyString' => '',
+               ])
               ->execute();
        }
    }
@@ -33,16 +50,24 @@ final class Version20200105165647 extends AbstractMigration
        $visitLocations = $schema->getTable('visit_locations');

        foreach (self::COLUMNS as $newName => $oldName) {
-            $visitLocations->addColumn($newName, Types::FLOAT);
+            $visitLocations->addColumn($newName, Types::FLOAT, [
+                'default' => '0.0',
+            ]);
        }
    }

+    /**
+     * @throws DBALException
+     */
    public function postUp(Schema $schema): void
    {
+        $platformName = $this->connection->getDatabasePlatform()->getName();
+        $castType = $platformName === 'postgres' ? 'DOUBLE PRECISION' : 'DECIMAL(9,2)';
+
        foreach (self::COLUMNS as $newName => $oldName) {
            $qb = $this->connection->createQueryBuilder();
            $qb->update('visit_locations')
-               ->set($newName, $oldName)
+               ->set($newName, 'CAST(' . $oldName . ' AS ' . $castType . ')')
               ->execute();
        }
    }
--- a/data/migrations/Version20200106215144.php
+++ b/data/migrations/Version20200106215144.php
@@ -9,6 +9,8 @@ use Doctrine\DBAL\Schema\Schema;
 use Doctrine\DBAL\Types\Types;
 use Doctrine\Migrations\AbstractMigration;

+use function Functional\none;
+
 final class Version20200106215144 extends AbstractMigration
 {
    private const COLUMNS = ['latitude', 'longitude'];
@@ -19,6 +21,10 @@ final class Version20200106215144 extends AbstractMigration
    public function up(Schema $schema): void
    {
        $visitLocations = $schema->getTable('visit_locations');
+        $this->skipIf(none(
+            self::COLUMNS,
+            fn (string $oldColName) => $visitLocations->hasColumn($oldColName),
+        ), 'Old columns do not exist');

        foreach (self::COLUMNS as $colName) {
            $visitLocations->dropColumn($colName);
--- a/data/migrations/Version20200110182849.php
+++ b/data/migrations/Version20200110182849.php
@@ -0,0 +1,53 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ShlinkMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+use function Functional\each;
+use function Functional\partial_left;
+
+final class Version20200110182849 extends AbstractMigration
+{
+    private const DEFAULT_EMPTY_VALUE = '';
+    private const COLUMN_DEFAULTS_MAP = [
+        'visits' => [
+            'referer',
+            'user_agent',
+        ],
+        'visit_locations' => [
+            'timezone',
+            'country_code',
+            'country_name',
+            'region_name',
+            'city_name',
+        ],
+    ];
+
+    public function up(Schema $schema): void
+    {
+        each(
+            self::COLUMN_DEFAULTS_MAP,
+            fn (array $columns, string $tableName) =>
+                each($columns, partial_left([$this, 'setDefaultValueForColumnInTable'], $tableName)),
+        );
+    }
+
+    public function setDefaultValueForColumnInTable(string $tableName, string $columnName): void
+    {
+        $qb = $this->connection->createQueryBuilder();
+        $qb->update($tableName)
+           ->set($columnName, ':emptyValue')
+           ->setParameter('emptyValue', self::DEFAULT_EMPTY_VALUE)
+           ->where($qb->expr()->isNull($columnName))
+           ->execute();
+    }
+
+    public function down(Schema $schema): void
+    {
+        // No need (and no way) to undo this migration
+    }
+}
--- a/docker/README.md
+++ b/docker/README.md
@@ -1,6 +1,6 @@
 # Shlink Docker image

-[![Docker build status](https://img.shields.io/docker/cloud/build/shlinkio/shlink.svg?style=flat-square)](https://hub.docker.com/r/shlinkio/shlink/)
+[![Docker build status](https://img.shields.io/docker/build/shlinkio/shlink.svg?style=flat-square)](https://hub.docker.com/r/shlinkio/shlink/)
 [![Docker pulls](https://img.shields.io/docker/pulls/shlinkio/shlink.svg?style=flat-square)](https://hub.docker.com/r/shlinkio/shlink/)

 This image provides an easy way to set up [shlink](https://shlink.io) on a container-based runtime.
--- a/module/CLI/config/dependencies.config.php
+++ b/module/CLI/config/dependencies.config.php
@@ -55,7 +55,7 @@ return [
        GeolocationDbUpdater::class => [DbUpdater::class, Reader::class, 'Shlinkio\Shlink\LocalLockFactory'],

        Command\ShortUrl\GenerateShortUrlCommand::class => [Service\UrlShortener::class, 'config.url_shortener.domain'],
-        Command\ShortUrl\ResolveUrlCommand::class => [Service\UrlShortener::class],
+        Command\ShortUrl\ResolveUrlCommand::class => [Service\ShortUrl\ShortUrlResolver::class],
        Command\ShortUrl\ListShortUrlsCommand::class => [Service\ShortUrlService::class, 'config.url_shortener.domain'],
        Command\ShortUrl\GetVisitsCommand::class => [Service\VisitsTracker::class],
        Command\ShortUrl\DeleteShortUrlCommand::class => [Service\ShortUrl\DeleteShortUrlService::class],
--- a/module/CLI/src/Command/ShortUrl/GenerateShortUrlCommand.php
+++ b/module/CLI/src/Command/ShortUrl/GenerateShortUrlCommand.php
@@ -10,6 +10,7 @@ use Shlinkio\Shlink\Core\Exception\InvalidUrlException;
 use Shlinkio\Shlink\Core\Exception\NonUniqueSlugException;
 use Shlinkio\Shlink\Core\Model\ShortUrlMeta;
 use Shlinkio\Shlink\Core\Service\UrlShortenerInterface;
+use Shlinkio\Shlink\Core\Validation\ShortUrlMetaInputFilter;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputInterface;
@@ -121,14 +122,14 @@ class GenerateShortUrlCommand extends Command
            $shortUrl = $this->urlShortener->urlToShortCode(
                new Uri($longUrl),
                $tags,
-                ShortUrlMeta::createFromParams(
-                    $input->getOption('validSince'),
-                    $input->getOption('validUntil'),
-                    $customSlug,
-                    $maxVisits !== null ? (int) $maxVisits : null,
-                    $input->getOption('findIfExists'),
-                    $input->getOption('domain'),
-                ),
+                ShortUrlMeta::fromRawData([
+                    ShortUrlMetaInputFilter::VALID_SINCE => $input->getOption('validSince'),
+                    ShortUrlMetaInputFilter::VALID_UNTIL => $input->getOption('validUntil'),
+                    ShortUrlMetaInputFilter::CUSTOM_SLUG => $customSlug,
+                    ShortUrlMetaInputFilter::MAX_VISITS => $maxVisits !== null ? (int) $maxVisits : null,
+                    ShortUrlMetaInputFilter::FIND_IF_EXISTS => $input->getOption('findIfExists'),
+                    ShortUrlMetaInputFilter::DOMAIN => $input->getOption('domain'),
+                ]),
            );

            $io->writeln([
--- a/module/CLI/src/Command/ShortUrl/ResolveUrlCommand.php
+++ b/module/CLI/src/Command/ShortUrl/ResolveUrlCommand.php
@@ -6,7 +6,7 @@ namespace Shlinkio\Shlink\CLI\Command\ShortUrl;

 use Shlinkio\Shlink\CLI\Util\ExitCodes;
 use Shlinkio\Shlink\Core\Exception\ShortUrlNotFoundException;
-use Shlinkio\Shlink\Core\Service\UrlShortenerInterface;
+use Shlinkio\Shlink\Core\Service\ShortUrl\ShortUrlResolverInterface;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputInterface;
@@ -20,12 +20,12 @@ class ResolveUrlCommand extends Command
 {
    public const NAME = 'short-url:parse';

-    private UrlShortenerInterface $urlShortener;
+    private ShortUrlResolverInterface $urlResolver;

-    public function __construct(UrlShortenerInterface $urlShortener)
+    public function __construct(ShortUrlResolverInterface $urlResolver)
    {
        parent::__construct();
-        $this->urlShortener = $urlShortener;
+        $this->urlResolver = $urlResolver;
    }

    protected function configure(): void
@@ -58,7 +58,7 @@ class ResolveUrlCommand extends Command
        $domain = $input->getOption('domain');

        try {
-            $url = $this->urlShortener->shortCodeToUrl($shortCode, $domain);
+            $url = $this->urlResolver->shortCodeToShortUrl($shortCode, $domain);
            $output->writeln(sprintf('Long URL: <info>%s</info>', $url->getLongUrl()));
            return ExitCodes::EXIT_SUCCESS;
        } catch (ShortUrlNotFoundException $e) {
--- a/module/CLI/test/Command/ShortUrl/ResolveUrlCommandTest.php
+++ b/module/CLI/test/Command/ShortUrl/ResolveUrlCommandTest.php
@@ -9,7 +9,7 @@ use Prophecy\Prophecy\ObjectProphecy;
 use Shlinkio\Shlink\CLI\Command\ShortUrl\ResolveUrlCommand;
 use Shlinkio\Shlink\Core\Entity\ShortUrl;
 use Shlinkio\Shlink\Core\Exception\ShortUrlNotFoundException;
-use Shlinkio\Shlink\Core\Service\UrlShortener;
+use Shlinkio\Shlink\Core\Service\ShortUrl\ShortUrlResolverInterface;
 use Symfony\Component\Console\Application;
 use Symfony\Component\Console\Tester\CommandTester;

@@ -20,12 +20,12 @@ use const PHP_EOL;
 class ResolveUrlCommandTest extends TestCase
 {
    private CommandTester $commandTester;
-    private ObjectProphecy $urlShortener;
+    private ObjectProphecy $urlResolver;

    public function setUp(): void
    {
-        $this->urlShortener = $this->prophesize(UrlShortener::class);
-        $command = new ResolveUrlCommand($this->urlShortener->reveal());
+        $this->urlResolver = $this->prophesize(ShortUrlResolverInterface::class);
+        $command = new ResolveUrlCommand($this->urlResolver->reveal());
        $app = new Application();
        $app->add($command);

@@ -38,8 +38,8 @@ class ResolveUrlCommandTest extends TestCase
        $shortCode = 'abc123';
        $expectedUrl = 'http://domain.com/foo/bar';
        $shortUrl = new ShortUrl($expectedUrl);
-        $this->urlShortener->shortCodeToUrl($shortCode, null)->willReturn($shortUrl)
-                                                             ->shouldBeCalledOnce();
+        $this->urlResolver->shortCodeToShortUrl($shortCode, null)->willReturn($shortUrl)
+                                                                 ->shouldBeCalledOnce();

        $this->commandTester->execute(['shortCode' => $shortCode]);
        $output = $this->commandTester->getDisplay();
@@ -50,7 +50,7 @@ class ResolveUrlCommandTest extends TestCase
    public function incorrectShortCodeOutputsErrorMessage(): void
    {
        $shortCode = 'abc123';
-        $this->urlShortener->shortCodeToUrl($shortCode, null)
+        $this->urlResolver->shortCodeToShortUrl($shortCode, null)
            ->willThrow(ShortUrlNotFoundException::fromNotFoundShortCode($shortCode))
            ->shouldBeCalledOnce();

--- a/module/Core/config/dependencies.config.php
+++ b/module/Core/config/dependencies.config.php
@@ -30,6 +30,7 @@ return [
            Service\VisitService::class => ConfigAbstractFactory::class,
            Service\Tag\TagService::class => ConfigAbstractFactory::class,
            Service\ShortUrl\DeleteShortUrlService::class => ConfigAbstractFactory::class,
+            Service\ShortUrl\ShortUrlResolver::class => ConfigAbstractFactory::class,

            Util\UrlValidator::class => ConfigAbstractFactory::class,

@@ -56,22 +57,27 @@ return [
        Service\VisitService::class => ['em'],
        Service\Tag\TagService::class => ['em'],
        Service\ShortUrl\DeleteShortUrlService::class => ['em', Options\DeleteShortUrlsOptions::class],
+        Service\ShortUrl\ShortUrlResolver::class => ['em'],

        Util\UrlValidator::class => ['httpClient'],

        Action\RedirectAction::class => [
-            Service\UrlShortener::class,
+            Service\ShortUrl\ShortUrlResolver::class,
            Service\VisitsTracker::class,
            Options\AppOptions::class,
            'Logger_Shlink',
        ],
        Action\PixelAction::class => [
-            Service\UrlShortener::class,
+            Service\ShortUrl\ShortUrlResolver::class,
            Service\VisitsTracker::class,
            Options\AppOptions::class,
            'Logger_Shlink',
        ],
-        Action\QrCodeAction::class => [RouterInterface::class, Service\UrlShortener::class, 'Logger_Shlink'],
+        Action\QrCodeAction::class => [
+            RouterInterface::class,
+            Service\ShortUrl\ShortUrlResolver::class,
+            'Logger_Shlink',
+        ],

        Middleware\QrCodeCacheMiddleware::class => [Cache::class],
    ],
--- a/module/Core/src/Action/AbstractTrackingAction.php
+++ b/module/Core/src/Action/AbstractTrackingAction.php
@@ -15,39 +15,33 @@ use Shlinkio\Shlink\Core\Entity\ShortUrl;
 use Shlinkio\Shlink\Core\Exception\ShortUrlNotFoundException;
 use Shlinkio\Shlink\Core\Model\Visitor;
 use Shlinkio\Shlink\Core\Options\AppOptions;
-use Shlinkio\Shlink\Core\Service\UrlShortenerInterface;
+use Shlinkio\Shlink\Core\Service\ShortUrl\ShortUrlResolverInterface;
 use Shlinkio\Shlink\Core\Service\VisitsTrackerInterface;

 use function array_key_exists;
 use function array_merge;
+use function GuzzleHttp\Psr7\build_query;
 use function GuzzleHttp\Psr7\parse_query;
-use function http_build_query;

 abstract class AbstractTrackingAction implements MiddlewareInterface
 {
-    private UrlShortenerInterface $urlShortener;
+    private ShortUrlResolverInterface $urlResolver;
    private VisitsTrackerInterface $visitTracker;
    private AppOptions $appOptions;
    private LoggerInterface $logger;

    public function __construct(
-        UrlShortenerInterface $urlShortener,
+        ShortUrlResolverInterface $urlResolver,
        VisitsTrackerInterface $visitTracker,
        AppOptions $appOptions,
        ?LoggerInterface $logger = null
    ) {
-        $this->urlShortener = $urlShortener;
+        $this->urlResolver = $urlResolver;
        $this->visitTracker = $visitTracker;
        $this->appOptions = $appOptions;
        $this->logger = $logger ?: new NullLogger();
    }

-    /**
-     * Process an incoming server request and return a response, optionally delegating
-     * to the next middleware component to create the response.
-     *
-     *
-     */
    public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        $shortCode = $request->getAttribute('shortCode', '');
@@ -56,7 +50,7 @@ abstract class AbstractTrackingAction implements MiddlewareInterface
        $disableTrackParam = $this->appOptions->getDisableTrackParam();

        try {
-            $url = $this->urlShortener->shortCodeToUrl($shortCode, $domain);
+            $url = $this->urlResolver->shortCodeToEnabledShortUrl($shortCode, $domain);

            // Track visit to this short code
            if ($disableTrackParam === null || ! array_key_exists($disableTrackParam, $query)) {
@@ -79,7 +73,7 @@ abstract class AbstractTrackingAction implements MiddlewareInterface
        }
        $mergedQuery = array_merge($hardcodedQuery, $currentQuery);

-        return (string) $uri->withQuery(http_build_query($mergedQuery));
+        return (string) $uri->withQuery(build_query($mergedQuery));
    }

    abstract protected function createSuccessResp(string $longUrl): ResponseInterface;
--- a/module/Core/src/Action/QrCodeAction.php
+++ b/module/Core/src/Action/QrCodeAction.php
@@ -5,7 +5,6 @@ declare(strict_types=1);
 namespace Shlinkio\Shlink\Core\Action;

 use Endroid\QrCode\QrCode;
-use Mezzio\Router\Exception\RuntimeException;
 use Mezzio\Router\RouterInterface;
 use Psr\Http\Message\ResponseInterface as Response;
 use Psr\Http\Message\ServerRequestInterface as Request;
@@ -15,7 +14,7 @@ use Psr\Log\LoggerInterface;
 use Psr\Log\NullLogger;
 use Shlinkio\Shlink\Common\Response\QrCodeResponse;
 use Shlinkio\Shlink\Core\Exception\ShortUrlNotFoundException;
-use Shlinkio\Shlink\Core\Service\UrlShortenerInterface;
+use Shlinkio\Shlink\Core\Service\ShortUrl\ShortUrlResolverInterface;

 class QrCodeAction implements MiddlewareInterface
 {
@@ -24,27 +23,19 @@ class QrCodeAction implements MiddlewareInterface
    private const MAX_SIZE = 1000;

    private RouterInterface $router;
-    private UrlShortenerInterface $urlShortener;
+    private ShortUrlResolverInterface $urlResolver;
    private LoggerInterface $logger;

    public function __construct(
        RouterInterface $router,
-        UrlShortenerInterface $urlShortener,
+        ShortUrlResolverInterface $urlResolver,
        ?LoggerInterface $logger = null
    ) {
        $this->router = $router;
-        $this->urlShortener = $urlShortener;
+        $this->urlResolver = $urlResolver;
        $this->logger = $logger ?: new NullLogger();
    }

-    /**
-     * Process an incoming server request and return a response, optionally delegating
-     * to the next middleware component to create the response.
-     *
-     *
-     * @throws \InvalidArgumentException
-     * @throws RuntimeException
-     */
    public function process(Request $request, RequestHandlerInterface $handler): Response
    {
        // Make sure the short URL exists for this short code
@@ -52,7 +43,7 @@ class QrCodeAction implements MiddlewareInterface
        $domain = $request->getUri()->getAuthority();

        try {
-            $this->urlShortener->shortCodeToUrl($shortCode, $domain);
+            $this->urlResolver->shortCodeToEnabledShortUrl($shortCode, $domain);
        } catch (ShortUrlNotFoundException $e) {
            $this->logger->warning('An error occurred while creating QR code. {e}', ['e' => $e]);
            return $handler->handle($request);
--- a/module/Core/src/Entity/ShortUrl.php
+++ b/module/Core/src/Entity/ShortUrl.php
@@ -29,9 +29,9 @@ class ShortUrl extends AbstractEntity
    private Collection $visits;
    /** @var Collection|Tag[] */
    private Collection $tags;
-    private ?Chronos $validSince;
-    private ?Chronos $validUntil;
-    private ?int $maxVisits;
+    private ?Chronos $validSince = null;
+    private ?Chronos $validUntil = null;
+    private ?int $maxVisits = null;
    private ?Domain $domain;
    private bool $customSlugWasProvided;

@@ -135,7 +135,6 @@ class ShortUrl extends AbstractEntity

    /**
     * @param Collection|Visit[] $visits
-     * @return ShortUrl
     * @internal
     */
    public function setVisits(Collection $visits): self
@@ -149,9 +148,25 @@ class ShortUrl extends AbstractEntity
        return $this->maxVisits;
    }

-    public function maxVisitsReached(): bool
+    public function isEnabled(): bool
    {
-        return $this->maxVisits !== null && $this->getVisitsCount() >= $this->maxVisits;
+        $maxVisitsReached = $this->maxVisits !== null && $this->getVisitsCount() >= $this->maxVisits;
+        if ($maxVisitsReached) {
+            return false;
+        }
+
+        $now = Chronos::now();
+        $beforeValidSince = $this->validSince !== null && $this->validSince->gt($now);
+        if ($beforeValidSince) {
+            return false;
+        }
+
+        $afterValidUntil = $this->validUntil !== null && $this->validUntil->lt($now);
+        if ($afterValidUntil) {
+            return false;
+        }
+
+        return true;
    }

    public function toString(array $domainConfig): string
@@ -186,12 +201,10 @@ class ShortUrl extends AbstractEntity
        }

        $shortUrlTags = invoke($this->getTags(), '__toString');
-        $hasAllTags = count($shortUrlTags) === count($tags) && array_reduce(
+        return count($shortUrlTags) === count($tags) && array_reduce(
            $tags,
            fn (bool $hasAllTags, string $tag) => $hasAllTags && contains($shortUrlTags, $tag),
            true,
        );
-
-        return $hasAllTags;
    }
 }
--- a/module/Core/src/Entity/Visit.php
+++ b/module/Core/src/Entity/Visit.php
@@ -15,10 +15,10 @@ use Shlinkio\Shlink\Core\Visit\Model\VisitLocationInterface;

 class Visit extends AbstractEntity implements JsonSerializable
 {
-    private string $referer = '';
+    private string $referer;
    private Chronos $date;
    private ?string $remoteAddr = null;
-    private string $userAgent = '';
+    private string $userAgent;
    private ShortUrl $shortUrl;
    private ?VisitLocation $visitLocation = null;

--- a/module/Core/src/Model/ShortUrlMeta.php
+++ b/module/Core/src/Model/ShortUrlMeta.php
@@ -9,11 +9,16 @@ use DateTimeInterface;
 use Shlinkio\Shlink\Core\Exception\ValidationException;
 use Shlinkio\Shlink\Core\Validation\ShortUrlMetaInputFilter;

+use function array_key_exists;
+
 final class ShortUrlMeta
 {
+    private bool $validSincePropWasProvided = false;
    private ?Chronos $validSince = null;
+    private bool $validUntilPropWasProvided = false;
    private ?Chronos $validUntil = null;
    private ?string $customSlug = null;
+    private bool $maxVisitsPropWasProvided = false;
    private ?int $maxVisits = null;
    private ?bool $findIfExists = null;
    private ?string $domain = null;
@@ -32,44 +37,13 @@ final class ShortUrlMeta
     * @param array $data
     * @throws ValidationException
     */
-    public static function createFromRawData(array $data): self
+    public static function fromRawData(array $data): self
    {
        $instance = new self();
        $instance->validate($data);
        return $instance;
    }

-    /**
-     * @param string|Chronos|null $validSince
-     * @param string|Chronos|null $validUntil
-     * @param string|null $customSlug
-     * @param int|null $maxVisits
-     * @param bool|null $findIfExists
-     * @param string|null $domain
-     * @throws ValidationException
-     */
-    public static function createFromParams( // phpcs:ignore
-        $validSince = null,
-        $validUntil = null,
-        $customSlug = null,
-        $maxVisits = null,
-        $findIfExists = null,
-        $domain = null
-    ): self {
-        // We do not type hint the arguments because that will be done by the validation process and we would get a
-        // type error if any of them do not match
-        $instance = new self();
-        $instance->validate([
-            ShortUrlMetaInputFilter::VALID_SINCE => $validSince,
-            ShortUrlMetaInputFilter::VALID_UNTIL => $validUntil,
-            ShortUrlMetaInputFilter::CUSTOM_SLUG => $customSlug,
-            ShortUrlMetaInputFilter::MAX_VISITS => $maxVisits,
-            ShortUrlMetaInputFilter::FIND_IF_EXISTS => $findIfExists,
-            ShortUrlMetaInputFilter::DOMAIN => $domain,
-        ]);
-        return $instance;
-    }
-
    /**
     * @param array $data
     * @throws ValidationException
@@ -82,10 +56,13 @@ final class ShortUrlMeta
        }

        $this->validSince = $this->parseDateField($inputFilter->getValue(ShortUrlMetaInputFilter::VALID_SINCE));
+        $this->validSincePropWasProvided = array_key_exists(ShortUrlMetaInputFilter::VALID_SINCE, $data);
        $this->validUntil = $this->parseDateField($inputFilter->getValue(ShortUrlMetaInputFilter::VALID_UNTIL));
+        $this->validUntilPropWasProvided = array_key_exists(ShortUrlMetaInputFilter::VALID_UNTIL, $data);
        $this->customSlug = $inputFilter->getValue(ShortUrlMetaInputFilter::CUSTOM_SLUG);
        $maxVisits = $inputFilter->getValue(ShortUrlMetaInputFilter::MAX_VISITS);
        $this->maxVisits = $maxVisits !== null ? (int) $maxVisits : null;
+        $this->maxVisitsPropWasProvided = array_key_exists(ShortUrlMetaInputFilter::MAX_VISITS, $data);
        $this->findIfExists = $inputFilter->getValue(ShortUrlMetaInputFilter::FIND_IF_EXISTS);
        $this->domain = $inputFilter->getValue(ShortUrlMetaInputFilter::DOMAIN);
    }
@@ -113,7 +90,7 @@ final class ShortUrlMeta

    public function hasValidSince(): bool
    {
-        return $this->validSince !== null;
+        return $this->validSincePropWasProvided;
    }

    public function getValidUntil(): ?Chronos
@@ -123,7 +100,7 @@ final class ShortUrlMeta

    public function hasValidUntil(): bool
    {
-        return $this->validUntil !== null;
+        return $this->validUntilPropWasProvided;
    }

    public function getCustomSlug(): ?string
@@ -143,7 +120,7 @@ final class ShortUrlMeta

    public function hasMaxVisits(): bool
    {
-        return $this->maxVisits !== null;
+        return $this->maxVisitsPropWasProvided;
    }

    public function findIfExists(): bool
--- a/module/Core/src/Repository/ShortUrlRepository.php
+++ b/module/Core/src/Repository/ShortUrlRepository.php
@@ -4,7 +4,6 @@ declare(strict_types=1);

 namespace Shlinkio\Shlink\Core\Repository;

-use Cake\Chronos\Chronos;
 use Doctrine\ORM\EntityRepository;
 use Doctrine\ORM\QueryBuilder;
 use Shlinkio\Shlink\Common\Util\DateRange;
@@ -146,8 +145,6 @@ class ShortUrlRepository extends EntityRepository implements ShortUrlRepositoryI
              FROM Shlinkio\Shlink\Core\Entity\ShortUrl AS s
         LEFT JOIN s.domain AS d
             WHERE s.shortCode = :shortCode
-               AND (s.validSince <= :now OR s.validSince IS NULL)
-               AND (s.validUntil >= :now OR s.validUntil IS NULL)
               AND (s.domain IS NULL OR d.authority = :domain)
          ORDER BY s.domain {$ordering}
 DQL;
@@ -156,7 +153,6 @@ DQL;
        $query->setMaxResults(1)
              ->setParameters([
                  'shortCode' => $shortCode,
-                  'now' => Chronos::now(),
                  'domain' => $domain,
              ]);

@@ -166,9 +162,7 @@ DQL;
        //  * The short URL matching the short code but without any domain, or
        //  * No short URL at all

-        /** @var ShortUrl|null $shortUrl */
-        $shortUrl = $query->getOneOrNullResult();
-        return $shortUrl !== null && ! $shortUrl->maxVisitsReached() ? $shortUrl : null;
+        return $query->getOneOrNullResult();
    }

    public function shortCodeIsInUse(string $slug, ?string $domain = null): bool
--- a/module/Core/src/Service/ShortUrl/ShortUrlResolver.php
+++ b/module/Core/src/Service/ShortUrl/ShortUrlResolver.php
@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Shlinkio\Shlink\Core\Service\ShortUrl;
+
+use Doctrine\ORM\EntityManagerInterface;
+use Shlinkio\Shlink\Core\Entity\ShortUrl;
+use Shlinkio\Shlink\Core\Exception\ShortUrlNotFoundException;
+use Shlinkio\Shlink\Core\Repository\ShortUrlRepository;
+
+class ShortUrlResolver implements ShortUrlResolverInterface
+{
+    private EntityManagerInterface $em;
+
+    public function __construct(EntityManagerInterface $em)
+    {
+        $this->em = $em;
+    }
+
+    /**
+     * @throws ShortUrlNotFoundException
+     */
+    public function shortCodeToShortUrl(string $shortCode, ?string $domain = null): ShortUrl
+    {
+        /** @var ShortUrlRepository $shortUrlRepo */
+        $shortUrlRepo = $this->em->getRepository(ShortUrl::class);
+        $shortUrl = $shortUrlRepo->findOneByShortCode($shortCode, $domain);
+        if ($shortUrl === null) {
+            throw ShortUrlNotFoundException::fromNotFoundShortCode($shortCode, $domain);
+        }
+
+        return $shortUrl;
+    }
+
+    /**
+     * @throws ShortUrlNotFoundException
+     */
+    public function shortCodeToEnabledShortUrl(string $shortCode, ?string $domain = null): ShortUrl
+    {
+        $shortUrl = $this->shortCodeToShortUrl($shortCode, $domain);
+        if (! $shortUrl->isEnabled()) {
+            throw ShortUrlNotFoundException::fromNotFoundShortCode($shortCode, $domain);
+        }
+
+        return $shortUrl;
+    }
+}
--- a/module/Core/src/Service/ShortUrl/ShortUrlResolverInterface.php
+++ b/module/Core/src/Service/ShortUrl/ShortUrlResolverInterface.php
@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Shlinkio\Shlink\Core\Service\ShortUrl;
+
+use Shlinkio\Shlink\Core\Entity\ShortUrl;
+use Shlinkio\Shlink\Core\Exception\ShortUrlNotFoundException;
+
+interface ShortUrlResolverInterface
+{
+    /**
+     * @throws ShortUrlNotFoundException
+     */
+    public function shortCodeToShortUrl(string $shortCode, ?string $domain = null): ShortUrl;
+
+    /**
+     * @throws ShortUrlNotFoundException
+     */
+    public function shortCodeToEnabledShortUrl(string $shortCode, ?string $domain = null): ShortUrl;
+}
--- a/module/Core/src/Service/UrlShortener.php
+++ b/module/Core/src/Service/UrlShortener.php
@@ -10,7 +10,6 @@ use Shlinkio\Shlink\Core\Domain\Resolver\PersistenceDomainResolver;
 use Shlinkio\Shlink\Core\Entity\ShortUrl;
 use Shlinkio\Shlink\Core\Exception\InvalidUrlException;
 use Shlinkio\Shlink\Core\Exception\NonUniqueSlugException;
-use Shlinkio\Shlink\Core\Exception\ShortUrlNotFoundException;
 use Shlinkio\Shlink\Core\Model\ShortUrlMeta;
 use Shlinkio\Shlink\Core\Options\UrlShortenerOptions;
 use Shlinkio\Shlink\Core\Repository\ShortUrlRepository;
@@ -124,20 +123,4 @@ class UrlShortener implements UrlShortenerInterface
            $this->verifyShortCodeUniqueness($meta, $shortUrlToBeCreated);
        }
    }
-
-    /**
-     * @throws ShortUrlNotFoundException
-     * @fixme Move this method to a different service
-     */
-    public function shortCodeToUrl(string $shortCode, ?string $domain = null): ShortUrl
-    {
-        /** @var ShortUrlRepository $shortUrlRepo */
-        $shortUrlRepo = $this->em->getRepository(ShortUrl::class);
-        $shortUrl = $shortUrlRepo->findOneByShortCode($shortCode, $domain);
-        if ($shortUrl === null) {
-            throw ShortUrlNotFoundException::fromNotFoundShortCode($shortCode, $domain);
-        }
-
-        return $shortUrl;
-    }
 }
--- a/module/Core/src/Service/UrlShortenerInterface.php
+++ b/module/Core/src/Service/UrlShortenerInterface.php
@@ -8,7 +8,6 @@ use Psr\Http\Message\UriInterface;
 use Shlinkio\Shlink\Core\Entity\ShortUrl;
 use Shlinkio\Shlink\Core\Exception\InvalidUrlException;
 use Shlinkio\Shlink\Core\Exception\NonUniqueSlugException;
-use Shlinkio\Shlink\Core\Exception\ShortUrlNotFoundException;
 use Shlinkio\Shlink\Core\Model\ShortUrlMeta;

 interface UrlShortenerInterface
@@ -19,9 +18,4 @@ interface UrlShortenerInterface
     * @throws InvalidUrlException
     */
    public function urlToShortCode(UriInterface $url, array $tags, ShortUrlMeta $meta): ShortUrl;
-
-    /**
-     * @throws ShortUrlNotFoundException
-     */
-    public function shortCodeToUrl(string $shortCode, ?string $domain = null): ShortUrl;
 }
--- a/module/Core/test-db/Repository/ShortUrlRepositoryTest.php
+++ b/module/Core/test-db/Repository/ShortUrlRepositoryTest.php
@@ -38,41 +38,17 @@ class ShortUrlRepositoryTest extends DatabaseTestCase
    /** @test */
    public function findOneByShortCodeReturnsProperData(): void
    {
-        $regularOne = new ShortUrl('foo', ShortUrlMeta::createFromParams(null, null, 'foo'));
+        $regularOne = new ShortUrl('foo', ShortUrlMeta::fromRawData(['customSlug' => 'foo']));
        $this->getEntityManager()->persist($regularOne);

-        $notYetValid = new ShortUrl(
-            'bar',
-            ShortUrlMeta::createFromParams(Chronos::now()->addMonth(), null, 'bar_very_long_text'),
-        );
-        $this->getEntityManager()->persist($notYetValid);
-
-        $expired = new ShortUrl('expired', ShortUrlMeta::createFromParams(null, Chronos::now()->subMonth(), 'expired'));
-        $this->getEntityManager()->persist($expired);
-
-        $allVisitsComplete = new ShortUrl('baz', ShortUrlMeta::createFromRawData([
-            'maxVisits' => 3,
-            'customSlug' => 'baz',
-        ]));
-        $visits = [];
-        for ($i = 0; $i < 3; $i++) {
-            $visit = new Visit($allVisitsComplete, Visitor::emptyInstance());
-            $this->getEntityManager()->persist($visit);
-            $visits[] = $visit;
-        }
-        $allVisitsComplete->setVisits(new ArrayCollection($visits));
-        $this->getEntityManager()->persist($allVisitsComplete);
-
-        $withDomain = new ShortUrl('foo', ShortUrlMeta::createFromRawData([
-            'domain' => 'example.com',
-            'customSlug' => 'domain-short-code',
-        ]));
+        $withDomain = new ShortUrl('foo', ShortUrlMeta::fromRawData(
+            ['domain' => 'example.com', 'customSlug' => 'domain-short-code'],
+        ));
        $this->getEntityManager()->persist($withDomain);

-        $withDomainDuplicatingRegular = new ShortUrl('foo_with_domain', ShortUrlMeta::createFromRawData([
-            'domain' => 'doma.in',
-            'customSlug' => 'foo',
-        ]));
+        $withDomainDuplicatingRegular = new ShortUrl('foo_with_domain', ShortUrlMeta::fromRawData(
+            ['domain' => 'doma.in', 'customSlug' => 'foo'],
+        ));
        $this->getEntityManager()->persist($withDomainDuplicatingRegular);

        $this->getEntityManager()->flush();
@@ -91,9 +67,6 @@ class ShortUrlRepositoryTest extends DatabaseTestCase
        $this->assertNull($this->repo->findOneByShortCode('invalid'));
        $this->assertNull($this->repo->findOneByShortCode($withDomain->getShortCode()));
        $this->assertNull($this->repo->findOneByShortCode($withDomain->getShortCode(), 'other-domain.com'));
-        $this->assertNull($this->repo->findOneByShortCode($notYetValid->getShortCode()));
-        $this->assertNull($this->repo->findOneByShortCode($expired->getShortCode()));
-        $this->assertNull($this->repo->findOneByShortCode($allVisitsComplete->getShortCode()));
    }

    /** @test */
@@ -187,12 +160,12 @@ class ShortUrlRepositoryTest extends DatabaseTestCase
    /** @test */
    public function shortCodeIsInUseLooksForShortUrlInProperSetOfTables(): void
    {
-        $shortUrlWithoutDomain = new ShortUrl('foo', ShortUrlMeta::createFromRawData(['customSlug' => 'my-cool-slug']));
+        $shortUrlWithoutDomain = new ShortUrl('foo', ShortUrlMeta::fromRawData(['customSlug' => 'my-cool-slug']));
        $this->getEntityManager()->persist($shortUrlWithoutDomain);

        $shortUrlWithDomain = new ShortUrl(
            'foo',
-            ShortUrlMeta::createFromRawData(['domain' => 'doma.in', 'customSlug' => 'another-slug']),
+            ShortUrlMeta::fromRawData(['domain' => 'doma.in', 'customSlug' => 'another-slug']),
        );
        $this->getEntityManager()->persist($shortUrlWithDomain);

--- a/module/Core/test/Action/PixelActionTest.php
+++ b/module/Core/test/Action/PixelActionTest.php
@@ -13,22 +13,22 @@ use Shlinkio\Shlink\Common\Response\PixelResponse;
 use Shlinkio\Shlink\Core\Action\PixelAction;
 use Shlinkio\Shlink\Core\Entity\ShortUrl;
 use Shlinkio\Shlink\Core\Options\AppOptions;
-use Shlinkio\Shlink\Core\Service\UrlShortener;
+use Shlinkio\Shlink\Core\Service\ShortUrl\ShortUrlResolverInterface;
 use Shlinkio\Shlink\Core\Service\VisitsTracker;

 class PixelActionTest extends TestCase
 {
    private PixelAction $action;
-    private ObjectProphecy $urlShortener;
+    private ObjectProphecy $urlResolver;
    private ObjectProphecy $visitTracker;

    public function setUp(): void
    {
-        $this->urlShortener = $this->prophesize(UrlShortener::class);
+        $this->urlResolver = $this->prophesize(ShortUrlResolverInterface::class);
        $this->visitTracker = $this->prophesize(VisitsTracker::class);

        $this->action = new PixelAction(
-            $this->urlShortener->reveal(),
+            $this->urlResolver->reveal(),
            $this->visitTracker->reveal(),
            new AppOptions(),
        );
@@ -38,7 +38,7 @@ class PixelActionTest extends TestCase
    public function imageIsReturned(): void
    {
        $shortCode = 'abc123';
-        $this->urlShortener->shortCodeToUrl($shortCode, '')->willReturn(
+        $this->urlResolver->shortCodeToEnabledShortUrl($shortCode, '')->willReturn(
            new ShortUrl('http://domain.com/foo/bar'),
        )->shouldBeCalledOnce();
        $this->visitTracker->track(Argument::cetera())->shouldBeCalledOnce();
--- a/module/Core/test/Action/QrCodeActionTest.php
+++ b/module/Core/test/Action/QrCodeActionTest.php
@@ -15,29 +15,29 @@ use Shlinkio\Shlink\Common\Response\QrCodeResponse;
 use Shlinkio\Shlink\Core\Action\QrCodeAction;
 use Shlinkio\Shlink\Core\Entity\ShortUrl;
 use Shlinkio\Shlink\Core\Exception\ShortUrlNotFoundException;
-use Shlinkio\Shlink\Core\Service\UrlShortener;
+use Shlinkio\Shlink\Core\Service\ShortUrl\ShortUrlResolverInterface;

 class QrCodeActionTest extends TestCase
 {
    private QrCodeAction $action;
-    private ObjectProphecy $urlShortener;
+    private ObjectProphecy $urlResolver;

    public function setUp(): void
    {
        $router = $this->prophesize(RouterInterface::class);
        $router->generateUri(Argument::cetera())->willReturn('/foo/bar');

-        $this->urlShortener = $this->prophesize(UrlShortener::class);
+        $this->urlResolver = $this->prophesize(ShortUrlResolverInterface::class);

-        $this->action = new QrCodeAction($router->reveal(), $this->urlShortener->reveal());
+        $this->action = new QrCodeAction($router->reveal(), $this->urlResolver->reveal());
    }

    /** @test */
    public function aNotFoundShortCodeWillDelegateIntoNextMiddleware(): void
    {
        $shortCode = 'abc123';
-        $this->urlShortener->shortCodeToUrl($shortCode, '')->willThrow(ShortUrlNotFoundException::class)
-                                                           ->shouldBeCalledOnce();
+        $this->urlResolver->shortCodeToEnabledShortUrl($shortCode, '')->willThrow(ShortUrlNotFoundException::class)
+                                                                      ->shouldBeCalledOnce();
        $delegate = $this->prophesize(RequestHandlerInterface::class);
        $process = $delegate->handle(Argument::any())->willReturn(new Response());

@@ -50,8 +50,8 @@ class QrCodeActionTest extends TestCase
    public function anInvalidShortCodeWillReturnNotFoundResponse(): void
    {
        $shortCode = 'abc123';
-        $this->urlShortener->shortCodeToUrl($shortCode, '')->willThrow(ShortUrlNotFoundException::class)
-                                                           ->shouldBeCalledOnce();
+        $this->urlResolver->shortCodeToEnabledShortUrl($shortCode, '')->willThrow(ShortUrlNotFoundException::class)
+                                                                      ->shouldBeCalledOnce();
        $delegate = $this->prophesize(RequestHandlerInterface::class);
        $process = $delegate->handle(Argument::any())->willReturn(new Response());

@@ -64,8 +64,8 @@ class QrCodeActionTest extends TestCase
    public function aCorrectRequestReturnsTheQrCodeResponse(): void
    {
        $shortCode = 'abc123';
-        $this->urlShortener->shortCodeToUrl($shortCode, '')->willReturn(new ShortUrl(''))
-                                                           ->shouldBeCalledOnce();
+        $this->urlResolver->shortCodeToEnabledShortUrl($shortCode, '')->willReturn(new ShortUrl(''))
+                                                                      ->shouldBeCalledOnce();
        $delegate = $this->prophesize(RequestHandlerInterface::class);

        $resp = $this->action->process(
--- a/module/Core/test/Action/RedirectActionTest.php
+++ b/module/Core/test/Action/RedirectActionTest.php
@@ -14,24 +14,24 @@ use Shlinkio\Shlink\Core\Action\RedirectAction;
 use Shlinkio\Shlink\Core\Entity\ShortUrl;
 use Shlinkio\Shlink\Core\Exception\ShortUrlNotFoundException;
 use Shlinkio\Shlink\Core\Options;
-use Shlinkio\Shlink\Core\Service\UrlShortener;
-use Shlinkio\Shlink\Core\Service\VisitsTracker;
+use Shlinkio\Shlink\Core\Service\ShortUrl\ShortUrlResolverInterface;
+use Shlinkio\Shlink\Core\Service\VisitsTrackerInterface;

 use function array_key_exists;

 class RedirectActionTest extends TestCase
 {
    private RedirectAction $action;
-    private ObjectProphecy $urlShortener;
+    private ObjectProphecy $urlResolver;
    private ObjectProphecy $visitTracker;

    public function setUp(): void
    {
-        $this->urlShortener = $this->prophesize(UrlShortener::class);
-        $this->visitTracker = $this->prophesize(VisitsTracker::class);
+        $this->urlResolver = $this->prophesize(ShortUrlResolverInterface::class);
+        $this->visitTracker = $this->prophesize(VisitsTrackerInterface::class);

        $this->action = new RedirectAction(
-            $this->urlShortener->reveal(),
+            $this->urlResolver->reveal(),
            $this->visitTracker->reveal(),
            new Options\AppOptions(['disableTrackParam' => 'foobar']),
        );
@@ -45,7 +45,7 @@ class RedirectActionTest extends TestCase
    {
        $shortCode = 'abc123';
        $shortUrl = new ShortUrl('http://domain.com/foo/bar?some=thing');
-        $shortCodeToUrl = $this->urlShortener->shortCodeToUrl($shortCode, '')->willReturn($shortUrl);
+        $shortCodeToUrl = $this->urlResolver->shortCodeToEnabledShortUrl($shortCode, '')->willReturn($shortUrl);
        $track = $this->visitTracker->track(Argument::cetera())->will(function (): void {
        });

@@ -64,6 +64,7 @@ class RedirectActionTest extends TestCase
    {
        yield ['http://domain.com/foo/bar?some=thing', []];
        yield ['http://domain.com/foo/bar?some=thing', ['foobar' => 'notrack']];
+        yield ['http://domain.com/foo/bar?some=thing&else', ['else' => null]];
        yield ['http://domain.com/foo/bar?some=thing&foo=bar', ['foo' => 'bar']];
        yield ['http://domain.com/foo/bar?some=overwritten&foo=bar', ['foo' => 'bar', 'some' => 'overwritten']];
        yield ['http://domain.com/foo/bar?some=overwritten', ['foobar' => 'notrack', 'some' => 'overwritten']];
@@ -73,8 +74,8 @@ class RedirectActionTest extends TestCase
    public function nextMiddlewareIsInvokedIfLongUrlIsNotFound(): void
    {
        $shortCode = 'abc123';
-        $this->urlShortener->shortCodeToUrl($shortCode, '')->willThrow(ShortUrlNotFoundException::class)
-                                                           ->shouldBeCalledOnce();
+        $this->urlResolver->shortCodeToEnabledShortUrl($shortCode, '')->willThrow(ShortUrlNotFoundException::class)
+                                                                      ->shouldBeCalledOnce();
        $this->visitTracker->track(Argument::cetera())->shouldNotBeCalled();

        $handler = $this->prophesize(RequestHandlerInterface::class);
--- a/module/Core/test/Entity/ShortUrlTest.php
+++ b/module/Core/test/Entity/ShortUrlTest.php
@@ -28,7 +28,7 @@ class ShortUrlTest extends TestCase
    public function provideInvalidShortUrls(): iterable
    {
        yield 'with custom slug' => [
-            new ShortUrl('', ShortUrlMeta::createFromRawData(['customSlug' => 'custom-slug'])),
+            new ShortUrl('', ShortUrlMeta::fromRawData(['customSlug' => 'custom-slug'])),
            'The short code cannot be regenerated on ShortUrls where a custom slug was provided.',
        ];
        yield 'already persisted' => [
--- a/module/Core/test/Model/ShortUrlMetaTest.php
+++ b/module/Core/test/Model/ShortUrlMetaTest.php
@@ -21,7 +21,7 @@ class ShortUrlMetaTest extends TestCase
    public function exceptionIsThrownIfProvidedDataIsInvalid(array $data): void
    {
        $this->expectException(ValidationException::class);
-        ShortUrlMeta::createFromRawData($data);
+        ShortUrlMeta::fromRawData($data);
    }

    public function provideInvalidData(): iterable
@@ -49,7 +49,9 @@ class ShortUrlMetaTest extends TestCase
    /** @test */
    public function properlyCreatedInstanceReturnsValues(): void
    {
-        $meta = ShortUrlMeta::createFromParams(Chronos::parse('2015-01-01')->toAtomString(), null, 'foobar');
+        $meta = ShortUrlMeta::fromRawData(
+            ['validSince' => Chronos::parse('2015-01-01')->toAtomString(), 'customSlug' => 'foobar'],
+        );

        $this->assertTrue($meta->hasValidSince());
        $this->assertEquals(Chronos::parse('2015-01-01'), $meta->getValidSince());
--- a/module/Core/test/Service/ShortUrl/ShortUrlResolverTest.php
+++ b/module/Core/test/Service/ShortUrl/ShortUrlResolverTest.php
@@ -0,0 +1,135 @@
+<?php
+
+declare(strict_types=1);
+
+namespace ShlinkioTest\Shlink\Core\Service\ShortUrl;
+
+use Cake\Chronos\Chronos;
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\ORM\EntityManagerInterface;
+use PHPUnit\Framework\TestCase;
+use Prophecy\Prophecy\ObjectProphecy;
+use Shlinkio\Shlink\Core\Entity\ShortUrl;
+use Shlinkio\Shlink\Core\Entity\Visit;
+use Shlinkio\Shlink\Core\Exception\ShortUrlNotFoundException;
+use Shlinkio\Shlink\Core\Model\ShortUrlMeta;
+use Shlinkio\Shlink\Core\Model\Visitor;
+use Shlinkio\Shlink\Core\Repository\ShortUrlRepositoryInterface;
+use Shlinkio\Shlink\Core\Service\ShortUrl\ShortUrlResolver;
+
+use function Functional\map;
+use function range;
+
+class ShortUrlResolverTest extends TestCase
+{
+    private ShortUrlResolver $urlResolver;
+    private ObjectProphecy $em;
+
+    public function setUp(): void
+    {
+        $this->em = $this->prophesize(EntityManagerInterface::class);
+        $this->urlResolver = new ShortUrlResolver($this->em->reveal());
+    }
+
+    /** @test */
+    public function shortCodeIsProperlyParsed(): void
+    {
+        $shortUrl = new ShortUrl('expected_url');
+        $shortCode = $shortUrl->getShortCode();
+
+        $repo = $this->prophesize(ShortUrlRepositoryInterface::class);
+        $findOneByShortCode = $repo->findOneByShortCode($shortCode, null)->willReturn($shortUrl);
+        $getRepo = $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());
+
+        $result = $this->urlResolver->shortCodeToShortUrl($shortCode);
+
+        $this->assertSame($shortUrl, $result);
+        $findOneByShortCode->shouldHaveBeenCalledOnce();
+        $getRepo->shouldHaveBeenCalledOnce();
+    }
+
+    /** @test */
+    public function exceptionIsThrownIfShortcodeIsNotFound(): void
+    {
+        $shortCode = 'abc123';
+
+        $repo = $this->prophesize(ShortUrlRepositoryInterface::class);
+        $findOneByShortCode = $repo->findOneByShortCode($shortCode, null)->willReturn(null);
+        $getRepo = $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());
+
+        $this->expectException(ShortUrlNotFoundException::class);
+        $findOneByShortCode->shouldBeCalledOnce();
+        $getRepo->shouldBeCalledOnce();
+
+        $this->urlResolver->shortCodeToShortUrl($shortCode);
+    }
+
+    /** @test */
+    public function shortCodeToEnabledShortUrlProperlyParsesShortCode(): void
+    {
+        $shortUrl = new ShortUrl('expected_url');
+        $shortCode = $shortUrl->getShortCode();
+
+        $repo = $this->prophesize(ShortUrlRepositoryInterface::class);
+        $findOneByShortCode = $repo->findOneByShortCode($shortCode, null)->willReturn($shortUrl);
+        $getRepo = $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());
+
+        $result = $this->urlResolver->shortCodeToEnabledShortUrl($shortCode);
+
+        $this->assertSame($shortUrl, $result);
+        $findOneByShortCode->shouldHaveBeenCalledOnce();
+        $getRepo->shouldHaveBeenCalledOnce();
+    }
+
+    /**
+     * @test
+     * @dataProvider provideDisabledShortUrls
+     */
+    public function shortCodeToEnabledShortUrlThrowsExceptionIfUrlIsNotEnabled(ShortUrl $shortUrl): void
+    {
+        $shortCode = $shortUrl->getShortCode();
+
+        $repo = $this->prophesize(ShortUrlRepositoryInterface::class);
+        $findOneByShortCode = $repo->findOneByShortCode($shortCode, null)->willReturn($shortUrl);
+        $getRepo = $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());
+
+        $this->expectException(ShortUrlNotFoundException::class);
+        $findOneByShortCode->shouldBeCalledOnce();
+        $getRepo->shouldBeCalledOnce();
+
+        $this->urlResolver->shortCodeToEnabledShortUrl($shortCode);
+    }
+
+    public function provideDisabledShortUrls(): iterable
+    {
+        $now = Chronos::now();
+
+        yield 'maxVisits reached' => [(function () {
+            $shortUrl = new ShortUrl('', ShortUrlMeta::fromRawData(['maxVisits' => 3]));
+            $shortUrl->setVisits(new ArrayCollection(map(
+                range(0, 4),
+                fn () => new Visit($shortUrl, Visitor::emptyInstance()),
+            )));
+
+            return $shortUrl;
+        })()];
+        yield 'future validSince' => [new ShortUrl('', ShortUrlMeta::fromRawData([
+            'validSince' => $now->addMonth()->toAtomString(),
+        ]))];
+        yield 'past validUntil' => [new ShortUrl('', ShortUrlMeta::fromRawData([
+            'validUntil' => $now->subMonth()->toAtomString(),
+        ]))];
+        yield 'mixed' => [(function () use ($now) {
+            $shortUrl = new ShortUrl('', ShortUrlMeta::fromRawData([
+                'maxVisits' => 3,
+                'validUntil' => $now->subMonth()->toAtomString(),
+            ]));
+            $shortUrl->setVisits(new ArrayCollection(map(
+                range(0, 4),
+                fn () => new Visit($shortUrl, Visitor::emptyInstance()),
+            )));
+
+            return $shortUrl;
+        })()];
+    }
+}
--- a/module/Core/test/Service/ShortUrlServiceTest.php
+++ b/module/Core/test/Service/ShortUrlServiceTest.php
@@ -93,12 +93,11 @@ class ShortUrlServiceTest extends TestCase
        $getRepo = $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());
        $flush = $this->em->flush()->willReturn(null);

-        $result = $this->service->updateMetadataByShortCode('abc123', ShortUrlMeta::createFromParams(
-            Chronos::parse('2017-01-01 00:00:00')->toAtomString(),
-            Chronos::parse('2017-01-05 00:00:00')->toAtomString(),
-            null,
-            5,
-        ));
+        $result = $this->service->updateMetadataByShortCode('abc123', ShortUrlMeta::fromRawData([
+            'validSince' => Chronos::parse('2017-01-01 00:00:00')->toAtomString(),
+            'validUntil' => Chronos::parse('2017-01-05 00:00:00')->toAtomString(),
+            'maxVisits' => 5,
+        ]));

        $this->assertSame($shortUrl, $result);
        $this->assertEquals(Chronos::parse('2017-01-01 00:00:00'), $shortUrl->getValidSince());
--- a/module/Core/test/Service/UrlShortenerTest.php
+++ b/module/Core/test/Service/UrlShortenerTest.php
@@ -19,7 +19,6 @@ use Shlinkio\Shlink\Core\Exception\NonUniqueSlugException;
 use Shlinkio\Shlink\Core\Model\ShortUrlMeta;
 use Shlinkio\Shlink\Core\Options\UrlShortenerOptions;
 use Shlinkio\Shlink\Core\Repository\ShortUrlRepository;
-use Shlinkio\Shlink\Core\Repository\ShortUrlRepositoryInterface;
 use Shlinkio\Shlink\Core\Service\UrlShortener;
 use Shlinkio\Shlink\Core\Util\UrlValidatorInterface;

@@ -153,7 +152,7 @@ class UrlShortenerTest extends TestCase
        $this->urlShortener->urlToShortCode(
            new Uri('http://foobar.com/12345/hello?foo=bar'),
            [],
-            ShortUrlMeta::createFromRawData(['customSlug' => 'custom-slug']),
+            ShortUrlMeta::fromRawData(['customSlug' => 'custom-slug']),
        );
    }

@@ -183,49 +182,49 @@ class UrlShortenerTest extends TestCase
    {
        $url = 'http://foo.com';

-        yield [$url, [], ShortUrlMeta::createFromRawData(['findIfExists' => true]), new ShortUrl($url)];
-        yield [$url, [], ShortUrlMeta::createFromRawData(
+        yield [$url, [], ShortUrlMeta::fromRawData(['findIfExists' => true]), new ShortUrl($url)];
+        yield [$url, [], ShortUrlMeta::fromRawData(
            ['findIfExists' => true, 'customSlug' => 'foo'],
        ), new ShortUrl($url)];
        yield [
            $url,
            ['foo', 'bar'],
-            ShortUrlMeta::createFromRawData(['findIfExists' => true]),
+            ShortUrlMeta::fromRawData(['findIfExists' => true]),
            (new ShortUrl($url))->setTags(new ArrayCollection([new Tag('bar'), new Tag('foo')])),
        ];
        yield [
            $url,
            [],
-            ShortUrlMeta::createFromRawData(['findIfExists' => true, 'maxVisits' => 3]),
-            new ShortUrl($url, ShortUrlMeta::createFromRawData(['maxVisits' => 3])),
+            ShortUrlMeta::fromRawData(['findIfExists' => true, 'maxVisits' => 3]),
+            new ShortUrl($url, ShortUrlMeta::fromRawData(['maxVisits' => 3])),
        ];
        yield [
            $url,
            [],
-            ShortUrlMeta::createFromRawData(['findIfExists' => true, 'validSince' => Chronos::parse('2017-01-01')]),
-            new ShortUrl($url, ShortUrlMeta::createFromRawData(['validSince' => Chronos::parse('2017-01-01')])),
+            ShortUrlMeta::fromRawData(['findIfExists' => true, 'validSince' => Chronos::parse('2017-01-01')]),
+            new ShortUrl($url, ShortUrlMeta::fromRawData(['validSince' => Chronos::parse('2017-01-01')])),
        ];
        yield [
            $url,
            [],
-            ShortUrlMeta::createFromRawData(['findIfExists' => true, 'validUntil' => Chronos::parse('2017-01-01')]),
-            new ShortUrl($url, ShortUrlMeta::createFromRawData(['validUntil' => Chronos::parse('2017-01-01')])),
+            ShortUrlMeta::fromRawData(['findIfExists' => true, 'validUntil' => Chronos::parse('2017-01-01')]),
+            new ShortUrl($url, ShortUrlMeta::fromRawData(['validUntil' => Chronos::parse('2017-01-01')])),
        ];
        yield [
            $url,
            [],
-            ShortUrlMeta::createFromRawData(['findIfExists' => true, 'domain' => 'example.com']),
-            new ShortUrl($url, ShortUrlMeta::createFromRawData(['domain' => 'example.com'])),
+            ShortUrlMeta::fromRawData(['findIfExists' => true, 'domain' => 'example.com']),
+            new ShortUrl($url, ShortUrlMeta::fromRawData(['domain' => 'example.com'])),
        ];
        yield [
            $url,
            ['baz', 'foo', 'bar'],
-            ShortUrlMeta::createFromRawData([
+            ShortUrlMeta::fromRawData([
                'findIfExists' => true,
                'validUntil' => Chronos::parse('2017-01-01'),
                'maxVisits' => 4,
            ]),
-            (new ShortUrl($url, ShortUrlMeta::createFromRawData([
+            (new ShortUrl($url, ShortUrlMeta::fromRawData([
                'validUntil' => Chronos::parse('2017-01-01'),
                'maxVisits' => 4,
            ])))->setTags(new ArrayCollection([new Tag('foo'), new Tag('bar'), new Tag('baz')])),
@@ -237,7 +236,7 @@ class UrlShortenerTest extends TestCase
    {
        $url = 'http://foo.com';
        $tags = ['baz', 'foo', 'bar'];
-        $meta = ShortUrlMeta::createFromRawData([
+        $meta = ShortUrlMeta::fromRawData([
            'findIfExists' => true,
            'validUntil' => Chronos::parse('2017-01-01'),
            'maxVisits' => 4,
@@ -260,18 +259,4 @@ class UrlShortenerTest extends TestCase
        $findExisting->shouldHaveBeenCalledOnce();
        $getRepo->shouldHaveBeenCalledOnce();
    }
-
-    /** @test */
-    public function shortCodeIsProperlyParsed(): void
-    {
-        $shortUrl = new ShortUrl('expected_url');
-        $shortCode = $shortUrl->getShortCode();
-
-        $repo = $this->prophesize(ShortUrlRepositoryInterface::class);
-        $repo->findOneByShortCode($shortCode, null)->willReturn($shortUrl);
-        $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());
-
-        $url = $this->urlShortener->shortCodeToUrl($shortCode);
-        $this->assertSame($shortUrl, $url);
-    }
 }
--- a/module/Core/test/Transformer/ShortUrlDataTransformerTest.php
+++ b/module/Core/test/Transformer/ShortUrlDataTransformerTest.php
@@ -42,13 +42,13 @@ class ShortUrlDataTransformerTest extends TestCase
            'validUntil' => null,
            'maxVisits' => null,
        ]];
-        yield 'max visits only' => [new ShortUrl('', ShortUrlMeta::createFromParams(null, null, null, $maxVisits)), [
+        yield 'max visits only' => [new ShortUrl('', ShortUrlMeta::fromRawData(['maxVisits' => $maxVisits])), [
            'validSince' => null,
            'validUntil' => null,
            'maxVisits' => $maxVisits,
        ]];
        yield 'max visits and valid since' => [
-            new ShortUrl('', ShortUrlMeta::createFromParams($now, null, null, $maxVisits)),
+            new ShortUrl('', ShortUrlMeta::fromRawData(['validSince' => $now, 'maxVisits' => $maxVisits])),
            [
                'validSince' => $now->toAtomString(),
                'validUntil' => null,
@@ -56,7 +56,9 @@ class ShortUrlDataTransformerTest extends TestCase
            ],
        ];
        yield 'both dates' => [
-            new ShortUrl('', ShortUrlMeta::createFromParams($now, $now->subDays(10))),
+            new ShortUrl('', ShortUrlMeta::fromRawData(
+                ['validSince' => $now, 'validUntil' => $now->subDays(10)],
+            )),
            [
                'validSince' => $now->toAtomString(),
                'validUntil' => $now->subDays(10)->toAtomString(),
@@ -64,7 +66,9 @@ class ShortUrlDataTransformerTest extends TestCase
            ],
        ];
        yield 'everything' => [
-            new ShortUrl('', ShortUrlMeta::createFromParams($now, $now->subDays(5), null, $maxVisits)),
+            new ShortUrl('', ShortUrlMeta::fromRawData(
+                ['validSince' => $now, 'validUntil' => $now->subDays(5), 'maxVisits' => $maxVisits],
+            )),
            [
                'validSince' => $now->toAtomString(),
                'validUntil' => $now->subDays(5)->toAtomString(),
--- a/module/Rest/config/dependencies.config.php
+++ b/module/Rest/config/dependencies.config.php
@@ -57,7 +57,10 @@ return [
        ],
        Action\ShortUrl\EditShortUrlAction::class => [Service\ShortUrlService::class, 'Logger_Shlink'],
        Action\ShortUrl\DeleteShortUrlAction::class => [Service\ShortUrl\DeleteShortUrlService::class, 'Logger_Shlink'],
-        Action\ShortUrl\ResolveShortUrlAction::class => [Service\UrlShortener::class, 'config.url_shortener.domain'],
+        Action\ShortUrl\ResolveShortUrlAction::class => [
+            Service\ShortUrl\ShortUrlResolver::class,
+            'config.url_shortener.domain',
+        ],
        Action\Visit\GetVisitsAction::class => [Service\VisitsTracker::class, 'Logger_Shlink'],
        Action\ShortUrl\ListShortUrlsAction::class => [
            Service\ShortUrlService::class,
--- a/module/Rest/src/Action/ShortUrl/CreateShortUrlAction.php
+++ b/module/Rest/src/Action/ShortUrl/CreateShortUrlAction.php
@@ -27,15 +27,7 @@ class CreateShortUrlAction extends AbstractCreateShortUrlAction
            ]);
        }

-        $meta = ShortUrlMeta::createFromParams(
-            $postData['validSince'] ?? null,
-            $postData['validUntil'] ?? null,
-            $postData['customSlug'] ?? null,
-            $postData['maxVisits'] ?? null,
-            $postData['findIfExists'] ?? null,
-            $postData['domain'] ?? null,
-        );
-
+        $meta = ShortUrlMeta::fromRawData($postData);
        return new CreateShortUrlData(new Uri($postData['longUrl']), (array) ($postData['tags'] ?? []), $meta);
    }
 }
--- a/module/Rest/src/Action/ShortUrl/EditShortUrlAction.php
+++ b/module/Rest/src/Action/ShortUrl/EditShortUrlAction.php
@@ -30,7 +30,7 @@ class EditShortUrlAction extends AbstractRestAction
        $postData = (array) $request->getParsedBody();
        $shortCode = $request->getAttribute('shortCode', '');

-        $this->shortUrlService->updateMetadataByShortCode($shortCode, ShortUrlMeta::createFromRawData($postData));
+        $this->shortUrlService->updateMetadataByShortCode($shortCode, ShortUrlMeta::fromRawData($postData));
        return new EmptyResponse();
    }
 }
--- a/module/Rest/src/Action/ShortUrl/ResolveShortUrlAction.php
+++ b/module/Rest/src/Action/ShortUrl/ResolveShortUrlAction.php
@@ -4,12 +4,11 @@ declare(strict_types=1);

 namespace Shlinkio\Shlink\Rest\Action\ShortUrl;

-use InvalidArgumentException;
 use Laminas\Diactoros\Response\JsonResponse;
 use Psr\Http\Message\ResponseInterface as Response;
 use Psr\Http\Message\ServerRequestInterface as Request;
 use Psr\Log\LoggerInterface;
-use Shlinkio\Shlink\Core\Service\UrlShortenerInterface;
+use Shlinkio\Shlink\Core\Service\ShortUrl\ShortUrlResolverInterface;
 use Shlinkio\Shlink\Core\Transformer\ShortUrlDataTransformer;
 use Shlinkio\Shlink\Rest\Action\AbstractRestAction;

@@ -18,29 +17,26 @@ class ResolveShortUrlAction extends AbstractRestAction
    protected const ROUTE_PATH = '/short-urls/{shortCode}';
    protected const ROUTE_ALLOWED_METHODS = [self::METHOD_GET];

-    private UrlShortenerInterface $urlShortener;
+    private ShortUrlResolverInterface $urlResolver;
    private array $domainConfig;

    public function __construct(
-        UrlShortenerInterface $urlShortener,
+        ShortUrlResolverInterface $urlResolver,
        array $domainConfig,
        ?LoggerInterface $logger = null
    ) {
        parent::__construct($logger);
-        $this->urlShortener = $urlShortener;
+        $this->urlResolver = $urlResolver;
        $this->domainConfig = $domainConfig;
    }

-    /**
-     * @throws InvalidArgumentException
-     */
    public function handle(Request $request): Response
    {
        $shortCode = $request->getAttribute('shortCode');
        $domain = $request->getQueryParams()['domain'] ?? null;
        $transformer = new ShortUrlDataTransformer($this->domainConfig);

-        $url = $this->urlShortener->shortCodeToUrl($shortCode, $domain);
+        $url = $this->urlResolver->shortCodeToShortUrl($shortCode, $domain);
        return new JsonResponse($transformer->transform($url));
    }
 }
--- a/module/Rest/src/Middleware/CrossDomainMiddleware.php
+++ b/module/Rest/src/Middleware/CrossDomainMiddleware.php
@@ -5,6 +5,7 @@ declare(strict_types=1);
 namespace Shlinkio\Shlink\Rest\Middleware;

 use Fig\Http\Message\RequestMethodInterface;
+use Laminas\Diactoros\Response\EmptyResponse;
 use Mezzio\Router\RouteResult;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
@@ -12,6 +13,7 @@ use Psr\Http\Server\MiddlewareInterface;
 use Psr\Http\Server\RequestHandlerInterface;
 use Shlinkio\Shlink\Rest\Authentication;

+use function array_merge;
 use function implode;

 class CrossDomainMiddleware implements MiddlewareInterface, RequestMethodInterface
@@ -53,10 +55,7 @@ class CrossDomainMiddleware implements MiddlewareInterface, RequestMethodInterfa
            'Access-Control-Allow-Headers' => $request->getHeaderLine('Access-Control-Request-Headers'),
        ];

-        foreach ($corsHeaders as $key => $value) {
-            $response = $response->withHeader($key, $value);
-        }
-
-        return $response;
+        // Options requests should always be empty and have a 204 status code
+        return EmptyResponse::withHeaders(array_merge($response->getHeaders(), $corsHeaders));
    }
 }
--- a/module/Rest/test-api/Action/EditShortUrlActionTest.php
+++ b/module/Rest/test-api/Action/EditShortUrlActionTest.php
@@ -4,11 +4,71 @@ declare(strict_types=1);

 namespace ShlinkioApiTest\Shlink\Rest\Action;

+use Cake\Chronos\Chronos;
+use DMS\PHPUnitExtensions\ArraySubset\ArraySubsetAsserts;
 use GuzzleHttp\RequestOptions;
 use Shlinkio\Shlink\TestUtils\ApiTest\ApiTestCase;

+use function Functional\first;
+use function sprintf;
+
 class EditShortUrlActionTest extends ApiTestCase
 {
+    use ArraySubsetAsserts;
+
+    /**
+     * @test
+     * @dataProvider provideMeta
+     */
+    public function metadataCanBeReset(array $meta): void
+    {
+        $shortCode = 'abc123';
+        $url = sprintf('/short-urls/%s', $shortCode);
+        $resetMeta = [
+            'validSince' => null,
+            'validUntil' => null,
+            'maxVisits' => null,
+        ];
+
+        $editWithProvidedMeta = $this->callApiWithKey(self::METHOD_PATCH, $url, [RequestOptions::JSON => $meta]);
+        $metaAfterEditing = $this->findShortUrlMetaByShortCode($shortCode);
+
+        $editWithResetMeta = $this->callApiWithKey(self::METHOD_PATCH, $url, [
+            RequestOptions::JSON => $resetMeta,
+        ]);
+        $metaAfterResetting = $this->findShortUrlMetaByShortCode($shortCode);
+
+        $this->assertEquals(self::STATUS_NO_CONTENT, $editWithProvidedMeta->getStatusCode());
+        $this->assertEquals(self::STATUS_NO_CONTENT, $editWithResetMeta->getStatusCode());
+        $this->assertEquals($resetMeta, $metaAfterResetting);
+        self::assertArraySubset($meta, $metaAfterEditing);
+    }
+
+    public function provideMeta(): iterable
+    {
+        $now = Chronos::now();
+
+        yield [['validSince' => $now->addMonth()->toAtomString()]];
+        yield [['validUntil' => $now->subMonth()->toAtomString()]];
+        yield [['maxVisits' => 20]];
+        yield [['validUntil' => $now->addYear()->toAtomString(), 'maxVisits' => 100]];
+        yield [[
+            'validSince' => $now->subYear()->toAtomString(),
+            'validUntil' => $now->addYear()->toAtomString(),
+            'maxVisits' => 100,
+        ]];
+    }
+
+    private function findShortUrlMetaByShortCode(string $shortCode): ?array
+    {
+        // FIXME Call GET /short-urls/{shortCode} once issue https://github.com/shlinkio/shlink/issues/628 is fixed
+        $allShortUrls = $this->getJsonResponsePayload($this->callApiWithKey(self::METHOD_GET, '/short-urls'));
+        $list = $allShortUrls['shortUrls']['data'] ?? [];
+        $matchingShortUrl = first($list, fn (array $shortUrl) => $shortUrl['shortCode'] ?? '' === $shortCode);
+
+        return $matchingShortUrl['meta'] ?? null;
+    }
+
    /** @test */
    public function tryingToEditInvalidUrlReturnsNotFoundError(): void
    {
--- a/module/Rest/test-api/Action/ResolveShortUrlActionTest.php
+++ b/module/Rest/test-api/Action/ResolveShortUrlActionTest.php
@@ -4,10 +4,42 @@ declare(strict_types=1);

 namespace ShlinkioApiTest\Shlink\Rest\Action;

+use Cake\Chronos\Chronos;
+use GuzzleHttp\RequestOptions;
 use Shlinkio\Shlink\TestUtils\ApiTest\ApiTestCase;

+use function sprintf;
+
 class ResolveShortUrlActionTest extends ApiTestCase
 {
+    /**
+     * @test
+     * @dataProvider provideDisabledMeta
+     */
+    public function shortUrlIsProperlyResolvedEvenWhenNotEnabled(array $disabledMeta): void
+    {
+        $shortCode = 'abc123';
+        $url = sprintf('/short-urls/%s', $shortCode);
+        $this->callShortUrl($shortCode);
+
+        $editResp = $this->callApiWithKey(self::METHOD_PATCH, $url, [RequestOptions::JSON => $disabledMeta]);
+        $visitResp = $this->callShortUrl($shortCode);
+        $fetchResp = $this->callApiWithKey(self::METHOD_GET, $url);
+
+        $this->assertEquals(self::STATUS_NO_CONTENT, $editResp->getStatusCode());
+        $this->assertEquals(self::STATUS_NOT_FOUND, $visitResp->getStatusCode());
+        $this->assertEquals(self::STATUS_OK, $fetchResp->getStatusCode());
+    }
+
+    public function provideDisabledMeta(): iterable
+    {
+        $now = Chronos::now();
+
+        yield 'future validSince' => [['validSince' => $now->addMonth()->toAtomString()]];
+        yield 'past validUntil' => [['validUntil' => $now->subMonth()->toAtomString()]];
+        yield 'maxVisits reached' => [['maxVisits' => 1]];
+    }
+
    /** @test */
    public function tryingToResolveInvalidUrlReturnsNotFoundError(): void
    {
--- a/module/Rest/test-api/Fixtures/ShortUrlsFixture.php
+++ b/module/Rest/test-api/Fixtures/ShortUrlsFixture.php
@@ -20,32 +20,32 @@ class ShortUrlsFixture extends AbstractFixture
    public function load(ObjectManager $manager): void
    {
        $abcShortUrl = $this->setShortUrlDate(
-            new ShortUrl('https://shlink.io', ShortUrlMeta::createFromRawData(['customSlug' => 'abc123'])),
+            new ShortUrl('https://shlink.io', ShortUrlMeta::fromRawData(['customSlug' => 'abc123'])),
            '2018-05-01',
        );
        $manager->persist($abcShortUrl);

        $defShortUrl = $this->setShortUrlDate(new ShortUrl(
            'https://blog.alejandrocelaya.com/2017/12/09/acmailer-7-0-the-most-important-release-in-a-long-time/',
-            ShortUrlMeta::createFromParams(Chronos::parse('2020-05-01'), null, 'def456'),
+            ShortUrlMeta::fromRawData(['validSince' => Chronos::parse('2020-05-01'), 'customSlug' => 'def456']),
        ), '2019-01-01 00:00:10');
        $manager->persist($defShortUrl);

        $customShortUrl = $this->setShortUrlDate(new ShortUrl(
            'https://shlink.io',
-            ShortUrlMeta::createFromParams(null, null, 'custom', 2),
+            ShortUrlMeta::fromRawData(['customSlug' => 'custom', 'maxVisits' => 2]),
        ), '2019-01-01 00:00:20');
        $manager->persist($customShortUrl);

        $withDomainShortUrl = $this->setShortUrlDate(new ShortUrl(
            'https://blog.alejandrocelaya.com/2019/04/27/considerations-to-properly-use-open-source-software-projects/',
-            ShortUrlMeta::createFromRawData(['domain' => 'example.com', 'customSlug' => 'ghi789']),
+            ShortUrlMeta::fromRawData(['domain' => 'example.com', 'customSlug' => 'ghi789']),
        ), '2019-01-01 00:00:30');
        $manager->persist($withDomainShortUrl);

        $withDomainAndSlugShortUrl = $this->setShortUrlDate(new ShortUrl(
            'https://google.com',
-            ShortUrlMeta::createFromRawData(['domain' => 'some-domain.com', 'customSlug' => 'custom-with-domain']),
+            ShortUrlMeta::fromRawData(['domain' => 'some-domain.com', 'customSlug' => 'custom-with-domain']),
        ), '2018-10-20');
        $manager->persist($withDomainAndSlugShortUrl);

--- a/module/Rest/test/Action/ShortUrl/CreateShortUrlActionTest.php
+++ b/module/Rest/test/Action/ShortUrl/CreateShortUrlActionTest.php
@@ -76,7 +76,7 @@ class CreateShortUrlActionTest extends TestCase
        ];

        yield [['longUrl' => 'http://www.domain.com/foo/bar'], ShortUrlMeta::createEmpty()];
-        yield [$fullMeta, ShortUrlMeta::createFromRawData($fullMeta)];
+        yield [$fullMeta, ShortUrlMeta::fromRawData($fullMeta)];
    }

    /**
--- a/module/Rest/test/Action/ShortUrl/ResolveShortUrlActionTest.php
+++ b/module/Rest/test/Action/ShortUrl/ResolveShortUrlActionTest.php
@@ -8,7 +8,7 @@ use Laminas\Diactoros\ServerRequest;
 use PHPUnit\Framework\TestCase;
 use Prophecy\Prophecy\ObjectProphecy;
 use Shlinkio\Shlink\Core\Entity\ShortUrl;
-use Shlinkio\Shlink\Core\Service\UrlShortener;
+use Shlinkio\Shlink\Core\Service\ShortUrl\ShortUrlResolverInterface;
 use Shlinkio\Shlink\Rest\Action\ShortUrl\ResolveShortUrlAction;

 use function strpos;
@@ -16,19 +16,19 @@ use function strpos;
 class ResolveShortUrlActionTest extends TestCase
 {
    private ResolveShortUrlAction $action;
-    private ObjectProphecy $urlShortener;
+    private ObjectProphecy $urlResolver;

    public function setUp(): void
    {
-        $this->urlShortener = $this->prophesize(UrlShortener::class);
-        $this->action = new ResolveShortUrlAction($this->urlShortener->reveal(), []);
+        $this->urlResolver = $this->prophesize(ShortUrlResolverInterface::class);
+        $this->action = new ResolveShortUrlAction($this->urlResolver->reveal(), []);
    }

    /** @test */
    public function correctShortCodeReturnsSuccess(): void
    {
        $shortCode = 'abc123';
-        $this->urlShortener->shortCodeToUrl($shortCode, null)->willReturn(
+        $this->urlResolver->shortCodeToShortUrl($shortCode, null)->willReturn(
            new ShortUrl('http://domain.com/foo/bar'),
        )->shouldBeCalledOnce();

--- a/module/Rest/test/Middleware/CrossDomainMiddlewareTest.php
+++ b/module/Rest/test/Middleware/CrossDomainMiddlewareTest.php
@@ -31,14 +31,14 @@ class CrossDomainMiddlewareTest extends TestCase
    /** @test */
    public function nonCrossDomainRequestsAreNotAffected(): void
    {
-        $originalResponse = new Response();
+        $originalResponse = (new Response())->withStatus(404);
        $this->handler->handle(Argument::any())->willReturn($originalResponse)->shouldBeCalledOnce();

        $response = $this->middleware->process(new ServerRequest(), $this->handler->reveal());
-        $this->assertSame($originalResponse, $response);
-
        $headers = $response->getHeaders();

+        $this->assertSame($originalResponse, $response);
+        $this->assertEquals(404, $response->getStatusCode());
        $this->assertArrayNotHasKey('Access-Control-Allow-Origin', $headers);
        $this->assertArrayNotHasKey('Access-Control-Expose-Headers', $headers);
        $this->assertArrayNotHasKey('Access-Control-Allow-Methods', $headers);
@@ -93,6 +93,7 @@ class CrossDomainMiddlewareTest extends TestCase
        $this->assertArrayHasKey('Access-Control-Allow-Methods', $headers);
        $this->assertEquals('1000', $response->getHeaderLine('Access-Control-Max-Age'));
        $this->assertEquals('foo, bar, baz', $response->getHeaderLine('Access-Control-Allow-Headers'));
+        $this->assertEquals(204, $response->getStatusCode());
    }

    /**
@@ -112,6 +113,7 @@ class CrossDomainMiddlewareTest extends TestCase
        $response = $this->middleware->process($request, $this->handler->reveal());

        $this->assertEquals($response->getHeaderLine('Access-Control-Allow-Methods'), $expectedAllowedMethods);
+        $this->assertEquals(204, $response->getStatusCode());
    }

    public function provideRouteResults(): iterable
@@ -126,4 +128,42 @@ class CrossDomainMiddlewareTest extends TestCase
            'DELETE,PATCH,PUT',
        ];
    }
+
+    /**
+     * @test
+     * @dataProvider provideMethods
+     */
+    public function expectedStatusCodeIsReturnDependingOnRequestMethod(
+        string $method,
+        int $status,
+        int $expectedStatus
+    ): void {
+        $originalResponse = (new Response())->withStatus($status);
+        $request = (new ServerRequest())->withMethod($method)
+                                        ->withHeader('Origin', 'local');
+        $this->handler->handle(Argument::any())->willReturn($originalResponse)->shouldBeCalledOnce();
+
+        $response = $this->middleware->process($request, $this->handler->reveal());
+
+        $this->assertEquals($expectedStatus, $response->getStatusCode());
+    }
+
+    public function provideMethods(): iterable
+    {
+        yield 'POST 200' => ['POST', 200, 200];
+        yield 'POST 400' => ['POST', 400, 400];
+        yield 'POST 500' => ['POST', 500, 500];
+        yield 'GET 200' => ['GET', 200, 200];
+        yield 'GET 400' => ['GET', 400, 400];
+        yield 'GET 500' => ['GET', 500, 500];
+        yield 'PATCH 200' => ['PATCH', 200, 200];
+        yield 'PATCH 400' => ['PATCH', 400, 400];
+        yield 'PATCH 500' => ['PATCH', 500, 500];
+        yield 'DELETE 200' => ['DELETE', 200, 200];
+        yield 'DELETE 400' => ['DELETE', 400, 400];
+        yield 'DELETE 500' => ['DELETE', 500, 500];
+        yield 'OPTIONS 200' => ['OPTIONS', 200, 204];
+        yield 'OPTIONS 400' => ['OPTIONS', 400, 204];
+        yield 'OPTIONS 500' => ['OPTIONS', 500, 204];
+    }
 }
--- a/phpstan.neon
+++ b/phpstan.neon
@@ -1,4 +1,6 @@
 parameters:
+	checkMissingIterableValueType: false
+	checkGenericClassInNonGenericObjectType: false
 	ignoreErrors:
 		- '#Undefined variable: \$metadata#'
 		- '#AbstractQuery::setParameters()#'
Author	SHA1	Message	Date
Alejandro Celaya	eca7800487	Merge pull request #632 from shlinkio/develop Release v2.0.3	2020-01-27 11:44:43 +01:00
Alejandro Celaya	b9e58b9300	Merge pull request #631 from acelaya-forks/feature/permission-denied Feature/permission denied	2020-01-27 11:37:37 +01:00
Alejandro Celaya	54918db9ef	Updated changelog	2020-01-27 11:31:44 +01:00
Alejandro Celaya	b07a603456	Updated dependencies	2020-01-27 11:30:29 +01:00
Alejandro Celaya	4fb2c64fa8	Merge pull request #630 from acelaya-forks/feature/fetch-not-visitable-url Feature/fetch not visitable url	2020-01-26 20:00:47 +01:00
Alejandro Celaya	258c4102be	Updated changelog	2020-01-26 19:55:03 +01:00
Alejandro Celaya	b9c7f8e8d4	Added unit tests for ShortUrlresolver	2020-01-26 19:53:18 +01:00
Alejandro Celaya	f32e7cc7c4	Removed tests checking domain logic from ShortUrlRepositoryTest	2020-01-26 19:25:41 +01:00
Alejandro Celaya	4ebd48b2b0	Created new service to resolve short URLs	2020-01-26 19:21:51 +01:00
Alejandro Celaya	f71bd84a20	Merge pull request #629 from acelaya-forks/feature/reset-meta Feature/reset meta	2020-01-26 09:49:36 +01:00
Alejandro Celaya	33b45eb620	Updated changelog	2020-01-26 09:37:43 +01:00
Alejandro Celaya	1f9a912c04	Added API tests covering the edition of short URL meta with resetted values	2020-01-26 09:29:04 +01:00
Alejandro Celaya	45151cdde6	Standardized how the ShortUrlMeta object is created by exposing a single named constructor	2020-01-26 08:42:51 +01:00
Alejandro Celaya	8ca45eb388	Merge pull request #627 from acelaya-forks/feature/remote-ip-order Feature/remote ip order	2020-01-24 21:28:39 +01:00
Alejandro Celaya	b7a34a6640	Updated changelog	2020-01-24 21:21:13 +01:00
Alejandro Celaya	8ec686f4e2	Updated order in which headers for remote IP detection are inspected	2020-01-24 21:19:40 +01:00
Alejandro Celaya	43fc655218	Merge pull request #618 from shlinkio/develop Release v2.0.2	2020-01-12 11:02:10 +01:00
Alejandro Celaya	f5a30c4c2d	Merge pull request #617 from acelaya-forks/feature/fix-urls-with-hash Feature/fix urls with hash	2020-01-12 10:38:25 +01:00
Alejandro Celaya	af1dd78b2c	Fixed typo	2020-01-12 10:32:03 +01:00
Alejandro Celaya	fc95986f0e	Updated changelog for v2.0.2	2020-01-12 10:30:14 +01:00
Alejandro Celaya	c52794aed6	Replaced standard http_build_query by guzzle's build_query, which keeps params with no value	2020-01-12 10:28:44 +01:00
Alejandro Celaya	15a72e2a88	Updated local config files which were not fulfilling the project's coding standards	2020-01-12 10:06:45 +01:00
Alejandro Celaya	94af588a3c	Merge pull request #616 from acelaya-forks/feature/successful-options-req Feature/successful options req	2020-01-12 09:36:18 +01:00
Alejandro Celaya	0a4f3bc0f5	Updated changelog	2020-01-11 20:38:10 +01:00
Alejandro Celaya	09e3464426	Ensured CrossDomainMiddleware always returns empty responses with success status on OPTIONS requests	2020-01-11 20:36:17 +01:00
Alejandro Celaya	7fcc4ebd57	Merge pull request #613 from shlinkio/develop Releasing v2.0.1	2020-01-10 19:56:56 +01:00
Alejandro Celaya	b246815529	Merge pull request #612 from acelaya-forks/feature/avoid-nulls Feature/avoid nulls	2020-01-10 19:51:02 +01:00
Alejandro Celaya	ad1334f289	Created database migration which ensures no nulls are present	2020-01-10 19:44:35 +01:00
Alejandro Celaya	49bccf9a06	Updated changelog	2020-01-10 19:20:44 +01:00
Alejandro Celaya	1a8bf54e8b	Merge pull request #611 from acelaya-forks/feature/db-migrate-syntax-error Feature/db migrate syntax error	2020-01-10 19:17:45 +01:00
Alejandro Celaya	96bb0321eb	Updated casting type so that it is dynamic	2020-01-10 19:08:23 +01:00
Alejandro Celaya	37f0abf86f	Fixed use of hardcoded quotes on database migration, making it crash on postgres	2020-01-10 18:40:49 +01:00
Alejandro Celaya	f9119a38b3	Updated changelog	2020-01-10 16:04:35 +01:00
Alejandro Celaya	8465a9da31	Merge pull request #608 from acelaya-forks/feature/missing-upgrade+info Added missing information in upgrading document	2020-01-09 07:48:27 +01:00
Alejandro Celaya	b6b0d09647	Added missing information in upgrading document	2020-01-09 07:37:59 +01:00