presidium 0.15.36 → 0.16.0

package/AutoScaling.js

@@ -0,0 +1,117 @@
+const rubico = require('rubico')
+const AWSAutoscaling = require('aws-sdk/clients/autoscaling')
+const AWSAutoScalingDescribeAutoScalingGroupsFilters =
+  require('./internal/AWSAutoScalingDescribeAutoScalingGroupsFilters')
+const filterExistsAndNotEmpty = require('./internal/filterExistsAndNotEmpty')
+const filterExists = require('./internal/filterExists')
+
+const {
+  pipe, tap,
+  switchCase, tryCatch,
+  fork, assign, get, set, pick, omit,
+  map, filter, reduce, transform, flatMap,
+  and, or, not, any, all,
+  eq, gt, lt, gte, lte,
+  thunkify, always,
+  curry, __,
+} = rubico
+
+/**
+ * @name AutoScaling
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new AutoScaling(options {
+ *   ...({
+ *     accessKeyId: string,
+ *     secretAccessKey: string,
+ *     region: string,
+ *   })|({
+ *     endpoint: string,
+ *     region: string,
+ *   })
+ * }) -> AutoScaling object
+ * ```
+ */
+const AutoScaling = function (options) {
+  this.awsAutoScaling = new AWSAutoscaling({
+    apiVersion: '2011-01-01',
+    ...pick([
+      'accessKeyId',
+      'secretAccessKey',
+      'region',
+      'endpoint',
+    ])(options),
+  })
+  return this
+}
+
+/**
+ * @name AutoScaling.prototype.listAutoScalingGroups
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * import AutoScalingListGroupsDescribeFilterOptions
+ *   from './internal/AutoScalingListGroupsDescribeFilterOptions.ss'
+ *
+ * new AutoScaling(...).listAutoScalingGroups(options? {
+ *   ...AutoScalingListGroupsDescribeFilterOptions.map(value => value|Array<value>),
+ *   limit?: 5-100, // default 100
+ *   nextToken?: string, // last result's NextToken
+ * }) -> Promise<{
+ *   AutoScalingGroups: Array<{
+ *     AutoScalingGroupName: string, // 'presidium-test'
+ *     AutoScalingGroupARN: string, // 'arn:aws:autoscaling:us-west-1:095798571722:autoScalingGroup:934690c8-d95d-46be-ac49-54950de41ef5:autoScalingGroupName/presidium-test'
+ *     LaunchTemplate: Object,
+ *     MinSize: number, // 1
+ *     MaxSize: number, // 1
+ *     DesiredCapacity: number, // 1
+ *     DefaultCooldown: number, // 300
+ *     AvailabilityZones: Array,
+ *     LoadBalancerNames: Array,
+ *     TargetGroupARNs: Array,
+ *     HealthCheckType: string, // 'EC2'
+ *     HealthCheckGracePeriod: number, // 300
+ *     Instances: Array,
+ *     CreatedTime: Date, // 2022-04-28T20:26:13.289Z
+ *     SuspendedProcesses: Array,
+ *     VPCZoneIdentifier: string, // 'subnet-916bb8f7,subnet-677c933d'
+ *     EnabledMetrics: Array,
+ *     Tags: Array,
+ *     TerminationPolicies: Array,
+ *     NewInstancesProtectedFromScaleIn: boolean,
+ *     ServiceLinkedRoleARN: string, // 'arn:aws:iam::095798571722:role/aws-service-role/autoscaling.amazonaws.com/AWSServiceRoleForAutoScaling'
+ *   }>,
+ *   NextToken: string|null,
+ * }>
+ * ```
+ */
+AutoScaling.prototype.listAutoScalingGroups = function (options = {}) {
+  return this.awsAutoScaling.describeAutoScalingGroups(filterExistsAndNotEmpty({
+    Filters: AWSAutoScalingDescribeAutoScalingGroupsFilters(options),
+    MaxRecords: options.limit ?? 100,
+    NextToken: options.nextToken,
+  })).promise()
+}
+
+/**
+ * @name AutoScaling.prototype.setDesiredCapacity
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new AutoScaling(...).setDesiredCapacity(options {
+ *   autoScalingGroupName: string,
+ *   desiredCapacity: number,
+ *   honorCooldown?: boolean, // whether Amazon EC2 Auto Scaling waits for the cooldown period to complete before initializing a scaling activity to set your Auto Scaling group to its new capacity, default false
+ * }) -> Promise<{}>
+ * ```
+ */
+AutoScaling.prototype.setDesiredCapacity = function (options) {
+  return this.awsAutoScaling.setDesiredCapacity(filterExists({
+    AutoScalingGroupName: options.autoScalingGroupName,
+    DesiredCapacity: options.desiredCapacity,
+    HonorCooldown: options.honorCooldown,
+  })).promise()
+}
+
+module.exports = AutoScaling

