@webda/aws 2.0.0-beta.3 → 2.1.0

package/lib/deployers/cloudformation.js

@@ -1,350 +1,302 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CloudFormationDeployer = exports.LAMBDA_LATEST_VERSION = void 0;
-const client_api_gateway_1 = require("@aws-sdk/client-api-gateway");
-const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
-const client_sts_1 = require("@aws-sdk/client-sts");
-const core_1 = require("@webda/core");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const YAML = __importStar(require("yaml"));
-const _1 = require(".");
+import { APIGateway } from "@aws-sdk/client-api-gateway";
+import { CloudFormation } from "@aws-sdk/client-cloudformation";
+import { STS } from "@aws-sdk/client-sts";
+import { JSONUtils, WebdaError } from "@webda/core";
+import * as fs from "fs";
+import * as path from "path";
+import * as YAML from "yaml";
+import { AWSDeployer } from "./index.js";
 const LAMBDA_LATEST_VERSION = "nodejs14.x";
-exports.LAMBDA_LATEST_VERSION = LAMBDA_LATEST_VERSION;
 /**
  * Deploy the application and its resources using AWS CloudFormation
  *
- * @WebdaDeployer
+ * @WebdaDeployer WebdaAWSDeployer/CloudFormation
  */
-class CloudFormationDeployer extends _1.AWSDeployer {
+export default class CloudFormationDeployer extends AWSDeployer {
     constructor(manager, resources) {
         super(manager, resources);
         this.template = {};
         this.result = {};
     }
-    defaultResources() {
-        const _super = Object.create(null, {
-            defaultResources: { get: () => super.defaultResources }
-        });
+    async defaultResources() {
         var _a, _b, _c;
-        var _d, _e, _f;
-        return __awaiter(this, void 0, void 0, function* () {
-            yield _super.defaultResources.call(this);
-            let packageDesc = this.getApplication().getPackageDescription();
-            packageDesc.webda = packageDesc.webda || {};
-            packageDesc.webda.aws = packageDesc.webda.aws || {};
-            if (this.resources.ResourcesToImport) {
-                if (!this.resources.ChangeSetType) {
-                    this.resources.ChangeSetType = "IMPORT";
-                }
-                if (this.resources.ChangeSetType !== "IMPORT") {
-                    throw new Error("ChangeSetType cannot be anything else than IMPORT if you have ResourcesToImport set");
-                }
+        await super.defaultResources();
+        let packageDesc = this.getApplication().getPackageDescription();
+        packageDesc.webda = packageDesc.webda || {};
+        packageDesc.webda.aws = packageDesc.webda.aws || {};
+        if (this.resources.ResourcesToImport) {
+            if (!this.resources.ChangeSetType) {
+                this.resources.ChangeSetType = "IMPORT";
             }
-            this.resources.ChangeSetType = this.resources.ChangeSetType || "CREATE";
-            this.resources.AssetsBucket = this.resources.AssetsBucket || packageDesc.webda.aws.AssetsBucket;
-            if (!this.resources.AssetsBucket) {
-                throw new core_1.WebdaError("ASSETS_BUCKET_REQUIRED", "AssetsBucket must be defined");
-            }
-            this.resources.AssetsPrefix = this.resources.AssetsPrefix || "${deployment}/${deployer.name}/";
-            this.resources.Description = this.resources.Description || "Deployed by @webda/aws/cloudformation";
-            this.resources.FileName = this.resources.FileName || `cloudformation-${this.resources.name}`;
-            this.resources.StackName = this.resources.StackName || this.resources.name;
-            this.resources.Format = this.resources.Format || "JSON";
-            this.resources.OpenAPIFileName = this.resources.OpenAPIFileName || "${resources.name}-openapi-${package.version}";
-            this.resources.OpenAPITitle = this.resources.OpenAPITitle || this.resources.name;
-            // Default Lambda value
-            if (this.resources.Lambda) {
-                let zipPath = "lambda-${package.version}.zip";
-                if (this.resources.LambdaPackager) {
-                    zipPath = this.resources.LambdaPackager.zipPath;
-                }
-                (_a = (_d = this.resources).LambdaPackager) !== null && _a !== void 0 ? _a : (_d.LambdaPackager = { zipPath });
-                this.resources.LambdaPackager.zipPath = zipPath;
-                this.resources.Lambda.Runtime = this.resources.Lambda.Runtime || LAMBDA_LATEST_VERSION;
-                this.resources.Lambda.MemorySize = this.resources.Lambda.MemorySize || 2048;
-                this.resources.Lambda.Timeout = this.resources.Lambda.Timeout || 30;
-                this.resources.Lambda.Handler =
-                    this.resources.Lambda.Handler || "node_modules/@webda/aws/lib/deployers/lambda-entrypoint.handler";
-                this.resources.Lambda.FunctionName = this.resources.Lambda.FunctionName || this.resources.name;
-                if (!this.resources.Lambda.Role) {
-                    this.resources.Lambda.Role = { "Fn::GetAtt": ["Role", "Arn"] };
-                    // If no role is specified auto enable Role and Policy creation
-                    this.resources.Role = this.resources.Role || {};
-                    this.resources.Policy = this.resources.Policy || {};
-                }
+            if (this.resources.ChangeSetType !== "IMPORT") {
+                throw new Error("ChangeSetType cannot be anything else than IMPORT if you have ResourcesToImport set");
+            }
+        }
+        this.resources.ChangeSetType = this.resources.ChangeSetType || "CREATE";
+        this.resources.AssetsBucket = this.resources.AssetsBucket || packageDesc.webda.aws.AssetsBucket;
+        if (!this.resources.AssetsBucket) {
+            throw new WebdaError("ASSETS_BUCKET_REQUIRED", "AssetsBucket must be defined");
+        }
+        this.resources.AssetsPrefix = this.resources.AssetsPrefix || "${deployment}/${deployer.name}/";
+        this.resources.Description = this.resources.Description || "Deployed by @webda/aws/cloudformation";
+        this.resources.FileName = this.resources.FileName || `cloudformation-${this.resources.name}`;
+        this.resources.StackName = this.resources.StackName || this.resources.name;
+        this.resources.Format = this.resources.Format || "JSON";
+        this.resources.OpenAPIFileName = this.resources.OpenAPIFileName || "${resources.name}-openapi-${package.version}";
+        this.resources.OpenAPITitle = this.resources.OpenAPITitle || this.resources.name;
+        // Default Lambda value
+        if (this.resources.Lambda) {
+            let zipPath = "lambda-${package.version}.zip";
+            if (this.resources.LambdaPackager) {
+                zipPath = this.resources.LambdaPackager.zipPath;
+            }
+            (_a = this.resources).LambdaPackager ?? (_a.LambdaPackager = { zipPath });
+            this.resources.LambdaPackager.zipPath = zipPath;
+            this.resources.Lambda.Runtime = this.resources.Lambda.Runtime || LAMBDA_LATEST_VERSION;
+            this.resources.Lambda.MemorySize = this.resources.Lambda.MemorySize || 2048;
+            this.resources.Lambda.Timeout = this.resources.Lambda.Timeout || 30;
+            this.resources.Lambda.Handler =
+                this.resources.Lambda.Handler || "node_modules/@webda/aws/lib/deployers/lambda-entrypoint.handler";
+            this.resources.Lambda.FunctionName = this.resources.Lambda.FunctionName || this.resources.name;
+            if (!this.resources.Lambda.Role) {
+                this.resources.Lambda.Role = { "Fn::GetAtt": ["Role", "Arn"] };
+                // If no role is specified auto enable Role and Policy creation
+                this.resources.Role = this.resources.Role || {};
+                this.resources.Policy = this.resources.Policy || {};
             }
-            // Default Role
+        }
+        // Default Role
+        if (this.resources.Role) {
+            this.resources.Role.RoleName = this.resources.Role.RoleName || `${this.resources.name}Role`;
+            if (!this.resources.Role.Policies || this.resources.Role.Policies.length === 0) {
+                this.resources.Policy = this.resources.Policy || {};
+            }
+            this.resources.Role.AssumeRolePolicyDocument = this.resources.Role.AssumeRolePolicyDocument || {
+                Statement: []
+            };
+            this.resources.Role.AssumeRolePolicyDocument.Statement =
+                this.resources.Role.AssumeRolePolicyDocument.Statement || [];
+            this.resources.Role.AssumeRolePolicyDocument.Version =
+                this.resources.Role.AssumeRolePolicyDocument.Version || "2012-10-17";
+        }
+        // Default Policy
+        if (this.resources.Policy) {
+            this.resources.Policy.PolicyName = this.resources.Policy.PolicyName || `${this.resources.name}Policy`;
+            this.resources.Policy.Roles = this.resources.Policy.Roles || [];
             if (this.resources.Role) {
-                this.resources.Role.RoleName = this.resources.Role.RoleName || `${this.resources.name}Role`;
-                if (!this.resources.Role.Policies || this.resources.Role.Policies.length === 0) {
-                    this.resources.Policy = this.resources.Policy || {};
-                }
-                this.resources.Role.AssumeRolePolicyDocument = this.resources.Role.AssumeRolePolicyDocument || {
-                    Statement: []
-                };
-                this.resources.Role.AssumeRolePolicyDocument.Statement =
-                    this.resources.Role.AssumeRolePolicyDocument.Statement || [];
-                this.resources.Role.AssumeRolePolicyDocument.Version =
-                    this.resources.Role.AssumeRolePolicyDocument.Version || "2012-10-17";
-            }
-            // Default Policy
-            if (this.resources.Policy) {
-                this.resources.Policy.PolicyName = this.resources.Policy.PolicyName || `${this.resources.name}Policy`;
-                this.resources.Policy.Roles = this.resources.Policy.Roles || [];
-                if (this.resources.Role) {
-                    this.resources.Policy.Roles.push({ Ref: "Role" });
-                }
-                this.resources.Policy.PolicyDocument = this.resources.Policy.PolicyDocument || { Statement: [] };
-            }
-            this.resources.Tags = this.transformMapTagsToArray(this.resources.Tags || []);
-            if (this.resources.APIGatewayStage) {
-                this.resources.APIGatewayStage.StageName =
-                    // @ts-ignore
-                    this.resources.APIGatewayStage.StageName || this.getApplication().currentDeployment;
-            }
-            // Activate Domain
-            if (this.resources.APIGatewayDomain) {
-                (_b = (_e = this.resources.APIGatewayDomain).SecurityPolicy) !== null && _b !== void 0 ? _b : (_e.SecurityPolicy = "TLS_1_2");
-            }
-            // Default BasePathMapping
-            if (this.resources.APIGatewayBasePathMapping) {
-                this.resources.APIGatewayBasePathMapping.BasePath = this.resources.APIGatewayBasePathMapping.BasePath || "";
-                (_c = (_f = this.resources.APIGatewayBasePathMapping).DomainName) !== null && _c !== void 0 ? _c : (_f.DomainName = this.resources.APIGatewayDomain.DomainName);
-                if (this.resources.APIGatewayBasePathMapping.DomainName.endsWith(".")) {
-                    this.resources.APIGatewayBasePathMapping.DomainName =
-                        this.resources.APIGatewayBasePathMapping.DomainName.substring(0, this.resources.APIGatewayBasePathMapping.DomainName.length - 1);
-                }
+                this.resources.Policy.Roles.push({ Ref: "Role" });
             }
-            // Activate Domain
-            if (this.resources.APIGatewayV2Domain) {
-                // Enable BasePathMapping if does not exist
-                this.resources.APIGatewayV2ApiMapping = this.resources.APIGatewayV2ApiMapping || {};
-                this.resources.APIGatewayV2Domain.DomainNameConfigurations =
-                    this.resources.APIGatewayV2Domain.DomainNameConfigurations || [];
-            }
-            // Default BasePathMapping
-            if (this.resources.APIGatewayV2ApiMapping) {
-                this.resources.APIGatewayV2ApiMapping.BasePath = this.resources.APIGatewayV2ApiMapping.BasePath || "";
-                this.resources.APIGatewayV2ApiMapping.DomainName =
-                    this.resources.APIGatewayV2ApiMapping.DomainName || this.resources.APIGatewayDomain.DomainName;
-                if (this.resources.APIGatewayV2ApiMapping.DomainName.endsWith(".")) {
-                    this.resources.APIGatewayV2ApiMapping.DomainName = this.resources.APIGatewayV2ApiMapping.DomainName.substring(0, this.resources.APIGatewayV2ApiMapping.DomainName.length - 1);
-                }
+            this.resources.Policy.PolicyDocument = this.resources.Policy.PolicyDocument || { Statement: [] };
+        }
+        this.resources.Tags = this.transformMapTagsToArray(this.resources.Tags || []);
+        if (this.resources.APIGatewayStage) {
+            this.resources.APIGatewayStage.StageName =
+                // @ts-ignore
+                this.resources.APIGatewayStage.StageName || this.getApplication().currentDeployment;
+        }
+        // Activate Domain
+        if (this.resources.APIGatewayDomain) {
+            (_b = this.resources.APIGatewayDomain).SecurityPolicy ?? (_b.SecurityPolicy = "TLS_1_2");
+        }
+        // Default BasePathMapping
+        if (this.resources.APIGatewayBasePathMapping) {
+            this.resources.APIGatewayBasePathMapping.BasePath = this.resources.APIGatewayBasePathMapping.BasePath || "";
+            (_c = this.resources.APIGatewayBasePathMapping).DomainName ?? (_c.DomainName = this.resources.APIGatewayDomain.DomainName);
+            if (this.resources.APIGatewayBasePathMapping.DomainName.endsWith(".")) {
+                this.resources.APIGatewayBasePathMapping.DomainName =
+                    this.resources.APIGatewayBasePathMapping.DomainName.substring(0, this.resources.APIGatewayBasePathMapping.DomainName.length - 1);
             }
-            this.resources.Statics = (this.resources.Statics || []);
-            this.resources.Statics.forEach(conf => {
-                // Should move to init
-                if (!conf.AssetsPath) {
-                    conf.AssetsPath = conf.Source;
-                    if (conf.AssetsPath.startsWith("/")) {
-                        conf.AssetsPath = conf.AssetsPath.substring(1);
-                    }
-                    if (!conf.AssetsPath.endsWith("/")) {
-                        conf.AssetsPath += "/";
-                    }
-                }
-                if (conf.CloudFront) {
-                    let DistributionConfig = conf.CloudFront.DistributionConfig || {};
-                    DistributionConfig.Aliases = DistributionConfig.Aliases || [];
-                    if (DistributionConfig.Aliases.indexOf(conf.DomainName) < 0) {
-                        DistributionConfig.Aliases.push(conf.DomainName);
-                    }
-                    DistributionConfig.PriceClass = DistributionConfig.PriceClass || "PriceClass_100";
-                    DistributionConfig.Comment = DistributionConfig.Comment || "Deployed with @webda/aws/cloudformation";
-                    if (DistributionConfig.Enabled === undefined) {
-                        DistributionConfig.Enabled = true;
-                    }
-                    if (!DistributionConfig.DefaultCacheBehavior) {
-                        DistributionConfig.DefaultCacheBehavior = {
-                            AllowedMethods: ["GET", "HEAD"],
-                            ViewerProtocolPolicy: "redirect-to-https",
-                            TargetOriginId: conf.DomainName,
-                            ForwardedValues: {
-                                QueryString: false
-                            }
-                        };
-                    }
-                    if (!DistributionConfig.Origins) {
-                        DistributionConfig.Origins = [
-                            {
-                                DomainName: `${this.resources.AssetsBucket}.s3.amazonaws.com`,
-                                Id: conf.DomainName,
-                                OriginPath: `/${conf.AssetsPath.substring(0, conf.AssetsPath.length - 1)}`,
-                                S3OriginConfig: {}
-                            }
-                        ];
-                    }
-                    conf.CloudFront.DistributionConfig = DistributionConfig;
+        }
+        // Activate Domain
+        if (this.resources.APIGatewayV2Domain) {
+            // Enable BasePathMapping if does not exist
+            this.resources.APIGatewayV2ApiMapping = this.resources.APIGatewayV2ApiMapping || {};
+            this.resources.APIGatewayV2Domain.DomainNameConfigurations =
+                this.resources.APIGatewayV2Domain.DomainNameConfigurations || [];
+        }
+        // Default BasePathMapping
+        if (this.resources.APIGatewayV2ApiMapping) {
+            this.resources.APIGatewayV2ApiMapping.BasePath = this.resources.APIGatewayV2ApiMapping.BasePath || "";
+            this.resources.APIGatewayV2ApiMapping.DomainName =
+                this.resources.APIGatewayV2ApiMapping.DomainName || this.resources.APIGatewayDomain.DomainName;
+            if (this.resources.APIGatewayV2ApiMapping.DomainName.endsWith(".")) {
+                this.resources.APIGatewayV2ApiMapping.DomainName = this.resources.APIGatewayV2ApiMapping.DomainName.substring(0, this.resources.APIGatewayV2ApiMapping.DomainName.length - 1);
+            }
+        }
+        this.resources.Statics = (this.resources.Statics || []);
+        this.resources.Statics.forEach(conf => {
+            // Should move to init
+            if (!conf.AssetsPath) {
+                conf.AssetsPath = conf.Source;
+                if (conf.AssetsPath.startsWith("/")) {
+                    conf.AssetsPath = conf.AssetsPath.substring(1);
+                }
+                if (!conf.AssetsPath.endsWith("/")) {
+                    conf.AssetsPath += "/";
+                }
+            }
+            if (conf.CloudFront) {
+                let DistributionConfig = conf.CloudFront.DistributionConfig || {};
+                DistributionConfig.Aliases = DistributionConfig.Aliases || [];
+                if (DistributionConfig.Aliases.indexOf(conf.DomainName) < 0) {
+                    DistributionConfig.Aliases.push(conf.DomainName);
+                }
+                DistributionConfig.PriceClass = DistributionConfig.PriceClass || "PriceClass_100";
+                DistributionConfig.Comment = DistributionConfig.Comment || "Deployed with @webda/aws/cloudformation";
+                if (DistributionConfig.Enabled === undefined) {
+                    DistributionConfig.Enabled = true;
+                }
+                if (!DistributionConfig.DefaultCacheBehavior) {
+                    DistributionConfig.DefaultCacheBehavior = {
+                        AllowedMethods: ["GET", "HEAD"],
+                        ViewerProtocolPolicy: "redirect-to-https",
+                        TargetOriginId: conf.DomainName,
+                        ForwardedValues: {
+                            QueryString: false
+                        }
+                    };
                 }
-            });
-            // Manage Docker build
-            if (this.resources.Docker) {
-                this.resources.Docker.push = this.resources.Docker.push === undefined ? true : this.resources.Docker.push;
-                this.resources.Docker.includeRepository =
-                    this.resources.Docker.includeRepository === undefined ? true : this.resources.Docker.includeRepository;
-                if (this.resources.Docker.includeRepository && this.resources.Docker.tag) {
-                    let accountId = (yield this.getAWSIdentity()).Account;
-                    this.resources.Docker.tag =
-                        accountId + ".dkr.ecr.eu-west-1.amazonaws.com/${package.webda.aws.Repository}:" + this.resources.Docker.tag;
+                if (!DistributionConfig.Origins) {
+                    DistributionConfig.Origins = [
+                        {
+                            DomainName: `${this.resources.AssetsBucket}.s3.amazonaws.com`,
+                            Id: conf.DomainName,
+                            OriginPath: `/${conf.AssetsPath.substring(0, conf.AssetsPath.length - 1)}`,
+                            S3OriginConfig: {}
+                        }
+                    ];
                 }
+                conf.CloudFront.DistributionConfig = DistributionConfig;
             }
         });
+        // Manage Docker build
+        if (this.resources.Docker) {
+            this.resources.Docker.push = this.resources.Docker.push === undefined ? true : this.resources.Docker.push;
+            this.resources.Docker.includeRepository =
+                this.resources.Docker.includeRepository === undefined ? true : this.resources.Docker.includeRepository;
+            if (this.resources.Docker.includeRepository && this.resources.Docker.tag) {
+                let accountId = (await this.getAWSIdentity()).Account;
+                this.resources.Docker.tag =
+                    accountId + ".dkr.ecr.eu-west-1.amazonaws.com/${package.webda.aws.Repository}:" + this.resources.Docker.tag;
+            }
+        }
     }
-    deploy() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { Description } = this.resources;
-            this.template = {
-                Description,
-                Resources: Object.assign({}, this.resources.CustomResources)
-            };
-            this.result = {};
-            // Ensure S3 bucket exist
-            this.logger.log("DEBUG", "Check assets bucket", this.resources.AssetsBucket);
-            yield this.createBucket(this.resources.AssetsBucket);
-            // Check if we need OpenAPI export
-            let openapi = yield this.completeOpenAPI(this.manager.getWebda().exportOpenAPI(false));
-            this.openapiS3Object = this.getStringified(openapi, this.resources.OpenAPIFileName);
-            yield this.putFilesOnBucket(this.resources.AssetsBucket, [this.openapiS3Object]);
-            // If APIGatewayImportOpenApi update REST API
-            if (this.resources.APIGatewayImportOpenApi) {
-                this.logger.log("INFO", "Importing open api");
-                yield this.importOpenApi(openapi);
-            }
-            // Build Docker if needed
-            if (this.resources.Docker && this.resources.Docker.tag) {
-                this.logger.log("INFO", "Building Docker image", this.resources.Docker.tag);
-                yield this.buildDocker();
-            }
-            this.logger.log("INFO", "Uploading statics");
-            // Upload any Statics
-            yield this.uploadStatics();
-            // Dynamicly call each methods
-            for (let i in this.resources) {
-                if (this[i] && typeof this[i] === "function") {
-                    this.logger.log("TRACE", "Add CloudFormation Resource", i);
-                    yield this[i]();
-                }
+    async deploy() {
+        const { Description } = this.resources;
+        this.template = {
+            Description,
+            Resources: { ...this.resources.CustomResources }
+        };
+        this.result = {};
+        // Ensure S3 bucket exist
+        this.logger.log("DEBUG", "Check assets bucket", this.resources.AssetsBucket);
+        await this.createBucket(this.resources.AssetsBucket);
+        // Check if we need OpenAPI export
+        let openapi = await this.completeOpenAPI(this.manager.getWebda().exportOpenAPI(false));
+        this.openapiS3Object = this.getStringified(openapi, this.resources.OpenAPIFileName);
+        await this.putFilesOnBucket(this.resources.AssetsBucket, [this.openapiS3Object]);
+        // If APIGatewayImportOpenApi update REST API
+        if (this.resources.APIGatewayImportOpenApi) {
+            this.logger.log("INFO", "Importing open api");
+            await this.importOpenApi(openapi);
+        }
+        // Build Docker if needed
+        if (this.resources.Docker && this.resources.Docker.tag) {
+            this.logger.log("INFO", "Building Docker image", this.resources.Docker.tag);
+            await this.buildDocker();
+        }
+        this.logger.log("INFO", "Uploading statics");
+        // Upload any Statics
+        await this.uploadStatics();
+        // Dynamicly call each methods
+        for (let i in this.resources) {
+            if (this[i] && typeof this[i] === "function") {
+                this.logger.log("TRACE", "Add CloudFormation Resource", i);
+                await this[i]();
             }
-            // Add any static
-            for (let i in this.resources.Statics) {
-                this.logger.log("TRACE", "Add Static Resource", i);
-                yield this.createStatic(this.resources.Statics[i]);
-            }
-            this.logger.log("INFO", "Deploy with CloudFormation");
-            // Upload new version it
-            yield this.sendCloudFormationTemplate();
-            // Load the stack
-            yield this.createCloudFormation();
-            return this.result;
-        });
+        }
+        // Add any static
+        for (let i in this.resources.Statics) {
+            this.logger.log("TRACE", "Add Static Resource", i);
+            await this.createStatic(this.resources.Statics[i]);
+        }
+        this.logger.log("INFO", "Deploy with CloudFormation");
+        // Upload new version it
+        await this.sendCloudFormationTemplate();
+        // Load the stack
+        await this.createCloudFormation();
+        return this.result;
     }
     /**
      * Upload any asset to bucket
      */
-    uploadStatics() {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (let i in this.resources.Statics) {
-                const { Source, AssetsPath } = this.resources.Statics[i];
-                yield this.putFolderOnBucket(this.resources.AssetsBucket, this.manager.getApplication().getAppPath(Source), AssetsPath);
-            }
-        });
+    async uploadStatics() {
+        for (let i in this.resources.Statics) {
+            const { Source, AssetsPath } = this.resources.Statics[i];
+            await this.putFolderOnBucket(this.resources.AssetsBucket, this.manager.getApplication().getAppPath(Source), AssetsPath);
+        }
     }
-    createStatic(info) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { DomainName, CloudFront, Bucket } = info;
-            info.Bucket = info.Bucket || {};
-            // Create bucket
-            let resPrefix = `Static${DomainName.replace(/\./g, "")}`;
-            if (Bucket) {
-                this.template.Resources[`${resPrefix}Bucket`] = {
-                    Type: "AWS::S3::Bucket",
-                    Properties: Object.assign(Object.assign({}, info.Bucket), { BucketName: DomainName, Tags: this.getDefaultTags(info.Bucket.Tags) })
-                };
-            }
-            if (CloudFront) {
-                if (!CloudFront.DistributionConfig.ViewerCertificate) {
-                    CloudFront.DistributionConfig.ViewerCertificate = {
-                        AcmCertificateArn: (yield this.getCertificate(DomainName)).CertificateArn,
-                        SslSupportMethod: "sni-only"
-                    };
+    async createStatic(info) {
+        const { DomainName, CloudFront, Bucket } = info;
+        info.Bucket = info.Bucket || {};
+        // Create bucket
+        let resPrefix = `Static${DomainName.replace(/\./g, "")}`;
+        if (Bucket) {
+            this.template.Resources[`${resPrefix}Bucket`] = {
+                Type: "AWS::S3::Bucket",
+                Properties: {
+                    ...info.Bucket,
+                    BucketName: DomainName,
+                    Tags: this.getDefaultTags(info.Bucket.Tags)
                 }
-                this.template.Resources[`${resPrefix}CloudFront`] = {
-                    Type: "AWS::CloudFront::Distribution",
-                    Properties: {
-                        DistributionConfig: CloudFront.DistributionConfig,
-                        Tags: this.getDefaultTags(info.CloudFront.Tags)
-                    }
+            };
+        }
+        if (CloudFront) {
+            if (!CloudFront.DistributionConfig.ViewerCertificate) {
+                CloudFront.DistributionConfig.ViewerCertificate = {
+                    AcmCertificateArn: (await this.getCertificate(DomainName)).CertificateArn,
+                    SslSupportMethod: "sni-only"
                 };
-                yield this.createCloudFormationDNSEntry({ "Fn::GetAtt": [`${resPrefix}CloudFront`, "DomainName"] }, DomainName, "Z2FDTNDATAQYW2" // Constant as seen here: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-aliastarget-1.html#cfn-route53-aliastarget-hostedzoneid
-                );
             }
-        });
+            this.template.Resources[`${resPrefix}CloudFront`] = {
+                Type: "AWS::CloudFront::Distribution",
+                Properties: {
+                    DistributionConfig: CloudFront.DistributionConfig,
+                    Tags: this.getDefaultTags(info.CloudFront.Tags)
+                }
+            };
+            await this.createCloudFormationDNSEntry({ "Fn::GetAtt": [`${resPrefix}CloudFront`, "DomainName"] }, DomainName, "Z2FDTNDATAQYW2" // Constant as seen here: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-route53-aliastarget-1.html#cfn-route53-aliastarget-hostedzoneid
+            );
+        }
     }
     /**
      * Copy the CloudFormation template to the Assets bucket
      */
-    sendCloudFormationTemplate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let res = this.getStringified(this.template, this.resources.FileName);
-            this.result.CloudFormation = {
-                Bucket: this.resources.AssetsBucket,
-                Key: res.key
-            };
-            this.result.CloudFormationContent = res.src.toString();
-            yield this.putFilesOnBucket(this.resources.AssetsBucket, [res]);
-        });
+    async sendCloudFormationTemplate() {
+        let res = this.getStringified(this.template, this.resources.FileName);
+        this.result.CloudFormation = {
+            Bucket: this.resources.AssetsBucket,
+            Key: res.key
+        };
+        this.result.CloudFormationContent = res.src.toString();
+        await this.putFilesOnBucket(this.resources.AssetsBucket, [res]);
     }
     /**
      * Delete the CloudFormation stack
      * @returns
      */
-    deleteCloudFormation() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let cloudformation = new client_cloudformation_1.CloudFormation({});
-            yield cloudformation.deleteStack({ StackName: this.resources.StackName });
-            return this.waitFor((resolve) => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    yield cloudformation.describeStacks({ StackName: this.resources.StackName });
-                }
-                catch (err) {
-                    resolve();
-                    return true;
-                }
-            }), 50, "Waiting on stack to be deleted", 5000);
-        });
+    async deleteCloudFormation() {
+        let cloudformation = new CloudFormation({});
+        await cloudformation.deleteStack({ StackName: this.resources.StackName });
+        return this.waitFor(async (resolve) => {
+            try {
+                await cloudformation.describeStacks({ StackName: this.resources.StackName });
+            }
+            catch (err) {
+                resolve();
+                return true;
+            }
+        }, 50, "Waiting on stack to be deleted", 5000);
     }
     /**
      *
@@ -353,36 +305,32 @@ class CloudFormationDeployer extends _1.AWSDeployer {
      * @param HostedZoneId
      * @returns
      */
-    createCloudFormationDNSEntry(ref, domain, HostedZoneId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let zone = yield this.getZoneForDomainName(domain);
-            if (!zone) {
-                this.logger.log("WARN", "Cannot find Route53 zone for", domain, ", you will have to create manually the CNAME");
-                return;
-            }
-            // Possible conflict if my.name.domain.io and myn.ame.domain.io exists
-            this.template.Resources[`DNSEntry${domain.replace(/\./g, "")}`] = {
-                Type: "AWS::Route53::RecordSet",
-                Properties: {
-                    AliasTarget: { DNSName: ref, HostedZoneId },
-                    Comment: "Created by @webda/aws/cloudformation",
-                    Type: "A",
-                    Name: domain,
-                    HostedZoneId: zone.Id
-                }
-            };
-        });
+    async createCloudFormationDNSEntry(ref, domain, HostedZoneId) {
+        let zone = await this.getZoneForDomainName(domain);
+        if (!zone) {
+            this.logger.log("WARN", "Cannot find Route53 zone for", domain, ", you will have to create manually the CNAME");
+            return;
+        }
+        // Possible conflict if my.name.domain.io and myn.ame.domain.io exists
+        this.template.Resources[`DNSEntry${domain.replace(/\./g, "")}`] = {
+            Type: "AWS::Route53::RecordSet",
+            Properties: {
+                AliasTarget: { DNSName: ref, HostedZoneId },
+                Comment: "Created by @webda/aws/cloudformation",
+                Type: "A",
+                Name: domain,
+                HostedZoneId: zone.Id
+            }
+        };
     }
-    importOpenApi(openapi) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let apigateway = new client_api_gateway_1.APIGateway({});
-            console.log("Creating API Gateway");
-            yield apigateway.putRestApi({
-                body: Buffer.from(JSON.stringify(openapi)),
-                failOnWarnings: false,
-                restApiId: this.resources.APIGatewayImportOpenApi,
-                mode: "overwrite"
-            });
+    async importOpenApi(openapi) {
+        let apigateway = new APIGateway({});
+        console.log("Creating API Gateway");
+        await apigateway.putRestApi({
+            body: Buffer.from(JSON.stringify(openapi)),
+            failOnWarnings: false,
+            restApiId: this.resources.APIGatewayImportOpenApi,
+            mode: "overwrite"
         });
     }
     /**
@@ -390,213 +338,229 @@ class CloudFormationDeployer extends _1.AWSDeployer {
      * @param cloudformation
      * @returns
      */
-    createCloudFormationChangeSet(cloudformation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let changeSetParams = Object.assign(Object.assign({}, this.resources.StackOptions), { StackName: this.resources.StackName, ChangeSetName: "WebdaCloudFormationDeployer", Capabilities: ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"], Tags: this.getDefaultTags("StackOptions"), TemplateURL: `https://${this.result.CloudFormation.Bucket}.s3.amazonaws.com/${this.result.CloudFormation.Key}`, ResourcesToImport: this.resources.ResourcesToImport });
-            let changeSet;
-            try {
-                changeSet = yield cloudformation.createChangeSet(Object.assign(Object.assign({}, changeSetParams), { ChangeSetType: this.resources.ChangeSetType === "IMPORT" ? "IMPORT" : "UPDATE" }));
+    async createCloudFormationChangeSet(cloudformation) {
+        let changeSetParams = {
+            ...this.resources.StackOptions,
+            StackName: this.resources.StackName,
+            ChangeSetName: "WebdaCloudFormationDeployer",
+            Capabilities: ["CAPABILITY_IAM", "CAPABILITY_NAMED_IAM"],
+            Tags: this.getDefaultTags("StackOptions"),
+            TemplateURL: `https://${this.result.CloudFormation.Bucket}.s3.amazonaws.com/${this.result.CloudFormation.Key}`,
+            ResourcesToImport: this.resources.ResourcesToImport
+        };
+        let changeSet;
+        try {
+            changeSet = await cloudformation.createChangeSet({
+                ...changeSetParams,
+                ChangeSetType: this.resources.ChangeSetType === "IMPORT" ? "IMPORT" : "UPDATE"
+            });
+        }
+        catch (err) {
+            if (err.message.endsWith(" is in ROLLBACK_COMPLETE state and can not be updated.")) {
+                this.logger.log("WARN", "Deleting buguous stack");
+                await this.deleteCloudFormation();
+                changeSet = await cloudformation.createChangeSet({
+                    ...changeSetParams,
+                    ChangeSetType: this.resources.ChangeSetType
+                });
             }
-            catch (err) {
-                if (err.message.endsWith(" is in ROLLBACK_COMPLETE state and can not be updated.")) {
-                    this.logger.log("WARN", "Deleting buguous stack");
-                    yield this.deleteCloudFormation();
-                    changeSet = yield cloudformation.createChangeSet(Object.assign(Object.assign({}, changeSetParams), { ChangeSetType: this.resources.ChangeSetType }));
-                }
-                else if (err.message === `Stack [${this.resources.StackName}] does not exist`) {
-                    changeSet = yield cloudformation.createChangeSet(Object.assign(Object.assign({}, changeSetParams), { ChangeSetType: this.resources.ChangeSetType }));
-                }
-                else if (err.message.endsWith(" state and can not be updated.")) {
-                    yield this.waitFor((resolve) => __awaiter(this, void 0, void 0, function* () {
-                        let res = yield cloudformation.describeStacks({
-                            StackName: this.resources.StackName
-                        });
-                        if (res.Stacks.length === 0) {
-                            // If it disapeared, recreate
-                            changeSet = yield cloudformation.createChangeSet(Object.assign(Object.assign({}, changeSetParams), { ChangeSetType: this.resources.ChangeSetType }));
-                            resolve();
-                            return true;
-                        }
-                        if (res.Stacks[0].StackStatus.endsWith("COMPLETE")) {
-                            changeSet = yield cloudformation.createChangeSet(Object.assign(Object.assign({}, changeSetParams), { ChangeSetType: this.resources.ChangeSetType === "IMPORT" ? "IMPORT" : "UPDATE" }));
-                            resolve();
-                            return true;
-                        }
-                        return false;
-                    }), 50, "Waiting for COMPLETE state", 5000);
-                }
-                else if (err.code === "AlreadyExistsException") {
-                    this.logger.log("WARN", "ChangeSet exists and need to be clean");
-                    yield cloudformation.deleteChangeSet({
-                        StackName: this.resources.StackName,
-                        ChangeSetName: "WebdaCloudFormationDeployer"
+            else if (err.message === `Stack [${this.resources.StackName}] does not exist`) {
+                changeSet = await cloudformation.createChangeSet({
+                    ...changeSetParams,
+                    ChangeSetType: this.resources.ChangeSetType
+                });
+            }
+            else if (err.message.endsWith(" state and can not be updated.")) {
+                await this.waitFor(async (resolve) => {
+                    let res = await cloudformation.describeStacks({
+                        StackName: this.resources.StackName
                     });
-                    changeSet = yield cloudformation.createChangeSet(Object.assign(Object.assign({}, changeSetParams), { ChangeSetType: this.resources.ChangeSetType === "IMPORT" ? "IMPORT" : "UPDATE" }));
-                }
-                else {
-                    throw err;
-                }
+                    if (res.Stacks.length === 0) {
+                        // If it disapeared, recreate
+                        changeSet = await cloudformation.createChangeSet({
+                            ...changeSetParams,
+                            ChangeSetType: this.resources.ChangeSetType
+                        });
+                        resolve();
+                        return true;
+                    }
+                    if (res.Stacks[0].StackStatus.endsWith("COMPLETE")) {
+                        changeSet = await cloudformation.createChangeSet({
+                            ...changeSetParams,
+                            ChangeSetType: this.resources.ChangeSetType === "IMPORT" ? "IMPORT" : "UPDATE"
+                        });
+                        resolve();
+                        return true;
+                    }
+                    return false;
+                }, 50, "Waiting for COMPLETE state", 5000);
+            }
+            else if (err.code === "AlreadyExistsException") {
+                this.logger.log("WARN", "ChangeSet exists and need to be clean");
+                await cloudformation.deleteChangeSet({
+                    StackName: this.resources.StackName,
+                    ChangeSetName: "WebdaCloudFormationDeployer"
+                });
+                changeSet = await cloudformation.createChangeSet({
+                    ...changeSetParams,
+                    ChangeSetType: this.resources.ChangeSetType === "IMPORT" ? "IMPORT" : "UPDATE"
+                });
             }
-            return changeSet;
-        });
+            else {
+                throw err;
+            }
+        }
+        return changeSet;
     }
     /**
      * Upload and create the cloudformation stack or update it
      * @returns
      */
-    createCloudFormation() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let cloudformation = new client_cloudformation_1.CloudFormation({});
-            let changeSet = yield this.createCloudFormationChangeSet(cloudformation);
-            // Wait for change set
-            this.logger.log("TRACE", `ChangeSet: ${changeSet}`);
-            // It will trigger an exception if timeout
-            let changes = yield this.waitFor((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-                let localChanges = yield cloudformation.describeChangeSet({
-                    ChangeSetName: "WebdaCloudFormationDeployer",
-                    StackName: this.resources.StackName
-                });
-                if (localChanges.Status === "FAILED" || localChanges.Status === "CREATE_COMPLETE") {
-                    resolve(localChanges);
-                    return true;
-                }
-                if (localChanges.Status === "ROLLBACK_COMPLETE") {
-                    reject();
-                }
-            }), 50, "Waiting for ChangeSet to be ready...", 5000);
-            if (changes.Status === "FAILED") {
-                if (changes.StatusReason ===
-                    "The submitted information didn't contain changes. Submit different information to create a change set.") {
-                    this.logger.log("INFO", "No changes to be made");
-                }
-                else {
-                    this.logger.log("ERROR", "Cannot execute ChangeSet:", changes.StatusReason);
-                }
-                return;
-            }
-            changes.Changes.filter(j => j.Type === "Resource").forEach(({ ResourceChange: info }) => this.logger.log("INFO", `${info.Action.toUpperCase().padEnd(38)} ${info.ResourceType.padEnd(30)} ${info.LogicalResourceId}`));
-            this.logger.log("INFO", "Executing Change Set");
-            let lastEvent = (yield cloudformation.describeStackEvents({ StackName: this.resources.StackName })).StackEvents.shift();
-            yield cloudformation.executeChangeSet({
+    async createCloudFormation() {
+        let cloudformation = new CloudFormation({});
+        let changeSet = await this.createCloudFormationChangeSet(cloudformation);
+        // Wait for change set
+        this.logger.log("TRACE", `ChangeSet: ${changeSet}`);
+        // It will trigger an exception if timeout
+        let changes = await this.waitFor(async (resolve, reject) => {
+            let localChanges = await cloudformation.describeChangeSet({
                 ChangeSetName: "WebdaCloudFormationDeployer",
                 StackName: this.resources.StackName
             });
-            // Wait for the completion of change and display events in the meantime
-            this.logger.log("INFO", "Waiting for update completion");
-            let i = 0;
-            let Timeout = true;
-            do {
-                let events = (yield cloudformation.describeStackEvents({ StackName: this.resources.StackName })).StackEvents;
-                let display = lastEvent ? false : true;
-                let event;
-                while ((event = events.pop())) {
-                    if (display) {
-                        this.logger.log("INFO", `${event.ResourceStatus.padEnd(38)} ${event.ResourceType.padEnd(30)} ${event.LogicalResourceId}`);
-                        lastEvent = event;
-                        if (lastEvent.LogicalResourceId === this.resources.StackName &&
-                            (lastEvent.ResourceStatus === "UPDATE_COMPLETE" ||
-                                lastEvent.ResourceStatus === "CREATE_COMPLETE" ||
-                                lastEvent.ResourceStatus === "ROLLBACK_COMPLETE" ||
-                                lastEvent.ResourceStatus === "UPDATE_ROLLBACK_COMPLETE")) {
-                            Timeout = false;
-                            break;
-                        }
-                    }
-                    else if (event.EventId === lastEvent.EventId) {
-                        display = true;
+            if (localChanges.Status === "FAILED" || localChanges.Status === "CREATE_COMPLETE") {
+                resolve(localChanges);
+                return true;
+            }
+            if (localChanges.Status === "ROLLBACK_COMPLETE") {
+                reject();
+            }
+        }, 50, "Waiting for ChangeSet to be ready...", 5000);
+        if (changes.Status === "FAILED") {
+            if (changes.StatusReason ===
+                "The submitted information didn't contain changes. Submit different information to create a change set.") {
+                this.logger.log("INFO", "No changes to be made");
+            }
+            else {
+                this.logger.log("ERROR", "Cannot execute ChangeSet:", changes.StatusReason);
+            }
+            return;
+        }
+        changes.Changes.filter(j => j.Type === "Resource").forEach(({ ResourceChange: info }) => this.logger.log("INFO", `${info.Action.toUpperCase().padEnd(38)} ${info.ResourceType.padEnd(30)} ${info.LogicalResourceId}`));
+        this.logger.log("INFO", "Executing Change Set");
+        let lastEvent = (await cloudformation.describeStackEvents({ StackName: this.resources.StackName })).StackEvents.shift();
+        await cloudformation.executeChangeSet({
+            ChangeSetName: "WebdaCloudFormationDeployer",
+            StackName: this.resources.StackName
+        });
+        // Wait for the completion of change and display events in the meantime
+        this.logger.log("INFO", "Waiting for update completion");
+        let i = 0;
+        let Timeout = true;
+        do {
+            let events = (await cloudformation.describeStackEvents({ StackName: this.resources.StackName })).StackEvents;
+            let display = lastEvent ? false : true;
+            let event;
+            while ((event = events.pop())) {
+                if (display) {
+                    this.logger.log("INFO", `${event.ResourceStatus.padEnd(38)} ${event.ResourceType.padEnd(30)} ${event.LogicalResourceId}`);
+                    lastEvent = event;
+                    if (lastEvent.LogicalResourceId === this.resources.StackName &&
+                        (lastEvent.ResourceStatus === "UPDATE_COMPLETE" ||
+                            lastEvent.ResourceStatus === "CREATE_COMPLETE" ||
+                            lastEvent.ResourceStatus === "ROLLBACK_COMPLETE" ||
+                            lastEvent.ResourceStatus === "UPDATE_ROLLBACK_COMPLETE")) {
+                        Timeout = false;
+                        break;
                     }
                 }
-                // If we are done do not pause
-                if (Timeout) {
-                    yield this.sleep(10);
-                    i++;
+                else if (event.EventId === lastEvent.EventId) {
+                    display = true;
                 }
-            } while (i < 60 && Timeout);
+            }
+            // If we are done do not pause
             if (Timeout) {
-                this.logger.log("WARN", "Timeout while waiting for stack to update");
-                return;
-            }
-            /*
-            CloudFormation does not update Stage when resources are modified
-        
-            https://stackoverflow.com/questions/41423439/cloudformation-doesnt-deploy-to-api-gateway-stages-on-update
-            */
-            if (this.APIGateway) {
-                let NextToken = undefined;
-                let stageName;
-                let restApiId;
-                // Retrieve resources
-                do {
-                    let res = yield cloudformation.listStackResources({ StackName: this.resources.StackName, NextToken });
-                    NextToken = res.NextToken;
-                    res.StackResourceSummaries.forEach(resource => {
-                        if (resource.ResourceType === "AWS::ApiGateway::Stage") {
-                            stageName = resource.PhysicalResourceId;
-                        }
-                        else if (resource.ResourceType === "AWS::ApiGateway::RestApi") {
-                            restApiId = resource.PhysicalResourceId;
-                        }
-                    });
-                } while (NextToken);
-                // Get RestAPIId
-                if (restApiId && stageName) {
-                    const gw = new client_api_gateway_1.APIGateway({});
-                    yield gw.createDeployment({
-                        restApiId,
-                        stageName
-                    });
-                }
+                await this.sleep(10);
+                i++;
             }
-        });
+        } while (i < 60 && Timeout);
+        if (Timeout) {
+            this.logger.log("WARN", "Timeout while waiting for stack to update");
+            return;
+        }
+        /*
+        CloudFormation does not update Stage when resources are modified
+    
+        https://stackoverflow.com/questions/41423439/cloudformation-doesnt-deploy-to-api-gateway-stages-on-update
+        */
+        if (this.APIGateway) {
+            let NextToken = undefined;
+            let stageName;
+            let restApiId;
+            // Retrieve resources
+            do {
+                let res = await cloudformation.listStackResources({ StackName: this.resources.StackName, NextToken });
+                NextToken = res.NextToken;
+                res.StackResourceSummaries.forEach(resource => {
+                    if (resource.ResourceType === "AWS::ApiGateway::Stage") {
+                        stageName = resource.PhysicalResourceId;
+                    }
+                    else if (resource.ResourceType === "AWS::ApiGateway::RestApi") {
+                        restApiId = resource.PhysicalResourceId;
+                    }
+                });
+            } while (NextToken);
+            // Get RestAPIId
+            if (restApiId && stageName) {
+                const gw = new APIGateway({});
+                await gw.createDeployment({
+                    restApiId,
+                    stageName
+                });
+            }
+        }
     }
     /**
      * Pause for x seconds
      * @param seconds
      */
-    sleep(sec) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield new Promise(resolve => setTimeout(resolve, sec * 1000));
-        });
+    async sleep(sec) {
+        await new Promise(resolve => setTimeout(resolve, sec * 1000));
     }
-    Resources() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let services = this.manager.getWebda().getServices();
-            // Build policy
-            for (let i in services) {
-                if ("getCloudFormation" in services[i]) {
-                    // Update to match recuring policy - might need to split if policy too big
-                    let res = services[i].getCloudFormation(this);
-                    for (let j in res) {
-                        this.template.Resources[`Service${i}_${j}`] = res[j];
-                    }
+    async Resources() {
+        let services = this.manager.getWebda().getServices();
+        // Build policy
+        for (let i in services) {
+            if ("getCloudFormation" in services[i]) {
+                // Update to match recuring policy - might need to split if policy too big
+                let res = services[i].getCloudFormation(this);
+                for (let j in res) {
+                    this.template.Resources[`Service${i}_${j}`] = res[j];
                 }
             }
-        });
+        }
     }
     getRegion() {
         return "us-east-1";
     }
-    completeOpenAPI(openapi) {
-        return __awaiter(this, void 0, void 0, function* () {
-            openapi.info.title = this.resources.OpenAPITitle;
-            let info = yield this.getAWSIdentity();
-            let arn = `arn:aws:lambda:${this.getRegion()}:${info.Account}:function:${this.resources.Lambda.FunctionName}`;
-            for (let p in openapi.paths) {
-                // Not using mockCors as the {@link RequestFilter.checkRequest} can be dynamic
-                // Invalid mapping expression parameter specified: method.response.header.Access-Control-Allow-Credentials
-                if (!openapi.paths[p]["options"]) {
-                    openapi.paths[p]["options"] = {};
-                }
-                for (let m in openapi.paths[p]) {
-                    openapi.paths[p][m]["x-amazon-apigateway-integration"] = {
-                        httpMethod: "POST",
-                        uri: `arn:aws:apigateway:${this.getRegion()}:lambda:path/2015-03-31/functions/${arn}/invocations`,
-                        type: "aws_proxy"
-                    };
-                }
+    async completeOpenAPI(openapi) {
+        openapi.info.title = this.resources.OpenAPITitle;
+        let info = await this.getAWSIdentity();
+        let arn = `arn:aws:lambda:${this.getRegion()}:${info.Account}:function:${this.resources.Lambda.FunctionName}`;
+        for (let p in openapi.paths) {
+            // Not using mockCors as the {@link RequestFilter.checkRequest} can be dynamic
+            // Invalid mapping expression parameter specified: method.response.header.Access-Control-Allow-Credentials
+            if (!openapi.paths[p]["options"]) {
+                openapi.paths[p]["options"] = {};
+            }
+            for (let m in openapi.paths[p]) {
+                openapi.paths[p][m]["x-amazon-apigateway-integration"] = {
+                    httpMethod: "POST",
+                    uri: `arn:aws:apigateway:${this.getRegion()}:lambda:path/2015-03-31/functions/${arn}/invocations`,
+                    type: "aws_proxy"
+                };
             }
-            return openapi;
-        });
+        }
+        return openapi;
     }
     getStringified(object, filename, addPrefix = true) {
         let key = addPrefix ? `${this.resources.AssetsPrefix}${filename}` : filename;
@@ -630,81 +594,98 @@ class CloudFormationDeployer extends _1.AWSDeployer {
             src
         };
     }
-    APIGateway() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.template.Resources.APIGateway = {
-                Type: "AWS::ApiGateway::RestApi",
-                Properties: Object.assign(Object.assign({}, this.resources.APIGateway), { Tags: this.getDefaultTags("APIGateway"), BodyS3Location: {
-                        Bucket: this.resources.AssetsBucket,
-                        Key: this.openapiS3Object.key
-                    } }),
-                DependsOn: "LambdaFunction"
-            };
-            this.template.Resources.LambdaApiGatewayPermission = {
-                Type: "AWS::Lambda::Permission",
-                Properties: {
-                    Action: "lambda:InvokeFunction",
-                    FunctionName: this.resources.Lambda.FunctionName,
-                    Principal: "apigateway.amazonaws.com",
-                    SourceArn: {
-                        "Fn::Join": [
-                            ":",
-                            [
-                                "arn:aws:execute-api",
-                                { Ref: "AWS::Region" },
-                                { Ref: "AWS::AccountId" },
-                                { "Fn::Join": ["", [{ Ref: "APIGateway" }, "/*"]] }
-                            ]
+    async APIGateway() {
+        this.template.Resources.APIGateway = {
+            Type: "AWS::ApiGateway::RestApi",
+            Properties: {
+                ...this.resources.APIGateway,
+                Tags: this.getDefaultTags("APIGateway"),
+                BodyS3Location: {
+                    Bucket: this.resources.AssetsBucket,
+                    Key: this.openapiS3Object.key
+                }
+            },
+            DependsOn: "LambdaFunction"
+        };
+        this.template.Resources.LambdaApiGatewayPermission = {
+            Type: "AWS::Lambda::Permission",
+            Properties: {
+                Action: "lambda:InvokeFunction",
+                FunctionName: this.resources.Lambda.FunctionName,
+                Principal: "apigateway.amazonaws.com",
+                SourceArn: {
+                    "Fn::Join": [
+                        ":",
+                        [
+                            "arn:aws:execute-api",
+                            { Ref: "AWS::Region" },
+                            { Ref: "AWS::AccountId" },
+                            { "Fn::Join": ["", [{ Ref: "APIGateway" }, "/*"]] }
                         ]
-                    }
-                },
-                DependsOn: "LambdaFunction"
-            };
-            this.template.Resources.APIGatewayDeployment = {
-                Type: "AWS::ApiGateway::Deployment",
-                Properties: Object.assign(Object.assign({}, this.resources.APIGatewayDeployment), { RestApiId: { Ref: "APIGateway" } })
-            };
-            // SourceArn: "arn:aws:execute-api:" + AWS.config.region + ":" + awsId + ":" + this.restApiId + "/*"
-            this.template.Resources.APIGatewayStage = {
-                Type: "AWS::ApiGateway::Stage",
-                Properties: Object.assign(Object.assign({}, this.resources.APIGatewayStage), { Tags: this.getDefaultTags("APIGatewayStage"), DeploymentId: { Ref: "APIGatewayDeployment" }, RestApiId: { Ref: "APIGateway" } })
-            };
-        });
-    }
-    APIGatewayDomain() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let region;
-            if (this.resources.APIGatewayDomain.EndpointConfiguration) {
-                if (this.resources.APIGatewayDomain.EndpointConfiguration.Types.indexOf("EDGE") >= 0) {
-                    region = "us-east-1";
+                    ]
                 }
+            },
+            DependsOn: "LambdaFunction"
+        };
+        this.template.Resources.APIGatewayDeployment = {
+            Type: "AWS::ApiGateway::Deployment",
+            Properties: {
+                ...this.resources.APIGatewayDeployment,
+                RestApiId: { Ref: "APIGateway" }
             }
-            else {
+        };
+        // SourceArn: "arn:aws:execute-api:" + AWS.config.region + ":" + awsId + ":" + this.restApiId + "/*"
+        this.template.Resources.APIGatewayStage = {
+            Type: "AWS::ApiGateway::Stage",
+            Properties: {
+                ...this.resources.APIGatewayStage,
+                Tags: this.getDefaultTags("APIGatewayStage"),
+                DeploymentId: { Ref: "APIGatewayDeployment" },
+                RestApiId: { Ref: "APIGateway" }
+            }
+        };
+    }
+    async APIGatewayDomain() {
+        let region;
+        if (this.resources.APIGatewayDomain.EndpointConfiguration) {
+            if (this.resources.APIGatewayDomain.EndpointConfiguration.Types.indexOf("EDGE") >= 0) {
                 region = "us-east-1";
             }
-            if (!this.resources.APIGatewayDomain.CertificateArn) {
-                this.resources.APIGatewayDomain.CertificateArn = (yield this.getCertificate(this.resources.APIGatewayDomain.DomainName, region)).CertificateArn;
+        }
+        else {
+            region = "us-east-1";
+        }
+        if (!this.resources.APIGatewayDomain.CertificateArn) {
+            this.resources.APIGatewayDomain.CertificateArn = (await this.getCertificate(this.resources.APIGatewayDomain.DomainName, region)).CertificateArn;
+        }
+        this.template.Resources.APIGatewayDomain = {
+            Type: "AWS::ApiGateway::DomainName",
+            Properties: {
+                ...this.resources.APIGatewayDomain,
+                Tags: this.getDefaultTags("APIGatewayDomain")
             }
-            this.template.Resources.APIGatewayDomain = {
-                Type: "AWS::ApiGateway::DomainName",
-                Properties: Object.assign(Object.assign({}, this.resources.APIGatewayDomain), { Tags: this.getDefaultTags("APIGatewayDomain") })
-            };
-            this.template.Resources.APIGatewayBasePathMapping = {
-                Type: "AWS::ApiGateway::BasePathMapping",
-                Properties: Object.assign(Object.assign({}, this.resources.APIGatewayBasePathMapping), { DomainName: { Ref: "APIGatewayDomain" }, RestApiId: { Ref: "APIGateway" }, Stage: { Ref: "APIGatewayStage" } })
-            };
-            // Should do conditional with RegionalDomainName/RegionalHostedZoneId
-            yield this.createCloudFormationDNSEntry({ "Fn::GetAtt": ["APIGatewayDomain", "DistributionDomainName"] }, this.resources.APIGatewayDomain.DomainName, { "Fn::GetAtt": ["APIGatewayDomain", "DistributionHostedZoneId"] });
-        });
+        };
+        this.template.Resources.APIGatewayBasePathMapping = {
+            Type: "AWS::ApiGateway::BasePathMapping",
+            Properties: {
+                ...this.resources.APIGatewayBasePathMapping,
+                DomainName: { Ref: "APIGatewayDomain" },
+                RestApiId: { Ref: "APIGateway" },
+                Stage: { Ref: "APIGatewayStage" }
+            }
+        };
+        // Should do conditional with RegionalDomainName/RegionalHostedZoneId
+        await this.createCloudFormationDNSEntry({ "Fn::GetAtt": ["APIGatewayDomain", "DistributionDomainName"] }, this.resources.APIGatewayDomain.DomainName, { "Fn::GetAtt": ["APIGatewayDomain", "DistributionHostedZoneId"] });
     }
-    Policy() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let PolicyDocument = JSON.stringify(yield this.getPolicyDocument(this.resources.Policy.PolicyDocument.Statement), undefined, 2);
-            this.template.Resources.Policy = {
-                Type: "AWS::IAM::Policy",
-                Properties: Object.assign(Object.assign({}, this.resources.Policy), { PolicyDocument })
-            };
-        });
+    async Policy() {
+        let PolicyDocument = JSON.stringify(await this.getPolicyDocument(this.resources.Policy.PolicyDocument.Statement), undefined, 2);
+        this.template.Resources.Policy = {
+            Type: "AWS::IAM::Policy",
+            Properties: {
+                ...this.resources.Policy,
+                PolicyDocument
+            }
+        };
     }
     addAssumeRolePolicyStatement(...statements) {
         // If we have a Role generation only
@@ -712,67 +693,68 @@ class CloudFormationDeployer extends _1.AWSDeployer {
             this.resources.Role.AssumeRolePolicyDocument.Statement.push(...statements);
         }
     }
-    Role() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // add auto generation
-            let AssumeRolePolicyDocument = JSON.stringify(this.resources.Role.AssumeRolePolicyDocument, undefined, 2);
-            this.template.Resources.Role = {
-                Type: "AWS::IAM::Role",
-                Properties: Object.assign(Object.assign({}, this.resources.Role), { AssumeRolePolicyDocument, Tags: this.getDefaultTags("Role") })
-            };
-        });
+    async Role() {
+        // add auto generation
+        let AssumeRolePolicyDocument = JSON.stringify(this.resources.Role.AssumeRolePolicyDocument, undefined, 2);
+        this.template.Resources.Role = {
+            Type: "AWS::IAM::Role",
+            Properties: {
+                ...this.resources.Role,
+                AssumeRolePolicyDocument,
+                Tags: this.getDefaultTags("Role")
+            }
+        };
     }
-    Lambda() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const Code = yield this.generateLambdaPackage();
-            this.addAssumeRolePolicyStatement({
-                Effect: "Allow",
-                Principal: { Service: "lambda.amazonaws.com" },
-                Action: "sts:AssumeRole"
-            });
-            this.template.Resources.LambdaFunction = {
-                Type: "AWS::Lambda::Function",
-                Properties: Object.assign(Object.assign({}, this.resources.Lambda), { Code, Tags: this.getDefaultTags("Lambda") })
-            };
+    async Lambda() {
+        const Code = await this.generateLambdaPackage();
+        this.addAssumeRolePolicyStatement({
+            Effect: "Allow",
+            Principal: { Service: "lambda.amazonaws.com" },
+            Action: "sts:AssumeRole"
         });
+        this.template.Resources.LambdaFunction = {
+            Type: "AWS::Lambda::Function",
+            Properties: {
+                ...this.resources.Lambda,
+                Code,
+                Tags: this.getDefaultTags("Lambda")
+            }
+        };
     }
-    buildDocker() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Launch the Docker deployment
-            yield this.manager.run("WebdaDeployer/Docker", Object.assign({}, this.resources.Docker));
+    async buildDocker() {
+        // Launch the Docker deployment
+        await this.manager.run("WebdaDeployer/Docker", {
+            ...this.resources.Docker
         });
     }
-    Fargate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.addAssumeRolePolicyStatement({
-                Effect: "Allow",
-                Principal: { Service: "ecs-tasks.amazonaws.com" },
-                Action: "sts:AssumeRole"
-            });
+    async Fargate() {
+        this.addAssumeRolePolicyStatement({
+            Effect: "Allow",
+            Principal: { Service: "ecs-tasks.amazonaws.com" },
+            Action: "sts:AssumeRole"
         });
     }
-    generateLambdaPackage() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { AssetsBucket: S3Bucket, LambdaPackager, AssetsPrefix = "", KeepPackage = false } = this.resources;
-            const { zipPath: ZipPath } = LambdaPackager;
-            let result = {
-                S3Bucket,
-                S3Key: AssetsPrefix + path.basename(ZipPath)
-            };
-            // Create the package
-            yield this.manager.run("WebdaAWSDeployer/LambdaPackager", LambdaPackager);
-            // Copy package to S3
-            yield this.putFilesOnBucket(result.S3Bucket, [
-                {
-                    key: result.S3Key,
-                    src: ZipPath
-                }
-            ]);
-            if (!KeepPackage) {
-                fs.unlinkSync(ZipPath);
-            }
-            return result;
-        });
+    async generateLambdaPackage() {
+        const { AssetsBucket: S3Bucket, LambdaPackager, AssetsPrefix = "", KeepPackage = false } = this.resources;
+        const { zipPath: ZipPath } = LambdaPackager;
+        let result = {
+            S3Bucket,
+            S3Key: AssetsPrefix + path.basename(ZipPath)
+        };
+        // Create the package
+        await this.manager.run("WebdaAWSDeployer/LambdaPackager", LambdaPackager);
+        // Copy package to S3
+        await this.putFilesOnBucket(result.S3Bucket, [
+            {
+                key: result.S3Key,
+                src: ZipPath
+            }
+        ]);
+        /* c8 ignore next 3 */
+        if (!KeepPackage) {
+            fs.unlinkSync(ZipPath);
+        }
+        return result;
     }
     /**
      * Init the project on AWS
@@ -787,65 +769,62 @@ class CloudFormationDeployer extends _1.AWSDeployer {
      * @param console
      * @returns
      */
-    static init(console) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let packageDescr = console.app.getAppPath("package.json");
-            if (!fs.existsSync(packageDescr)) {
-                console.log("ERROR", "package.json not found");
-                return -1;
-            }
-            let pkg = core_1.JSONUtils.loadFile(packageDescr);
-            pkg.webda = pkg.webda || {};
-            let sts = new client_sts_1.STS({});
-            let identity;
-            try {
-                identity = yield sts.getCallerIdentity({});
-            }
-            catch (ex) {
-                console.log("ERROR", "Cannot retrieve your AWS credentials, make sure to have a correct AWS setup");
-                return -1;
-            }
-            let pkgName = (pkg.name || "").replace(/@/g, "").replace(/\//g, "-");
-            let StackName = `webda-${pkgName}-global`;
-            if (!pkg.webda.aws) {
-                console.log("INFO", `This will create a small CloudFormation on your AWS account (${identity.Account}) and region (${sts.config.region || process.env.AWS_DEFAULT_REGION || "us-east-1"})`);
-                console.log("INFO", `The stack will be called ${StackName}`);
-                pkg.webda.aws = {
-                    AssetsBucket: `webda-${pkgName}-assets`,
-                    Repository: `webda-${pkgName}`
-                };
-                let cloudformation = new client_cloudformation_1.CloudFormation({});
-                yield cloudformation.createStack({
-                    StackName,
-                    TemplateBody: JSON.stringify({
-                        Resources: {
-                            WebdaAssetsBucket: {
-                                Type: "AWS::S3::Bucket",
-                                Properties: {
-                                    BucketName: pkg.webda.aws.AssetsBucket
-                                }
-                            },
-                            WebdaECR: {
-                                Type: "AWS::ECR::Repository",
-                                Properties: {
-                                    RepositoryName: pkg.webda.aws.Repository
-                                }
+    static async init(console) {
+        let packageDescr = console.app.getAppPath("package.json");
+        if (!fs.existsSync(packageDescr)) {
+            console.log("ERROR", "package.json not found");
+            return -1;
+        }
+        let pkg = JSONUtils.loadFile(packageDescr);
+        pkg.webda = pkg.webda || {};
+        let sts = new STS({});
+        let identity;
+        try {
+            identity = await sts.getCallerIdentity({});
+        }
+        catch (ex) {
+            console.log("ERROR", "Cannot retrieve your AWS credentials, make sure to have a correct AWS setup");
+            return -1;
+        }
+        let pkgName = (pkg.name || "").replace(/@/g, "").replace(/\//g, "-");
+        let StackName = `webda-${pkgName}-global`;
+        if (!pkg.webda.aws) {
+            console.log("INFO", `This will create a small CloudFormation on your AWS account (${identity.Account}) and region (${sts.config.region || process.env.AWS_DEFAULT_REGION || "us-east-1"})`);
+            console.log("INFO", `The stack will be called ${StackName}`);
+            pkg.webda.aws = {
+                AssetsBucket: `webda-${pkgName}-assets`,
+                Repository: `webda-${pkgName}`
+            };
+            let cloudformation = new CloudFormation({});
+            await cloudformation.createStack({
+                StackName,
+                TemplateBody: JSON.stringify({
+                    Resources: {
+                        WebdaAssetsBucket: {
+                            Type: "AWS::S3::Bucket",
+                            Properties: {
+                                BucketName: pkg.webda.aws.AssetsBucket
+                            }
+                        },
+                        WebdaECR: {
+                            Type: "AWS::ECR::Repository",
+                            Properties: {
+                                RepositoryName: pkg.webda.aws.Repository
                             }
                         }
-                    })
-                });
-                console.log("INFO", "Updating package description with default information");
-                core_1.JSONUtils.saveFile(pkg, packageDescr);
-                return 0;
-            }
-            else {
-                // Check if stack already exists
-                console.log("WARN", "Default information are already in your package.json");
-                return -1;
-            }
-        });
+                    }
+                })
+            });
+            console.log("INFO", "Updating package description with default information");
+            JSONUtils.saveFile(pkg, packageDescr);
+            return 0;
+        }
+        else {
+            // Check if stack already exists
+            console.log("WARN", "Default information are already in your package.json");
+            return -1;
+        }
     }
 }
-exports.default = CloudFormationDeployer;
-exports.CloudFormationDeployer = CloudFormationDeployer;
+export { LAMBDA_LATEST_VERSION, CloudFormationDeployer };
 //# sourceMappingURL=cloudformation.js.map