SecurityScheme.php

<?php declare(strict_types = 1);

namespace Contributte\OpenApi\Schema;

use InvalidArgumentException;

class SecurityScheme
{

	public const TYPE_API_KEY = 'apiKey';
	public const TYPE_HTTP = 'http';
	public const TYPE_MUTUAL_TLS = 'mutualTLS';
	public const TYPE_OAUTH2 = 'oauth2';
	public const TYPE_OPEN_ID_CONNECT = 'openIdConnect';

	public const TYPES = [
		self::TYPE_API_KEY,
		self::TYPE_HTTP,
		self::TYPE_MUTUAL_TLS,
		self::TYPE_OAUTH2,
		self::TYPE_OPEN_ID_CONNECT,
	];

	public const IN_COOKIE = 'cookie';
	public const IN_HEADER = 'header';
	public const IN_QUERY = 'query';

	public const INS = [
		self::IN_COOKIE,
		self::IN_HEADER,
		self::IN_QUERY,
	];

	public const FLOW_IMPLICIT = 'implicit';
	public const FLOW_PASSWORD = 'password';
	public const FLOW_CLIENT_CREDENTIALS = 'clientCredentials';
	public const FLOW_AUTHORIZATION_CODE = 'authorizationCode';

	public const FLOWS = [
		self::FLOW_IMPLICIT,
		self::FLOW_PASSWORD,
		self::FLOW_CLIENT_CREDENTIALS,
		self::FLOW_AUTHORIZATION_CODE,
	];

	private string $type;

	private ?string $description = null;

	private ?string $name = null;

	private ?string $in = null;

	private ?string $scheme = null;

	private ?string $bearerFormat = null;

	/** @var array<string, OAuthFlow> */
	private array $flows = [];

	private ?string $openIdConnectUrl = null;

	private ?VendorExtensions $vendorExtensions = null;

	public function __construct(string $type)
	{
		$this->setType($type);
	}

	/**
	 * @param mixed[] $data
	 */
	public static function fromArray(array $data): SecurityScheme
	{
		$type = $data['type'];
		$securityScheme = new SecurityScheme($type);
		$securityScheme->setName($data['name'] ?? null);
		$securityScheme->setDescription($data['description'] ?? null);
		$securityScheme->setIn($data['in'] ?? null);
		$securityScheme->setScheme($data['scheme'] ?? null);
		$securityScheme->setBearerFormat($data['bearerFormat'] ?? null);
		$securityScheme->setFlows(array_map(static fn (array $flow): OAuthFlow => OAuthFlow::fromArray($flow), $data['flows'] ?? []));
		$securityScheme->setOpenIdConnectUrl($data['openIdConnectUrl'] ?? null);
		$securityScheme->setVendorExtensions(VendorExtensions::fromArray($data));

		return $securityScheme;
	}

	/**
	 * @return mixed[]
	 */
	public function toArray(): array
	{
		$data = [];
		$data['type'] = $this->type;

		if ($this->name !== null) {
			$data['name'] = $this->name;
		}

		if ($this->description !== null) {
			$data['description'] = $this->description;
		}

		if ($this->in !== null) {
			$data['in'] = $this->in;
		}

		if ($this->scheme !== null) {
			$data['scheme'] = $this->scheme;
		}

		if ($this->bearerFormat !== null) {
			$data['bearerFormat'] = $this->bearerFormat;
		}

		if ($this->flows !== []) {
			$data['flows'] = array_map(static fn (OAuthFlow $flow): array => $flow->toArray(), $this->flows);
		}

		if ($this->openIdConnectUrl !== null) {
			$data['openIdConnectUrl'] = $this->openIdConnectUrl;
		}

		if ($this->vendorExtensions !== null) {
			$data = array_merge($data, $this->vendorExtensions->toArray());
		}

		return $data;
	}

	public function getType(): string
	{
		return $this->type;
	}

	public function setType(string $type): void
	{
		if (!in_array($type, self::TYPES, true)) {
			throw new InvalidArgumentException(sprintf(
				'Invalid value "%s" for attribute "type" given. It must be one of "%s".',
				$type,
				implode(', ', self::TYPES)
			));
		}

		$this->type = $type;
	}