package/AutoScaling.test.js

@@ -0,0 +1,57 @@
+const Test = require('thunk-test')
+const assert = require('assert')
+const AwsCredentials = require('./internal/AwsCredentials')
+const AutoScaling = require('./AutoScaling')
+
+const test = new Test('AutoScaling', async function () {
+  const awsCreds = await AwsCredentials('default').catch(error => {
+    if (error.code == 'ENOENT') {
+      const accessKeyId = process.env.AWS_ACCESS_KEY_ID
+      const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY
+      if (accessKeyId == null || secretAccessKey == null) {
+        throw new Error('No AWS credential file or environment variables')
+      }
+      return { accessKeyId, secretAccessKey }
+    }
+    throw error
+  })
+  awsCreds.region = 'us-west-1'
+
+  const autoScaling = new AutoScaling({
+    ...awsCreds,
+  })
+
+  // there is one auto scaling group named presidium-test with one ec2 instance in this region
+
+  { // listInstances all instances
+    const response = await autoScaling.listAutoScalingGroups()
+    assert(
+      response.AutoScalingGroups.map(group => group.AutoScalingGroupName).includes('presidium-test'),
+      'There is no presidium-test autoscaling group, check the aws account'
+    )
+    assert.equal(response.NextToken, null)
+  }
+
+  { // listAutoScalingGroups with tag
+    const response = await autoScaling.listAutoScalingGroups({
+      'tag:Env': 'test',
+    })
+    assert(
+      response.AutoScalingGroups.map(group => group.AutoScalingGroupName).includes('presidium-test'),
+      'There is no presidium-test autoscaling group, check the aws account'
+    )
+    assert.equal(response.NextToken, null)
+  }
+
+  // setDesiredCapacity (errors if not auto scaling group not found)
+  await autoScaling.setDesiredCapacity({
+    autoScalingGroupName: 'presidium-test',
+    desiredCapacity: 1,
+  })
+}).case()
+
+if (process.argv[1] == __filename) {
+  test()
+}
+
+module.exports = test

package/EC2.js

