Add schema properties as class properties for stronger type system

packages/framework/src/Console/Commands/MakePublicationTypeCommand.php

@@ -6,7 +6,7 @@
 
 use Exception;
 use Hyde\Console\Commands\Interfaces\CommandHandleInterface;
-use Hyde\Framework\Actions\CreatesNewPublicationTypeSchema;
+use Hyde\Framework\Actions\CreatesNewPublicationType;
 use Hyde\Framework\Features\Publications\PublicationHelper;
 use InvalidArgumentException;
 use LaravelZero\Framework\Commands\Command;
@@ -60,10 +60,10 @@ public function handle(): int
             2 => 'DESC',
         };
 
-        $pagesize = (int) PublicationHelper::askWithValidation(
+        $pageSize = (int) PublicationHelper::askWithValidation(
             $this,
-            'pagesize',
-            'Enter the pagesize (0 for no limit)',
+            'pageSize',
+            'Enter the pageSize (0 for no limit)',
             ['required', 'integer', 'between:0,100'],
             25
         );
@@ -86,14 +86,16 @@ public function handle(): int
         $canonicalField = $fields[$selected - 1]['name'];
 
         try {
-            $creator = new CreatesNewPublicationTypeSchema($title, $fields, $canonicalField, $sortField, $sortDirection, $pagesize, $prevNextLinks);
+            $creator = new CreatesNewPublicationType($title, $fields, $canonicalField, $sortField, $sortDirection, $pageSize, $prevNextLinks, $this->output);
             $creator->create();
         } catch (Exception $e) {
             $this->error('Error: '.$e->getMessage().' at '.$e->getFile().':'.$e->getLine());
 
             return Command::FAILURE;
         }
 
+        $this->info('Publication type created successfully!');
+
         return Command::SUCCESS;
     }
 

packages/framework/src/Foundation/PageCollection.php

@@ -24,6 +24,9 @@
  * This class is stored as a singleton in the HydeKernel.
  * You would commonly access it via one of the facades:
  *
+ * @todo We could improve this by catching exceptions and rethrowing them using a
+ *       DiscoveryException to make it clear that the problem is with the discovery process.
+ *
  * @see \Hyde\Foundation\Facades\PageCollection
  * @see \Hyde\Hyde::pages()
  */

packages/framework/src/Framework/Actions/CreatesNewPublicationType.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Hyde\Framework\Actions;
+
+use Hyde\Framework\Actions\Interfaces\CreateActionInterface;
+use Hyde\Framework\Features\Publications\Models\PublicationType;
+use Hyde\Framework\Features\Publications\PublicationHelper;
+use Hyde\Hyde;
+use Illuminate\Console\OutputStyle;
+use Rgasch\Collection\Collection;
+use function sprintf;
+
+/**
+ * Scaffold a new publication type schema.
+ *
+ * @see \Hyde\Framework\Testing\Feature\Actions\CreatesNewPublicationTypeSchemaTest
+ */
+class CreatesNewPublicationType implements CreateActionInterface
+{
+    protected string $result;
+
+    public function __construct(
+        protected string $name,
+        protected Collection $fields,
+        protected string $canonicalField,
+        protected string $sortField,
+        protected string $sortDirection,
+        protected int $pageSize,
+        protected bool $prevNextLinks,
+        protected ?OutputStyle $output = null,
+    ) {
+    }
+
+    public function create(): void
+    {
+        $dirName = PublicationHelper::formatNameForStorage($this->name);
+        $outFile = Hyde::path("$dirName/schema.json");
+
+        $type = new PublicationType(
+            $this->name,
+            $this->canonicalField,
+            $this->sortField,
+            $this->sortDirection,
+            $this->pageSize,
+            $this->prevNextLinks,
+            "{$dirName}_detail",
+            "{$dirName}_list",
+            $this->fields->toArray()
+        );
+
+        $this->output?->writeln(sprintf('Saving publication data to [%s]', Hyde::pathToRelative($outFile)));
+
+        $type->save($outFile);
+        $this->result = $type->toJson();
+    }
+
+    public function getResult(): string
+    {
+        return $this->result;
+    }
+}

