Phalcon\Di\Exception: Service 'messages' wasn't found in the dependency injection container

<?php
 
namespace Api\Application\Plugin;
 
use Api\Application\Cache\Keys;
use Api\Application\Cache\Manager;
use Api\Application\Exception\ApiException;
use Api\Application\Exception\PaymentException;
use Api\Application\Exception\ShippingMethodException;
use Model\SiteLang;
use Phalcon\Db\Adapter;
use Phalcon\Http\Response;
use Phalcon\Mvc\User\Plugin;
 
class ErrorHandler extends Plugin
{
    public function handle(\Throwable $exception)
    {
        // Rollback open transactions
        $this->closeOpenTransaction();
 
        // log message
        $this->log($exception->getMessage());
 
        // get requested site
        $siteID = defined('SITE_ID') ? constant('SITE_ID') : null;
        // search phone number for the site
        $phone = $this->getSitePhone($siteID);
 
        // Prepare response massage
        $messages = $this->getDI()->get('messages');
        $error = $messages->t('DEFAULT_MESSAGE_OF_EXCEPTION', ['phone' => $phone]);
 
        if ($exception instanceof ApiException) {
            $error = $exception->decodeMessages();
        } else if ($exception instanceof ShippingMethodException) {
            $error = $exception->getMessage();
        } else if ($exception instanceof PaymentException) {
            // send exception to the Sentry
            if (SENTRY_ENABLED) {
                \Sentry\captureException($exception);
            }
 
            $error = $exception->getMessage();
        } else {
            // send exception to the Sentry
            if (
                SENTRY_ENABLED
                && $exception->getMessage() !== 'Authentication is incorrect. Site ID required'
            ) {
                \Sentry\captureException($exception);
            }
 
            if (APPLICATION_ENV !== 'production') {
                $error = $exception->getMessage();
            }
        }
 
        $response = new Response();
 
        $response->setJsonContent(['error' => $error]);
        $response->setStatusCode(403);
        $response->send();
 
        return false;
    }
 
    private function closeOpenTransaction()
    {
        /** @var Adapter $db */
        $db = $this->getDI()->get('db');
        if ($db->isUnderTransaction()) {
 
            // Rollback transaction
            $db->rollback();
        }
    }
 
    private function log(string $message): void
    {
        /** @var \Core\Service\Logger\AdapterInterface $logger */
        $logger = $this->getDI()->get('log');
        $logger->setKeyMessage(\Core\Service\Logger\Key::GENERAL_ERROR);
        $logger->warning($message);
    }
 
    private function getSitePhone(?int $siteID): string
    {
        $defPhone = '+44 (0)1438 880 758';
        if ($siteID === null) {
            return $defPhone;
        }
 
        /** @var Manager $cacheManager */
        $cacheManager = $this->getDI()->get('cacheManager');
        [$key, $ttl] = Keys::getKeyTtl(Keys::SITE_PHONE);
 
        // search site phone
        $result = $cacheManager->load(
            [$key, $siteID],
            static function() use($siteID) {
                /** @var SiteLang $model */
                $model = SiteLang::query()
                    ->where('foreign_id = :site:', ['site' => $siteID])
                    ->andWhere('lang_id = :lang:', ['lang' => LANG_ID])
                    ->execute()->getFirst();
 
                if ($model) {
                    return $model->getPhone();
                }
 
                return null;
            },
            $ttl
        );
 
        // check specified phone number for the site
        if ($result === null) {
            return $defPhone;
        }
 
        return $result;
    }
}

<?php
 
namespace Api;
 
use Api\Application\Middleware\BasketListener;
use Api\Application\Middleware\JwtMiddleware;
use Api\Application\Middleware\LangCheckMiddleware;
use Api\Application\Middleware\NotFoundMiddleware;
use Api\Application\Middleware\ProfilerMiddleware;
use Api\Application\Middleware\ResponseMiddleware;
use Api\Application\Plugin\ErrorHandler;
use Api\Application\Service\BarcodeService;
use Api\Application\Service\CountryService;
use Api\Application\Service\CurrencyService;
use Api\Application\Service\JwtService;
use Core\Service\Language;
use Core\Service\ProductPriceService;
use Core\Service\TranslationsService;
use Phalcon\Config;
use Phalcon\Events\Manager;
use Phalcon\Translate\Adapter\NativeArray;
 