@@ -0,0 +1,181 @@
+const rubico = require('rubico')
+const AWSEC2 = require('aws-sdk/clients/ec2')
+const AWSEC2DescribeInstancesFilters = require('./internal/AWSEC2DescribeInstancesFilters.js')
+const filterExistsAndNotEmpty = require('./internal/filterExistsAndNotEmpty')
+
+const {
+  pipe, tap,
+  switchCase, tryCatch,
+  fork, assign, get, set, pick, omit,
+  map, filter, reduce, transform, flatMap,
+  and, or, not, any, all,
+  eq, gt, lt, gte, lte,
+  thunkify, always,
+  curry, __,
+} = rubico
+
+/**
+ * @name EC2
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * new EC2(options {
+ *   ...({
+ *     accessKeyId: string,
+ *     secretAccessKey: string,
+ *     region: string,
+ *   })|({
+ *     endpoint: string,
+ *     region: string,
+ *   })
+ * }) -> EC2
+ * ```
+ *
+ * @description
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/EC2.html
+ */
+const EC2 = function (options) {
+  this.awsEc2 = new AWSEC2({
+    apiVersion: '2016-11-15',
+    ...pick([
+      'accessKeyId',
+      'secretAccessKey',
+      'region',
+      'endpoint',
+    ])(options),
+  })
+  return this
+}
+
+/**
+ * @name EC2.prototype.listInstances
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * import EC2ListInstancesDescribeFilterOptions from './internal/EC2ListInstancesDescribeFilterOptions.ss'
+ *
+ * new EC2(...).listInstances(options? {
+ *   ...EC2ListInstancesDescribeFilterOptions.map(value => value|Array<value>),
+ *   limit?: 5-1000, // default 1000
+ *   nextToken?: string, // last result's NextToken
+ * }) -> Promise<{
+ *   Instances: Array<{
+ *     InstanceId: string,
+ *     AmiLaunchIndex: number, // 0
+ *     ImageId: string, // 'ami-09625adacc474a7b4'
+ *     InstanceId: 'i-04a9d2103428c73c0'
+ *     InstanceType: string, // 't2.micro'
+ *     KeyName: string, // 'solumlibs-test'
+ *     LaunchTime: Date, // 2022-04-28T17:08:41.000Z
+ *     Monitoring: {
+ *       State: string, // 'disabled'
+ *     },
+ *     Placement: {
+ *       AvailabilityZone: string, // 'us-west-1a'
+ *       GroupName: string, // ''
+ *       Tenancy: string, // 'default'
+ *     },
+ *     PrivateDnsName: string, // 'ip-172-31-31-44.us-west-1.compute.internal'
+ *     PrivateIpAddress: string, // '172.31.31.44'
+ *     ProductCodes: Array<string>,
+ *     PublicDnsName: string, // 'ec2-3-101-88-163.us-west-1.compute.amazonaws.com'
+ *     PublicIpAddress: string, // '3.101.88.163'
+ *     State: {
+ *       Code: number, // 16
+ *       Name: string, // 'running'
+ *     },
+ *     StateTransitionReason: string,
+ *     SubnetId: string, // 'subnet-916bb8f7'
+ *     VpcId: string, // 'vpc-9c42a2fa'
+ *     Architecture: string, // 'x86_64'
+ *     BlockDeviceMappings: Array<Object>,
+ *     ClientToken: string,
+ *     EbsOptimized: boolean,
+ *     EnaSupport: boolean,
+ *     Hypervisor: string, // 'xen'
+ *     ElasticGpuAssociations: Array,
+ *     ElasticInferenceAcceleratorAssociations: Array,
+ *     NetworkInterfaces: Array<Object>,
+ *     RootDeviceName: string, // '/dev/xvda'
+ *     RootDeviceType: string, // 'ebs'
+ *     SecurityGroups: Array<Object>,
+ *     SourceDestCheck: boolean,
+ *     Tags: Array<Object>,
+ *     VirtualizationType: string, // 'hvm'
+ *     CpuOptions: {
+ *       CoreCount: number, // 1
+ *       ThreadsPerCore: number, // 1
+ *     },
+ *     CapacityReservationSpecification: {
+ *       CapacityReservationPreference: string, // 'open'
+ *     },
+ *     HibernationOptions: {
+ *       Configured: boolean, // false
+ *     },
+ *     Licenses: [],
+ *     MetadataOptions: {
+ *       State: string, // 'applied'
+ *       HttpTokens: string, // 'optional'
+ *       HttpPutResponseHopLimit: number, // 1
+ *       HttpEndpoint: string, // 'enabled'
+ *     },
+ *     EnclaveOptions: {
+ *       Enabled: boolean, // false
+ *     },
+ *     AvailabilityZone: string, // 'us-west-1a'
+ *     Events: Array,
+ *     InstanceState: {
+ *       Code: number, // 16
+ *       Name: string, // 'running'
+ *     },
+ *     InstanceStatus: {
+ *       Details: Array,
+ *       Status: string, // 'ok'
+ *     },
+ *     SystemStatus: {
+ *       Details: Array,
+ *       Status: string, // 'ok'
+ *     }
+ *   }>,
+ *   NextToken: string|null,
+ * }>
+ * ```
+ */
+
+EC2.prototype.listInstances = async function (options = {}) {
+  const {
+    Reservations: reservations,
+    NextToken: nextToken,
+  } = await this.awsEc2.describeInstances(filterExistsAndNotEmpty({
+    Filters: AWSEC2DescribeInstancesFilters(options),
+    MaxResults: options.limit ?? 1000,
+    NextToken: options.nextToken,
+  })).promise()
+
+  const instances = reservations.flatMap(get('Instances'))
+  const instanceIds = instances.map(get('InstanceId'))
+
+  const instanceIdStatusMap = new Map()
+  let instanceIndex = 0
+  while (instanceIndex < instanceIds.length) {
+    const { InstanceStatuses: instanceStatuses } =
+      await this.awsEc2.describeInstanceStatus({
+        InstanceIds: instanceIds.slice(instanceIndex, (instanceIndex += 100)),
+      }).promise()
+    for (const instanceStatus of instanceStatuses) {
+      instanceIdStatusMap.set(instanceStatus.InstanceId, instanceStatus)
+    }
+  }
+
+  const instancesWithStatusFields = instances.map(instance => ({
+    ...instance,
+    ...instanceIdStatusMap.get(instance.InstanceId),
+  }))
+
+  return {
+    Instances: instancesWithStatusFields,
+    NextToken: nextToken,
+  }
+}
+
+module.exports = EC2

