Feat: Global segments

src/Configuration/Context.php

@@ -24,6 +24,9 @@ public function getSessionId(): ?string;
 
     public function getCustomProperty(string $name): string;
 
+    /**
+     * @todo make $value nullable
+     */
     public function setCustomProperty(string $name, string $value): self;
 
     public function hasCustomProperty(string $name): bool;

src/Configuration/UnleashContext.php

@@ -55,9 +55,9 @@ public function getCustomProperty(string $name): string
         return $this->customContext[$name];
     }
 
-    public function setCustomProperty(string $name, string $value): self
+    public function setCustomProperty(string $name, ?string $value): self
     {
-        $this->customContext[$name] = $value;
+        $this->customContext[$name] = $value ?? '';
 
         return $this;
     }

src/DTO/DefaultSegment.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Unleash\Client\DTO;
+
+final class DefaultSegment implements Segment
+{
+    /**
+     * @param array<Constraint> $constraints
+     */
+    public function __construct(
+        private readonly int $id,
+        private readonly array $constraints,
+    ) {
+    }
+
+    public function getId(): int
+    {
+        return $this->id;
+    }
+
+    public function getConstraints(): array
+    {
+        return $this->constraints;
+    }
+}

src/DTO/DefaultStrategy.php

@@ -7,11 +7,14 @@ final class DefaultStrategy implements Strategy
     /**
      * @param array<string,string> $parameters
      * @param array<Constraint>    $constraints
+     * @param array<Segment>       $segments
      */
     public function __construct(
         private readonly string $name,
         private readonly array $parameters = [],
         private readonly array $constraints = [],
+        private readonly array $segments = [],
+        private readonly bool $nonexistentSegments = false,
     ) {
     }
 
@@ -35,4 +38,17 @@ public function getConstraints(): array
     {
         return $this->constraints;
     }
+
+    /**
+     * @return array<Segment>
+     */
+    public function getSegments(): array
+    {
+        return $this->segments;
+    }
+
+    public function hasNonexistentSegments(): bool
+    {
+        return $this->nonexistentSegments;
+    }
 }

src/DTO/Segment.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Unleash\Client\DTO;
+
+interface Segment
+{
+    public function getId(): int;
+
+    /**
+     * @return array<Constraint>
+     */
+    public function getConstraints(): array;
+}

src/DTO/Strategy.php

@@ -2,6 +2,10 @@
 
 namespace Unleash\Client\DTO;
 