class Application extends \Phalcon\Mvc\Micro
{
    public function run($config)
    {
        $di = new \Phalcon\DI\FactoryDefault();
 
        // init Sentry
        if (SENTRY_ENABLED) {
            \Sentry\init([
                'dsn'         => 'https://[email protected]/1550222',
                'release'     => 'v1.0',
                'error_types' => E_ALL & ~E_DEPRECATED,
            ]);
 
            \Sentry\configureScope(function (\Sentry\State\Scope $scope): void {
//                $scope->setExtra('headers', getallheaders());
                $scope->setExtra('request', $_REQUEST);
//                $scope->setLevel(\Sentry\Severity::warning());
                $scope->setTag('app_env', APPLICATION_ENV);
                $scope->setTag('app', 'api');
            });
        }
 
        // define default scale param for the bcmatch functions
        bcscale(32);
 
        // start application time
        $startTime = microtime(true);
 
        // create registry
        $registry = new \Phalcon\Registry();
 
        // list of URLs which is allowed without jwt auth
        $registry->publicURLs = [
            '/service/images-without-watermark',
        ];
        $di->setShared('registry', $registry);
 
        // config
        $appConfig = new Config($config);
        $di->setShared('appConfig', $appConfig);
 
        // system and core services
        $configServices = require BASE_PATH . '/config/services.php';
 
        // local services
        $localServices = [
            // set cache manager
            'cacheManager' => Application\Cache\Manager::class,
            // useful functions
            'helper' => Application\Helper::class,
            // JWT service
            'jwt' => JwtService::class,
            // currency service
            'currency' => CurrencyService::class,
            'barcodeService' => BarcodeService::class,
            // price service (using for a page with price filtering)
            'priceService' => ProductPriceService::class,
        ];
 
        $serviceLoader = new \Core\Service\Loader(
            array_merge($configServices, $localServices),
            $di
        );
        $di->set('serviceLoader', $serviceLoader, true);
 
        $appConfig = $di->get('appConfig');
 
        \define('IMAGES_SERVER', $appConfig->get('IMAGE_SERVER'));
        \define('STATIC_SERVER', $appConfig->get('STATIC_SERVER'));
 
        // define VAT
        \define('VAT', $config['VAT'] ?? 20);
 
        $this->setDI($di);
 
        /** @var Manager $eventsManager */
        $eventsManager = $di->get('eventsManager');
 
        // middleware
        $eventsManager->attach('micro', new JwtMiddleware());
        $eventsManager->attach('micro', new NotFoundMiddleware());
        $eventsManager->attach('micro', new LangCheckMiddleware());
        $eventsManager->attach('micro', new ProfilerMiddleware());
 
        // make events manager is in the DI container now
        $this->setEventsManager($eventsManager);
 
        // mount collections
        $routes = new Routes($this);
        $routes->addRoute(Index\Router::class);
        $routes->addRoute(Catalogue\Router::class);
        $routes->addRoute(Product\Router::class);
        $routes->addRoute(Service\Router::class);
        $routes->addRoute(Site\Router::class);
        $routes->addRoute(Basket\Router::class);
        $routes->addRoute(Pages\Router::class);
        $routes->addRoute(Checkout\Router::class);
 
        // mount all handlers
        $routes->mount();
 
        // define lang
        $this->before(function() use($di) {
            /** @var Language $langService */
            $langService = $di->get('language');
 
            $jwtService = $this->getDI()->get('jwt');
            if ($jwtService->isDefined()) {
                $countryID = $jwtService->getCountryID();
 
                $lang   = $langService->getLangByCountryId($countryID);
                $langID = $langService->getLangID($lang);
 
                \define('LANG', $lang);
                \define('LANG_ID', $langID);
 
            } else {
                $defaultLang = Language::DEFAULT_LANG;
                $langID = $langService->getLangID($defaultLang);
 
                \define('LANG', $defaultLang);
                \define('LANG_ID', $langID);
 
            }
 
            // additional params for Sentry
            if (SENTRY_ENABLED) {
                \Sentry\configureScope(function (\Sentry\State\Scope $scope): void {
                    $scope->setTag('langID', LANG_ID);
                });
            }
 
            $langParam = LANG;
            $di->setShared('messages', function () use ($langParam) {
                // $messages = require './messages/en.php';
                $translationsService = new TranslationsService();
                $translationObject = $translationsService->getApiTranslateMessages($langParam);
 
                // Return a translation object
                return $translationObject;
            });
 
        });
 
        // define site id
        $this->before(function() {
            /** @var \Api\Application\Service\JwtService $jwtService */
            $jwtService = $this->getDI()->get('jwt');
            if ($jwtService->isDefined()) {
                $siteID = $jwtService->getSite();
 
                \define('SITE_ID', $siteID);
 
                // additional params for Sentry
                if (SENTRY_ENABLED) {
                    \Sentry\configureScope(function (\Sentry\State\Scope $scope): void {
                        $scope->setTag('siteID', SITE_ID);
                    });
                }
            } else {
                \define('SITE_ID', \Model\Site::PENCOMPANY_SITE);
            }
        });
 
        // define include VAT for price or not
        $this->before(function() {
            /** @var \Api\Application\Service\JwtService $jwtService */
            $jwtService = $this->getDI()->get('jwt');
            if ($jwtService->isDefined()) {
                $countryID = $jwtService->getCountryID();
 
                $countryService = new CountryService();
                $vat = $countryService->includeVat($countryID);
 
                /** @var ProductPriceService $priceService */
                $priceService = $this->getDI()->get('priceService');
                $priceService->setWithVat($vat);
            }
        });
 
        // add headers with response time (non for production)
        $this->after(function() use($startTime) {
            if (APPLICATION_ENV !== 'production') {
                $t = microtime(true) - $startTime;
                $this->response->setHeader('X-ResponseTime', $t);
            }
        });
 
        // Middleware after the route is executed
        $this->after(new ResponseMiddleware());
 
        // change filters
        // add a filter to skip encoding for quotes
        $di->setShared('filter', function () {
 
            $filter = new \Phalcon\Filter();
 
            $filter->add('estring', function ($value) {
                return filter_var(
                    $value,
                    FILTER_SANITIZE_STRING,
                    [
                        'flags' => FILTER_FLAG_NO_ENCODE_QUOTES,
                    ]
                );
            });
 
            return $filter;
 
        });
 
        // add my eventManager
        /** @var \Core\Service\EventService $eventService */
        $eventService = $this->getDI()->get('eventService');
        $eventManager = $eventService->getEventsManager();
 
        // attach listeners
        $eventManager->attach('basket', new BasketListener());
 
        // handle app
        try {
            $this->handle();
        } catch (\Throwable $e) {
            $handler = new ErrorHandler();
            $handler->handle($e);
        }
    }
}