packages/framework/src/Framework/Features/Publications/Models/PublicationListPage.php

@@ -9,6 +9,7 @@
 use Hyde\Hyde;
 use Hyde\Pages\BladePage;
 use Illuminate\Support\Facades\Blade;
+use InvalidArgumentException;
 use function str_contains;
 use function view;
 
@@ -37,14 +38,19 @@ public function compile(): string
             'publications' => PublicationHelper::getPublicationsForPubType($this->type),
         ];
 
-        $template = $this->type->getSchema()['listTemplate'];
+        $template = $this->type->listTemplate;
         if (str_contains($template, '::')) {
             return view($template, $data)->render();
         }
 
         // Using the Blade facade we can render any file without having to register the directory with the view finder.
+        $viewPath = Hyde::path("{$this->type->getDirectory()}/$template").'.blade.php';
+        if (! file_exists($viewPath)) {
+            throw new InvalidArgumentException("View [$viewPath] not found.");
+        }
+
         return Blade::render(
-            file_get_contents(Hyde::path("{$this->type->getDirectory()}/$template").'.blade.php'), $data
+            file_get_contents($viewPath), $data
         );
     }
 

packages/framework/src/Framework/Features/Publications/Models/PublicationType.php

@@ -4,50 +4,122 @@
 
 namespace Hyde\Framework\Features\Publications\Models;
 
+use function dirname;
+use Exception;
+use function file_get_contents;
+use Hyde\Framework\Concerns\InteractsWithDirectories;
 use Hyde\Hyde;
+use Hyde\Support\Concerns\JsonSerializesArrayable;
+use Illuminate\Contracts\Support\Arrayable;
+use Illuminate\Contracts\Support\Jsonable;
+use Illuminate\Support\Str;
+use function json_decode;
+use JsonSerializable;
+use RuntimeException;
 
