create-prisma-php-app 1.0.0

package/vendor/ramsey/uuid/src/Rfc4122/Version.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\Rfc4122;
+
+/**
+ * The version number describes how the UUID was generated
+ *
+ * The version number has the following meaning:
+ *
+ * 1. Time-based UUID
+ * 2. DCE security UUID
+ * 3. Name-based UUID hashed with MD5
+ * 4. Randomly generated UUID
+ * 5. Name-based UUID hashed with SHA-1
+ * 6. Reordered time-based UUID
+ * 7. Unix Epoch time-based UUID
+ * 8. Implementation-specific custom UUID
+ *
+ * @link http://tools.ietf.org/html/rfc4122#section-4.1.3 RFC 4122, § 4.1.3: Version
+ *
+ * phpcs:disable Generic.NamingConventions.UpperCaseConstantName.ClassConstantNotUpperCase
+ */
+enum Version: int
+{
+    /**
+     * Version 1 (time-based) UUID
+     *
+     * @link https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.3 RFC 4122, § 4.1.3
+     */
+    case Time = 1;
+
+    /**
+     * Version 2 (DCE Security) UUID
+     *
+     * @link https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.3 RFC 4122, § 4.1.3
+     */
+    case DceSecurity = 2;
+
+    /**
+     * Version 3 (name-based and hashed with MD5) UUID
+     *
+     * @link https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.3 RFC 4122, § 4.1.3
+     */
+    case HashMd5 = 3;
+
+    /**
+     * Version 4 (random) UUID
+     *
+     * @link https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.3 RFC 4122, § 4.1.3
+     */
+    case Random = 4;
+
+    /**
+     * Version 5 (name-based and hashed with SHA1) UUID
+     *
+     * @link https://datatracker.ietf.org/doc/html/rfc4122#section-4.1.3 RFC 4122, § 4.1.3
+     */
+    case HashSha1 = 5;
+
+    /**
+     * Version 6 (reordered time-based) UUID
+     *
+     * @link https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-04#section-4 draft-peabody-dispatch-new-uuid-format-04, § 4
+     * @link https://github.com/uuid6/uuid6-ietf-draft UUID version 6 IETF draft
+     * @link http://gh.peabody.io/uuidv6/ "Version 6" UUIDs
+     */
+    case ReorderedTime = 6;
+
+    /**
+     * Version 7 (Unix Epoch time-based) UUID
+     *
+     * @link https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-04#section-4 draft-peabody-dispatch-new-uuid-format-04, § 4
+     */
+    case UnixTime = 7;
+
+    /**
+     * Version 8 (implementation-specific custom) UUID
+     *
+     * @link https://datatracker.ietf.org/doc/html/draft-peabody-dispatch-new-uuid-format-04#section-4 draft-peabody-dispatch-new-uuid-format-04, § 4
+     */
+    case Custom = 8;
+
+    /**
+     * Alias for {@see self::Time}
+     */
+    public const V1 = self::Time;
+
+    /**
+     * Alias for {@see self::DceSecurity}
+     */
+    public const V2 = self::DceSecurity;
+
+    /**
+     * Alias for {@see self::HashMd5}
+     */
+    public const V3 = self::HashMd5;
+
+    /**
+     * Alias for {@see self::Random}
+     */
+    public const V4 = self::Random;
+
+    /**
+     * Alias for {@see self::HashSha1}
+     */
+    public const V5 = self::HashSha1;
+
+    /**
+     * Alias for {@see self::ReorderedTime}
+     */
+    public const V6 = self::ReorderedTime;
+
+    /**
+     * Alias for {@see self::UnixTime}
+     */
+    public const V7 = self::UnixTime;
+
+    /**
+     * Alias for {@see self::Custom}
+     */
+    public const V8 = self::Custom;
+
+    /**
+     * Alias for {@see self::ReorderedTime}
+     */
+    public const Peabody = self::ReorderedTime;
+}

package/vendor/ramsey/uuid/src/Rfc4122/VersionTrait.php

@@ -0,0 +1,57 @@
+<?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\Rfc4122;
+
+/**
+ * Provides common functionality for handling the version, as defined by RFC 4122
+ *
+ * @psalm-immutable
+ */
+trait VersionTrait
+{
+    /**
+     * Returns the version
+     */
+    abstract public function getVersion(): ?Version;
+
+    /**
+     * Returns true if these fields represent a max UUID
+     */
+    abstract public function isMax(): bool;
+
+    /**
+     * Returns true if these fields represent a nil UUID
+     */
+    abstract public function isNil(): bool;
+
+    /**
+     * Returns true if the version matches one of those defined by RFC 4122
+     *
+     * @return bool True if the UUID version is valid, false otherwise
+     */
+    private function isCorrectVersion(): bool
+    {
+        if ($this->isNil() || $this->isMax()) {
+            return true;
+        }
+
+        return match ($this->getVersion()) {
+            Version::Time, Version::DceSecurity, Version::HashMd5,
+                Version::Random, Version::HashSha1, Version::ReorderedTime,
+                Version::UnixTime, Version::Custom => true,
+            default => false,
+        };
+    }
+}