package/EC2.test.js

@@ -0,0 +1,48 @@
+const Test = require('thunk-test')
+const assert = require('assert')
+const AwsCredentials = require('./internal/AwsCredentials')
+const EC2 = require('./EC2')
+
+const test = new Test('EC2', async function () {
+  const awsCreds = await AwsCredentials('default').catch(error => {
+    if (error.code == 'ENOENT') {
+      const accessKeyId = process.env.AWS_ACCESS_KEY_ID
+      const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY
+      if (accessKeyId == null || secretAccessKey == null) {
+        throw new Error('No AWS credential file or environment variables')
+      }
+      return { accessKeyId, secretAccessKey }
+    }
+    throw error
+  })
+  awsCreds.region = 'us-west-1'
+
+  const ec2 = new EC2({
+    ...awsCreds,
+  })
+
+  // there is one test instance in this region
+
+  { // listInstances all instances
+    const response = await ec2.listInstances()
+    assert(
+      response.Instances.filter(instance => instance.State.Name == 'running').length == 1,
+      'There is not a running instance, check the aws account'
+    )
+    assert.equal(response.NextToken, null)
+  }
+
+  { // listInstances with tag
+    const response = await ec2.listInstances({
+      'tag:Env': 'test',
+    })
+    assert.equal(response.Instances.length, 1)
+    assert.equal(response.NextToken, null)
+  }
+}).case()
+
+if (process.argv[1] == __filename) {
+  test()
+}
+
+module.exports = test

package/internal/AWSAutoScalingDescribeAutoScalingGroupsFilters.js

@@ -0,0 +1,46 @@
+const rubico = require('rubico')
+const filterExists = require('./filterExists')
+const objectFilterKeys = require('./objectFilterKeys')
+const toArray = require('./toArray')
+
+const {
+  pipe, tap,
+  switchCase, tryCatch,
+  fork, assign, get, set, pick, omit,
+  map, filter, reduce, transform, flatMap,
+  and, or, not, any, all,
+  eq, gt, lt, gte, lte,
+  thunkify, always,
+  curry, __,
+} = rubico
+
+/**
+ * @name AWSAutoScalingDescribeAutoScalingGroupsFilters
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * import AutoScalingListGroupsDescribeFilterOptions
+ *   from './AutoScalingListGroupsDescribeFilterOptions.ss'
+ *
+ * AWSAutoScalingDescribeAutoScalingGroupsFilters(
+ *   options AutoScalingListGroupsDescribeFilterOptions
+ * ) -> awsAutoScalingDescribeAutoScalingGroupsFilters Array<{ Name: string, Values: Array }>
+ * ```
+ */
+const AWSAutoScalingDescribeAutoScalingGroupsFilters = pipe([
+  options => ({
+    'tag-key': options.tagKey,
+    'tag-value': options.tagValue,
+    ...objectFilterKeys(options, key => key.startsWith('tag:')),
+  }),
+  filterExists,
+  options => {
+    const filters = []
+    for (const name in options) {
+      filters.push({ Name: name, Values: toArray(options[name]) })
+    }
+    return filters
+  },
+])
+
+module.exports = AWSAutoScalingDescribeAutoScalingGroupsFilters

package/internal/AWSEC2DescribeInstancesFilters.js

