@adtrackify/at-service-common 1.0.0 → 1.0.1

package/package.json

@@ -1,27 +1,19 @@
 {
   "name": "@adtrackify/at-service-common",
-  "version": "1.0.0",
-  "description": "Upstackified fingerprint module",
-  "files": [
-    "dist/*"
-  ],
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
-  "type": "module",
-  "engines": {
-    "npm": ">=8.0.0 <9.0.0",
-    "node": ">=16.0.0 <18.14.2"
-  },
+  "version": "1.0.1",
+  "description": "",
+  "main": "dist/index.ts",
+  "types": "dist/index.d.ts",
   "scripts": {
     "clean": "rimraf dist",
-    "build": "cross-env NODE_ENV=production npm run tsc",
+    "build": "node ./node_modules/typescript/bin/tsc",
     "build:dev": "npm run clean && npm run verify && cross-env NODE_ENV=production stage=dev APP_ENV=dev npm run build",
-    "build:qa": "npm run clean && npm run verify && cross-env NODE_ENV=production stage=qa APP_ENV=qa npm run build",
-    "build:prod": "npm run clean && npm run verify && cross-env NODE_ENV=production stage=prod APP_ENV=prod npm run build",
-    "elint": "eslint .",
+    "build:qa": "npm run clean && npm run verify && cross-env NODE_ENV=production stage=qa APP_ENV=qa webpack",
+    "build:prod": "npm run clean && npm run verify && cross-env NODE_ENV=production stage=prod APP_ENV=prod webpack",
+    "elint": "eslint --ignore-path .gitignore .",
     "format": "prettier --write \"src/**/*.ts\" \"src/**/*.js\"",
-    "lint": "eslint src/",
-    "lint:fix": "eslint . --fix",
+    "lint": "tslint -p tsconfig.json",
+    "lint:fix": "eslint --ignore-path .gitignore . --fix",
     "coverage": "npm run test:all -- --coverage --group=unit",
     "test": "jest --group=unit --coverage",
     "test:all": "cross-env AWS_REGION=us-east-2 NODE_ENV=test jest --group=unit --coverage",
@@ -29,72 +21,70 @@
     "verify": "npm run clean && npm run type-check && npm run lint:fix",
     "version": "npm run format && git add -A src",
     "postversion": "git push && git push --tags",
-    "tsc": "tsc -p tsconfig.json && tsc -p tsconfig-cjs.json",
-    "push": "npm install && npm run build:dev &&  npm publish --verbose",
-    "type-check": "tsc --noEmit",
-    "prepublishOnly": "npm run tsc"
+    "type-check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@types/axios": "^0.14.0",
+    "@types/deep-freeze": "^0.1.2",
+    "@types/ua-parser-js": "^0.7.36",
+    "aws-sdk": "^2.1189.0",
+    "axios": "^0.27.2",
+    "axios-retry": "^3.3.1",
+    "crypto": "^1.0.1",
+    "esbuild": "^0.14.53",
+    "http-status-codes": "^2.2.0",
+    "joi": "^17.6.0",
+    "lambda-log": "^3.1.0",
+    "typescript": "^4.7.4",
+    "ua-parser-js": "^1.0.2"
   },
-  "dependencies": {},
-  "peerDependencies": {},
   "devDependencies": {
-    "@adtrackify/at-tracking-event-types": "^2.0.42",
-    "@aws-sdk/client-cognito-identity-provider": "^3.345.0",
-    "@aws-sdk/client-dynamodb": "^3.345.0",
-    "@aws-sdk/client-eventbridge": "^3.345.0",
-    "@aws-sdk/client-s3": "^3.345.0",
-    "@aws-sdk/client-sqs": "^3.345.0",
-    "@aws-sdk/lib-dynamodb": "^3.345.0",
-    "@faker-js/faker": "^7.5.0",
-    "@swc/core": "^1.3.1",
-    "@swc/jest": "^0.2.22",
-    "@types/jest": "^28.1.8",
-    "@types/lambda-log": "^3.0.0",
-    "@types/luxon": "^3.0.1",
+    "@babel/cli": "^7.13.16",
+    "@babel/core": "^7.13.10",
+    "@babel/plugin-proposal-optional-chaining": "^7.13.8",
+    "@babel/plugin-transform-runtime": "^7.10.3",
+    "@babel/preset-env": "^7.16.8",
+    "@babel/preset-typescript": "^7.16.7",
+    "@babel/runtime-corejs3": "^7.13.17",
+    "@types/jest": "^27.4.1",
+    "@types/lambda-log": "^2.2.1",
+    "@types/luxon": "^3.0.0",
     "@types/node": "^17.0.8",
-    "@types/ua-parser-js": "^0.7.36",
-    "@types/uuid": "^8.3.4",
-    "@typescript-eslint/eslint-plugin": "^5.37.0",
-    "@typescript-eslint/parser": "^5.37.0",
-    "core-js": "^3.25.1",
+    "@typescript-eslint/eslint-plugin": "^5.21.0",
+    "@typescript-eslint/parser": "^5.21.0",
+    "babel-eslint": "^10.1.0",
+    "babel-jest": "^26.6.3",
+    "babel-loader": "^8.2.2",
+    "babel-polyfill": "^6.26.0",
+    "core-js": "^3.21.1",
     "cross-env": "^7.0.3",
-    "esbuild": "^0.17.1",
-    "eslint": "^8.23.1",
+    "eslint": "^8.14.0",
     "eslint-config-standard": "^17.0.0",
+    "eslint-loader": "^4.0.2",
     "eslint-plugin-babel": "^5.3.1",
     "eslint-plugin-import": "^2.26.0",
-    "eslint-plugin-n": "^15.2.5",
-    "eslint-plugin-promise": "^6.0.1",
+    "eslint-plugin-n": "^15.2.0",
+    "eslint-plugin-promise": "^6.0.0",
+    "eslint-webpack-plugin": "^3.1.1",
     "glob": "^8.0.3",
     "husky": "^6.0.0",
-    "jest": "^29.2.1",
+    "jest": "^27.5.1",
     "jest-cucumber": "3.0.1",
     "jest-junit": "13.0.0",
-    "jest-runner": "^29.0.2",
-    "jest-runner-groups": "2.2.0",
-    "npm-dts": "^1.3.12",
+    "jest-runner-groups": "2.1.0",
     "npm-run-all": "^4.1.5",
     "npm-scripts-info": "^0.3.9",
     "prettier": "^2.7.1",
     "regenerator-runtime": "^0.13.9",
     "rimraf": "^3.0.2",
-    "swc-loader": "^0.2.3",
-    "ts-jest": "^29.0.5",
-    "ts-jest-resolver": "^2.0.1",
-    "ts-loader": "^9.4.2",
-    "ts-node": "^10.9.1",
     "tslint": "^6.1.3",
-    "tslint-config-prettier": "^1.18.0",
-    "typescript": "4.9.5"
+    "tslint-config-prettier": "^1.18.0"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://yash-upstackified@bitbucket.org/eacap/fingerprint.git"
+    "url": "git+ssh://git@bitbucket.org/eacap/at-tracking-event-types.git"
   },
   "author": "",
   "license": "ISC",
-  "keywords": [],
-  "bugs": {
-    "url": "https://bitbucket.org/eacap/fingerprint/issues"
-  },
-  "homepage": "https://bitbucket.org/eacap/fingerprint#readme"
+  "homepage": "https://bitbucket.org/eacap/at-tracking-event-types#readme"
 }

