@things-factory/aws-base 8.0.0-beta.9 → 8.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/aws-base",
-  "version": "8.0.0-beta.9",
+  "version": "8.0.2",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh <heartyoh@hatiolab.com>",
@@ -23,10 +23,10 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@things-factory/auth-base": "^8.0.0-beta.9",
-    "@things-factory/shell": "^8.0.0-beta.9",
+    "@things-factory/auth-base": "^8.0.2",
+    "@things-factory/shell": "^8.0.2",
     "athena-express": "^7.1.4",
     "aws-sdk": "^2.1096.0"
   },
-  "gitHead": "86b1dfa26292926a2d5447fdc23bfa5a9e983245"
+  "gitHead": "39d60f56e142561233ddf6d47b539c637971357c"
 }

package/server/controllers/athena-controller.ts

@@ -0,0 +1,105 @@
+import { AthenaExpress } from 'athena-express'
+import AWS from 'aws-sdk'
+
+import { config, logger } from '@things-factory/env'
+
+const athenaConfig = config.get('athena', {})
+const awsCredentials = {
+  region: athenaConfig.region,
+  accessKeyId: athenaConfig.accessKeyId,
+  secretAccessKey: athenaConfig.secretAccessKey
+}
+
+if (!athenaConfig.region) {
+  console.log(`\
+application config for 'athena' required like following
+/*
+athena: {
+accessKeyId: 'YOUR ACCESS KEY ID',
+secretAccessKey: 'YOUR SECRET ACCESS KEY',
+region: 'YOUR S3 REGION'
+options: { athenaExpressConfig
+  retry: 200,
+  getStats: true,
+  formatJson: true
+}
+}
+*/
+please, refer to https://github.com/ghdna/athena-express#advance-config-parameters for about more detail configuration parameters
+`)
+}
+
+export class AthenaController {
+  private athenaExpressClient
+  private queryPaginationInfo = {
+    NextToken: '',
+    QueryExecutionId: ''
+  }
+
+  constructor() {
+    if (!athenaConfig.region) {
+      return
+    }
+
+    try {
+      AWS.config.update(awsCredentials)
+    } catch (err) {
+      // missing config
+      logger.error(err)
+    }
+
+    // refer to https://github.com/ghdna/athena-express#advance-config-parameters
+    // about more detail configuration parameters
+    let athenaExpressConfig = {
+      aws: AWS,
+      ...athenaConfig.options
+    }
+
+    this.athenaExpressClient = new AthenaExpress(athenaExpressConfig)
+  }
+
+  // query parameters: https://github.com/ghdna/athena-express#advance-query-parameters
+  /* SAMPLE QUERY PARAMTERS
+    {
+      sql: "SELECT * FROM elb_logs LIMIT 3" // required,
+      db: "sampledb", // optional.
+      pagination: 5, //optional
+      NextToken: "ARfCDXRjMk...", //optional
+      QueryExecutionId: "c274843b-4c5c-4ccf-ac8b-e33d595b927d", //optional
+      catalog: "hive" //optional
+    };  */
+
+  // pagination: https://github.com/ghdna/athena-express#pagination
+  async query(reqQuery) {
+    var queryResult
+    try {
+      // check if sql key is available in the input parameter
+      if (reqQuery.sql === undefined || reqQuery.sql === '') return {}
+
+      let queryInput = {
+        ...reqQuery
+      }
+
+      // check if pagination would be available.
+      if (
+        reqQuery.pagination > 0 &&
+        this.queryPaginationInfo.NextToken !== '' &&
+        this.queryPaginationInfo.QueryExecutionId !== ''
+      ) {
+        queryInput.NextToken = this.queryPaginationInfo.NextToken
+        queryInput.QueryExecutionId = this.queryPaginationInfo.QueryExecutionId
+      }
+
+      // run the query
+      queryResult = await this.athenaExpressClient.query(queryInput)
+
+      // keep pagination parameters if they are available in the result
+      this.queryPaginationInfo.NextToken = queryResult?.NextToken || ''
+      this.queryPaginationInfo.QueryExecutionId = queryResult?.QueryExecutionId || ''
+    } catch (error) {
+      logger.error(error)
+    }
+
+    return queryResult
+  }
+}

package/server/controllers/index.ts

@@ -0,0 +1,2 @@
+
+export * from './athena-controller'

package/server/index.ts

@@ -0,0 +1,7 @@
+export * from './controllers'
+export * from './migrations'
+export * from './middlewares'
+export * from './service'
+export * from './controllers/athena-controller'
+
+import './routes'

package/server/middlewares/index.ts

@@ -0,0 +1,3 @@
+export function initMiddlewares(app) {
+  /* can add middlewares into app */
+}

package/server/migrations/index.ts

@@ -0,0 +1,9 @@
+const glob = require('glob')
+const path = require('path')
+
+export var migrations = []
+
+glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
+  if (file.indexOf('index.js') !== -1) return
+  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
+})

package/server/routes.ts

@@ -0,0 +1,26 @@
+process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
+  /*
+   * can add global public routes to application (auth not required, tenancy not required)
+   *
+   * ex) routes.get('/path', async(context, next) => {})
+   * ex) routes.post('/path', async(context, next) => {})
+   */
+})
+
+process.on('bootstrap-module-global-private-route' as any, (app, globalPrivateRouter) => {
+  /*
+   * can add global private routes to application (auth required, tenancy not required)
+   */
+})
+
+process.on('bootstrap-module-domain-public-route' as any, (app, domainPublicRouter) => {
+  /*
+   * can add domain public routes to application (auth not required, tenancy required)
+   */
+})
+
+process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
+  /*
+   * can add domain private routes to application (auth required, tenancy required)
+   */
+})

package/server/service/athena/athena-query.ts

@@ -0,0 +1,24 @@
+import '@things-factory/auth-base' // for ResolverContext
+
+import { Arg, Ctx, Query, Root } from 'type-graphql'
+
+import { ScalarAny, ScalarObject } from '@things-factory/shell'
+
+import { AthenaController } from '../../controllers'
+
+const athenaClient = new AthenaController()
+
+export class AthenaQuery {
+  @Query(returns => ScalarAny, { description: 'To query data in S3 using Amazon Athena SDK' })
+  async queryFromAthena(
+    @Root() _,
+    @Arg('queryData', type => ScalarObject) queryData: any,
+    @Ctx() context: ResolverContext
+  ): Promise<any> {
+    const { domain, user } = context.state
+
+    var queryResult = await athenaClient.query(queryData)
+
+    return queryResult
+  }
+}

package/server/service/athena/index.ts

@@ -0,0 +1,4 @@
+import { AthenaQuery } from './athena-query'
+
+export const entities = []
+export const resolvers = [AthenaQuery]

package/server/service/index.ts

@@ -0,0 +1,14 @@
+/* IMPORT ENTITIES AND RESOLVERS */
+import { resolvers as AthenaResolvers } from './athena'
+
+export const entities = [  
+  /* ENTITIES */
+] 
+
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+		...AthenaResolvers,
+  ] 
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../tsconfig-base.json",
+  "compilerOptions": {
+    "outDir": "./dist-server",
+    "baseUrl": "./"
+  },
+  "include": ["./server/**/*"],
+  "exclude": ["**/*.spec.ts"]
+}