	public function getName(): ?string
	{
		return $this->name;
	}

	public function setName(?string $name): void
	{
		if ($this->type === self::TYPE_API_KEY && $name === null) {
			throw new InvalidArgumentException('Attribute "name" is required for type "apiKey".');
		}

		$this->name = $name;
	}

	public function getDescription(): ?string
	{
		return $this->description;
	}

	public function setDescription(?string $description): void
	{
		$this->description = $description;
	}

	public function getIn(): ?string
	{
		return $this->in;
	}

	public function setIn(?string $in): void
	{
		if ($this->type === self::TYPE_API_KEY && $in === null) {
			throw new InvalidArgumentException('Attribute "in" is required for type "apiKey".');
		}

		if ($in === null || in_array($in, self::INS, true)) {
			$this->in = $in;

			return;
		}

		throw new InvalidArgumentException(sprintf(
			'Invalid value "%s" for attribute "in" given. It must be one of "%s".',
			$in,
			implode(', ', self::INS)
		));
	}

	public function getScheme(): ?string
	{
		return $this->scheme;
	}

	public function setScheme(?string $scheme): void
	{
		if ($this->type === self::TYPE_HTTP && $scheme === null) {
			throw new InvalidArgumentException('Attribute "scheme" is required for type "http".');
		}

		$this->scheme = $scheme;
	}

	public function getBearerFormat(): ?string
	{
		return $this->bearerFormat;
	}

	public function setBearerFormat(?string $bearerFormat): void
	{
		$this->bearerFormat = $bearerFormat;
	}

	/**
	 * @return array<string, OAuthFlow>
	 */
	public function getFlows(): array
	{
		return $this->flows;
	}

	/**
	 * @param array<string, OAuthFlow> $flows
	 */
	public function setFlows(array $flows): void
	{
		if ($this->type === self::TYPE_OAUTH2 && $flows === []) {
			throw new InvalidArgumentException('Attribute "flows" is required for type "oauth2".');
		}

		if ($this->type === self::TYPE_OAUTH2) {
			foreach ($flows as $flowType => $flow) {
				if (!in_array($flowType, self::FLOWS, true)) {
					throw new InvalidArgumentException(sprintf(
						'Invalid flow type "%s" given. It must be one of "%s".',
						$flowType,
						implode(', ', self::FLOWS)
					));
				}

				self::validateFlow($flowType, $flow);
			}
		}

		$this->flows = $flows;
	}

	public function getOpenIdConnectUrl(): ?string
	{
		return $this->openIdConnectUrl;
	}

	public function setOpenIdConnectUrl(?string $openIdConnectUrl): void
	{
		if ($this->type === self::TYPE_OPEN_ID_CONNECT && $openIdConnectUrl === null) {
			throw new InvalidArgumentException('Attribute "openIdConnectUrl" is required for type "openIdConnect".');
		}

		$this->openIdConnectUrl = $openIdConnectUrl;
	}

	public function getVendorExtensions(): ?VendorExtensions
	{
		return $this->vendorExtensions;
	}

	public function setVendorExtensions(?VendorExtensions $vendorExtensions): void
	{
		$this->vendorExtensions = $vendorExtensions;
	}

	private static function validateFlow(string $flowType, OAuthFlow $flow): void
	{
		$needsAuthorizationUrl = in_array($flowType, [
			self::FLOW_IMPLICIT,
			self::FLOW_AUTHORIZATION_CODE,
		], true);

		if ($needsAuthorizationUrl && $flow->getAuthorizationUrl() === null) {
			throw new InvalidArgumentException(sprintf(
				'Attribute "authorizationUrl" is required for flow "%s".',
				$flowType
			));
		}

		$needsTokenUrl = in_array($flowType, [
			self::FLOW_PASSWORD,
			self::FLOW_CLIENT_CREDENTIALS,
			self::FLOW_AUTHORIZATION_CODE,
		], true);

		if ($needsTokenUrl && $flow->getTokenUrl() === null) {
			throw new InvalidArgumentException(sprintf(
				'Attribute "tokenUrl" is required for flow "%s".',
				$flowType
			));
		}
	}

}