Init

Author: Leon Michalski

packages/aws-cdk-lib/aws-lambda/test/function.test.ts

@@ -5108,6 +5108,120 @@ describe('telemetry metadata', () => {
   });
 });
 
+describe('L1 Relationships', () => {
+  it('simple union', () => {
+    const stack = new cdk.Stack();
+    const role = new iam.Role(stack, 'SomeRole', {
+      assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
+    });
+    new lambda.CfnFunction(stack, 'MyLambda', {
+      code: { zipFile: 'foo' },
+      role: role, // Simple Union
+    });
+    Template.fromStack(stack).hasResource('AWS::Lambda::Function', {
+      Properties: {
+        Role: { 'Fn::GetAtt': ['SomeRole6DDC54DD', 'Arn'] },
+      },
+    });
+  });
+
+  it('array of unions', () => {
+    const stack = new cdk.Stack();
+    const role = new iam.Role(stack, 'SomeRole', {
+      assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
+    });
+    const layer1 = new lambda.LayerVersion(stack, 'LayerVersion1', {
+      code: lambda.Code.fromAsset(path.join(__dirname, 'my-lambda-handler')),
+      compatibleRuntimes: [lambda.Runtime.PYTHON_3_13],
+    });
+    const layer2 = new lambda.LayerVersion(stack, 'LayerVersion2', {
+      code: lambda.Code.fromAsset(path.join(__dirname, 'my-lambda-handler')),
+      compatibleRuntimes: [lambda.Runtime.PYTHON_3_13],
+    });
+    new lambda.CfnFunction(stack, 'MyLambda', {
+      code: { zipFile: 'foo' },
+      role: role,
+      layers: [layer1, layer2], // Array of Unions
+    });
+    Template.fromStack(stack).hasResource('AWS::Lambda::Function', {
+      Properties: {
+        Role: { 'Fn::GetAtt': ['SomeRole6DDC54DD', 'Arn'] },
+        Layers: [{ Ref: 'LayerVersion139D4D7A8' }, { Ref: 'LayerVersion23E5F3CEA' }],
+      },
+    });
+  });
+
+  it('nested union', () => {
+    const stack = new cdk.Stack();
+    const role = new iam.Role(stack, 'SomeRole', {
+      assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
+    });
+    const bucket = new s3.Bucket(stack, 'MyBucket');
+
+    new lambda.CfnFunction(stack, 'MyLambda', {
+      code: {
+        s3Bucket: bucket, // Nested union
+      },
+      role: role,
+    });
+    Template.fromStack(stack).hasResource('AWS::Lambda::Function', {
+      Properties: {
+        Role: { 'Fn::GetAtt': ['SomeRole6DDC54DD', 'Arn'] },
+        Code: { S3Bucket: { Ref: 'MyBucketF68F3FF0' } },
+      },
+    });
+  });
+
+  it('deeply nested union', () => {
+    const stack = new cdk.Stack();
+    const topic = new sns.CfnTopic(stack, 'Topic');
+
+    new lambda.CfnEventInvokeConfig(stack, 'EventConfig', {
+      functionName: 'myFunction',
+      qualifier: '$LATEST',
+      destinationConfig: {
+        onFailure: {
+          destination: topic, // Deeply nested: destinationConfig -> onFailure -> destination (union)
+        },
+      },
+    });
+    Template.fromStack(stack).hasResource('AWS::Lambda::EventInvokeConfig', {
+      Properties: {
+        DestinationConfig: {
+          OnFailure: {
+            Destination: { Ref: 'Topic' },
+          },
+        },
+      },
+    });
+  });
+
+  it('nested array of unions', () => {
+    const stack = new cdk.Stack();
+    const role = new iam.Role(stack, 'SomeRole', {
+      assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),
+    });
+    const securityGroup = new ec2.SecurityGroup(stack, 'SG', {
+      vpc: new ec2.Vpc(stack, 'VPC'),
+    });
+    new lambda.CfnFunction(stack, 'MyLambda', {
+      code: { zipFile: 'foo' },
+      role: role,
+      vpcConfig: {
+        securityGroupIds: [securityGroup], // Nested array of union
+      },
+    });
+    Template.fromStack(stack).hasResource('AWS::Lambda::Function', {
+      Properties: {
+        Role: { 'Fn::GetAtt': ['SomeRole6DDC54DD', 'Arn'] },
+        VpcConfig: {
+          SecurityGroupIds: [{ 'Fn::GetAtt': ['SGADB53937', 'GroupId'] }],
+        },
+      },
+    });
+  });
+});
+
 function newTestLambda(scope: constructs.Construct) {
   return new lambda.Function(scope, 'MyLambda', {
     code: new lambda.InlineCode('foo'),

tools/@aws-cdk/spec2cdk/lib/cdk/ast.ts

@@ -3,6 +3,7 @@ import { Module } from '@cdklabs/typewriter';
 import { AugmentationsModule } from './augmentation-generator';
 import { CannedMetricsModule } from './canned-metrics';
 import { CDK_CORE, CONSTRUCTS, ModuleImportLocations } from './cdk';
+import { SelectiveImport } from './relationship-decider';
 import { ResourceClass } from './resource-class';
 
 /**
@@ -59,7 +60,7 @@ export class AstBuilder<T extends Module> {
     for (const link of resources) {
       ast.addResource(link.entity);
     }
-
+    ast.renderImports();
     return ast;
   }
 
@@ -74,6 +75,7 @@ export class AstBuilder<T extends Module> {
 
     const ast = new AstBuilder(scope, props, aug, metrics);
     ast.addResource(resource);
+    ast.renderImports();
 
     return ast;
   }
@@ -85,6 +87,8 @@ export class AstBuilder<T extends Module> {
   public readonly resources: Record<string, string> = {};
   private nameSuffix?: string;
   private deprecated?: string;
+  public readonly selectiveImports = new Array<SelectiveImport>();
+  private readonly modulesRootLocation: string;
 
   protected constructor(
     public readonly module: T,
@@ -95,6 +99,7 @@ export class AstBuilder<T extends Module> {
     this.db = props.db;
     this.nameSuffix = props.nameSuffix;
     this.deprecated = props.deprecated;
+    this.modulesRootLocation = props.importLocations?.modulesRoot ?? '../..';
 
     CDK_CORE.import(this.module, 'cdk', { fromLocation: props.importLocations?.core });
     CONSTRUCTS.import(this.module, 'constructs');
@@ -111,6 +116,35 @@ export class AstBuilder<T extends Module> {
 
     resourceClass.build();
 
+    this.addImports(resourceClass);
     this.augmentations?.augmentResource(resource, resourceClass);
   }
+
+  private addImports(resourceClass: ResourceClass) {
+    for (const selectiveImport of resourceClass.imports) {
+      const existingModuleImport = this.selectiveImports.find(
+        (imp) => imp.moduleName === selectiveImport.moduleName,
+      );
+      if (!existingModuleImport) {
+        this.selectiveImports.push(selectiveImport);
+      } else {
+        // We need to avoid importing the same reference multiple times
+        for (const type of selectiveImport.types) {
+          if (!existingModuleImport.types.find((t) =>
+            t.originalType === type.originalType && t.aliasedType === type.aliasedType,
+          )) {
+            existingModuleImport.types.push(type);
+          }
+        }
+      }
+    }
+  }
+
+  public renderImports() {
+    const sortedImports = this.selectiveImports.sort((a, b) => a.moduleName.localeCompare(b.moduleName));
+    for (const selectiveImport of sortedImports) {
+      const sourceModule = new Module(selectiveImport.moduleName);
+      sourceModule.importSelective(this.module, selectiveImport.types.map((t) => `${t.originalType} as ${t.aliasedType}`), { fromLocation: `${this.modulesRootLocation}/${sourceModule.name}` });
+    }
+  }
 }

tools/@aws-cdk/spec2cdk/lib/cdk/cdk.ts

@@ -22,6 +22,11 @@ export interface ModuleImportLocations {
    * @default 'aws-cdk-lib/aws-cloudwatch'
    */
   readonly cloudwatch?: string;
+  /**
+   * The root location of all the modules
+   * @default '../..'
+   */
+  readonly modulesRoot?: string;
 }
 
 export class CdkCore extends ExternalModule {

tools/@aws-cdk/spec2cdk/lib/cdk/reference-props.ts

@@ -0,0 +1,86 @@
+import { Resource } from '@aws-cdk/service-spec-types';
+import { $E, expr, Expression, PropertySpec, Type } from '@cdklabs/typewriter';
+import { attributePropertyName, referencePropertyName } from '../naming';
+import { CDK_CORE } from './cdk';
+
+export interface ReferenceProp {
+  readonly declaration: PropertySpec;
+  readonly cfnValue: Expression;
+}
+
+// Convenience typewriter builder
+const $this = $E(expr.this_());
+
+export function getReferenceProps(resource: Resource): ReferenceProp[] {
+  const referenceProps = [];
+  // Primary identifier. We assume all parts are strings.
+  const primaryIdentifier = resource.primaryIdentifier ?? [];
+  if (primaryIdentifier.length === 1) {
+    referenceProps.push({
+      declaration: {
+        name: referencePropertyName(primaryIdentifier[0], resource.name),
+        type: Type.STRING,
+        immutable: true,
+        docs: {
+          summary: `The ${primaryIdentifier[0]} of the ${resource.name} resource.`,
+        },
+      },
+      cfnValue: $this.ref,
+    });
+  } else if (primaryIdentifier.length > 1) {
+    for (const [i, cfnName] of enumerate(primaryIdentifier)) {
+      referenceProps.push({
+        declaration: {
+          name: referencePropertyName(cfnName, resource.name),
+          type: Type.STRING,
+          immutable: true,
+          docs: {
+            summary: `The ${cfnName} of the ${resource.name} resource.`,
+          },
+        },
+        cfnValue: splitSelect('|', i, $this.ref),
+      });
+    }
+  }
+
+  const arnProp = findArnProperty(resource);
+  if (arnProp) {
+    referenceProps.push({
+      declaration: {
+        name: referencePropertyName(arnProp, resource.name),
+        type: Type.STRING,
+        immutable: true,
+        docs: {
+          summary: `The ARN of the ${resource.name} resource.`,
+        },
+      },
+      cfnValue: $this[attributePropertyName(arnProp)],
+    });
+  }
+  return referenceProps;
+}
+
+/**
+ * Find an ARN property for a given resource
+ *
+ * Returns `undefined` if no ARN property is found, or if the ARN property is already
+ * included in the primary identifier.
+ */
+export function findArnProperty(resource: Resource) {
+  const possibleArnNames = ['Arn', `${resource.name}Arn`];
+  for (const name of possibleArnNames) {
+    const prop = resource.attributes[name];
+    if (prop && !resource.primaryIdentifier?.includes(name)) {
+      return name;
+    }
+  }
+  return undefined;
+}
+
+function splitSelect(sep: string, n: number, base: Expression) {
+  return CDK_CORE.Fn.select(expr.lit(n), CDK_CORE.Fn.split(expr.lit(sep), base));
+}
+
+function enumerate<A>(xs: A[]): Array<[number, A]> {
+  return xs.map((x, i) => [i, x]);
+}