package/prettier.config.js

@@ -0,0 +1,9 @@
+/*eslint-disable */
+
+module.exports = {
+  trailingComma: 'es5',
+  tabWidth: 2,
+  semi: false,
+  singleQuote: true,
+};
+  /*eslint-enable */

package/src/clients/axios.d.ts

@@ -0,0 +1,8 @@
+declare module 'axios/lib/adapters/http' {
+  import { AxiosAdapter } from 'axios';
+
+  const httpAdapter: AxiosAdapter;
+  namespace httpAdapter { }
+
+  export = httpAdapter;
+}

package/src/clients/dynamodb-client.ts

@@ -0,0 +1,85 @@
+import AWS from 'aws-sdk';
+import * as log from 'lambda-log';
+import { BatchGetItemInput, DeleteItemInput, GetItemInput, PutItemInput, QueryInput, QueryOutput, ScanInput, UpdateItemInput } from 'aws-sdk/clients/dynamodb';
+const client = new AWS.DynamoDB.DocumentClient();
+
+export default class DynamoDbClient {
+  static safeGet = async (tableName: string, keyName: string, keyValue: any) => {
+    try {
+      const params = {
+        TableName: tableName,
+        Key: {
+          [keyName]: keyValue
+        }
+      };
+      const res = await client.get(params).promise();
+      return res?.Item ?? null;
+    } catch (e: any) {
+      log.error(e, { message: 'Dynamo Client Get Failed' });
+      return null;
+    }
+  };
+
+  static safePut = async (tableName: string, data: any) => {
+    try {
+      const params = {
+        TableName: tableName,
+        Item: data
+      };
+      const res = await client.put(params).promise();
+      return res;
+    } catch (e: any) {
+      log.error(e, { message: 'Dynamo failed simplePut' })
+      return null;
+    }
+  };
+
+  static safeBatchGet = async (tableName: string, keys: AWS.DynamoDB.KeyList) => {
+    try {
+      const params: BatchGetItemInput = {
+        RequestItems: {}
+      };
+      params.RequestItems[tableName] = {
+        Keys: keys
+      };
+      const res = await client.batchGet(params).promise();
+      log.info('batchget res', { batchGetRes: res })
+      if (res?.Responses?.[tableName]) {
+        return res?.Responses?.[tableName];
+      }
+      return [];
+    } catch (e: any) {
+      log.error(e, { message: 'Dynamo failed safeBatchGet' })
+      return [];
+    }
+  };
+
+  static queryAll = async (params: QueryInput) => {
+    try {
+      log.info('Invoke Query All', { params });
+      let currentResult: QueryOutput, exclusiveStartKey;
+      let accumulatedResults: any[] = [];
+      do {
+        params.ExclusiveStartKey = exclusiveStartKey;
+        params.Limit = 200;
+        currentResult = await client.query(params).promise();
+        if (currentResult.Items) {
+          exclusiveStartKey = currentResult.LastEvaluatedKey;
+          accumulatedResults = [...accumulatedResults, ...currentResult.Items];
+        }
+      } while (currentResult.Items && currentResult.Items.length > 0 && currentResult.LastEvaluatedKey);
+      return accumulatedResults;
+    } catch (e: any) {
+      log.error(e, { message: 'Dynamo failed queryAll' })
+      return null;
+    }
+  };
+
+  static batchGet = (params: BatchGetItemInput) => client.batchGet(params).promise();
+  static get = (params: GetItemInput) => client.get(params).promise();
+  static put = (params: PutItemInput) => client.put(params).promise();
+  static query = (params: QueryInput) => client.query(params).promise();
+  static scan = (params: ScanInput) => client.scan(params).promise();
+  static update = (params: UpdateItemInput) => client.update(params).promise();
+  static delete = (params: DeleteItemInput) => client.delete(params).promise();
+}

