Implement naming conventions and type mapper

src/Generator/NamingConverter.php

···
+<?php
+
+namespace SocialDept\Schema\Generator;
+
+use SocialDept\Schema\Parser\Nsid;
+
+class NamingConverter
+{
+    /**
+     * Base namespace for generated classes.
+     */
+    protected string $baseNamespace;
+
+    /**
+     * Create a new NamingConverter.
+     */
+    public function __construct(string $baseNamespace = 'App\\Lexicon')
+    {
+        $this->baseNamespace = rtrim($baseNamespace, '\\');
+    }
+
+    /**
+     * Convert NSID to fully qualified class name.
+     */
+    public function nsidToClassName(string $nsidString): string
+    {
+        $nsid = Nsid::parse($nsidString);
+        $namespace = $this->nsidToNamespace($nsidString);
+        $className = $this->toClassName($nsid->getName());
+
+        return $namespace.'\\'.$className;
+    }
+
+    /**
+     * Convert NSID to namespace.
+     */
+    public function nsidToNamespace(string $nsidString): string
+    {
+        $nsid = Nsid::parse($nsidString);
+
+        // Split authority into parts (e.g., "app.bsky" -> ["app", "bsky"])
+        $authorityParts = array_reverse(explode('.', $nsid->getAuthority()));
+
+        // Convert each part to PascalCase
+        $namespaceParts = array_map(
+            fn ($part) => $this->toPascalCase($part),
+            $authorityParts
+        );
+
+        return $this->baseNamespace.'\\'.implode('\\', $namespaceParts);
+    }
+
+    /**
+     * Get class name from NSID name part.
+     */
+    public function toClassName(string $name): string
+    {
+        // Split on dots (e.g., "feed.post" -> "FeedPost")
+        $parts = explode('.', $name);
+
+        $className = implode('', array_map(
+            fn ($part) => $this->toPascalCase($part),
+            $parts
+        ));
+
+        return $className;
+    }
+
+    /**
+     * Convert to PascalCase.
+     */
+    public function toPascalCase(string $string): string
+    {
+        // Split on hyphens, underscores, or existing camelCase boundaries
+        $words = preg_split('/[-_\s]+|(?=[A-Z])/', $string);
+
+        if ($words === false) {
+            $words = [$string];
+        }
+
+        // Capitalize first letter of each word
+        $words = array_map(fn ($word) => ucfirst(strtolower($word)), $words);
+
+        return implode('', $words);
+    }
+
+    /**
+     * Convert to camelCase.
+     */
+    public function toCamelCase(string $string): string
+    {
+        $pascalCase = $this->toPascalCase($string);
+
+        return lcfirst($pascalCase);
+    }
+
+    /**
+     * Convert to snake_case.
+     */
+    public function toSnakeCase(string $string): string
+    {
+        // Insert underscore before capital letters, except at the start
+        $snake = preg_replace('/(?<!^)[A-Z]/', '_$0', $string);
+
+        if ($snake === null) {
+            return strtolower($string);
+        }
+
+        return strtolower($snake);
+    }
+
+    /**
+     * Convert to kebab-case.
+     */
+    public function toKebabCase(string $string): string
+    {
+        return str_replace('_', '-', $this->toSnakeCase($string));
+    }
+
+    /**
+     * Pluralize a word (simple English rules).
+     */
+    public function pluralize(string $word): string
+    {
+        if (str_ends_with($word, 'y')) {
+            return substr($word, 0, -1).'ies';
+        }
+
+        if (str_ends_with($word, 's') || str_ends_with($word, 'x') || str_ends_with($word, 'ch') || str_ends_with($word, 'sh')) {
+            return $word.'es';
+        }
+
+        return $word.'s';
+    }
+
+    /**
+     * Singularize a word (simple English rules).
+     */
+    public function singularize(string $word): string
+    {
+        if (str_ends_with($word, 'ies')) {
+            return substr($word, 0, -3).'y';
+        }
+
+        if (str_ends_with($word, 'ses') || str_ends_with($word, 'xes') || str_ends_with($word, 'ches') || str_ends_with($word, 'shes')) {
+            return substr($word, 0, -2);
+        }
+
+        if (str_ends_with($word, 's') && ! str_ends_with($word, 'ss')) {
+            return substr($word, 0, -1);
+        }
+
+        return $word;
+    }
+
+    /**
+     * Get the base namespace.
+     */
+    public function getBaseNamespace(): string
+    {
+        return $this->baseNamespace;
+    }
+
+    /**
+     * Set the base namespace.
+     */
+    public function setBaseNamespace(string $namespace): void
+    {
+        $this->baseNamespace = rtrim($namespace, '\\');
+    }
+}