<?php
chdir(dirname(__DIR__));
 
define('BASE_PATH', __DIR__ . '/../../../');
define('APPLICATION_PATH', __DIR__ . '/../../api');
define('WEB_PATH', __DIR__);
 
// Autoloader for Composer packages
require_once BASE_PATH . '/vendor/autoload.php';
 
$dotenv = new Dotenv\Dotenv(BASE_PATH);
$dotenv->load();
 
\defined('APPLICATION_ENV') ||
    \define('APPLICATION_ENV', (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV') : 'production'));
 
\defined('CACHE_ENABLED') ||
    \define('CACHE_ENABLED', (array_key_exists('CACHE_ENABLED', $_ENV) ? (int)getenv('CACHE_ENABLED') : 1));
 
\defined('ENGRAVING_ENABLED') ||
    \define('ENGRAVING_ENABLED', (array_key_exists('ENGRAVING_ENABLED', $_ENV) ? (int)getenv('ENGRAVING_ENABLED') : 1));
 
\defined('SENTRY_ENABLED') ||
    \define('SENTRY_ENABLED', (array_key_exists('SENTRY_ENABLED', $_ENV) ? (int)getenv('SENTRY_ENABLED') : 0));
 
\defined('OUTPUT_TIMEZONE')
    || \define('OUTPUT_TIMEZONE', (array_key_exists('OUTPUT_TIMEZONE', $_ENV) ? getenv('OUTPUT_TIMEZONE') : 'Europe/London'));
 
//Debug
if (APPLICATION_ENV !== 'production') {
    $debug = new \Phalcon\Debug();
    $debug->listen();
}
 
// Application class
require_once APPLICATION_PATH . '/Application.php';
$app = new \Api\Application();
$app->run($_ENV);