package/src/clients/eventbridge-client.ts

@@ -0,0 +1,38 @@
+import { EventBridge } from 'aws-sdk';
+import { v4 as uuidv4 } from 'uuid';
+import { getCurrentTimestamp } from '../libs/dates';
+
+export class EventBridgeClient {
+  public eventBridge: EventBridge;
+  public EVENT_BUS_NAME: string;
+
+  constructor (eventBusName: string) {
+    this.eventBridge = new EventBridge();
+    this.EVENT_BUS_NAME = eventBusName;
+  }
+
+  public buildEvent = (eventType: string, eventData: any, eventId: string = uuidv4(), eventTime: string = getCurrentTimestamp()) => {
+    return {
+      eventId,
+      eventType,
+      eventTime,
+      eventData
+    };
+  };
+
+
+  public putEvent = async (source: string, detailType: string, data: any, headers: any = null) => {
+    const params = {
+      Entries: [ {
+        Detail: JSON.stringify({ headers, data }),
+        DetailType: detailType,
+        EventBusName: this.EVENT_BUS_NAME,
+        Source: source,
+        Time: new Date(),
+      } ],
+    };
+    return await this.eventBridge.putEvents(params).promise();
+  };
+
+}
+

package/src/clients/http-client.ts

@@ -0,0 +1,36 @@
+import axios, { AxiosRequestConfig } from 'axios';
+import axiosRetry from 'axios-retry';
+import https from 'https'
+import httpAdapter from 'axios/lib/adapters/http';
+
+const httpResponse = (res: any = {}) => {
+  return {
+    headers: res?.header || {},
+    data: res?.data || {},
+    status: res?.status || 0,
+  };
+};
+
+export const axiosHttpService = (config: AxiosRequestConfig = {}) => {
+  config.adapter = httpAdapter;
+  config.httpsAgent = new https.Agent({ keepAlive: true });
+  const axiosService = axios.create(config);
+
+  axiosRetry(axiosService, { retryDelay: axiosRetry.exponentialDelay, retries: 3 });
+
+  const handleAxiosError = (error: any) => {
+    if (!error?.response && !error?.request) throw error;
+    return error.response ? httpResponse(error.response) : httpResponse({ status: 500, data: { error: error.request } });
+  };
+
+  return {
+    instance: () => axiosService,
+    get: (url: string, config?: AxiosRequestConfig) => axiosService.get(url, config).then(httpResponse, handleAxiosError),
+    post: (url: string, data?: any, config?: AxiosRequestConfig) => axiosService.post(url, data, config).then(httpResponse, handleAxiosError),
+    delete: (url: string, config?: AxiosRequestConfig) => axiosService.delete(url, config).then(httpResponse, handleAxiosError),
+    put: (url: string, data?: any, config?: AxiosRequestConfig) => axiosService.put(url, data, config).then(httpResponse, handleAxiosError),
+    patch: (url: string, data?: any, config?: AxiosRequestConfig) => axiosService.patch(url, data, config).then(httpResponse, handleAxiosError),
+    setBaseUrl: (url: string) => !!(axiosService.defaults.baseURL = url)
+  }
+}
+

