Chapter 2 code

bin/doctrine-migrations.php

@@ -0,0 +1,8 @@
+#!/usr/bin/env php
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Migrations;
+
+require __DIR__ . '/../vendor/doctrine/migrations/bin/doctrine-migrations.php';

composer.json

@@ -52,7 +52,8 @@
     "autoload": {
         "psr-4": {
             "Light\\App\\": "src/App/src/",
-            "Light\\Page\\": "src/Page/src/"
+            "Light\\Page\\": "src/Page/src/",
+            "Light\\Book\\": "src/Book/src/"
         }
     },
     "autoload-dev": {

config/cli-config.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+use Doctrine\Migrations\Configuration\EntityManager\ExistingEntityManager;
+use Doctrine\Migrations\Configuration\Migration\ConfigurationArray;
+use Doctrine\Migrations\DependencyFactory;
+use Doctrine\ORM\EntityManager;
+
+$container = require 'config/container.php';
+
+$entityManager = $container->get(EntityManager::class);
+$entityManager->getEventManager();
+
+return DependencyFactory::fromEntityManager(
+    new ConfigurationArray($container->get('config')['doctrine']['migrations']),
+    new ExistingEntityManager($entityManager)
+);

config/config.php

@@ -31,6 +31,7 @@
     // Default App module config
     \Light\App\ConfigProvider::class,
     \Light\Page\ConfigProvider::class,
+    \Light\Book\ConfigProvider::class,
 
     // Load application config in a pre-defined order in such a way that local settings
     // overwrite global settings. (Loaded as first to last):

phpcs.xml

@@ -19,5 +19,7 @@
     <file>test</file>
 
     <!-- Include all rules from the Laminas Coding Standard -->
-    <rule ref="LaminasCodingStandard" />
+    <rule ref="LaminasCodingStandard" >
+        <exclude-pattern>src/Migrations/*</exclude-pattern>
+    </rule>
 </ruleset>

src/App/src/ConfigProvider.php

@@ -6,24 +6,72 @@
 
 use Doctrine\ORM\EntityManager;
 use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\Persistence\Mapping\Driver\MappingDriver;
 use Doctrine\Persistence\Mapping\Driver\MappingDriverChain;
 use Dot\Cache\Adapter\ArrayAdapter;
 use Dot\Cache\Adapter\FilesystemAdapter;
 use Light\App\Factory\GetIndexViewHandlerFactory;
 use Light\App\Handler\GetIndexViewHandler;
+use Light\App\Types\UuidType;
 use Mezzio\Application;
-use Ramsey\Uuid\Doctrine\UuidType;
 use Roave\PsrContainerDoctrine\EntityManagerFactory;
+use Symfony\Component\Cache\Adapter\AdapterInterface;
 
 use function getcwd;
 
+/**
+ * @phpstan-type ConfigType array{
+ *      dependencies: DependenciesType,
+ *      doctrine: DoctrineConfigType,
+ * }
+ * @phpstan-type DoctrineConfigType array{
+ *      cache: array{
+ *          array: array{
+ *              class: class-string<AdapterInterface>,
+ *          },
+ *          filesystem: array{
+ *              class: class-string<AdapterInterface>,
+ *              directory: non-empty-string,
+ *              namespace: non-empty-string,
+ *          },
+ *      },
+ *      configuration: array{
+ *          orm_default: array{
+ *              result_cache: non-empty-string,
+ *              metadata_cache: non-empty-string,
+ *              query_cache: non-empty-string,
+ *              hydration_cache: non-empty-string,
+ *              typed_field_mapper: non-empty-string|null,
+ *              second_level_cache: array{
+ *                  enabled: bool,
+ *                  default_lifetime: int,
+ *                  default_lock_lifetime: int,
+ *                  file_lock_region_directory: string,
+ *                  regions: string[],
+ *               },
+ *          },
+ *      },
+ *      driver: array{
+ *          orm_default: array{
+ *              class: class-string<MappingDriver>,
+ *          },
+ *      },
+ *      migrations: array{
+ *          migrations_paths: array<non-empty-string, non-empty-string>,
+ *          all_or_nothing: bool,
+ *          check_database_platform: bool,
+ *      },
+ *      types: array<non-empty-string, class-string>,
+ * }
+ * @phpstan-type DependenciesType array{
+ *       factories: array<class-string|non-empty-string, class-string|non-empty-string>,
+ *       aliases: array<class-string|non-empty-string, class-string|non-empty-string>,
+ * }
+ **/
 class ConfigProvider
 {
     /**
-    @return array{
-     *     dependencies: array<mixed>,
-     *     templates: array<mixed>,
-     * }
+     * @return ConfigType
      */
     public function __invoke(): array
     {
@@ -35,10 +83,7 @@ public function __invoke(): array
     }
 
     /**
-     * @return array{
-     *     delegators: array<class-string, array<class-string>>,
-     *     factories: array<class-string, class-string>,
-     * }
+     * @return DependenciesType
      */
     public function getDependencies(): array
     {
@@ -81,6 +126,9 @@ public function getTemplates(): array
         ];
     }
 
+    /**
+     * @return DoctrineConfigType
+     */
     private function getDoctrineConfig(): array
     {
         return [
@@ -117,6 +165,21 @@ private function getDoctrineConfig(): array
                     'class' => MappingDriverChain::class,
                 ],
             ],
+            'migrations'    => [
+                'table_storage' => [
+                    'table_name'                 => 'doctrine_migration_versions',
+                    'version_column_name'        => 'version',
+                    'version_column_length'      => 191,
+                    'executed_at_column_name'    => 'executed_at',
+                    'execution_time_column_name' => 'execution_time',
+                ],
+                // Modify this line based on where you would like to have you migrations
+                'migrations_paths'        => [
+                    'Migrations' => 'src/Migrations',
+                ],
+                'all_or_nothing'          => true,
+                'check_database_platform' => true,
+            ],
             'types'         => [
                 UuidType::NAME => UuidType::class,
             ],

src/App/src/Entity/AbstractEntity.php

@@ -0,0 +1,106 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Light\App\Entity;
+
+use DateTimeImmutable;
+use Doctrine\ORM\Mapping as ORM;
+use Laminas\Stdlib\ArraySerializableInterface;
+use Ramsey\Uuid\Uuid;
+use Ramsey\Uuid\UuidInterface;
+
+use function is_array;
+use function method_exists;
+use function ucfirst;
+
+#[ORM\MappedSuperclass]
+abstract class AbstractEntity implements ArraySerializableInterface
+{
+    #[ORM\Column(name: 'created', type: 'datetime_immutable', nullable: false)]
+    protected DateTimeImmutable $created;
+
+    #[ORM\Column(name: 'updated', type: 'datetime_immutable', nullable: true)]
+    protected ?DateTimeImmutable $updated = null;
+
+    #[ORM\Id]
+    #[ORM\Column(name: 'id', type: 'uuid', unique: true, nullable: false)]
+    protected UuidInterface $uuid;
+
+    #[ORM\PrePersist]
+    public function created(): void
+    {
+        $this->created = new DateTimeImmutable();
+    }
+
+    #[ORM\PreUpdate]
+    public function touch(): void
+    {
+        $this->updated = new DateTimeImmutable();
+    }
+
+    public function __construct()
+    {
+        $this->uuid = Uuid::uuid7();
+    }
+
+    public function getId(): UuidInterface
+    {
+        return $this->uuid;
+    }
+
+    public function setId(UuidInterface $id): static
+    {
+        $this->uuid = $id;
+
+        return $this;
+    }
+
+    public function getCreated(): ?DateTimeImmutable
+    {
+        return $this->created;
+    }
+
+    public function getCreatedFormatted(string $dateFormat = 'Y-m-d H:i:s'): string
+    {
+        return $this->created->format($dateFormat);
+    }
+
+    public function getUpdated(): ?DateTimeImmutable
+    {
+        return $this->updated;
+    }
+
+    public function getUpdatedFormatted(string $dateFormat = 'Y-m-d H:i:s'): ?string
+    {
+        if ($this->updated instanceof DateTimeImmutable) {
+            return $this->updated->format($dateFormat);
+        }
+
+        return null;
+    }
+
+    /**
+     * @param array<non-empty-string, mixed> $array
+     */
+    public function exchangeArray(array $array): void
+    {
+        foreach ($array as $property => $values) {
+            if (is_array($values)) {
+                $method = 'add' . ucfirst($property);
+                if (! method_exists($this, $method)) {
+                    continue;
+                }
+                foreach ($values as $value) {
+                    $this->$method($value);
+                }
+            } else {
+                $method = 'set' . ucfirst($property);
+                if (! method_exists($this, $method)) {
+                    continue;
+                }
+                $this->$method($values);
+            }
+        }
+    }
+}

src/App/src/Entity/EntityInterface.php

@@ -0,0 +1,21 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Light\App\Entity;
+
+use DateTimeImmutable;
+use Ramsey\Uuid\UuidInterface;
+
+interface EntityInterface
+{
+    public function getId(): UuidInterface;
+
+    public function getCreated(): ?DateTimeImmutable;
+
+    public function getCreatedFormatted(string $dateFormat = 'Y-m-d H:i:s'): string;
+
+    public function getUpdated(): ?DateTimeImmutable;
+
+    public function getUpdatedFormatted(string $dateFormat = 'Y-m-d H:i:s'): ?string;
+}

src/App/src/Repository/AbstractRepository.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Light\App\Repository;
+
+use Doctrine\ORM\EntityRepository;
+use Doctrine\ORM\QueryBuilder;
+use Light\App\Entity\EntityInterface;
+
+/**
+ * @extends EntityRepository<object>
+ */
+class AbstractRepository extends EntityRepository
+{
+    public function deleteResource(EntityInterface $resource): void
+    {
+        $this->getEntityManager()->remove($resource);
+        $this->getEntityManager()->flush();
+    }
+
+    public function getQueryBuilder(): QueryBuilder
+    {
+        return $this->getEntityManager()->createQueryBuilder();
+    }
+
+    public function saveResource(EntityInterface $resource): void
+    {
+        $this->getEntityManager()->persist($resource);
+        $this->getEntityManager()->flush();
+    }
+}