presidium 0.16.16 → 0.16.18

package/.eslintrc.js

@@ -210,7 +210,7 @@ module.exports = {
         'no-sequences': 'off',
         'no-shadow': 'off',
         'no-spaced-func': 'error',
-        'no-sync': 'error',
+        'no-sync': 'off',
         'no-tabs': 'error',
         'no-template-curly-in-string': 'error',
         'no-ternary': 'off',

package/AwsCredentials.js

@@ -0,0 +1,61 @@
+require('rubico/global')
+const fs = require('fs')
+const nodePath = require('path')
+const pathResolve = require('./internal/pathResolve')
+
+/**
+ * @name AwsCredentials
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * AwsCredentials(options {
+ *   profile?: string,
+ *   credentialsFileDir?: string,
+ * }) -> awsCreds {
+ *   accessKeyId: string,
+ *   secretAccessKey: string,
+ * }
+ *
+ * AwsCredentials(profile string) -> awsCreds {
+ *   accessKeyId: string,
+ *   secretAccessKey: string,
+ * }
+ * ```
+ */
+
+const AwsCredentials = async function (options = {}) {
+  const profile = (
+    typeof options == 'string' ? options : options.profile
+  ) ?? 'default'
+
+  let credentialsFileDir =
+    options.credentialsFileDir ?? pathResolve(process.cwd())
+  let lines = ''
+  while (credentialsFileDir != '/') {
+    const credentialsFilePath =
+      pathResolve(credentialsFileDir, '.aws/credentials')
+    if (fs.existsSync(credentialsFilePath)) {
+      lines = await (
+        fs.promises.readFile(credentialsFilePath)
+        .then(buffer => `${buffer}`.split('\n'))
+      )
+      break
+    }
+    credentialsFileDir = pathResolve(credentialsFileDir, '..')
+  }
+
+  const startingLineNumber = lines.findIndex(line => line == `[${profile}]`)
+
+  const accessKeyId = lines.find(
+    (line, index) => index > startingLineNumber
+    && line.startsWith('aws_access_key_id')
+  ).split(' = ')[1]
+  const secretAccessKey = lines.find(
+    (line, index) => index > startingLineNumber
+    && line.startsWith('aws_secret_access_key')
+  ).split(' = ')[1]
+
+  return { accessKeyId, secretAccessKey }
+}
+
+module.exports = AwsCredentials

package/AwsCredentials.test.js

@@ -0,0 +1,45 @@
+const Test = require('thunk-test')
+const assert = require('assert')
+const fs = require('fs')
+const AwsCredentials = require('./AwsCredentials')
+
+const test = new Test('AwsCredentials', async function () {
+  try {
+    await fs.promises.mkdir(`${__dirname}/../.aws`)
+  } catch {
+    await fs.promises.rm(`${__dirname}/../.aws`, { recursive: true })
+    await fs.promises.mkdir(`${__dirname}/../.aws`)
+  }
+
+  await fs.promises.writeFile(`${__dirname}/../.aws/credentials`, `
+[default]
+aws_access_key_id = AAA
+aws_secret_access_key = FFF
+  `.trim())
+
+  {
+    const awsCreds = await AwsCredentials('default')
+    assert.equal(awsCreds.accessKeyId, 'AAA')
+    assert.equal(awsCreds.secretAccessKey, 'FFF')
+  }
+
+  {
+    const awsCreds = await AwsCredentials({ profile: 'default' })
+    assert.equal(awsCreds.accessKeyId, 'AAA')
+    assert.equal(awsCreds.secretAccessKey, 'FFF')
+  }
+
+  {
+    const awsCreds = await AwsCredentials()
+    assert.equal(awsCreds.accessKeyId, 'AAA')
+    assert.equal(awsCreds.secretAccessKey, 'FFF')
+  }
+
+  await fs.promises.rm(`${__dirname}/../.aws`, { recursive: true })
+}).case()
+
+if (process.argv[1] == __filename) {
+  test()
+}
+
+module.exports = test

package/DynamoStream.test.js

@@ -38,6 +38,7 @@ const test = Test('DynamoStream', DynamoStream)
   table: 'my-table',
   endpoint: 'http://localhost:8000',
   shardIteratorType: 'TRIM_HORIZON',
+  shardUpdatePeriod: 1000,
 }, async function (myStream) {
   await myStream.ready
 
@@ -83,7 +84,7 @@ const test = Test('DynamoStream', DynamoStream)
   endpoint: 'http://localhost:8000',
   getRecordsLimit: 1,
   getRecordsInterval: 1000,
-  shardUpdatePeriod: 5000,
+  shardUpdatePeriod: 1000,
   shardIteratorType: 'TRIM_HORIZON',
 }, async function (myStream) {
   await myStream.ready
@@ -129,6 +130,7 @@ const test = Test('DynamoStream', DynamoStream)
   table: 'my-table',
   endpoint: 'http://localhost:8000',
   getRecordsLimit: 1,
+  shardUpdatePeriod: 1000,
   shardIteratorType: 'TRIM_HORIZON',
 }, async function (myStream) {
   await myStream.ready
@@ -183,6 +185,7 @@ const test = Test('DynamoStream', DynamoStream)
   listStreamsLimit: 1,
   shardIteratorType: 'TRIM_HORIZON',
   debug: true,
+  shardUpdatePeriod: 1000,
 }, async function (myStream) {
   await myStream.ready
 
@@ -223,6 +226,82 @@ const test = Test('DynamoStream', DynamoStream)
   myStream.close()
 })
 
