feat(PLATECO-111): add allowed app names by regular expressions

Author: serhiidonii

.github/CODEOWNERS

@@ -0,0 +1 @@
+*                              @MacPaw/platform-backend-engineers

README.md

@@ -35,11 +35,38 @@ Add this config to `config/packages/schema_context.yaml`:
 
 ```yaml
 schema_context:
-    app_name: '%env(APP_NAME)%' # Application name
-    header_name: 'X-Tenant' # Request header to extract schema name
-    default_schema: 'public' # Default schema to fallback to
-    allowed_app_names: ['develop', 'staging', 'test'] # App names where schema context is allowed to change
+    # Name of your application (required). Used to decide whether incoming
+    # requests are allowed to override the schema from baggage.
+    app_name: '%env(APP_NAME)%'
+
+    # The KEY inside the RFC 8941 "baggage" HTTP header that holds the schema name.
+    # This is NOT an HTTP header name itself. Default: 'X-Schema'
+    header_name: 'X-Schema'
+
+    # Fallback schema used when baggage doesn't contain the key or value is empty
+    default_schema: 'public'
+
+    # Explicit app names that ARE allowed to take schema from baggage
+    allowed_app_names: ['develop', 'staging', 'test']
+
+    # Additionally allow app names by regex patterns (evaluated with preg_match)
+    # Example: allow PR preview apps like "pr-123"
+    allowed_app_names_regex: ['/^pr-\d+$/']
+```
+
+Notes:
+- The bundle reads the standard "baggage" HTTP header and expects a comma-separated list of key=value pairs.
+- It looks up the schema by the configured header_name key inside that baggage.
+
+Example incoming HTTP headers:
+```
+GET / HTTP/1.1
+Host: example.test
+baggage: X-Schema=tenant_42,traceId=abc123
 ```
+
+With the config above, the bundle will resolve schema "tenant_42" and store the entire baggage map.
+
 ### 2. Set Environment Parameters
 If you're using .env, define the app name:
 

config/services.yaml

@@ -19,6 +19,7 @@ services:
       $defaultSchema: '%schema_context.default_schema%'
       $appName: '%schema_context.app_name%'
       $allowedAppNames: '%schema_context.allowed_app_names%'
+      $allowedAppNamesRegex: '%schema_context.allowed_app_names_regex%'
     tags:
       - { name: kernel.event_subscriber }
 

src/DependencyInjection/Configuration.php

@@ -22,6 +22,10 @@ public function getConfigTreeBuilder(): TreeBuilder
                     ->scalarPrototype()->end()
                     ->defaultValue([])
                 ->end()
+                ->arrayNode('allowed_app_names_regex')
+                    ->scalarPrototype()->end()
+                    ->defaultValue([])
+                ->end()
             ->end();
 
         return $treeBuilder;

src/DependencyInjection/SchemaContextExtension.php

@@ -20,6 +20,7 @@ public function load(array $configs, ContainerBuilder $container)
         $container->setParameter('schema_context.default_schema', $config['default_schema']);
         $container->setParameter('schema_context.app_name', $config['app_name']);
         $container->setParameter('schema_context.allowed_app_names', $config['allowed_app_names']);
+        $container->setParameter('schema_context.allowed_app_names_regex', $config['allowed_app_names_regex']);
 
         $loader = new YamlFileLoader($container, new FileLocator(__DIR__ . '/../../config'));
 

src/EventListener/BaggageRequestListener.php

@@ -20,6 +20,8 @@ public function __construct(
         private string $appName,
         /** @var string[] */
         private array $allowedAppNames,
+        /** @var string[] */
+        private array $allowedAppNamesRegex,
     ) {
     }
 
@@ -54,6 +56,18 @@ public function onKernelRequest(RequestEvent $event): void
 
     private function isAllowedAppName(): bool
     {
-        return in_array($this->appName, $this->allowedAppNames, true);
+        $isAppNameAllowed = in_array($this->appName, $this->allowedAppNames, true);
+
+        if ($isAppNameAllowed === true || count($this->allowedAppNamesRegex) === 0) {
+            return $isAppNameAllowed;
+        }
+
+        foreach ($this->allowedAppNamesRegex as $pattern) {
+            if (preg_match($pattern, $this->appName) === 1) {
+                return true;
+            }
+        }
+
+        return false;
     }
 }

tests/EventListener/BaggageRequestListenerTest.php

@@ -25,6 +25,7 @@ public function testBaggageFromHeaderIsSet(): void
             'default',
             'test-app',
             ['test-app'],
+            [],
         );
 
         $request = new Request([], [], [], [], [], ['HTTP_BAGGAGE' => 'X-Schema=tenant1']);
@@ -50,6 +51,7 @@ public function testBaggageFromHeaderIsSetWithMultiplyParameters(): void
             'default',
             'test-app',
             ['test-app'],
