create-prisma-php-app 1.0.0

package/vendor/ramsey/uuid/docs/rfc4122/version7.rst

@@ -0,0 +1,173 @@
+.. _rfc4122.version7:
+
+==========================
+Version 7: Unix Epoch Time
+==========================
+
+.. note::
+
+    Version 7, Unix Epoch time UUIDs are a new format of UUID, proposed in an
+    `Internet-Draft under review`_ at the IETF. While the draft is still going
+    through the IETF process, the version 7 format is not expected to change
+    in any way that breaks compatibility.
+
+.. admonition:: ULIDs and Version 7 UUIDs
+    :class: hint
+
+    Version 7 UUIDs are binary-compatible with `ULIDs`_ (universally unique
+    lexicographically-sortable identifiers).
+
+    Both use a 48-bit timestamp in milliseconds since the Unix Epoch, filling
+    the rest with random data. Version 7 UUIDs then add the version and variant
+    bits required by the UUID specification, which reduces the randomness from
+    80 bits to 74. Otherwise, they are identical.
+
+    You may even convert a version 7 UUID to a ULID.
+    :ref:`See below for an example. <rfc4122.version7.ulid>`
+
+Version 7 UUIDs solve `two problems that have long existed`_ with the use of
+:ref:`version 1 <rfc4122.version1>` UUIDs:
+
+1. Scattered database records
+2. Inability to sort by an identifier in a meaningful way (i.e., insert order)
+
+To overcome these issues, we need the ability to generate UUIDs that are
+*monotonically increasing*.
+
+:ref:`Version 6 UUIDs <rfc4122.version6>` provide an excellent solution for
+those who need monotonically increasing, sortable UUIDs with the features of
+version 1 UUIDs (MAC address and clock sequence), but if those features aren't
+necessary for your application, using a version 6 UUID might be overkill.
+
+Version 7 UUIDs combine random data (like version 4 UUIDs) with a timestamp (in
+milliseconds since the Unix Epoch, i.e., 1970-01-01 00:00:00 UTC) to create a
+monotonically increasing, sortable UUID that doesn't have any privacy concerns,
+since it doesn't include a MAC address.
+
+For this reason, implementations should use version 7 UUIDs over versions 1 and
+6, if possible.
+
+.. code-block:: php
+    :caption: Generate a version 7, Unix Epoch time UUID
+    :name: rfc4122.version7.example
+
+    use Ramsey\Uuid\Uuid;
+
+    $uuid = Uuid::uuid7();
+
+    printf(
+        "UUID: %s\nVersion: %d\nDate: %s\n",
+        $uuid->toString(),
+        $uuid->getFields()->getVersion(),
+        $uuid->getDateTime()->format('r'),
+    );
+
+This will generate a version 7 UUID and print out its string representation and
+the time it was created.
+
+It will look something like this:
+
+.. code-block:: text
+
+    UUID: 01833ce0-3486-7bfd-84a1-ad157cf64005
+    Version: 7
+    Date: Wed, 14 Sep 2022 16:41:10 +0000
+
+To use an existing date and time to generate a version 7 UUID, you may pass a
+``\DateTimeInterface`` instance to the ``uuid7()`` method.
+
+.. code-block:: php
+    :caption: Generate a version 7 UUID from an existing date and time
+    :name: rfc4122.version7.example-datetime
+
+    use DateTimeImmutable;
+    use Ramsey\Uuid\Uuid;
+
+    $dateTime = new DateTimeImmutable('@281474976710.655');
+    $uuid = Uuid::uuid7($dateTime);
+
+    printf(
+        "UUID: %s\nVersion: %d\nDate: %s\n",
+        $uuid->toString(),
+        $uuid->getFields()->getVersion(),
+        $uuid->getDateTime()->format('r'),
+    );
+
+Which will print something like this:
+
+.. code-block:: text
+
+    UUID: ffffffff-ffff-7964-a8f6-001336ac20cb
+    Version: 7
+    Date: Tue, 02 Aug 10889 05:31:50 +0000
+
+.. tip::
+
+    Version 7 UUIDs generated in ramsey/uuid are instances of UuidV7. Check out
+    the :php:class:`Ramsey\\Uuid\\Rfc4122\\UuidV7` API documentation to learn
+    more about what you can do with a UuidV7 instance.
+
+
+.. _rfc4122.version7.ulid:
+
+Convert a Version 7 UUID to a ULID
+##################################
+
+As mentioned in the callout above, version 7 UUIDs are binary-compatible with
+`ULIDs`_. This means you can encode a version 7 UUID using `Crockford's Base 32
+algorithm`_ and it will be a valid ULID, timestamp and all.
+
+Using the third-party library `tuupola/base32`_, here's how we can encode a
+version 7 UUID as a ULID. Note that there's a little bit of work to perform the
+conversion, since you're working with different bases.
+
+.. code-block:: php
+    :caption: Encode a version 7, Unix Epoch time UUID as a ULID
+    :name: rfc4122.version7.example-ulid
+
+    use Ramsey\Uuid\Uuid;
+    use Tuupola\Base32;
+
+    $crockford = new Base32([
+        'characters' => Base32::CROCKFORD,
+        'padding' => false,
+        'crockford' => true,
+    ]);
+
+    $uuid = Uuid::uuid7();
+
+    // First, we must pad the 16-byte string to 20 bytes
+    // for proper conversion without data loss.
+    $bytes = str_pad($uuid->getBytes(), 20, "\x00", STR_PAD_LEFT);
+
+    // Use Crockford's Base 32 encoding algorithm.
+    $encoded = $crockford->encode($bytes);
+
+    // That 20-byte string was encoded to 32 characters to avoid loss
+    // of data. We must strip off the first 6 characters--which are
+    // all zeros--to get a valid 26-character ULID string.
+    $ulid = substr($encoded, 6);
+
+    printf("ULID: %s\n", $ulid);
+
+This will print something like this:
+
+.. code-block:: text
+
+    ULID: 01GCZ05N3JFRKBRWKNGCQZGP44
+
+.. caution::
+
+    Be aware that all version 7 UUIDs may be converted to ULIDs but not all
+    ULIDs may be converted to UUIDs.
+
+    For that matter, all UUIDs of any version may be encoded as ULIDs, but they
+    will not be monotonically increasing and sortable unless they are version 7
+    UUIDs. You will also not be able to extract a meaningful timestamp from the
+    ULID, unless it was converted from a version 7 UUID.
+
+.. _ULIDs: https://github.com/ulid/spec
+.. _Internet-Draft under review: https://datatracker.ietf.org/doc/html/draft-ietf-uuidrev-rfc4122bis-00#section-5.7
+.. _two problems that have long existed: https://www.percona.com/blog/2014/12/19/store-uuid-optimized-way/
+.. _Crockford's Base 32 algorithm: https://www.crockford.com/base32.html
+.. _tuupola/base32: https://packagist.org/packages/tuupola/base32