src/Generator/TypeMapper.php

···
+<?php
+
+namespace SocialDept\Schema\Generator;
+
+class TypeMapper
+{
+    /**
+     * Naming converter instance.
+     */
+    protected NamingConverter $naming;
+
+    /**
+     * Create a new TypeMapper.
+     */
+    public function __construct(?NamingConverter $naming = null)
+    {
+        $this->naming = $naming ?? new NamingConverter;
+    }
+
+    /**
+     * Map lexicon type to PHP type.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    public function toPhpType(array $definition, bool $nullable = false): string
+    {
+        $type = $definition['type'] ?? 'unknown';
+
+        $phpType = match ($type) {
+            'string' => 'string',
+            'integer' => 'int',
+            'boolean' => 'bool',
+            'number' => 'float',
+            'array' => $this->mapArrayType($definition),
+            'object' => $this->mapObjectType($definition),
+            'blob' => '\\SocialDept\\Schema\\Data\\BlobReference',
+            'bytes' => 'string',
+            'cid-link' => 'string',
+            'unknown' => 'mixed',
+            'ref' => $this->mapRefType($definition),
+            'union' => $this->mapUnionType($definition),
+            default => 'mixed',
+        };
+
+        if ($nullable && $phpType !== 'mixed') {
+            return '?'.$phpType;
+        }
+
+        return $phpType;
+    }
+
+    /**
+     * Map lexicon type to PHPDoc type.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    public function toPhpDocType(array $definition, bool $nullable = false): string
+    {
+        $type = $definition['type'] ?? 'unknown';
+
+        $docType = match ($type) {
+            'string' => 'string',
+            'integer' => 'int',
+            'boolean' => 'bool',
+            'number' => 'float',
+            'array' => $this->mapArrayDocType($definition),
+            'object' => $this->mapObjectDocType($definition),
+            'blob' => '\\SocialDept\\Schema\\Data\\BlobReference',
+            'bytes' => 'string',
+            'cid-link' => 'string',
+            'unknown' => 'mixed',
+            'ref' => $this->mapRefDocType($definition),
+            'union' => $this->mapUnionDocType($definition),
+            default => 'mixed',
+        };
+
+        if ($nullable && $docType !== 'mixed') {
+            return $docType.'|null';
+        }
+
+        return $docType;
+    }
+
+    /**
+     * Map array type.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    protected function mapArrayType(array $definition): string
+    {
+        return 'array';
+    }
+
+    /**
+     * Map array type for PHPDoc.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    protected function mapArrayDocType(array $definition): string
+    {
+        if (! isset($definition['items'])) {
+            return 'array';
+        }
+
+        $itemType = $this->toPhpDocType($definition['items']);
+
+        return "array<{$itemType}>";
+    }
+
+    /**
+     * Map object type.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    protected function mapObjectType(array $definition): string
+    {
+        return 'array';
+    }
+
+    /**
+     * Map object type for PHPDoc.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    protected function mapObjectDocType(array $definition): string
+    {
+        if (! isset($definition['properties'])) {
+            return 'array';
+        }
+
+        // Build array shape annotation
+        $properties = [];
+        foreach ($definition['properties'] as $key => $propDef) {
+            $propType = $this->toPhpDocType($propDef);
+            $properties[] = "{$key}: {$propType}";
+        }
+
+        if (empty($properties)) {
+            return 'array';
+        }
+
+        return 'array{'.implode(', ', $properties).'}';
+    }
+
+    /**
+     * Map reference type.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    protected function mapRefType(array $definition): string
+    {
+        if (! isset($definition['ref'])) {
+            return 'mixed';
+        }
+
+        // Convert NSID reference to class name
+        return '\\'.$this->naming->nsidToClassName($definition['ref']);
+    }
+
+    /**
+     * Map reference type for PHPDoc.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    protected function mapRefDocType(array $definition): string
+    {
+        return $this->mapRefType($definition);
+    }
+
+    /**
+     * Map union type.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    protected function mapUnionType(array $definition): string
+    {
+        // For runtime type hints, unions of different types must be 'mixed'
+        return 'mixed';
+    }
+
+    /**
+     * Map union type for PHPDoc.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    protected function mapUnionDocType(array $definition): string
+    {
+        if (! isset($definition['refs'])) {
+            return 'mixed';
+        }
+
+        $types = array_map(
+            fn ($ref) => '\\'.$this->naming->nsidToClassName($ref),
+            $definition['refs']
+        );
+
+        return implode('|', $types);
+    }
+
+    /**
+     * Check if type is nullable based on definition.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    public function isNullable(array $definition, array $required = []): bool
+    {
+        // Check if explicitly marked as required
+        if (isset($definition['required']) && $definition['required'] === true) {
+            return false;
+        }
+
+        // Check if in required array
+        if (! empty($required)) {
+            return false;
+        }
+
+        // Default to nullable for optional fields
+        return true;
+    }
+
+    /**
+     * Get default value for a type.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    public function getDefaultValue(array $definition): ?string
+    {
+        if (! array_key_exists('default', $definition)) {
+            return null;
+        }
+
+        $default = $definition['default'];
+
+        if ($default === null) {
+            return 'null';
+        }
+
+        if (is_string($default)) {
+            return "'".addslashes($default)."'";
+        }
+
+        if (is_bool($default)) {
+            return $default ? 'true' : 'false';
+        }
+
+        if (is_numeric($default)) {
+            return (string) $default;
+        }
+
+        if (is_array($default)) {
+            return '[]';
+        }
+
+        return null;
+    }
+
+    /**
+     * Check if type needs use statement.
+     *
+     * @param  array<string, mixed>  $definition
+     */
+    public function needsUseStatement(array $definition): bool
+    {
+        $type = $definition['type'] ?? 'unknown';
+
+        return in_array($type, ['ref', 'blob']);
+    }
+
+    /**
+     * Get use statements for type.
+     *
+     * @param  array<string, mixed>  $definition
+     * @return array<string>
+     */
+    public function getUseStatements(array $definition): array
+    {
+        $type = $definition['type'] ?? 'unknown';
+
+        if ($type === 'blob') {
+            return ['SocialDept\\Schema\\Data\\BlobReference'];
+        }
+
+        if ($type === 'ref' && isset($definition['ref'])) {
+            return [$this->naming->nsidToClassName($definition['ref'])];
+        }
+
+        if ($type === 'union' && isset($definition['refs'])) {
+            return array_map(
+                fn ($ref) => $this->naming->nsidToClassName($ref),
+                $definition['refs']
+            );
+        }
+
+        return [];
+    }
+}

