Compare commits

..

No commits in common. '933f193dd7511f29619c61e5bc9bbd076b34272c' and '8d86f09feb43ff386188e0b69f651bce90228d30' have entirely different histories.

@ -17,10 +17,7 @@ return static function (DeptracConfig $config): void {
$analyzePublic = Layer::withName('AnalyzePublic') $analyzePublic = Layer::withName('AnalyzePublic')
->collectors( ->collectors(
ClassLikeConfig::create('Kartierung\\Analyze\\Exception\\.+'), ClassLikeConfig::create('Kartierung\\Analyze\\Exception\\.+'),
ClassLikeConfig::create('Kartierung\\Analyze\\Result\\.+'), ClassLikeConfig::create('Kartierung\\Analyze\\Result\\.+')
ClassLikeConfig::create('Kartierung\\Analyze\\RepositoryAnalyzer'),
ClassLikeConfig::create('Kartierung\\Analyze\\EntityAnalyzer'),
ClassLikeConfig::create('Kartierung\\Analyze\\RecursionCheck')
), ),
$analyze = Layer::withName('Analyze') $analyze = Layer::withName('Analyze')
->collectors( ->collectors(
@ -33,20 +30,12 @@ return static function (DeptracConfig $config): void {
), ),
$attribute = Layer::withName('Attribute') $attribute = Layer::withName('Attribute')
->collectors( ->collectors(
ClassLikeConfig::create('Kartierung\\Attribute\\.+'), ClassLikeConfig::create('Kartierung\\Attribute\\.*'),
), ),
$repository = Layer::withName('Repository')
->collectors(
ClassLikeConfig::create('Kartierung\\Repository\\.+')
)
) )
->rulesets( ->rulesets(
Ruleset::forLayer($analyze) Ruleset::forLayer($analyze)
->accesses($attribute),
Ruleset::forLayer($analyzePublic)
->accesses($attribute) ->accesses($attribute)
->accesses($analyze), ->accesses($analyzePublic),
Ruleset::forLayer($repository)
->accesses($analyzePublic)
); );
}; };

@ -11,6 +11,7 @@ use Kartierung\Analyze\Result\RepositoryMethodParameter;
use Kartierung\Analyze\Result\RepositoryResult; use Kartierung\Analyze\Result\RepositoryResult;
use Kartierung\Attribute\ListOf; use Kartierung\Attribute\ListOf;
use Kartierung\Attribute\Query; use Kartierung\Attribute\Query;
use Kartierung\Repository\ResolutionStrategy\ResolutionStrategyFactory;
use ReflectionClass; use ReflectionClass;
use ReflectionIntersectionType; use ReflectionIntersectionType;
use ReflectionMethod; use ReflectionMethod;
@ -22,6 +23,11 @@ use ReflectionUnionType;
*/ */
readonly class RepositoryAnalyzer readonly class RepositoryAnalyzer
{ {
public function __construct(
private ResolutionStrategyFactory $methodValidator
) {}
/** /**
* @param class-string<R> $repositoryClass * @param class-string<R> $repositoryClass
* @noinspection PhpDocMissingThrowsInspection * @noinspection PhpDocMissingThrowsInspection
@ -34,7 +40,6 @@ readonly class RepositoryAnalyzer
$refClass = new ReflectionClass($repositoryClass); $refClass = new ReflectionClass($repositoryClass);
return new RepositoryResult( return new RepositoryResult(
repoFqcn: $repositoryClass,
methods: $this->methods($refClass) methods: $this->methods($refClass)
); );
} }
@ -55,6 +60,15 @@ readonly class RepositoryAnalyzer
$params = $this->parameters($refMethod); $params = $this->parameters($refMethod);
$name = $refMethod->name; $name = $refMethod->name;
$resolutionStrategy = $this->methodValidator->forRepositoryMethod(
repName: $refClass->name,
methodName: $name,
query: $query,
returnType: $returnType,
returnsNullable: $returnsNullable,
listType: $listType,
params: $params
);
$methods[$refMethod->name] = new RepositoryMethod( $methods[$refMethod->name] = new RepositoryMethod(
query: $query, query: $query,
@ -63,6 +77,7 @@ readonly class RepositoryAnalyzer
returnListType: $listType, returnListType: $listType,
name: $name, name: $name,
parameters: $params, parameters: $params,
resolutionStrategy: $resolutionStrategy
); );
} }

@ -27,7 +27,6 @@ readonly class EntityResult
*/ */
public function fieldsWithoutId(): array public function fieldsWithoutId(): array
{ {
/** @var list<EntityField> */
return array_filter($this->fields, static fn(EntityField $field) => !$field->isIdField); return array_filter($this->fields, static fn(EntityField $field) => !$field->isIdField);
} }
} }

