Merge pull request #10 from SalemC/7-resolve-relation-infinite-loop

Resolve relation infinite loop

Author: SalemC

src/TypeScriptifyModel.php

@@ -51,10 +51,24 @@ final class TypeScriptifyModel {
 
     /**
      * @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.
      */
     public function __construct(
-        private readonly string $fullyQualifiedModelName,
+        private string $fullyQualifiedModelName,
+        private ?array &$convertedModelsMap = []
     ) {
+        // For consistency in comparisons that happen throughout the lifecycle of this class,
+        // we need all fully qualified model names to have a leading \.
+        $this->fullyQualifiedModelName = Str::of($fullyQualifiedModelName)->start('\\')->toString();
+
+        if (!$this->hasValidModel()) {
+            throw new Exception('That\'s not a valid model!');
+        }
+
+        if (!$this->hasSupportedDatabaseConnection()) {
+            throw new Exception('Your database connection is currently unsupported! The following database connections are supported: ' . implode(', ', self::SUPPORTED_DATABASE_CONNECTIONS));
+        }
+
         $this->model = new $fullyQualifiedModelName;
 
         $this->modelForeignKeyConstraints = collect(
@@ -171,11 +185,13 @@ private function mapNativeCastToTypeScriptType(string $attribute): string {
     /**
      * Map a database column type to a TypeScript type.
      *
-     * @param \Illuminate\Support\Stringable $columnType
+     * @param string $columnType
      *
      * @return string
      */
-    private function mapDatabaseTypeToTypeScriptType(Stringable $columnType): string {
+    private function mapDatabaseTypeToTypeScriptType(string $columnType): string {
+        $columnType = Str::of($columnType);
+
         return match (true) {
             $columnType->startsWith('bit') => 'number',
             $columnType->startsWith('int') => 'number',
@@ -266,22 +282,29 @@ private function convertForeignKeyToFullyQualifiedModelName(string $attribute):
      * @return string
      */
     private function getTypeScriptType(stdClass $columnSchema): string {
-        $columnType = Str::of($columnSchema->Type);
-
         if ($this->isAttributeRelation($columnSchema->Field)) {
             $fullyQualifiedRelatedModelName = $this->convertForeignKeyToFullyQualifiedModelName($columnSchema->Field);
 
-            // We generate new interfaces for any relational attributes.
-            // That means we can recursively instantiate the current class to generate
-            // as many interface definitions for relational attributes as we need.
-            $mappedType = (new self($fullyQualifiedRelatedModelName))->generate();
+            if (array_key_exists($fullyQualifiedRelatedModelName, $this->convertedModelsMap)) {
+                // If we've already mapped this model to a TypeScript interface definition,
+                // we don't want to scan it again, otherwise we could potentially cause
+                // an infinite mapping loop.
+                $mappedType = $this->convertedModelsMap[$fullyQualifiedRelatedModelName];
+            } else {
+                // We generate new interfaces for any relational attributes.
+                // That means we can recursively instantiate the current class to generate
+                // 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();
+            }
         } else {
             // If the attribute is natively casted, we'll want to perform native cast checking
             // to generate the correct TypeScript type. If it's not natively casted, we can
             // simply map the database type to a TypeScript type.
             $mappedType = $this->isAttributeNativelyCasted($columnSchema->Field)
                 ? $this->mapNativeCastToTypeScriptType($columnSchema->Field)
-                : $this->mapDatabaseTypeToTypeScriptType($columnType);
+                : $this->mapDatabaseTypeToTypeScriptType($columnSchema->Type);
         }
 
         // We can't do much with an unknown type.
@@ -303,56 +326,6 @@ private function convertForeignKeyToPredictedRelationName(string $attribute): st
         return Str::of($attribute)->replaceLast('_id', '')->camel();
     }
 
-    /**
-     * Generate the interface.
-     *
-     * @return string
-     */
-    private function generateInterface(): string {
-        $tableColumns = collect(DB::select(DB::raw('SHOW COLUMNS FROM ' . $this->model->getTable())));
-
-        $outputBuffer = collect([
-            // The output buffer always needs to start with the first `interface X {` line.
-            sprintf('interface %s {', Str::of($this->fullyQualifiedModelName)->afterLast('\\')),
-        ]);
-
-        $tableColumns->each(function ($column) use ($outputBuffer) {
-            // If this attribute is hidden and we're not including hidden, we'll skip it.
-            if (!$this->includeHidden && $this->isAttributeHidden($column->Field)) return;
-
-            if ($this->isAttributeRelation($column->Field)) {
-                $relationName = $this->convertForeignKeyToPredictedRelationName($column->Field);
-                $generatedTypeScriptType = Str::of($this->getTypeScriptType($column));
-
-                $generatedTypeName = $generatedTypeScriptType
-                    ->after('interface ')
-                    ->before(' {')
-                    ->append($generatedTypeScriptType->afterLast('}'));
-
-                $outputBuffer->push(sprintf('    %s: %s;', $relationName, $generatedTypeName));
-
-                // Add an empty line so related interfaces aren't directly after each other.
-                $outputBuffer->prepend('');
-
-                // Get the TypeScript type of this column. We know it's a relation,
-                // therefore we know the string we get back will be another interface.
-                // Once we've got the interface, we'll want to explode it, then prepend
-                // each piece of the interface to the output buffer.
-                // We reverse the exploded string because we prepend, otherwise we'd prepend backwards.
-                $generatedTypeScriptType
-                    ->explode("\n")
-                    ->reverse()
-                    ->each(fn ($str) => $outputBuffer->prepend($str));
-            } else {
-                $outputBuffer->push(sprintf('    %s: %s;', $column->Field, $this->getTypeScriptType($column)));
-            }
-        });
-
-        $outputBuffer->push('}');
-
-        return $outputBuffer->join("\n");
-    }
-
     /**
      * Set whether we should include the model's protected $hidden attributes.
      *
@@ -374,14 +347,81 @@ public function includeHidden(bool $includeHidden): self {
      * @throws \Exception
      */
     public function generate(): string {
-        if (!$this->hasValidModel()) {
-            throw new Exception('That\'s not a valid model!');
-        }
+        $tableColumns = collect(DB::select(DB::raw('SHOW COLUMNS FROM ' . $this->model->getTable())));
 
-        if (!$this->hasSupportedDatabaseConnection()) {
-            throw new Exception('Your database connection is currently unsupported! The following database connections are supported: ' . implode(', ', self::SUPPORTED_DATABASE_CONNECTIONS));
-        }
+        $interfaceName = Str::afterLast($this->fullyQualifiedModelName, '\\');
+
+        // At this point, we haven't technically generated the full TypeScript interface definition
+        // for the target model. However, if the current model was to reference itself (which is valid),
+        // without doing this here, it would cause an infinite loop.
+        $this->convertedModelsMap[$this->fullyQualifiedModelName] = $interfaceName;
+
+        // The output buffer always needs to start with the first `interface X {` line.
+        $outputBuffer = collect([sprintf('interface %s {', $interfaceName)]);
 
-        return $this->generateInterface();
+        $tableColumns->each(function ($columnSchema) use ($outputBuffer) {
+            // 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)) {
+                $relationName = $this->convertForeignKeyToPredictedRelationName($columnSchema->Field);
+                $generatedTypeScriptType = Str::of($this->getTypeScriptType($columnSchema));
+
+                // We know we've just generated a new interface if the generated TypeScript type
+                // starts with 'interface '. If it doesn't, we'll be referring to a TypeScript type
+                // that's been previously generated.
+                $isRelationInterfaceDefinition = $generatedTypeScriptType->startsWith('interface ');
+
+                if ($isRelationInterfaceDefinition) {
+                    // interface User { => User
+                    $generatedInterfaceName = $generatedTypeScriptType
+                        ->after('interface ')
+                        ->before(' {');
+
+                    $fullyQualifiedRelatedModelName = $this->convertForeignKeyToFullyQualifiedModelName($columnSchema->Field);
+                    // We've just generated a new interface, we'll want to make sure our class doesn't attempt to
+                    // generate it again by adding it to our convertedModelsMap.
+                    $this->convertedModelsMap[$fullyQualifiedRelatedModelName] = $generatedInterfaceName->toString();
+
+                    // Columns aren't always required. To make sure we're not losing other type metadata,
+                    // we'll append everything after the end of the interface definition onto the new
+                    // interface name we've generated.
+                    $generatedType = $generatedInterfaceName->append($generatedTypeScriptType->afterLast('}'));
+                } else {
+                    // If we don't have a new relation interface definition, we'll have the interface name definition,
+                    // retrieved from the convertedModelsMap (as well as any type metadata). We can use that value directly.
+                    $generatedType = $generatedTypeScriptType;
+                }
+
+                // Append the relation to the interface we're generating.
+                $outputBuffer->push(sprintf('    %s: %s;', $relationName, $generatedType));
+
+                // If we've generated a new interface, we'll want to append it above the current
+                // interface we're in the process of generating.
+                if ($isRelationInterfaceDefinition) {
+                    // Add an empty line so related interfaces aren't directly after each other.
+                    $outputBuffer->prepend('');
+
+                    // Get the TypeScript type of this column. We know it's a relation,
+                    // therefore we know the string we get back will be another interface.
+                    // Once we've got the interface, we'll want to explode it, then prepend
+                    // each piece of the interface to the output buffer.
+                    // We reverse the exploded string because we prepend, otherwise we'd prepend backwards.
+                    $generatedTypeScriptType
+                        ->beforeLast('}')
+                        ->append('}')
+                        ->explode("\n")
+                        ->reverse()
+                        ->each(fn ($str) => $outputBuffer->prepend($str));
+                }
+            } else {
+                // Append the column name, and the TypeScript type to the interface we're generating.
+                $outputBuffer->push(sprintf('    %s: %s;', $columnSchema->Field, $this->getTypeScriptType($columnSchema)));
+            }
+        });
+
+        $outputBuffer->push('}');
+
+        return $outputBuffer->join("\n");
     }
 }