@@ -0,0 +1,151 @@
+const rubico = require('rubico')
+const filterExists = require('./filterExists')
+const objectFilterKeys = require('./objectFilterKeys')
+const toArray = require('./toArray')
+
+const {
+  pipe, tap,
+  switchCase, tryCatch,
+  fork, assign, get, set, pick, omit,
+  map, filter, reduce, transform, flatMap,
+  and, or, not, any, all,
+  eq, gt, lt, gte, lte,
+  thunkify, always,
+  curry, __,
+} = rubico
+
+/**
+ * @name AWSEC2DescribeInstancesFilters
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * import EC2ListInstancesDescribeFilterOptions from './EC2ListInstancesDescribeFilterOptions.ss'
+ *
+ * AWSEC2DescribeInstancesFilters(
+ *   options EC2ListInstancesDescribeFilterOptions.map(value => value|Array<value>)
+ * ) -> awsEC2DescribeInstancesFilters Array<{ Name: string, Values: Array }>
+ * ```
+ */
+const AWSEC2DescribeInstancesFilters = pipe([
+  options => ({
+    'affinity': options.affinity,
+    'architecture': options.architecture,
+    'availability-zone': options.availabilityZone,
+    'block-device-mapping.attach-time': options.blockDeviceMappingAttachTime,
+    'block-device-mapping.delete-on-termination':
+      options.blockDeviceMappingDeleteOnTermination,
+    'block-device-mapping.device-name': options.blockDeviceMappingDeviceName,
+    'block-device-mapping.status': options.blockDeviceMappingStatus,
+    'block-device-mapping.volume-id': options.blockDeviceMappingVolumeId,
+    'capacity-reservation-id': options.capacityReservationId,
+    'client-token': options.clientToken,
+    'dns-name': options.dnsName,
+    'hibernation-options.configured': options.hibernationOptionsConfigured,
+    'host-id': options.hostId,
+    'hypervisor': options.hypervisor,
+    'iam-instance-profile.arn': options.iamInstanceProfileArn,
+    'image-id': options.imageId,
+    'instance-id': options.instanceId,
+    'instance-lifecycle': options.instanceLifecycle,
+    'instance-state-code': options.instanceStateCode,
+    'instance-state-name': options.instanceStateName,
+    'instance-type': options.instanceType,
+    'instance.group-id': options.instanceGroupId,
+    'instance.group-name': options.instanceGroupName,
+    'ip-address': options.ipAddress,
+    'kernel-id': options.kernelId,
+    'key-name': options.keyName,
+    'launch-index': options.launchIndex,
+    'launch-time': options.launchTime,
+    'metadata-options.http-tokens': options.metadataOptionsHttpTokens,
+    'metadata-options.http-put-response-hop-limit':
+      options.metadataOptionsHttpPutResponseHopLimit,
+    'metadata-options.http-endpoint': options.metadataOptionsHttpEndpoint,
+    'monitoring-state': options.monitoringState,
+    'network-interface.addresses.private-ip-address':
+      options.networkInterfaceAddressesPrivateIpAddress,
+    'network-interface.addresses.primary':
+      options.networkInterfaceAddressesPrimary,
+    'network-interface.addresses.association.public-ip':
+      options.networkInterfaceAddressesAssociationPublicIp,
+    'network-interface.addresses.association.ip-owner-id':
+      options.networkInterfaceAddressesAssociationIpOwnerId,
+    'network-interface.association.public-ip':
+      options.networkInterfaceAssociationPublicIp,
+    'network-interface.association.ip-owner-id':
+      options.networkInterfaceAssociationIpOwnerId,
+    'network-interface.association.allocation-id':
+      options.networkInterfaceAssociationAllocationId,
+    'network-interface.association.association-id':
+      options.networkInterfaceAssociationId,
+    'network-interface.attachment.attachment-id':
+      options.networkInterfaceAttachmentId,
+    'network-interface.attachment.instance-id':
+      options.networkInterfaceAttachmentInstanceId,
+    'network-interface.attachment.instance-owner-id':
+      options.networkInterfaceAttachmentInstanceOwnerId,
+    'network-interface.attachment.device-index':
+      options.networkInterfaceAttachmentDeviceIndex,
+    'network-interface.attachment.status':
+      options.networkInterfaceAttachmentStatus,
+    'network-interface.attachment.attach-time':
+      options.networkInterfaceAttachTime,
+    'network-interface.attachment.delete-on-termination':
+      options.networkInterfaceAttachmentDeleteOnTermination,
+    'network-interface.availability-zone':
+      options.networkInterfaceAvailabilityZone,
+    'network-interface.description': options.networkInterfaceDescription,
+    'network-interface.group-id': options.networkInterfaceGroupId,
+    'network-interface.group-name': options.networkInterfaceGroupName,
+    'network-interface.ipv6-addresses.ipv6-address':
+      options.networkInterfaceIpv6Address,
+    'network-interface.mac-address': options.networkInterfaceMacAddress,
+    'network-interface.network-interface-id': options.networkInterfaceId,
+    'network-interface.owner-id': options.networkInterfaceOwnerId,
+    'network-interface.private-dns-name':
+      options.networkInterfacePrivateDnsName,
+    'network-interface.requester-id': options.networkInterfaceRequesterId,
+    'network-interface.requester-managed':
+      options.networkInterfaceRequesterManaged,
+    'network-interface.status': options.networkInterfaceStatus,
+    'network-interface.source-dest-check':
+      options.networkInterfaceSourceDestCheck,
+    'network-interface.subnet-id': options.networkInterfaceSubnetId,
+    'network-interface.vpc-id': options.networkInterfaceVpcId,
+    'outpost-arn': options.outpostArn,
+    'owner-id': options.ownerId,
+    'placement-group-name': options.placementGroupName,
+    'placement-partition-number': options.placementPartitionNumber,
+    'platform': options.platform,
+    'private-dns-name': options.privateDnsName,
+    'private-ip-address': options.privateIpAddress,
+    'product-code': options.productCode,
+    'product-code.type': options.productCodeType,
+    'ramdisk-id': options.ramdiskId,
+    'reason': options.reason,
+    'requester-id': options.requesterId,
+    'reservation-id': options.reservationId,
+    'root-device-name': options.rootDeviceName,
+    'root-device-type': options.rootDeviceType,
+    'source-dest-check': options.sourceDestCheck,
+    'spot-instance-request-id': options.spotInstanceRequestId,
+    'state-reason-code': options.stateReasonCode,
+    'state-reason-message': options.stateReasonMessage,
+    'subnet-id': options.subnetId,
+    'tag-key': options.tagKey,
+    'tenancy': options.tenancy,
+    'virtualization-type': options.virtualizationType,
+    'vpc-id': options.vpcId,
+    ...objectFilterKeys(options, key => key.startsWith('tag:')),
+  }),
+  filterExists,
+  options => {
+    const filters = []
+    for (const name in options) {
+      filters.push({ Name: name, Values: toArray(options[name]) })
+    }
+    return filters
+  },
+])
+
+module.exports = AWSEC2DescribeInstancesFilters