package/vendor/ramsey/uuid/src/TimeBasedUuidFactoryInterface.php

@@ -0,0 +1,48 @@
+<?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;
+
+use DateTimeInterface;
+use Ramsey\Uuid\Type\Hexadecimal;
+
+/**
+ * TimeBasedUuidFactoryInterface defines common functionality all factories for
+ * time-based UUIDs must implement
+ *
+ * @psalm-immutable
+ */
+interface TimeBasedUuidFactoryInterface extends UuidFactoryInterface
+{
+    /**
+     * Creates a UUID from a DateTimeInterface instance
+     *
+     * @param DateTimeInterface $dateTime The date and time
+     * @param Hexadecimal|null $node A 48-bit number representing the hardware
+     *     address
+     * @param int<0, 16383>|null $clockSeq A 14-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 UuidInterface A UuidInterface instance that represents a
+     *     UUID created from a DateTimeInterface instance
+     *
+     * @psalm-pure
+     */
+    public function fromDateTime(
+        DateTimeInterface $dateTime,
+        ?Hexadecimal $node = null,
+        ?int $clockSeq = null
+    ): UuidInterface;
+}

package/vendor/ramsey/uuid/src/TimeBasedUuidInterface.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;
+
+use DateTimeInterface;
+
+/**
+ * Time-based UUIDs are derived from a date/time value
+ *
+ * @psalm-immutable
+ */
+interface TimeBasedUuidInterface extends UuidInterface
+{
+    /**
+     * Returns a date object representing the timestamp associated with the UUID
+     */
+    public function getDateTime(): DateTimeInterface;
+}

package/vendor/ramsey/uuid/src/Type/Decimal.php