+/**
+ * @method array<Segment> getSegments()
+ * @method bool           hasNonexistentSegments()
+ */
 interface Strategy
 {
     public function getName(): string;

src/Repository/DefaultUnleashRepository.php

@@ -10,20 +10,33 @@
 use Psr\Http\Message\RequestFactoryInterface;
 use Psr\SimpleCache\InvalidArgumentException;
 use Unleash\Client\Configuration\UnleashConfiguration;
+use Unleash\Client\DTO\Constraint;
 use Unleash\Client\DTO\DefaultConstraint;
 use Unleash\Client\DTO\DefaultFeature;
+use Unleash\Client\DTO\DefaultSegment;
 use Unleash\Client\DTO\DefaultStrategy;
 use Unleash\Client\DTO\DefaultVariant;
 use Unleash\Client\DTO\DefaultVariantOverride;
 use Unleash\Client\DTO\DefaultVariantPayload;
 use Unleash\Client\DTO\Feature;
+use Unleash\Client\DTO\Segment;
 use Unleash\Client\Enum\CacheKey;
 use Unleash\Client\Enum\Stickiness;
 use Unleash\Client\Event\FetchingDataFailedEvent;
 use Unleash\Client\Event\UnleashEvents;
 use Unleash\Client\Exception\HttpResponseException;
 use Unleash\Client\Exception\InvalidValueException;
 
+/**
+ * @phpstan-type ConstraintArray array{
+ *     contextName: string,
+ *     operator: string,
+ *     values?: array<string>,
+ *     value?: string,
+ *     inverted?: bool,
+ *     caseInsensitive?: bool
+ * }
+ */
 final class DefaultUnleashRepository implements UnleashRepository
 {
     public function __construct(
@@ -64,7 +77,9 @@ public function getFeatures(): iterable
                 $request = $this->requestFactory
                     ->createRequest('GET', $this->configuration->getUrl() . 'client/features')
                     ->withHeader('UNLEASH-APPNAME', $this->configuration->getAppName())
-                    ->withHeader('UNLEASH-INSTANCEID', $this->configuration->getInstanceId());
+                    ->withHeader('UNLEASH-INSTANCEID', $this->configuration->getInstanceId())
+                    ->withHeader('Unleash-Client-Spec', '4.2.2')
+                ;
 
                 foreach ($this->configuration->getHeaders() as $name => $value) {
                     $request = $request->withHeader($name, $value);
@@ -140,6 +155,8 @@ private function parseFeatures(string $rawBody): array
         $body = json_decode($rawBody, true, 512, JSON_THROW_ON_ERROR);
         assert(is_array($body));
 
+        $globalSegments = $this->parseSegments($body['segments'] ?? []);
+
         if (!isset($body['features']) || !is_array($body['features'])) {
             throw new InvalidValueException("The body isn't valid because it doesn't contain a 'features' key");
         }
@@ -149,21 +166,24 @@ private function parseFeatures(string $rawBody): array
             $variants = [];
 
             foreach ($feature['strategies'] as $strategy) {
-                $constraints = [];
-                foreach ($strategy['constraints'] ?? [] as $constraint) {
-                    $constraints[] = new DefaultConstraint(
-                        $constraint['contextName'],
-                        $constraint['operator'],
-                        $constraint['values'] ?? null,
-                        $constraint['value'] ?? null,
-                        $constraint['inverted'] ?? false,
-                        $constraint['caseInsensitive'] ?? false,
-                    );
+                $constraints = $this->parseConstraints($strategy['constraints'] ?? []);
+
+                $hasNonexistentSegments = false;
+                $segments = [];
+                foreach ($strategy['segments'] ?? [] as $segment) {
+                    if (isset($globalSegments[$segment])) {
+                        $segments[] = $globalSegments[$segment];
+                    } else {
+                        $hasNonexistentSegments = true;
+                        break;
+                    }
                 }
                 $strategies[] = new DefaultStrategy(
                     $strategy['name'],
                     $strategy['parameters'] ?? [],
-                    $constraints
+                    $constraints,
+                    $segments,
+                    $hasNonexistentSegments,
                 );
             }
             foreach ($feature['variants'] ?? [] as $variant) {
@@ -182,6 +202,7 @@ private function parseFeatures(string $rawBody): array
                     $overrides,
                 );
             }
+
             $features[$feature['name']] = new DefaultFeature(
                 $feature['name'],
                 $feature['enabled'],
@@ -220,4 +241,45 @@ private function setLastValidState(string $data): void
             $this->configuration->getStaleTtl(),
         );
     }
+
+    /**
+     * @param array<array{id: int, constraints: array<ConstraintArray>}> $segmentsRaw
+     *
+     * @return array<Segment>
+     */
+    private function parseSegments(array $segmentsRaw): array
+    {
+        $result = [];
+        foreach ($segmentsRaw as $segmentRaw) {
+            $result[$segmentRaw['id']] = new DefaultSegment(
+                $segmentRaw['id'],
+                $this->parseConstraints($segmentRaw['constraints']),
+            );
+        }
+
+        return $result;
+    }
+
+    /**
+     * @param array<ConstraintArray> $constraintsRaw
+     *
+     * @return array<Constraint>
+     */
+    private function parseConstraints(array $constraintsRaw): array
+    {
+        $constraints = [];
+
+        foreach ($constraintsRaw as $constraint) {
+            $constraints[] = new DefaultConstraint(
+                $constraint['contextName'],
+                $constraint['operator'],
+                $constraint['values'] ?? null,
+                $constraint['value'] ?? null,
+                $constraint['inverted'] ?? false,
+                $constraint['caseInsensitive'] ?? false,
+            );
+        }
+
+        return $constraints;
+    }
 }

src/Strategy/AbstractStrategyHandler.php

@@ -24,7 +24,16 @@ protected function findParameter(string $parameter, Strategy $strategy): ?string
 
     protected function validateConstraints(Strategy $strategy, Context $context): bool
     {
+        if (method_exists($strategy, 'hasNonexistentSegments') && $strategy->hasNonexistentSegments()) {
+            return false;
+        }
+
         $constraints = $strategy->getConstraints();
+        $segments = method_exists($strategy, 'getSegments') ? $strategy->getSegments() : [];
+        foreach ($segments as $segment) {
+            $constraints = [...$constraints, ...$segment->getConstraints()];
+        }
+
         foreach ($constraints as $constraint) {
             if (!$this->getValidator()->validateConstraint($constraint, $context)) {
                 return false;

tests/CoverageOnlyTest.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace Unleash\Client\Tests;
+
+use PHPUnit\Framework\TestCase;
+use Unleash\Client\DTO\DefaultSegment;
+
+/**
+ * This class is only for triggering code that doesn't really make sense to test and is here to achieve 100% code coverage.
+ * The reason is to catch potential problems during transpilation to lower versions of php.
+ */
+final class CoverageOnlyTest extends TestCase
+{
+    public function testDefaultSegment(): void
+    {
+        $instance = new DefaultSegment(1, []);
+        self::assertEquals(1, $instance->getId());
+    }
+}