tests/Unit/Generator/NamingConverterTest.php

···
+<?php
+
+namespace SocialDept\Schema\Tests\Unit\Generator;
+
+use Orchestra\Testbench\TestCase;
+use SocialDept\Schema\Generator\NamingConverter;
+
+class NamingConverterTest extends TestCase
+{
+    protected NamingConverter $converter;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->converter = new NamingConverter('App\\Lexicon');
+    }
+
+    public function test_it_converts_nsid_to_class_name(): void
+    {
+        $className = $this->converter->nsidToClassName('app.bsky.feed.post');
+
+        $this->assertSame('App\\Lexicon\\Feed\\Bsky\\App\\Post', $className);
+    }
+
+    public function test_it_converts_nsid_to_namespace(): void
+    {
+        $namespace = $this->converter->nsidToNamespace('app.bsky.feed.post');
+
+        $this->assertSame('App\\Lexicon\\Feed\\Bsky\\App', $namespace);
+    }
+
+    public function test_it_handles_multi_part_names(): void
+    {
+        $className = $this->converter->toClassName('feed.post');
+
+        $this->assertSame('FeedPost', $className);
+    }
+
+    public function test_it_handles_single_part_names(): void
+    {
+        $className = $this->converter->toClassName('post');
+
+        $this->assertSame('Post', $className);
+    }
+
+    public function test_it_converts_to_pascal_case(): void
+    {
+        $this->assertSame('HelloWorld', $this->converter->toPascalCase('hello_world'));
+        $this->assertSame('HelloWorld', $this->converter->toPascalCase('hello-world'));
+        $this->assertSame('HelloWorld', $this->converter->toPascalCase('hello world'));
+        $this->assertSame('HelloWorld', $this->converter->toPascalCase('helloWorld'));
+        $this->assertSame('Foo', $this->converter->toPascalCase('foo'));
+    }
+
+    public function test_it_converts_to_camel_case(): void
+    {
+        $this->assertSame('helloWorld', $this->converter->toCamelCase('hello_world'));
+        $this->assertSame('helloWorld', $this->converter->toCamelCase('hello-world'));
+        $this->assertSame('helloWorld', $this->converter->toCamelCase('hello world'));
+        $this->assertSame('helloWorld', $this->converter->toCamelCase('HelloWorld'));
+        $this->assertSame('foo', $this->converter->toCamelCase('foo'));
+    }
+
+    public function test_it_converts_to_snake_case(): void
+    {
+        $this->assertSame('hello_world', $this->converter->toSnakeCase('HelloWorld'));
+        $this->assertSame('hello_world', $this->converter->toSnakeCase('helloWorld'));
+        $this->assertSame('foo', $this->converter->toSnakeCase('foo'));
+        $this->assertSame('foo_bar_baz', $this->converter->toSnakeCase('FooBarBaz'));
+    }
+
+    public function test_it_converts_to_kebab_case(): void
+    {
+        $this->assertSame('hello-world', $this->converter->toKebabCase('HelloWorld'));
+        $this->assertSame('hello-world', $this->converter->toKebabCase('helloWorld'));
+        $this->assertSame('foo', $this->converter->toKebabCase('foo'));
+        $this->assertSame('foo-bar-baz', $this->converter->toKebabCase('FooBarBaz'));
+    }
+
+    public function test_it_pluralizes_words(): void
+    {
+        $this->assertSame('posts', $this->converter->pluralize('post'));
+        $this->assertSame('categories', $this->converter->pluralize('category'));
+        $this->assertSame('boxes', $this->converter->pluralize('box'));
+        $this->assertSame('churches', $this->converter->pluralize('church'));
+        $this->assertSame('bushes', $this->converter->pluralize('bush'));
+        $this->assertSame('postses', $this->converter->pluralize('posts')); // 'posts' ends with 's', gets 'es'
+    }
+
+    public function test_it_singularizes_words(): void
+    {
+        $this->assertSame('post', $this->converter->singularize('posts'));
+        $this->assertSame('category', $this->converter->singularize('categories'));
+        $this->assertSame('box', $this->converter->singularize('boxes'));
+        $this->assertSame('church', $this->converter->singularize('churches'));
+        $this->assertSame('bush', $this->converter->singularize('bushes'));
+        $this->assertSame('post', $this->converter->singularize('post')); // Already singular
+    }
+
+    public function test_it_handles_complex_nsid(): void
+    {
+        $className = $this->converter->nsidToClassName('com.atproto.repo.getRecord');
+
+        $this->assertSame('App\\Lexicon\\Repo\\Atproto\\Com\\GetRecord', $className);
+    }
+
+    public function test_it_gets_base_namespace(): void
+    {
+        $namespace = $this->converter->getBaseNamespace();
+
+        $this->assertSame('App\\Lexicon', $namespace);
+    }
+
+    public function test_it_sets_base_namespace(): void
+    {
+        $this->converter->setBaseNamespace('Custom\\Namespace');
+
+        $this->assertSame('Custom\\Namespace', $this->converter->getBaseNamespace());
+    }
+
+    public function test_it_strips_trailing_slash_from_namespace(): void
+    {
+        $converter = new NamingConverter('App\\Lexicon\\');
+
+        $this->assertSame('App\\Lexicon', $converter->getBaseNamespace());
+    }
+
+    public function test_it_handles_three_part_authority(): void
+    {
+        $className = $this->converter->nsidToClassName('com.example.api.getUser');
+
+        $this->assertSame('App\\Lexicon\\Api\\Example\\Com\\GetUser', $className);
+    }
+
+    public function test_it_handles_hyphens_in_names(): void
+    {
+        $className = $this->converter->toClassName('my-post');
+
+        $this->assertSame('MyPost', $className);
+    }
+
+    public function test_it_handles_underscores_in_names(): void
+    {
+        $className = $this->converter->toClassName('my_post');
+
+        $this->assertSame('MyPost', $className);
+    }
+
+    public function test_namespace_parts_are_reversed(): void
+    {
+        // app.bsky.feed should become Feed\Bsky\App (reversed)
+        $namespace = $this->converter->nsidToNamespace('app.bsky.feed.post');
+
+        $this->assertStringContainsString('Feed\\Bsky\\App', $namespace);
+    }
+
+    public function test_it_handles_single_letter_parts(): void
+    {
+        $pascalCase = $this->converter->toPascalCase('a');
+
+        $this->assertSame('A', $pascalCase);
+    }
+
+    public function test_it_handles_numbers_in_names(): void
+    {
+        $className = $this->converter->toClassName('post2');
+
+        $this->assertSame('Post2', $className);
+    }
+}