@ -19,6 +19,15 @@ readonly class RepositoryMethod
public bool $returnsNullable, public bool $returnsNullable,
public ?string $returnListType, public ?string $returnListType,
public string $name, public string $name,
public array $parameters public array $parameters,
public ResolutionStrategy $resolutionStrategy
) {} ) {}
/**
* @param array<string, mixed> $parameters
*/
public function createQuery(array $parameters): LazyQuery
{
return $this->resolutionStrategy->createQuery($this, $parameters);
}
} }

@ -7,11 +7,9 @@ namespace Kartierung\Analyze\Result;
readonly class RepositoryResult readonly class RepositoryResult
{ {
/** /**
* @param class-string<object> $repoFqcn
* @param array<string, RepositoryMethod> $methods * @param array<string, RepositoryMethod> $methods
*/ */
public function __construct( public function __construct(
public string $repoFqcn,
public array $methods public array $methods
) {} ) {}
} }

@ -23,7 +23,8 @@ readonly class Repository
*/ */
public function ofType(string $clazz): object public function ofType(string $clazz): object
{ {
$repoResult = (new RepositoryAnalyzer())->analyze($clazz); $resolutionStrategyFactory = new ResolutionStrategyFactory();
$repoResult = (new RepositoryAnalyzer($resolutionStrategyFactory))->analyze($clazz);
/** /**
* @var R $proxy * @var R $proxy
@ -45,11 +46,7 @@ readonly class Repository
$repoMethod = $this->repoResult->methods[$methodName]; $repoMethod = $this->repoResult->methods[$methodName];
$queryArgs = $this->callArgsToQueryArgs($repoMethod, $arguments); $queryArgs = $this->callArgsToQueryArgs($repoMethod, $arguments);
$strategy = (new ResolutionStrategyFactory())->forRepositoryMethod( $query = $repoMethod->createQuery($queryArgs);
$this->repoResult,
$repoMethod
);
$query = $strategy->createQuery($repoMethod, $queryArgs);
return $query->execute($this->pdo); return $query->execute($this->pdo);
} }

@ -9,7 +9,6 @@ use Kartierung\Analyze\Result\EntityResult;
use Kartierung\Analyze\Result\FieldAccess; use Kartierung\Analyze\Result\FieldAccess;
use Kartierung\Analyze\Result\Type\ArrayType; use Kartierung\Analyze\Result\Type\ArrayType;
use Kartierung\Analyze\Result\Type\ClassType; use Kartierung\Analyze\Result\Type\ClassType;
use Kartierung\Repository\InvalidCall;
class EntityToDataMapper class EntityToDataMapper
{ {
@ -48,8 +47,7 @@ class EntityToDataMapper
{ {
return match ($field->readAccess) { return match ($field->readAccess) {
FieldAccess::PUBLIC => $entity->{$field->name}, FieldAccess::PUBLIC => $entity->{$field->name},
FieldAccess::GETTER => $entity->{'get' . ucfirst($field->name)}(), FieldAccess::GETTER => $entity->{'get' . ucfirst($field->name)}()
FieldAccess::NONE => throw new InvalidCall("Field $field->name cannot be accessed.")
}; };
} }
} }

@ -41,10 +41,6 @@ readonly class InsertEntity
return $newEntity; return $newEntity;
} }
/**
* @param EntityResult<object> $entityResult
* @param array<string, mixed> $data
*/
private function insertWithNewId(EntityResult $entityResult, array $data): string|false private function insertWithNewId(EntityResult $entityResult, array $data): string|false
{ {
$cols = implode(", ", array_map( $cols = implode(", ", array_map(

@ -34,10 +34,7 @@ readonly class UpdateEntity
); );
$id = $data[$entityResult->idField->columnName] ?? null; $id = $data[$entityResult->idField->columnName] ?? null;
$params[] = $id; $params[] = $id;
/** // reindex keys for pdo
* reindex for pdo
* @phpstan-ignore arrayValues.list
*/
$params = array_values($params); $params = array_values($params);
$sql = "UPDATE $entityResult->tableName SET $pairs WHERE $idWhere"; $sql = "UPDATE $entityResult->tableName SET $pairs WHERE $idWhere";
@ -59,10 +56,8 @@ readonly class UpdateEntity
$entity = (new SelectEntityById($this->pdo))->select($entityResult, $id); $entity = (new SelectEntityById($this->pdo))->select($entityResult, $id);
if (!$entity) { if (!$entity) {
/** @phpstan-ignore argument.type */
$idStr = strval($id);
throw new InvalidCall( throw new InvalidCall(
"Entity of type $entityResult->classFqcn with id $idStr can not be selected." "Entity of type $entityResult->classFqcn with id $id can not be selected."
); );
} }

@ -22,10 +22,8 @@ readonly class FindById implements ResolutionStrategy
static function (PDO $pdo) use ($method, $parameters) { static function (PDO $pdo) use ($method, $parameters) {
$id = array_first($parameters); $id = array_first($parameters);
if($id === null || count($parameters) !== 1) { if($id === null || count($parameters) !== 1) {
/** @phpstan-ignore argument.type */
$idStr = strval($id);
throw new InvalidCall( throw new InvalidCall(
"Expected exactly on parameter as id of an entity to find. $idStr was given." "Expected exactly on parameter as id of an entity to find. $id was given."
); );
} }

@ -5,8 +5,6 @@ declare(strict_types=1);
namespace Kartierung\Repository\ResolutionStrategy; namespace Kartierung\Repository\ResolutionStrategy;
use Kartierung\Analyze\Exception\InvalidRepository; use Kartierung\Analyze\Exception\InvalidRepository;
use Kartierung\Analyze\Result\RepositoryMethod;
use Kartierung\Analyze\Result\RepositoryResult;
class ResolutionStrategyFactory class ResolutionStrategyFactory
{ {
@ -15,20 +13,17 @@ class ResolutionStrategyFactory
* @param class-string|null $listType * @param class-string|null $listType
*/ */
public function forRepositoryMethod( public function forRepositoryMethod(
RepositoryResult $repositoryResult, string $repName,
RepositoryMethod $method, string $methodName,
?string $query,
string $returnType,
bool $returnsNullable,
?string $listType,
array $params
): ResolutionStrategy ): ResolutionStrategy
{ {
$params = $method->parameters;
$oneParam = count($params) === 1; $oneParam = count($params) === 1;
$query = $method->query;
$methodName = $method->name;
$returnType = $method->returnType;
$returnsNullable = $method->returnsNullable;
$listType = $method->returnListType;
$repName = $repositoryResult->repoFqcn;
return match (true) { return match (true) {
$query !== null => new UserDefinedQuery(), $query !== null => new UserDefinedQuery(),

@ -37,9 +37,10 @@ class FindAllTest extends SqliteBaseCase
returnsNullable: true, returnsNullable: true,
returnListType: SimpleEntity::class, returnListType: SimpleEntity::class,
name: '', name: '',
parameters: [] parameters: [],
resolutionStrategy: new FindAll()
); );
$query = (new FindAll())->createQuery($method, []); $query = $method->createQuery([]);
// When // When
$result = $query->execute($this->getPdo()); $result = $query->execute($this->getPdo());

@ -39,8 +39,9 @@ class FindByIdTest extends SqliteBaseCase
returnListType: '', returnListType: '',
name: '', name: '',
parameters: [], parameters: [],
resolutionStrategy: $findBy
); );
$query = $findBy->createQuery($method, [1]); $query = $method->createQuery([1]);
// When // When
$result = $query->execute($this->getPdo()); $result = $query->execute($this->getPdo());
@ -64,8 +65,9 @@ class FindByIdTest extends SqliteBaseCase
returnListType: '', returnListType: '',
name: '', name: '',
parameters: [], parameters: [],
resolutionStrategy: $findBy
); );
$query = $findBy->createQuery($method, [3]); $query = $method->createQuery([3]);
// When // When
$result = $query->execute($this->getPdo()); $result = $query->execute($this->getPdo());
@ -89,8 +91,9 @@ class FindByIdTest extends SqliteBaseCase
returnListType: '', returnListType: '',
name: '', name: '',
parameters: [], parameters: [],
resolutionStrategy: $findBy
); );
$query = $findBy->createQuery($method, [4]); $query = $method->createQuery([4]);
// When // When
$result = $query->execute($this->getPdo()); $result = $query->execute($this->getPdo());

@ -4,8 +4,6 @@ declare(strict_types=1);
namespace Kartierung\Repository\ResolutionStrategy; namespace Kartierung\Repository\ResolutionStrategy;
use Kartierung\Analyze\Result\RepositoryMethod;
use Kartierung\Analyze\Result\RepositoryResult;
use Kartierung\FullEntity; use Kartierung\FullEntity;
use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase; use PHPUnit\Framework\TestCase;
@ -35,24 +33,15 @@ class ResolutionStrategyFactoryTest extends TestCase
string $strategyClass string $strategyClass
): void ): void
{ {
// Given // When
$method = new RepositoryMethod( $function = (new ResolutionStrategyFactory())->forRepositoryMethod(
repName: $repName,
methodName: $name,
query: $query, query: $query,
returnType: $returnType, returnType: $returnType,
returnsNullable: $returnsNullable, returnsNullable: $returnsNullable,
returnListType: $listType, listType: $listType,
name: $name, params: $params
parameters: $params
);
$repositoryResult = new RepositoryResult(
'',
[$method]
);
// When
$function = (new ResolutionStrategyFactory())->forRepositoryMethod(
$repositoryResult,
$method
); );
// Then // Then
@ -80,24 +69,15 @@ class ResolutionStrategyFactoryTest extends TestCase
string $strategyClass string $strategyClass
): void ): void
{ {
// Given
$method = new RepositoryMethod(
query: $query,
returnType: $returnType,
returnsNullable: true,
returnListType: $listType,
name: $name,
parameters: $params
);
$repositoryResult = new RepositoryResult(
'',
[$method]
);
// When // When
$function = (new ResolutionStrategyFactory())->forRepositoryMethod( $function = (new ResolutionStrategyFactory())->forRepositoryMethod(
$repositoryResult, repName: $repName,
$method methodName: $name,
query: $query,
returnType: $returnType,
returnsNullable: false,
listType: $listType,
params: $params
); );
// Then // Then

@ -47,9 +47,10 @@ class SaveEntityTest extends SqliteBaseCase
function: ParameterFunction::STATEMENT_PARAMETER function: ParameterFunction::STATEMENT_PARAMETER
) )
], ],
resolutionStrategy: $strategy
); );
$entity = new SimpleEntity(null, 'foobar'); $entity = new SimpleEntity(null, 'foobar');
$query = $strategy->createQuery($method, [$entity]); $query = $method->createQuery([$entity]);
// When // When
$result = $query->execute($this->getPdo()); $result = $query->execute($this->getPdo());
@ -82,9 +83,10 @@ class SaveEntityTest extends SqliteBaseCase
function: ParameterFunction::STATEMENT_PARAMETER function: ParameterFunction::STATEMENT_PARAMETER
) )
], ],
resolutionStrategy: $strategy
); );
$entity = new SimpleEntity(1, 'foobar'); $entity = new SimpleEntity(1, 'foobar');
$query = $strategy->createQuery($method, [$entity]); $query = $method->createQuery([$entity]);
// When // When
$result = $query->execute($this->getPdo()); $result = $query->execute($this->getPdo());

Loading…
Cancel
Save