How to detect direct instantiation of dependencies in custom architecture rules?

[datamweb]

Hi @samsonasik ,

I’m using StructArmed to enforce the architectural boundaries of a CI4 package, and I have a question about enforcing dependency injection.

In my architecture, a service layer is allowed to depend on a repository abstraction, but I want to prevent the service from creating a concrete repository itself.

For example, conceptually, I want the architecture to distinguish between:

1. a service receiving a repository dependency from the outside (dependency injection), which should be allowed.
2. a service creating a concrete repository internally, which should be forbidden.

The important part is that the repository layer itself is allowed as a dependency of the service layer, so a normal layer dependency rule cannot distinguish these two cases.

I noticed that StructArmed exposes information indicating that a class has been instantiated, but what I really need for an architecture rule is the relationship between the source class/scope and the instantiated class.

In other words, I need the architecture analyser to be able to answer a question like:

Did this service directly instantiate this concrete dependency?

rather than only:

Was this class instantiated somewhere in the scanned code?

Ideally, a custom rule would be able to inspect something conceptually similar to:

• source class: SomeService
• source method/scope: someMethod
• instantiated class: SomeConcreteRepository
• source line: the location of the instantiation

This would allow a rule such as:

Services must not directly instantiate concrete infrastructure or repository dependencies; those dependencies must be provided through dependency injection.

I’m wondering what the recommended way to implement this with StructArmed is.

Is there already a supported API for accessing this kind of instantiation provenance in a custom rule?

If not, is there another intended StructArmed approach for enforcing “dependency injection rather than direct instantiation” at the architectural level?

I would prefer to use the public StructArmed API rather than accessing the underlying AST directly.

Thanks!

[samsonasik]

Hi @datamweb, could you give example of code with namespace relation, I think most of usecase should be detected via something like:

if ($classNode->isReferenced && ! $classNode->isInstantiated) {
    return null;
}

return new RuleViolation( ... );

That's referenced allowed, but not directly instantiated.

You can implements the interface marker, for example: Boundwize\StructArmed\Rule\ExtendedClassAwareRuleInterface

Ref https://boundwize.github.io/structarmed/custom-rules-and-presets/#reading-usage-flags-in-a-custom-rule

[samsonasik]

On addition, you may also extends AbstractLayerAwareRule so you can resolve dependent layer of class.

Example

structarmed/src/Rule/Rules/Layer/MayNotDependOnRule.php

Line 18 in c95b82c

final class MayNotDependOnRule extends AbstractLayerAwareRule implements MultipleRuleViolationInterface

with check scanned dependency node

structarmed/src/Rule/Rules/Layer/MayNotDependOnRule.php

Line 76 in c95b82c

$dependencyNode = $this->getDependencyNode($dependency);