create-prisma-php-app 1.0.0

package/vendor/ramsey/uuid/src/Generator/DceSecurityGenerator.php

@@ -0,0 +1,139 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Generator;
+
+use Ramsey\Uuid\Converter\NumberConverterInterface;
+use Ramsey\Uuid\Exception\DceSecurityException;
+use Ramsey\Uuid\Provider\DceSecurityProviderInterface;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Type\Integer as IntegerObject;
+use Ramsey\Uuid\Uuid;
+
+use function hex2bin;
+use function in_array;
+use function pack;
+use function str_pad;
+use function strlen;
+use function substr_replace;
+
+use const STR_PAD_LEFT;
+
+/**
+ * DceSecurityGenerator generates strings of binary data based on a local
+ * domain, local identifier, node ID, clock sequence, and the current time
+ */
+class DceSecurityGenerator implements DceSecurityGeneratorInterface
+{
+    private const DOMAINS = [
+        Uuid::DCE_DOMAIN_PERSON,
+        Uuid::DCE_DOMAIN_GROUP,
+        Uuid::DCE_DOMAIN_ORG,
+    ];
+
+    /**
+     * Upper bounds for the clock sequence in DCE Security UUIDs.
+     */
+    private const CLOCK_SEQ_HIGH = 63;
+
+    /**
+     * Lower bounds for the clock sequence in DCE Security UUIDs.
+     */
+    private const CLOCK_SEQ_LOW = 0;
+
+    public function __construct(
+        private readonly NumberConverterInterface $numberConverter,
+        private readonly TimeGeneratorInterface $timeGenerator,
+        private readonly DceSecurityProviderInterface $dceSecurityProvider
+    ) {
+    }
+
+    public function generate(
+        int $localDomain,
+        ?IntegerObject $localIdentifier = null,
+        Hexadecimal | int | string | null $node = null,
+        ?int $clockSeq = null
+    ): string {
+        if (!in_array($localDomain, self::DOMAINS)) {
+            throw new DceSecurityException(
+                'Local domain must be a valid DCE Security domain'
+            );
+        }
+
+        if ($localIdentifier && $localIdentifier->isNegative()) {
+            throw new DceSecurityException(
+                'Local identifier out of bounds; it must be a value between 0 and 4294967295'
+            );
+        }
+
+        if ($clockSeq > self::CLOCK_SEQ_HIGH || $clockSeq < self::CLOCK_SEQ_LOW) {
+            throw new DceSecurityException(
+                'Clock sequence out of bounds; it must be a value between 0 and 63'
+            );
+        }
+
+        switch ($localDomain) {
+            case Uuid::DCE_DOMAIN_ORG:
+                if ($localIdentifier === null) {
+                    throw new DceSecurityException(
+                        'A local identifier must be provided for the org domain'
+                    );
+                }
+
+                break;
+            case Uuid::DCE_DOMAIN_PERSON:
+                if ($localIdentifier === null) {
+                    $localIdentifier = $this->dceSecurityProvider->getUid();
+                }
+
+                break;
+            case Uuid::DCE_DOMAIN_GROUP:
+            default:
+                if ($localIdentifier === null) {
+                    $localIdentifier = $this->dceSecurityProvider->getGid();
+                }
+
+                break;
+        }
+
+        $identifierHex = $this->numberConverter->toHex($localIdentifier->toString());
+
+        // The maximum value for the local identifier is 0xffffffff, or
+        // 4294967295. This is 8 hexadecimal digits, so if the length of
+        // hexadecimal digits is greater than 8, we know the value is greater
+        // than 0xffffffff.
+        if (strlen($identifierHex) > 8) {
+            throw new DceSecurityException(
+                'Local identifier out of bounds; it must be a value between 0 and 4294967295'
+            );
+        }
+
+        $domainByte = pack('n', $localDomain)[1];
+        $identifierBytes = (string) hex2bin(str_pad($identifierHex, 8, '0', STR_PAD_LEFT));
+
+        // Shift the clock sequence 8 bits to the left, so it matches 0x3f00.
+        if ($clockSeq !== null) {
+            /** @var int<0, 16383> $clockSeq */
+            $clockSeq = $clockSeq << 8;
+        }
+
+        $bytes = $this->timeGenerator->generate($node, $clockSeq);
+
+        // Replace bytes in the time-based UUID with DCE Security values.
+        $bytes = substr_replace($bytes, $identifierBytes, 0, 4);
+
+        /** @var non-empty-string */
+        return substr_replace($bytes, $domainByte, 9, 1);
+    }
+}

