axe - npm Package Compare versions

Comparing version 0.1.1 to 0.2.0

lib/cli.js

@@ -37,2 +37,3 @@ 'use strict';
   var template = require(_path2.default.resolve(stackFile));
+  if (template.default) template = template.default;
 
@@ -52,7 +53,17 @@ _awsSdk2.default.config.update({
   if (action === 'delete') {
-    new _awsSdk2.default.CloudFormation().deleteStack({
-      StackName: name + '--' + process.env.NODE_ENV
-    }, function (err, res) {
-      if (err && !quiet) return console.error(err);
-      if (!quiet) console.log(res);
+    _inquirer2.default.prompt([{
+      type: 'confirm',
+      name: 'sure',
+      message: 'Are you sure you want to destroy everything for ' + name + '?'
+    }]).then(function (_ref) {
+      var sure = _ref.sure;
+
+      if (!sure) return;
+
+      new _awsSdk2.default.CloudFormation().deleteStack({
+        StackName: name + '--' + process.env.NODE_ENV
+      }, function (err, res) {
+        if (err && !quiet) return console.error(err);
+        if (!quiet) console.log(res);
+      });
     });
@@ -63,4 +74,10 @@ } else {
       StackName: name + '--' + process.env.NODE_ENV,
-      TemplateBody: JSON.stringify(template),
-      Tags: _index2.default.DefaultTags({ name: name })
+      TemplateBody: JSON.stringify(template.stack || template),
+      Tags: _index2.default.DefaultTags({ name: name }),
+      Parameters: Object.keys(template.parameters).map(function (key) {
+        return {
+          ParameterKey: key,
+          ParameterValue: template.parameters[key]
+        };
+      })
     }, function (err, res) {
@@ -83,2 +100,6 @@ if (err && !quiet) return console.error(err);
 
+var _inquirer = require('inquirer');
+
+var _inquirer2 = _interopRequireDefault(_inquirer);
+
 var _dotenv = require('dotenv');
@@ -85,0 +106,0 @@

lib/index.js

@@ -37,2 +37,5 @@ 'use strict';
 
+  AccountId: function AccountId() {
+    return { Ref: 'AWS::AccountId' };
+  },
   StackId: function StackId() {
@@ -48,2 +51,11 @@ return { Ref: 'AWS::StackId' };
 
+  Build: function Build(stack) {
+    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+    return {
+      stack: stack,
+      parameters: opts.parameters || []
+    };
+  },
+
   DefaultTags: function DefaultTags() {
@@ -50,0 +62,0 @@ var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

lib/resources.js

@@ -6,82 +6,272 @@ 'use strict';
 });
+
+var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
+
+var build = function build(Type) {
+  return function (Properties, more) {
+    return _extends({
+      Type: Type,
+      Properties: Properties
+    }, more);
+  };
+};
+
 exports.default = {
-  vpc: {
-    vpc: function vpc(Properties) {
-      return { Type: 'AWS::EC2::VPC', Properties: Properties };
-    },
-    internetGateway: function internetGateway(Properties) {
-      return { Type: 'AWS::EC2::InternetGateway', Properties: Properties };
-    },
-    gatewayAttachment: function gatewayAttachment(Properties) {
-      return { Type: 'AWS::EC2::VPCGatewayAttachment', Properties: Properties };
-    },
-    routeTable: function routeTable(Properties) {
-      return { Type: 'AWS::EC2::RouteTable', Properties: Properties };
-    },
-    route: function route(Properties) {
-      return { Type: 'AWS::EC2::Route', Properties: Properties };
-    },
-    subnet: function subnet(Properties) {
-      return { Type: 'AWS::EC2::Subnet', Properties: Properties };
-    },
-    subnetRouteTableAssoc: function subnetRouteTableAssoc(Properties) {
-      return { Type: 'AWS::EC2::SubnetRouteTableAssociation', Properties: Properties };
-    }
+  apiGateway: {
+    account: build('AWS::ApiGateway::Account'),
+    key: build('AWS::ApiGateway::ApiKey'),
+    authorizer: build('AWS::ApiGateway::Authorizer'),
+    basePathMapping: build('AWS::ApiGateway::BasePathMapping'),
+    cert: build('AWS::ApiGateway::ClientCertificate'),
+    deployment: build('AWS::ApiGateway::Deployment'),
+    method: build('AWS::ApiGateway::Method'),
+    model: build('AWS::ApiGateway::Model'),
+    resource: build('AWS::ApiGateway::Resource'),
+    restApi: build('AWS::ApiGateway::RestApi'),
+    stage: build('AWS::ApiGateway::Stage'),
+    usagePlan: build('AWS::ApiGateway::UsagePlan')
   },
+  autoscaling: {
+    launchConfig: build('AWS::AutoScaling::LaunchConfiguration'),
+    group: build('AWS::AutoScaling::AutoScalingGroup'),
+    appScalableTarget: build('AWS::ApplicationAutoScaling::ScalableTarget'),
+    appScalingPolicy: build('AWS::ApplicationAutoScaling::ScalingPolicy'),
+    lifecycleHook: build('AWS::AutoScaling::LifecycleHook'),
+    scalingPolicy: build('AWS::AutoScaling::ScalingPolicy'),
+    scheduledAction: build('AWS::AutoScaling::ScheduledAction')
+  },
+  certificates: {
+    cert: build('AWS::CertificateManager::Certificate')
+  },
+  cloudFormation: {
+    authentication: build('AWS::CloudFormation::Authentication'),
+    customResource: build('AWS::CloudFormation::CustomResource'),
+    init: build('AWS::CloudFormation::Init'),
+    interface: build('AWS::CloudFormation::Interface'),
+    stack: build('AWS::CloudFormation::Stack'),
+    waitCondition: build('AWS::CloudFormation::WaitCondition'),
+    waitConditionHandle: build('AWS::CloudFormation::WaitConditionHandle')
+  },
+  cloudFront: {
+    dist: build('AWS::CloudFront::Distribution')
+  },
+  cloudTrail: {
+    trail: build('AWS::CloudTrail::Trail')
+  },
+  cloudWatch: {
+    alarm: build('AWS::CloudWatch::Alarm')
+  },
+  codeCommit: {
+    repo: build('AWS::CodeCommit::Repository')
+  },
+  codeDeploy: {
+    application: build('AWS::CodeDeploy::Application'),
+    deploymentConfig: build('AWS::CodeDeploy::DeploymentConfig'),
+    deploymentGroup: build('AWS::CodeDeploy::DeploymentGroup')
+  },
+  codePipeline: {
+    customActionType: build('AWS::CodePipeline::CustomActionType'),
+    pipeline: build('AWS::CodePipeline::Pipeline')
+  },
+  config: {
+    configRule: build('AWS::Config::ConfigRule'),
+    configRecorder: build('AWS::Config::ConfigurationRecorder'),
+    deliveryChannel: build('AWS::Config::DeliveryChannel')
+  },
+  dataPipeline: {
+    pipeline: build('AWS::DataPipeline::Pipeline')
+  },
+  directoryService: {
+    microsoft: build('AWS::DirectoryService::MicrosoftAD'),
+    simple: build('AWS::DirectoryService::SimpleAD')
+  },
+  dynamoDB: {
+    table: build('AWS::DynamoDB::Table')
+  },
   ec2: {
-    securityGroup: function securityGroup(Properties) {
-      return { Type: 'AWS::EC2::SecurityGroup', Properties: Properties };
-    },
-    instance: function instance(Properties) {
-      return { Type: 'AWS::EC2::Instance', Properties: Properties };
-    },
-    elasticIp: function elasticIp(Properties) {
-      return { Type: 'AWS::EC2::EIP', Properties: Properties };
-    },
-    launchConfig: function launchConfig(Properties) {
-      return { Type: 'AWS::AutoScaling::LaunchConfiguration', Properties: Properties };
-    },
-    autoscalingGroup: function autoscalingGroup(Properties) {
-      return { Type: 'AWS::AutoScaling::AutoScalingGroup', Properties: Properties };
-    }
+    elasticIp: build('AWS::EC2::EIP'),
+    elasticIpAssoc: build('AWS::EC2::EIPAssociation'),
+    host: build('AWS::EC2::Host'),
+    instance: build('AWS::EC2::Instance'),
+    networkInterface: build('AWS::EC2::NetworkInterface'),
+    networkInterfaceAttach: build('AWS::EC2::NetworkInterfaceAttachment'),
+    placementGroup: build('AWS::EC2::PlacementGroup'),
+    securityGroup: build('AWS::EC2::SecurityGroup'),
+    securityGroupEgress: build('AWS::EC2::SecurityGroupEgress'),
+    securityGroupIngress: build('AWS::EC2::SecurityGroupIngress'),
+    spotFleet: build('AWS::EC2::SpotFleet'),
+    volume: build('AWS::EC2::Volume'),
+    volumeAttach: build('AWS::EC2::VolumeAttachment'),
+    classicLoadBalancer: build('AWS::ElasticLoadBalancing::LoadBalancer'),
+    appLoadBalancer: build('AWS::ElasticLoadBalancingV2::LoadBalancer'),
+    listener: build('AWS::ElasticLoadBalancingV2::Listener'),
+    listenerRule: build('AWS::ElasticLoadBalancingV2::ListenerRule'),
+    targetGroup: build('AWS::ElasticLoadBalancingV2::TargetGroup')
   },
-  s3: {
-    bucket: function bucket(Properties) {
-      return { Type: 'AWS::S3::Bucket', Properties: Properties };
-    }
+  vpc: {
+    customerGateway: build('AWS::EC2::CustomerGateway'),
+    dhcpOptions: build('AWS::EC2::DHCPOptions'),
+    flowLog: build('AWS::EC2::FlowLog'),
+    internetGateway: build('AWS::EC2::InternetGateway'),
+    natGateway: build('AWS::EC2::NatGateway'),
+    networkAcl: build('AWS::EC2::NetworkAcl'),
+    networkAclEntry: build('AWS::EC2::NetworkAclEntry'),
+    route: build('AWS::EC2::Route'),
+    routeTable: build('AWS::EC2::RouteTable'),
+    subnet: build('AWS::EC2::Subnet'),
+    subnetNetworkAclAssoc: build('AWS::EC2::SubnetNetworkAclAssociation'),
+    subnetRouteTableAssoc: build('AWS::EC2::SubnetRouteTableAssociation'),
+    vpc: build('AWS::EC2::VPC'),
+    dhcpOptionsAssoc: build('AWS::EC2::VPCDHCPOptionsAssociation'),
+    endpoint: build('AWS::EC2::VPCEndpoint'),
+    gatewayAttach: build('AWS::EC2::VPCGatewayAttachment'),
+    peeringConnection: build('AWS::EC2::VPCPeeringConnection'),
+    vpcConnection: build('AWS::EC2::VPNConnection'),
+    vpcConnectionRoute: build('AWS::EC2::VPNConnectionRoute'),
+    vpnGateway: build('AWS::EC2::VPNGateway'),
+    vpnGatewayRouteProp: build('AWS::EC2::VPNGatewayRoutePropagation')
   },
-  route53: {
-    recordGroup: function recordGroup(Properties) {
-      return { Type: 'AWS::Route53::RecordSetGroup', Properties: Properties };
-    },
-    record: function record(Properties) {
-      return { Type: 'AWS::Route53::RecordSet', Properties: Properties };
-    }
+  ecr: {
+    repo: build('AWS::ECR::Repository')
   },
   ecs: {
-    cluster: function cluster(Properties) {
-      return { Type: 'AWS::ECS::Cluster', Properties: Properties };
-    },
-    taskDefinition: function taskDefinition(Properties) {
-      return { Type: 'AWS::ECS::TaskDefinition', Properties: Properties };
-    }
+    cluster: build('AWS::ECS::Cluster'),
+    service: build('AWS::ECS::Service'),
+    taskDefinition: build('AWS::ECS::TaskDefinition')
   },
-  lambda: {
-    func: function func(Properties) {
-      return { Type: 'AWS::Lambda::Function', Properties: Properties };
-    }
+  efs: {
+    fileSystem: build('AWS::EFS::FileSystem'),
+    mountTarget: build('AWS::EFS::MountTarget')
   },
+  elasticache: {
+    cluster: build('AWS::ElastiCache::CacheCluster'),
+    parameterGroup: build('AWS::ElastiCache::ParameterGroup'),
+    replicationGroup: build('AWS::ElastiCache::ReplicationGroup'),
+    securityGroup: build('AWS::ElastiCache::SecurityGroup'),
+    securityGroupIngress: build('AWS::ElastiCache::SecurityGroupIngress'),
+    subnetGroup: build('AWS::ElastiCache::SubnetGroup')
+  },
+  beanstalk: {
+    app: build('AWS::ElasticBeanstalk::Application'),
+    appVersion: build('AWS::ElasticBeanstalk::ApplicationVersion'),
+    configTemplate: build('AWS::ElasticBeanstalk::ConfigurationTemplate'),
+    environment: build('AWS::ElasticBeanstalk::Environment')
+  },
+  elasticsearch: {
+    domain: build('AWS::Elasticsearch::Domain')
+  },
+  emr: {
+    cluster: build('AWS::EMR::Cluster'),
+    instanceGroupConfig: build('AWS::EMR::InstanceGroupConfig'),
+    step: build('AWS::EMR::Step')
+  },
+  events: {
+    rule: build('AWS::Events::Rule')
+  },
+  gameLift: {
+    alias: build('AWS::GameLift::Alias'),
+    build: build('AWS::GameLift::Build'),
+    fleet: build('AWS::GameLift::Fleet')
+  },
   iam: {
-    role: function role(Properties) {
-      return { Type: 'AWS::IAM::Role', Properties: Properties };
-    },
-    instanceProfile: function instanceProfile(Properties) {
-      return { Type: 'AWS::IAM::InstanceProfile', Properties: Properties };
-    }
+    accessKey: build('AWS::IAM::AccessKey'),
+    group: build('AWS::IAM::Group'),
+    instanceProfile: build('AWS::IAM::InstanceProfile'),
+    managedPolicy: build('AWS::IAM::ManagedPolicy'),
+    policy: build('AWS::IAM::Policy'),
+    role: build('AWS::IAM::Role'),
+    user: build('AWS::IAM::User'),
+    userToGroupAddition: build('AWS::IAM::UserToGroupAddition')
   },
-  cloudwatch: {
-    logGroup: function logGroup(Properties) {
-      return { Type: 'AWS::Logs::LogGroup', Properties: Properties };
-    }
+  iot: {
+    cert: build('AWS::IoT::Certificate'),
+    policy: build('AWS::IoT::Policy'),
+    policyPrincipalAttach: build('AWS::IoT::PolicyPrincipalAttachment'),
+    thing: build('AWS::IoT::Thing'),
+    thingPrincipalAttach: build('AWS::IoT::ThingPrincipalAttachment'),
+    topicRule: build('AWS::IoT::TopicRule')
+  },
+  kinesis: {
+    stream: build('AWS::Kinesis::Stream'),
+    deliveryStream: build('AWS::KinesisFirehose::DeliveryStream')
+  },
+  kms: {
+    alias: build('AWS::KMS::Alias'),
+    key: build('AWS::KMS::Key')
+  },
+  lambda: {
+    eventSourceMapping: build('AWS::Lambda::EventSourceMapping'),
+    alias: build('AWS::Lambda::Alias'),
+    function: build('AWS::Lambda::Function'),
+    permission: build('AWS::Lambda::Permission'),
+    version: build('AWS::Lambda::Version')
+  },
+  logs: {
+    destination: build('AWS::Logs::Destination'),
+    logGroup: build('AWS::Logs::LogGroup'),
+    logStream: build('AWS::Logs::LogStream'),
+    metricFilter: build('AWS::Logs::MetricFilter'),
+    subscriptionFilter: build('AWS::Logs::SubscriptionFilter')
+  },
+  opsworks: {
+    app: build('AWS::OpsWorks::App'),
+    elasticLoadBalancerAttach: build('AWS::OpsWorks::ElasticLoadBalancerAttachment'),
+    instance: build('AWS::OpsWorks::Instance'),
+    layer: build('AWS::OpsWorks::Layer'),
+    stack: build('AWS::OpsWorks::Stack')
+  },
+  rds: {
+    cluster: build('AWS::RDS::DBCluster'),
+    clusterParameterGroup: build('AWS::RDS::DBClusterParameterGroup'),
+    instance: build('AWS::RDS::DBInstance'),
+    dbParameterGroup: build('AWS::RDS::DBParameterGroup'),
+    securityGroup: build('AWS::RDS::DBSecurityGroup'),
+    securityGroupIngress: build('AWS::RDS::DBSecurityGroupIngress'),
+    subnetGroup: build('AWS::RDS::DBSubnetGroup'),
+    eventSubscription: build('AWS::RDS::EventSubscription'),
+    optionGroup: build('AWS::RDS::OptionGroup')
+  },
+  redshift: {
+    cluster: build('AWS::Redshift::Cluster'),
+    parameterGroup: build('AWS::Redshift::ClusterParameterGroup'),
+    securityGroup: build('AWS::Redshift::ClusterSecurityGroup'),
+    securityGroupIngress: build('AWS::Redshift::ClusterSecurityGroupIngress'),
+    subnetGroup: build('AWS::Redshift::ClusterSubnetGroup')
+  },
+  route53: {
+    healthCheck: build('AWS::Route53::HealthCheck'),
+    hostedZone: build('AWS::Route53::HostedZone'),
+    recordSet: build('AWS::Route53::RecordSet'),
+    recordSetGroup: build('AWS::Route53::RecordSetGroup')
+  },
+  s3: {
+    bucket: build('AWS::S3::Bucket'),
+    bucketPolicy: build('AWS::S3::BucketPolicy')
+  },
+  sdb: {
+    domain: build('AWS::SDB::Domain')
+  },
+  sns: {
+    topic: build('AWS::SNS::Topic'),
+    policy: build('AWS::SNS::TopicPolicy')
+  },
+  sqs: {
+    queue: build('AWS::SQS::Queue'),
+    policy: build('AWS::SQS::QueuePolicy')
+  },
+  ssm: {
+    document: build('AWS::SSM::Document')
+  },
+  waf: {
+    byteMatchSet: build('AWS::WAF::ByteMatchSet'),
+    ipSet: build('AWS::WAF::IPSet'),
+    rule: build('AWS::WAF::Rule'),
+    sizeConstraintSet: build('AWS::WAF::SizeConstraintSet'),
+    sqlInjectionMatchSet: build('AWS::WAF::SqlInjectionMatchSet'),
+    webACL: build('AWS::WAF::WebACL'),
+    xssMatchSet: build('AWS::WAF::XssMatchSet')
+  },
+  workspaces: {
+    workspace: build('AWS::WorkSpaces::Workspace')
   }
 };

package.json

 {
   "name": "axe",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Painlessly create AWS CloudFormation stacks",
@@ -44,2 +44,3 @@ "author": "Jason Maurer",
     "dotenv": "2.0.0",
+    "inquirer": "1.2.1",
     "minimist": "1.2.0",
@@ -50,2 +51,3 @@ "update-notifier": "1.0.2"
     "babel-cli": "6.16.0",
+    "babel-plugin-transform-object-rest-spread": "6.16.0",
     "babel-preset-es2015": "6.16.0",
@@ -59,4 +61,7 @@ "npm-run-all": "3.1.0",
       "es2015"
+    ],
+    "plugins": [
+      "transform-object-rest-spread"
     ]
   }
 }

No alert changes

Improved metrics

Total package byte prevSize

21797

increased by64.52%

Lines of code

504

increased by73.79%

Worsened metrics

Dependency count

5

increased by25%

Dev dependency count

6

increased by20%

Dependency changes

• + Addedinquirer@1.2.1

• + Addedansi-escapes@1.4.0(transitive)

• + Addedbuffer-from@1.1.2(transitive)

• + Addedcli-cursor@1.0.2(transitive)

• + Addedcli-width@2.2.1(transitive)

• + Addedconcat-stream@1.6.2(transitive)

• + Addedexit-hook@1.1.1(transitive)

• + Addedextend@3.0.2(transitive)

• + Addedexternal-editor@1.1.1(transitive)

• + Addedfigures@1.7.0(transitive)

• + Addedinquirer@1.2.1(transitive)

• + Addedlodash@4.17.21(transitive)

• + Addedmute-stream@0.0.6(transitive)

• + Addedonetime@1.1.0(transitive)

• + Addedos-shim@0.1.3(transitive)

• + Addedrestore-cursor@1.0.1(transitive)

• + Addedrun-async@2.4.1(transitive)

• + Addedrx@4.1.0(transitive)

• + Addedspawn-sync@1.0.15(transitive)

• + Addedthrough@2.3.8(transitive)

• + Addedtmp@0.0.29(transitive)

• + Addedtypedarray@0.0.6(transitive)