Compare commits

..

2 Commits

Author SHA1 Message Date
Josha von Gizycki 933f193dd7 refactor analyze results, work out cyclic dependencies 3 weeks ago
Josha von Gizycki 29972a6982 make phpstan happy 3 weeks ago

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

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

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

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

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

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

@ -9,6 +9,7 @@ use Kartierung\Analyze\Result\EntityResult;
use Kartierung\Analyze\Result\FieldAccess;
use Kartierung\Analyze\Result\Type\ArrayType;
use Kartierung\Analyze\Result\Type\ClassType;
use Kartierung\Repository\InvalidCall;
class EntityToDataMapper
{
@ -47,7 +48,8 @@ class EntityToDataMapper
{
return match ($field->readAccess) {
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,6 +41,10 @@ readonly class InsertEntity
return $newEntity;
}
/**
* @param EntityResult<object> $entityResult
* @param array<string, mixed> $data
*/
private function insertWithNewId(EntityResult $entityResult, array $data): string|false
{
$cols = implode(", ", array_map(

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

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

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

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

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

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

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

Loading…
Cancel
Save