package/vendor/ramsey/uuid/src/Generator/DceSecurityGeneratorInterface.php

@@ -0,0 +1,53 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Generator;
+
+use Ramsey\Uuid\Rfc4122\UuidV2;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Type\Integer as IntegerObject;
+
+/**
+ * A DCE Security generator generates strings of binary data based on a local
+ * domain, local identifier, node ID, clock sequence, and the current time
+ *
+ * @see UuidV2
+ */
+interface DceSecurityGeneratorInterface
+{
+    /**
+     * Generate a binary string from a local domain, local identifier, node ID,
+     * clock sequence, and current time
+     *
+     * @param int $localDomain The local domain to use when generating bytes,
+     *     according to DCE Security
+     * @param IntegerObject|null $localIdentifier The local identifier for the
+     *     given domain; this may be a UID or GID on POSIX systems, if the local
+     *     domain is person or group, or it may be a site-defined identifier
+     *     if the local domain is org
+     * @param Hexadecimal|positive-int|non-empty-string|null $node A 48-bit
+     *     number representing the hardware address
+     * @param int<0, 63>|null $clockSeq A 6-bit number used to help avoid
+     *     duplicates that could arise when the clock is set backwards in time
+     *     or if the node ID changes
+     *
+     * @return non-empty-string A binary string
+     */
+    public function generate(
+        int $localDomain,
+        ?IntegerObject $localIdentifier = null,
+        Hexadecimal | int | string | null $node = null,
+        ?int $clockSeq = null
+    ): string;
+}

package/vendor/ramsey/uuid/src/Generator/DefaultNameGenerator.php

@@ -0,0 +1,51 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Generator;
+
+use Ramsey\Uuid\Exception\NameException;
+use Ramsey\Uuid\UuidInterface;
+use ValueError;
+
+use function hash;
+
+/**
+ * DefaultNameGenerator generates strings of binary data based on a namespace,
+ * name, and hashing algorithm
+ */
+class DefaultNameGenerator implements NameGeneratorInterface
+{
+    /**
+     * @inheritDoc
+     * @psalm-pure
+     */
+    public function generate(UuidInterface $ns, string $name, string $hashAlgorithm): string
+    {
+        try {
+            /** @var non-empty-string|false $bytes */
+            $bytes = @hash($hashAlgorithm, $ns->getBytes() . $name, true);
+        } catch (ValueError $e) {
+            $bytes = false; // keep same behavior than PHP 7
+        }
+
+        if ($bytes === false) {
+            throw new NameException(sprintf(
+                'Unable to hash namespace and name with algorithm \'%s\'',
+                $hashAlgorithm
+            ));
+        }
+
+        return $bytes;
+    }
+}

package/vendor/ramsey/uuid/src/Generator/DefaultTimeGenerator.php