-class PublicationType
+/**
+ * @see \Hyde\Framework\Testing\Feature\PublicationTypeTest
+ */
+class PublicationType implements JsonSerializable, Jsonable, Arrayable
 {
-    protected string $schemaFile;
+    use JsonSerializesArrayable;
+    use InteractsWithDirectories;
+
     protected string $directory;
-    protected array $schema;
 
-    public static function get(string $name): self
+    public string $name;
+    public string $canonicalField;
+    public string $sortField;
+    public string $sortDirection;
+    public int $pageSize;
+    public bool $prevNextLinks;
+    public string $detailTemplate;
+    public string $listTemplate;
+    public array $fields;
+
+    public static function get(string $name): static
+    {
+        return static::fromFile(Hyde::path("$name/schema.json"));
+    }
+
+    public static function fromFile(string $schemaFile): static
+    {
+        try {
+            return new static(...array_merge(
+                static::parseSchemaFile($schemaFile),
+                static::getRelativeDirectoryName($schemaFile))
+            );
+        } catch (Exception $exception) {
+            throw new RuntimeException("Could not parse schema file $schemaFile", 0, $exception);
+        }
+    }
+
+    public function __construct(string $name, string $canonicalField, string $sortField, string $sortDirection, int $pageSize, bool $prevNextLinks, string $detailTemplate, string $listTemplate, array $fields, ?string $directory = null)
     {
-        return new self(Hyde::path("$name/schema.json"));
+        $this->name = $name;
+        $this->canonicalField = $canonicalField;
+        $this->sortField = $sortField;
+        $this->sortDirection = $sortDirection;
+        $this->pageSize = $pageSize;
+        $this->prevNextLinks = $prevNextLinks;
+        $this->detailTemplate = $detailTemplate;
+        $this->listTemplate = $listTemplate;
+        $this->fields = $fields;
+
+        if ($directory) {
+            $this->directory = $directory;
+        }
     }
 
-    public function __construct(string $schemaFile)
+    public function toArray(): array
     {
-        $this->schemaFile = $schemaFile;
-        $this->directory = Hyde::pathToRelative(dirname($schemaFile));
-        $this->schema = static::parseSchema($schemaFile);
+        return [
+            'name' => $this->name,
+            'canonicalField' => $this->canonicalField,
+            'sortField' => $this->sortField,
+            'sortDirection' => $this->sortDirection,
+            'pageSize' => $this->pageSize,
+            'prevNextLinks' => $this->prevNextLinks,
+            'detailTemplate' => $this->detailTemplate,
+            'listTemplate' => $this->listTemplate,
+            'fields' => $this->fields,
+        ];
     }
 
-    public function __get(string $name): mixed
+    public function toJson($options = JSON_PRETTY_PRINT): string
     {
-        return $this->$name ?? $this->schema[$name] ?? null;
+        return json_encode($this->toArray(), $options);
+    }
+
+    public function getIdentifier(): string
+    {
+        return $this->directory ?? Str::slug($this->name);
     }
 
     public function getSchemaFile(): string
     {
-        return $this->schemaFile;
+        return "$this->directory/schema.json";
     }
 
     public function getDirectory(): string
     {
         return $this->directory;
     }
 
-    public function getSchema(): array
+    public function save(?string $path = null): void
     {
-        return $this->schema;
+        $path ??= $this->getSchemaFile();
+        $this->needsParentDirectory($path);
+        file_put_contents($path, json_encode($this->toArray(), JSON_PRETTY_PRINT));
     }
 
-    protected static function parseSchema(string $schemaFile): array
+    protected static function parseSchemaFile(string $schemaFile): array
     {
         return json_decode(file_get_contents($schemaFile), true, 512, JSON_THROW_ON_ERROR);
     }
 
-    // TODO build list pages and detail pages for each publication type
+    protected static function getRelativeDirectoryName(string $schemaFile): array
+    {
+        return ['directory' => Hyde::pathToRelative(dirname($schemaFile))];
+    }
 }

packages/framework/src/Framework/Features/Publications/PublicationHelper.php

@@ -72,7 +72,7 @@ public static function getPublicationTypes(): Collection
 
         $pubTypes = Collection::create();
         foreach ($schemaFiles as $schemaFile) {
-            $publicationType = new PublicationType($schemaFile);
+            $publicationType = PublicationType::fromFile($schemaFile);
             $pubTypes->{$publicationType->getDirectory()} = $publicationType;
         }
 
@@ -87,7 +87,7 @@ public static function getPublicationTypes(): Collection
     public static function getPublicationsForPubType(PublicationType $pubType, $sort = true): Collection
     {
         $root = base_path();
-        $files = glob("$root/{$pubType->directory}/*.md");
+        $files = glob("$root/{$pubType->getDirectory()}/*.md");
 
         $publications = Collection::create();
         foreach ($files as $file) {
@@ -109,7 +109,7 @@ public static function getPublicationsForPubType(PublicationType $pubType, $sort
     public static function getMediaForPubType(PublicationType $pubType, $sort = true): Collection
     {
         $root = Hyde::path();
-        $files = glob("$root/_media/{$pubType->directory}/*.{jpg,jpeg,png,gif,pdf}", GLOB_BRACE);
+        $files = glob("$root/_media/{$pubType->getDirectory()}/*.{jpg,jpeg,png,gif,pdf}", GLOB_BRACE);
 
         $media = Collection::create();
         foreach ($files as $file) {

packages/framework/src/Pages/PublicationPage.php

@@ -47,7 +47,7 @@ protected function renderComponent(): string
             'publication' => $this,
         ];
 
-        $template = $this->type->getSchema()['detailTemplate'];
+        $template = $this->type->detailTemplate;
         if (str_contains($template, '::')) {
             return view($template, $data)->render();
         }