package/internal/AutoScalingListGroupsDescribeFilterOptions.ss

@@ -0,0 +1,7 @@
+AutoScalingListGroupsDescribeFilterOptions {
+  tagKey?: string, // filter by tag keys
+  tagValue?: string, // filter tag values
+  `tag:${key string}`?: string, // filter by the specified tag key/value pairs
+}
+
+export default AutoScalingListGroupsDescribeFilterOptions

package/internal/EC2ListInstancesDescribeFilterOptions.ss

@@ -0,0 +1,91 @@
+EC2FindInstancesDescribeFilterOptions {
+  affinity?: 'default'|'host',
+  architecture?: 'i386'|'x86_64'|'arm64',
+  availabilityZone?: string,
+  blockDeviceMappingAttachTime?: string, // e.g. '2010-09-15T17:15:20.000Z'
+  blockDeviceMappingDeleteOnTermination?: boolean, // whether EBS volume is deleted on instance termination
+  blockDeviceMappingDeviceName?: string, // device name specified in the block mapping e.g. /dev/sdh or xvdh
+  blockDeviceMappingStatus?: 'attaching'|'attached'|'detaching'|'detached',
+  blockDeviceMappingVolumeId?: string, // volume ID of the EBS volume
+  capacityReservationId?: string, // ID of the Capacity Reservation into which the instance was launched
+  clientToken?: string, // idempotency token you provided when you launched the instance
+  dnsName?: string, // public DNS name of the instance
+  hibernationOptionsConfigured?: boolean, // whether instance is enabled for hibernation
+  hostId?: string, // ID of the dedicated host on which the instance is running
+  hypervisor?: 'ovm'|'xen', // 'xen' is used for both Xen and Nitro hypervisors
+  iamInstanceProfileArn?: string, // ARN of the instance profile associated with the instance
+  imageId?: string, // ID of the image used to launch the instance 
+  instanceId?: string, // ID of the instance
+  instanceLifecycle?: 'spot'|'scheduled', // whether this is a Spot or Scheduled instance
+  instanceStateCode?: 0|16|32|48|64|80, // state of the instance as a 16 bit unsigned int: 0 - pending; 16 - running; 32 - shutting-down; 48 - terminated; 64 - stopping; 80 - stopped
+  instanceStateName?: 'pending'|'running'|'shutting-down'|'terminated'|'stopping'|'stopped', // state of the instance
+  instanceType?: string, // type of the instance, e.g. 't2.micro'
+  instanceGroupId?: string, // ID of the security group for the instance
+  instanceGroupName?: string, // name of the security group for the instance
+  ipAddress?: string, // public IPv4 address of the instance
+  kernelId?: string, // kernel ID
+  keyName?: string, // name of the key pair used when the instance was launched
+  launchIndex?: number, // when launching multiple instances, index for the instance in the launch group e.g. 0, 1, 2
+  launchTime?: string, // time when the instance was launched in ISO 8601 format in UTC (YYYY-MM-DDThh:mm:ss.sssZ). Wildcard `*` (2021-09-29T*) matches an entire day
+  metadataOptionsHttpTokens?: 'optional'|'required', // metadata request authorization state
+  metadataOptionsHttpPutResponseHopLimit?: 1-64, // http metadata request put response hop limit
+  metadataOptionsHttpEndpoint?: 'enabled'|'disabled', // enable or disable metadata access on http endpoint
+  monitoringState?: 'enabled'|'disabled', // whether detailed monitoring is enabled
+  networkInterfaceAddressesPrivateIpAddress?: string, // private IPv4 address associated with the network interface
+  networkInterfaceAddressesPrimary?: boolean, // whether the IPv4 address of the network interface is the primary private IPv4 address
+  networkInterfaceAddressesAssociationPublicIp?: string, // ID of the association of an IPv4 Elastic IP Address with a network interface
+  networkInterfaceAddressesAssociationIpOwnerId?: string, // owner ID of the private IPv4 address associated with the network interface
+  networkInterfaceAssociationPublicIp?: string, // address of the Elastic IPv4 address bound to the network interface
+  networkInterfaceAssociationIpOwnerId?: string, // ownern of the Elastic IPv4 address associated with the network interface
+  networkInterfaceAssociationAllocationId?: string, // allocation ID returned when you allocated the IPv4 Elastic IP Address for your network interface
+  networkInterfaceAssociationId?: string, // association ID returned when the network interface was associated with an IPv4 address
+  networkInterfaceAttachmentId?: string, // ID of the interface attachment
+  networkInterfaceAttachmentInstanceId?: string, // ID of the instance to which the network interface is attached
+  networkInterfaceAttachmentInstanceOwnerId?: string, // owner ID of the instance to which the network interface is attached
+  networkInterfaceAttachmentDeviceIndex?: number, // device index to which the network interface is attached
+  networkInterfaceAttachmentStatus?: 'attaching'|'attached'|'detaching'|'detached',
+  networkInterfaceAttachTime?: string, // ISO 8601 string for time when network interface was attached to an instance
+  networkInterfaceAttachmentDeleteOnTermination?: boolean, // whether the attachment is deleted when an instance is terminated
+  networkInterfaceAvailabilityZone?: string, // Availability Zone of the network interface
+  networkInterfaceDescription?: string, // description of the network interface
+  networkInterfaceGroupId?: string, // ID of a security group associated with the network interface
+  networkInterfaceGroupName?: string, // name of a security group associated with the network interface
+  networkInterfaceIpv6Address?: string, // IPv6 address associated with the network interface
+  networkInterfaceMacAddress?: string, // MAC address of the network interface
+  networkInterfaceId?: string, // ID of the network interface
+  networkInterfaceOwnerId?: string, // ID of the owner of the network interface
+  networkInterfacePrivateDnsName?: string, // private DNS name of the network interface
+  networkInterfaceRequesterId?: string, // requester ID of the network interface
+  networkInterfaceRequesterManaged?: boolean, // whether the network interface is being managed by AWS
+  networkInterfaceStatus?: 'available'|'in-use',
+  networkInterfaceSourceDestCheck?: boolean, // whether network interface performs source/destination checking, must be false for the network interface to perform network address translation (NAT) in your VPC
+  networkInterfaceSubnetId?: string, // ID of the subnet for the network interface
+  networkInterfaceVpcId?: string, // ID of the vpc for the network interface
+  outpostArn?: string, // ARN of the Outpost
+  ownerId?: string, // the AWS account ID of the instance's owner
+  placementGroupName?: string, // name of the placement group for the instance
+  placementPartitionNumber?: number, // partition in which the instance is located
+  platform?: 'Windows', // platform, only valid value is 'Windows'
+  privateDnsName?: string, // private IPv4 DNS name of the instance
+  privateIpAddress?: string, // private IPv4 address of the instance
+  productCode?: string, // product code associated with the AMI used to launch the instance
+  productCodeType?: 'devpay'|'marketplace', // type of the product code
+  ramdiskId?: string, // RAM disk ID
+  reason?: string, // reason for the current state of the instance, e.g. 'User Initiated [date]' when you stop or terminate an instance
+  requesterId?: string, // ID of the entity that launched the instance on your behalf, e.g. 'Amazon Web Services Management Console' or 'Auto Scaling'
+  reservationId?: string, // ID of the instance's reservation. A reservation ID has 1:1 relationship with an instance launch request. An instance launch request can have multiple instances
+  rootDeviceName?: string, // device name of the root device volume e.g. '/dev/sda1'
+  rootDeviceType?: 'ebs'|'instance-store', // type of the root device volume
+  sourceDestCheck?: boolean, // whether instance performs source/destination checking. Must be false for instance to perform network address translation (NAT) in your VPC
+  spotInstanceRequestId?: string, // ID of the spot instance reequest
+  stateReasonCode?: string, // reason code for the state change
+  stateReasonMessage?: string, // message the describes the state change
+  subnetId?: string, // ID of the subnet for the instance
+  `tag:${key string}`?: string, // key/value combination of a tag assigned to the resource. For example, to find all resources that have a tag with key `Owner` and value `TeamA`, specify `tag:Owner` with value `TeamA`
+  tagKey?: string, // key of a tag assigned to the resource. Use to find all resources with a specific tag, regardless of the value
+  tenancy?: 'dedicated'|'default'|'host', // tenancy of the instance
+  virtualizationType?: 'paravirtual'|'hvm', // virtualization type of the instance
+  vpcId?: string, // ID of the VPC that the instance is running in
+}
+
+export default EC2FindInstancesDescribeFilterOptions