@@ -0,0 +1,131 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Generator;
+
+use Ramsey\Uuid\Converter\TimeConverterInterface;
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Exception\RandomSourceException;
+use Ramsey\Uuid\Exception\TimeSourceException;
+use Ramsey\Uuid\Provider\NodeProviderInterface;
+use Ramsey\Uuid\Provider\TimeProviderInterface;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Throwable;
+
+use function dechex;
+use function hex2bin;
+use function is_int;
+use function pack;
+use function preg_match;
+use function sprintf;
+use function str_pad;
+use function strlen;
+
+use const STR_PAD_LEFT;
+
+/**
+ * DefaultTimeGenerator generates strings of binary data based on a node ID,
+ * clock sequence, and the current time
+ */
+class DefaultTimeGenerator implements TimeGeneratorInterface
+{
+    public function __construct(
+        private readonly NodeProviderInterface $nodeProvider,
+        private readonly TimeConverterInterface $timeConverter,
+        private readonly TimeProviderInterface $timeProvider
+    ) {
+    }
+
+    /**
+     * @throws InvalidArgumentException if the parameters contain invalid values
+     * @throws RandomSourceException if random_int() throws an exception/error
+     *
+     * @inheritDoc
+     */
+    public function generate(Hexadecimal | int | string | null $node = null, ?int $clockSeq = null): string
+    {
+        if ($node instanceof Hexadecimal) {
+            $node = $node->toString();
+        }
+
+        $node = $this->getValidNode($node);
+
+        if ($clockSeq === null) {
+            try {
+                // This does not use "stable storage"; see RFC 4122, Section 4.2.1.1.
+                $clockSeq = random_int(0, 0x3fff);
+            } catch (Throwable $exception) {
+                throw new RandomSourceException(
+                    $exception->getMessage(),
+                    (int) $exception->getCode(),
+                    $exception
+                );
+            }
+        }
+
+        $time = $this->timeProvider->getTime();
+
+        $uuidTime = $this->timeConverter->calculateTime(
+            $time->getSeconds()->toString(),
+            $time->getMicroseconds()->toString()
+        );
+
+        $timeHex = str_pad($uuidTime->toString(), 16, '0', STR_PAD_LEFT);
+
+        if (strlen($timeHex) !== 16) {
+            throw new TimeSourceException(sprintf(
+                'The generated time of \'%s\' is larger than expected',
+                $timeHex
+            ));
+        }
+
+        $timeBytes = (string) hex2bin($timeHex);
+
+        return $timeBytes[4] . $timeBytes[5] . $timeBytes[6] . $timeBytes[7]
+            . $timeBytes[2] . $timeBytes[3]
+            . $timeBytes[0] . $timeBytes[1]
+            . pack('n*', $clockSeq)
+            . $node;
+    }
+
+    /**
+     * Uses the node provider given when constructing this instance to get
+     * the node ID (usually a MAC address)
+     *
+     * @param non-empty-string|positive-int|null $node A node value that may be
+     *     used to override the node provider
+     *
+     * @return non-empty-string 6-byte binary string representation of the node
+     *
+     * @throws InvalidArgumentException
+     */
+    private function getValidNode(int | string | null $node): string
+    {
+        if ($node === null) {
+            $node = $this->nodeProvider->getNode();
+        }
+
+        // Convert the node to hex, if it is still an integer.
+        if (is_int($node)) {
+            $node = dechex($node);
+        }
+
+        if (!preg_match('/^[A-Fa-f0-9]+$/', (string) $node) || strlen((string) $node) > 12) {
+            throw new InvalidArgumentException('Invalid node value');
+        }
+
+        /** @var non-empty-string */
+        return (string) hex2bin(str_pad((string) $node, 12, '0', STR_PAD_LEFT));
+    }
+}

package/vendor/ramsey/uuid/src/Generator/NameGeneratorFactory.php

@@ -0,0 +1,30 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Generator;
+
+/**
+ * NameGeneratorFactory retrieves a default name generator, based on the
+ * environment
+ */
+class NameGeneratorFactory
+{
+    /**
+     * Returns a default name generator, based on the current environment
+     */
+    public function getGenerator(): NameGeneratorInterface
+    {
+        return new DefaultNameGenerator();
+    }
+}

package/vendor/ramsey/uuid/src/Generator/NameGeneratorInterface.php

@@ -0,0 +1,38 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Generator;
+
+use Ramsey\Uuid\UuidInterface;
+
+/**
+ * A name generator generates strings of binary data created by hashing together
+ * a namespace with a name, according to a hashing algorithm
+ */
+interface NameGeneratorInterface
+{
+    /**
+     * Generate a binary string from a namespace and name hashed together with
+     * the specified hashing algorithm
+     *
+     * @param UuidInterface $ns The namespace
+     * @param string $name The name to use for creating a UUID
+     * @param non-empty-string $hashAlgorithm The hashing algorithm to use
+     *
+     * @return non-empty-string A binary string
+     *
+     * @psalm-pure
+     */
+    public function generate(UuidInterface $ns, string $name, string $hashAlgorithm): string;
+}

package/vendor/ramsey/uuid/src/Generator/PeclUuidNameGenerator.php

