feat: new resource interfaces shared by both L1s and L2s

packages/awslint/lib/rules/core-types.ts

@@ -44,11 +44,7 @@ export class CoreTypes {
       return false;
     }
 
-    if (!c.name.startsWith('Cfn')) {
-      return false;
-    }
-
-    return true;
+    return c.name.startsWith('Cfn');
   }
 
   /**
@@ -86,10 +82,11 @@ export class CoreTypes {
   }
 
   /**
-   * Return true if the given interface type is a CFN class or prop type
+   * Return true if the given interface type is a CFN class, prop type or interface
    */
   public static isCfnType(interfaceType: reflect.Type) {
     return interfaceType.name.startsWith('Cfn')
+      || interfaceType.name.startsWith('ICfn')
       || (interfaceType.namespace && interfaceType.namespace.startsWith('Cfn'))
       // aws_service.CfnTheResource.SubType
       || (interfaceType.namespace && interfaceType.namespace.split('.', 2).at(1)?.startsWith('Cfn'));

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

@@ -20,6 +20,7 @@ import {
   Stability,
   ObjectLiteral,
   Module,
+  InterfaceType,
 } from '@cdklabs/typewriter';
 import { CDK_CORE, CONSTRUCTS } from './cdk';
 import { CloudFormationMapping } from './cloudformation-mapping';
@@ -33,6 +34,7 @@ import {
   cfnProducerNameFromType,
   propStructNameFromResource,
   staticRequiredTransform,
+  interfaceNameFromResource,
 } from '../naming';
 import { splitDocumentation } from '../util';
 
@@ -45,6 +47,7 @@ const $this = $E(expr.this_());
 
 export class ResourceClass extends ClassType {
   private readonly propsType: StructType;
+  private readonly resourceInterface: InterfaceType;
   private readonly decider: ResourceDecider;
   private readonly converter: TypeConverter;
   private readonly module: Module;
@@ -55,6 +58,16 @@ export class ResourceClass extends ClassType {
     private readonly resource: Resource,
     private readonly suffix?: string,
   ) {
+    const resourceInterface = new InterfaceType(scope, {
+      export: true,
+      name: interfaceNameFromResource(resource, suffix),
+      docs: {
+        summary: `Attributes to reference a \`${classNameFromResource(resource)}\`.`,
+        stability: Stability.External,
+      },
+      extends: [CONSTRUCTS.IConstruct],
+    });
+
     super(scope, {
       export: true,
       name: classNameFromResource(resource, suffix),
@@ -67,9 +80,10 @@ export class ResourceClass extends ClassType {
         }),
       },
       extends: CDK_CORE.CfnResource,
-      implements: [CDK_CORE.IInspectable, ...ResourceDecider.taggabilityInterfaces(resource)],
+      implements: [CDK_CORE.IInspectable, resourceInterface.type, ...ResourceDecider.taggabilityInterfaces(resource)],
     });
 
+    this.resourceInterface = resourceInterface;
     this.module = Module.of(this);
 
     this.propsType = new StructType(this.scope, {
@@ -105,6 +119,14 @@ export class ResourceClass extends ClassType {
       cfnMapping.add(prop.cfnMapping);
     }
 
+    // Build the shared interface
+    for (const identifier of this.decider.primaryIdentifier ?? []) {
+      this.resourceInterface.addProperty({
+        ...identifier,
+        immutable: true,
+      });
+    }
+
     // Build the members of this class
     this.addProperty({
       name: staticResourceTypeName(),

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

@@ -10,6 +10,9 @@ import { splitDocumentation } from '../util';
 // This convenience typewriter builder is used all over the place
 const $this = $E(expr.this_());
 
+// This convenience typewriter builder is used for cloudformation intrinsics
+const $Fn = $E(expr.directCode('cdk.Fn'));
+
 /**
  * Decide how properties get mapped between model types, Typescript types, and CloudFormation
  */
@@ -25,6 +28,7 @@ export class ResourceDecider {
 
   private readonly taggability?: TaggabilityStyle;
 
+  public readonly primaryIdentifier = new Array<PropertySpec>();
   public readonly propsProperties = new Array<PropsProperty>();
   public readonly classProperties = new Array<ClassProperty>();
   public readonly classAttributeProperties = new Array<ClassAttributeProperty>();
@@ -35,6 +39,8 @@ export class ResourceDecider {
     this.convertProperties();
     this.convertAttributes();
 
+    this.convertPrimaryIdentifier();
+
     this.propsProperties.sort((p1, p2) => p1.propertySpec.name.localeCompare(p2.propertySpec.name));
     this.classProperties.sort((p1, p2) => p1.propertySpec.name.localeCompare(p2.propertySpec.name));
     this.classAttributeProperties.sort((p1, p2) => p1.propertySpec.name.localeCompare(p2.propertySpec.name));
@@ -59,6 +65,73 @@ export class ResourceDecider {
     }
   }
 
+  private convertPrimaryIdentifier() {
+    if (this.resource.primaryIdentifier === undefined) { return; }
+    for (let i = 0; i < (this.resource.primaryIdentifier).length; i++) {
+      const cfnName = this.resource.primaryIdentifier[i];
+      const att = this.findAttributeByName(attributePropertyName(cfnName));
+      const prop = this.findPropertyByName(propertyNameFromCloudFormation(cfnName));
+      if (att) {
+        this.primaryIdentifier.push(att);
+      } else if (prop) {
+        const propSpec = prop.propertySpec;
+
+        // Build an attribute out of the property we're getting
+        // Create initializer for new attribute, if possible
+        let initializer: Expression | undefined = undefined;
+        if (propSpec.type === Type.STRING) { // handling only this case for now
+          if (this.resource.primaryIdentifier!.length === 1) {
+            initializer = CDK_CORE.tokenAsString($this.ref);
+          } else {
+            initializer = CDK_CORE.tokenAsString($Fn.select(expr.lit(i), $Fn.split(expr.lit('|'), $this.ref)));
+          }
+        }
+
+        // If we cannot come up with an initializer, we're dropping this property on the floor
+        if (!initializer) { continue; }
+
+        // Build an attribute spec out of the property spec
+        const attrPropertySpec = this.convertPropertySpecToRefAttribute(propSpec);
+
+        // Add the new attribute to the relevant places
+        this.classAttributeProperties.push({
+          propertySpec: attrPropertySpec,
+          initializer,
+        });
+
+        this.primaryIdentifier.push(attrPropertySpec);
+      }
+    }
+  }
+
+  private convertPropertySpecToRefAttribute(propSpec: PropertySpec): PropertySpec {
+    return {
+      ...propSpec,
+      name: attributePropertyName(propSpec.name[0].toUpperCase() + propSpec.name.slice(1)),
+      docs: {
+        ...propSpec.docs,
+        summary: (propSpec.docs?.summary ?? '').concat('\nThis property gets determined after the resource is created.'),
+        remarks: (propSpec.docs?.remarks ?? '').concat('@cloudformationAttribute Ref'),
+      },
+      immutable: true,
+      optional: false,
+    };
+  }
+
+  private findPropertyByName(name: string): ClassProperty | undefined {
+    const props = this.classProperties.filter((prop) => prop.propertySpec.name === name);
+    // there's no way we have multiple properties with the same name
+    if (props.length > 0) { return props[0]; }
+    return;
+  }
+
+  private findAttributeByName(name: string): PropertySpec | undefined {
+    const atts = this.classAttributeProperties.filter((att) => att.propertySpec.name === name);
+    // there's no way we have multiple attributes with the same name
+    if (atts.length > 0) { return atts[0].propertySpec; }
+    return;
+  }
+
   /**
    * Default mapping for a property
    */

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

@@ -55,6 +55,10 @@ export function propStructNameFromResource(res: Resource, suffix?: string) {
   return `${classNameFromResource(res, suffix)}Props`;
 }
 
+export function interfaceNameFromResource(res: Resource, suffix?: string) {
+  return `I${classNameFromResource(res, suffix)}`;
+}
+
 export function cfnProducerNameFromType(struct: TypeDeclaration) {
   return `convert${qualifiedName(struct)}ToCloudFormation`;
 }