@@ -0,0 +1,135 @@
+<?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\Type;
+
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use ValueError;
+
+use function abs;
+use function assert;
+use function is_numeric;
+use function sprintf;
+use function str_starts_with;
+
+/**
+ * A value object representing a decimal
+ *
+ * This class exists for type-safety purposes, to ensure that decimals
+ * returned from ramsey/uuid methods as strings are truly decimals and not some
+ * other kind of string.
+ *
+ * To support values as true decimals and not as floats or doubles, we store the
+ * decimals as strings.
+ *
+ * @psalm-immutable
+ */
+final class Decimal implements NumberInterface
+{
+    /**
+     * @var numeric-string
+     */
+    private readonly string $value;
+
+    private bool $isNegative = false;
+
+    public function __construct(float | int | self | string $value)
+    {
+        $this->value = $value instanceof self ? (string) $value : $this->prepareValue($value);
+    }
+
+    public function isNegative(): bool
+    {
+        return $this->isNegative;
+    }
+
+    /**
+     * @return numeric-string
+     */
+    public function toString(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * @return numeric-string
+     */
+    public function __toString(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * @return numeric-string
+     */
+    public function jsonSerialize(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * @return array{string: string}
+     */
+    public function __serialize(): array
+    {
+        return ['string' => $this->value];
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function __unserialize(array $data): void
+    {
+        if (!isset($data['string'])) {
+            throw new ValueError(sprintf('%s(): Argument #1 ($data) is invalid', __METHOD__));
+        }
+
+        assert(is_string($data['string']));
+
+        $this->value = $this->prepareValue($data['string']);
+    }
+
+    /**
+     * @return numeric-string
+     */
+    private function prepareValue(float | int | string $value): string
+    {
+        $value = (string) $value;
+
+        if (!is_numeric($value)) {
+            throw new InvalidArgumentException(
+                'Value must be a signed decimal or a string containing only '
+                . 'digits 0-9 and, optionally, a decimal point or sign (+ or -)'
+            );
+        }
+
+        // Remove the leading +-symbol.
+        if (str_starts_with($value, '+')) {
+            $value = substr($value, 1);
+        }
+
+        // For cases like `-0` or `-0.0000`, convert the value to `0`.
+        if (abs((float) $value) === 0.0) {
+            $value = '0';
+        }
+
+        if (str_starts_with($value, '-')) {
+            $this->isNegative = true;
+        }
+
+        assert(is_numeric($value));
+
+        return $value;
+    }
+}

package/vendor/ramsey/uuid/src/Type/Hexadecimal.php

@@ -0,0 +1,109 @@
+<?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\Type;
+
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use ValueError;
+
+use function preg_match;
+use function sprintf;
+use function str_starts_with;
+use function strtolower;
+use function substr;
+
+/**
+ * A value object representing a hexadecimal number
+ *
+ * This class exists for type-safety purposes, to ensure that hexadecimal numbers
+ * returned from ramsey/uuid methods as strings are truly hexadecimal and not some
+ * other kind of string.
+ *
+ * @psalm-immutable
+ */
+final class Hexadecimal implements TypeInterface
+{
+    /**
+     * @var non-empty-string
+     */
+    private readonly string $value;
+
+    /**
+     * @param non-empty-string|self $value The hexadecimal value to store
+     */
+    public function __construct(self | string $value)
+    {
+        $this->value = $value instanceof self ? (string) $value : $this->prepareValue($value);
+    }
+
+    public function toString(): string
+    {
+        return $this->value;
+    }
+
+    public function __toString(): string
+    {
+        return $this->value;
+    }
+
+    public function jsonSerialize(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * @return array{string: string}
+     */
+    public function __serialize(): array
+    {
+        return ['string' => $this->value];
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function __unserialize(array $data): void
+    {
+        if (!isset($data['string'])) {
+            throw new ValueError(sprintf('%s(): Argument #1 ($data) is invalid', __METHOD__));
+        }
+
+        assert(is_string($data['string']) && $data['string'] !== '');
+
+        $this->value = $this->prepareValue($data['string']);
+    }
+
+    /**
+     * @param non-empty-string $value
+     *
+     * @return non-empty-string
+     */
+    private function prepareValue(string $value): string
+    {
+        $value = strtolower($value);
+
+        if (str_starts_with($value, '0x')) {
+            $value = substr($value, 2);
+        }
+
+        if (!preg_match('/^[A-Fa-f0-9]+$/', $value)) {
+            throw new InvalidArgumentException(
+                'Value must be a hexadecimal number'
+            );
+        }
+
+        /** @var non-empty-string */
+        return $value;
+    }
+}

package/vendor/ramsey/uuid/src/Type/Integer.php

@@ -0,0 +1,145 @@
+<?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\Type;
+
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use ValueError;
+
+use function assert;
+use function is_numeric;
+use function ltrim;
+use function preg_match;
+use function sprintf;
+use function substr;
+
+/**
+ * A value object representing an integer
+ *
+ * This class exists for type-safety purposes, to ensure that integers
+ * returned from ramsey/uuid methods as strings are truly integers and not some
+ * other kind of string.
+ *
+ * To support large integers beyond PHP_INT_MAX and PHP_INT_MIN on both 64-bit
+ * and 32-bit systems, we store the integers as strings.
+ *
+ * @psalm-immutable
+ */
+final class Integer implements NumberInterface
+{
+    /**
+     * @var numeric-string
+     */
+    private readonly string $value;
+
+    private bool $isNegative = false;
+
+    public function __construct(float | int | self | string $value)
+    {
+        $this->value = $value instanceof self ? (string) $value : $this->prepareValue($value);
+    }
+
+    public function isNegative(): bool
+    {
+        return $this->isNegative;
+    }
+
+    /**
+     * @psalm-return numeric-string
+     */
+    public function toString(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * @psalm-return numeric-string
+     */
+    public function __toString(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * @psalm-return numeric-string
+     */
+    public function jsonSerialize(): string
+    {
+        return $this->value;
+    }
+
+    /**
+     * @return array{string: string}
+     */
+    public function __serialize(): array
+    {
+        return ['string' => $this->value];
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function __unserialize(array $data): void
+    {
+        if (!isset($data['string'])) {
+            throw new ValueError(sprintf('%s(): Argument #1 ($data) is invalid', __METHOD__));
+        }
+
+        assert(is_string($data['string']));
+
+        $this->value = $this->prepareValue($data['string']);
+    }
+
+    /**
+     * @return numeric-string
+     */
+    private function prepareValue(float | int | string $value): string
+    {
+        $value = (string) $value;
+        $sign = '+';
+
+        // If the value contains a sign, remove it for digit pattern check.
+        if (str_starts_with($value, '-') || str_starts_with($value, '+')) {
+            $sign = substr($value, 0, 1);
+            $value = substr($value, 1);
+        }
+
+        if (!preg_match('/^\d+$/', $value)) {
+            throw new InvalidArgumentException(
+                'Value must be a signed integer or a string containing only '
+                . 'digits 0-9 and, optionally, a sign (+ or -)'
+            );
+        }
+
+        // Trim any leading zeros.
+        $value = ltrim($value, '0');
+
+        // Set to zero if the string is empty after trimming zeros.
+        if ($value === '') {
+            $value = '0';
+        }
+
+        // Add the negative sign back to the value.
+        if ($sign === '-' && $value !== '0') {
+            $value = $sign . $value;
+
+            /** @psalm-suppress InaccessibleProperty */
+            $this->isNegative = true;
+        }
+
+        assert(is_numeric($value));
+
+        return $value;
+    }
+}

package/vendor/ramsey/uuid/src/Type/NumberInterface.php

@@ -0,0 +1,28 @@
+<?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\Type;
+
+/**
+ * NumberInterface ensures consistency in numeric values returned by ramsey/uuid
+ *
+ * @psalm-immutable
+ */
+interface NumberInterface extends TypeInterface
+{
+    /**
+     * Returns true if this number is less than zero
+     */
+    public function isNegative(): bool;
+}