Merge branch 'master' into huijbers/cli-default-profile

Author: mergify[bot]

packages/@aws-cdk/aws-appsync/lib/private.ts

@@ -1,8 +1,5 @@
-function concatAndDedup<T>(left: T[], right: T[]): T[] {
-  return left.concat(right).filter((elem, index, self) => {
-    return index === self.indexOf(elem);
-  });
-}
+import { Directive } from './schema-base';
+import { InterfaceType } from './schema-intermediate';
 
 /**
  * Utility enum for Schema class
@@ -12,6 +9,69 @@ export enum SchemaMode {
   CODE = 'CODE',
 };
 
+/**
+ * Generates an addition to the schema
+ *
+ * ```
+ * prefix name interfaces directives {
+ *   field
+ *   field
+ *   ...
+ * }
+ * ```
+ */
+export interface SchemaAdditionOptions {
+  /**
+   * the prefix for this additon (type, interface, enum, input, schema)
+   */
+  readonly prefix: string;
+  /**
+   * the name for this addition (some additions dont need this [i.e. schema])
+   *
+   * @default - no name
+   */
+  readonly name?: string;
+  /**
+   * the interface types if this is creating an object type
+   *
+   * @default - no interfaces
+   */
+  readonly interfaceTypes?: InterfaceType[];
+  /**
+   * the directives for this type
+   *
+   * @default - no directives
+   */
+  readonly directives?: Directive[];
+  /**
+   * the fields to reduce onto the addition
+   */
+  readonly fields: string[];
+}
+
+/**
+ * Generates an addition to the schema
+ *
+ * @param options the options to produced a stringfied addition
+ *
+ * @returns the following shape:
+ *
+ * ```
+ * prefix name interfaces directives {
+ *   field
+ *   field
+ *   ...
+ * }
+ * ```
+ */
+export function shapeAddition(options: SchemaAdditionOptions): string {
+  const typeName = (): string => { return options.name ? ` ${options.name}` : ''; };
+  const interfaces = generateInterfaces(options.interfaceTypes);
+  const directives = generateDirectives(options.directives);
+  return options.fields.reduce((acc, field) =>
+    `${acc}  ${field}\n`, `${options.prefix}${typeName()}${interfaces}${directives} {\n`) + '}';
+}
+
 /**
  * Utility class to represent DynamoDB key conditions.
  */
@@ -118,4 +178,33 @@ export class Between extends BaseKeyCondition {
   public args(): string[] {
     return [this.arg1, this.arg2];
   }
+}
+
+function concatAndDedup<T>(left: T[], right: T[]): T[] {
+  return left.concat(right).filter((elem, index, self) => {
+    return index === self.indexOf(elem);
+  });
+}
+
+/**
+ * Utility function to generate interfaces for object types
+ *
+ * @param interfaceTypes the interfaces this object type implements
+ */
+function generateInterfaces(interfaceTypes?: InterfaceType[]): string {
+  if (!interfaceTypes || interfaceTypes.length === 0) return '';
+  return interfaceTypes.reduce((acc, interfaceType) =>
+    `${acc} ${interfaceType.name},`, ' implements').slice(0, -1);
+}
+
+/**
+ * Utility function to generate directives
+ *
+ * @param directives the directives of a given type
+ * @param delimiter the separator betweeen directives (by default we will add a space)
+ */
+function generateDirectives(directives?: Directive[], delimiter?: string): string {
+  if (!directives || directives.length === 0) return '';
+  return directives.reduce((acc, directive) =>
+    `${acc}${directive.statement}${delimiter ?? ' '}`, ' ').slice(0, -1);
 }

packages/@aws-cdk/aws-appsync/lib/schema-intermediate.ts

@@ -1,3 +1,4 @@
+import { shapeAddition } from './private';
 import { Resolver } from './resolver';
 import { Directive, IField, IIntermediateType } from './schema-base';
 import { BaseTypeOptions, GraphqlType, ResolvableFieldOptions } from './schema-field';