package/src/clients/index.ts

@@ -0,0 +1,3 @@
+export * from './dynamodb-client';
+export * from './eventbridge-client';
+export * from './http-client';

package/src/helpers/index.ts

@@ -0,0 +1,3 @@
+export * from './input-validation-helper';
+export * from './logging-helper';
+export * from './response-helper'

package/src/helpers/input-validation-helper.ts

@@ -0,0 +1,22 @@
+import HttpError from '../libs/http-error';
+import * as log from 'lambda-log';
+import Joi from 'joi';
+
+export const validateInput = (schema: Joi.ObjectSchema<any>, input: any) => {
+  const { error, value } = schema.validate(input);
+  if (error) {
+    log.info('', { error });
+
+    const httperr = HttpError.badRequest('Input Validation Failure', {
+      errors: error.details.map(detail => ({
+        message: detail?.message,
+        key: detail?.context?.key,
+        path: detail?.path,
+      }))
+    });
+
+    log.info('', { httperr });
+    throw httperr;
+  }
+  return value;
+}

package/src/helpers/logging-helper.ts

@@ -0,0 +1,10 @@
+import * as log from 'lambda-log';
+const stage = process?.env?.STAGE;
+
+export const configureLogger = (event: any, context: any, debug: boolean = true) => {
+  log.options.meta.stage = stage;
+  log.options.meta.source_name = context?.functionName || 'unknown';
+  log.options.meta.awsRequestId = context?.awsRequestId || 'unknown';
+  log.options.meta.lambdaEvent = event;
+  log.options.debug = debug;
+}

package/src/helpers/response-helper.ts