package/vendor/ramsey/uuid/docs/rfc4122/version8.rst

@@ -0,0 +1,51 @@
+.. _rfc4122.version8:
+
+=================
+Version 8: Custom
+=================
+
+.. note::
+
+    Version 8, custom UUIDs are a new format of UUID, proposed in an
+    `Internet-Draft under review`_ at the IETF. While the draft is still going
+    through the IETF process, the version 8 format is not expected to change
+    in any way that breaks compatibility.
+
+Version 8 UUIDs allow applications to create custom UUIDs in an RFC-compatible
+way. The only requirement is the version and variant bits must be set according
+to the UUID specification. The bytes provided may contain any value according to
+your application's needs. Be aware, however, that other applications may not
+understand the semantics of the value.
+
+.. warning::
+
+    The bytes should be a 16-byte octet string, an open blob of data that you
+    may fill with 128 bits of information. However, bits 48 through 51 will be
+    replaced with the UUID version field, and bits 64 and 65 will be replaced
+    with the UUID variant. You must not rely on these bits for your application
+    needs.
+
+.. code-block:: php
+    :caption: Generate a version 8, custom UUID
+    :name: rfc4122.version8.example
+
+    use Ramsey\Uuid\Uuid;
+
+    $uuid = Uuid::uuid8("\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xaa\xbb\xcc\xdd\xee\xff");
+
+    printf(
+        "UUID: %s\nVersion: %d\n",
+        $uuid->toString(),
+        $uuid->getFields()->getVersion()
+    );
+
+This will generate a version 8 UUID and print out its string representation.
+It will look something like this:
+
+.. code-block:: text
+
+    UUID: 00112233-4455-8677-8899-aabbccddeeff
+    Version: 8
+
+
+.. _Internet-Draft under review: https://datatracker.ietf.org/doc/html/draft-ietf-uuidrev-rfc4122bis-00#section-5.8

package/vendor/ramsey/uuid/docs/rfc4122.rst