@@ -59,13 +60,12 @@ export class InterfaceType implements IIntermediateType {
    * Generate the string of this object type
    */
   public toString(): string {
-    let schemaAddition = `interface ${this.name} {\n`;
-    Object.keys(this.definition).forEach( (key) => {
-      const attribute = this.definition[key];
-      const args = attribute.argsToString();
-      schemaAddition = `${schemaAddition}  ${key}${args}: ${attribute.toString()}\n`;
+    return shapeAddition({
+      prefix: 'interface',
+      name: this.name,
+      fields: Object.keys(this.definition).map((key) =>
+        `${key}${this.definition[key].argsToString()}: ${this.definition[key].toString()}`),
     });
-    return `${schemaAddition}}`;
   }
 
   /**
@@ -159,38 +159,14 @@ export class ObjectType extends InterfaceType implements IIntermediateType {
    * Generate the string of this object type
    */
   public toString(): string {
-    let title = this.name;
-    if (this.interfaceTypes && this.interfaceTypes.length) {
-      title = `${title} implements`;
-      this.interfaceTypes.map((interfaceType) => {
-        title = `${title} ${interfaceType.name},`;
-      });
-      title = title.slice(0, -1);
-    }
-    const directives = this.generateDirectives(this.directives);
-    let schemaAddition = `type ${title} ${directives}{\n`;
-    Object.keys(this.definition).forEach( (key) => {
-      const attribute = this.definition[key];
-      const args = attribute.argsToString();
-      schemaAddition = `${schemaAddition}  ${key}${args}: ${attribute.toString()}\n`;
-    });
-    return `${schemaAddition}}`;
-  }
-
-  /**
-   * Utility function to generate directives
-   *
-   * @param directives the directives of a given type
-   * @param delimiter the separator betweeen directives
-   * @default - ' '
-   */
-  private generateDirectives(directives?: Directive[], delimiter?: string): string {
-    let schemaAddition = '';
-    if (!directives) { return schemaAddition; }
-    directives.map((directive) => {
-      schemaAddition = `${schemaAddition}${directive.statement}${delimiter ?? ' '}`;
+    return shapeAddition({
+      prefix: 'type',
+      name: this.name,
+      interfaceTypes: this.interfaceTypes,
+      directives: this.directives,
+      fields: Object.keys(this.definition).map((key) =>
+        `${key}${this.definition[key].argsToString()}: ${this.definition[key].toString()}`),
     });
-    return schemaAddition;
   }
 
   /**

packages/@aws-cdk/aws-cloudfront/README.md

@@ -82,7 +82,7 @@ new cloudfront.Distribution(this, 'myDist', {
 });
 ```
 
-## From an HTTP endpoint
+#### From an HTTP endpoint
 
 Origins can also be created from any other HTTP endpoint, given the domain name, and optionally, other origin properties.
 
@@ -246,6 +246,18 @@ new cloudfront.Distribution(this, 'myDist', {
 });
 ```
 
+### Importing Distributions
+
+Existing distributions can be imported as well; note that like most imported constructs, an imported distribution cannot be modified.
+However, it can be used as a reference for other higher-level constructs.
+
+```ts
+const distribution = cloudfront.Distribution.fromDistributionAttributes(scope, 'ImportedDist', {
+  domainName: 'd111111abcdef8.cloudfront.net',
+  distributionId: '012345ABCDEF',
+});
+```
+
 ## CloudFrontWebDistribution API - Stable
 
 ![cdk-constructs: Stable](https://img.shields.io/badge/cdk--constructs-stable-success.svg?style=for-the-badge)
@@ -305,7 +317,7 @@ Example:
 
 [create a distrubution with an iam certificate example](test/example.iam-cert-alias.lit.ts)
 
-#### Restrictions
+### Restrictions
 
 CloudFront supports adding restrictions to your distribution.
 

packages/@aws-cdk/aws-cloudfront/lib/private/cache-behavior.ts

@@ -1,5 +1,6 @@
+import * as iam from '@aws-cdk/aws-iam';
 import { CfnDistribution } from '../cloudfront.generated';
-import { AddBehaviorOptions, ViewerProtocolPolicy } from '../distribution';
+import { AddBehaviorOptions, EdgeLambda, ViewerProtocolPolicy } from '../distribution';
 
 /**
  * Properties for specifying custom behaviors for origins.
@@ -24,6 +25,8 @@ export class CacheBehavior {
 
   constructor(originId: string, private readonly props: CacheBehaviorProps) {
     this.originId = originId;
+
+    this.grantEdgeLambdaFunctionExecutionRole(props.edgeLambdas);
   }
 
   /**
@@ -55,4 +58,17 @@ export class CacheBehavior {
         : undefined,
     };
   }
+
+  private grantEdgeLambdaFunctionExecutionRole(edgeLambdas?: EdgeLambda[]) {
+    if (!edgeLambdas || edgeLambdas.length === 0) { return; }
+    edgeLambdas.forEach((edgeLambda) => {
+      const role = edgeLambda.functionVersion.role;
+      if (role && role instanceof iam.Role && role.assumeRolePolicy) {
+        role.assumeRolePolicy.addStatements(new iam.PolicyStatement({
+          actions: ['sts:AssumeRole'],
+          principals: [new iam.ServicePrincipal('edgelambda.amazonaws.com')],
+        }));
+      }
+    });
+  }
 }

packages/@aws-cdk/aws-cloudfront/lib/web_distribution.ts

@@ -628,6 +628,27 @@ interface BehaviorWithOrigin extends Behavior {
   readonly targetOriginId: string;
 }
 
+/**
+ * Attributes used to import a Distribution.
+ *
+ * @experimental
+ */
+export interface CloudFrontWebDistributionAttributes {
+  /**
+   * The generated domain name of the Distribution, such as d111111abcdef8.cloudfront.net.
+   *
+   * @attribute
+   */
+  readonly domainName: string;
+
+  /**
+   * The distribution ID for this distribution.
+   *
+   * @attribute
+   */
+  readonly distributionId: string;
+}
+
 /**
  * Amazon CloudFront is a global content delivery network (CDN) service that securely delivers data, videos,
  * applications, and APIs to your viewers with low latency and high transfer speeds.
@@ -659,6 +680,25 @@ interface BehaviorWithOrigin extends Behavior {
  * @resource AWS::CloudFront::Distribution
  */
 export class CloudFrontWebDistribution extends cdk.Resource implements IDistribution {
+
+  /**
+   * Creates a construct that represents an external (imported) distribution.
+   */
+  public static fromDistributionAttributes(scope: cdk.Construct, id: string, attrs: CloudFrontWebDistributionAttributes): IDistribution {
+    return new class extends cdk.Resource implements IDistribution {
+      public readonly domainName: string;
+      public readonly distributionDomainName: string;
+      public readonly distributionId: string;
+
+      constructor() {
+        super(scope, id);
+        this.domainName = attrs.domainName;
+        this.distributionDomainName = attrs.domainName;
+        this.distributionId = attrs.distributionId;
+      }
+    }();
+  }
+
   /**
    * The logging bucket for this CloudFront distribution.
    * If logging is not enabled for this distribution - this property will be undefined.

packages/@aws-cdk/aws-cloudfront/test/distribution.test.ts

@@ -489,6 +489,42 @@ describe('with Lambda@Edge functions', () => {
     });
   });
 
+  test('edgelambda.amazonaws.com is added to the trust policy of lambda', () => {
+    new Distribution(stack, 'MyDist', {
+      defaultBehavior: {
+        origin,
+        edgeLambdas: [
+          {
+            functionVersion: lambdaFunction.currentVersion,
+            eventType: LambdaEdgeEventType.ORIGIN_REQUEST,
+          },
+        ],
+      },
+    });
+
+    expect(stack).toHaveResource('AWS::IAM::Role', {
+      AssumeRolePolicyDocument: {
+        Statement: [
+          {
+            Action: 'sts:AssumeRole',
+            Effect: 'Allow',
+            Principal: {
+              Service: 'lambda.amazonaws.com',
+            },
+          },
+          {
+            Action: 'sts:AssumeRole',
+            Effect: 'Allow',
+            Principal: {
+              Service: 'edgelambda.amazonaws.com',
+            },
+          },
+        ],
+        Version: '2012-10-17',
+      },
+    });
+  });
+
   test('can add an edge lambdas to additional behaviors', () => {
     new Distribution(stack, 'MyDist', {
       defaultBehavior: { origin },