# Aspects

Aspects can be applied to CDK tree scopes and can operate on the tree before synthesis.

Obtainable from: Aspects.of

- Source: [`core/lib/aspect.ts`](https://github.com/aws/aws-cdk/blob/v2.277.0/packages/aws-cdk-lib/core/lib/aspect.ts#L57)
- Type last changed: v2.172.0 · 7 Dec 2024

## Example

TypeScript:

```ts
import * as cdk from 'aws-cdk-lib';
import { Construct, IConstruct } from 'constructs';

class MyAspect implements cdk.IAspect {
  public visit(node: IConstruct): void {
    if (node instanceof cdk.CfnResource && node.cfnResourceType === 'Foo::Bar') {
      this.error(node, 'we do not want a Foo::Bar resource');
    }
  }

  protected error(node: IConstruct, message: string): void {
    cdk.Annotations.of(node).addError(message);
  }
}

class MyStack extends cdk.Stack {
  constructor(scope: Construct, id: string) {
    super(scope, id);

    const stack = new cdk.Stack();
    new cdk.CfnResource(stack, 'Foo', {
      type: 'Foo::Bar',
      properties: {
        Fred: 'Thud',
      },
    });
    cdk.Aspects.of(stack).add(new MyAspect());
  }
}
```

Python:

```python
import aws_cdk as cdk
from constructs import Construct, IConstruct

@jsii.implements(cdk.IAspect)
class MyAspect:
    def visit(self, node):
        if node instanceof cdk.CfnResource && node.cfn_resource_type == "Foo::Bar":
            self.error(node, "we do not want a Foo::Bar resource")

    def error(self, node, message):
        cdk.Annotations.of(node).add_error(message)

class MyStack(cdk.Stack):
    def __init__(self, scope, id):
        super().__init__(scope, id)

        stack = cdk.Stack()
        cdk.CfnResource(stack, "Foo",
            type="Foo::Bar",
            properties={
                "Fred": "Thud"
            }
        )
        cdk.Aspects.of(stack).add(MyAspect())
```

Java:

```java
import software.amazon.awscdk.*;
import software.constructs.Construct;
import software.constructs.IConstruct;

public class MyAspect implements IAspect {
    public void visit(IConstruct node) {
        if (node instanceof CfnResource && node.getCfnResourceType() == "Foo::Bar") {
            this.error(node, "we do not want a Foo::Bar resource");
        }
    }

    public void error(IConstruct node, String message) {
        Annotations.of(node).addError(message);
    }
}

public class MyStack extends Stack {
    public MyStack(Construct scope, String id) {
        super(scope, id);

        Stack stack = new Stack();
        CfnResource.Builder.create(stack, "Foo")
                .type("Foo::Bar")
                .properties(Map.of(
                        "Fred", "Thud"))
                .build();
        Aspects.of(stack).add(new MyAspect());
    }
}
```

C# / .NET:

```csharp
// Install: dotnet add package Amazon.CDK.Lib
using Amazon.CDK;
using Constructs;

class MyAspect : IAspect
{
    public void Visit(IConstruct node)
    {
        if (node instanceof CfnResource && node.CfnResourceType == "Foo::Bar")
        {
            Error(node, "we do not want a Foo::Bar resource");
        }
    }

    protected void Error(IConstruct node, string message)
    {
        Annotations.Of(node).AddError(message);
    }
}

class MyStack : Stack
{
    public MyStack(Construct scope, string id) : base(scope, id)
    {

        var stack = new Stack();
        new CfnResource(stack, "Foo", new CfnResourceProps {
            Type = "Foo::Bar",
            Properties = new Dictionary<string, object> {
                { "Fred", "Thud" }
            }
        });
        Aspects.Of(stack).Add(new MyAspect());
    }
}
```

Golang:

```go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/constructs-go/constructs"

type myAspect struct {
}

func (this *myAspect) visit(node IConstruct) {
	if *node instanceof cdk.CfnResource && *node.CfnResourceType == "Foo::Bar" {
		this.error(*node, jsii.String("we do not want a Foo::Bar resource"))
	}
}

func (this *myAspect) error(node IConstruct, message *string) {
	cdk.Annotations_Of(*node).AddError(*message)
}

type myStack struct {
	Stack
}

func newMyStack(scope Construct, id *string) *myStack {
	this := &myStack{}
	cdk.NewStack_Override(this, scope, id)

	stack := cdk.NewStack()
	cdk.NewCfnResource(stack, jsii.String("Foo"), &CfnResourceProps{
		Type: jsii.String("Foo::Bar"),
		Properties: map[string]interface{}{
			"Fred": jsii.String("Thud"),
		},
	})
	cdk.Aspects_Of(stack).Add(newMyAspect())
	return this
}
```

## Properties

- `all`: [IAspect](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.IAspect.html)[] — The list of aspects which were directly applied on this scope.

- `applied`: [AspectApplication](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.AspectApplication.html)[] — The list of aspects with priority which were directly applied on this scope.

  Also returns inherited Aspects of this node.

## Methods

- `add(aspect: IAspect, options?: AspectOptions): void` — Adds an aspect to apply this scope before synthesis.

  **Parameters**

  - `aspect` — The aspect to add.
  - `options` — Options to apply on this aspect.

- `of(scope: IConstruct): Aspects // chainable` (static) — Returns the `Aspects` object associated with a construct scope.

  **Parameters**

  - `scope` — The scope for which these aspects will apply.
