Fix bug where mapped relations wouldn't persist parent config. Add support for controlling relation mapping

Author: SalemC

src/Commands/TypeScriptifyModelCommand.php

@@ -14,7 +14,8 @@ class TypeScriptifyModelCommand extends Command {
      */
     protected $signature = 'typescriptify:model
                                                 {model : The fully qualified class name for the model - e.g. App\Models\User}
-                                                {--includeHidden : Include the protected $hidden properties}';
+                                                {--includeHidden : Include the protected $hidden properties}
+                                                {--includeRelations=true : Map foreign key columns to interface definitions}';
 
     /**
      * The console command description.
@@ -23,14 +24,26 @@ class TypeScriptifyModelCommand extends Command {
      */
     protected $description = 'Convert a model to it\'s TypeScript definition.';
 
+    /**
+     * Cast the `$name` option to a boolean.
+     *
+     * @param string $name
+     *
+     * @return bool
+     */
+    private function boolOption(string $name): bool {
+        return filter_var($this->option($name), FILTER_VALIDATE_BOOLEAN);
+    }
+
     /**
      * Execute the console command.
      *
      * @return int
      */
     public function handle() {
         echo (new TypeScriptifyModel($this->argument('model')))
-            ->includeHidden($this->option('includeHidden'))
+            ->includeHidden($this->boolOption('includeHidden'))
+            ->includeRelations($this->boolOption('includeRelations'))
             ->generate();
 
         return Command::SUCCESS;

src/TypeScriptifyModel.php

@@ -45,10 +45,17 @@ final class TypeScriptifyModel {
     /**
      * Whether to include the model's $hidden properties.
      *
-     * @var bool $includeHidden
+     * @var bool
      */
     private bool $includeHidden = false;
 
+    /**
+     * Whether to map the model's foreign keys to interfaces.
+     *
+     * @var bool
+     */
+    private bool $includeRelations = true;
+
     /**
      * @param string $fullyQualifiedModelName The fully qualified model class name.
      * @param ?array<string,string> $convertedModelsMap The map of `fully qualified model name => interface name` definitions this class can use instead of generating its own definitions.
@@ -282,7 +289,7 @@ private function convertForeignKeyToFullyQualifiedModelName(string $attribute):
      * @return string
      */
     private function getTypeScriptType(stdClass $columnSchema): string {
-        if ($this->isAttributeRelation($columnSchema->Field)) {
+        if ($this->includeRelations && $this->isAttributeRelation($columnSchema->Field)) {
             $fullyQualifiedRelatedModelName = $this->convertForeignKeyToFullyQualifiedModelName($columnSchema->Field);
 
             if (array_key_exists($fullyQualifiedRelatedModelName, $this->convertedModelsMap)) {
@@ -296,7 +303,10 @@ private function getTypeScriptType(stdClass $columnSchema): string {
                 // as many interface definitions for relational attributes as we need.
                 // We pass our existing convertedModelsMap instance here to prevent this class
                 // mapping models we've already mapped in this current class instance.
-                $mappedType = (new self($fullyQualifiedRelatedModelName, $this->convertedModelsMap))->generate();
+                $mappedType = (new self($fullyQualifiedRelatedModelName, $this->convertedModelsMap))
+                    ->includeHidden($this->includeHidden)
+                    ->includeRelations($this->includeRelations)
+                    ->generate();
             }
         } else {
             // If the attribute is natively casted, we'll want to perform native cast checking
@@ -339,6 +349,19 @@ public function includeHidden(bool $includeHidden): self {
         return $this;
     }
 
+    /**
+     * Set whether we should map the model's foreign keys to interfaces.
+     *
+     * @param bool $includeRelations
+     *
+     * @return self
+     */
+    public function includeRelations(bool $includeRelations): self {
+        $this->includeRelations = $includeRelations;
+
+        return $this;
+    }
+
     /**
      * Generate the TypeScript interface.
      *
@@ -363,7 +386,7 @@ public function generate(): string {
             // If this attribute is hidden and we're not including hidden, we'll skip it.
             if (!$this->includeHidden && $this->isAttributeHidden($columnSchema->Field)) return;
 
-            if ($this->isAttributeRelation($columnSchema->Field)) {
+            if ($this->includeRelations && $this->isAttributeRelation($columnSchema->Field)) {
                 $relationName = $this->convertForeignKeyToPredictedRelationName($columnSchema->Field);
                 $generatedTypeScriptType = Str::of($this->getTypeScriptType($columnSchema));
 
@@ -373,7 +396,7 @@ public function generate(): string {
                 $isRelationInterfaceDefinition = $generatedTypeScriptType->startsWith('interface ');
 
                 if ($isRelationInterfaceDefinition) {
-                    // interface User { => User
+                    // `interface User {` => `User`
                     $generatedInterfaceName = $generatedTypeScriptType
                         ->after('interface ')
                         ->before(' {');