@aws-cdk/aws-lambda - npm Package Compare versions

Comparing version 0.28.0 to 0.29.0

lib/alias.d.ts

 import cloudwatch = require('@aws-cdk/aws-cloudwatch');
-import cdk = require('@aws-cdk/cdk');
+import { Construct } from '@aws-cdk/cdk';
 import { FunctionBase, FunctionImportProps } from './function-base';
@@ -49,2 +49,6 @@ import { Version } from './lambda-version';
     /**
+     * Name of this alias.
+     */
+    readonly aliasName: string;
+    /**
      * ARN of this alias
@@ -68,3 +72,3 @@ *
     private readonly underlyingLambda;
-    constructor(scope: cdk.Construct, id: string, props: AliasProps);
+    constructor(scope: Construct, id: string, props: AliasProps);
     /**
@@ -75,3 +79,3 @@ * Role associated with this alias
     readonly grantPrincipal: import("@aws-cdk/aws-iam").IPrincipal;
-    metric(metricName: string, props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+    metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;
     export(): FunctionImportProps;
@@ -78,0 +82,0 @@ /**

lib/alias.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const cdk = require("@aws-cdk/cdk");
+const cdk_1 = require("@aws-cdk/cdk");
 const function_base_1 = require("./function-base");
@@ -13,2 +13,3 @@ const lambda_generated_1 = require("./lambda.generated");
         this.canCreatePermissions = true;
+        this.aliasName = props.aliasName;
         this.underlyingLambda = props.version.lambda;
@@ -39,10 +40,16 @@ const alias = new lambda_generated_1.CfnAlias(this, 'Resource', {
         // Metrics on Aliases need the "bare" function name, and the alias' ARN, this differes from the base behavior.
-        return super.metric(metricName, Object.assign({ dimensions: {
+        return super.metric(metricName, {
+            dimensions: {
                 FunctionName: this.underlyingLambda.functionName,
-                Resource: this.functionArn
-            } }, props));
+                // construct the ARN from the underlying lambda so that alarms on an alias
+                // don't cause a circular dependency with CodeDeploy
+                // see: https://github.com/awslabs/aws-cdk/issues/2231
+                Resource: `${this.underlyingLambda.functionArn}:${this.aliasName}`
+            },
+            ...props
+        });
     }
     export() {
         return {
-            functionArn: new cdk.CfnOutput(this, 'AliasArn', { value: this.functionArn }).makeImportValue().toString()
+            functionArn: new cdk_1.CfnOutput(this, 'AliasArn', { value: this.functionArn }).makeImportValue().toString()
         };
@@ -85,2 +92,2 @@ }
 exports.Alias = Alias;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alias.js","sourceRoot":"","sources":["alias.ts"],"names":[],"mappings":"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","sourcesContent":["import cloudwatch = require('@aws-cdk/aws-cloudwatch');\nimport cdk = require('@aws-cdk/cdk');\nimport { FunctionBase, FunctionImportProps, IFunction } from './function-base';\nimport { Version } from './lambda-version';\nimport { CfnAlias } from './lambda.generated';\n\n/**\n * Properties for a new Lambda alias\n */\nexport interface AliasProps {\n  /**\n   * Description for the alias\n   *\n   * @default No description\n   */\n  readonly description?: string;\n\n  /**\n   * Function version this alias refers to\n   *\n   * Use lambda.addVersion() to obtain a new lambda version to refer to.\n   */\n  readonly version: Version;\n\n  /**\n   * Name of this alias\n   */\n  readonly aliasName: string;\n\n  /**\n   * Additional versions with individual weights this alias points to\n   *\n   * Individual additional version weights specified here should add up to\n   * (less than) one. All remaining weight is routed to the default\n   * version.\n   *\n   * For example, the config is\n   *\n   *    version: \"1\"\n   *    additionalVersions: [{ version: \"2\", weight: 0.05 }]\n   *\n   * Then 5% of traffic will be routed to function version 2, while\n   * the remaining 95% of traffic will be routed to function version 1.\n   *\n   * @default No additional versions\n   */\n  readonly additionalVersions?: VersionWeight[];\n}\n\n/**\n * A new alias to a particular version of a Lambda function.\n */\nexport class Alias extends FunctionBase {\n  /**\n   * ARN of this alias\n   *\n   * Used to be able to use Alias in place of a regular Lambda. Lambda accepts\n   * ARNs everywhere it accepts function names.\n   */\n  public readonly functionName: string;\n\n  /**\n   * ARN of this alias\n   *\n   * Used to be able to use Alias in place of a regular Lambda. Lambda accepts\n   * ARNs everywhere it accepts function names.\n   */\n  public readonly functionArn: string;\n\n  protected readonly canCreatePermissions: boolean = true;\n\n  /**\n   * The actual Lambda function object that this Alias is pointing to\n   */\n  private readonly underlyingLambda: IFunction;\n\n  constructor(scope: cdk.Construct, id: string, props: AliasProps) {\n    super(scope, id);\n\n    this.underlyingLambda = props.version.lambda;\n\n    const alias = new CfnAlias(this, 'Resource', {\n      name: props.aliasName,\n      description: props.description,\n      functionName: this.underlyingLambda.functionName,\n      functionVersion: props.version.functionVersion,\n      routingConfig: this.determineRoutingConfig(props)\n    });\n\n    // ARN parsing splits on `:`, so we can only get the function's name from the ARN as resourceName...\n    // And we're parsing it out (instead of using the underlying function directly) in order to have use of it incur\n    // an implicit dependency on the resource.\n    this.functionName = `${this.node.stack.parseArn(alias.aliasArn, \":\").resourceName!}:${props.aliasName}`;\n    this.functionArn = alias.aliasArn;\n  }\n\n  /**\n   * Role associated with this alias\n   */\n  public get role() {\n    return this.underlyingLambda.role;\n  }\n\n  public get grantPrincipal() {\n    return this.underlyingLambda.grantPrincipal;\n  }\n\n  public metric(metricName: string, props: cloudwatch.MetricCustomization = {}): cloudwatch.Metric {\n    // Metrics on Aliases need the \"bare\" function name, and the alias' ARN, this differes from the base behavior.\n    return super.metric(metricName, {\n      dimensions: {\n        FunctionName: this.underlyingLambda.functionName,\n        Resource: this.functionArn\n      },\n      ...props\n    });\n  }\n\n  public export(): FunctionImportProps {\n    return {\n      functionArn: new cdk.CfnOutput(this, 'AliasArn', { value: this.functionArn }).makeImportValue().toString()\n    };\n  }\n\n  /**\n   * Calculate the routingConfig parameter from the input props\n   */\n  private determineRoutingConfig(props: AliasProps) {\n    if (!props.additionalVersions || props.additionalVersions.length === 0) {\n      return undefined;\n    }\n\n    this.validateAdditionalWeights(props.additionalVersions);\n\n    return {\n      additionalVersionWeights: props.additionalVersions.map(vw => {\n        return {\n          functionVersion: vw.version.functionVersion,\n          functionWeight: vw.weight\n        };\n      })\n    };\n  }\n\n  /**\n   * Validate that the additional version weights make sense\n   *\n   * We validate that they are positive and add up to something <= 1.\n   */\n  private validateAdditionalWeights(weights: VersionWeight[]) {\n    const total = weights.map(w => {\n      if (w.weight < 0 || w.weight > 1) { throw new Error(`Additional version weight must be between 0 and 1, got: ${w.weight}`); }\n      return w.weight;\n    }).reduce((a, x) => a + x);\n\n    if (total > 1) {\n      throw new Error(`Sum of additional version weights must not exceed 1, got: ${total}`);\n    }\n  }\n}\n\n/**\n * A version/weight pair for routing traffic to Lambda functions\n */\nexport interface VersionWeight {\n  /**\n   * The version to route traffic to\n   */\n  readonly version: Version;\n\n  /**\n   * How much weight to assign to this version (0..1)\n   */\n  readonly weight: number;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"alias.js","sourceRoot":"","sources":["alias.ts"],"names":[],"mappings":"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","sourcesContent":["import cloudwatch = require('@aws-cdk/aws-cloudwatch');\nimport { CfnOutput, Construct } from '@aws-cdk/cdk';\nimport { FunctionBase, FunctionImportProps, IFunction } from './function-base';\nimport { Version } from './lambda-version';\nimport { CfnAlias } from './lambda.generated';\n\n/**\n * Properties for a new Lambda alias\n */\nexport interface AliasProps {\n  /**\n   * Description for the alias\n   *\n   * @default No description\n   */\n  readonly description?: string;\n\n  /**\n   * Function version this alias refers to\n   *\n   * Use lambda.addVersion() to obtain a new lambda version to refer to.\n   */\n  readonly version: Version;\n\n  /**\n   * Name of this alias\n   */\n  readonly aliasName: string;\n\n  /**\n   * Additional versions with individual weights this alias points to\n   *\n   * Individual additional version weights specified here should add up to\n   * (less than) one. All remaining weight is routed to the default\n   * version.\n   *\n   * For example, the config is\n   *\n   *    version: \"1\"\n   *    additionalVersions: [{ version: \"2\", weight: 0.05 }]\n   *\n   * Then 5% of traffic will be routed to function version 2, while\n   * the remaining 95% of traffic will be routed to function version 1.\n   *\n   * @default No additional versions\n   */\n  readonly additionalVersions?: VersionWeight[];\n}\n\n/**\n * A new alias to a particular version of a Lambda function.\n */\nexport class Alias extends FunctionBase {\n  /**\n   * Name of this alias.\n   */\n  public readonly aliasName: string;\n  /**\n   * ARN of this alias\n   *\n   * Used to be able to use Alias in place of a regular Lambda. Lambda accepts\n   * ARNs everywhere it accepts function names.\n   */\n  public readonly functionName: string;\n\n  /**\n   * ARN of this alias\n   *\n   * Used to be able to use Alias in place of a regular Lambda. Lambda accepts\n   * ARNs everywhere it accepts function names.\n   */\n  public readonly functionArn: string;\n\n  protected readonly canCreatePermissions: boolean = true;\n\n  /**\n   * The actual Lambda function object that this Alias is pointing to\n   */\n  private readonly underlyingLambda: IFunction;\n\n  constructor(scope: Construct, id: string, props: AliasProps) {\n    super(scope, id);\n\n    this.aliasName = props.aliasName;\n    this.underlyingLambda = props.version.lambda;\n\n    const alias = new CfnAlias(this, 'Resource', {\n      name: props.aliasName,\n      description: props.description,\n      functionName: this.underlyingLambda.functionName,\n      functionVersion: props.version.functionVersion,\n      routingConfig: this.determineRoutingConfig(props)\n    });\n\n    // ARN parsing splits on `:`, so we can only get the function's name from the ARN as resourceName...\n    // And we're parsing it out (instead of using the underlying function directly) in order to have use of it incur\n    // an implicit dependency on the resource.\n    this.functionName = `${this.node.stack.parseArn(alias.aliasArn, \":\").resourceName!}:${props.aliasName}`;\n    this.functionArn = alias.aliasArn;\n  }\n\n  /**\n   * Role associated with this alias\n   */\n  public get role() {\n    return this.underlyingLambda.role;\n  }\n\n  public get grantPrincipal() {\n    return this.underlyingLambda.grantPrincipal;\n  }\n\n  public metric(metricName: string, props: cloudwatch.MetricOptions = {}): cloudwatch.Metric {\n    // Metrics on Aliases need the \"bare\" function name, and the alias' ARN, this differes from the base behavior.\n    return super.metric(metricName, {\n      dimensions: {\n        FunctionName: this.underlyingLambda.functionName,\n        // construct the ARN from the underlying lambda so that alarms on an alias\n        // don't cause a circular dependency with CodeDeploy\n        // see: https://github.com/awslabs/aws-cdk/issues/2231\n        Resource: `${this.underlyingLambda.functionArn}:${this.aliasName}`\n      },\n      ...props\n    });\n  }\n\n  public export(): FunctionImportProps {\n    return {\n      functionArn: new CfnOutput(this, 'AliasArn', { value: this.functionArn }).makeImportValue().toString()\n    };\n  }\n\n  /**\n   * Calculate the routingConfig parameter from the input props\n   */\n  private determineRoutingConfig(props: AliasProps) {\n    if (!props.additionalVersions || props.additionalVersions.length === 0) {\n      return undefined;\n    }\n\n    this.validateAdditionalWeights(props.additionalVersions);\n\n    return {\n      additionalVersionWeights: props.additionalVersions.map(vw => {\n        return {\n          functionVersion: vw.version.functionVersion,\n          functionWeight: vw.weight\n        };\n      })\n    };\n  }\n\n  /**\n   * Validate that the additional version weights make sense\n   *\n   * We validate that they are positive and add up to something <= 1.\n   */\n  private validateAdditionalWeights(weights: VersionWeight[]) {\n    const total = weights.map(w => {\n      if (w.weight < 0 || w.weight > 1) { throw new Error(`Additional version weight must be between 0 and 1, got: ${w.weight}`); }\n      return w.weight;\n    }).reduce((a, x) => a + x);\n\n    if (total > 1) {\n      throw new Error(`Sum of additional version weights must not exceed 1, got: ${total}`);\n    }\n  }\n}\n\n/**\n * A version/weight pair for routing traffic to Lambda functions\n */\nexport interface VersionWeight {\n  /**\n   * The version to route traffic to\n   */\n  readonly version: Version;\n\n  /**\n   * How much weight to assign to this version (0..1)\n   */\n  readonly weight: number;\n}\n"]}

lib/code.d.ts

@@ -36,2 +36,9 @@ import assets = require('@aws-cdk/assets');
     /**
+     * Creates a new Lambda source defined using CloudFormation parameters.
+     *
+     * @returns a new instance of `CfnParametersCode`
+     * @param props optional construction properties of {@link CfnParametersCode}
+     */
+    static cfnParameters(props?: CfnParametersCodeProps): CfnParametersCode;
+    /**
      * Determines whether this Code is inline code or not.
@@ -83,1 +90,52 @@ */
 }
+/**
+ * Construction properties for {@link CfnParametersCode}.
+ */
+export interface CfnParametersCodeProps {
+    /**
+     * The CloudFormation parameter that represents the name of the S3 Bucket
+     * where the Lambda code will be located in.
+     * Must be of type 'String'.
+     *
+     * @default a new parameter will be created
+     */
+    readonly bucketNameParam?: cdk.CfnParameter;
+    /**
+     * The CloudFormation parameter that represents the path inside the S3 Bucket
+     * where the Lambda code will be located at.
+     * Must be of type 'String'.
+     *
+     * @default a new parameter will be created
+     */
+    readonly objectKeyParam?: cdk.CfnParameter;
+}
+/**
+ * Lambda code defined using 2 CloudFormation parameters.
+ * Useful when you don't have access to the code of your Lambda from your CDK code, so you can't use Assets,
+ * and you want to deploy the Lambda in a CodePipeline, using CloudFormation Actions -
+ * you can fill the parameters using the {@link #assign} method.
+ */
+export declare class CfnParametersCode extends Code {
+    readonly isInline = false;
+    private _bucketNameParam?;
+    private _objectKeyParam?;
+    constructor(props?: CfnParametersCodeProps);
+    bind(construct: cdk.Construct): void;
+    /**
+     * Create a parameters map from this instance's CloudFormation parameters.
+     *
+     * It returns a map with 2 keys that correspond to the names of the parameters defined in this Lambda code,
+     * and as values it contains the appropriate expressions pointing at the provided S3 coordinates
+     * (most likely, obtained from a CodePipeline Artifact by calling the `artifact.s3Coordinates` method).
+     * The result should be provided to the CloudFormation Action
+     * that is deploying the Stack that the Lambda with this code is part of,
+     * in the `parameterOverrides` property.
+     *
+     * @param coordinates the coordinates of the object in S3 that represents the Lambda code
+     */
+    assign(coordinates: s3.Coordinates): {
+        [name: string]: any;
+    };
+    readonly bucketNameParam: string;
+    readonly objectKeyParam: string;
+}

lib/code.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const assets = require("@aws-cdk/assets");
+const cdk = require("@aws-cdk/cdk");
 const fs = require("fs");
@@ -47,2 +48,11 @@ class Code {
     /**
+     * Creates a new Lambda source defined using CloudFormation parameters.
+     *
+     * @returns a new instance of `CfnParametersCode`
+     * @param props optional construction properties of {@link CfnParametersCode}
+     */
+    static cfnParameters(props) {
+        return new CfnParametersCode(props);
+    }
+    /**
      * Called when the lambda or layer is initialized to allow this object to
@@ -158,2 +168,70 @@ * bind to the stack, add resources and have fun.
 exports.AssetCode = AssetCode;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"code.js","sourceRoot":"","sources":["code.ts"],"names":[],"mappings":"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","sourcesContent":["import assets = require('@aws-cdk/assets');\nimport s3 = require('@aws-cdk/aws-s3');\nimport cdk = require('@aws-cdk/cdk');\nimport fs = require('fs');\nimport { CfnFunction } from './lambda.generated';\n\nexport abstract class Code {\n  /**\n   * @returns `LambdaS3Code` associated with the specified S3 object.\n   * @param bucket The S3 bucket\n   * @param key The object key\n   * @param objectVersion Optional S3 object version\n   */\n  public static bucket(bucket: s3.IBucket, key: string, objectVersion?: string) {\n    return new S3Code(bucket, key, objectVersion);\n  }\n\n  /**\n   * @returns `LambdaInlineCode` with inline code.\n   * @param code The actual handler code (limited to 4KiB)\n   */\n  public static inline(code: string) {\n    return new InlineCode(code);\n  }\n\n  /**\n   * Loads the function code from a local disk asset.\n   * @param path Either a directory with the Lambda code bundle or a .zip file\n   */\n  public static asset(path: string) {\n    return new AssetCode(path);\n  }\n\n  /**\n   * @returns Zip archives the contents of a directory on disk and uses this\n   * as the lambda handler's code.\n   * @param directoryToZip The directory to zip\n   * @deprecated use `lambda.Code.asset(path)` (no need to specify if it's a file or a directory)\n   */\n  public static directory(directoryToZip: string) {\n    return new AssetCode(directoryToZip, assets.AssetPackaging.ZipDirectory);\n  }\n\n  /**\n   * @returns Uses a file on disk as a lambda handler's code.\n   * @param filePath The file path\n   * @deprecated use `lambda.Code.asset(path)` (no need to specify if it's a file or a directory)\n   */\n  public static file(filePath: string) {\n    return new AssetCode(filePath, assets.AssetPackaging.File);\n  }\n\n  /**\n   * Determines whether this Code is inline code or not.\n   */\n  public abstract readonly isInline: boolean;\n\n  /**\n   * Called during stack synthesis to render the CodePropery for the\n   * Lambda function.\n   *\n   * @param resource the resource to which the code will be attached (a CfnFunction, or a CfnLayerVersion).\n   *\n   * @internal\n   */\n  public abstract _toJSON(resource?: cdk.CfnResource): CfnFunction.CodeProperty;\n\n  /**\n   * Called when the lambda or layer is initialized to allow this object to\n   * bind to the stack, add resources and have fun.\n   */\n  public bind(_construct: cdk.Construct) {\n    return;\n  }\n}\n\n/**\n * Lambda code from an S3 archive.\n */\nexport class S3Code extends Code {\n  public readonly isInline = false;\n  private bucketName: string;\n\n  constructor(bucket: s3.IBucket, private key: string, private objectVersion?: string) {\n    super();\n\n    if (!bucket.bucketName) {\n      throw new Error('bucketName is undefined for the provided bucket');\n    }\n\n    this.bucketName = bucket.bucketName;\n  }\n\n  /**\n   * @internal\n   */\n  public _toJSON(_?: cdk.CfnResource): CfnFunction.CodeProperty {\n    return {\n      s3Bucket: this.bucketName,\n      s3Key: this.key,\n      s3ObjectVersion: this.objectVersion\n    };\n  }\n}\n\n/**\n * Lambda code from an inline string (limited to 4KiB).\n */\nexport class InlineCode extends Code {\n  public readonly isInline = true;\n\n  constructor(private code: string) {\n    super();\n\n    if (code.length > 4096) {\n      throw new Error(\"Lambda source is too large, must be <= 4096 but is \" + code.length);\n    }\n  }\n\n  public bind(construct: cdk.Construct) {\n    const runtime = (construct as any).runtime;\n    if (!runtime.supportsInlineCode) {\n      throw new Error(`Inline source not allowed for ${runtime && runtime.name}`);\n    }\n  }\n\n  /**\n   * @internal\n   */\n  public _toJSON(_?: cdk.CfnResource): CfnFunction.CodeProperty {\n    return {\n      zipFile: this.code\n    };\n  }\n}\n\n/**\n * Lambda code from a local directory.\n */\nexport class AssetCode extends Code {\n  public readonly isInline = false;\n\n  /**\n   * The asset packaging.\n   */\n  public readonly packaging: assets.AssetPackaging;\n\n  private asset?: assets.Asset;\n\n  /**\n   * @param path The path to the asset file or directory.\n   * @param packaging The asset packaging format (optional, determined automatically)\n   */\n  constructor(public readonly path: string, packaging?: assets.AssetPackaging) {\n    super();\n\n    if (packaging !== undefined) {\n      this.packaging = packaging;\n    } else {\n      this.packaging = fs.lstatSync(path).isDirectory()\n      ? assets.AssetPackaging.ZipDirectory\n      : assets.AssetPackaging.File;\n    }\n  }\n\n  public bind(construct: cdk.Construct) {\n    // If the same AssetCode is used multiple times, retain only the first instantiation.\n    if (!this.asset) {\n      this.asset = new assets.Asset(construct, 'Code', {\n        path: this.path,\n        packaging: this.packaging\n      });\n    }\n\n    if (!this.asset.isZipArchive) {\n      throw new Error(`Asset must be a .zip file or a directory (${this.path})`);\n    }\n  }\n\n  /**\n   * @internal\n   */\n  public _toJSON(resource?: cdk.CfnResource): CfnFunction.CodeProperty {\n    if (resource) {\n      // https://github.com/awslabs/aws-cdk/issues/1432\n      this.asset!.addResourceMetadata(resource, 'Code');\n    }\n\n    return  {\n      s3Bucket: this.asset!.s3BucketName,\n      s3Key: this.asset!.s3ObjectKey\n    };\n  }\n}\n"]}
+/**
+ * Lambda code defined using 2 CloudFormation parameters.
+ * Useful when you don't have access to the code of your Lambda from your CDK code, so you can't use Assets,
+ * and you want to deploy the Lambda in a CodePipeline, using CloudFormation Actions -
+ * you can fill the parameters using the {@link #assign} method.
+ */
+class CfnParametersCode extends Code {
+    constructor(props = {}) {
+        super();
+        this.isInline = false;
+        this._bucketNameParam = props.bucketNameParam;
+        this._objectKeyParam = props.objectKeyParam;
+    }
+    bind(construct) {
+        if (!this._bucketNameParam) {
+            this._bucketNameParam = new cdk.CfnParameter(construct, 'LambdaSourceBucketNameParameter', {
+                type: 'String',
+            });
+        }
+        if (!this._objectKeyParam) {
+            this._objectKeyParam = new cdk.CfnParameter(construct, 'LambdaSourceObjectKeyParameter', {
+                type: 'String',
+            });
+        }
+    }
+    /**
+     * Create a parameters map from this instance's CloudFormation parameters.
+     *
+     * It returns a map with 2 keys that correspond to the names of the parameters defined in this Lambda code,
+     * and as values it contains the appropriate expressions pointing at the provided S3 coordinates
+     * (most likely, obtained from a CodePipeline Artifact by calling the `artifact.s3Coordinates` method).
+     * The result should be provided to the CloudFormation Action
+     * that is deploying the Stack that the Lambda with this code is part of,
+     * in the `parameterOverrides` property.
+     *
+     * @param coordinates the coordinates of the object in S3 that represents the Lambda code
+     */
+    assign(coordinates) {
+        const ret = {};
+        ret[this.bucketNameParam] = coordinates.bucketName;
+        ret[this.objectKeyParam] = coordinates.objectKey;
+        return ret;
+    }
+    /** @internal */
+    _toJSON(_) {
+        return {
+            s3Bucket: this._bucketNameParam.stringValue,
+            s3Key: this._objectKeyParam.stringValue,
+        };
+    }
+    get bucketNameParam() {
+        if (this._bucketNameParam) {
+            return this._bucketNameParam.logicalId;
+        }
+        else {
+            throw new Error('Pass CfnParametersCode to a Lambda Function before accessing the bucketNameParam property');
+        }
+    }
+    get objectKeyParam() {
+        if (this._objectKeyParam) {
+            return this._objectKeyParam.logicalId;
+        }
+        else {
+            throw new Error('Pass CfnParametersCode to a Lambda Function before accessing the objectKeyParam property');
+        }
+    }
+}
+exports.CfnParametersCode = CfnParametersCode;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"code.js","sourceRoot":"","sources":["code.ts"],"names":[],"mappings":"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","sourcesContent":["import assets = require('@aws-cdk/assets');\nimport s3 = require('@aws-cdk/aws-s3');\nimport cdk = require('@aws-cdk/cdk');\nimport fs = require('fs');\nimport { CfnFunction } from './lambda.generated';\n\nexport abstract class Code {\n  /**\n   * @returns `LambdaS3Code` associated with the specified S3 object.\n   * @param bucket The S3 bucket\n   * @param key The object key\n   * @param objectVersion Optional S3 object version\n   */\n  public static bucket(bucket: s3.IBucket, key: string, objectVersion?: string): S3Code {\n    return new S3Code(bucket, key, objectVersion);\n  }\n\n  /**\n   * @returns `LambdaInlineCode` with inline code.\n   * @param code The actual handler code (limited to 4KiB)\n   */\n  public static inline(code: string): InlineCode {\n    return new InlineCode(code);\n  }\n\n  /**\n   * Loads the function code from a local disk asset.\n   * @param path Either a directory with the Lambda code bundle or a .zip file\n   */\n  public static asset(path: string): AssetCode {\n    return new AssetCode(path);\n  }\n\n  /**\n   * @returns Zip archives the contents of a directory on disk and uses this\n   * as the lambda handler's code.\n   * @param directoryToZip The directory to zip\n   * @deprecated use `lambda.Code.asset(path)` (no need to specify if it's a file or a directory)\n   */\n  public static directory(directoryToZip: string): AssetCode {\n    return new AssetCode(directoryToZip, assets.AssetPackaging.ZipDirectory);\n  }\n\n  /**\n   * @returns Uses a file on disk as a lambda handler's code.\n   * @param filePath The file path\n   * @deprecated use `lambda.Code.asset(path)` (no need to specify if it's a file or a directory)\n   */\n  public static file(filePath: string): AssetCode {\n    return new AssetCode(filePath, assets.AssetPackaging.File);\n  }\n\n  /**\n   * Creates a new Lambda source defined using CloudFormation parameters.\n   *\n   * @returns a new instance of `CfnParametersCode`\n   * @param props optional construction properties of {@link CfnParametersCode}\n   */\n  public static cfnParameters(props?: CfnParametersCodeProps): CfnParametersCode {\n    return new CfnParametersCode(props);\n  }\n\n  /**\n   * Determines whether this Code is inline code or not.\n   */\n  public abstract readonly isInline: boolean;\n\n  /**\n   * Called during stack synthesis to render the CodePropery for the\n   * Lambda function.\n   *\n   * @param resource the resource to which the code will be attached (a CfnFunction, or a CfnLayerVersion).\n   *\n   * @internal\n   */\n  public abstract _toJSON(resource?: cdk.CfnResource): CfnFunction.CodeProperty;\n\n  /**\n   * Called when the lambda or layer is initialized to allow this object to\n   * bind to the stack, add resources and have fun.\n   */\n  public bind(_construct: cdk.Construct) {\n    return;\n  }\n}\n\n/**\n * Lambda code from an S3 archive.\n */\nexport class S3Code extends Code {\n  public readonly isInline = false;\n  private bucketName: string;\n\n  constructor(bucket: s3.IBucket, private key: string, private objectVersion?: string) {\n    super();\n\n    if (!bucket.bucketName) {\n      throw new Error('bucketName is undefined for the provided bucket');\n    }\n\n    this.bucketName = bucket.bucketName;\n  }\n\n  /**\n   * @internal\n   */\n  public _toJSON(_?: cdk.CfnResource): CfnFunction.CodeProperty {\n    return {\n      s3Bucket: this.bucketName,\n      s3Key: this.key,\n      s3ObjectVersion: this.objectVersion\n    };\n  }\n}\n\n/**\n * Lambda code from an inline string (limited to 4KiB).\n */\nexport class InlineCode extends Code {\n  public readonly isInline = true;\n\n  constructor(private code: string) {\n    super();\n\n    if (code.length > 4096) {\n      throw new Error(\"Lambda source is too large, must be <= 4096 but is \" + code.length);\n    }\n  }\n\n  public bind(construct: cdk.Construct) {\n    const runtime = (construct as any).runtime;\n    if (!runtime.supportsInlineCode) {\n      throw new Error(`Inline source not allowed for ${runtime && runtime.name}`);\n    }\n  }\n\n  /**\n   * @internal\n   */\n  public _toJSON(_?: cdk.CfnResource): CfnFunction.CodeProperty {\n    return {\n      zipFile: this.code\n    };\n  }\n}\n\n/**\n * Lambda code from a local directory.\n */\nexport class AssetCode extends Code {\n  public readonly isInline = false;\n\n  /**\n   * The asset packaging.\n   */\n  public readonly packaging: assets.AssetPackaging;\n\n  private asset?: assets.Asset;\n\n  /**\n   * @param path The path to the asset file or directory.\n   * @param packaging The asset packaging format (optional, determined automatically)\n   */\n  constructor(public readonly path: string, packaging?: assets.AssetPackaging) {\n    super();\n\n    if (packaging !== undefined) {\n      this.packaging = packaging;\n    } else {\n      this.packaging = fs.lstatSync(path).isDirectory()\n        ? assets.AssetPackaging.ZipDirectory\n        : assets.AssetPackaging.File;\n    }\n  }\n\n  public bind(construct: cdk.Construct) {\n    // If the same AssetCode is used multiple times, retain only the first instantiation.\n    if (!this.asset) {\n      this.asset = new assets.Asset(construct, 'Code', {\n        path: this.path,\n        packaging: this.packaging\n      });\n    }\n\n    if (!this.asset.isZipArchive) {\n      throw new Error(`Asset must be a .zip file or a directory (${this.path})`);\n    }\n  }\n\n  /**\n   * @internal\n   */\n  public _toJSON(resource?: cdk.CfnResource): CfnFunction.CodeProperty {\n    if (resource) {\n      // https://github.com/awslabs/aws-cdk/issues/1432\n      this.asset!.addResourceMetadata(resource, 'Code');\n    }\n\n    return {\n      s3Bucket: this.asset!.s3BucketName,\n      s3Key: this.asset!.s3ObjectKey\n    };\n  }\n}\n\n/**\n * Construction properties for {@link CfnParametersCode}.\n */\nexport interface CfnParametersCodeProps {\n  /**\n   * The CloudFormation parameter that represents the name of the S3 Bucket\n   * where the Lambda code will be located in.\n   * Must be of type 'String'.\n   *\n   * @default a new parameter will be created\n   */\n  readonly bucketNameParam?: cdk.CfnParameter;\n\n  /**\n   * The CloudFormation parameter that represents the path inside the S3 Bucket\n   * where the Lambda code will be located at.\n   * Must be of type 'String'.\n   *\n   * @default a new parameter will be created\n   */\n  readonly objectKeyParam?: cdk.CfnParameter;\n}\n\n/**\n * Lambda code defined using 2 CloudFormation parameters.\n * Useful when you don't have access to the code of your Lambda from your CDK code, so you can't use Assets,\n * and you want to deploy the Lambda in a CodePipeline, using CloudFormation Actions -\n * you can fill the parameters using the {@link #assign} method.\n */\nexport class CfnParametersCode extends Code {\n  public readonly isInline = false;\n  private _bucketNameParam?: cdk.CfnParameter;\n  private _objectKeyParam?: cdk.CfnParameter;\n\n  constructor(props: CfnParametersCodeProps = {}) {\n    super();\n\n    this._bucketNameParam = props.bucketNameParam;\n    this._objectKeyParam = props.objectKeyParam;\n  }\n\n  public bind(construct: cdk.Construct) {\n    if (!this._bucketNameParam) {\n      this._bucketNameParam = new cdk.CfnParameter(construct, 'LambdaSourceBucketNameParameter', {\n        type: 'String',\n      });\n    }\n\n    if (!this._objectKeyParam) {\n      this._objectKeyParam = new cdk.CfnParameter(construct, 'LambdaSourceObjectKeyParameter', {\n        type: 'String',\n      });\n    }\n  }\n\n  /**\n   * Create a parameters map from this instance's CloudFormation parameters.\n   *\n   * It returns a map with 2 keys that correspond to the names of the parameters defined in this Lambda code,\n   * and as values it contains the appropriate expressions pointing at the provided S3 coordinates\n   * (most likely, obtained from a CodePipeline Artifact by calling the `artifact.s3Coordinates` method).\n   * The result should be provided to the CloudFormation Action\n   * that is deploying the Stack that the Lambda with this code is part of,\n   * in the `parameterOverrides` property.\n   *\n   * @param coordinates the coordinates of the object in S3 that represents the Lambda code\n   */\n  public assign(coordinates: s3.Coordinates): { [name: string]: any } {\n    const ret: { [name: string]: any } = {};\n    ret[this.bucketNameParam] = coordinates.bucketName;\n    ret[this.objectKeyParam] = coordinates.objectKey;\n    return ret;\n  }\n\n  /** @internal */\n  public _toJSON(_?: cdk.CfnResource): CfnFunction.CodeProperty {\n    return {\n      s3Bucket: this._bucketNameParam!.stringValue,\n      s3Key: this._objectKeyParam!.stringValue,\n    };\n  }\n\n  public get bucketNameParam(): string {\n    if (this._bucketNameParam) {\n      return this._bucketNameParam.logicalId;\n    } else {\n      throw new Error('Pass CfnParametersCode to a Lambda Function before accessing the bucketNameParam property');\n    }\n  }\n\n  public get objectKeyParam(): string {\n    if (this._objectKeyParam) {\n      return this._objectKeyParam.logicalId;\n    } else {\n      throw new Error('Pass CfnParametersCode to a Lambda Function before accessing the objectKeyParam property');\n    }\n  }\n}\n"]}

lib/event-source-mapping.d.ts

 import cdk = require('@aws-cdk/cdk');
+import { Resource } from '@aws-cdk/cdk';
 import { IFunction } from './function-base';
@@ -50,3 +51,3 @@ export interface EventSourceMappingProps {
  */
-export declare class EventSourceMapping extends cdk.Construct {
+export declare class EventSourceMapping extends Resource {
     constructor(scope: cdk.Construct, id: string, props: EventSourceMappingProps);
@@ -53,0 +54,0 @@ }

lib/event-source-mapping.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const cdk = require("@aws-cdk/cdk");
+const cdk_1 = require("@aws-cdk/cdk");
 const lambda_generated_1 = require("./lambda.generated");
@@ -17,3 +17,3 @@ /**
  */
-class EventSourceMapping extends cdk.Construct {
+class EventSourceMapping extends cdk_1.Resource {
     constructor(scope, id, props) {
@@ -48,2 +48,2 @@ super(scope, id);
 })(StartingPosition = exports.StartingPosition || (exports.StartingPosition = {}));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

lib/function-base.d.ts

 import cloudwatch = require('@aws-cdk/aws-cloudwatch');
 import ec2 = require('@aws-cdk/aws-ec2');
-import events = require('@aws-cdk/aws-events');
 import iam = require('@aws-cdk/aws-iam');
@@ -8,6 +7,6 @@ import logs = require('@aws-cdk/aws-logs');
 import stepfunctions = require('@aws-cdk/aws-stepfunctions');
-import cdk = require('@aws-cdk/cdk');
+import { IResource, Resource } from '@aws-cdk/cdk';
 import { IEventSource } from './event-source';
 import { Permission } from './permission';
-export interface IFunction extends cdk.IConstruct, events.IEventRuleTarget, logs.ILogSubscriptionDestination, s3n.IBucketNotificationDestination, ec2.IConnectable, stepfunctions.IStepFunctionsTaskResource, iam.IGrantable {
+export interface IFunction extends IResource, logs.ILogSubscriptionDestination, s3n.IBucketNotificationDestination, ec2.IConnectable, stepfunctions.IStepFunctionsTaskResource, iam.IGrantable {
     /**
@@ -48,3 +47,3 @@ * Logical ID of this Function.
      */
-    metric(metricName: string, props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+    metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;
     /**
@@ -55,3 +54,3 @@ * Metric for the Duration of this Lambda
      */
-    metricDuration(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+    metricDuration(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
     /**
@@ -62,3 +61,3 @@ * Metric for the number of invocations of this Lambda
      */
-    metricInvocations(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+    metricInvocations(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
     /**
@@ -69,3 +68,3 @@ * Metric for the number of throttled invocations of this Lambda
      */
-    metricThrottles(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+    metricThrottles(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
     /**
@@ -101,3 +100,3 @@ * Export this Function (without the role)
 }
-export declare abstract class FunctionBase extends cdk.Construct implements IFunction {
+export declare abstract class FunctionBase extends Resource implements IFunction {
     /**
@@ -151,7 +150,2 @@ * The principal this Lambda Function is running as
     /**
-     * Returns a RuleTarget that can be used to trigger this Lambda as a
-     * result from a CloudWatch event.
-     */
-    asEventRuleTarget(ruleArn: string, ruleId: string): events.EventRuleTargetProps;
-    /**
      * Grant the given identity permissions to invoke this Lambda
@@ -158,0 +152,0 @@ */

lib/function-base.js

@@ -5,5 +5,5 @@ "use strict";
 const s3n = require("@aws-cdk/aws-s3-notifications");
-const cdk = require("@aws-cdk/cdk");
+const cdk_1 = require("@aws-cdk/cdk");
 const lambda_generated_1 = require("./lambda.generated");
-class FunctionBase extends cdk.Construct {
+class FunctionBase extends cdk_1.Resource {
     constructor() {
@@ -66,20 +66,2 @@ super(...arguments);
     /**
-     * Returns a RuleTarget that can be used to trigger this Lambda as a
-     * result from a CloudWatch event.
-     */
-    asEventRuleTarget(ruleArn, ruleId) {
-        const permissionId = `AllowEventRule${ruleId}`;
-        if (!this.node.tryFindChild(permissionId)) {
-            this.addPermission(permissionId, {
-                action: 'lambda:InvokeFunction',
-                principal: new iam.ServicePrincipal('events.amazonaws.com'),
-                sourceArn: ruleArn
-            });
-        }
-        return {
-            id: this.node.id,
-            arn: this.functionArn,
-        };
-    }
-    /**
      * Grant the given identity permissions to invoke this Lambda
@@ -188,2 +170,2 @@ */
 exports.FunctionBase = FunctionBase;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function-base.js","sourceRoot":"","sources":["function-base.ts"],"names":[],"mappings":"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","sourcesContent":["import cloudwatch = require('@aws-cdk/aws-cloudwatch');\nimport ec2 = require('@aws-cdk/aws-ec2');\nimport events = require('@aws-cdk/aws-events');\nimport iam = require('@aws-cdk/aws-iam');\nimport logs = require('@aws-cdk/aws-logs');\nimport s3n = require('@aws-cdk/aws-s3-notifications');\nimport stepfunctions = require('@aws-cdk/aws-stepfunctions');\nimport cdk = require('@aws-cdk/cdk');\nimport { IEventSource } from './event-source';\nimport { CfnPermission } from './lambda.generated';\nimport { Permission } from './permission';\n\nexport interface IFunction extends cdk.IConstruct, events.IEventRuleTarget, logs.ILogSubscriptionDestination,\n  s3n.IBucketNotificationDestination, ec2.IConnectable, stepfunctions.IStepFunctionsTaskResource, iam.IGrantable {\n\n  /**\n   * Logical ID of this Function.\n   */\n  readonly id: string;\n\n  /**\n   * The name of the function.\n   */\n  readonly functionName: string;\n\n  /**\n   * The ARN fo the function.\n   */\n  readonly functionArn: string;\n\n  /**\n   * The IAM role associated with this function.\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * Whether or not this Lambda function was bound to a VPC\n   *\n   * If this is is `false`, trying to access the `connections` object will fail.\n   */\n  readonly isBoundToVpc: boolean;\n\n  /**\n   * Adds a permission to the Lambda resource policy.\n   * @param id The id ƒor the permission construct\n   */\n  addPermission(id: string, permission: Permission): void;\n\n  addToRolePolicy(statement: iam.PolicyStatement): void;\n\n  /**\n   * Grant the given identity permissions to invoke this Lambda\n   */\n  grantInvoke(identity: iam.IGrantable): iam.Grant;\n\n  /**\n   * Return the given named metric for this Lambda\n   */\n  metric(metricName: string, props?: cloudwatch.MetricCustomization): cloudwatch.Metric;\n\n  /**\n   * Metric for the Duration of this Lambda\n   *\n   * @default average over 5 minutes\n   */\n  metricDuration(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;\n\n  /**\n   * Metric for the number of invocations of this Lambda\n   *\n   * @default sum over 5 minutes\n   */\n  metricInvocations(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;\n\n  /**\n   * Metric for the number of throttled invocations of this Lambda\n   *\n   * @default sum over 5 minutes\n   */\n  metricThrottles(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;\n\n  /**\n   * Export this Function (without the role)\n   */\n  export(): FunctionImportProps;\n\n  addEventSource(source: IEventSource): void;\n}\n\n/**\n * Represents a Lambda function defined outside of this stack.\n */\nexport interface FunctionImportProps {\n  /**\n   * The ARN of the Lambda function.\n   *\n   * Format: arn:<partition>:lambda:<region>:<account-id>:function:<function-name>\n   */\n  readonly functionArn: string;\n\n  /**\n   * The IAM execution role associated with this function.\n   *\n   * If the role is not specified, any role-related operations will no-op.\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * Id of the securityGroup for this Lambda, if in a VPC.\n   *\n   * This needs to be given in order to support allowing connections\n   * to this Lambda.\n   */\n  readonly securityGroupId?: string;\n}\n\nexport abstract class FunctionBase extends cdk.Construct implements IFunction  {\n  /**\n   * The principal this Lambda Function is running as\n   */\n  public abstract readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * The name of the function.\n   */\n  public abstract readonly functionName: string;\n\n  /**\n   * The ARN fo the function.\n   */\n  public abstract readonly functionArn: string;\n\n  /**\n   * The IAM role associated with this function.\n   *\n   * Undefined if the function was imported without a role.\n   */\n  public abstract readonly role?: iam.IRole;\n\n  /**\n   * Whether the addPermission() call adds any permissions\n   *\n   * True for new Lambdas, false for imported Lambdas (they might live in different accounts).\n   */\n  protected abstract readonly canCreatePermissions: boolean;\n\n  /**\n   * Actual connections object for this Lambda\n   *\n   * May be unset, in which case this Lambda is not configured use in a VPC.\n   * @internal\n   */\n  protected _connections?: ec2.Connections;\n\n  /**\n   * Indicates if the policy that allows CloudWatch logs to publish to this lambda has been added.\n   */\n  private logSubscriptionDestinationPolicyAddedFor: string[] = [];\n\n  /**\n   * Adds a permission to the Lambda resource policy.\n   * @param id The id ƒor the permission construct\n   */\n  public addPermission(id: string, permission: Permission) {\n    if (!this.canCreatePermissions) {\n      // FIXME: Report metadata\n      return;\n    }\n\n    const principal = this.parsePermissionPrincipal(permission.principal);\n    const action = permission.action || 'lambda:InvokeFunction';\n\n    new CfnPermission(this, id, {\n      action,\n      principal,\n      functionName: this.functionArn,\n      eventSourceToken: permission.eventSourceToken,\n      sourceAccount: permission.sourceAccount,\n      sourceArn: permission.sourceArn,\n    });\n  }\n\n  public get id() {\n    return this.node.id;\n  }\n\n  public addToRolePolicy(statement: iam.PolicyStatement) {\n    if (!this.role) {\n      return;\n    }\n\n    this.role.addToPolicy(statement);\n  }\n\n  /**\n   * Access the Connections object\n   *\n   * Will fail if not a VPC-enabled Lambda Function\n   */\n  public get connections(): ec2.Connections {\n    if (!this._connections) {\n      // tslint:disable-next-line:max-line-length\n      throw new Error('Only VPC-associated Lambda Functions have security groups to manage. Supply the \"vpc\" parameter when creating the Lambda, or \"securityGroupId\" when importing it.');\n    }\n    return this._connections;\n  }\n\n  /**\n   * Whether or not this Lambda function was bound to a VPC\n   *\n   * If this is is `false`, trying to access the `connections` object will fail.\n   */\n  public get isBoundToVpc(): boolean {\n    return !!this._connections;\n  }\n\n  /**\n   * Returns a RuleTarget that can be used to trigger this Lambda as a\n   * result from a CloudWatch event.\n   */\n  public asEventRuleTarget(ruleArn: string, ruleId: string): events.EventRuleTargetProps {\n    const permissionId = `AllowEventRule${ruleId}`;\n    if (!this.node.tryFindChild(permissionId)) {\n      this.addPermission(permissionId, {\n        action: 'lambda:InvokeFunction',\n        principal: new iam.ServicePrincipal('events.amazonaws.com'),\n        sourceArn: ruleArn\n      });\n    }\n\n    return {\n      id: this.node.id,\n      arn: this.functionArn,\n    };\n  }\n\n  /**\n   * Grant the given identity permissions to invoke this Lambda\n   */\n  public grantInvoke(grantee: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipalOrResource({\n      grantee,\n      actions: ['lambda:InvokeFunction'],\n      resourceArns: [this.functionArn],\n\n      // Fake resource-like object on which to call addToResourcePolicy(), which actually\n      // calls addPermission()\n      resource: {\n        addToResourcePolicy: (_statement) => {\n          // Couldn't add permissions to the principal, so add them locally.\n          const identifier = 'Invoke' + JSON.stringify(grantee!.grantPrincipal.policyFragment.principalJson);\n          this.addPermission(identifier, {\n            principal: grantee.grantPrincipal!,\n            action: 'lambda:InvokeFunction',\n          });\n        },\n        dependencyRoots: [],\n        node: this.node,\n      },\n    });\n  }\n\n  public logSubscriptionDestination(sourceLogGroup: logs.ILogGroup): logs.LogSubscriptionDestination {\n    const arn = sourceLogGroup.logGroupArn;\n\n    if (this.logSubscriptionDestinationPolicyAddedFor.indexOf(arn) === -1) {\n      // NOTE: the use of {AWS::Region} limits this to the same region, which shouldn't really be an issue,\n      // since the Lambda must be in the same region as the SubscriptionFilter anyway.\n      //\n      // (Wildcards in principals are unfortunately not supported.\n      this.addPermission('InvokedByCloudWatchLogs', {\n        principal: new iam.ServicePrincipal(`logs.${this.node.stack.region}.amazonaws.com`),\n        sourceArn: arn\n      });\n      this.logSubscriptionDestinationPolicyAddedFor.push(arn);\n    }\n    return { arn: this.functionArn };\n  }\n\n  /**\n   * Export this Function (without the role)\n   */\n  public abstract export(): FunctionImportProps;\n\n  /**\n   * Allows this Lambda to be used as a destination for bucket notifications.\n   * Use `bucket.onEvent(lambda)` to subscribe.\n   */\n  public asBucketNotificationDestination(bucketArn: string, bucketId: string): s3n.BucketNotificationDestinationProps {\n    const permissionId = `AllowBucketNotificationsFrom${bucketId}`;\n    if (!this.node.tryFindChild(permissionId)) {\n      this.addPermission(permissionId, {\n        sourceAccount: this.node.stack.accountId,\n        principal: new iam.ServicePrincipal('s3.amazonaws.com'),\n        sourceArn: bucketArn,\n      });\n    }\n\n    // if we have a permission resource for this relationship, add it as a dependency\n    // to the bucket notifications resource, so it will be created first.\n    const permission = this.node.tryFindChild(permissionId) as cdk.CfnResource;\n\n    return {\n      type: s3n.BucketNotificationDestinationType.Lambda,\n      arn: this.functionArn,\n      dependencies: permission ? [ permission ] : undefined\n    };\n  }\n\n  public asStepFunctionsTaskResource(_callingTask: stepfunctions.Task): stepfunctions.StepFunctionsTaskResourceProps {\n    return {\n      resourceArn: this.functionArn,\n      metricPrefixSingular: 'LambdaFunction',\n      metricPrefixPlural: 'LambdaFunctions',\n      metricDimensions: { LambdaFunctionArn: this.functionArn },\n      policyStatements: [new iam.PolicyStatement()\n        .addResource(this.functionArn)\n        .addActions(\"lambda:InvokeFunction\")\n      ]\n    };\n  }\n\n  /**\n   * Adds an event source to this function.\n   *\n   * Event sources are implemented in the @aws-cdk/aws-lambda-event-sources module.\n   *\n   * The following example adds an SQS Queue as an event source:\n   *\n   *     import { SqsEventSource } from '@aws-cdk/aws-lambda-event-sources';\n   *     myFunction.addEventSource(new SqsEventSource(myQueue));\n   *\n   * @param source The event source to bind to this function\n   */\n  public addEventSource(source: IEventSource) {\n    source.bind(this);\n  }\n\n  private parsePermissionPrincipal(principal?: iam.IPrincipal) {\n    if (!principal) {\n      return undefined;\n    }\n    // use duck-typing, not instance of\n\n    if ('accountId' in principal) {\n      return (principal as iam.AccountPrincipal).accountId;\n    }\n\n    if (`service` in principal) {\n      return (principal as iam.ServicePrincipal).service;\n    }\n\n    throw new Error(`Invalid principal type for Lambda permission statement: ${this.node.resolve(principal.toString())}. ` +\n      'Supported: AccountPrincipal, ServicePrincipal');\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function-base.js","sourceRoot":"","sources":["function-base.ts"],"names":[],"mappings":"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","sourcesContent":["import cloudwatch = require('@aws-cdk/aws-cloudwatch');\nimport ec2 = require('@aws-cdk/aws-ec2');\nimport iam = require('@aws-cdk/aws-iam');\nimport logs = require('@aws-cdk/aws-logs');\nimport s3n = require('@aws-cdk/aws-s3-notifications');\nimport stepfunctions = require('@aws-cdk/aws-stepfunctions');\nimport cdk = require('@aws-cdk/cdk');\nimport { IResource, Resource } from '@aws-cdk/cdk';\nimport { IEventSource } from './event-source';\nimport { CfnPermission } from './lambda.generated';\nimport { Permission } from './permission';\n\nexport interface IFunction extends IResource, logs.ILogSubscriptionDestination,\n  s3n.IBucketNotificationDestination, ec2.IConnectable, stepfunctions.IStepFunctionsTaskResource, iam.IGrantable {\n\n  /**\n   * Logical ID of this Function.\n   */\n  readonly id: string;\n\n  /**\n   * The name of the function.\n   */\n  readonly functionName: string;\n\n  /**\n   * The ARN fo the function.\n   */\n  readonly functionArn: string;\n\n  /**\n   * The IAM role associated with this function.\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * Whether or not this Lambda function was bound to a VPC\n   *\n   * If this is is `false`, trying to access the `connections` object will fail.\n   */\n  readonly isBoundToVpc: boolean;\n\n  /**\n   * Adds a permission to the Lambda resource policy.\n   * @param id The id ƒor the permission construct\n   */\n  addPermission(id: string, permission: Permission): void;\n\n  addToRolePolicy(statement: iam.PolicyStatement): void;\n\n  /**\n   * Grant the given identity permissions to invoke this Lambda\n   */\n  grantInvoke(identity: iam.IGrantable): iam.Grant;\n\n  /**\n   * Return the given named metric for this Lambda\n   */\n  metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Metric for the Duration of this Lambda\n   *\n   * @default average over 5 minutes\n   */\n  metricDuration(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Metric for the number of invocations of this Lambda\n   *\n   * @default sum over 5 minutes\n   */\n  metricInvocations(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Metric for the number of throttled invocations of this Lambda\n   *\n   * @default sum over 5 minutes\n   */\n  metricThrottles(props?: cloudwatch.MetricOptions): cloudwatch.Metric;\n\n  /**\n   * Export this Function (without the role)\n   */\n  export(): FunctionImportProps;\n\n  addEventSource(source: IEventSource): void;\n}\n\n/**\n * Represents a Lambda function defined outside of this stack.\n */\nexport interface FunctionImportProps {\n  /**\n   * The ARN of the Lambda function.\n   *\n   * Format: arn:<partition>:lambda:<region>:<account-id>:function:<function-name>\n   */\n  readonly functionArn: string;\n\n  /**\n   * The IAM execution role associated with this function.\n   *\n   * If the role is not specified, any role-related operations will no-op.\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * Id of the securityGroup for this Lambda, if in a VPC.\n   *\n   * This needs to be given in order to support allowing connections\n   * to this Lambda.\n   */\n  readonly securityGroupId?: string;\n}\n\nexport abstract class FunctionBase extends Resource implements IFunction  {\n  /**\n   * The principal this Lambda Function is running as\n   */\n  public abstract readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * The name of the function.\n   */\n  public abstract readonly functionName: string;\n\n  /**\n   * The ARN fo the function.\n   */\n  public abstract readonly functionArn: string;\n\n  /**\n   * The IAM role associated with this function.\n   *\n   * Undefined if the function was imported without a role.\n   */\n  public abstract readonly role?: iam.IRole;\n\n  /**\n   * Whether the addPermission() call adds any permissions\n   *\n   * True for new Lambdas, false for imported Lambdas (they might live in different accounts).\n   */\n  protected abstract readonly canCreatePermissions: boolean;\n\n  /**\n   * Actual connections object for this Lambda\n   *\n   * May be unset, in which case this Lambda is not configured use in a VPC.\n   * @internal\n   */\n  protected _connections?: ec2.Connections;\n\n  /**\n   * Indicates if the policy that allows CloudWatch logs to publish to this lambda has been added.\n   */\n  private logSubscriptionDestinationPolicyAddedFor: string[] = [];\n\n  /**\n   * Adds a permission to the Lambda resource policy.\n   * @param id The id ƒor the permission construct\n   */\n  public addPermission(id: string, permission: Permission) {\n    if (!this.canCreatePermissions) {\n      // FIXME: Report metadata\n      return;\n    }\n\n    const principal = this.parsePermissionPrincipal(permission.principal);\n    const action = permission.action || 'lambda:InvokeFunction';\n\n    new CfnPermission(this, id, {\n      action,\n      principal,\n      functionName: this.functionArn,\n      eventSourceToken: permission.eventSourceToken,\n      sourceAccount: permission.sourceAccount,\n      sourceArn: permission.sourceArn,\n    });\n  }\n\n  public get id() {\n    return this.node.id;\n  }\n\n  public addToRolePolicy(statement: iam.PolicyStatement) {\n    if (!this.role) {\n      return;\n    }\n\n    this.role.addToPolicy(statement);\n  }\n\n  /**\n   * Access the Connections object\n   *\n   * Will fail if not a VPC-enabled Lambda Function\n   */\n  public get connections(): ec2.Connections {\n    if (!this._connections) {\n      // tslint:disable-next-line:max-line-length\n      throw new Error('Only VPC-associated Lambda Functions have security groups to manage. Supply the \"vpc\" parameter when creating the Lambda, or \"securityGroupId\" when importing it.');\n    }\n    return this._connections;\n  }\n\n  /**\n   * Whether or not this Lambda function was bound to a VPC\n   *\n   * If this is is `false`, trying to access the `connections` object will fail.\n   */\n  public get isBoundToVpc(): boolean {\n    return !!this._connections;\n  }\n\n  /**\n   * Grant the given identity permissions to invoke this Lambda\n   */\n  public grantInvoke(grantee: iam.IGrantable): iam.Grant {\n    return iam.Grant.addToPrincipalOrResource({\n      grantee,\n      actions: ['lambda:InvokeFunction'],\n      resourceArns: [this.functionArn],\n\n      // Fake resource-like object on which to call addToResourcePolicy(), which actually\n      // calls addPermission()\n      resource: {\n        addToResourcePolicy: (_statement) => {\n          // Couldn't add permissions to the principal, so add them locally.\n          const identifier = 'Invoke' + JSON.stringify(grantee!.grantPrincipal.policyFragment.principalJson);\n          this.addPermission(identifier, {\n            principal: grantee.grantPrincipal!,\n            action: 'lambda:InvokeFunction',\n          });\n        },\n        dependencyRoots: [],\n        node: this.node,\n      },\n    });\n  }\n\n  public logSubscriptionDestination(sourceLogGroup: logs.ILogGroup): logs.LogSubscriptionDestination {\n    const arn = sourceLogGroup.logGroupArn;\n\n    if (this.logSubscriptionDestinationPolicyAddedFor.indexOf(arn) === -1) {\n      // NOTE: the use of {AWS::Region} limits this to the same region, which shouldn't really be an issue,\n      // since the Lambda must be in the same region as the SubscriptionFilter anyway.\n      //\n      // (Wildcards in principals are unfortunately not supported.\n      this.addPermission('InvokedByCloudWatchLogs', {\n        principal: new iam.ServicePrincipal(`logs.${this.node.stack.region}.amazonaws.com`),\n        sourceArn: arn\n      });\n      this.logSubscriptionDestinationPolicyAddedFor.push(arn);\n    }\n    return { arn: this.functionArn };\n  }\n\n  /**\n   * Export this Function (without the role)\n   */\n  public abstract export(): FunctionImportProps;\n\n  /**\n   * Allows this Lambda to be used as a destination for bucket notifications.\n   * Use `bucket.onEvent(lambda)` to subscribe.\n   */\n  public asBucketNotificationDestination(bucketArn: string, bucketId: string): s3n.BucketNotificationDestinationProps {\n    const permissionId = `AllowBucketNotificationsFrom${bucketId}`;\n    if (!this.node.tryFindChild(permissionId)) {\n      this.addPermission(permissionId, {\n        sourceAccount: this.node.stack.accountId,\n        principal: new iam.ServicePrincipal('s3.amazonaws.com'),\n        sourceArn: bucketArn,\n      });\n    }\n\n    // if we have a permission resource for this relationship, add it as a dependency\n    // to the bucket notifications resource, so it will be created first.\n    const permission = this.node.tryFindChild(permissionId) as cdk.CfnResource;\n\n    return {\n      type: s3n.BucketNotificationDestinationType.Lambda,\n      arn: this.functionArn,\n      dependencies: permission ? [ permission ] : undefined\n    };\n  }\n\n  public asStepFunctionsTaskResource(_callingTask: stepfunctions.Task): stepfunctions.StepFunctionsTaskResourceProps {\n    return {\n      resourceArn: this.functionArn,\n      metricPrefixSingular: 'LambdaFunction',\n      metricPrefixPlural: 'LambdaFunctions',\n      metricDimensions: { LambdaFunctionArn: this.functionArn },\n      policyStatements: [new iam.PolicyStatement()\n        .addResource(this.functionArn)\n        .addActions(\"lambda:InvokeFunction\")\n      ]\n    };\n  }\n\n  /**\n   * Adds an event source to this function.\n   *\n   * Event sources are implemented in the @aws-cdk/aws-lambda-event-sources module.\n   *\n   * The following example adds an SQS Queue as an event source:\n   *\n   *     import { SqsEventSource } from '@aws-cdk/aws-lambda-event-sources';\n   *     myFunction.addEventSource(new SqsEventSource(myQueue));\n   *\n   * @param source The event source to bind to this function\n   */\n  public addEventSource(source: IEventSource) {\n    source.bind(this);\n  }\n\n  private parsePermissionPrincipal(principal?: iam.IPrincipal) {\n    if (!principal) {\n      return undefined;\n    }\n    // use duck-typing, not instance of\n\n    if ('accountId' in principal) {\n      return (principal as iam.AccountPrincipal).accountId;\n    }\n\n    if (`service` in principal) {\n      return (principal as iam.ServicePrincipal).service;\n    }\n\n    throw new Error(`Invalid principal type for Lambda permission statement: ${this.node.resolve(principal.toString())}. ` +\n      'Supported: AccountPrincipal, ServicePrincipal');\n  }\n}\n"]}

lib/function.d.ts

@@ -6,3 +6,3 @@ import cloudwatch = require('@aws-cdk/aws-cloudwatch');
 import sqs = require('@aws-cdk/aws-sqs');
-import cdk = require('@aws-cdk/cdk');
+import { Construct } from '@aws-cdk/cdk';
 import { Code } from './code';
@@ -210,3 +210,3 @@ import { IEventSource } from './event-source';
      *
-     * @param parent The parent construct
+     * @param scope The parent construct
      * @param id The name of the lambda construct
@@ -216,7 +216,7 @@ * @param props A reference to a Lambda function. Can be created manually (see
      */
-    static import(scope: cdk.Construct, id: string, props: FunctionImportProps): IFunction;
+    static import(scope: Construct, id: string, props: FunctionImportProps): IFunction;
     /**
      * Return the given named metric for this Lambda
      */
-    static metricAll(metricName: string, props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+    static metricAll(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;
     /**
@@ -227,3 +227,3 @@ * Metric for the number of Errors executing all Lambdas
      */
-    static metricAllErrors(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+    static metricAllErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
     /**
@@ -234,3 +234,3 @@ * Metric for the Duration executing all Lambdas
      */
-    static metricAllDuration(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+    static metricAllDuration(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
     /**
@@ -241,3 +241,3 @@ * Metric for the number of invocations of all Lambdas
      */
-    static metricAllInvocations(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+    static metricAllInvocations(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
     /**
@@ -248,3 +248,3 @@ * Metric for the number of throttled invocations of all Lambdas
      */
-    static metricAllThrottles(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+    static metricAllThrottles(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
     /**
@@ -255,3 +255,3 @@ * Metric for the number of concurrent executions across all Lambdas
      */
-    static metricAllConcurrentExecutions(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+    static metricAllConcurrentExecutions(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
     /**
@@ -262,3 +262,3 @@ * Metric for the number of unreserved concurrent executions across all Lambdas
      */
-    static metricAllUnreservedConcurrentExecutions(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+    static metricAllUnreservedConcurrentExecutions(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
     /**
@@ -294,3 +294,3 @@ * Name of this function
     private readonly environment?;
-    constructor(scope: cdk.Construct, id: string, props: FunctionProps);
+    constructor(scope: Construct, id: string, props: FunctionProps);
     /**
@@ -358,11 +358,1 @@ * Export this Function (without the role)
 }
-export declare class ImportedFunction extends FunctionBase {
-    private readonly props;
-    readonly grantPrincipal: iam.IPrincipal;
-    readonly functionName: string;
-    readonly functionArn: string;
-    readonly role?: iam.IRole;
-    protected readonly canCreatePermissions = false;
-    constructor(scope: cdk.Construct, id: string, props: FunctionImportProps);
-    export(): FunctionImportProps;
-}

lib/function.js

@@ -7,3 +7,3 @@ "use strict";
 const sqs = require("@aws-cdk/aws-sqs");
-const cdk = require("@aws-cdk/cdk");
+const cdk_1 = require("@aws-cdk/cdk");
 const function_base_1 = require("./function-base");
@@ -73,4 +73,4 @@ const lambda_version_1 = require("./lambda-version");
             description: props.description,
-            code: new cdk.Token(() => props.code._toJSON(resource)),
-            layers: new cdk.Token(() => this.layers.length > 0 ? this.layers.map(layer => layer.layerVersionArn) : undefined).toList(),
+            code: new cdk_1.Token(() => props.code._toJSON(resource)),
+            layers: new cdk_1.Token(() => this.layers.length > 0 ? this.layers.map(layer => layer.layerVersionArn) : undefined).toList(),
             handler: props.handler,
@@ -80,3 +80,3 @@ timeout: props.timeout,
             role: this.role.roleArn,
-            environment: new cdk.Token(() => this.renderEnvironment()),
+            environment: new cdk_1.Token(() => this.renderEnvironment()),
             memorySize: props.memorySize,
@@ -115,3 +115,3 @@ vpcConfig: this.configureVpc(props),
      *
-     * @param parent The parent construct
+     * @param scope The parent construct
      * @param id The name of the lambda construct
@@ -128,3 +128,7 @@ * @param props A reference to a Lambda function. Can be created manually (see
     static metricAll(metricName, props) {
-        return new cloudwatch.Metric(Object.assign({ namespace: 'AWS/Lambda', metricName }, props));
+        return new cloudwatch.Metric({
+            namespace: 'AWS/Lambda',
+            metricName,
+            ...props
+        });
     }
@@ -137,3 +141,3 @@ /**
     static metricAllErrors(props) {
-        return this.metricAll('Errors', Object.assign({ statistic: 'sum' }, props));
+        return this.metricAll('Errors', { statistic: 'sum', ...props });
     }
@@ -154,3 +158,3 @@ /**
     static metricAllInvocations(props) {
-        return this.metricAll('Invocations', Object.assign({ statistic: 'sum' }, props));
+        return this.metricAll('Invocations', { statistic: 'sum', ...props });
     }
@@ -163,3 +167,3 @@ /**
     static metricAllThrottles(props) {
-        return this.metricAll('Throttles', Object.assign({ statistic: 'sum' }, props));
+        return this.metricAll('Throttles', { statistic: 'sum', ...props });
     }
@@ -178,3 +182,3 @@ /**
         // otherwise not be visible in the avg)
-        return this.metricAll('ConcurrentExecutions', Object.assign({ statistic: 'max' }, props));
+        return this.metricAll('ConcurrentExecutions', { statistic: 'max', ...props });
     }
@@ -187,3 +191,3 @@ /**
     static metricAllUnreservedConcurrentExecutions(props) {
-        return this.metricAll('UnreservedConcurrentExecutions', Object.assign({ statistic: 'max' }, props));
+        return this.metricAll('UnreservedConcurrentExecutions', { statistic: 'max', ...props });
     }
@@ -195,5 +199,5 @@ /**
         return {
-            functionArn: new cdk.CfnOutput(this, 'FunctionArn', { value: this.functionArn }).makeImportValue().toString(),
+            functionArn: new cdk_1.CfnOutput(this, 'FunctionArn', { value: this.functionArn }).makeImportValue().toString(),
             securityGroupId: this._connections && this._connections.securityGroups[0]
-                ? new cdk.CfnOutput(this, 'SecurityGroupId', { value: this._connections.securityGroups[0].securityGroupId }).makeImportValue().toString()
+                ? new cdk_1.CfnOutput(this, 'SecurityGroupId', { value: this._connections.securityGroups[0].securityGroupId }).makeImportValue().toString()
                 : undefined
@@ -309,3 +313,3 @@ };
         // Isolated networks or selecting among 2 sets of Private subnets by name.
-        const subnetIds = props.vpc.subnetIds(props.vpcSubnets);
+        const { subnetIds } = props.vpc.selectSubnets(props.vpcSubnets);
         const publicSubnetIds = new Set(props.vpc.publicSubnets.map(s => s.subnetId));
@@ -376,3 +380,2 @@ for (const subnetId of subnetIds) {
 }
-exports.ImportedFunction = ImportedFunction;
 /**
@@ -392,4 +395,4 @@ * Given an opaque (token) ARN, returns a CloudFormation expression that extracts the function
 function extractNameFromArn(arn) {
-    return cdk.Fn.select(6, cdk.Fn.split(':', arn));
+    return cdk_1.Fn.select(6, cdk_1.Fn.split(':', arn));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function.js","sourceRoot":"","sources":["function.ts"],"names":[],"mappings":"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","sourcesContent":["import cloudwatch = require('@aws-cdk/aws-cloudwatch');\nimport ec2 = require('@aws-cdk/aws-ec2');\nimport iam = require('@aws-cdk/aws-iam');\nimport logs = require('@aws-cdk/aws-logs');\nimport sqs = require('@aws-cdk/aws-sqs');\nimport cdk = require('@aws-cdk/cdk');\nimport { Code } from './code';\nimport { IEventSource } from './event-source';\nimport { FunctionBase, FunctionImportProps, IFunction } from './function-base';\nimport { Version } from './lambda-version';\nimport { CfnFunction } from './lambda.generated';\nimport { ILayerVersion } from './layers';\nimport { LogRetention } from './log-retention';\nimport { Runtime } from './runtime';\n\n/**\n * X-Ray Tracing Modes (https://docs.aws.amazon.com/lambda/latest/dg/API_TracingConfig.html)\n */\nexport enum Tracing {\n  /**\n   * Lambda will respect any tracing header it receives from an upstream service.\n   * If no tracing header is received, Lambda will call X-Ray for a tracing decision.\n   */\n  Active,\n  /**\n   * Lambda will only trace the request from an upstream service\n   * if it contains a tracing header with \"sampled=1\"\n   */\n  PassThrough,\n  /**\n   * Lambda will not trace any request.\n   */\n  Disabled\n}\n\nexport interface FunctionProps {\n  /**\n   * The source code of your Lambda function. You can point to a file in an\n   * Amazon Simple Storage Service (Amazon S3) bucket or specify your source\n   * code as inline text.\n   */\n  readonly code: Code;\n\n  /**\n   * A description of the function.\n   */\n  readonly description?: string;\n\n  /**\n   * The name of the function (within your source code) that Lambda calls to\n   * start running your code. For more information, see the Handler property\n   * in the AWS Lambda Developer Guide.\n   *\n   * NOTE: If you specify your source code as inline text by specifying the\n   * ZipFile property within the Code property, specify index.function_name as\n   * the handler.\n   */\n  readonly handler: string;\n\n  /**\n   * The function execution time (in seconds) after which Lambda terminates\n   * the function. Because the execution time affects cost, set this value\n   * based on the function's expected execution time.\n   *\n   * @default 3 seconds.\n   */\n  readonly timeout?: number;\n\n  /**\n   * Key-value pairs that Lambda caches and makes available for your Lambda\n   * functions. Use environment variables to apply configuration changes, such\n   * as test and production environment configurations, without changing your\n   * Lambda function source code.\n   */\n  readonly environment?: { [key: string]: any };\n\n  /**\n   * The runtime environment for the Lambda function that you are uploading.\n   * For valid values, see the Runtime property in the AWS Lambda Developer\n   * Guide.\n   */\n  readonly runtime: Runtime;\n\n  /**\n   * A name for the function. If you don't specify a name, AWS CloudFormation\n   * generates a unique physical ID and uses that ID for the function's name.\n   * For more information, see Name Type.\n   */\n  readonly functionName?: string;\n\n  /**\n   * The amount of memory, in MB, that is allocated to your Lambda function.\n   * Lambda uses this value to proportionally allocate the amount of CPU\n   * power. For more information, see Resource Model in the AWS Lambda\n   * Developer Guide.\n   *\n   * @default The default value is 128 MB\n   */\n  readonly memorySize?: number;\n\n  /**\n   * Initial policy statements to add to the created Lambda Role.\n   *\n   * You can call `addToRolePolicy` to the created lambda to add statements post creation.\n   */\n  readonly initialPolicy?: iam.PolicyStatement[];\n\n  /**\n   * Lambda execution role.\n   *\n   * This is the role that will be assumed by the function upon execution.\n   * It controls the permissions that the function will have. The Role must\n   * be assumable by the 'lambda.amazonaws.com' service principal.\n   *\n   * @default a unique role will be generated for this lambda function.\n   * Both supplied and generated roles can always be changed by calling `addToRolePolicy`.\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * VPC network to place Lambda network interfaces\n   *\n   * Specify this if the Lambda function needs to access resources in a VPC.\n   */\n  readonly vpc?: ec2.IVpcNetwork;\n\n  /**\n   * Where to place the network interfaces within the VPC.\n   *\n   * Only used if 'vpc' is supplied. Note: internet access for Lambdas\n   * requires a NAT gateway, so picking Public subnets is not allowed.\n   *\n   * @default All private subnets\n   */\n  readonly vpcSubnets?: ec2.SubnetSelection;\n\n  /**\n   * What security group to associate with the Lambda's network interfaces.\n   *\n   * Only used if 'vpc' is supplied.\n   *\n   * @default If the function is placed within a VPC and a security group is\n   * not specified, a dedicated security group will be created for this\n   * function.\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Whether to allow the Lambda to send all network traffic\n   *\n   * If set to false, you must individually add traffic rules to allow the\n   * Lambda to connect to network targets.\n   *\n   * @default true\n   */\n  readonly allowAllOutbound?: boolean;\n\n  /**\n   * Enabled DLQ. If `deadLetterQueue` is undefined,\n   * an SQS queue with default options will be defined for your Function.\n   *\n   * @default false unless `deadLetterQueue` is set, which implies DLQ is enabled\n   */\n  readonly deadLetterQueueEnabled?: boolean;\n\n  /**\n   * The SQS queue to use if DLQ is enabled.\n   *\n   * @default SQS queue with 14 day retention period if `deadLetterQueueEnabled` is `true`\n   */\n  readonly deadLetterQueue?: sqs.IQueue;\n\n  /**\n   * Enable AWS X-Ray Tracing for Lambda Function.\n   *\n   * @default undefined X-Ray tracing disabled\n   */\n  readonly tracing?: Tracing;\n\n  /**\n   * A list of layers to add to the function's execution environment. You can configure your Lambda function to pull in\n   * additional code during initialization in the form of layers. Layers are packages of libraries or other dependencies\n   * that can be used by mulitple functions.\n   *\n   * @default no layers\n   */\n  readonly layers?: ILayerVersion[];\n\n  /**\n   * The maximum of concurrent executions you want to reserve for the function.\n   *\n   * @default no specific limit - account limit\n   * @see https://docs.aws.amazon.com/lambda/latest/dg/concurrent-executions.html\n   */\n  readonly reservedConcurrentExecutions?: number;\n\n  /**\n   * Event sources for this function.\n   *\n   * You can also add event sources using `addEventSource`.\n   */\n  readonly events?: IEventSource[];\n\n  /**\n   * The number of days log events are kept in CloudWatch Logs. When updating\n   * this property, unsetting it doesn't remove the log retention policy. To\n   * remove the retention policy, set the value to `Infinity`.\n   *\n   * @default logs never expire\n   */\n  readonly logRetentionDays?: logs.RetentionDays;\n}\n\n/**\n * Deploys a file from from inside the construct library as a function.\n *\n * The supplied file is subject to the 4096 bytes limit of being embedded in a\n * CloudFormation template.\n *\n * The construct includes an associated role with the lambda.\n *\n * This construct does not yet reproduce all features from the underlying resource\n * library.\n */\nexport class Function extends FunctionBase {\n  /**\n   * Creates a Lambda function object which represents a function not defined\n   * within this stack.\n   *\n   *    Lambda.import(this, 'MyImportedFunction', { lambdaArn: new LambdaArn('arn:aws:...') });\n   *\n   * @param parent The parent construct\n   * @param id The name of the lambda construct\n   * @param props A reference to a Lambda function. Can be created manually (see\n   * example above) or obtained through a call to `lambda.export()`.\n   */\n  public static import(scope: cdk.Construct, id: string, props: FunctionImportProps): IFunction {\n    return new ImportedFunction(scope, id, props);\n  }\n\n  /**\n   * Return the given named metric for this Lambda\n   */\n  public static metricAll(metricName: string, props?: cloudwatch.MetricCustomization): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      namespace: 'AWS/Lambda',\n      metricName,\n      ...props\n    });\n  }\n  /**\n   * Metric for the number of Errors executing all Lambdas\n   *\n   * @default sum over 5 minutes\n   */\n  public static metricAllErrors(props?: cloudwatch.MetricCustomization): cloudwatch.Metric {\n    return this.metricAll('Errors', { statistic: 'sum', ...props });\n  }\n\n  /**\n   * Metric for the Duration executing all Lambdas\n   *\n   * @default average over 5 minutes\n   */\n  public static metricAllDuration(props?: cloudwatch.MetricCustomization): cloudwatch.Metric {\n    return this.metricAll('Duration', props);\n  }\n\n  /**\n   * Metric for the number of invocations of all Lambdas\n   *\n   * @default sum over 5 minutes\n   */\n  public static metricAllInvocations(props?: cloudwatch.MetricCustomization): cloudwatch.Metric {\n    return this.metricAll('Invocations', { statistic: 'sum', ...props });\n  }\n\n  /**\n   * Metric for the number of throttled invocations of all Lambdas\n   *\n   * @default sum over 5 minutes\n   */\n  public static metricAllThrottles(props?: cloudwatch.MetricCustomization): cloudwatch.Metric {\n    return this.metricAll('Throttles', { statistic: 'sum', ...props });\n  }\n\n  /**\n   * Metric for the number of concurrent executions across all Lambdas\n   *\n   * @default max over 5 minutes\n   */\n  public static metricAllConcurrentExecutions(props?: cloudwatch.MetricCustomization): cloudwatch.Metric {\n    // Mini-FAQ: why max? This metric is a gauge that is emitted every\n    // minute, so either max or avg or a percentile make sense (but sum\n    // doesn't). Max is more sensitive to spiky load changes which is\n    // probably what you're interested in if you're looking at this metric\n    // (Load spikes may lead to concurrent execution errors that would\n    // otherwise not be visible in the avg)\n    return this.metricAll('ConcurrentExecutions', { statistic: 'max', ...props });\n  }\n\n  /**\n   * Metric for the number of unreserved concurrent executions across all Lambdas\n   *\n   * @default max over 5 minutes\n   */\n  public static metricAllUnreservedConcurrentExecutions(props?: cloudwatch.MetricCustomization): cloudwatch.Metric {\n    return this.metricAll('UnreservedConcurrentExecutions', { statistic: 'max', ...props });\n  }\n\n  /**\n   * Name of this function\n   */\n  public readonly functionName: string;\n\n  /**\n   * ARN of this function\n   */\n  public readonly functionArn: string;\n\n  /**\n   * Execution role associated with this function\n   */\n  public readonly role?: iam.IRole;\n\n  /**\n   * The runtime configured for this lambda.\n   */\n  public readonly runtime: Runtime;\n\n  /**\n   * The name of the handler configured for this lambda.\n   */\n  public readonly handler: string;\n\n  /**\n   * The principal this Lambda Function is running as\n   */\n  public readonly grantPrincipal: iam.IPrincipal;\n\n  protected readonly canCreatePermissions = true;\n\n  private readonly layers: ILayerVersion[] = [];\n\n  /**\n   * Environment variables for this function\n   */\n  private readonly environment?: { [key: string]: any };\n\n  constructor(scope: cdk.Construct, id: string, props: FunctionProps) {\n    super(scope, id);\n\n    this.environment = props.environment || { };\n\n    const managedPolicyArns = new Array<string>();\n\n    // the arn is in the form of - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole\n    managedPolicyArns.push(new iam.AwsManagedPolicy(\"service-role/AWSLambdaBasicExecutionRole\", this).policyArn);\n\n    if (props.vpc) {\n      // Policy that will have ENI creation permissions\n      managedPolicyArns.push(new iam.AwsManagedPolicy(\"service-role/AWSLambdaVPCAccessExecutionRole\", this).policyArn);\n    }\n\n    this.role = props.role || new iam.Role(this, 'ServiceRole', {\n      assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),\n      managedPolicyArns,\n    });\n    this.grantPrincipal = this.role;\n\n    for (const statement of (props.initialPolicy || [])) {\n      this.role.addToPolicy(statement);\n    }\n\n    const isChina = this.node.stack.env.region && this.node.stack.env.region.startsWith('cn-');\n    if (isChina && props.environment && Object.keys(props.environment).length > 0) {\n      // tslint:disable-next-line:max-line-length\n      throw new Error(`Environment variables are not supported in this region (${this.node.stack.env.region}); consider using tags or SSM parameters instead`);\n    }\n\n    const resource = new CfnFunction(this, 'Resource', {\n      functionName: props.functionName,\n      description: props.description,\n      code: new cdk.Token(() => props.code._toJSON(resource)),\n      layers: new cdk.Token(() => this.layers.length > 0 ? this.layers.map(layer => layer.layerVersionArn) : undefined).toList(),\n      handler: props.handler,\n      timeout: props.timeout,\n      runtime: props.runtime.name,\n      role: this.role.roleArn,\n      environment: new cdk.Token(() => this.renderEnvironment()),\n      memorySize: props.memorySize,\n      vpcConfig: this.configureVpc(props),\n      deadLetterConfig: this.buildDeadLetterConfig(props),\n      tracingConfig: this.buildTracingConfig(props),\n      reservedConcurrentExecutions: props.reservedConcurrentExecutions\n    });\n\n    resource.node.addDependency(this.role);\n\n    this.functionName = resource.ref;\n    this.functionArn = resource.functionArn;\n    this.handler = props.handler;\n    this.runtime = props.runtime;\n\n    // allow code to bind to stack.\n    props.code.bind(this);\n\n    for (const layer of props.layers || []) {\n      this.addLayer(layer);\n    }\n\n    for (const event of props.events || []) {\n      this.addEventSource(event);\n    }\n\n    // Log retention\n    if (props.logRetentionDays) {\n      new LogRetention(this, 'LogRetention', {\n        logGroupName: `/aws/lambda/${this.functionName}`,\n        retentionDays: props.logRetentionDays\n      });\n    }\n  }\n\n  /**\n   * Export this Function (without the role)\n   */\n  public export(): FunctionImportProps {\n    return {\n      functionArn: new cdk.CfnOutput(this, 'FunctionArn', { value: this.functionArn }).makeImportValue().toString(),\n      securityGroupId: this._connections && this._connections.securityGroups[0]\n          ? new cdk.CfnOutput(this, 'SecurityGroupId', { value: this._connections.securityGroups[0].securityGroupId }).makeImportValue().toString()\n          : undefined\n    };\n  }\n\n  /**\n   * Adds an environment variable to this Lambda function.\n   * If this is a ref to a Lambda function, this operation results in a no-op.\n   * @param key The environment variable key.\n   * @param value The environment variable's value.\n   */\n  public addEnvironment(key: string, value: any): this {\n    if (!this.environment) {\n      // TODO: add metadata\n      return this;\n    }\n    this.environment[key] = value;\n    return this;\n  }\n\n  /**\n   * Adds a Lambda Layer to this Lambda function.\n   *\n   * @param layer the layer to be added.\n   *\n   * @throws if there are already 5 layers on this function, or the layer is incompatible with this function's runtime.\n   */\n  public addLayer(layer: ILayerVersion): this {\n    if (this.layers.length === 5) {\n      throw new Error('Unable to add layer: this lambda function already uses 5 layers.');\n    }\n    if (layer.compatibleRuntimes && layer.compatibleRuntimes.indexOf(this.runtime) === -1) {\n      const runtimes = layer.compatibleRuntimes.map(runtime => runtime.name).join(', ');\n      throw new Error(`This lambda function uses a runtime that is incompatible with this layer (${this.runtime.name} is not in [${runtimes}])`);\n    }\n    this.layers.push(layer);\n    return this;\n  }\n\n  /**\n   * Add a new version for this Lambda\n   *\n   * If you want to deploy through CloudFormation and use aliases, you need to\n   * add a new version (with a new name) to your Lambda every time you want\n   * to deploy an update. An alias can then refer to the newly created Version.\n   *\n   * All versions should have distinct names, and you should not delete versions\n   * as long as your Alias needs to refer to them.\n   *\n   * @param name A unique name for this version\n   * @param codeSha256 The SHA-256 hash of the most recently deployed Lambda source code, or\n   *  omit to skip validation.\n   * @param description A description for this version.\n   * @returns A new Version object.\n   */\n  public addVersion(name: string, codeSha256?: string, description?: string): Version {\n    return new Version(this, 'Version' + name, {\n      lambda: this,\n      codeSha256,\n      description,\n    });\n  }\n\n  /**\n   * Add a new version for this Lambda, always with a different name.\n   *\n   * This is similar to the {@link addVersion} method,\n   * but useful when deploying this Lambda through CodePipeline with blue/green deployments.\n   * When using {@link addVersion},\n   * your Alias will not be updated until you change the name passed to {@link addVersion} in your CDK code.\n   * When deploying through a Pipeline,\n   * that might lead to a situation where a change to your Lambda application code will never be activated,\n   * even though it traveled through the entire Pipeline,\n   * because the Alias is still pointing to an old Version.\n   * This method creates a new, unique Version every time the CDK code is executed,\n   * and so prevents that from happening.\n   */\n  public newVersion(): Version {\n    const now = new Date();\n    return this.addVersion(now.toISOString());\n  }\n\n  private renderEnvironment() {\n    if (!this.environment || Object.keys(this.environment).length === 0) {\n      return undefined;\n    }\n\n    return {\n      variables: this.environment\n    };\n  }\n\n  /**\n   * If configured, set up the VPC-related properties\n   *\n   * Returns the VpcConfig that should be added to the\n   * Lambda creation properties.\n   */\n  private configureVpc(props: FunctionProps): CfnFunction.VpcConfigProperty | undefined {\n    if ((props.securityGroup || props.allowAllOutbound !== undefined) && !props.vpc) {\n      throw new Error(`Cannot configure 'securityGroup' or 'allowAllOutbound' without configuring a VPC`);\n    }\n\n    if (!props.vpc) { return undefined; }\n\n    if (props.securityGroup && props.allowAllOutbound !== undefined) {\n      throw new Error(`Configure 'allowAllOutbound' directly on the supplied SecurityGroup.`);\n    }\n\n    const securityGroup = props.securityGroup || new ec2.SecurityGroup(this, 'SecurityGroup', {\n      vpc: props.vpc,\n      description: 'Automatic security group for Lambda Function ' + this.node.uniqueId,\n      allowAllOutbound: props.allowAllOutbound\n    });\n\n    this._connections = new ec2.Connections({ securityGroups: [securityGroup] });\n\n    // Pick subnets, make sure they're not Public. Routing through an IGW\n    // won't work because the ENIs don't get a Public IP.\n    // Why are we not simply forcing vpcSubnets? Because you might still be choosing\n    // Isolated networks or selecting among 2 sets of Private subnets by name.\n    const subnetIds = props.vpc.subnetIds(props.vpcSubnets);\n    const publicSubnetIds = new Set(props.vpc.publicSubnets.map(s => s.subnetId));\n    for (const subnetId of subnetIds) {\n      if (publicSubnetIds.has(subnetId)) {\n        throw new Error('Not possible to place Lambda Functions in a Public subnet');\n      }\n    }\n\n    // List can't be empty here, if we got this far you intended to put your Lambda\n    // in subnets. We're going to guarantee that we get the nice error message by\n    // making VpcNetwork do the selection again.\n\n    return {\n      subnetIds,\n      securityGroupIds: [securityGroup.securityGroupId]\n    };\n  }\n\n  private buildDeadLetterConfig(props: FunctionProps) {\n    if (props.deadLetterQueue && props.deadLetterQueueEnabled === false) {\n      throw Error('deadLetterQueue defined but deadLetterQueueEnabled explicitly set to false');\n    }\n\n    if (!props.deadLetterQueue && !props.deadLetterQueueEnabled) {\n      return undefined;\n    }\n\n    const deadLetterQueue = props.deadLetterQueue || new sqs.Queue(this, 'DeadLetterQueue', {\n      retentionPeriodSec: 1209600\n    });\n\n    this.addToRolePolicy(new iam.PolicyStatement()\n      .addAction('sqs:SendMessage')\n      .addResource(deadLetterQueue.queueArn));\n\n    return {\n      targetArn: deadLetterQueue.queueArn\n    };\n  }\n\n  private buildTracingConfig(props: FunctionProps) {\n    if (props.tracing === undefined || props.tracing === Tracing.Disabled) {\n      return undefined;\n    }\n\n    this.addToRolePolicy(new iam.PolicyStatement()\n      .addActions('xray:PutTraceSegments', 'xray:PutTelemetryRecords')\n      .addAllResources());\n\n    return {\n      mode: Tracing[props.tracing]\n    };\n  }\n}\n\nexport class ImportedFunction extends FunctionBase {\n  public readonly grantPrincipal: iam.IPrincipal;\n  public readonly functionName: string;\n  public readonly functionArn: string;\n  public readonly role?: iam.IRole;\n\n  protected readonly canCreatePermissions = false;\n\n  constructor(scope: cdk.Construct, id: string, private readonly props: FunctionImportProps) {\n    super(scope, id);\n\n    this.functionArn = props.functionArn;\n    this.functionName = extractNameFromArn(props.functionArn);\n    this.role = props.role;\n    this.grantPrincipal = this.role || new iam.ImportedResourcePrincipal({ resource: this } );\n\n    if (props.securityGroupId) {\n      this._connections = new ec2.Connections({\n        securityGroups: [\n          ec2.SecurityGroup.import(this, 'SecurityGroup', { securityGroupId: props.securityGroupId })\n        ]\n      });\n    }\n  }\n\n  public export() {\n    return this.props;\n  }\n}\n\n/**\n * Given an opaque (token) ARN, returns a CloudFormation expression that extracts the function\n * name from the ARN.\n *\n * Function ARNs look like this:\n *\n *   arn:aws:lambda:region:account-id:function:function-name\n *\n * ..which means that in order to extract the `function-name` component from the ARN, we can\n * split the ARN using \":\" and select the component in index 6.\n *\n * @returns `FnSelect(6, FnSplit(':', arn))`\n */\nfunction extractNameFromArn(arn: string) {\n  return cdk.Fn.select(6, cdk.Fn.split(':', arn));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function.js","sourceRoot":"","sources":["function.ts"],"names":[],"mappings":"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","sourcesContent":["import cloudwatch = require('@aws-cdk/aws-cloudwatch');\nimport ec2 = require('@aws-cdk/aws-ec2');\nimport iam = require('@aws-cdk/aws-iam');\nimport logs = require('@aws-cdk/aws-logs');\nimport sqs = require('@aws-cdk/aws-sqs');\nimport { CfnOutput, Construct, Fn, Token } from '@aws-cdk/cdk';\nimport { Code } from './code';\nimport { IEventSource } from './event-source';\nimport { FunctionBase, FunctionImportProps, IFunction } from './function-base';\nimport { Version } from './lambda-version';\nimport { CfnFunction } from './lambda.generated';\nimport { ILayerVersion } from './layers';\nimport { LogRetention } from './log-retention';\nimport { Runtime } from './runtime';\n\n/**\n * X-Ray Tracing Modes (https://docs.aws.amazon.com/lambda/latest/dg/API_TracingConfig.html)\n */\nexport enum Tracing {\n  /**\n   * Lambda will respect any tracing header it receives from an upstream service.\n   * If no tracing header is received, Lambda will call X-Ray for a tracing decision.\n   */\n  Active,\n  /**\n   * Lambda will only trace the request from an upstream service\n   * if it contains a tracing header with \"sampled=1\"\n   */\n  PassThrough,\n  /**\n   * Lambda will not trace any request.\n   */\n  Disabled\n}\n\nexport interface FunctionProps {\n  /**\n   * The source code of your Lambda function. You can point to a file in an\n   * Amazon Simple Storage Service (Amazon S3) bucket or specify your source\n   * code as inline text.\n   */\n  readonly code: Code;\n\n  /**\n   * A description of the function.\n   */\n  readonly description?: string;\n\n  /**\n   * The name of the function (within your source code) that Lambda calls to\n   * start running your code. For more information, see the Handler property\n   * in the AWS Lambda Developer Guide.\n   *\n   * NOTE: If you specify your source code as inline text by specifying the\n   * ZipFile property within the Code property, specify index.function_name as\n   * the handler.\n   */\n  readonly handler: string;\n\n  /**\n   * The function execution time (in seconds) after which Lambda terminates\n   * the function. Because the execution time affects cost, set this value\n   * based on the function's expected execution time.\n   *\n   * @default 3 seconds.\n   */\n  readonly timeout?: number;\n\n  /**\n   * Key-value pairs that Lambda caches and makes available for your Lambda\n   * functions. Use environment variables to apply configuration changes, such\n   * as test and production environment configurations, without changing your\n   * Lambda function source code.\n   */\n  readonly environment?: { [key: string]: any };\n\n  /**\n   * The runtime environment for the Lambda function that you are uploading.\n   * For valid values, see the Runtime property in the AWS Lambda Developer\n   * Guide.\n   */\n  readonly runtime: Runtime;\n\n  /**\n   * A name for the function. If you don't specify a name, AWS CloudFormation\n   * generates a unique physical ID and uses that ID for the function's name.\n   * For more information, see Name Type.\n   */\n  readonly functionName?: string;\n\n  /**\n   * The amount of memory, in MB, that is allocated to your Lambda function.\n   * Lambda uses this value to proportionally allocate the amount of CPU\n   * power. For more information, see Resource Model in the AWS Lambda\n   * Developer Guide.\n   *\n   * @default The default value is 128 MB\n   */\n  readonly memorySize?: number;\n\n  /**\n   * Initial policy statements to add to the created Lambda Role.\n   *\n   * You can call `addToRolePolicy` to the created lambda to add statements post creation.\n   */\n  readonly initialPolicy?: iam.PolicyStatement[];\n\n  /**\n   * Lambda execution role.\n   *\n   * This is the role that will be assumed by the function upon execution.\n   * It controls the permissions that the function will have. The Role must\n   * be assumable by the 'lambda.amazonaws.com' service principal.\n   *\n   * @default a unique role will be generated for this lambda function.\n   * Both supplied and generated roles can always be changed by calling `addToRolePolicy`.\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * VPC network to place Lambda network interfaces\n   *\n   * Specify this if the Lambda function needs to access resources in a VPC.\n   */\n  readonly vpc?: ec2.IVpcNetwork;\n\n  /**\n   * Where to place the network interfaces within the VPC.\n   *\n   * Only used if 'vpc' is supplied. Note: internet access for Lambdas\n   * requires a NAT gateway, so picking Public subnets is not allowed.\n   *\n   * @default All private subnets\n   */\n  readonly vpcSubnets?: ec2.SubnetSelection;\n\n  /**\n   * What security group to associate with the Lambda's network interfaces.\n   *\n   * Only used if 'vpc' is supplied.\n   *\n   * @default If the function is placed within a VPC and a security group is\n   * not specified, a dedicated security group will be created for this\n   * function.\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Whether to allow the Lambda to send all network traffic\n   *\n   * If set to false, you must individually add traffic rules to allow the\n   * Lambda to connect to network targets.\n   *\n   * @default true\n   */\n  readonly allowAllOutbound?: boolean;\n\n  /**\n   * Enabled DLQ. If `deadLetterQueue` is undefined,\n   * an SQS queue with default options will be defined for your Function.\n   *\n   * @default false unless `deadLetterQueue` is set, which implies DLQ is enabled\n   */\n  readonly deadLetterQueueEnabled?: boolean;\n\n  /**\n   * The SQS queue to use if DLQ is enabled.\n   *\n   * @default SQS queue with 14 day retention period if `deadLetterQueueEnabled` is `true`\n   */\n  readonly deadLetterQueue?: sqs.IQueue;\n\n  /**\n   * Enable AWS X-Ray Tracing for Lambda Function.\n   *\n   * @default undefined X-Ray tracing disabled\n   */\n  readonly tracing?: Tracing;\n\n  /**\n   * A list of layers to add to the function's execution environment. You can configure your Lambda function to pull in\n   * additional code during initialization in the form of layers. Layers are packages of libraries or other dependencies\n   * that can be used by mulitple functions.\n   *\n   * @default no layers\n   */\n  readonly layers?: ILayerVersion[];\n\n  /**\n   * The maximum of concurrent executions you want to reserve for the function.\n   *\n   * @default no specific limit - account limit\n   * @see https://docs.aws.amazon.com/lambda/latest/dg/concurrent-executions.html\n   */\n  readonly reservedConcurrentExecutions?: number;\n\n  /**\n   * Event sources for this function.\n   *\n   * You can also add event sources using `addEventSource`.\n   */\n  readonly events?: IEventSource[];\n\n  /**\n   * The number of days log events are kept in CloudWatch Logs. When updating\n   * this property, unsetting it doesn't remove the log retention policy. To\n   * remove the retention policy, set the value to `Infinity`.\n   *\n   * @default logs never expire\n   */\n  readonly logRetentionDays?: logs.RetentionDays;\n}\n\n/**\n * Deploys a file from from inside the construct library as a function.\n *\n * The supplied file is subject to the 4096 bytes limit of being embedded in a\n * CloudFormation template.\n *\n * The construct includes an associated role with the lambda.\n *\n * This construct does not yet reproduce all features from the underlying resource\n * library.\n */\nexport class Function extends FunctionBase {\n  /**\n   * Creates a Lambda function object which represents a function not defined\n   * within this stack.\n   *\n   *    Lambda.import(this, 'MyImportedFunction', { lambdaArn: new LambdaArn('arn:aws:...') });\n   *\n   * @param scope The parent construct\n   * @param id The name of the lambda construct\n   * @param props A reference to a Lambda function. Can be created manually (see\n   * example above) or obtained through a call to `lambda.export()`.\n   */\n  public static import(scope: Construct, id: string, props: FunctionImportProps): IFunction {\n    return new ImportedFunction(scope, id, props);\n  }\n\n  /**\n   * Return the given named metric for this Lambda\n   */\n  public static metricAll(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return new cloudwatch.Metric({\n      namespace: 'AWS/Lambda',\n      metricName,\n      ...props\n    });\n  }\n  /**\n   * Metric for the number of Errors executing all Lambdas\n   *\n   * @default sum over 5 minutes\n   */\n  public static metricAllErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metricAll('Errors', { statistic: 'sum', ...props });\n  }\n\n  /**\n   * Metric for the Duration executing all Lambdas\n   *\n   * @default average over 5 minutes\n   */\n  public static metricAllDuration(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metricAll('Duration', props);\n  }\n\n  /**\n   * Metric for the number of invocations of all Lambdas\n   *\n   * @default sum over 5 minutes\n   */\n  public static metricAllInvocations(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metricAll('Invocations', { statistic: 'sum', ...props });\n  }\n\n  /**\n   * Metric for the number of throttled invocations of all Lambdas\n   *\n   * @default sum over 5 minutes\n   */\n  public static metricAllThrottles(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metricAll('Throttles', { statistic: 'sum', ...props });\n  }\n\n  /**\n   * Metric for the number of concurrent executions across all Lambdas\n   *\n   * @default max over 5 minutes\n   */\n  public static metricAllConcurrentExecutions(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    // Mini-FAQ: why max? This metric is a gauge that is emitted every\n    // minute, so either max or avg or a percentile make sense (but sum\n    // doesn't). Max is more sensitive to spiky load changes which is\n    // probably what you're interested in if you're looking at this metric\n    // (Load spikes may lead to concurrent execution errors that would\n    // otherwise not be visible in the avg)\n    return this.metricAll('ConcurrentExecutions', { statistic: 'max', ...props });\n  }\n\n  /**\n   * Metric for the number of unreserved concurrent executions across all Lambdas\n   *\n   * @default max over 5 minutes\n   */\n  public static metricAllUnreservedConcurrentExecutions(props?: cloudwatch.MetricOptions): cloudwatch.Metric {\n    return this.metricAll('UnreservedConcurrentExecutions', { statistic: 'max', ...props });\n  }\n\n  /**\n   * Name of this function\n   */\n  public readonly functionName: string;\n\n  /**\n   * ARN of this function\n   */\n  public readonly functionArn: string;\n\n  /**\n   * Execution role associated with this function\n   */\n  public readonly role?: iam.IRole;\n\n  /**\n   * The runtime configured for this lambda.\n   */\n  public readonly runtime: Runtime;\n\n  /**\n   * The name of the handler configured for this lambda.\n   */\n  public readonly handler: string;\n\n  /**\n   * The principal this Lambda Function is running as\n   */\n  public readonly grantPrincipal: iam.IPrincipal;\n\n  protected readonly canCreatePermissions = true;\n\n  private readonly layers: ILayerVersion[] = [];\n\n  /**\n   * Environment variables for this function\n   */\n  private readonly environment?: { [key: string]: any };\n\n  constructor(scope: Construct, id: string, props: FunctionProps) {\n    super(scope, id);\n\n    this.environment = props.environment || { };\n\n    const managedPolicyArns = new Array<string>();\n\n    // the arn is in the form of - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole\n    managedPolicyArns.push(new iam.AwsManagedPolicy(\"service-role/AWSLambdaBasicExecutionRole\", this).policyArn);\n\n    if (props.vpc) {\n      // Policy that will have ENI creation permissions\n      managedPolicyArns.push(new iam.AwsManagedPolicy(\"service-role/AWSLambdaVPCAccessExecutionRole\", this).policyArn);\n    }\n\n    this.role = props.role || new iam.Role(this, 'ServiceRole', {\n      assumedBy: new iam.ServicePrincipal('lambda.amazonaws.com'),\n      managedPolicyArns,\n    });\n    this.grantPrincipal = this.role;\n\n    for (const statement of (props.initialPolicy || [])) {\n      this.role.addToPolicy(statement);\n    }\n\n    const isChina = this.node.stack.env.region && this.node.stack.env.region.startsWith('cn-');\n    if (isChina && props.environment && Object.keys(props.environment).length > 0) {\n      // tslint:disable-next-line:max-line-length\n      throw new Error(`Environment variables are not supported in this region (${this.node.stack.env.region}); consider using tags or SSM parameters instead`);\n    }\n\n    const resource = new CfnFunction(this, 'Resource', {\n      functionName: props.functionName,\n      description: props.description,\n      code: new Token(() => props.code._toJSON(resource)),\n      layers: new Token(() => this.layers.length > 0 ? this.layers.map(layer => layer.layerVersionArn) : undefined).toList(),\n      handler: props.handler,\n      timeout: props.timeout,\n      runtime: props.runtime.name,\n      role: this.role.roleArn,\n      environment: new Token(() => this.renderEnvironment()),\n      memorySize: props.memorySize,\n      vpcConfig: this.configureVpc(props),\n      deadLetterConfig: this.buildDeadLetterConfig(props),\n      tracingConfig: this.buildTracingConfig(props),\n      reservedConcurrentExecutions: props.reservedConcurrentExecutions\n    });\n\n    resource.node.addDependency(this.role);\n\n    this.functionName = resource.ref;\n    this.functionArn = resource.functionArn;\n    this.handler = props.handler;\n    this.runtime = props.runtime;\n\n    // allow code to bind to stack.\n    props.code.bind(this);\n\n    for (const layer of props.layers || []) {\n      this.addLayer(layer);\n    }\n\n    for (const event of props.events || []) {\n      this.addEventSource(event);\n    }\n\n    // Log retention\n    if (props.logRetentionDays) {\n      new LogRetention(this, 'LogRetention', {\n        logGroupName: `/aws/lambda/${this.functionName}`,\n        retentionDays: props.logRetentionDays\n      });\n    }\n  }\n\n  /**\n   * Export this Function (without the role)\n   */\n  public export(): FunctionImportProps {\n    return {\n      functionArn: new CfnOutput(this, 'FunctionArn', { value: this.functionArn }).makeImportValue().toString(),\n      securityGroupId: this._connections && this._connections.securityGroups[0]\n          ? new CfnOutput(this, 'SecurityGroupId', { value: this._connections.securityGroups[0].securityGroupId }).makeImportValue().toString()\n          : undefined\n    };\n  }\n\n  /**\n   * Adds an environment variable to this Lambda function.\n   * If this is a ref to a Lambda function, this operation results in a no-op.\n   * @param key The environment variable key.\n   * @param value The environment variable's value.\n   */\n  public addEnvironment(key: string, value: any): this {\n    if (!this.environment) {\n      // TODO: add metadata\n      return this;\n    }\n    this.environment[key] = value;\n    return this;\n  }\n\n  /**\n   * Adds a Lambda Layer to this Lambda function.\n   *\n   * @param layer the layer to be added.\n   *\n   * @throws if there are already 5 layers on this function, or the layer is incompatible with this function's runtime.\n   */\n  public addLayer(layer: ILayerVersion): this {\n    if (this.layers.length === 5) {\n      throw new Error('Unable to add layer: this lambda function already uses 5 layers.');\n    }\n    if (layer.compatibleRuntimes && layer.compatibleRuntimes.indexOf(this.runtime) === -1) {\n      const runtimes = layer.compatibleRuntimes.map(runtime => runtime.name).join(', ');\n      throw new Error(`This lambda function uses a runtime that is incompatible with this layer (${this.runtime.name} is not in [${runtimes}])`);\n    }\n    this.layers.push(layer);\n    return this;\n  }\n\n  /**\n   * Add a new version for this Lambda\n   *\n   * If you want to deploy through CloudFormation and use aliases, you need to\n   * add a new version (with a new name) to your Lambda every time you want\n   * to deploy an update. An alias can then refer to the newly created Version.\n   *\n   * All versions should have distinct names, and you should not delete versions\n   * as long as your Alias needs to refer to them.\n   *\n   * @param name A unique name for this version\n   * @param codeSha256 The SHA-256 hash of the most recently deployed Lambda source code, or\n   *  omit to skip validation.\n   * @param description A description for this version.\n   * @returns A new Version object.\n   */\n  public addVersion(name: string, codeSha256?: string, description?: string): Version {\n    return new Version(this, 'Version' + name, {\n      lambda: this,\n      codeSha256,\n      description,\n    });\n  }\n\n  /**\n   * Add a new version for this Lambda, always with a different name.\n   *\n   * This is similar to the {@link addVersion} method,\n   * but useful when deploying this Lambda through CodePipeline with blue/green deployments.\n   * When using {@link addVersion},\n   * your Alias will not be updated until you change the name passed to {@link addVersion} in your CDK code.\n   * When deploying through a Pipeline,\n   * that might lead to a situation where a change to your Lambda application code will never be activated,\n   * even though it traveled through the entire Pipeline,\n   * because the Alias is still pointing to an old Version.\n   * This method creates a new, unique Version every time the CDK code is executed,\n   * and so prevents that from happening.\n   */\n  public newVersion(): Version {\n    const now = new Date();\n    return this.addVersion(now.toISOString());\n  }\n\n  private renderEnvironment() {\n    if (!this.environment || Object.keys(this.environment).length === 0) {\n      return undefined;\n    }\n\n    return {\n      variables: this.environment\n    };\n  }\n\n  /**\n   * If configured, set up the VPC-related properties\n   *\n   * Returns the VpcConfig that should be added to the\n   * Lambda creation properties.\n   */\n  private configureVpc(props: FunctionProps): CfnFunction.VpcConfigProperty | undefined {\n    if ((props.securityGroup || props.allowAllOutbound !== undefined) && !props.vpc) {\n      throw new Error(`Cannot configure 'securityGroup' or 'allowAllOutbound' without configuring a VPC`);\n    }\n\n    if (!props.vpc) { return undefined; }\n\n    if (props.securityGroup && props.allowAllOutbound !== undefined) {\n      throw new Error(`Configure 'allowAllOutbound' directly on the supplied SecurityGroup.`);\n    }\n\n    const securityGroup = props.securityGroup || new ec2.SecurityGroup(this, 'SecurityGroup', {\n      vpc: props.vpc,\n      description: 'Automatic security group for Lambda Function ' + this.node.uniqueId,\n      allowAllOutbound: props.allowAllOutbound\n    });\n\n    this._connections = new ec2.Connections({ securityGroups: [securityGroup] });\n\n    // Pick subnets, make sure they're not Public. Routing through an IGW\n    // won't work because the ENIs don't get a Public IP.\n    // Why are we not simply forcing vpcSubnets? Because you might still be choosing\n    // Isolated networks or selecting among 2 sets of Private subnets by name.\n    const { subnetIds } = props.vpc.selectSubnets(props.vpcSubnets);\n    const publicSubnetIds = new Set(props.vpc.publicSubnets.map(s => s.subnetId));\n    for (const subnetId of subnetIds) {\n      if (publicSubnetIds.has(subnetId)) {\n        throw new Error('Not possible to place Lambda Functions in a Public subnet');\n      }\n    }\n\n    // List can't be empty here, if we got this far you intended to put your Lambda\n    // in subnets. We're going to guarantee that we get the nice error message by\n    // making VpcNetwork do the selection again.\n\n    return {\n      subnetIds,\n      securityGroupIds: [securityGroup.securityGroupId]\n    };\n  }\n\n  private buildDeadLetterConfig(props: FunctionProps) {\n    if (props.deadLetterQueue && props.deadLetterQueueEnabled === false) {\n      throw Error('deadLetterQueue defined but deadLetterQueueEnabled explicitly set to false');\n    }\n\n    if (!props.deadLetterQueue && !props.deadLetterQueueEnabled) {\n      return undefined;\n    }\n\n    const deadLetterQueue = props.deadLetterQueue || new sqs.Queue(this, 'DeadLetterQueue', {\n      retentionPeriodSec: 1209600\n    });\n\n    this.addToRolePolicy(new iam.PolicyStatement()\n      .addAction('sqs:SendMessage')\n      .addResource(deadLetterQueue.queueArn));\n\n    return {\n      targetArn: deadLetterQueue.queueArn\n    };\n  }\n\n  private buildTracingConfig(props: FunctionProps) {\n    if (props.tracing === undefined || props.tracing === Tracing.Disabled) {\n      return undefined;\n    }\n\n    this.addToRolePolicy(new iam.PolicyStatement()\n      .addActions('xray:PutTraceSegments', 'xray:PutTelemetryRecords')\n      .addAllResources());\n\n    return {\n      mode: Tracing[props.tracing]\n    };\n  }\n}\n\nclass ImportedFunction extends FunctionBase {\n  public readonly grantPrincipal: iam.IPrincipal;\n  public readonly functionName: string;\n  public readonly functionArn: string;\n  public readonly role?: iam.IRole;\n\n  protected readonly canCreatePermissions = false;\n\n  constructor(scope: Construct, id: string, private readonly props: FunctionImportProps) {\n    super(scope, id);\n\n    this.functionArn = props.functionArn;\n    this.functionName = extractNameFromArn(props.functionArn);\n    this.role = props.role;\n    this.grantPrincipal = this.role || new iam.ImportedResourcePrincipal({ resource: this } );\n\n    if (props.securityGroupId) {\n      this._connections = new ec2.Connections({\n        securityGroups: [\n          ec2.SecurityGroup.import(this, 'SecurityGroup', { securityGroupId: props.securityGroupId })\n        ]\n      });\n    }\n  }\n\n  public export() {\n    return this.props;\n  }\n}\n\n/**\n * Given an opaque (token) ARN, returns a CloudFormation expression that extracts the function\n * name from the ARN.\n *\n * Function ARNs look like this:\n *\n *   arn:aws:lambda:region:account-id:function:function-name\n *\n * ..which means that in order to extract the `function-name` component from the ARN, we can\n * split the ARN using \":\" and select the component in index 6.\n *\n * @returns `FnSelect(6, FnSplit(':', arn))`\n */\nfunction extractNameFromArn(arn: string) {\n  return Fn.select(6, Fn.split(':', arn));\n}\n"]}

lib/lambda-augmentations.generated.d.ts

@@ -7,3 +7,3 @@ import cloudwatch = require("@aws-cdk/aws-cloudwatch");
          */
-        metric(metricName: string, props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+        metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;
         /**
@@ -14,3 +14,3 @@ * How often this Lambda is throttled
          */
-        metricThrottles(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+        metricThrottles(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
         /**
@@ -21,3 +21,3 @@ * How often this Lambda is invoked
          */
-        metricInvocations(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+        metricInvocations(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
         /**
@@ -28,3 +28,3 @@ * How many invocations of this Lambda fail
          */
-        metricErrors(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+        metricErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
         /**
@@ -35,3 +35,3 @@ * How long execution of this Lambda takes
          */
-        metricDuration(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+        metricDuration(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
     }
@@ -42,3 +42,3 @@ interface FunctionBase {
          */
-        metric(metricName: string, props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+        metric(metricName: string, props?: cloudwatch.MetricOptions): cloudwatch.Metric;
         /**
@@ -49,3 +49,3 @@ * How often this Lambda is throttled
          */
-        metricThrottles(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+        metricThrottles(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
         /**
@@ -56,3 +56,3 @@ * How often this Lambda is invoked
          */
-        metricInvocations(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+        metricInvocations(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
         /**
@@ -63,3 +63,3 @@ * How many invocations of this Lambda fail
          */
-        metricErrors(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+        metricErrors(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
         /**
@@ -70,4 +70,4 @@ * How long execution of this Lambda takes
          */
-        metricDuration(props?: cloudwatch.MetricCustomization): cloudwatch.Metric;
+        metricDuration(props?: cloudwatch.MetricOptions): cloudwatch.Metric;
     }
 }

lib/lambda-augmentations.generated.js

@@ -8,16 +8,21 @@ "use strict";
 function_base_1.FunctionBase.prototype.metric = function (metricName, props) {
-    return new cloudwatch.Metric(Object.assign({ namespace: 'AWS/Lambda', metricName, dimensions: { FunctionName: this.functionName } }, props));
+    return new cloudwatch.Metric({
+        namespace: 'AWS/Lambda',
+        metricName,
+        dimensions: { FunctionName: this.functionName },
+        ...props
+    });
 };
 function_base_1.FunctionBase.prototype.metricThrottles = function (props) {
-    return this.metric('Throttles', Object.assign({ statistic: 'Sum' }, props));
+    return this.metric('Throttles', { statistic: 'Sum', ...props });
 };
 function_base_1.FunctionBase.prototype.metricInvocations = function (props) {
-    return this.metric('Invocations', Object.assign({ statistic: 'Sum' }, props));
+    return this.metric('Invocations', { statistic: 'Sum', ...props });
 };
 function_base_1.FunctionBase.prototype.metricErrors = function (props) {
-    return this.metric('Errors', Object.assign({ statistic: 'Sum' }, props));
+    return this.metric('Errors', { statistic: 'Sum', ...props });
 };
 function_base_1.FunctionBase.prototype.metricDuration = function (props) {
-    return this.metric('Duration', Object.assign({ statistic: 'Average' }, props));
+    return this.metric('Duration', { statistic: 'Average', ...props });
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

lib/lambda-version.d.ts

@@ -1,2 +0,2 @@
-import { Construct } from '@aws-cdk/cdk';
+import { Construct, Resource } from '@aws-cdk/cdk';
 import { IFunction } from './function-base';
@@ -42,3 +42,3 @@ /**
  */
-export declare class Version extends Construct {
+export declare class Version extends Resource {
     /**
@@ -45,0 +45,0 @@ * The most recently deployed version of this function.

lib/lambda-version.js

@@ -21,3 +21,3 @@ "use strict";
  */
-class Version extends cdk_1.Construct {
+class Version extends cdk_1.Resource {
     constructor(scope, id, props) {
@@ -35,2 +35,2 @@ super(scope, id);
 exports.Version = Version;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

lib/layers.d.ts

@@ -1,2 +0,2 @@
-import cdk = require('@aws-cdk/cdk');
+import { Construct, IResource, Resource } from '@aws-cdk/cdk';
 import { Code } from './code';
@@ -31,3 +31,3 @@ import { Runtime } from './runtime';
 }
-export interface ILayerVersion extends cdk.IConstruct {
+export interface ILayerVersion extends IResource {
     /**
@@ -60,3 +60,3 @@ * The ARN of the Lambda Layer version that this Layer defines.
  */
-export declare abstract class LayerVersionBase extends cdk.Construct implements ILayerVersion {
+export declare abstract class LayerVersionBase extends Resource implements ILayerVersion {
     abstract readonly layerVersionArn: string;
@@ -107,6 +107,6 @@ abstract readonly compatibleRuntimes?: Runtime[];
      */
-    static import(scope: cdk.Construct, id: string, props: LayerVersionImportProps): ILayerVersion;
+    static import(scope: Construct, id: string, props: LayerVersionImportProps): ILayerVersion;
     readonly layerVersionArn: string;
     readonly compatibleRuntimes?: Runtime[];
-    constructor(scope: cdk.Construct, id: string, props: LayerVersionProps);
+    constructor(scope: Construct, id: string, props: LayerVersionProps);
 }
@@ -130,5 +130,5 @@ /**
  */
-export declare class SingletonLayerVersion extends cdk.Construct implements ILayerVersion {
+export declare class SingletonLayerVersion extends Construct implements ILayerVersion {
     private readonly layerVersion;
-    constructor(scope: cdk.Construct, id: string, props: SingletonLayerVersionProps);
+    constructor(scope: Construct, id: string, props: SingletonLayerVersionProps);
     readonly layerVersionArn: string;
@@ -135,0 +135,0 @@ readonly compatibleRuntimes: Runtime[] | undefined;

lib/layers.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const cdk = require("@aws-cdk/cdk");
+const cdk_1 = require("@aws-cdk/cdk");
 const lambda_generated_1 = require("./lambda.generated");
@@ -8,3 +8,3 @@ /**
  */
-class LayerVersionBase extends cdk.Construct {
+class LayerVersionBase extends cdk_1.Resource {
     grantUsage(id, grantee) {
@@ -24,3 +24,3 @@ if (grantee.organizationId != null && grantee.accountId !== '*') {
         return {
-            layerVersionArn: new cdk.CfnOutput(this, 'LayerVersionArn', { value: this.layerVersionArn }).makeImportValue().toString(),
+            layerVersionArn: new cdk_1.CfnOutput(this, 'LayerVersionArn', { value: this.layerVersionArn }).makeImportValue().toString(),
             compatibleRuntimes: this.compatibleRuntimes,
@@ -57,3 +57,3 @@ };
             compatibleRuntimes: props.compatibleRuntimes && props.compatibleRuntimes.map(r => r.name),
-            content: new cdk.Token(() => props.code._toJSON(resource)),
+            content: new cdk_1.Token(() => props.code._toJSON(resource)),
             description: props.description,
@@ -83,3 +83,3 @@ layerName: props.name,
  */
-class SingletonLayerVersion extends cdk.Construct {
+class SingletonLayerVersion extends cdk_1.Construct {
     constructor(scope, id, props) {
@@ -115,2 +115,2 @@ super(scope, id);
 exports.SingletonLayerVersion = SingletonLayerVersion;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layers.js","sourceRoot":"","sources":["layers.ts"],"names":[],"mappings":";;AAAA,oCAAqC;AAErC,yDAAgF;AAgEhF;;GAEG;AACH,MAAsB,gBAAiB,SAAQ,GAAG,CAAC,SAAS;IAInD,UAAU,CAAC,EAAU,EAAE,OAAiC;QAC7D,IAAI,OAAO,CAAC,cAAc,IAAI,IAAI,IAAI,OAAO,CAAC,SAAS,KAAK,GAAG,EAAE;YAC/D,MAAM,IAAI,KAAK,CAAC,0EAA0E,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;SAChH;QAED,IAAI,4CAAyB,CAAC,IAAI,EAAE,EAAE,EAAE;YACtC,MAAM,EAAE,wBAAwB;YAChC,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,cAAc,EAAE,OAAO,CAAC,cAAc;SACvC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,MAAM;QACX,OAAO;YACL,eAAe,EAAE,IAAI,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,eAAe,EAAE,CAAC,QAAQ,EAAE;YACzH,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;SAC5C,CAAC;IACJ,CAAC;CACF;AAxBD,4CAwBC;AAmCD;;GAEG;AACH,MAAa,YAAa,SAAQ,gBAAgB;IAChD;;;;;;OAMG;IACI,MAAM,CAAC,MAAM,CAAC,KAAoB,EAAE,EAAU,EAAE,KAA8B;QACnF,OAAO,IAAI,oBAAoB,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;IACpD,CAAC;IAKD,YAAY,KAAoB,EAAE,EAAU,EAAE,KAAwB;QACpE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,KAAK,CAAC,kBAAkB,IAAI,KAAK,CAAC,kBAAkB,CAAC,MAAM,KAAK,CAAC,EAAE;YACrE,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;SACjF;QACD,IAAI,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE;YACvB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;SACrE;QACD,6CAA6C;QAC7C,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEtB,MAAM,QAAQ,GAAG,IAAI,kCAAe,CAAC,IAAI,EAAE,UAAU,EAAE;YACrD,kBAAkB,EAAE,KAAK,CAAC,kBAAkB,IAAI,KAAK,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;YACzF,OAAO,EAAE,IAAI,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;YAC1D,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,SAAS,EAAE,KAAK,CAAC,IAAI;YACrB,WAAW,EAAE,KAAK,CAAC,OAAO;SAC3B,CAAC,CAAC;QAEH,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC,eAAe,CAAC;QAChD,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,kBAAkB,CAAC;IACrD,CAAC;CACF;AArCD,oCAqCC;AAED,MAAM,oBAAqB,SAAQ,gBAAgB;IAIjD,YAAmB,MAAqB,EAAE,EAAU,EAAE,KAA8B;QAClF,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QAElB,IAAI,KAAK,CAAC,kBAAkB,IAAI,KAAK,CAAC,kBAAkB,CAAC,MAAM,KAAK,CAAC,EAAE;YACrE,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;SACjF;QAED,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,eAAe,CAAC;QAC7C,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,kBAAkB,CAAC;IACrD,CAAC;CACF;AAeD;;;;GAIG;AACH,MAAa,qBAAsB,SAAQ,GAAG,CAAC,SAAS;IAGtD,YAAY,KAAoB,EAAE,EAAU,EAAE,KAAiC;QAC7E,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;IACrD,CAAC;IAED,IAAW,eAAe;QACxB,OAAO,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC;IAC3C,CAAC;IAED,IAAW,kBAAkB;QAC3B,OAAO,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC;IAC9C,CAAC;IAEM,MAAM;QACX,OAAO;YACL,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;SAC5C,CAAC;IACJ,CAAC;IAEM,UAAU,CAAC,EAAU,EAAE,OAAiC;QAC7D,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QAC1C,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,kBAAkB,CAAC,KAAiC;QAC1D,MAAM,WAAW,GAAG,kBAAkB,KAAK,CAAC,IAAI,EAAE,CAAC;QACnD,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;QAChE,IAAI,QAAQ,EAAE;YACZ,OAAO,QAAoC,CAAC;SAC7C;QACD,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;IAC/D,CAAC;CACF;AArCD,sDAqCC","sourcesContent":["import cdk = require('@aws-cdk/cdk');\nimport { Code } from './code';\nimport { CfnLayerVersion, CfnLayerVersionPermission } from './lambda.generated';\nimport { Runtime } from './runtime';\n\nexport interface LayerVersionProps {\n  /**\n   * The runtimes that this layer is compatible with.\n   *\n   * @default All runtimes are supported\n   */\n  readonly compatibleRuntimes?: Runtime[];\n\n  /**\n   * The content of this Layer. Using *inline* (per ``code.isInline``) code is not permitted.\n   */\n  readonly code: Code;\n\n  /**\n   * The description the this Lambda Layer.\n   */\n  readonly description?: string;\n\n  /**\n   * The SPDX licence identifier or URL to the license file for this layer.\n   *\n   * @default no license information will be recorded.\n   */\n  readonly license?: string;\n\n  /**\n   * The name of the layer.\n   * @default a name will be generated.\n   */\n  readonly name?: string;\n}\n\nexport interface ILayerVersion extends cdk.IConstruct {\n  /**\n   * The ARN of the Lambda Layer version that this Layer defines.\n   */\n  readonly layerVersionArn: string;\n\n  /**\n   * The runtimes compatible with this Layer.\n   */\n  readonly compatibleRuntimes?: Runtime[];\n\n  /**\n   * Exports this layer for use in another Stack. The resulting object can be passed to the ``LayerVersion.import``\n   * function to obtain an ``ILayerVersion`` in the user stack.\n   */\n  export(): LayerVersionImportProps;\n\n  /**\n   * Grants usage of this layer to specific entities. Usage within the same account where the layer is defined is always\n   * allowed and does not require calling this method. Note that the principal that creates the Lambda function using\n   * the layer (for example, a CloudFormation changeset execution role) also needs to have the\n   * ``lambda:GetLayerVersion`` permission on the layer version.\n   *\n   * @param id the ID of the grant in the construct tree.\n   * @param grantee the identification of the grantee.\n   */\n  grantUsage(id: string, grantee: LayerVersionUsageGrantee): ILayerVersion\n}\n\n/**\n * A reference to a Lambda Layer version.\n */\nexport abstract class LayerVersionBase extends cdk.Construct implements ILayerVersion {\n  public abstract readonly layerVersionArn: string;\n  public abstract readonly compatibleRuntimes?: Runtime[];\n\n  public grantUsage(id: string, grantee: LayerVersionUsageGrantee): ILayerVersion {\n    if (grantee.organizationId != null && grantee.accountId !== '*') {\n      throw new Error(`OrganizationId can only be specified if AwsAccountId is '*', but it is ${grantee.accountId}`);\n    }\n\n    new CfnLayerVersionPermission(this, id, {\n      action: 'lambda:GetLayerVersion',\n      layerVersionArn: this.layerVersionArn,\n      principal: grantee.accountId,\n      organizationId: grantee.organizationId,\n    });\n    return this;\n  }\n\n  public export(): LayerVersionImportProps {\n    return {\n      layerVersionArn: new cdk.CfnOutput(this, 'LayerVersionArn', { value: this.layerVersionArn }).makeImportValue().toString(),\n      compatibleRuntimes: this.compatibleRuntimes,\n    };\n  }\n}\n\n/**\n * Identification of an account (or organization) that is allowed to access a Lambda Layer Version.\n */\nexport interface LayerVersionUsageGrantee {\n  /**\n   * The AWS Account id of the account that is authorized to use a Lambda Layer Version. The wild-card ``'*'`` can be\n   * used to grant access to \"any\" account (or any account in an organization when ``organizationId`` is specified).\n   */\n  readonly accountId: string;\n\n  /**\n   * The ID of the AWS Organization to hwich the grant is restricted.\n   *\n   * Can only be specified if ``accountId`` is ``'*'``\n   */\n  readonly organizationId?: string;\n}\n\n/**\n * Properties necessary to import a LayerVersion.\n */\nexport interface LayerVersionImportProps {\n  /**\n   * The ARN of the LayerVersion.\n   */\n  readonly layerVersionArn: string;\n\n  /**\n   * The list of compatible runtimes with this Layer.\n   */\n  readonly compatibleRuntimes?: Runtime[];\n}\n\n/**\n * Defines a new Lambda Layer version.\n */\nexport class LayerVersion extends LayerVersionBase {\n  /**\n   * Imports a Layer that has been defined externally.\n   *\n   * @param scope the parent Construct that will use the imported layer.\n   * @param id    the id of the imported layer in the construct tree.\n   * @param props the properties of the imported layer.\n   */\n  public static import(scope: cdk.Construct, id: string, props: LayerVersionImportProps): ILayerVersion {\n    return new ImportedLayerVersion(scope, id, props);\n  }\n\n  public readonly layerVersionArn: string;\n  public readonly compatibleRuntimes?: Runtime[];\n\n  constructor(scope: cdk.Construct, id: string, props: LayerVersionProps) {\n    super(scope, id);\n    if (props.compatibleRuntimes && props.compatibleRuntimes.length === 0) {\n      throw new Error('Attempted to define a Lambda layer that supports no runtime!');\n    }\n    if (props.code.isInline) {\n      throw new Error('Lambda layers cannot be created from inline code');\n    }\n    // Allow usage of the code in this context...\n    props.code.bind(this);\n\n    const resource = new CfnLayerVersion(this, 'Resource', {\n      compatibleRuntimes: props.compatibleRuntimes && props.compatibleRuntimes.map(r => r.name),\n      content: new cdk.Token(() => props.code._toJSON(resource)),\n      description: props.description,\n      layerName: props.name,\n      licenseInfo: props.license,\n    });\n\n    this.layerVersionArn = resource.layerVersionArn;\n    this.compatibleRuntimes = props.compatibleRuntimes;\n  }\n}\n\nclass ImportedLayerVersion extends LayerVersionBase {\n  public readonly layerVersionArn: string;\n  public readonly compatibleRuntimes?: Runtime[];\n\n  public constructor(parent: cdk.Construct, id: string, props: LayerVersionImportProps) {\n    super(parent, id);\n\n    if (props.compatibleRuntimes && props.compatibleRuntimes.length === 0) {\n      throw new Error('Attempted to import a Lambda layer that supports no runtime!');\n    }\n\n    this.layerVersionArn = props.layerVersionArn;\n    this.compatibleRuntimes = props.compatibleRuntimes;\n  }\n}\n\n/**\n * Properties of a Singleton Lambda Layer Version.\n */\nexport interface SingletonLayerVersionProps extends LayerVersionProps {\n  /**\n   * A unique identifier to identify this lambda layer version.\n   *\n   * The identifier should be unique across all layer providers.\n   * We recommend generating a UUID per provider.\n   */\n  readonly uuid: string;\n}\n\n/**\n * A Singleton Lambda Layer Version. The construct gurantees exactly one LayerVersion will be created in a given Stack\n * for the provided ``uuid``. It is recommended to use ``uuidgen`` to create a new ``uuid`` each time a new singleton\n * layer is created.\n */\nexport class SingletonLayerVersion extends cdk.Construct implements ILayerVersion {\n  private readonly layerVersion: ILayerVersion;\n\n  constructor(scope: cdk.Construct, id: string, props: SingletonLayerVersionProps) {\n    super(scope, id);\n\n    this.layerVersion = this.ensureLayerVersion(props);\n  }\n\n  public get layerVersionArn(): string {\n    return this.layerVersion.layerVersionArn;\n  }\n\n  public get compatibleRuntimes(): Runtime[] | undefined {\n    return this.layerVersion.compatibleRuntimes;\n  }\n\n  public export(): LayerVersionImportProps {\n    return {\n      layerVersionArn: this.layerVersionArn,\n      compatibleRuntimes: this.compatibleRuntimes,\n    };\n  }\n\n  public grantUsage(id: string, grantee: LayerVersionUsageGrantee): ILayerVersion {\n    this.layerVersion.grantUsage(id, grantee);\n    return this;\n  }\n\n  private ensureLayerVersion(props: SingletonLayerVersionProps): ILayerVersion {\n    const singletonId = `SingletonLayer-${props.uuid}`;\n    const existing = this.node.stack.node.tryFindChild(singletonId);\n    if (existing) {\n      return existing as unknown as ILayerVersion;\n    }\n    return new LayerVersion(this.node.stack, singletonId, props);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"layers.js","sourceRoot":"","sources":["layers.ts"],"names":[],"mappings":";;AAAA,sCAAgF;AAEhF,yDAAgF;AAgEhF;;GAEG;AACH,MAAsB,gBAAiB,SAAQ,cAAQ;IAI9C,UAAU,CAAC,EAAU,EAAE,OAAiC;QAC7D,IAAI,OAAO,CAAC,cAAc,IAAI,IAAI,IAAI,OAAO,CAAC,SAAS,KAAK,GAAG,EAAE;YAC/D,MAAM,IAAI,KAAK,CAAC,0EAA0E,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;SAChH;QAED,IAAI,4CAAyB,CAAC,IAAI,EAAE,EAAE,EAAE;YACtC,MAAM,EAAE,wBAAwB;YAChC,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,cAAc,EAAE,OAAO,CAAC,cAAc;SACvC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,MAAM;QACX,OAAO;YACL,eAAe,EAAE,IAAI,eAAS,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC,eAAe,EAAE,CAAC,QAAQ,EAAE;YACrH,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;SAC5C,CAAC;IACJ,CAAC;CACF;AAxBD,4CAwBC;AAmCD;;GAEG;AACH,MAAa,YAAa,SAAQ,gBAAgB;IAChD;;;;;;OAMG;IACI,MAAM,CAAC,MAAM,CAAC,KAAgB,EAAE,EAAU,EAAE,KAA8B;QAC/E,OAAO,IAAI,oBAAoB,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;IACpD,CAAC;IAKD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAwB;QAChE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,KAAK,CAAC,kBAAkB,IAAI,KAAK,CAAC,kBAAkB,CAAC,MAAM,KAAK,CAAC,EAAE;YACrE,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;SACjF;QACD,IAAI,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE;YACvB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;SACrE;QACD,6CAA6C;QAC7C,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEtB,MAAM,QAAQ,GAAG,IAAI,kCAAe,CAAC,IAAI,EAAE,UAAU,EAAE;YACrD,kBAAkB,EAAE,KAAK,CAAC,kBAAkB,IAAI,KAAK,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;YACzF,OAAO,EAAE,IAAI,WAAK,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;YACtD,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,SAAS,EAAE,KAAK,CAAC,IAAI;YACrB,WAAW,EAAE,KAAK,CAAC,OAAO;SAC3B,CAAC,CAAC;QAEH,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC,eAAe,CAAC;QAChD,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,kBAAkB,CAAC;IACrD,CAAC;CACF;AArCD,oCAqCC;AAED,MAAM,oBAAqB,SAAQ,gBAAgB;IAIjD,YAAmB,MAAiB,EAAE,EAAU,EAAE,KAA8B;QAC9E,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QAElB,IAAI,KAAK,CAAC,kBAAkB,IAAI,KAAK,CAAC,kBAAkB,CAAC,MAAM,KAAK,CAAC,EAAE;YACrE,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;SACjF;QAED,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC,eAAe,CAAC;QAC7C,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,kBAAkB,CAAC;IACrD,CAAC;CACF;AAeD;;;;GAIG;AACH,MAAa,qBAAsB,SAAQ,eAAS;IAGlD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAiC;QACzE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;IACrD,CAAC;IAED,IAAW,eAAe;QACxB,OAAO,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC;IAC3C,CAAC;IAED,IAAW,kBAAkB;QAC3B,OAAO,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC;IAC9C,CAAC;IAEM,MAAM;QACX,OAAO;YACL,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;SAC5C,CAAC;IACJ,CAAC;IAEM,UAAU,CAAC,EAAU,EAAE,OAAiC;QAC7D,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QAC1C,OAAO,IAAI,CAAC;IACd,CAAC;IAEO,kBAAkB,CAAC,KAAiC;QAC1D,MAAM,WAAW,GAAG,kBAAkB,KAAK,CAAC,IAAI,EAAE,CAAC;QACnD,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,CAAC;QAChE,IAAI,QAAQ,EAAE;YACZ,OAAO,QAAoC,CAAC;SAC7C;QACD,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC,CAAC;IAC/D,CAAC;CACF;AArCD,sDAqCC","sourcesContent":["import { CfnOutput, Construct, IResource, Resource, Token } from '@aws-cdk/cdk';\nimport { Code } from './code';\nimport { CfnLayerVersion, CfnLayerVersionPermission } from './lambda.generated';\nimport { Runtime } from './runtime';\n\nexport interface LayerVersionProps {\n  /**\n   * The runtimes that this layer is compatible with.\n   *\n   * @default All runtimes are supported\n   */\n  readonly compatibleRuntimes?: Runtime[];\n\n  /**\n   * The content of this Layer. Using *inline* (per ``code.isInline``) code is not permitted.\n   */\n  readonly code: Code;\n\n  /**\n   * The description the this Lambda Layer.\n   */\n  readonly description?: string;\n\n  /**\n   * The SPDX licence identifier or URL to the license file for this layer.\n   *\n   * @default no license information will be recorded.\n   */\n  readonly license?: string;\n\n  /**\n   * The name of the layer.\n   * @default a name will be generated.\n   */\n  readonly name?: string;\n}\n\nexport interface ILayerVersion extends IResource {\n  /**\n   * The ARN of the Lambda Layer version that this Layer defines.\n   */\n  readonly layerVersionArn: string;\n\n  /**\n   * The runtimes compatible with this Layer.\n   */\n  readonly compatibleRuntimes?: Runtime[];\n\n  /**\n   * Exports this layer for use in another Stack. The resulting object can be passed to the ``LayerVersion.import``\n   * function to obtain an ``ILayerVersion`` in the user stack.\n   */\n  export(): LayerVersionImportProps;\n\n  /**\n   * Grants usage of this layer to specific entities. Usage within the same account where the layer is defined is always\n   * allowed and does not require calling this method. Note that the principal that creates the Lambda function using\n   * the layer (for example, a CloudFormation changeset execution role) also needs to have the\n   * ``lambda:GetLayerVersion`` permission on the layer version.\n   *\n   * @param id the ID of the grant in the construct tree.\n   * @param grantee the identification of the grantee.\n   */\n  grantUsage(id: string, grantee: LayerVersionUsageGrantee): ILayerVersion\n}\n\n/**\n * A reference to a Lambda Layer version.\n */\nexport abstract class LayerVersionBase extends Resource implements ILayerVersion {\n  public abstract readonly layerVersionArn: string;\n  public abstract readonly compatibleRuntimes?: Runtime[];\n\n  public grantUsage(id: string, grantee: LayerVersionUsageGrantee): ILayerVersion {\n    if (grantee.organizationId != null && grantee.accountId !== '*') {\n      throw new Error(`OrganizationId can only be specified if AwsAccountId is '*', but it is ${grantee.accountId}`);\n    }\n\n    new CfnLayerVersionPermission(this, id, {\n      action: 'lambda:GetLayerVersion',\n      layerVersionArn: this.layerVersionArn,\n      principal: grantee.accountId,\n      organizationId: grantee.organizationId,\n    });\n    return this;\n  }\n\n  public export(): LayerVersionImportProps {\n    return {\n      layerVersionArn: new CfnOutput(this, 'LayerVersionArn', { value: this.layerVersionArn }).makeImportValue().toString(),\n      compatibleRuntimes: this.compatibleRuntimes,\n    };\n  }\n}\n\n/**\n * Identification of an account (or organization) that is allowed to access a Lambda Layer Version.\n */\nexport interface LayerVersionUsageGrantee {\n  /**\n   * The AWS Account id of the account that is authorized to use a Lambda Layer Version. The wild-card ``'*'`` can be\n   * used to grant access to \"any\" account (or any account in an organization when ``organizationId`` is specified).\n   */\n  readonly accountId: string;\n\n  /**\n   * The ID of the AWS Organization to hwich the grant is restricted.\n   *\n   * Can only be specified if ``accountId`` is ``'*'``\n   */\n  readonly organizationId?: string;\n}\n\n/**\n * Properties necessary to import a LayerVersion.\n */\nexport interface LayerVersionImportProps {\n  /**\n   * The ARN of the LayerVersion.\n   */\n  readonly layerVersionArn: string;\n\n  /**\n   * The list of compatible runtimes with this Layer.\n   */\n  readonly compatibleRuntimes?: Runtime[];\n}\n\n/**\n * Defines a new Lambda Layer version.\n */\nexport class LayerVersion extends LayerVersionBase {\n  /**\n   * Imports a Layer that has been defined externally.\n   *\n   * @param scope the parent Construct that will use the imported layer.\n   * @param id    the id of the imported layer in the construct tree.\n   * @param props the properties of the imported layer.\n   */\n  public static import(scope: Construct, id: string, props: LayerVersionImportProps): ILayerVersion {\n    return new ImportedLayerVersion(scope, id, props);\n  }\n\n  public readonly layerVersionArn: string;\n  public readonly compatibleRuntimes?: Runtime[];\n\n  constructor(scope: Construct, id: string, props: LayerVersionProps) {\n    super(scope, id);\n    if (props.compatibleRuntimes && props.compatibleRuntimes.length === 0) {\n      throw new Error('Attempted to define a Lambda layer that supports no runtime!');\n    }\n    if (props.code.isInline) {\n      throw new Error('Lambda layers cannot be created from inline code');\n    }\n    // Allow usage of the code in this context...\n    props.code.bind(this);\n\n    const resource = new CfnLayerVersion(this, 'Resource', {\n      compatibleRuntimes: props.compatibleRuntimes && props.compatibleRuntimes.map(r => r.name),\n      content: new Token(() => props.code._toJSON(resource)),\n      description: props.description,\n      layerName: props.name,\n      licenseInfo: props.license,\n    });\n\n    this.layerVersionArn = resource.layerVersionArn;\n    this.compatibleRuntimes = props.compatibleRuntimes;\n  }\n}\n\nclass ImportedLayerVersion extends LayerVersionBase {\n  public readonly layerVersionArn: string;\n  public readonly compatibleRuntimes?: Runtime[];\n\n  public constructor(parent: Construct, id: string, props: LayerVersionImportProps) {\n    super(parent, id);\n\n    if (props.compatibleRuntimes && props.compatibleRuntimes.length === 0) {\n      throw new Error('Attempted to import a Lambda layer that supports no runtime!');\n    }\n\n    this.layerVersionArn = props.layerVersionArn;\n    this.compatibleRuntimes = props.compatibleRuntimes;\n  }\n}\n\n/**\n * Properties of a Singleton Lambda Layer Version.\n */\nexport interface SingletonLayerVersionProps extends LayerVersionProps {\n  /**\n   * A unique identifier to identify this lambda layer version.\n   *\n   * The identifier should be unique across all layer providers.\n   * We recommend generating a UUID per provider.\n   */\n  readonly uuid: string;\n}\n\n/**\n * A Singleton Lambda Layer Version. The construct gurantees exactly one LayerVersion will be created in a given Stack\n * for the provided ``uuid``. It is recommended to use ``uuidgen`` to create a new ``uuid`` each time a new singleton\n * layer is created.\n */\nexport class SingletonLayerVersion extends Construct implements ILayerVersion {\n  private readonly layerVersion: ILayerVersion;\n\n  constructor(scope: Construct, id: string, props: SingletonLayerVersionProps) {\n    super(scope, id);\n\n    this.layerVersion = this.ensureLayerVersion(props);\n  }\n\n  public get layerVersionArn(): string {\n    return this.layerVersion.layerVersionArn;\n  }\n\n  public get compatibleRuntimes(): Runtime[] | undefined {\n    return this.layerVersion.compatibleRuntimes;\n  }\n\n  public export(): LayerVersionImportProps {\n    return {\n      layerVersionArn: this.layerVersionArn,\n      compatibleRuntimes: this.compatibleRuntimes,\n    };\n  }\n\n  public grantUsage(id: string, grantee: LayerVersionUsageGrantee): ILayerVersion {\n    this.layerVersion.grantUsage(id, grantee);\n    return this;\n  }\n\n  private ensureLayerVersion(props: SingletonLayerVersionProps): ILayerVersion {\n    const singletonId = `SingletonLayer-${props.uuid}`;\n    const existing = this.node.stack.node.tryFindChild(singletonId);\n    if (existing) {\n      return existing as unknown as ILayerVersion;\n    }\n    return new LayerVersion(this.node.stack, singletonId, props);\n  }\n}\n"]}

lib/log-retention-provider/index.js

@@ -50,5 +50,13 @@ "use strict";
                 // there could be a race condition. So we also try to create the log group
-                // of this function first.
-                await createLogGroupSafe(`/aws/lambda/${context.functionName}`);
-                await setRetentionPolicy(`/aws/lambda/${context.functionName}`, 1);
+                // of this function first. If multiple LogRetention constructs are present
+                // in the stack, they will try to act on this function's log group at the
+                // same time. This can sometime result in an OperationAbortedException. To
+                // avoid this and because this operation is not critical we catch all errors.
+                try {
+                    await createLogGroupSafe(`/aws/lambda/${context.functionName}`);
+                    await setRetentionPolicy(`/aws/lambda/${context.functionName}`, 1);
+                }
+                catch (e) {
+                    console.log(e);
+                }
             }
@@ -94,2 +102,2 @@ }
 exports.handler = handler;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable:no-console\nimport AWS = require('aws-sdk');\n\n/**\n * Creates a log group and doesn't throw if it exists.\n *\n * @param logGroupName the name of the log group to create\n */\nasync function createLogGroupSafe(logGroupName: string) {\n  try { // Try to create the log group\n    const cloudwatchlogs = new AWS.CloudWatchLogs({ apiVersion: '2014-03-28' });\n    await cloudwatchlogs.createLogGroup({ logGroupName }).promise();\n  } catch (e) {\n    if (e.code !== 'ResourceAlreadyExistsException') {\n      throw e;\n    }\n  }\n}\n\n/**\n * Puts or deletes a retention policy on a log group.\n *\n * @param logGroupName the name of the log group to create\n * @param retentionInDays the number of days to retain the log events in the specified log group.\n */\nasync function setRetentionPolicy(logGroupName: string, retentionInDays?: number) {\n  const cloudwatchlogs = new AWS.CloudWatchLogs({ apiVersion: '2014-03-28' });\n  if (!retentionInDays) {\n    await cloudwatchlogs.deleteRetentionPolicy({ logGroupName }).promise();\n  } else {\n    await cloudwatchlogs.putRetentionPolicy({ logGroupName, retentionInDays }).promise();\n  }\n}\n\nexport async function handler(event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context) {\n  try {\n    console.log(JSON.stringify(event));\n\n    // The target log group\n    const logGroupName = event.ResourceProperties.LogGroupName;\n\n    if (event.RequestType === 'Create' || event.RequestType === 'Update') {\n      // Act on the target log group\n      await createLogGroupSafe(logGroupName);\n      await setRetentionPolicy(logGroupName, parseInt(event.ResourceProperties.RetentionInDays, 10));\n\n      if (event.RequestType === 'Create') {\n        // Set a retention policy of 1 day on the logs of this function. The log\n        // group for this function should already exist at this stage because we\n        // already logged the event but due to the async nature of Lambda logging\n        // there could be a race condition. So we also try to create the log group\n        // of this function first.\n        await createLogGroupSafe(`/aws/lambda/${context.functionName}`);\n        await setRetentionPolicy(`/aws/lambda/${context.functionName}`, 1);\n      }\n    }\n\n    await respond('SUCCESS', 'OK', logGroupName);\n  } catch (e) {\n    console.log(e);\n\n    await respond('FAILED', e.message, event.ResourceProperties.LogGroupName);\n  }\n\n  function respond(responseStatus: string, reason: string, physicalResourceId: string) {\n    const responseBody = JSON.stringify({\n      Status: responseStatus,\n      Reason: reason,\n      PhysicalResourceId: physicalResourceId,\n      StackId: event.StackId,\n      RequestId: event.RequestId,\n      LogicalResourceId: event.LogicalResourceId,\n      Data: {}\n    });\n\n    console.log('Responding', responseBody);\n\n    const parsedUrl = require('url').parse(event.ResponseURL);\n    const requestOptions = {\n      hostname: parsedUrl.hostname,\n      path: parsedUrl.path,\n      method: 'PUT',\n      headers: { 'content-type': '', 'content-length': responseBody.length }\n    };\n\n    return new Promise((resolve, reject) => {\n      try {\n        const request = require('https').request(requestOptions, resolve);\n        request.on('error', reject);\n        request.write(responseBody);\n        request.end();\n      } catch (e) {\n        reject(e);\n      }\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable:no-console\nimport AWS = require('aws-sdk');\n\n/**\n * Creates a log group and doesn't throw if it exists.\n *\n * @param logGroupName the name of the log group to create\n */\nasync function createLogGroupSafe(logGroupName: string) {\n  try { // Try to create the log group\n    const cloudwatchlogs = new AWS.CloudWatchLogs({ apiVersion: '2014-03-28' });\n    await cloudwatchlogs.createLogGroup({ logGroupName }).promise();\n  } catch (e) {\n    if (e.code !== 'ResourceAlreadyExistsException') {\n      throw e;\n    }\n  }\n}\n\n/**\n * Puts or deletes a retention policy on a log group.\n *\n * @param logGroupName the name of the log group to create\n * @param retentionInDays the number of days to retain the log events in the specified log group.\n */\nasync function setRetentionPolicy(logGroupName: string, retentionInDays?: number) {\n  const cloudwatchlogs = new AWS.CloudWatchLogs({ apiVersion: '2014-03-28' });\n  if (!retentionInDays) {\n    await cloudwatchlogs.deleteRetentionPolicy({ logGroupName }).promise();\n  } else {\n    await cloudwatchlogs.putRetentionPolicy({ logGroupName, retentionInDays }).promise();\n  }\n}\n\nexport async function handler(event: AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context) {\n  try {\n    console.log(JSON.stringify(event));\n\n    // The target log group\n    const logGroupName = event.ResourceProperties.LogGroupName;\n\n    if (event.RequestType === 'Create' || event.RequestType === 'Update') {\n      // Act on the target log group\n      await createLogGroupSafe(logGroupName);\n      await setRetentionPolicy(logGroupName, parseInt(event.ResourceProperties.RetentionInDays, 10));\n\n      if (event.RequestType === 'Create') {\n        // Set a retention policy of 1 day on the logs of this function. The log\n        // group for this function should already exist at this stage because we\n        // already logged the event but due to the async nature of Lambda logging\n        // there could be a race condition. So we also try to create the log group\n        // of this function first. If multiple LogRetention constructs are present\n        // in the stack, they will try to act on this function's log group at the\n        // same time. This can sometime result in an OperationAbortedException. To\n        // avoid this and because this operation is not critical we catch all errors.\n        try {\n          await createLogGroupSafe(`/aws/lambda/${context.functionName}`);\n          await setRetentionPolicy(`/aws/lambda/${context.functionName}`, 1);\n        } catch (e) {\n          console.log(e);\n        }\n      }\n    }\n\n    await respond('SUCCESS', 'OK', logGroupName);\n  } catch (e) {\n    console.log(e);\n\n    await respond('FAILED', e.message, event.ResourceProperties.LogGroupName);\n  }\n\n  function respond(responseStatus: string, reason: string, physicalResourceId: string) {\n    const responseBody = JSON.stringify({\n      Status: responseStatus,\n      Reason: reason,\n      PhysicalResourceId: physicalResourceId,\n      StackId: event.StackId,\n      RequestId: event.RequestId,\n      LogicalResourceId: event.LogicalResourceId,\n      Data: {}\n    });\n\n    console.log('Responding', responseBody);\n\n    const parsedUrl = require('url').parse(event.ResponseURL);\n    const requestOptions = {\n      hostname: parsedUrl.hostname,\n      path: parsedUrl.path,\n      method: 'PUT',\n      headers: { 'content-type': '', 'content-length': responseBody.length }\n    };\n\n    return new Promise((resolve, reject) => {\n      try {\n        const request = require('https').request(requestOptions, resolve);\n        request.on('error', reject);\n        request.write(responseBody);\n        request.end();\n      } catch (e) {\n        reject(e);\n      }\n    });\n  }\n}\n"]}

lib/log-retention.js

@@ -25,10 +25,9 @@ "use strict";
         });
-        if (provider.role && !provider.role.node.tryFindChild('DefaultPolicy')) { // Avoid duplicate statements
-            provider.role.addToPolicy(new iam.PolicyStatement()
-                .addActions('logs:PutRetentionPolicy', 'logs:DeleteRetentionPolicy')
-                // We need '*' here because we will also put a retention policy on
-                // the log group of the provider function. Referencing it's name
-                // creates a CF circular dependency.
-                .addAllResources());
-        }
+        provider.addToRolePolicy(// Duplicate statements will be deduplicated by `PolicyDocument`
+        new iam.PolicyStatement()
+            .addActions('logs:PutRetentionPolicy', 'logs:DeleteRetentionPolicy')
+            // We need '*' here because we will also put a retention policy on
+            // the log group of the provider function. Referencing it's name
+            // creates a CF circular dependency.
+            .addAllResources());
         // Need to use a CfnResource here to prevent lerna dependency cycles
@@ -47,2 +46,2 @@ // @aws-cdk/aws-cloudformation -> @aws-cdk/aws-lambda -> @aws-cdk/aws-cloudformation
 exports.LogRetention = LogRetention;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package.json

 {
   "name": "@aws-cdk/aws-lambda",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "CDK Constructs for AWS Lambda",
@@ -32,3 +32,4 @@ "main": "lib/index.js",
     "type": "git",
-    "url": "https://github.com/awslabs/aws-cdk.git"
+    "url": "https://github.com/awslabs/aws-cdk.git",
+    "directory": "packages/@aws-cdk/aws-lambda"
   },
@@ -66,42 +67,43 @@ "scripts": {
   "devDependencies": {
-    "@aws-cdk/assert": "^0.28.0",
-    "@types/aws-lambda": "^8.10.23",
+    "@aws-cdk/assert": "^0.29.0",
+    "@types/aws-lambda": "^8.10.24",
     "@types/nock": "^9.3.1",
-    "@types/sinon": "^7.0.10",
-    "aws-sdk": "^2.425.0",
-    "aws-sdk-mock": "^4.3.1",
-    "cdk-build-tools": "^0.28.0",
-    "cdk-integ-tools": "^0.28.0",
-    "cfn2ts": "^0.28.0",
+    "@types/sinon": "^7.0.11",
+    "aws-sdk": "^2.438.0",
+    "aws-sdk-mock": "^4.4.0",
+    "cdk-build-tools": "^0.29.0",
+    "cdk-integ-tools": "^0.29.0",
+    "cfn2ts": "^0.29.0",
     "nock": "^10.0.6",
-    "pkglint": "^0.28.0",
-    "sinon": "^7.3.0"
+    "pkglint": "^0.29.0",
+    "sinon": "^7.3.1"
   },
   "dependencies": {
-    "@aws-cdk/assets": "^0.28.0",
-    "@aws-cdk/aws-cloudwatch": "^0.28.0",
-    "@aws-cdk/aws-ec2": "^0.28.0",
-    "@aws-cdk/aws-events": "^0.28.0",
-    "@aws-cdk/aws-iam": "^0.28.0",
-    "@aws-cdk/aws-logs": "^0.28.0",
-    "@aws-cdk/aws-s3": "^0.28.0",
-    "@aws-cdk/aws-s3-notifications": "^0.28.0",
-    "@aws-cdk/aws-sqs": "^0.28.0",
-    "@aws-cdk/aws-stepfunctions": "^0.28.0",
-    "@aws-cdk/cdk": "^0.28.0",
-    "@aws-cdk/cx-api": "^0.28.0"
+    "@aws-cdk/assets": "^0.29.0",
+    "@aws-cdk/aws-cloudwatch": "^0.29.0",
+    "@aws-cdk/aws-ec2": "^0.29.0",
+    "@aws-cdk/aws-events": "^0.29.0",
+    "@aws-cdk/aws-iam": "^0.29.0",
+    "@aws-cdk/aws-logs": "^0.29.0",
+    "@aws-cdk/aws-s3": "^0.29.0",
+    "@aws-cdk/aws-s3-notifications": "^0.29.0",
+    "@aws-cdk/aws-sqs": "^0.29.0",
+    "@aws-cdk/aws-stepfunctions": "^0.29.0",
+    "@aws-cdk/cdk": "^0.29.0",
+    "@aws-cdk/cx-api": "^0.29.0"
   },
   "homepage": "https://github.com/awslabs/aws-cdk",
   "peerDependencies": {
-    "@aws-cdk/assets": "^0.28.0",
-    "@aws-cdk/aws-cloudwatch": "^0.28.0",
-    "@aws-cdk/aws-ec2": "^0.28.0",
-    "@aws-cdk/aws-events": "^0.28.0",
-    "@aws-cdk/aws-iam": "^0.28.0",
-    "@aws-cdk/aws-logs": "^0.28.0",
-    "@aws-cdk/aws-s3": "^0.28.0",
-    "@aws-cdk/aws-s3-notifications": "^0.28.0",
-    "@aws-cdk/aws-sqs": "^0.28.0",
-    "@aws-cdk/aws-stepfunctions": "^0.28.0",
-    "@aws-cdk/cdk": "^0.28.0"
+    "@aws-cdk/assets": "^0.29.0",
+    "@aws-cdk/aws-cloudwatch": "^0.29.0",
+    "@aws-cdk/aws-ec2": "^0.29.0",
+    "@aws-cdk/aws-events": "^0.29.0",
+    "@aws-cdk/aws-iam": "^0.29.0",
+    "@aws-cdk/aws-logs": "^0.29.0",
+    "@aws-cdk/aws-s3": "^0.29.0",
+    "@aws-cdk/aws-s3-notifications": "^0.29.0",
+    "@aws-cdk/aws-sqs": "^0.29.0",
+    "@aws-cdk/aws-stepfunctions": "^0.29.0",
+    "@aws-cdk/cdk": "^0.29.0",
+    "@aws-cdk/cx-api": "^0.29.0"
   },
@@ -116,2 +118,2 @@ "engines": {
   }
-}
+}

README.md

@@ -43,2 +43,12 @@ ## AWS Lambda Construct Library
 
+## Event Rule Target
+
+You can use an AWS Lambda function as a target for an Amazon CloudWatch event
+rule:
+
+```ts
+import targets = require('@aws-cdk/aws-events-targets');
+rule.addTarget(new targets.LambdaFunction(myFunction));
+```
+
 ### Event Sources
@@ -45,0 +55,0 @@

test/test.alias.js

@@ -136,3 +136,14 @@ "use strict";
                     Value: {
-                        Ref: "Alias325C5727"
+                        'Fn::Join': [
+                            '',
+                            [
+                                {
+                                    "Fn::GetAtt": [
+                                        "MyLambdaCCE802FB",
+                                        "Arn"
+                                    ]
+                                },
+                                ':prod'
+                            ]
+                        ]
                     }
@@ -192,2 +203,2 @@ }]
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.alias.js","sourceRoot":"","sources":["test.alias.ts"],"names":[],"mappings":"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","sourcesContent":["import { beASupersetOfTemplate, expect, haveResource, haveResourceLike } from '@aws-cdk/assert';\nimport cloudwatch = require('@aws-cdk/aws-cloudwatch');\nimport { Stack } from '@aws-cdk/cdk';\nimport { Test } from 'nodeunit';\nimport lambda = require('../lib');\n\nexport = {\n  'version and aliases'(test: Test): void {\n    const stack = new Stack();\n    const fn = new lambda.Function(stack, 'MyLambda', {\n      code: new lambda.InlineCode('hello()'),\n      handler: 'index.hello',\n      runtime: lambda.Runtime.NodeJS610,\n    });\n\n    const version = fn.addVersion('1');\n\n    new lambda.Alias(stack, 'Alias', {\n      aliasName: 'prod',\n      version,\n    });\n\n    expect(stack).to(beASupersetOfTemplate({\n      MyLambdaVersion16CDE3C40: {\n        Type: \"AWS::Lambda::Version\",\n        Properties: {\n          FunctionName: { Ref: \"MyLambdaCCE802FB\" }\n        }\n        },\n        Alias325C5727: {\n        Type: \"AWS::Lambda::Alias\",\n        Properties: {\n          FunctionName: { Ref: \"MyLambdaCCE802FB\" },\n          FunctionVersion: stack.node.resolve(version.functionVersion),\n          Name: \"prod\"\n        }\n        }\n    }));\n\n    test.done();\n  },\n\n  'can use newVersion to create a new Version'(test: Test) {\n    const stack = new Stack();\n    const fn = new lambda.Function(stack, 'MyLambda', {\n      code: new lambda.InlineCode('hello()'),\n      handler: 'index.hello',\n      runtime: lambda.Runtime.NodeJS610,\n    });\n\n    const version = fn.newVersion();\n\n    new lambda.Alias(stack, 'Alias', {\n      aliasName: 'prod',\n      version,\n    });\n\n    expect(stack).to(haveResourceLike('AWS::Lambda::Version', {\n      FunctionName: { Ref: \"MyLambdaCCE802FB\" },\n    }));\n\n    expect(stack).to(haveResourceLike('AWS::Lambda::Alias', {\n      FunctionName: { Ref: \"MyLambdaCCE802FB\" },\n      Name: \"prod\"\n    }));\n\n    test.done();\n  },\n\n  'can add additional versions to alias'(test: Test) {\n    const stack = new Stack();\n\n    const fn = new lambda.Function(stack, 'MyLambda', {\n      code: new lambda.InlineCode('hello()'),\n      handler: 'index.hello',\n      runtime: lambda.Runtime.NodeJS610,\n    });\n\n    const version1 = fn.addVersion('1');\n    const version2 = fn.addVersion('2');\n\n    new lambda.Alias(stack, 'Alias', {\n      aliasName: 'prod',\n      version: version1,\n      additionalVersions: [{ version: version2, weight: 0.1 }]\n    });\n\n    expect(stack).to(haveResource('AWS::Lambda::Alias', {\n      FunctionVersion: stack.node.resolve(version1.functionVersion),\n      RoutingConfig: {\n        AdditionalVersionWeights: [\n          {\n          FunctionVersion: stack.node.resolve(version2.functionVersion),\n          FunctionWeight: 0.1\n          }\n        ]\n        }\n    }));\n\n    test.done();\n  },\n\n  'sanity checks on version weights'(test: Test) {\n    const stack = new Stack();\n\n    const fn = new lambda.Function(stack, 'MyLambda', {\n      code: new lambda.InlineCode('hello()'),\n      handler: 'index.hello',\n      runtime: lambda.Runtime.NodeJS610,\n    });\n\n    const version = fn.addVersion('1');\n\n    // WHEN: Individual weight too high\n    test.throws(() => {\n      new lambda.Alias(stack, 'Alias1', {\n        aliasName: 'prod', version,\n        additionalVersions: [{ version, weight: 5 }]\n      });\n    });\n\n    // WHEN: Sum too high\n    test.throws(() => {\n      new lambda.Alias(stack, 'Alias2', {\n        aliasName: 'prod', version,\n        additionalVersions: [{ version, weight: 0.5 }, { version, weight: 0.6 }]\n      });\n    });\n\n    test.done();\n  },\n\n  'metric adds Resource: aliasArn to dimensions'(test: Test) {\n    const stack = new Stack();\n\n    // GIVEN\n    const fn = new lambda.Function(stack, 'MyLambda', {\n      code: new lambda.InlineCode('hello()'),\n      handler: 'index.hello',\n      runtime: lambda.Runtime.NodeJS610,\n    });\n\n    const version = fn.addVersion('1');\n    const alias = new lambda.Alias(stack, 'Alias', { aliasName: 'prod', version });\n\n    // WHEN\n    new cloudwatch.Alarm(stack, 'Alarm', {\n      metric: alias.metric('Test'),\n      alarmName: 'Test',\n      threshold: 1,\n      evaluationPeriods: 1\n    });\n\n    // THEN\n    expect(stack).to(haveResource('AWS::CloudWatch::Alarm', {\n      Dimensions: [{\n        Name: \"FunctionName\",\n        Value: {\n          Ref: \"MyLambdaCCE802FB\"\n        }\n      }, {\n        Name: \"Resource\",\n        Value: {\n          Ref: \"Alias325C5727\"\n        }\n      }]\n    }));\n\n    test.done();\n  },\n\n  'alias exposes real Lambdas role'(test: Test) {\n    const stack = new Stack();\n\n    // GIVEN\n    const fn = new lambda.Function(stack, 'MyLambda', {\n      code: new lambda.InlineCode('hello()'),\n      handler: 'index.hello',\n      runtime: lambda.Runtime.NodeJS610,\n    });\n\n    const version = fn.addVersion('1');\n    const alias = new lambda.Alias(stack, 'Alias', { aliasName: 'prod', version });\n\n    // THEN\n    test.equals(alias.role, fn.role);\n\n    test.done();\n  },\n\n  'functionName is derived from the aliasArn so that dependencies are sound'(test: Test) {\n    const stack = new Stack();\n\n    // GIVEN\n    const fn = new lambda.Function(stack, 'MyLambda', {\n      code: new lambda.InlineCode('hello()'),\n      handler: 'index.hello',\n      runtime: lambda.Runtime.NodeJS610,\n    });\n\n    const version = fn.addVersion('1');\n    const alias = new lambda.Alias(stack, 'Alias', { aliasName: 'prod', version });\n\n    // WHEN\n    test.deepEqual(stack.node.resolve(alias.functionName), {\n      \"Fn::Join\": [\n        \"\",\n        [\n          {\n            \"Fn::Select\": [\n              6,\n              {\n                \"Fn::Split\": [\n                  \":\",\n                  {\n                    Ref: \"Alias325C5727\"\n                  }\n                ]\n              }\n            ]\n          },\n          \":prod\"\n        ]\n      ]\n    });\n\n    test.done();\n  }\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.alias.js","sourceRoot":"","sources":["test.alias.ts"],"names":[],"mappings":"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","sourcesContent":["import { beASupersetOfTemplate, expect, haveResource, haveResourceLike } from '@aws-cdk/assert';\nimport cloudwatch = require('@aws-cdk/aws-cloudwatch');\nimport { Stack } from '@aws-cdk/cdk';\nimport { Test } from 'nodeunit';\nimport lambda = require('../lib');\n\nexport = {\n  'version and aliases'(test: Test): void {\n    const stack = new Stack();\n    const fn = new lambda.Function(stack, 'MyLambda', {\n      code: new lambda.InlineCode('hello()'),\n      handler: 'index.hello',\n      runtime: lambda.Runtime.NodeJS610,\n    });\n\n    const version = fn.addVersion('1');\n\n    new lambda.Alias(stack, 'Alias', {\n      aliasName: 'prod',\n      version,\n    });\n\n    expect(stack).to(beASupersetOfTemplate({\n      MyLambdaVersion16CDE3C40: {\n        Type: \"AWS::Lambda::Version\",\n        Properties: {\n          FunctionName: { Ref: \"MyLambdaCCE802FB\" }\n        }\n        },\n        Alias325C5727: {\n        Type: \"AWS::Lambda::Alias\",\n        Properties: {\n          FunctionName: { Ref: \"MyLambdaCCE802FB\" },\n          FunctionVersion: stack.node.resolve(version.functionVersion),\n          Name: \"prod\"\n        }\n        }\n    }));\n\n    test.done();\n  },\n\n  'can use newVersion to create a new Version'(test: Test) {\n    const stack = new Stack();\n    const fn = new lambda.Function(stack, 'MyLambda', {\n      code: new lambda.InlineCode('hello()'),\n      handler: 'index.hello',\n      runtime: lambda.Runtime.NodeJS610,\n    });\n\n    const version = fn.newVersion();\n\n    new lambda.Alias(stack, 'Alias', {\n      aliasName: 'prod',\n      version,\n    });\n\n    expect(stack).to(haveResourceLike('AWS::Lambda::Version', {\n      FunctionName: { Ref: \"MyLambdaCCE802FB\" },\n    }));\n\n    expect(stack).to(haveResourceLike('AWS::Lambda::Alias', {\n      FunctionName: { Ref: \"MyLambdaCCE802FB\" },\n      Name: \"prod\"\n    }));\n\n    test.done();\n  },\n\n  'can add additional versions to alias'(test: Test) {\n    const stack = new Stack();\n\n    const fn = new lambda.Function(stack, 'MyLambda', {\n      code: new lambda.InlineCode('hello()'),\n      handler: 'index.hello',\n      runtime: lambda.Runtime.NodeJS610,\n    });\n\n    const version1 = fn.addVersion('1');\n    const version2 = fn.addVersion('2');\n\n    new lambda.Alias(stack, 'Alias', {\n      aliasName: 'prod',\n      version: version1,\n      additionalVersions: [{ version: version2, weight: 0.1 }]\n    });\n\n    expect(stack).to(haveResource('AWS::Lambda::Alias', {\n      FunctionVersion: stack.node.resolve(version1.functionVersion),\n      RoutingConfig: {\n        AdditionalVersionWeights: [\n          {\n          FunctionVersion: stack.node.resolve(version2.functionVersion),\n          FunctionWeight: 0.1\n          }\n        ]\n        }\n    }));\n\n    test.done();\n  },\n\n  'sanity checks on version weights'(test: Test) {\n    const stack = new Stack();\n\n    const fn = new lambda.Function(stack, 'MyLambda', {\n      code: new lambda.InlineCode('hello()'),\n      handler: 'index.hello',\n      runtime: lambda.Runtime.NodeJS610,\n    });\n\n    const version = fn.addVersion('1');\n\n    // WHEN: Individual weight too high\n    test.throws(() => {\n      new lambda.Alias(stack, 'Alias1', {\n        aliasName: 'prod', version,\n        additionalVersions: [{ version, weight: 5 }]\n      });\n    });\n\n    // WHEN: Sum too high\n    test.throws(() => {\n      new lambda.Alias(stack, 'Alias2', {\n        aliasName: 'prod', version,\n        additionalVersions: [{ version, weight: 0.5 }, { version, weight: 0.6 }]\n      });\n    });\n\n    test.done();\n  },\n\n  'metric adds Resource: aliasArn to dimensions'(test: Test) {\n    const stack = new Stack();\n\n    // GIVEN\n    const fn = new lambda.Function(stack, 'MyLambda', {\n      code: new lambda.InlineCode('hello()'),\n      handler: 'index.hello',\n      runtime: lambda.Runtime.NodeJS610,\n    });\n\n    const version = fn.addVersion('1');\n    const alias = new lambda.Alias(stack, 'Alias', { aliasName: 'prod', version });\n\n    // WHEN\n    new cloudwatch.Alarm(stack, 'Alarm', {\n      metric: alias.metric('Test'),\n      alarmName: 'Test',\n      threshold: 1,\n      evaluationPeriods: 1\n    });\n\n    // THEN\n    expect(stack).to(haveResource('AWS::CloudWatch::Alarm', {\n      Dimensions: [{\n        Name: \"FunctionName\",\n        Value: {\n          Ref: \"MyLambdaCCE802FB\"\n        }\n      }, {\n        Name: \"Resource\",\n        Value: {\n          'Fn::Join': [\n            '',\n            [\n              {\n                \"Fn::GetAtt\": [\n                  \"MyLambdaCCE802FB\",\n                  \"Arn\"\n                ]\n              },\n              ':prod'\n            ]\n          ]\n        }\n      }]\n    }));\n\n    test.done();\n  },\n\n  'alias exposes real Lambdas role'(test: Test) {\n    const stack = new Stack();\n\n    // GIVEN\n    const fn = new lambda.Function(stack, 'MyLambda', {\n      code: new lambda.InlineCode('hello()'),\n      handler: 'index.hello',\n      runtime: lambda.Runtime.NodeJS610,\n    });\n\n    const version = fn.addVersion('1');\n    const alias = new lambda.Alias(stack, 'Alias', { aliasName: 'prod', version });\n\n    // THEN\n    test.equals(alias.role, fn.role);\n\n    test.done();\n  },\n\n  'functionName is derived from the aliasArn so that dependencies are sound'(test: Test) {\n    const stack = new Stack();\n\n    // GIVEN\n    const fn = new lambda.Function(stack, 'MyLambda', {\n      code: new lambda.InlineCode('hello()'),\n      handler: 'index.hello',\n      runtime: lambda.Runtime.NodeJS610,\n    });\n\n    const version = fn.addVersion('1');\n    const alias = new lambda.Alias(stack, 'Alias', { aliasName: 'prod', version });\n\n    // WHEN\n    test.deepEqual(stack.node.resolve(alias.functionName), {\n      \"Fn::Join\": [\n        \"\",\n        [\n          {\n            \"Fn::Select\": [\n              6,\n              {\n                \"Fn::Split\": [\n                  \":\",\n                  {\n                    Ref: \"Alias325C5727\"\n                  }\n                ]\n              }\n            ]\n          },\n          \":prod\"\n        ]\n      ]\n    });\n\n    test.done();\n  }\n};\n"]}

test/test.code.d.ts

@@ -13,3 +13,9 @@ import { Test } from 'nodeunit';
     };
+    'lambda.Code.cfnParameters': {
+        "automatically creates the Bucket and Key parameters when it's used in a Function"(test: Test): void;
+        'does not allow accessing the Parameter properties before being used in a Function'(test: Test): void;
+        'allows passing custom Parameters when creating it'(test: Test): void;
+        'can assign parameters'(test: Test): void;
+    };
 };
 export = _default;

test/test.code.js

@@ -94,4 +94,90 @@ "use strict";
         }
-    }
+    },
+    'lambda.Code.cfnParameters': {
+        "automatically creates the Bucket and Key parameters when it's used in a Function"(test) {
+            const stack = new cdk.Stack();
+            const code = new lambda.CfnParametersCode();
+            new lambda.Function(stack, 'Function', {
+                code,
+                runtime: lambda.Runtime.NodeJS810,
+                handler: 'index.handler',
+            });
+            assert_1.expect(stack).to(assert_1.haveResourceLike('AWS::Lambda::Function', {
+                Code: {
+                    S3Bucket: {
+                        Ref: "FunctionLambdaSourceBucketNameParameter9E9E108F",
+                    },
+                    S3Key: {
+                        Ref: "FunctionLambdaSourceObjectKeyParameter1C7AED11",
+                    },
+                },
+            }));
+            test.equal(stack.node.resolve(code.bucketNameParam), 'FunctionLambdaSourceBucketNameParameter9E9E108F');
+            test.equal(stack.node.resolve(code.objectKeyParam), 'FunctionLambdaSourceObjectKeyParameter1C7AED11');
+            test.done();
+        },
+        'does not allow accessing the Parameter properties before being used in a Function'(test) {
+            const code = new lambda.CfnParametersCode();
+            test.throws(() => {
+                test.notEqual(code.bucketNameParam, undefined);
+            }, /bucketNameParam/);
+            test.throws(() => {
+                test.notEqual(code.objectKeyParam, undefined);
+            }, /objectKeyParam/);
+            test.done();
+        },
+        'allows passing custom Parameters when creating it'(test) {
+            const stack = new cdk.Stack();
+            const bucketNameParam = new cdk.CfnParameter(stack, 'BucketNameParam', {
+                type: 'String',
+            });
+            const bucketKeyParam = new cdk.CfnParameter(stack, 'ObjectKeyParam', {
+                type: 'String',
+            });
+            const code = lambda.Code.cfnParameters({
+                bucketNameParam,
+                objectKeyParam: bucketKeyParam,
+            });
+            test.equal(stack.node.resolve(code.bucketNameParam), 'BucketNameParam');
+            test.equal(stack.node.resolve(code.objectKeyParam), 'ObjectKeyParam');
+            new lambda.Function(stack, 'Function', {
+                code,
+                runtime: lambda.Runtime.NodeJS810,
+                handler: 'index.handler',
+            });
+            assert_1.expect(stack).to(assert_1.haveResourceLike('AWS::Lambda::Function', {
+                Code: {
+                    S3Bucket: {
+                        Ref: "BucketNameParam",
+                    },
+                    S3Key: {
+                        Ref: "ObjectKeyParam",
+                    },
+                },
+            }));
+            test.done();
+        },
+        'can assign parameters'(test) {
+            // given
+            const stack = new cdk.Stack();
+            const code = new lambda.CfnParametersCode({
+                bucketNameParam: new cdk.CfnParameter(stack, 'BucketNameParam', {
+                    type: 'String',
+                }),
+                objectKeyParam: new cdk.CfnParameter(stack, 'ObjectKeyParam', {
+                    type: 'String',
+                }),
+            });
+            // when
+            const overrides = stack.node.resolve(code.assign({
+                bucketName: 'SomeBucketName',
+                objectKey: 'SomeObjectKey',
+            }));
+            // then
+            test.equal(overrides['BucketNameParam'], 'SomeBucketName');
+            test.equal(overrides['ObjectKeyParam'], 'SomeObjectKey');
+            test.done();
+        },
+    },
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.code.js","sourceRoot":"","sources":["test.code.ts"],"names":[],"mappings":"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","sourcesContent":["import { expect, haveResource, ResourcePart } from '@aws-cdk/assert';\nimport assets = require('@aws-cdk/assets');\nimport cdk = require('@aws-cdk/cdk');\nimport cxapi = require('@aws-cdk/cx-api');\nimport { Test } from 'nodeunit';\nimport path = require('path');\nimport lambda = require('../lib');\n\nexport = {\n  'lambda.Code.inline': {\n    'fails if used with unsupported runtimes'(test: Test) {\n      test.throws(() => defineFunction(lambda.Code.inline('boom'), lambda.Runtime.Go1x), /Inline source not allowed for go1\\.x/);\n      test.throws(() => defineFunction(lambda.Code.inline('boom'), lambda.Runtime.Java8), /Inline source not allowed for java8/);\n      test.done();\n    },\n    'fails if larger than 4096 bytes'(test: Test) {\n      test.throws(\n        () => defineFunction(lambda.Code.inline(generateRandomString(4097)), lambda.Runtime.NodeJS610),\n        /Lambda source is too large, must be <= 4096 but is 4097/);\n      test.done();\n    }\n  },\n  'lambda.Code.asset': {\n    'determines packaging type from file type'(test: Test) {\n      // WHEN\n      const fileAsset = lambda.Code.asset(path.join(__dirname, 'handler.zip'));\n      const directoryAsset = lambda.Code.asset(path.join(__dirname, 'my-lambda-handler'));\n\n      // THEN\n      test.deepEqual(fileAsset.packaging, assets.AssetPackaging.File);\n      test.deepEqual(directoryAsset.packaging, assets.AssetPackaging.ZipDirectory);\n      test.done();\n    },\n\n    'fails if a non-zip asset is used'(test: Test) {\n      // GIVEN\n      const fileAsset = lambda.Code.asset(path.join(__dirname, 'my-lambda-handler', 'index.py'));\n\n      // THEN\n      test.throws(() => defineFunction(fileAsset), /Asset must be a \\.zip file or a directory/);\n      test.done();\n    },\n\n    'only one Asset object gets created even if multiple functions use the same AssetCode'(test: Test) {\n      // GIVEN\n      const app = new cdk.App();\n      const stack = new cdk.Stack(app, 'MyStack');\n      const directoryAsset = lambda.Code.asset(path.join(__dirname, 'my-lambda-handler'));\n\n      // WHEN\n      new lambda.Function(stack, 'Func1', {\n        handler: 'foom',\n        runtime: lambda.Runtime.NodeJS810,\n        code: directoryAsset\n      });\n\n      new lambda.Function(stack, 'Func2', {\n        handler: 'foom',\n        runtime: lambda.Runtime.NodeJS810,\n        code: directoryAsset\n      });\n\n      // THEN\n      const synthesized = app.synthesizeStack('MyStack');\n\n      // Func1 has an asset, Func2 does not\n      test.deepEqual(synthesized.metadata['/MyStack/Func1/Code'][0].type, 'aws:cdk:asset');\n      test.deepEqual(synthesized.metadata['/MyStack/Func2/Code'], undefined);\n\n      test.done();\n    },\n\n    'adds code asset metadata'(test: Test) {\n      // GIVEN\n      const stack = new cdk.Stack();\n      stack.node.setContext(cxapi.ASSET_RESOURCE_METADATA_ENABLED_CONTEXT, true);\n\n      const location = path.join(__dirname, 'my-lambda-handler');\n\n      // WHEN\n      new lambda.Function(stack, 'Func1', {\n        code: lambda.Code.asset(location),\n        runtime: lambda.Runtime.NodeJS810,\n        handler: 'foom',\n      });\n\n      // THEN\n      expect(stack).to(haveResource('AWS::Lambda::Function', {\n        Metadata: {\n          [cxapi.ASSET_RESOURCE_METADATA_PATH_KEY]: location,\n          [cxapi.ASSET_RESOURCE_METADATA_PROPERTY_KEY]: 'Code'\n        }\n      }, ResourcePart.CompleteDefinition));\n      test.done();\n    }\n  }\n};\n\nfunction defineFunction(code: lambda.Code, runtime: lambda.Runtime = lambda.Runtime.NodeJS810) {\n  const stack = new cdk.Stack();\n  return new lambda.Function(stack, 'Func', {\n    handler: 'foom',\n    code, runtime\n  });\n}\n\nfunction generateRandomString(bytes: number) {\n  let s = '';\n  for (let i = 0; i < bytes; ++i) {\n    s += String.fromCharCode(Math.round(Math.random() * 256));\n  }\n  return s;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.code.js","sourceRoot":"","sources":["test.code.ts"],"names":[],"mappings":"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","sourcesContent":["import { expect, haveResource, haveResourceLike, ResourcePart } from '@aws-cdk/assert';\nimport assets = require('@aws-cdk/assets');\nimport cdk = require('@aws-cdk/cdk');\nimport cxapi = require('@aws-cdk/cx-api');\nimport { Test } from 'nodeunit';\nimport path = require('path');\nimport lambda = require('../lib');\n\n// tslint:disable:no-string-literal\n\nexport = {\n  'lambda.Code.inline': {\n    'fails if used with unsupported runtimes'(test: Test) {\n      test.throws(() => defineFunction(lambda.Code.inline('boom'), lambda.Runtime.Go1x), /Inline source not allowed for go1\\.x/);\n      test.throws(() => defineFunction(lambda.Code.inline('boom'), lambda.Runtime.Java8), /Inline source not allowed for java8/);\n      test.done();\n    },\n    'fails if larger than 4096 bytes'(test: Test) {\n      test.throws(\n        () => defineFunction(lambda.Code.inline(generateRandomString(4097)), lambda.Runtime.NodeJS610),\n        /Lambda source is too large, must be <= 4096 but is 4097/);\n      test.done();\n    }\n  },\n  'lambda.Code.asset': {\n    'determines packaging type from file type'(test: Test) {\n      // WHEN\n      const fileAsset = lambda.Code.asset(path.join(__dirname, 'handler.zip'));\n      const directoryAsset = lambda.Code.asset(path.join(__dirname, 'my-lambda-handler'));\n\n      // THEN\n      test.deepEqual(fileAsset.packaging, assets.AssetPackaging.File);\n      test.deepEqual(directoryAsset.packaging, assets.AssetPackaging.ZipDirectory);\n      test.done();\n    },\n\n    'fails if a non-zip asset is used'(test: Test) {\n      // GIVEN\n      const fileAsset = lambda.Code.asset(path.join(__dirname, 'my-lambda-handler', 'index.py'));\n\n      // THEN\n      test.throws(() => defineFunction(fileAsset), /Asset must be a \\.zip file or a directory/);\n      test.done();\n    },\n\n    'only one Asset object gets created even if multiple functions use the same AssetCode'(test: Test) {\n      // GIVEN\n      const app = new cdk.App();\n      const stack = new cdk.Stack(app, 'MyStack');\n      const directoryAsset = lambda.Code.asset(path.join(__dirname, 'my-lambda-handler'));\n\n      // WHEN\n      new lambda.Function(stack, 'Func1', {\n        handler: 'foom',\n        runtime: lambda.Runtime.NodeJS810,\n        code: directoryAsset\n      });\n\n      new lambda.Function(stack, 'Func2', {\n        handler: 'foom',\n        runtime: lambda.Runtime.NodeJS810,\n        code: directoryAsset\n      });\n\n      // THEN\n      const synthesized = app.synthesizeStack('MyStack');\n\n      // Func1 has an asset, Func2 does not\n      test.deepEqual(synthesized.metadata['/MyStack/Func1/Code'][0].type, 'aws:cdk:asset');\n      test.deepEqual(synthesized.metadata['/MyStack/Func2/Code'], undefined);\n\n      test.done();\n    },\n\n    'adds code asset metadata'(test: Test) {\n      // GIVEN\n      const stack = new cdk.Stack();\n      stack.node.setContext(cxapi.ASSET_RESOURCE_METADATA_ENABLED_CONTEXT, true);\n\n      const location = path.join(__dirname, 'my-lambda-handler');\n\n      // WHEN\n      new lambda.Function(stack, 'Func1', {\n        code: lambda.Code.asset(location),\n        runtime: lambda.Runtime.NodeJS810,\n        handler: 'foom',\n      });\n\n      // THEN\n      expect(stack).to(haveResource('AWS::Lambda::Function', {\n        Metadata: {\n          [cxapi.ASSET_RESOURCE_METADATA_PATH_KEY]: location,\n          [cxapi.ASSET_RESOURCE_METADATA_PROPERTY_KEY]: 'Code'\n        }\n      }, ResourcePart.CompleteDefinition));\n      test.done();\n    }\n  },\n\n  'lambda.Code.cfnParameters': {\n    \"automatically creates the Bucket and Key parameters when it's used in a Function\"(test: Test) {\n      const stack = new cdk.Stack();\n      const code = new lambda.CfnParametersCode();\n      new lambda.Function(stack, 'Function', {\n        code,\n        runtime: lambda.Runtime.NodeJS810,\n        handler: 'index.handler',\n      });\n\n      expect(stack).to(haveResourceLike('AWS::Lambda::Function', {\n        Code: {\n          S3Bucket: {\n            Ref: \"FunctionLambdaSourceBucketNameParameter9E9E108F\",\n          },\n          S3Key: {\n            Ref: \"FunctionLambdaSourceObjectKeyParameter1C7AED11\",\n          },\n        },\n      }));\n\n      test.equal(stack.node.resolve(code.bucketNameParam), 'FunctionLambdaSourceBucketNameParameter9E9E108F');\n      test.equal(stack.node.resolve(code.objectKeyParam), 'FunctionLambdaSourceObjectKeyParameter1C7AED11');\n\n      test.done();\n    },\n\n    'does not allow accessing the Parameter properties before being used in a Function'(test: Test) {\n      const code = new lambda.CfnParametersCode();\n\n      test.throws(() => {\n        test.notEqual(code.bucketNameParam, undefined);\n      }, /bucketNameParam/);\n\n      test.throws(() => {\n        test.notEqual(code.objectKeyParam, undefined);\n      }, /objectKeyParam/);\n\n      test.done();\n    },\n\n    'allows passing custom Parameters when creating it'(test: Test) {\n      const stack = new cdk.Stack();\n      const bucketNameParam = new cdk.CfnParameter(stack, 'BucketNameParam', {\n        type: 'String',\n      });\n      const bucketKeyParam = new cdk.CfnParameter(stack, 'ObjectKeyParam', {\n        type: 'String',\n      });\n\n      const code = lambda.Code.cfnParameters({\n        bucketNameParam,\n        objectKeyParam: bucketKeyParam,\n      });\n\n      test.equal(stack.node.resolve(code.bucketNameParam), 'BucketNameParam');\n      test.equal(stack.node.resolve(code.objectKeyParam), 'ObjectKeyParam');\n\n      new lambda.Function(stack, 'Function', {\n        code,\n        runtime: lambda.Runtime.NodeJS810,\n        handler: 'index.handler',\n      });\n\n      expect(stack).to(haveResourceLike('AWS::Lambda::Function', {\n        Code: {\n          S3Bucket: {\n            Ref: \"BucketNameParam\",\n          },\n          S3Key: {\n            Ref: \"ObjectKeyParam\",\n          },\n        },\n      }));\n\n      test.done();\n    },\n\n    'can assign parameters'(test: Test) {\n      // given\n      const stack = new cdk.Stack();\n      const code = new lambda.CfnParametersCode({\n        bucketNameParam: new cdk.CfnParameter(stack, 'BucketNameParam', {\n          type: 'String',\n        }),\n        objectKeyParam: new cdk.CfnParameter(stack, 'ObjectKeyParam', {\n          type: 'String',\n        }),\n      });\n\n      // when\n      const overrides = stack.node.resolve(code.assign({\n        bucketName: 'SomeBucketName',\n        objectKey: 'SomeObjectKey',\n      }));\n\n      // then\n      test.equal(overrides['BucketNameParam'], 'SomeBucketName');\n      test.equal(overrides['ObjectKeyParam'], 'SomeObjectKey');\n\n      test.done();\n    },\n  },\n};\n\nfunction defineFunction(code: lambda.Code, runtime: lambda.Runtime = lambda.Runtime.NodeJS810) {\n  const stack = new cdk.Stack();\n  return new lambda.Function(stack, 'Func', {\n    handler: 'foom',\n    code, runtime\n  });\n}\n\nfunction generateRandomString(bytes: number) {\n  let s = '';\n  for (let i = 0; i < bytes; ++i) {\n    s += String.fromCharCode(Math.round(Math.random() * 256));\n  }\n  return s;\n}\n"]}

test/test.lambda.d.ts

@@ -14,3 +14,2 @@ import { Test } from 'nodeunit';
     };
-    'Lambda can serve as EventRule target, permission gets added'(test: Test): void;
     'Lambda code can be read from a local directory via an asset'(test: Test): void;
@@ -17,0 +16,0 @@ 'default function with SQS DLQ when client sets deadLetterQueueEnabled to true and functionName defined by client'(test: Test): void;

test/test.log-retention-provider.d.ts

@@ -9,3 +9,4 @@ import { Test } from 'nodeunit';
     'responds with FAILED on error'(test: Test): Promise<void>;
+    'does not fail when operations on provider log group fail'(test: Test): Promise<void>;
 };
 export = _default;

test/test.log-retention-provider.js

@@ -36,7 +36,11 @@ "use strict";
         AWS.mock('CloudWatchLogs', 'deleteRetentionPolicy', deleteRetentionPolicyFake);
-        const event = Object.assign({}, eventCommon, { RequestType: 'Create', ResourceProperties: {
+        const event = {
+            ...eventCommon,
+            RequestType: 'Create',
+            ResourceProperties: {
                 ServiceToken: 'token',
                 RetentionInDays: '30',
                 LogGroupName: 'group'
-            } });
+            }
+        };
         const request = createRequest('SUCCESS');
@@ -71,11 +75,16 @@ await provider.handler(event, context);
         AWS.mock('CloudWatchLogs', 'deleteRetentionPolicy', deleteRetentionPolicyFake);
-        const event = Object.assign({}, eventCommon, { RequestType: 'Update', ResourceProperties: {
+        const event = {
+            ...eventCommon,
+            RequestType: 'Update',
+            ResourceProperties: {
                 ServiceToken: 'token',
                 RetentionInDays: '365',
                 LogGroupName: 'group'
-            }, OldResourceProperties: {
+            },
+            OldResourceProperties: {
                 ServiceToken: 'token',
                 LogGroupName: 'group',
                 RetentionInDays: '30'
-            } });
+            }
+        };
         const request = createRequest('SUCCESS');
@@ -103,10 +112,16 @@ await provider.handler(event, context);
         AWS.mock('CloudWatchLogs', 'deleteRetentionPolicy', deleteRetentionPolicyFake);
-        const event = Object.assign({}, eventCommon, { RequestType: 'Update', PhysicalResourceId: 'group', ResourceProperties: {
+        const event = {
+            ...eventCommon,
+            RequestType: 'Update',
+            PhysicalResourceId: 'group',
+            ResourceProperties: {
                 ServiceToken: 'token',
                 LogGroupName: 'group'
-            }, OldResourceProperties: {
+            },
+            OldResourceProperties: {
                 ServiceToken: 'token',
                 LogGroupName: 'group',
                 RetentionInDays: '365'
-            } });
+            }
+        };
         const request = createRequest('SUCCESS');
@@ -130,6 +145,11 @@ await provider.handler(event, context);
         AWS.mock('CloudWatchLogs', 'deleteRetentionPolicy', deleteRetentionPolicyFake);
-        const event = Object.assign({}, eventCommon, { RequestType: 'Delete', PhysicalResourceId: 'group', ResourceProperties: {
+        const event = {
+            ...eventCommon,
+            RequestType: 'Delete',
+            PhysicalResourceId: 'group',
+            ResourceProperties: {
                 ServiceToken: 'token',
                 LogGroupName: 'group'
-            } });
+            }
+        };
         const request = createRequest('SUCCESS');
@@ -146,7 +166,11 @@ await provider.handler(event, context);
         AWS.mock('CloudWatchLogs', 'createLogGroup', createLogGroupFake);
-        const event = Object.assign({}, eventCommon, { RequestType: 'Create', ResourceProperties: {
+        const event = {
+            ...eventCommon,
+            RequestType: 'Create',
+            ResourceProperties: {
                 ServiceToken: 'token',
                 RetentionInDays: '30',
                 LogGroupName: 'group'
-            } });
+            }
+        };
         const request = createRequest('FAILED');
@@ -157,3 +181,29 @@ await provider.handler(event, context);
     },
+    async 'does not fail when operations on provider log group fail'(test) {
+        const createLogGroupFake = (params) => {
+            if (params.logGroupName === '/aws/lambda/provider') {
+                return Promise.reject(new Error('OperationAbortedException'));
+            }
+            return Promise.resolve({});
+        };
+        const putRetentionPolicyFake = sinon.fake.resolves({});
+        const deleteRetentionPolicyFake = sinon.fake.resolves({});
+        AWS.mock('CloudWatchLogs', 'createLogGroup', createLogGroupFake);
+        AWS.mock('CloudWatchLogs', 'putRetentionPolicy', putRetentionPolicyFake);
+        AWS.mock('CloudWatchLogs', 'deleteRetentionPolicy', deleteRetentionPolicyFake);
+        const event = {
+            ...eventCommon,
+            RequestType: 'Create',
+            ResourceProperties: {
+                ServiceToken: 'token',
+                RetentionInDays: '30',
+                LogGroupName: 'group'
+            }
+        };
+        const request = createRequest('SUCCESS');
+        await provider.handler(event, context);
+        test.equal(request.isDone(), true);
+        test.done();
+    }
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.log-retention-provider.js","sourceRoot":"","sources":["test.log-retention-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import AWS = require('aws-sdk-mock');\nimport nock = require('nock');\nimport { Test } from 'nodeunit';\nimport sinon = require('sinon');\nimport provider = require('../lib/log-retention-provider');\n\nconst eventCommon = {\n  ServiceToken: 'token',\n  ResponseURL: 'https://localhost',\n  StackId: 'stackId',\n  RequestId: 'requestId',\n  LogicalResourceId: 'logicalResourceId',\n  PhysicalResourceId: 'group',\n  ResourceType: 'Custom::LogRetention',\n};\n\nconst context = {\n  functionName: 'provider'\n} as AWSLambda.Context;\n\nfunction createRequest(type: string) {\n  return nock('https://localhost')\n    .put('/', (body: AWSLambda.CloudFormationCustomResourceResponse) => body.Status === type && body.PhysicalResourceId === 'group')\n    .reply(200);\n}\n\nexport = {\n  'tearDown'(callback: any) {\n    AWS.restore();\n    nock.cleanAll();\n    callback();\n  },\n\n  async 'create event'(test: Test) {\n    const createLogGroupFake = sinon.fake.resolves({});\n    const putRetentionPolicyFake = sinon.fake.resolves({});\n    const deleteRetentionPolicyFake = sinon.fake.resolves({});\n\n    AWS.mock('CloudWatchLogs', 'createLogGroup', createLogGroupFake);\n    AWS.mock('CloudWatchLogs', 'putRetentionPolicy', putRetentionPolicyFake);\n    AWS.mock('CloudWatchLogs', 'deleteRetentionPolicy', deleteRetentionPolicyFake);\n\n    const event = {\n      ...eventCommon,\n      RequestType: 'Create',\n      ResourceProperties: {\n          ServiceToken: 'token',\n          RetentionInDays: '30',\n          LogGroupName: 'group'\n      }\n    };\n\n    const request = createRequest('SUCCESS');\n\n    await provider.handler(event as AWSLambda.CloudFormationCustomResourceCreateEvent, context);\n\n    sinon.assert.calledWith(createLogGroupFake, {\n      logGroupName: 'group'\n    });\n\n    sinon.assert.calledWith(putRetentionPolicyFake, {\n      logGroupName: 'group',\n      retentionInDays: 30\n    });\n\n    sinon.assert.calledWith(createLogGroupFake, {\n      logGroupName: '/aws/lambda/provider'\n    });\n\n    sinon.assert.calledWith(putRetentionPolicyFake, {\n      logGroupName: '/aws/lambda/provider',\n      retentionInDays: 1\n    });\n\n    sinon.assert.notCalled(deleteRetentionPolicyFake);\n\n    test.equal(request.isDone(), true);\n\n    test.done();\n  },\n\n  async 'update event with new log retention'(test: Test) {\n    const error = new Error() as NodeJS.ErrnoException;\n    error.code = 'ResourceAlreadyExistsException';\n\n    const createLogGroupFake = sinon.fake.rejects(error);\n    const putRetentionPolicyFake = sinon.fake.resolves({});\n    const deleteRetentionPolicyFake = sinon.fake.resolves({});\n\n    AWS.mock('CloudWatchLogs', 'createLogGroup', createLogGroupFake);\n    AWS.mock('CloudWatchLogs', 'putRetentionPolicy', putRetentionPolicyFake);\n    AWS.mock('CloudWatchLogs', 'deleteRetentionPolicy', deleteRetentionPolicyFake);\n\n    const event = {\n      ...eventCommon,\n      RequestType: 'Update',\n      ResourceProperties: {\n          ServiceToken: 'token',\n          RetentionInDays: '365',\n          LogGroupName: 'group'\n      },\n      OldResourceProperties: {\n        ServiceToken: 'token',\n        LogGroupName: 'group',\n        RetentionInDays: '30'\n      }\n    };\n\n    const request = createRequest('SUCCESS');\n\n    await provider.handler(event as AWSLambda.CloudFormationCustomResourceUpdateEvent, context);\n\n    sinon.assert.calledWith(createLogGroupFake, {\n      logGroupName: 'group'\n    });\n\n    sinon.assert.calledWith(putRetentionPolicyFake, {\n      logGroupName: 'group',\n      retentionInDays: 365\n    });\n\n    sinon.assert.notCalled(deleteRetentionPolicyFake);\n\n    test.equal(request.isDone(), true);\n\n    test.done();\n  },\n\n  async 'update event with log retention undefined'(test: Test) {\n    const error = new Error() as NodeJS.ErrnoException;\n    error.code = 'ResourceAlreadyExistsException';\n\n    const createLogGroupFake = sinon.fake.rejects(error);\n    const putRetentionPolicyFake = sinon.fake.resolves({});\n    const deleteRetentionPolicyFake = sinon.fake.resolves({});\n\n    AWS.mock('CloudWatchLogs', 'createLogGroup', createLogGroupFake);\n    AWS.mock('CloudWatchLogs', 'putRetentionPolicy', putRetentionPolicyFake);\n    AWS.mock('CloudWatchLogs', 'deleteRetentionPolicy', deleteRetentionPolicyFake);\n\n    const event = {\n      ...eventCommon,\n      RequestType: 'Update',\n      PhysicalResourceId: 'group',\n      ResourceProperties: {\n          ServiceToken: 'token',\n          LogGroupName: 'group'\n      },\n      OldResourceProperties: {\n        ServiceToken: 'token',\n        LogGroupName: 'group',\n        RetentionInDays: '365'\n      }\n    };\n\n    const request = createRequest('SUCCESS');\n\n    await provider.handler(event as AWSLambda.CloudFormationCustomResourceUpdateEvent, context);\n\n    sinon.assert.calledWith(createLogGroupFake, {\n      logGroupName: 'group'\n    });\n\n    sinon.assert.calledWith(deleteRetentionPolicyFake, {\n      logGroupName: 'group'\n    });\n\n    test.equal(request.isDone(), true);\n\n    test.done();\n  },\n\n  async 'delete event'(test: Test) {\n    const createLogGroupFake = sinon.fake.resolves({});\n    const putRetentionPolicyFake = sinon.fake.resolves({});\n    const deleteRetentionPolicyFake = sinon.fake.resolves({});\n\n    AWS.mock('CloudWatchLogs', 'createLogGroup', createLogGroupFake);\n    AWS.mock('CloudWatchLogs', 'putRetentionPolicy', putRetentionPolicyFake);\n    AWS.mock('CloudWatchLogs', 'deleteRetentionPolicy', deleteRetentionPolicyFake);\n\n    const event = {\n      ...eventCommon,\n      RequestType: 'Delete',\n      PhysicalResourceId: 'group',\n      ResourceProperties: {\n          ServiceToken: 'token',\n          LogGroupName: 'group'\n      }\n    };\n\n    const request = createRequest('SUCCESS');\n\n    await provider.handler(event as AWSLambda.CloudFormationCustomResourceDeleteEvent, context);\n\n    sinon.assert.notCalled(createLogGroupFake);\n\n    sinon.assert.notCalled(putRetentionPolicyFake);\n\n    sinon.assert.notCalled(deleteRetentionPolicyFake);\n\n    test.equal(request.isDone(), true);\n\n    test.done();\n  },\n\n  async 'responds with FAILED on error'(test: Test) {\n    const createLogGroupFake = sinon.fake.rejects(new Error('UnkownError'));\n\n    AWS.mock('CloudWatchLogs', 'createLogGroup', createLogGroupFake);\n\n    const event = {\n      ...eventCommon,\n      RequestType: 'Create',\n      ResourceProperties: {\n          ServiceToken: 'token',\n          RetentionInDays: '30',\n          LogGroupName: 'group'\n      }\n    };\n\n    const request = createRequest('FAILED');\n\n    await provider.handler(event as AWSLambda.CloudFormationCustomResourceCreateEvent, context);\n\n    test.equal(request.isDone(), true);\n\n    test.done();\n  },\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test.log-retention-provider.js","sourceRoot":"","sources":["test.log-retention-provider.ts"],"names":[],"mappings":"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","sourcesContent":["import AWSSDK = require('aws-sdk');\nimport AWS = require('aws-sdk-mock');\nimport nock = require('nock');\nimport { Test } from 'nodeunit';\nimport sinon = require('sinon');\nimport provider = require('../lib/log-retention-provider');\n\nconst eventCommon = {\n  ServiceToken: 'token',\n  ResponseURL: 'https://localhost',\n  StackId: 'stackId',\n  RequestId: 'requestId',\n  LogicalResourceId: 'logicalResourceId',\n  PhysicalResourceId: 'group',\n  ResourceType: 'Custom::LogRetention',\n};\n\nconst context = {\n  functionName: 'provider'\n} as AWSLambda.Context;\n\nfunction createRequest(type: string) {\n  return nock('https://localhost')\n    .put('/', (body: AWSLambda.CloudFormationCustomResourceResponse) => body.Status === type && body.PhysicalResourceId === 'group')\n    .reply(200);\n}\n\nexport = {\n  'tearDown'(callback: any) {\n    AWS.restore();\n    nock.cleanAll();\n    callback();\n  },\n\n  async 'create event'(test: Test) {\n    const createLogGroupFake = sinon.fake.resolves({});\n    const putRetentionPolicyFake = sinon.fake.resolves({});\n    const deleteRetentionPolicyFake = sinon.fake.resolves({});\n\n    AWS.mock('CloudWatchLogs', 'createLogGroup', createLogGroupFake);\n    AWS.mock('CloudWatchLogs', 'putRetentionPolicy', putRetentionPolicyFake);\n    AWS.mock('CloudWatchLogs', 'deleteRetentionPolicy', deleteRetentionPolicyFake);\n\n    const event = {\n      ...eventCommon,\n      RequestType: 'Create',\n      ResourceProperties: {\n          ServiceToken: 'token',\n          RetentionInDays: '30',\n          LogGroupName: 'group'\n      }\n    };\n\n    const request = createRequest('SUCCESS');\n\n    await provider.handler(event as AWSLambda.CloudFormationCustomResourceCreateEvent, context);\n\n    sinon.assert.calledWith(createLogGroupFake, {\n      logGroupName: 'group'\n    });\n\n    sinon.assert.calledWith(putRetentionPolicyFake, {\n      logGroupName: 'group',\n      retentionInDays: 30\n    });\n\n    sinon.assert.calledWith(createLogGroupFake, {\n      logGroupName: '/aws/lambda/provider'\n    });\n\n    sinon.assert.calledWith(putRetentionPolicyFake, {\n      logGroupName: '/aws/lambda/provider',\n      retentionInDays: 1\n    });\n\n    sinon.assert.notCalled(deleteRetentionPolicyFake);\n\n    test.equal(request.isDone(), true);\n\n    test.done();\n  },\n\n  async 'update event with new log retention'(test: Test) {\n    const error = new Error() as NodeJS.ErrnoException;\n    error.code = 'ResourceAlreadyExistsException';\n\n    const createLogGroupFake = sinon.fake.rejects(error);\n    const putRetentionPolicyFake = sinon.fake.resolves({});\n    const deleteRetentionPolicyFake = sinon.fake.resolves({});\n\n    AWS.mock('CloudWatchLogs', 'createLogGroup', createLogGroupFake);\n    AWS.mock('CloudWatchLogs', 'putRetentionPolicy', putRetentionPolicyFake);\n    AWS.mock('CloudWatchLogs', 'deleteRetentionPolicy', deleteRetentionPolicyFake);\n\n    const event = {\n      ...eventCommon,\n      RequestType: 'Update',\n      ResourceProperties: {\n          ServiceToken: 'token',\n          RetentionInDays: '365',\n          LogGroupName: 'group'\n      },\n      OldResourceProperties: {\n        ServiceToken: 'token',\n        LogGroupName: 'group',\n        RetentionInDays: '30'\n      }\n    };\n\n    const request = createRequest('SUCCESS');\n\n    await provider.handler(event as AWSLambda.CloudFormationCustomResourceUpdateEvent, context);\n\n    sinon.assert.calledWith(createLogGroupFake, {\n      logGroupName: 'group'\n    });\n\n    sinon.assert.calledWith(putRetentionPolicyFake, {\n      logGroupName: 'group',\n      retentionInDays: 365\n    });\n\n    sinon.assert.notCalled(deleteRetentionPolicyFake);\n\n    test.equal(request.isDone(), true);\n\n    test.done();\n  },\n\n  async 'update event with log retention undefined'(test: Test) {\n    const error = new Error() as NodeJS.ErrnoException;\n    error.code = 'ResourceAlreadyExistsException';\n\n    const createLogGroupFake = sinon.fake.rejects(error);\n    const putRetentionPolicyFake = sinon.fake.resolves({});\n    const deleteRetentionPolicyFake = sinon.fake.resolves({});\n\n    AWS.mock('CloudWatchLogs', 'createLogGroup', createLogGroupFake);\n    AWS.mock('CloudWatchLogs', 'putRetentionPolicy', putRetentionPolicyFake);\n    AWS.mock('CloudWatchLogs', 'deleteRetentionPolicy', deleteRetentionPolicyFake);\n\n    const event = {\n      ...eventCommon,\n      RequestType: 'Update',\n      PhysicalResourceId: 'group',\n      ResourceProperties: {\n          ServiceToken: 'token',\n          LogGroupName: 'group'\n      },\n      OldResourceProperties: {\n        ServiceToken: 'token',\n        LogGroupName: 'group',\n        RetentionInDays: '365'\n      }\n    };\n\n    const request = createRequest('SUCCESS');\n\n    await provider.handler(event as AWSLambda.CloudFormationCustomResourceUpdateEvent, context);\n\n    sinon.assert.calledWith(createLogGroupFake, {\n      logGroupName: 'group'\n    });\n\n    sinon.assert.calledWith(deleteRetentionPolicyFake, {\n      logGroupName: 'group'\n    });\n\n    test.equal(request.isDone(), true);\n\n    test.done();\n  },\n\n  async 'delete event'(test: Test) {\n    const createLogGroupFake = sinon.fake.resolves({});\n    const putRetentionPolicyFake = sinon.fake.resolves({});\n    const deleteRetentionPolicyFake = sinon.fake.resolves({});\n\n    AWS.mock('CloudWatchLogs', 'createLogGroup', createLogGroupFake);\n    AWS.mock('CloudWatchLogs', 'putRetentionPolicy', putRetentionPolicyFake);\n    AWS.mock('CloudWatchLogs', 'deleteRetentionPolicy', deleteRetentionPolicyFake);\n\n    const event = {\n      ...eventCommon,\n      RequestType: 'Delete',\n      PhysicalResourceId: 'group',\n      ResourceProperties: {\n          ServiceToken: 'token',\n          LogGroupName: 'group'\n      }\n    };\n\n    const request = createRequest('SUCCESS');\n\n    await provider.handler(event as AWSLambda.CloudFormationCustomResourceDeleteEvent, context);\n\n    sinon.assert.notCalled(createLogGroupFake);\n\n    sinon.assert.notCalled(putRetentionPolicyFake);\n\n    sinon.assert.notCalled(deleteRetentionPolicyFake);\n\n    test.equal(request.isDone(), true);\n\n    test.done();\n  },\n\n  async 'responds with FAILED on error'(test: Test) {\n    const createLogGroupFake = sinon.fake.rejects(new Error('UnkownError'));\n\n    AWS.mock('CloudWatchLogs', 'createLogGroup', createLogGroupFake);\n\n    const event = {\n      ...eventCommon,\n      RequestType: 'Create',\n      ResourceProperties: {\n          ServiceToken: 'token',\n          RetentionInDays: '30',\n          LogGroupName: 'group'\n      }\n    };\n\n    const request = createRequest('FAILED');\n\n    await provider.handler(event as AWSLambda.CloudFormationCustomResourceCreateEvent, context);\n\n    test.equal(request.isDone(), true);\n\n    test.done();\n  },\n\n  async 'does not fail when operations on provider log group fail'(test: Test) {\n    const createLogGroupFake = (params: AWSSDK.CloudWatchLogs.CreateLogGroupRequest) => {\n      if (params.logGroupName === '/aws/lambda/provider') {\n        return Promise.reject(new Error('OperationAbortedException'));\n      }\n      return Promise.resolve({});\n    };\n\n    const putRetentionPolicyFake = sinon.fake.resolves({});\n    const deleteRetentionPolicyFake = sinon.fake.resolves({});\n\n    AWS.mock('CloudWatchLogs', 'createLogGroup', createLogGroupFake);\n    AWS.mock('CloudWatchLogs', 'putRetentionPolicy', putRetentionPolicyFake);\n    AWS.mock('CloudWatchLogs', 'deleteRetentionPolicy', deleteRetentionPolicyFake);\n\n    const event = {\n      ...eventCommon,\n      RequestType: 'Create',\n      ResourceProperties: {\n          ServiceToken: 'token',\n          RetentionInDays: '30',\n          LogGroupName: 'group'\n      }\n    };\n\n    const request = createRequest('SUCCESS');\n\n    await provider.handler(event as AWSLambda.CloudFormationCustomResourceCreateEvent, context);\n\n    test.equal(request.isDone(), true);\n\n    test.done();\n  }\n};\n"]}

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Number of lines in readme file

129

increased by8.4%

Worsened metrics

Total package byte prevSize

1014730

decreased by-6.96%

Dependency count

24

increased by4.35%

Number of package files

81

decreased by-4.71%

Dependency changes

• + Added@aws-cdk/assets@0.29.0(transitive)

• + Added@aws-cdk/aws-autoscaling-api@0.29.0(transitive)

• + Added@aws-cdk/aws-cloudwatch@0.29.0(transitive)

• + Added@aws-cdk/aws-ec2@0.29.0(transitive)

• + Added@aws-cdk/aws-events@0.29.0(transitive)

• + Added@aws-cdk/aws-iam@0.29.0(transitive)

• + Added@aws-cdk/aws-kms@0.29.0(transitive)

• + Added@aws-cdk/aws-logs@0.29.0(transitive)

• + Added@aws-cdk/aws-s3@0.29.0(transitive)

• + Added@aws-cdk/aws-s3-notifications@0.29.0(transitive)

• + Added@aws-cdk/aws-sqs@0.29.0(transitive)

• + Added@aws-cdk/aws-stepfunctions@0.29.0(transitive)

• + Added@aws-cdk/cdk@0.29.0(transitive)

• + Added@aws-cdk/cx-api@0.29.0(transitive)

• + Added@aws-cdk/region-info@0.29.0(transitive)

• - Removed@aws-cdk/assets@0.28.0(transitive)

• - Removed@aws-cdk/aws-autoscaling-api@0.28.0(transitive)

• - Removed@aws-cdk/aws-cloudwatch@0.28.0(transitive)

• - Removed@aws-cdk/aws-ec2@0.28.0(transitive)

• - Removed@aws-cdk/aws-events@0.28.0(transitive)

• - Removed@aws-cdk/aws-iam@0.28.0(transitive)

• - Removed@aws-cdk/aws-kms@0.28.0(transitive)

• - Removed@aws-cdk/aws-logs@0.28.0(transitive)

• - Removed@aws-cdk/aws-s3@0.28.0(transitive)

• - Removed@aws-cdk/aws-s3-notifications@0.28.0(transitive)

• - Removed@aws-cdk/aws-sqs@0.28.0(transitive)

• - Removed@aws-cdk/aws-stepfunctions@0.28.0(transitive)

• - Removed@aws-cdk/cdk@0.28.0(transitive)

• - Removed@aws-cdk/cx-api@0.28.0(transitive)

• - Removed@aws-cdk/region-info@0.28.0(transitive)

• Updated@aws-cdk/assets@^0.29.0

• Updated@aws-cdk/aws-cloudwatch@^0.29.0

• Updated@aws-cdk/aws-ec2@^0.29.0

• Updated@aws-cdk/aws-events@^0.29.0

• Updated@aws-cdk/aws-iam@^0.29.0

• Updated@aws-cdk/aws-logs@^0.29.0

• Updated@aws-cdk/aws-s3@^0.29.0

• Updated@aws-cdk/aws-s3-notifications@^0.29.0

• Updated@aws-cdk/aws-sqs@^0.29.0

• Updated@aws-cdk/aws-stepfunctions@^0.29.0

• Updated@aws-cdk/cdk@^0.29.0

• Updated@aws-cdk/cx-api@^0.29.0