@@ -0,0 +1,40 @@
+
+export const success = (body: any) => {
+  return buildResponse(200, body);
+}
+
+const defaultError = {
+  message: 'internalServerError'
+}
+
+export const failure = (error: any, statusCode: number = 500) => {
+  statusCode = error?.statusCode ?? statusCode;
+
+  let body = defaultError;
+  if (error?.body) {
+    body = error.body;
+  }
+  else if (error?.message) {
+    body = { message: error.message };
+  } else if (statusCode === 500) {
+    body = defaultError;
+  }
+  return buildResponse(statusCode, body);
+}
+
+export const buildResponse = (statusCode: number, body: any = {}) => {
+  delete body.stack;
+  return {
+    statusCode: statusCode,
+    headers: {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Credentials': true,
+      'cache-control': 'max-age=86400',
+      Date: new Date(),
+      'Last-Modified': new Date(),
+      'Access-Control-Allow-Headers':
+        'Content-Type, Content-Encoding'
+    },
+    body: JSON.stringify(body),
+  };
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './clients';
+export * from './helpers';
+export * from './libs';
+export * from './types';

package/src/libs/crypto.ts

@@ -0,0 +1,6 @@
+import crypto from 'crypto';
+
+export const generatePublicKey = (): string => {
+  const publicKey = crypto.randomBytes(26);
+  return publicKey.toString('utf8');
+};

package/src/libs/dates.ts

@@ -0,0 +1,14 @@
+
+import { DateTime } from 'luxon';
+
+export const getCurrentTimestamp = (): string => {
+  return DateTime.utc().toJSDate().toISOString();
+}
+
+export const getDateFromTimestamp = (timestamp: string) => {
+  return timestamp.split('T')[0];
+}
+
+export const getCurrentDate = (): string => {
+  return getDateFromTimestamp(getCurrentTimestamp());
+}

package/src/libs/http-error.ts

@@ -0,0 +1,100 @@
+/* eslint-disable no-dupe-class-members */
+import { strict as assert } from 'assert';
+import deepFreeze from 'deep-freeze';
+
+const deepClone = (o = {}) => JSON.parse(JSON.stringify(o));
+const containsStackTrace = (text: string = '') => /at.+\.js:\d+:\d+/.test(text);
+const objectContainsStackTrace = (obj: any) =>
+  !obj ? false : containsStackTrace(JSON.stringify(obj));
+
+// may only be expanded by governance, never reduced
+const supportedStatusCodes: any = {
+  400: 'Bad Request',
+  401: 'Unauthorized',
+  403: 'Forbidden',
+  404: 'Not Found',
+  405: 'Method Not Allowed',
+  409: 'Conflict',
+  412: 'Precondition Failed',
+  413: 'Payload Too Large',
+  415: 'Unsupported Media Type',
+  428: 'Precondition Required',
+  429: 'Too Many Requests',
+  500: 'Internal Server Error',
+  501: 'Not Implemented',
+  502: 'Bad Gateway',
+  503: 'Service Unavailable',
+  504: 'Gateway Timeout'
+};
+
+const supportedStatusCodesMessage = `statusCode must be one of the following: ${JSON.stringify(Object.keys(supportedStatusCodes))}`;
+const onlyStatusCodeMessage = 'Server errors may not specify any parameter except statusCode';
+
+const isNullOrUndefined = (value: any) => value === null || value === undefined;
+
+export default class HttpError extends Error {
+  body: {
+    [key: string]: any;
+  };
+  headers: object[];
+  statusCode: number;
+  isServerError: boolean;
+
+  constructor(statusCode: number,
+    message?: string,
+    body?: {
+      [key: string]: any;
+    },
+    headers?: object[]) {
+    assert(statusCode in supportedStatusCodes, supportedStatusCodesMessage);
+
+    const isServerError = statusCode > 499;
+
+    if (isServerError) {
+      assert(
+        isNullOrUndefined(message) && isNullOrUndefined(body),
+        onlyStatusCodeMessage
+      );
+
+      message = supportedStatusCodes[statusCode] as string;
+    } else {
+      assert(
+        body === undefined || typeof body === 'object',
+        'body must be an object or omitted'
+      );
+      assert(
+        headers === undefined || typeof headers === 'object',
+        'headers must be an object or omitted'
+      );
+
+      message = message ?? supportedStatusCodes[statusCode];
+
+      assert(
+        !containsStackTrace(message) && !objectContainsStackTrace(body),
+        'the message or data parameters may not contain errors or stack traces'
+      );
+    }
+
+    super(message);
+
+    this.body = deepClone(body);
+    this.headers = deepFreeze(deepClone(headers));
+    this.statusCode = statusCode;
+    this.isServerError = isServerError;
+    if (!this?.body?.message) {
+      this.body.message = this.message;
+    }
+  }
+
+
+  static get supportedStatusCodes() { return supportedStatusCodes; }
+  static badRequest = (message?: string, body?: object, headers?: object[]) => { return new HttpError(400, message, body, headers) };
+  static unauthorized = (message?: string, body?: object, headers?: object[]) => new HttpError(401, message, body, headers);
+  static forbidden = (message?: string, body?: object, headers?: object[]) => new HttpError(403, message, body, headers);
+  static notFound = (message?: string, body?: object, headers?: object[]) => new HttpError(404, message, body, headers);
+  static internal = (message?: string, body?: object, headers?: object[]) => new HttpError(500, message, body, headers);
+  static notImplemented = () => new HttpError(501);
+  static badGateway = () => new HttpError(502);
+  static serviceUnavailable = (headers: object[]) => new HttpError(503, undefined, undefined, headers);
+  static gatewayTimeout = () => new HttpError(504);
+}