package/internal/filterExists.js

@@ -0,0 +1,7 @@
+const filter = require('rubico/filter')
+
+const exists = value => value != null
+
+const filterExists = filter(exists)
+
+module.exports = filterExists

package/internal/filterExistsAndNotEmpty.js

@@ -0,0 +1,12 @@
+const filter = require('rubico/filter')
+const and = require('rubico/and')
+const not = require('rubico/not')
+const isEmpty = require('rubico/x/isEmpty')
+
+const exists = value => value != null
+
+const notEmpty = not(isEmpty)
+
+const filterExistsAndNotEmpty = filter(and([exists, notEmpty]))
+
+module.exports = filterExistsAndNotEmpty

package/internal/objectFilterKeys.js

@@ -0,0 +1,21 @@
+/**
+ * @name objectFilterKeys
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * objectFilterKeys(object Object, predicate function) -> filteredObject Object
+ * ```
+ *
+ * @TODO handle async
+ */
+const objectFilterKeys = function (object, predicate) {
+  const result = {}
+  for (const key in object) {
+    if (predicate(key)) {
+      result[key] = object[key]
+    }
+  }
+  return result
+}
+
+module.exports = objectFilterKeys

package/internal/toArray.js

@@ -0,0 +1,13 @@
+const isArray = require('./isArray')
+
+/**
+ * @name toArray
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * toArray(value Array|any) -> originalValueOrArrayOfJustValue Array
+ * ```
+ */
+const toArray = value => isArray(value) ? value : [value]
+
+module.exports = toArray

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "presidium",
-  "version": "0.15.36",
+  "version": "0.16.0",
   "description": "A library for creating web services",
   "author": "Richard Tong",
   "license": "MIT",
@@ -30,7 +30,7 @@
   ],
   "dependencies": {
     "@elastic/elasticsearch": "^7.10.0",
-    "aws-sdk": "^2.787.0",
+    "aws-sdk": "^2.1123.0",
     "ioredis": "^4.19.0",
     "mongodb": "^3.6.3",
     "node-fetch": "^2.6.1",