tests/Unit/Generator/TypeMapperTest.php

···
+<?php
+
+namespace SocialDept\Schema\Tests\Unit\Generator;
+
+use Orchestra\Testbench\TestCase;
+use SocialDept\Schema\Generator\NamingConverter;
+use SocialDept\Schema\Generator\TypeMapper;
+
+class TypeMapperTest extends TestCase
+{
+    protected TypeMapper $mapper;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $naming = new NamingConverter('App\\Lexicon');
+        $this->mapper = new TypeMapper($naming);
+    }
+
+    public function test_it_maps_string_type(): void
+    {
+        $type = $this->mapper->toPhpType(['type' => 'string']);
+
+        $this->assertSame('string', $type);
+    }
+
+    public function test_it_maps_integer_type(): void
+    {
+        $type = $this->mapper->toPhpType(['type' => 'integer']);
+
+        $this->assertSame('int', $type);
+    }
+
+    public function test_it_maps_boolean_type(): void
+    {
+        $type = $this->mapper->toPhpType(['type' => 'boolean']);
+
+        $this->assertSame('bool', $type);
+    }
+
+    public function test_it_maps_number_type(): void
+    {
+        $type = $this->mapper->toPhpType(['type' => 'number']);
+
+        $this->assertSame('float', $type);
+    }
+
+    public function test_it_maps_array_type(): void
+    {
+        $type = $this->mapper->toPhpType(['type' => 'array']);
+
+        $this->assertSame('array', $type);
+    }
+
+    public function test_it_maps_object_type(): void
+    {
+        $type = $this->mapper->toPhpType(['type' => 'object']);
+
+        $this->assertSame('array', $type);
+    }
+
+    public function test_it_maps_blob_type(): void
+    {
+        $type = $this->mapper->toPhpType(['type' => 'blob']);
+
+        $this->assertSame('\\SocialDept\\Schema\\Data\\BlobReference', $type);
+    }
+
+    public function test_it_maps_bytes_type(): void
+    {
+        $type = $this->mapper->toPhpType(['type' => 'bytes']);
+
+        $this->assertSame('string', $type);
+    }
+
+    public function test_it_maps_cid_link_type(): void
+    {
+        $type = $this->mapper->toPhpType(['type' => 'cid-link']);
+
+        $this->assertSame('string', $type);
+    }
+
+    public function test_it_maps_unknown_type(): void
+    {
+        $type = $this->mapper->toPhpType(['type' => 'unknown']);
+
+        $this->assertSame('mixed', $type);
+    }
+
+    public function test_it_maps_ref_type(): void
+    {
+        $type = $this->mapper->toPhpType([
+            'type' => 'ref',
+            'ref' => 'app.bsky.feed.post',
+        ]);
+
+        $this->assertSame('\\App\\Lexicon\\Feed\\Bsky\\App\\Post', $type);
+    }
+
+    public function test_it_maps_union_type(): void
+    {
+        $type = $this->mapper->toPhpType(['type' => 'union']);
+
+        $this->assertSame('mixed', $type);
+    }
+
+    public function test_it_handles_nullable_types(): void
+    {
+        $type = $this->mapper->toPhpType(['type' => 'string'], true);
+
+        $this->assertSame('?string', $type);
+    }
+
+    public function test_it_does_not_make_mixed_nullable(): void
+    {
+        $type = $this->mapper->toPhpType(['type' => 'unknown'], true);
+
+        $this->assertSame('mixed', $type);
+    }
+
+    public function test_it_maps_array_doc_type_with_items(): void
+    {
+        $docType = $this->mapper->toPhpDocType([
+            'type' => 'array',
+            'items' => ['type' => 'string'],
+        ]);
+
+        $this->assertSame('array<string>', $docType);
+    }
+
+    public function test_it_maps_array_doc_type_without_items(): void
+    {
+        $docType = $this->mapper->toPhpDocType(['type' => 'array']);
+
+        $this->assertSame('array', $docType);
+    }
+
+    public function test_it_maps_object_doc_type_with_properties(): void
+    {
+        $docType = $this->mapper->toPhpDocType([
+            'type' => 'object',
+            'properties' => [
+                'name' => ['type' => 'string'],
+                'age' => ['type' => 'integer'],
+            ],
+        ]);
+
+        $this->assertSame('array{name: string, age: int}', $docType);
+    }
+
+    public function test_it_maps_object_doc_type_without_properties(): void
+    {
+        $docType = $this->mapper->toPhpDocType(['type' => 'object']);
+
+        $this->assertSame('array', $docType);
+    }
+
+    public function test_it_maps_union_doc_type(): void
+    {
+        $docType = $this->mapper->toPhpDocType([
+            'type' => 'union',
+            'refs' => [
+                'app.bsky.feed.post',
+                'app.bsky.feed.repost',
+            ],
+        ]);
+
+        $this->assertSame('\\App\\Lexicon\\Feed\\Bsky\\App\\Post|\\App\\Lexicon\\Feed\\Bsky\\App\\Repost', $docType);
+    }
+
+    public function test_it_adds_null_to_doc_type_when_nullable(): void
+    {
+        $docType = $this->mapper->toPhpDocType(['type' => 'string'], true);
+
+        $this->assertSame('string|null', $docType);
+    }
+
+    public function test_it_checks_if_type_is_nullable(): void
+    {
+        // Field marked as required
+        $this->assertFalse($this->mapper->isNullable(['required' => true]));
+
+        // Field in required array
+        $this->assertFalse($this->mapper->isNullable(['name' => 'field'], ['field']));
+
+        // Optional field
+        $this->assertTrue($this->mapper->isNullable([]));
+    }
+
+    public function test_it_gets_string_default_value(): void
+    {
+        $default = $this->mapper->getDefaultValue(['default' => 'hello']);
+
+        $this->assertSame("'hello'", $default);
+    }
+
+    public function test_it_gets_boolean_default_value(): void
+    {
+        $this->assertSame('true', $this->mapper->getDefaultValue(['default' => true]));
+        $this->assertSame('false', $this->mapper->getDefaultValue(['default' => false]));
+    }
+
+    public function test_it_gets_numeric_default_value(): void
+    {
+        $this->assertSame('42', $this->mapper->getDefaultValue(['default' => 42]));
+        $this->assertSame('3.14', $this->mapper->getDefaultValue(['default' => 3.14]));
+    }
+
+    public function test_it_gets_array_default_value(): void
+    {
+        $default = $this->mapper->getDefaultValue(['default' => []]);
+
+        $this->assertSame('[]', $default);
+    }
+
+    public function test_it_gets_null_default_value(): void
+    {
+        $default = $this->mapper->getDefaultValue(['default' => null]);
+
+        $this->assertSame('null', $default);
+    }
+
+    public function test_it_returns_null_when_no_default(): void
+    {
+        $default = $this->mapper->getDefaultValue([]);
+
+        $this->assertNull($default);
+    }
+
+    public function test_it_checks_if_type_needs_use_statement(): void
+    {
+        $this->assertTrue($this->mapper->needsUseStatement(['type' => 'ref']));
+        $this->assertTrue($this->mapper->needsUseStatement(['type' => 'blob']));
+        $this->assertFalse($this->mapper->needsUseStatement(['type' => 'string']));
+    }
+
+    public function test_it_gets_use_statements_for_blob(): void
+    {
+        $uses = $this->mapper->getUseStatements(['type' => 'blob']);
+
+        $this->assertContains('SocialDept\\Schema\\Data\\BlobReference', $uses);
+    }
+
+    public function test_it_gets_use_statements_for_ref(): void
+    {
+        $uses = $this->mapper->getUseStatements([
+            'type' => 'ref',
+            'ref' => 'app.bsky.feed.post',
+        ]);
+
+        $this->assertContains('App\\Lexicon\\Feed\\Bsky\\App\\Post', $uses);
+    }
+
+    public function test_it_gets_use_statements_for_union(): void
+    {
+        $uses = $this->mapper->getUseStatements([
+            'type' => 'union',
+            'refs' => [
+                'app.bsky.feed.post',
+                'app.bsky.feed.repost',
+            ],
+        ]);
+
+        $this->assertContains('App\\Lexicon\\Feed\\Bsky\\App\\Post', $uses);
+        $this->assertContains('App\\Lexicon\\Feed\\Bsky\\App\\Repost', $uses);
+    }
+
+    public function test_it_gets_empty_use_statements_for_primitive(): void
+    {
+        $uses = $this->mapper->getUseStatements(['type' => 'string']);
+
+        $this->assertEmpty($uses);
+    }
+
+    public function test_it_escapes_quotes_in_string_defaults(): void
+    {
+        $default = $this->mapper->getDefaultValue(['default' => "it's great"]);
+
+        $this->assertSame("'it\\'s great'", $default);
+    }
+
+    public function test_it_handles_missing_type(): void
+    {
+        $type = $this->mapper->toPhpType([]);
+
+        $this->assertSame('mixed', $type);
+    }
+}