presidium 0.16.11 → 0.16.15

package/Dynamo.js

@@ -442,4 +442,23 @@ Dynamo.attributeValueToJSON = function attributeValueToJSON(attributeValue) {
   }
 }
 
+/**
+ * @name Dynamo.itemResponseToJSON
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * Dynamo.itemResponseToJSON(
+ *   dynamoResponse {
+ *     Item: Object<DynamoAttributeValue>
+ *   }
+ * ) -> json Object
+ * ```
+ */
+Dynamo.itemResponseToJSON = function itemResponseToJSON(dynamoResponse) {
+  return pipe(dynamoResponse, [
+    get('Item'),
+    map(Dynamo.attributeValueToJSON),
+  ])
+}
+
 module.exports = Dynamo

package/Dynamo.test.js

@@ -29,6 +29,12 @@ const combinedTest = Test.all([
     .case({ M: { a: { N: '1' }, b: { L: [{ S: 'a' }, { BOOL: true }] } } }, { a: 1, b: ['a', true] })
     .throws(NaN, new TypeError('unknown attributeValue NaN')),
 
+  Test('Dynamo.itemResponseToJSON', Dynamo.itemResponseToJSON)
+    .case({ Item: { a: { S: 'hey' } } }, { a: 'hey' })
+    .case({ Item: { b: { S: '' } } }, { b: '' })
+    .case({ Item: { c: { N: '1' } } }, { c: 1 })
+    .case({ Item: { a: { M: { a: { N: '1' }, b: { L: [{ S: 'a' }, { BOOL: true }] } } } } }, { a: { a: 1, b: ['a', true] } }),
+
   Test('Dynamo.AttributeType', Dynamo.AttributeType)
     .case('string', 'S')
     .case('S', 'S')

package/DynamoIndexQueryIterator.js

@@ -0,0 +1,46 @@
+/**
+ * @name DynamoIndexQueryIterator
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * DynamoIndexQueryIterator(
+ *   dynamoIndex DynamoIndex,
+ *   keyConditionExpression string,
+ *   queryValues object,
+ *   options? {
+ *     limit?: number,
+ *     scanIndexForward?: boolean, // true for ASC, false for DESC
+ *   },
+ * ) -> AsyncGenerator<DynamoItem>
+ * ```
+ */
+const DynamoIndexQueryIterator = async function* (
+  dynamoIndex, keyConditionExpression, queryValues, options = {}
+) {
+  const {
+    limit = 1000,
+    scanIndexForward = true,
+  } = options
+
+  let response = await dynamoIndex.query(
+    keyConditionExpression,
+    queryValues,
+    { limit, scanIndexForward },
+  )
+  yield* response.Items
+
+  while (response.LastEvaluatedKey != null) {
+    response = await dynamoIndex.query(
+      keyConditionExpression,
+      queryValues,
+      {
+        limit,
+        scanIndexForward,
+        exclusiveStartKey: response.LastEvaluatedKey,
+      },
+    )
+    yield* response.Items
+  }
+}
+
+module.exports = DynamoIndexQueryIterator

package/DynamoIndexQueryIterator.test.js

@@ -0,0 +1,72 @@
+require('rubico/global')
+const Test = require('thunk-test')
+const assert = require('assert')
+const Dynamo = require('./Dynamo')
+const DynamoTable = require('./DynamoTable')
+const DynamoIndex = require('./DynamoIndex')
+const DynamoIndexQueryIterator = require('./DynamoIndexQueryIterator')
+
+const test = new Test('DynamoIndexQueryIterator', async function () {
+  const testTable = new DynamoTable({
+    name: 'test_table',
+    key: [{ id: 'string' }],
+    endpoint: 'http://localhost:8000/',
+    region: 'dynamodblocal',
+  })
+  await testTable.ready
+
+  const testStatusCreateTimeIndex = new DynamoIndex({
+    table: 'test_table',
+    key: [{ status: 'string' }, { createTime: 'number' }],
+    endpoint: 'http://localhost:8000/',
+    region: 'dynamodblocal',
+  })
+  await testStatusCreateTimeIndex.ready
+
+  {
+    let number = -1
+    while (++number < 50) {
+      await testTable.putItem({
+        id: number.toString(),
+        status: 'pending',
+        createTime: number + 1,
+      })
+    }
+  }
+
+  {
+    const array = []
+    const iter = DynamoIndexQueryIterator(
+      testStatusCreateTimeIndex,
+      'status = :status AND createTime > :createTime',
+      { status: 'pending', createTime: 0 },
+      { limit: 10, scanIndexForward: true },
+    )
+    for await (const item of iter) {
+      array.push(map(item, Dynamo.attributeValueToJSON))
+    }
+    assert.equal(array.length, 50)
+    assert.equal(array[0].id, '0')
+  }
+
+  {
+    const array = []
+    const iter = DynamoIndexQueryIterator(
+      testStatusCreateTimeIndex,
+      'status = :status AND createTime > :createTime',
+      { status: 'pending', createTime: 0 },
+      { limit: 10, scanIndexForward: false },
+    )
+    for await (const item of iter) {
+      array.push(map(item, Dynamo.attributeValueToJSON))
+    }
+    assert.equal(array.length, 50)
+    assert.equal(array[0].id, '49')
+  }
+}).case()
+
+if (process.argv[1] == __filename) {
+  test()
+}
+
+module.exports = test

package/EC2.js

@@ -124,15 +124,15 @@ const EC2 = function (options) {
  *     },
  *     AvailabilityZone: string, // 'us-west-1a'
  *     Events: Array,
- *     InstanceState: {
+ *     InstanceState: { // the intended state of the instance
  *       Code: number, // 16
  *       Name: string, // 'running'
  *     },
- *     InstanceStatus: {
+ *     InstanceStatus: { // reports impaired functionality that stems from issues internal to the instance, such as impaired reachability
  *       Details: Array,
  *       Status: string, // 'ok'
  *     },
- *     SystemStatus: {
+ *     SystemStatus: { // reports impaired functionality that stems from issues related to systems that support the instance, such as hardware failures and network connectivity problems
  *       Details: Array,
  *       Status: string, // 'ok'
  *     }

package/SecretsManager.js

@@ -0,0 +1,58 @@
+/*
+// Use this code snippet in your app.
+// If you need more information about configurations or implementing the sample code, visit the AWS docs:
+// https://aws.amazon.com/developers/getting-started/nodejs/
+
+// Load the AWS SDK
+var AWS = require('aws-sdk'),
+    region = "us-west-1",
+    secretName = "production/PAYPAL_CLIENT_ID",
+    secret,
+    decodedBinarySecret;
+
+// Create a Secrets Manager client
+var client = new AWS.SecretsManager({
+    region: region
+});
+
+// In this sample we only handle the specific exceptions for the 'GetSecretValue' API.
+// See https://docs.aws.amazon.com/secretsmanager/latest/apireference/API_GetSecretValue.html
+// We rethrow the exception by default.
+
+client.getSecretValue({SecretId: secretName}, function(err, data) {
+    if (err) {
+        if (err.code === 'DecryptionFailureException')
+            // Secrets Manager can't decrypt the protected secret text using the provided KMS key.
+            // Deal with the exception here, and/or rethrow at your discretion.
+            throw err;
+        else if (err.code === 'InternalServiceErrorException')
+            // An error occurred on the server side.
+            // Deal with the exception here, and/or rethrow at your discretion.
+            throw err;
+        else if (err.code === 'InvalidParameterException')
+            // You provided an invalid value for a parameter.
+            // Deal with the exception here, and/or rethrow at your discretion.
+            throw err;
+        else if (err.code === 'InvalidRequestException')
+            // You provided a parameter value that is not valid for the current state of the resource.
+            // Deal with the exception here, and/or rethrow at your discretion.
+            throw err;
+        else if (err.code === 'ResourceNotFoundException')
+            // We can't find the resource that you asked for.
+            // Deal with the exception here, and/or rethrow at your discretion.
+            throw err;
+    }
+    else {
+        // Decrypts secret using the associated KMS key.
+        // Depending on whether the secret is a string or binary, one of these fields will be populated.
+        if ('SecretString' in data) {
+            secret = data.SecretString;
+        } else {
+            let buff = new Buffer(data.SecretBinary, 'base64');
+            decodedBinarySecret = buff.toString('ascii');
+        }
+    }
+    
+    // Your code goes here. 
+});
+*/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "presidium",
-  "version": "0.16.11",
+  "version": "0.16.15",
   "description": "A library for creating web services",
   "author": "Richard Tong",
   "license": "MIT",