+            [],
         );
 
         $request = new Request([], [], [], [], [], ['HTTP_BAGGAGE' => 'X-Schema= tenant1 ,test , foo=bar']);
@@ -77,6 +79,7 @@ public function testDefaultSchemaIsUsedIfHeaderMissing(): void
             'fallback',
             'test-app',
             ['test-app'],
+            []
         );
 
         $request = new Request();
@@ -88,4 +91,120 @@ public function testDefaultSchemaIsUsedIfHeaderMissing(): void
         self::assertSame('fallback', $resolver->getSchema());
         self::assertNull($resolver->getBaggage());
     }
+
+    public function testAppNameIsAllowed(): void
+    {
+        $resolver = new BaggageSchemaResolver();
+        $baggageCodec = new BaggageCodec();
+        $listener = new BaggageRequestListener(
+            $resolver,
+            $baggageCodec,
+            'X-Schema',
+            'fallback',
+            'test-app',
+            ['test-app'],
+            [],
+        );
+
+        $request = new Request();
+        $kernel = $this->createMock(HttpKernelInterface::class);
+        $event = new RequestEvent($kernel, $request, HttpKernelInterface::MAIN_REQUEST);
+
+        $listener->onKernelRequest($event);
+
+        $reflection = new \ReflectionClass(BaggageRequestListener::class);
+        $reflectionMethod = $reflection->getMethod('isAllowedAppName');
+        $reflectionMethod->setAccessible(true);
+
+        self::assertTrue($reflectionMethod->invoke($listener));
+        self::assertSame('fallback', $resolver->getSchema());
+        self::assertNull($resolver->getBaggage());
+    }
+
+    public function testAppNameIsNotAllowed(): void
+    {
+        $resolver = new BaggageSchemaResolver();
+        $baggageCodec = new BaggageCodec();
+        $listener = new BaggageRequestListener(
+            $resolver,
+            $baggageCodec,
+            'X-Schema',
+            'fallback',
+            'staging',
+            ['test-app'],
+            [],
+        );
+
+        $request = new Request();
+        $kernel = $this->createMock(HttpKernelInterface::class);
+        $event = new RequestEvent($kernel, $request, HttpKernelInterface::MAIN_REQUEST);
+
+        $listener->onKernelRequest($event);
+
+        $reflection = new \ReflectionClass(BaggageRequestListener::class);
+        $reflectionMethod = $reflection->getMethod('isAllowedAppName');
+        $reflectionMethod->setAccessible(true);
+
+        self::assertFalse($reflectionMethod->invoke($listener));
+        self::assertNull($resolver->getSchema());
+        self::assertNull($resolver->getBaggage());
+    }
+
+    public function testAppNameIsNotAllowedByRegex(): void
+    {
+        $resolver = new BaggageSchemaResolver();
+        $baggageCodec = new BaggageCodec();
+        $listener = new BaggageRequestListener(
+            $resolver,
+            $baggageCodec,
+            'X-Schema',
+            'fallback',
+            'staging',
+            ['test-app'],
+            ['/^prod$/'],
+        );
+
+        $request = new Request();
+        $kernel = $this->createMock(HttpKernelInterface::class);
+        $event = new RequestEvent($kernel, $request, HttpKernelInterface::MAIN_REQUEST);
+
+        $listener->onKernelRequest($event);
+
+        $reflection = new \ReflectionClass(BaggageRequestListener::class);
+        $reflectionMethod = $reflection->getMethod('isAllowedAppName');
+        $reflectionMethod->setAccessible(true);
+
+        self::assertFalse($reflectionMethod->invoke($listener));
+        self::assertNull($resolver->getSchema());
+        self::assertNull($resolver->getBaggage());
+    }
+
+    public function testAppNameIsAllowedByRegex(): void
+    {
+        $resolver = new BaggageSchemaResolver();
+        $baggageCodec = new BaggageCodec();
+        $listener = new BaggageRequestListener(
+            $resolver,
+            $baggageCodec,
+            'X-Schema',
+            'fallback',
+            'pr-100',
+            ['test-app'],
+            ['/^pr-\d+$/'],
+        );
+
+        $request = new Request();
+        $kernel = $this->createMock(HttpKernelInterface::class);
+        $event = new RequestEvent($kernel, $request, HttpKernelInterface::MAIN_REQUEST);
+
+        $listener->onKernelRequest($event);
+
+        $reflection = new \ReflectionClass(BaggageRequestListener::class);
+        $reflectionMethod = $reflection->getMethod('isAllowedAppName');
+        $reflectionMethod->setAccessible(true);
+
+        self::assertTrue($reflectionMethod->invoke($listener));
+        self::assertEquals('fallback', $resolver->getSchema());
+        self::assertNull($resolver->getBaggage());
+    }
 }