+.case({
+  table: 'my-table',
+  endpoint: 'http://localhost:8000',
+  listStreamsLimit: 1,
+  shardIteratorType: 'TRIM_HORIZON',
+  debug: true,
+  shardUpdatePeriod: 1000,
+}, async function (myStream) {
+  await myStream.ready
+
+  const originalClient = myStream.client
+  const alternatingErrorClient = {
+    listStreams(options) {
+      return originalClient.listStreams(options)
+    },
+    describeStream(options) {
+      return originalClient.describeStream(options)
+    },
+    getShardIterator(options) {
+      return originalClient.getShardIterator(options)
+    },
+    getRecordsCount: 0,
+    getRecords(options) {
+      return {
+        async promise() {
+          if (alternatingErrorClient.getRecordsCount % 2 == 0) {
+            const error = new Error('stub error')
+            error.retryable = true
+            alternatingErrorClient.getRecordsCount += 1
+            throw error
+          }
+          alternatingErrorClient.getRecordsCount += 1
+          return originalClient.getRecords(options).promise()
+        },
+      }
+    },
+  }
+  myStream.client = alternatingErrorClient
+
+  const table = this.table
+  await table.putItem({
+    id: '1',
+    status: 'waitlist',
+    createTime: 1000,
+    name: 'George',
+  })
+  await table.putItem({
+    id: '2',
+    status: 'waitlist',
+    createTime: 1001,
+    name: 'geo',
+  })
+  await table.putItem({
+    id: '3',
+    status: 'waitlist',
+    createTime: 1002,
+    name: 'john',
+  })
+  await table.putItem({
+    id: '4',
+    status: 'approved',
+    createTime: 1003,
+    name: 'sally',
+  })
+  await table.putItem({
+    id: '5',
+    status: 'approved',
+    createTime: 1004,
+    name: 'sally',
+  })
+
+  const first5 = await asyncIterableTake(5)(myStream)
+  assert.strictEqual(first5.length, 5)
+  myStream.close()
+})
+
 .case({
   table: 'my-table',
   endpoint: 'http://localhost:8000',

package/package.json

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

package/teardown.js

@@ -0,0 +1,39 @@
+const DynamoTable = require('./DynamoTable')
+const DynamoStream = require('./DynamoStream')
+const ElasticsearchIndex = require('./ElasticsearchIndex')
+const S3Bucket = require('./S3Bucket')
+const KinesisStream = require('./KinesisStream')
+
+/**
+ * @name teardown
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * teardown(
+ *   dependency DynamoTable|DynamoStream
+ *              |ElasticsearchIndex|S3Bucket
+ *              |KinesisStream
+ * ) -> Promise<>
+ * ```
+ */
+const teardown = async function (dependency) {
+  if (dependency.constructor == DynamoTable) {
+    await dependency.delete()
+  }
+  else if (dependency.constructor == DynamoStream) {
+    dependency.close()
+  }
+  else if (dependency.constructor == ElasticsearchIndex) {
+    await dependency.delete()
+  }
+  else if (dependency.constructor == S3Bucket) {
+    await dependency.deleteAllObjects()
+    await dependency.delete()
+  }
+  else if (dependency.constructor == KinesisStream) {
+    dependency.close()
+    await dependency.delete()
+  }
+}
+
+module.exports = teardown

package/teardown.test.js

@@ -0,0 +1,62 @@
+const Test = require('thunk-test')
+const DynamoTable = require('presidium/DynamoTable')
+const DynamoStream = require('presidium/DynamoStream')
+const ElasticsearchIndex = require('presidium/ElasticsearchIndex')
+const S3Bucket = require('presidium/S3Bucket')
+const KinesisStream = require('presidium/KinesisStream')
+const teardown = require('./teardown')
+
+const test = new Test('teardown', async function () {
+  const myDynamoTable = new DynamoTable({
+    name: 'my_dynamo_table',
+    key: [{ a: 'string' }],
+    endpoint: 'http://localhost:8000',
+    region: 'dynamodblocal',
+  })
+  await myDynamoTable.ready
+
+  const myDynamoStream = new DynamoStream({
+    table: 'my_dynamo_table',
+    endpoint: 'http://localhost:8000',
+    region: 'dynamodblocal',
+  })
+  await myDynamoStream.ready
+
+  const myElasticsearchIndex = new ElasticsearchIndex({
+    node: 'http://localhost:9200/',
+    index: 'local_post',
+    mappings: {
+      a: { type: 'keyword' },
+      b: { type: 'keyword' },
+    },
+  })
+  await myElasticsearchIndex.ready
+
+  const myS3Bucket = new S3Bucket({
+    name: 'my-s3-bucket',
+    endpoint: 'http://localhost:9000',
+    region: 'us-west-1',
+    accessKeyId: 'minioadmin',
+    secretAccessKey: 'minioadmin',
+  })
+  await myS3Bucket.ready
+
+  const myKinesisStream = new KinesisStream({
+    name: 'my_kinesis_stream',
+    endpoint: 'http://localhost:4567',
+    shardIteratorType: 'TRIM_HORIZON',
+  })
+  await myKinesisStream.ready
+
+  await teardown(myDynamoTable)
+  await teardown(myDynamoStream)
+  await teardown(myElasticsearchIndex)
+  await teardown(myS3Bucket)
+  await teardown(myKinesisStream)
+}).case()
+
+if (process.argv[1] == __filename) {
+  test()
+}
+
+module.exports = teardown