|null */ private ?array $responses = []; public function __construct() {} /** * @return BatchResponseItem[]|null */ public function getResponses(): ?array { return is_null($this->responses) ? null : array_values($this->responses); } /** * @param BatchResponseItem[]|null $responses */ public function setResponses(?array $responses): void { if (is_array($responses)) { array_map(fn ($response) => $this->responses[$response->getId()] = $response, $responses); return; } $this->responses = $responses; } /** * Gets a response for a given request ID * @param string $requestId * @return BatchResponseItem */ public function getResponse(string $requestId): BatchResponseItem { if (!$this->responses || !array_key_exists($requestId, $this->responses)) { throw new InvalidArgumentException("No response found for id: {$requestId}"); } return $this->responses[$requestId]; } /** * Deserializes a response item's body to $type. $type MUST implement Parsable. * Uses the ParseNodeFactory registry to get the required Parse Node implementation * * @template T of Parsable * @param string $requestId * @param class-string $type Parsable class name * @return T|null */ public function getResponseBody(string $requestId, string $type): ?Parsable { if (!$this->responses || !array_key_exists($requestId, $this->responses)) { throw new InvalidArgumentException("No response found for id: {$requestId}"); } $interfaces = class_implements($type); if (!$interfaces || !in_array(Parsable::class, $interfaces)) { throw new InvalidArgumentException("Type passed must implement the Parsable interface"); } $response = $this->responses[$requestId]; $contentType = $response->getContentType(); if (!$contentType) { throw new RuntimeException("Unable to get content-type header in response item"); } $responseBody = $response->getBody() ?? Utils::streamFor(null); try { try { $parseNode = ParseNodeFactoryRegistry::getDefaultInstance()->getRootParseNode($contentType, $responseBody); } catch (Exception $ex) { // Responses to requests with base 64 encoded stream bodies are base 64 encoded // Tries to decode the response body and retries deserialization $responseBody->rewind(); $base64DecodedBody = Utils::streamFor(base64_decode($responseBody->getContents())); $parseNode = ParseNodeFactoryRegistry::getDefaultInstance() ->getRootParseNode($contentType, $base64DecodedBody); // Update response body only after we're sure decoding worked $response->setBody($base64DecodedBody); } return $parseNode->getObjectValue([$type, 'createFromDiscriminatorValue']); } catch (Exception $ex) { throw new InvalidArgumentException( "Unable to deserialize batch response for request Id: $requestId to $type" ); } } public function getFieldDeserializers(): array { return [ 'responses' => fn (ParseNode $n) => $this->setResponses($n->getCollectionOfObjectValues([BatchResponseItem::class, 'create'])) ]; } public function serialize(SerializationWriter $writer): void { $writer->writeCollectionOfObjectValues('responses', $this->getResponses()); } public static function createFromDiscriminatorValue(ParseNode $parseNode): BatchResponseContent { return new BatchResponseContent(); } }