Implement model mapping

src/Contracts/Transformer.php

···
+<?php
+
+namespace SocialDept\Schema\Contracts;
+
+interface Transformer
+{
+    /**
+     * Transform raw data to model.
+     */
+    public function fromArray(array $data): mixed;
+
+    /**
+     * Transform model to raw data.
+     */
+    public function toArray(mixed $model): array;
+
+    /**
+     * Check if this transformer supports the given type.
+     */
+    public function supports(string $type): bool;
+}

src/Services/ModelMapper.php

···
+<?php
+
+namespace SocialDept\Schema\Services;
+
+use SocialDept\Schema\Contracts\Transformer;
+use SocialDept\Schema\Exceptions\SchemaException;
+
+class ModelMapper
+{
+    /**
+     * Registered transformers.
+     *
+     * @var array<string, Transformer>
+     */
+    protected array $transformers = [];
+
+    /**
+     * Register a transformer for a specific type.
+     */
+    public function register(string $type, Transformer $transformer): self
+    {
+        $this->transformers[$type] = $transformer;
+
+        return $this;
+    }
+
+    /**
+     * Register multiple transformers at once.
+     *
+     * @param  array<string, Transformer>  $transformers
+     */
+    public function registerMany(array $transformers): self
+    {
+        foreach ($transformers as $type => $transformer) {
+            $this->register($type, $transformer);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Transform raw data to model.
+     */
+    public function fromArray(string $type, array $data): mixed
+    {
+        $transformer = $this->getTransformer($type);
+
+        if ($transformer === null) {
+            throw SchemaException::withContext(
+                "No transformer registered for type '{$type}'",
+                ['type' => $type]
+            );
+        }
+
+        return $transformer->fromArray($data);
+    }
+
+    /**
+     * Transform model to raw data.
+     */
+    public function toArray(string $type, mixed $model): array
+    {
+        $transformer = $this->getTransformer($type);
+
+        if ($transformer === null) {
+            throw SchemaException::withContext(
+                "No transformer registered for type '{$type}'",
+                ['type' => $type]
+            );
+        }
+
+        return $transformer->toArray($model);
+    }
+
+    /**
+     * Transform multiple items from arrays.
+     *
+     * @param  array<array>  $items
+     * @return array<mixed>
+     */
+    public function fromArrayMany(string $type, array $items): array
+    {
+        return array_map(
+            fn (array $item) => $this->fromArray($type, $item),
+            $items
+        );
+    }
+
+    /**
+     * Transform multiple items to arrays.
+     *
+     * @param  array<mixed>  $items
+     * @return array<array>
+     */
+    public function toArrayMany(string $type, array $items): array
+    {
+        return array_map(
+            fn (mixed $item) => $this->toArray($type, $item),
+            $items
+        );
+    }
+
+    /**
+     * Get transformer for a specific type.
+     */
+    public function getTransformer(string $type): ?Transformer
+    {
+        // Check exact match first
+        if (isset($this->transformers[$type])) {
+            return $this->transformers[$type];
+        }
+
+        // Check if any transformer supports this type
+        foreach ($this->transformers as $transformer) {
+            if ($transformer->supports($type)) {
+                return $transformer;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Check if a transformer is registered for a type.
+     */
+    public function has(string $type): bool
+    {
+        return $this->getTransformer($type) !== null;
+    }
+
+    /**
+     * Unregister a transformer.
+     */
+    public function unregister(string $type): self
+    {
+        unset($this->transformers[$type]);
+
+        return $this;
+    }
+
+    /**
+     * Get all registered transformers.
+     *
+     * @return array<string, Transformer>
+     */
+    public function all(): array
+    {
+        return $this->transformers;
+    }
+
+    /**
+     * Clear all registered transformers.
+     */
+    public function clear(): self
+    {
+        $this->transformers = [];
+
+        return $this;
+    }
+
+    /**
+     * Try to transform from array, return null if transformer not found.
+     */
+    public function tryFromArray(string $type, array $data): mixed
+    {
+        if (! $this->has($type)) {
+            return null;
+        }
+
+        return $this->fromArray($type, $data);
+    }
+
+    /**
+     * Try to transform to array, return null if transformer not found.
+     */
+    public function tryToArray(string $type, mixed $model): ?array
+    {
+        if (! $this->has($type)) {
+            return null;
+        }
+
+        return $this->toArray($type, $model);
+    }
+
+    /**
+     * Get count of registered transformers.
+     */
+    public function count(): int
+    {
+        return count($this->transformers);
+    }
+}

tests/Unit/Services/ModelMapperTest.php

···
+<?php
+
+namespace SocialDept\Schema\Tests\Unit\Services;
+
+use Orchestra\Testbench\TestCase;
+use SocialDept\Schema\Contracts\Transformer;
+use SocialDept\Schema\Exceptions\SchemaException;
+use SocialDept\Schema\Services\ModelMapper;
+
+class ModelMapperTest extends TestCase
+{
+    protected ModelMapper $mapper;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->mapper = new ModelMapper();
+    }
+
+    public function test_it_registers_transformer(): void
+    {
+        $transformer = $this->createTestTransformer('app.bsky.feed.post');
+
+        $this->mapper->register('app.bsky.feed.post', $transformer);
+
+        $this->assertTrue($this->mapper->has('app.bsky.feed.post'));
+    }
+
+    public function test_it_registers_multiple_transformers(): void
+    {
+        $transformer1 = $this->createTestTransformer('app.bsky.feed.post');
+        $transformer2 = $this->createTestTransformer('app.bsky.feed.repost');
+
+        $this->mapper->registerMany([
+            'app.bsky.feed.post' => $transformer1,
+            'app.bsky.feed.repost' => $transformer2,
+        ]);
+
+        $this->assertTrue($this->mapper->has('app.bsky.feed.post'));
+        $this->assertTrue($this->mapper->has('app.bsky.feed.repost'));
+    }
+
+    public function test_it_transforms_from_array(): void
+    {
+        $transformer = $this->createTestTransformer('app.bsky.feed.post');
+        $this->mapper->register('app.bsky.feed.post', $transformer);
+
+        $data = ['text' => 'Hello, world!'];
+        $model = $this->mapper->fromArray('app.bsky.feed.post', $data);
+
+        $this->assertInstanceOf(\stdClass::class, $model);
+        $this->assertEquals('Hello, world!', $model->text);
+    }
+
+    public function test_it_transforms_to_array(): void
+    {
+        $transformer = $this->createTestTransformer('app.bsky.feed.post');
+        $this->mapper->register('app.bsky.feed.post', $transformer);
+
+        $model = (object) ['text' => 'Hello, world!'];
+        $data = $this->mapper->toArray('app.bsky.feed.post', $model);
+
+        $this->assertEquals(['text' => 'Hello, world!'], $data);
+    }
+
+    public function test_it_throws_exception_when_transformer_not_found_for_from_array(): void
+    {
+        $this->expectException(SchemaException::class);
+
+        $this->mapper->fromArray('unknown.type', []);
+    }
+
+    public function test_it_throws_exception_when_transformer_not_found_for_to_array(): void
+    {
+        $this->expectException(SchemaException::class);
+
+        $this->mapper->toArray('unknown.type', new \stdClass());
+    }
+
+    public function test_it_transforms_multiple_items_from_arrays(): void
+    {
+        $transformer = $this->createTestTransformer('app.bsky.feed.post');
+        $this->mapper->register('app.bsky.feed.post', $transformer);
+
+        $items = [
+            ['text' => 'First post'],
+            ['text' => 'Second post'],
+        ];
+
+        $models = $this->mapper->fromArrayMany('app.bsky.feed.post', $items);
+
+        $this->assertCount(2, $models);
+        $this->assertEquals('First post', $models[0]->text);
+        $this->assertEquals('Second post', $models[1]->text);
+    }
+
+    public function test_it_transforms_multiple_items_to_arrays(): void
+    {
+        $transformer = $this->createTestTransformer('app.bsky.feed.post');
+        $this->mapper->register('app.bsky.feed.post', $transformer);
+
+        $models = [
+            (object) ['text' => 'First post'],
+            (object) ['text' => 'Second post'],
+        ];
+
+        $arrays = $this->mapper->toArrayMany('app.bsky.feed.post', $models);
+
+        $this->assertCount(2, $arrays);
+        $this->assertEquals(['text' => 'First post'], $arrays[0]);
+        $this->assertEquals(['text' => 'Second post'], $arrays[1]);
+    }
+
+    public function test_it_gets_transformer(): void
+    {
+        $transformer = $this->createTestTransformer('app.bsky.feed.post');
+        $this->mapper->register('app.bsky.feed.post', $transformer);
+
+        $retrieved = $this->mapper->getTransformer('app.bsky.feed.post');
+
+        $this->assertSame($transformer, $retrieved);
+    }
+
+    public function test_it_returns_null_for_missing_transformer(): void
+    {
+        $transformer = $this->mapper->getTransformer('unknown.type');
+
+        $this->assertNull($transformer);
+    }
+
+    public function test_it_checks_if_has_transformer(): void
+    {
+        $transformer = $this->createTestTransformer('app.bsky.feed.post');
+        $this->mapper->register('app.bsky.feed.post', $transformer);
+
+        $this->assertTrue($this->mapper->has('app.bsky.feed.post'));
+        $this->assertFalse($this->mapper->has('unknown.type'));
+    }
+
+    public function test_it_unregisters_transformer(): void
+    {
+        $transformer = $this->createTestTransformer('app.bsky.feed.post');
+        $this->mapper->register('app.bsky.feed.post', $transformer);
+
+        $this->assertTrue($this->mapper->has('app.bsky.feed.post'));
+
+        $this->mapper->unregister('app.bsky.feed.post');
+
+        $this->assertFalse($this->mapper->has('app.bsky.feed.post'));
+    }
+
+    public function test_it_gets_all_transformers(): void
+    {
+        $transformer1 = $this->createTestTransformer('app.bsky.feed.post');
+        $transformer2 = $this->createTestTransformer('app.bsky.feed.repost');
+
+        $this->mapper->registerMany([
+            'app.bsky.feed.post' => $transformer1,
+            'app.bsky.feed.repost' => $transformer2,
+        ]);
+
+        $all = $this->mapper->all();
+
+        $this->assertCount(2, $all);
+        $this->assertArrayHasKey('app.bsky.feed.post', $all);
+        $this->assertArrayHasKey('app.bsky.feed.repost', $all);
+    }
+
+    public function test_it_clears_all_transformers(): void
+    {
+        $transformer = $this->createTestTransformer('app.bsky.feed.post');
+        $this->mapper->register('app.bsky.feed.post', $transformer);
+
+        $this->assertEquals(1, $this->mapper->count());
+
+        $this->mapper->clear();
+
+        $this->assertEquals(0, $this->mapper->count());
+    }
+
+    public function test_it_tries_from_array_with_missing_transformer(): void
+    {
+        $result = $this->mapper->tryFromArray('unknown.type', []);
+
+        $this->assertNull($result);
+    }
+
+    public function test_it_tries_from_array_with_existing_transformer(): void
+    {
+        $transformer = $this->createTestTransformer('app.bsky.feed.post');
+        $this->mapper->register('app.bsky.feed.post', $transformer);
+
+        $result = $this->mapper->tryFromArray('app.bsky.feed.post', ['text' => 'Hello']);
+
+        $this->assertNotNull($result);
+        $this->assertEquals('Hello', $result->text);
+    }
+
+    public function test_it_tries_to_array_with_missing_transformer(): void
+    {
+        $result = $this->mapper->tryToArray('unknown.type', new \stdClass());
+
+        $this->assertNull($result);
+    }
+
+    public function test_it_tries_to_array_with_existing_transformer(): void
+    {
+        $transformer = $this->createTestTransformer('app.bsky.feed.post');
+        $this->mapper->register('app.bsky.feed.post', $transformer);
+
+        $model = (object) ['text' => 'Hello'];
+        $result = $this->mapper->tryToArray('app.bsky.feed.post', $model);
+
+        $this->assertNotNull($result);
+        $this->assertEquals(['text' => 'Hello'], $result);
+    }
+
+    public function test_it_counts_transformers(): void
+    {
+        $this->assertEquals(0, $this->mapper->count());
+
+        $this->mapper->register('app.bsky.feed.post', $this->createTestTransformer('app.bsky.feed.post'));
+
+        $this->assertEquals(1, $this->mapper->count());
+
+        $this->mapper->register('app.bsky.feed.repost', $this->createTestTransformer('app.bsky.feed.repost'));
+
+        $this->assertEquals(2, $this->mapper->count());
+    }
+
+    public function test_it_uses_wildcard_transformer(): void
+    {
+        $transformer = $this->createWildcardTransformer('app.bsky.feed.*');
+        $this->mapper->register('app.bsky.feed.*', $transformer);
+
+        $this->assertTrue($this->mapper->has('app.bsky.feed.post'));
+        $this->assertTrue($this->mapper->has('app.bsky.feed.repost'));
+        $this->assertFalse($this->mapper->has('app.bsky.graph.follow'));
+    }
+
+    public function test_it_prefers_exact_match_over_wildcard(): void
+    {
+        $wildcardTransformer = $this->createWildcardTransformer('app.bsky.feed.*');
+        $exactTransformer = $this->createTestTransformer('app.bsky.feed.post');
+
+        $this->mapper->register('app.bsky.feed.*', $wildcardTransformer);
+        $this->mapper->register('app.bsky.feed.post', $exactTransformer);
+
+        $retrieved = $this->mapper->getTransformer('app.bsky.feed.post');
+
+        $this->assertSame($exactTransformer, $retrieved);
+    }
+
+    public function test_it_chains_register_calls(): void
+    {
+        $transformer1 = $this->createTestTransformer('type1');
+        $transformer2 = $this->createTestTransformer('type2');
+
+        $result = $this->mapper
+            ->register('type1', $transformer1)
+            ->register('type2', $transformer2);
+
+        $this->assertSame($this->mapper, $result);
+        $this->assertTrue($this->mapper->has('type1'));
+        $this->assertTrue($this->mapper->has('type2'));
+    }
+
+    public function test_it_chains_register_many_calls(): void
+    {
+        $result = $this->mapper->registerMany([
+            'type1' => $this->createTestTransformer('type1'),
+            'type2' => $this->createTestTransformer('type2'),
+        ]);
+
+        $this->assertSame($this->mapper, $result);
+    }
+
+    public function test_it_chains_unregister_calls(): void
+    {
+        $this->mapper->register('type1', $this->createTestTransformer('type1'));
+
+        $result = $this->mapper->unregister('type1');
+
+        $this->assertSame($this->mapper, $result);
+    }
+
+    public function test_it_chains_clear_calls(): void
+    {
+        $result = $this->mapper->clear();
+
+        $this->assertSame($this->mapper, $result);
+    }
+
+    protected function createTestTransformer(string $type): Transformer
+    {
+        return new class ($type) implements Transformer {
+            public function __construct(protected string $type)
+            {
+            }
+
+            public function fromArray(array $data): mixed
+            {
+                return (object) $data;
+            }
+
+            public function toArray(mixed $model): array
+            {
+                return (array) $model;
+            }
+
+            public function supports(string $type): bool
+            {
+                return $type === $this->type;
+            }
+        };
+    }
+
+    protected function createWildcardTransformer(string $pattern): Transformer
+    {
+        return new class ($pattern) implements Transformer {
+            public function __construct(protected string $pattern)
+            {
+            }
+
+            public function fromArray(array $data): mixed
+            {
+                return (object) $data;
+            }
+
+            public function toArray(mixed $model): array
+            {
+                return (array) $model;
+            }
+
+            public function supports(string $type): bool
+            {
+                $regex = '/^'.str_replace('\\*', '.*', preg_quote($this->pattern, '/')).'$/';
+
+                return (bool) preg_match($regex, $type);
+            }
+        };
+    }
+}