@@ -0,0 +1,52 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Generator;
+
+use Ramsey\Uuid\Exception\NameException;
+use Ramsey\Uuid\UuidInterface;
+
+use function sprintf;
+use function uuid_generate_md5;
+use function uuid_generate_sha1;
+use function uuid_parse;
+
+/**
+ * PeclUuidNameGenerator generates strings of binary data from a namespace and a
+ * name, using ext-uuid
+ *
+ * @link https://pecl.php.net/package/uuid ext-uuid
+ */
+class PeclUuidNameGenerator implements NameGeneratorInterface
+{
+    /**
+     * @inheritDoc
+     * @psalm-pure
+     */
+    public function generate(UuidInterface $ns, string $name, string $hashAlgorithm): string
+    {
+        $uuid = match ($hashAlgorithm) {
+            'md5' => uuid_generate_md5($ns->toString(), $name),
+            'sha1' => uuid_generate_sha1($ns->toString(), $name),
+            default => throw new NameException(
+                sprintf(
+                    'Unable to hash namespace and name with algorithm \'%s\'',
+                    $hashAlgorithm
+                )
+            ),
+        };
+
+        return uuid_parse($uuid) ?: throw new NameException('Unable to generate UUID from ext-uuid');
+    }
+}

package/vendor/ramsey/uuid/src/Generator/PeclUuidRandomGenerator.php

@@ -0,0 +1,37 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Generator;
+
+use Ramsey\Uuid\Exception\NameException;
+
+use function uuid_create;
+use function uuid_parse;
+
+use const UUID_TYPE_RANDOM;
+
+/**
+ * PeclUuidRandomGenerator generates strings of random binary data using ext-uuid
+ *
+ * @link https://pecl.php.net/package/uuid ext-uuid
+ */
+class PeclUuidRandomGenerator implements RandomGeneratorInterface
+{
+    public function generate(int $length): string
+    {
+        $uuid = uuid_create(UUID_TYPE_RANDOM);
+
+        return uuid_parse($uuid) ?: throw new NameException('Unable to generate UUID from ext-uuid');
+    }
+}

package/vendor/ramsey/uuid/src/Generator/PeclUuidTimeGenerator.php

@@ -0,0 +1,39 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Generator;
+
+use Ramsey\Uuid\Exception\NameException;
+use Ramsey\Uuid\Type\Hexadecimal;
+
+use function uuid_create;
+use function uuid_parse;
+
+use const UUID_TYPE_TIME;
+
+/**
+ * PeclUuidTimeGenerator generates strings of binary data for time-base UUIDs,
+ * using ext-uuid
+ *
+ * @link https://pecl.php.net/package/uuid ext-uuid
+ */
+class PeclUuidTimeGenerator implements TimeGeneratorInterface
+{
+    public function generate(Hexadecimal | int | string | null $node = null, ?int $clockSeq = null): string
+    {
+        $uuid = uuid_create(UUID_TYPE_TIME);
+
+        return uuid_parse($uuid) ?: throw new NameException('Unable to generate UUID from ext-uuid');
+    }
+}

package/vendor/ramsey/uuid/src/Generator/RandomBytesGenerator.php

@@ -0,0 +1,45 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Generator;
+
+use Ramsey\Uuid\Exception\RandomSourceException;
+use Throwable;
+
+/**
+ * RandomBytesGenerator generates strings of random binary data using the
+ * built-in `random_bytes()` PHP function
+ *
+ * @link http://php.net/random_bytes random_bytes()
+ */
+class RandomBytesGenerator implements RandomGeneratorInterface
+{
+    /**
+     * @throws RandomSourceException if random_bytes() throws an exception/error
+     *
+     * @inheritDoc
+     */
+    public function generate(int $length): string
+    {
+        try {
+            return random_bytes($length);
+        } catch (Throwable $exception) {
+            throw new RandomSourceException(
+                $exception->getMessage(),
+                (int) $exception->getCode(),
+                $exception
+            );
+        }
+    }
+}

package/vendor/ramsey/uuid/src/Generator/RandomGeneratorFactory.php

@@ -0,0 +1,30 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Generator;
+
+/**
+ * RandomGeneratorFactory retrieves a default random generator, based on the
+ * environment
+ */
+class RandomGeneratorFactory
+{
+    /**
+     * Returns a default random generator, based on the current environment
+     */
+    public function getGenerator(): RandomGeneratorInterface
+    {
+        return new RandomBytesGenerator();
+    }
+}

package/vendor/ramsey/uuid/src/Generator/RandomGeneratorInterface.php

@@ -0,0 +1,31 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Generator;
+
+/**
+ * A random generator generates strings of random binary data
+ */
+interface RandomGeneratorInterface
+{
+    /**
+     * Generates a string of randomized binary data
+     *
+     * @param positive-int $length The number of bytes of random binary data to
+     *     generate
+     *
+     * @return non-empty-string A binary string
+     */
+    public function generate(int $length): string;
+}