@kumologica/builder/src/export/github/githubAWSCFWorkflow.js

Kumologica build and deploy module

class GithubAWSCFWorkflow {
    constructor() {}

    createWorkflow(params) {
       //console.log('creating workflow file ' + JSON.stringify(params));
            
        // create gh workflow environment variables
        let [ghEnv, cm] = this.parseParams(params);
        const ts = new Date().toISOString();
        const version = require('../../../package').version;

        // render template
        let fs = require('fs')
        let filename = require.resolve('../../templates/ghAwsCf.txt');
        let template = fs.readFileSync(filename).toString()
                            .replace("KL_ENV", this.getTextEnv(ghEnv))
                            .replace("KL_CM", cm)
                            .replace("KL_VER", version)
                            .replace("KL_TS", ts);
        
        return template;
    }


  parseParams(params) {
    let ghEnv = [];
    let cm = "";

    if (!params.zipFileName) {
        params.zipFileName = 'lambda.zip';
    }

    ghEnv.push("  LAMBDA_NAME: " + params.functionName);
    ghEnv.push("  BUCKET_NAME: " + params.deploymentBucketName || "ENTER_YOUR_BUCKET_HERE");
    ghEnv.push("  AWS_REGION: " + (params.region|| "ENTER_AWS_REGION_HERE"));
   
    if (params.logRetentionDays) {
        ghEnv.push("  KL_LOGS: " + params.logRetentionDays);
        cm += "               --log-retention-days ${{ env.KL_LOGS }} \\\n";
    }
    if (params.description) {
        ghEnv.push(`  KL_DESCRIPTION: '${params.description}'`);
        cm += "               --description '${{ env.KL_DESCRIPTION }}' \\\n";
    }
    if (params.architectures) {
        ghEnv.push(`  KL_ARCHITECTURES: '${params.architectures}'`);
        cm += "               --architectures '${{ env.KL_ARCHITECTURES }}' \\\n";
    }   
    if (params.tracingConfig) {
        ghEnv.push(`  KL_TRACING: '${JSON.stringify(params.tracingConfig)}'`);
        cm += "               --tracing-config '${{ env.KL_TRACING }}' \\\n";
    }
    if (params.environment) {
        ghEnv.push(`  KL_ENVIRONMENT: '${JSON.stringify(params.environment)}'`);
        cm += "               --environment '${{ env.KL_ENVIRONMENT }}' \\\n";
    }
    if (params.tags) { 
        ghEnv.push(`  KL_TAGS: '${JSON.stringify(params.tags)}'`);
        cm += "               --tags '${{ env.KL_TAGS }}' \\\n";
    }
    if (params.roleArn) {
        ghEnv.push("  KL_ROLEARN: " + params.roleArn);
        cm += "               --role-arn ${{ env.KL_ROLEARN }} \\\n";
    }
    if (params.reservedConcurrency) {
        ghEnv.push("  KL_RESERVED_CONCURRENCY: " + params.reservedConcurrency);
        cm += "               --reserved-concurrency ${{ env.RESERVED_CONCURRENCY }} \\\n";
    }
    if (params.kmsKeyArn) {
      ghEnv.push("  KL_KMS: " + params.kmsKeyArn);
      cm += "               --kms-key-arn ${{ env.KL_KMS }} \\\n";
    }
    if (params.vpcConfig) {
        ghEnv.push(`  KL_VPC: '${JSON.stringify(params.vpcConfig)}'`);
        cm += "               --vpc-config '${{ env.KL_VPC }}' \\\n";
    }
    if (params.runtime) {
        ghEnv.push("  KL_RUNTIME: " + params.runtime);
        cm += "               --runtime ${{ env.KL_RUNTIME }} \\\n";
    }
    if (params.timeout) {
        ghEnv.push("  KL_TIMEOUT: " + params.timeout);
        cm += "               --timeout ${{ env.KL_TIMEOUT }} \\\n";
    }
    if (params.memory) {
        ghEnv.push("  KL_MEMORY: " + params.memory);
        cm += "               --memory ${{ env.KL_MEMORY }} \\\n";
    }
    if (params.deadLetterConfig) {
        ghEnv.push(`  KL_DLC: '${JSON.stringify(params.deadLetterConfig)}'`);
        cm += "               --dead-letter-config '${{ env.KL_DLC }}' \\\n";
    }
    if (params.fileSystemConfigs) {
        ghEnv.push(`  KL_FS: '${JSON.stringify(params.fileSystemConfigs)}'`);
        cm += "               --file-system-configs '${{ env.KL_FS }}' \\\n";
   }
    if (params.layers) {
        ghEnv.push("  KL_LAYERS: " + params.layers);
        cm += "               --layers ${{ env.KL_LAYERS }} \\\n";
    }
    if (params.triggers) {
        ghEnv.push(`  KL_TRIGGERS: '${JSON.stringify(params.triggers)}'`);
        cm += "               --triggers '${{ env.KL_TRIGGERS }}' \\\n";
    }
    if (params.policy) {
        ghEnv.push(`  KL_POLICY: '${JSON.stringify(params.policy)}'`);
        cm += "               --policy '${{ env.KL_POLICY }}' \\\n";
    }
    if (params.roleName) {
        ghEnv.push("  KL_ROLENAME: " + params.roleName);
        cm += "               --role-name ${{ env.KL_ROLENAME }} \\\n";
    }
    if (params.strictMode != undefined) {
        ghEnv.push("  KL_STRICT: " + params.strictMode);
        cm += "               --strict-mode ${{ env.KL_STRICT }} \\\n";
    }
    
    if (!params.region) {
        ghEnv.push("  # warning: parameter: region was not provided");
    }
 
    cm += "               --project-directory . \\\n";
    cm += "               --bucket-name ${{ env.BUCKET_NAME }} \\\n";
    cm += `               --zip-file-name ${params.zipFileName}`;
    
    return [ghEnv, cm];
  }

  getTextEnv(ghEnv) {
    return ghEnv.join("\r\n");
  }
}

module.exports = GithubAWSCFWorkflow;