@@ -0,0 +1,67 @@
+.. _rfc4122:
+
+==============
+RFC 4122 UUIDs
+==============
+
+.. toctree::
+    :titlesonly:
+    :hidden:
+
+    rfc4122/version1
+    rfc4122/version2
+    rfc4122/version3
+    rfc4122/version4
+    rfc4122/version5
+    rfc4122/version6
+    rfc4122/version7
+    rfc4122/version8
+
+`RFC 4122`_ defines five versions of UUID, while a `new Internet-Draft under
+review`_ defines three new versions. Each version has different generation
+algorithms and properties. Which one you choose depends on your use-case. You
+can find out more about their applications on the specific page for that version.
+
+Version 1: Gregorian Time
+    This version of UUID combines a timestamp, node value (in the form of a MAC
+    address from the local computer's network interface), and a clock sequence
+    to ensure uniqueness. For more details, see :doc:`rfc4122/version1`.
+
+Version 2: DCE Security
+    This version of UUID is the same as Version 1, except the ``clock_seq_low``
+    field is replaced with a *local domain* and the ``time_low`` field is
+    replaced with a *local identifier*. For more details, see
+    :doc:`rfc4122/version2`.
+
+Version 3: Name-based (MD5)
+    This version of UUID hashes together a namespace and a name to create a
+    deterministic UUID. The hashing algorithm used is MD5. For more details, see
+    :doc:`rfc4122/version3`.
+
+Version 4: Random
+    This version creates a UUID using truly-random or pseudo-random numbers. For
+    more details, see :doc:`rfc4122/version4`.
+
+Version 5: Named-based (SHA-1)
+    This version of UUID hashes together a namespace and a name to create a
+    deterministic UUID. The hashing algorithm used is SHA-1. For more details,
+    see :doc:`rfc4122/version5`.
+
+Version 6: Reordered Time
+    This version of UUID combines the features of a
+    :ref:`version 1 UUID <rfc4122.version1>` with a *monotonically increasing*
+    UUID. For more details, see :ref:`rfc4122.version6`.
+
+Version 7: Unix Epoch Time
+    This version of UUID combines a timestamp--based on milliseconds elapsed
+    since the Unix Epoch--and random bytes to create a monotonically increasing,
+    sortable UUID without the privacy and entropy concerns associated with
+    version 1 and version 6 UUIDs. For more details, see :ref:`rfc4122.version7`.
+
+Version 8: Custom
+    This version of UUID allows applications to generate custom identifiers in
+    an RFC-compatible format. For more details, see :doc:`rfc4122/version8`.
+
+
+.. _RFC 4122: https://tools.ietf.org/html/rfc4122
+.. _new Internet-Draft under review: https://datatracker.ietf.org/doc/html/draft-ietf-uuidrev-rfc4122bis-00

package/vendor/ramsey/uuid/docs/testing.rst

@@ -0,0 +1,199 @@
+.. _testing:
+
+==================
+Testing With UUIDs
+==================
+
+One problem with the use of ``final`` is the inability to create a `mock object`_
+to use in tests. However, the following techniques should help with testing.
+
+.. tip::
+
+    To learn why ramsey/uuid uses ``final``, take a look at :ref:`faq.final`.
+
+
+.. _testing.inject:
+
+Inject a UUID of a Specific Type
+--------------------------------
+
+Let's say we have a method that uses a type hint for :php:class:`UuidV1
+<Ramsey\\Uuid\\Rfc4122\\UuidV1>`.
+
+.. code-block:: php
+
+    public function tellTime(UuidV1 $uuid): string
+    {
+        return $uuid->getDateTime()->format('Y-m-d H:i:s');
+    }
+
+Since this method uses UuidV1 as the type hint, we're not able to pass another
+object that implements UuidInterface, and we cannot extend or mock UuidV1, so
+how do we test this?
+
+One way is to use :php:meth:`Uuid::uuid1() <Ramsey\\Uuid\\Uuid::uuid1>` to
+create a regular UuidV1 instance and pass it.
+
+.. code-block:: php
+
+    public function testTellTime(): void
+    {
+        $uuid = Uuid::uuid1();
+        $myObj = new MyClass();
+
+        $this->assertIsString($myObj->tellTime($uuid));
+    }
+
+This might satisfy our testing needs if we only want to assert that the method
+returns a string. If we want to test for a specific string, we can do that, too,
+by generating a UUID ahead of time and using it as a known value.
+
+.. code-block:: php
+
+    public function testTellTime(): void
+    {
+        // We generated this version 1 UUID ahead of time and know the
+        // exact date and time it contains, so we can use it to test the
+        // return value of our method.
+        $uuid = Uuid::fromString('177ef0d8-6630-11ea-b69a-0242ac130003');
+        $myObj = new MyClass();
+
+        $this->assertSame('2020-03-14 20:12:12', $myObj->tellTime($uuid));
+    }
+
+.. note::
+
+    These examples assume the use of `PHPUnit`_ for tests. The concepts will
+    work no matter what testing framework you use.
+
+
+.. _testing.static:
+
+Returning Specific UUIDs From a Static Method
+---------------------------------------------
+
+Sometimes, rather than pass UUIDs as method arguments, we might call the static
+methods on the Uuid class from inside the method we want to test. This can be
+tricky to test.
+
+.. code-block:: php
+
+    public function tellTime(): string
+    {
+        $uuid = Uuid::uuid1();
+
+        return $uuid->getDateTime()->format('Y-m-d H:i:s');
+    }
+
+We can call this in a test and assert that it returns a string, but we can't
+return a specific UUID value from the static method call --- or can we?
+
+We can do this by :ref:`overriding the default factory <customize.factory>`.
+
+First, we create our own factory class for testing. In this example, we extend
+UuidFactory, but you may create your own separate factory class for testing, as
+long as you implement :php:interface:`Ramsey\\Uuid\\UuidFactoryInterface`.
+
+.. code-block:: php
+
+    namespace MyPackage;
+
+    use Ramsey\Uuid\UuidFactory;
+    use Ramsey\Uuid\UuidInterface;
+
+    class MyTestUuidFactory extends UuidFactory
+    {
+        public $uuid1;
+
+        public function uuid1($node = null, ?int $clockSeq = null): UuidInterface
+        {
+            return $this->uuid1;
+        }
+    }
+
+Now, from our tests, we can replace the default factory with our new factory,
+and we can even change the value returned by the :php:meth:`uuid1()
+<Ramsey\\Uuid\\UuidFactoryInterface::uuid1>` method for our tests.
+
+.. code-block:: php
+
+    /**
+     * @runInSeparateProcess
+     * @preserveGlobalState disabled
+     */
+    public function testTellTime(): void
+    {
+        $factory = new MyTestUuidFactory();
+        Uuid::setFactory($factory);
+
+        $myObj = new MyClass();
+
+        $factory->uuid1 = Uuid::fromString('177ef0d8-6630-11ea-b69a-0242ac130003');
+        $this->assertSame('2020-03-14 20:12:12', $myObj->tellTime());
+
+        $factory->uuid1 = Uuid::fromString('13814000-1dd2-11b2-9669-00007ffffffe');
+        $this->assertSame('1970-01-01 00:00:00', $myObj->tellTime());
+    }
+
+.. attention::
+
+    The factory is a static property on the Uuid class. By replacing it like
+    this, all uses of the Uuid class after this point will continue to use the
+    new factory. This is why we must run the test in a separate process.
+    Otherwise, this could cause other tests to fail.
+
+    Running tests in separate processes can significantly slow down your tests,
+    so try to use this technique sparingly, and if possible, pass your
+    dependencies to your objects, rather than creating (or fetching them) from
+    within. This makes testing easier.
+
+
+.. _testing.mock:
+
+Mocking UuidInterface
+---------------------
+
+Another technique for testing with UUIDs is to mock
+:php:interface:`UuidInterface <Ramsey\\Uuid\\UuidInterface>`.
+
+Consider a method that accepts a UuidInterface.
+
+.. code-block:: php
+
+    public function tellTime(UuidInterface $uuid): string
+    {
+        return $uuid->getDateTime()->format('Y-m-d H:i:s');
+    }
+
+We can mock UuidInterface, passing that mocked value into this method. Then, we
+can make assertions about what methods were called on the mock object. In the
+following example test, we don't care whether the return value matches an
+actual date format. What we care about is that the methods on the UuidInterface
+object were called.
+
+.. code-block:: php
+
+    public function testTellTime(): void
+    {
+        $dateTime = Mockery::mock(DateTime::class);
+        $dateTime->expects()->format('Y-m-d H:i:s')->andReturn('a test date');
+
+        $uuid = Mockery::mock(UuidInterface::class, [
+            'getDateTime' => $dateTime,
+        ]);
+
+        $myObj = new MyClass();
+
+        $this->assertSame('a test date', $myObj->tellTime($uuid));
+    }
+
+.. note::
+
+    One of my favorite mocking libraries is `Mockery`_, so that's what I use in
+    these examples. However, other mocking libraries exist, and PHPUnit provides
+    built-in mocking capabilities.
+
+
+.. _mock object: https://en.wikipedia.org/wiki/Mock_object
+.. _PHPUnit: https://phpunit.de
+.. _Mockery: https://github.com/mockery/mockery

package/vendor/ramsey/uuid/docs/tidelift.rst

@@ -0,0 +1,74 @@
+.. role:: btn-info
+    :class: btn btn-info
+
+.. role:: btn-neutral
+    :class: btn btn-neutral
+
+.. |nbsp| unicode:: 0xA0
+    :trim:
+
+.. |Learn More| replace:: :btn-neutral:`Learn More`
+.. _Learn More: https://tidelift.com/subscription/pkg/packagist-ramsey-uuid?utm_source=undefined&utm_medium=referral&utm_campaign=enterprise
+.. |Request a Demo| replace:: :btn-info:`Request a Demo`
+.. _Request a Demo: https://tidelift.com/subscription/request-a-demo?utm_source=undefined&utm_medium=referral&utm_campaign=enterprise
+
+.. _tidelift:
+
+==========================
+ramsey/uuid for Enterprise
+==========================
+
+.. rubric:: Available as part of the Tidelift Subscription
+
+Tidelift is working with the maintainers of ramsey/uuid and thousands of other
+open source projects to deliver commercial support and maintenance for the open
+source dependencies you use to build your applications. Save time, reduce risk,
+and improve code health, while paying the maintainers of the exact dependencies
+you use.
+
+.. centered:: |Learn More|_ |nbsp| |nbsp| |nbsp| |Request a Demo|_
+
+.. rubric:: Enterprise-ready open source software --- managed for you
+
+The Tidelift Subscription is a managed open source subscription for application
+dependencies covering millions of open source projects across JavaScript,
+Python, Java, PHP, Ruby, .NET, and more.
+
+Your subscription includes:
+
+Security updates
+    Tidelift’s security response team coordinates patches for new breaking
+    security vulnerabilities and alerts immediately through a private channel,
+    so your software supply chain is always secure.
+
+Licensing verification and indemnification
+    Tidelift verifies license information to enable easy policy enforcement and
+    adds intellectual property indemnification to cover creators and users in
+    case something goes wrong. You always have a 100% up-to-date bill of
+    materials for your dependencies to share with your legal team, customers,
+    or partners.
+
+Maintenance and code improvement
+    Tidelift ensures the software you rely on keeps working as long as you need
+    it to work. Your managed dependencies are actively maintained and we recruit
+    additional maintainers where required.
+
+Package selection and version guidance
+    We help you choose the best open source packages from the start—and then
+    guide you through updates to stay on the best releases as new issues arise.
+
+Roadmap input
+    Take a seat at the table with the creators behind the software you use.
+    Tidelift’s participating maintainers earn more income as their software is
+    used by more subscribers, so they’re interested in knowing what you need.
+
+Tooling and cloud integration
+    Tidelift works with GitHub, GitLab, BitBucket, and more. We support every
+    cloud platform (and other deployment targets, too).
+
+The end result? All of the capabilities you expect from commercial-grade
+software, for the full breadth of open source you use. That means less time
+grappling with esoteric open source trivia, and more time building your own
+applications—and your business.
+
+.. centered:: |Learn More|_ |nbsp| |nbsp| |nbsp| |Request a Demo|_

package/vendor/ramsey/uuid/docs/upgrading/2-to-3.rst

@@ -0,0 +1,31 @@
+.. _upgrading.2-to-3:
+
+==============
+Version 2 to 3
+==============
+
+While we have made significant internal changes to the library, we have made
+every effort to ensure a seamless upgrade path from the 2.x series of this
+library to 3.x.
+
+One major breaking change is the transition from the ``Rhumsaa`` root namespace
+to ``Ramsey``. In most cases, all you will need is to change the namespace to
+``Ramsey`` in your code, and everything will "just work."
+
+.. note::
+    For more details on the namespace change, including reasons for the change,
+    read the blog post "`Introducing ramsey/uuid
+    <https://benramsey.com/blog/2016/04/ramsey-uuid/>`_".
+
+Here are full details on the breaking changes to the public API of this library:
+
+1. All namespace references of ``Rhumsaa`` have changed to ``Ramsey``. Simply
+   change the namespace to ``Ramsey`` in your code and everything should work.
+2. The console application has moved to
+   `ramsey/uuid-console <https://packagist.org/packages/ramsey/uuid-console>`_.
+   If using the console functionality, use Composer to require
+   ``ramsey/uuid-console``.
+3. The Doctrine field type mapping has moved to
+   `ramsey/uuid-doctrine <https://packagist.org/packages/ramsey/uuid-doctrine>`_.
+   If using the Doctrine functionality, use Composer to require
+   ``ramsey/uuid-doctrine``.