@eyevinn/player-analytics-shared 0.5.0

package/.github/workflows/build-test.yml

@@ -0,0 +1,19 @@
+name: Run tests
+on: push
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [14.x]
+    steps:
+      - uses: actions/checkout@v1
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+      - name: Install dependencies and run tests
+        run: |
+          npm ci
+          npm install
+          npm test

package/.github/workflows/release-gh-package.yml

@@ -0,0 +1,24 @@
+
+name: Publish GitHub Package
+on:
+  release:
+    types: [published]
+jobs:
+  publish-gpr:
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 14.x
+          registry-url: https://npm.pkg.github.com/
+      - run: npm ci
+      - run: npm install
+      - run: npm test
+      - run: npm run build --if-present
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}

package/.github/workflows/release-npmjs-package.yml

@@ -0,0 +1,21 @@
+
+name: Publish Package on NPM
+on:
+  release:
+    types: [published]
+jobs:
+  publish-npmjs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 14.x
+          registry-url: https://registry.npmjs.org/
+      - run: npm ci
+      - run: npm install
+      - run: npm test
+      - run: npm run build --if-present
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/README.md

@@ -0,0 +1,2 @@
+# player-analytics-shared
+Shared modules & adapters for EPAS components

package/adapters/db/DynamoDBAdapter.ts

@@ -0,0 +1,147 @@
+import {
+  CreateTableCommand,
+  ListTablesCommand,
+  PutItemCommand,
+  DynamoDBClient,
+  GetItemCommand,
+  DeleteItemCommand,
+  QueryCommand,
+  QueryCommandInput,
+  QueryCommandOutput,
+  DescribeTableCommand,
+  DescribeTableCommandInput
+} from '@aws-sdk/client-dynamodb';
+import { marshall, unmarshall } from '@aws-sdk/util-dynamodb';
+import winston from 'winston';
+import {
+  AbstractDBAdapter,
+  IGetItemInput,
+  IGetItems,
+  IPutItemInput,
+  IHandleErrorOutput,
+  ErrorType,
+} from '../../types/interfaces';
+
+export class DynamoDBAdapter implements AbstractDBAdapter {
+  logger: winston.Logger;
+  dbClient: DynamoDBClient;
+
+  constructor(logger: winston.Logger) {
+    this.dbClient = new DynamoDBClient({
+      region: process.env.AWS_REGION,
+      maxAttempts: 5,
+    });
+    this.logger = logger;
+  }
+
+  async tableExists(name: string): Promise<boolean> {
+    try {
+      const params: DescribeTableCommandInput = { TableName: name };
+      const tablesData = await this.dbClient.send(new DescribeTableCommand(params));
+      if (tablesData['Table'] && tablesData['Table'].TableStatus === 'ACTIVE') return true;
+      return false;
+    } catch (awsError) {
+      if (awsError.name && awsError.name === 'ResourceNotFoundException') {
+        return false;
+      } else {
+        this.logger.error(awsError);
+        throw new Error(awsError);
+      }
+    }
+  }
+
+  async putItem(params: IPutItemInput): Promise<boolean> {
+    try {
+      const data = await this.dbClient.send(
+        new PutItemCommand({
+          TableName: params.tableName,
+          Item: marshall(params.data),
+        })
+      );
+      return data.$metadata.httpStatusCode === 200;
+    } catch (err) {
+      throw this.handleError(err);
+    }
+  }
+
+  async getItem(params: IGetItemInput): Promise<any> {
+    try {
+      const data = await this.dbClient.send(
+        new GetItemCommand({
+          TableName: params.tableName,
+          Key: marshall({
+            sessionId: params.sessionId,
+            timestamp: params.timestamp,
+          }),
+        })
+      );
+      this.logger.debug('Read Item from Table');
+      return data;
+    } catch (err) {
+      throw this.handleError(err);
+    }
+  }
+
+  async deleteItem(params: IGetItemInput): Promise<boolean> {
+    try {
+      const data = await this.dbClient.send(
+        new DeleteItemCommand({
+          TableName: params.tableName,
+          Key: marshall({
+            sessionId: params.sessionId,
+            timestamp: params.timestamp,
+          }),
+        })
+      );
+      this.logger.debug('Deleted Item from Table', data);
+      return data.$metadata.httpStatusCode === 200;
+    } catch (err) {
+      throw this.handleError(err);
+    }
+  }
+
+  async getItemsBySession(params: IGetItems): Promise<any[]> {
+    try {
+      const inputData: QueryCommandInput = {
+        TableName: params.tableName,
+        KeyConditionExpression: '#sid = :sid',
+        ExpressionAttributeNames: {
+          '#sid': 'sessionId',
+        },
+        ExpressionAttributeValues: marshall({
+          ':sid': params.sessionId,
+        }),
+      };
+      const queryData: QueryCommandOutput = await this.dbClient.send(
+        new QueryCommand(inputData)
+      );
+      if (queryData.Items && queryData.Items.length > 0) {
+        let items: any[] = [];
+        for (let i = 0; i < queryData.Items.length; i++) {
+          items[i] = unmarshall(queryData.Items[i]);
+        }
+        return items;
+      }
+      return [];
+    } catch (err) {
+      throw this.handleError(err);
+    }
+  }
+
+  handleError(errorObject: any): IHandleErrorOutput {
+    this.logger.error(errorObject);
+    const errorOutput: IHandleErrorOutput = {
+      errorType: ErrorType.ABORT,
+      error: errorObject,
+    };
+    if (errorObject.name) {
+      if (
+        errorObject.name === 'ResourceNotFoundException' ||
+        errorObject.name === 'ResourceInUseException'
+      ) {
+        errorOutput['errorType'] = ErrorType.CONTINUE;
+      }
+    }
+    return errorOutput;
+  }
+}

package/adapters/db/MongoDBAdapter.ts

@@ -0,0 +1,79 @@
+import { Logger } from "winston";
+import { AbstractDBAdapter, IHandleErrorOutput, ErrorType, IPutItemInput, IGetItemInput, IGetItems } from "../../types/interfaces";
+import { MongoClient } from "mongodb";
+
+const DB_NAME = "EPAS";
+
+export class MongoDBAdapter implements AbstractDBAdapter {
+  logger: Logger;
+  dbClient: MongoClient;
+
+  constructor(logger: Logger) {
+    const connectionString = process.env.MONGODB_URI || "mongodb://localhost";
+    this.dbClient = new MongoClient(connectionString);
+    this.connect()
+    this.logger = logger;
+  }
+
+  private async isConnected(): Promise<boolean> {
+    return !!await this.dbClient.db("admin").command({ ping: 1 });
+  }
+
+  private async connect(): Promise<void> {
+    await this.dbClient.connect();
+  }
+
+  public async tableExists(tableName: string): Promise<boolean> {
+    if (!await this.isConnected()) await this.connect();
+    const collections = await this.dbClient.db().collections();
+    const tableNames = collections.map((collection) => collection.collectionName);
+    return tableNames.includes(tableName);
+  }
+
+  public async putItem({ tableName, data }: IPutItemInput): Promise<boolean> {
+    try {
+      const collection = await this.dbClient.db().collection(tableName);
+      const result = await collection.insertOne(data);
+      return result.acknowledged;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  public async getItem({ sessionId, tableName, timestamp }: IGetItemInput): Promise<any> {
+    try {
+      const collection = await this.dbClient.db().collection(tableName);
+      const result = await collection.findOne({ sessionId: sessionId, timestamp: timestamp });
+      return result;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  public async deleteItem({ sessionId, tableName, timestamp }: IGetItemInput): Promise<boolean> {
+    try {
+      const collection = await this.dbClient.db().collection(tableName);
+      const result = await collection.deleteOne({ sessionId: sessionId, timestamp: timestamp });
+      return result.acknowledged;
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  public async getItemsBySession({ tableName, sessionId }: IGetItems): Promise<any[]> {
+    try {
+      const collection = await this.dbClient.db().collection(tableName);
+      return await collection.find({ sessionId: sessionId }).toArray();
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+
+  public handleError(error: any): IHandleErrorOutput {
+    this.logger.error(error);
+    return {
+      errorType: ErrorType.ABORT,
+      error: error,
+    };
+  }
+
+}

package/adapters/queue/BeanstalkdAdapter.ts

@@ -0,0 +1,41 @@
+import { Client } from "node-beanstalk";
+import winston from "winston";
+import { AbstractQueueAdapter } from "../../types/interfaces";
+
+export class BeanstalkdAdapter implements AbstractQueueAdapter {
+  logger: winston.Logger;
+  client: Client;
+
+  constructor(logger: winston.Logger) {
+    this.logger = logger;
+    this.client = new Client();
+  }
+
+  private async connect(): Promise<void> {
+    await this.client.connect();
+  }
+
+  async pushToQueue(body: Object): Promise<Object> {
+    if (!this.client.isConnected) await this.connect();
+    const result = await this.client.put(body);
+    return result;
+  }
+
+  async pullFromQueue(): Promise<Object> {
+    if (!this.client.isConnected) await this.connect();
+    const job = await this.client.reserveWithTimeout(1);
+    return job || {};
+  }
+
+  async removeFromQueue(body: Record<string, any>): Promise<boolean> {
+    if (!this.client.isConnected) await this.connect();
+    const jobId = body.id;
+    const result = await this.client.delete(jobId);
+    return result;
+  }
+
+  getEventJSONsFromMessages(body: any[]): Object[] {
+    this.logger.warn("Method not implemented.");
+    return body;
+  }
+}

package/adapters/queue/RedisAdapter.ts

@@ -0,0 +1,34 @@
+import RedisTaskQueue = require("redis-task-queue");
+import winston from "winston";
+import { AbstractQueueAdapter } from "../../types/interfaces";
+
+export class RedisAdapter implements AbstractQueueAdapter {
+  logger: winston.Logger;
+  client: RedisTaskQueue;
+
+  constructor(logger: winston.Logger) {
+    this.logger = logger;
+    this.client = new RedisTaskQueue();
+  }
+
+  async pushToQueue(body: Object): Promise<Object> {
+    const result = await this.client.add({ data: body });
+    return result;
+  }
+
+  async pullFromQueue(): Promise<Object> {
+    const job = await this.client.get();
+    return job || {};
+  }
+
+  async removeFromQueue(body: Record<string, any>): Promise<boolean> {
+    const jobId = body.id;
+    const result = await this.client.getStatus(jobId);
+    return result === 'completed';
+  }
+
+  getEventJSONsFromMessages(body: any[]): Object[] {
+    this.logger.warn("Method not implemented.");
+    return body;
+  }
+}

package/adapters/queue/SqsQueueAdapter.ts

@@ -0,0 +1,127 @@
+import {
+  SQSClient,
+  SendMessageCommand,
+  SendMessageCommandInput,
+  ReceiveMessageCommandInput,
+  ReceiveMessageCommand,
+  DeleteMessageCommandInput,
+  Message,
+  DeleteMessageCommand,
+} from '@aws-sdk/client-sqs';
+import { AbstractQueueAdapter } from '../../types/interfaces';
+import winston from 'winston';
+
+export class SqsQueueAdapter implements AbstractQueueAdapter {
+  logger: winston.Logger;
+  client: SQSClient;
+
+  constructor(logger: winston.Logger) {
+    this.logger = logger;
+    let region: any;
+    if ('QUEUE_REGION' in process.env) {
+      region = process.env.QUEUE_REGION;
+    } else {
+      region = process.env.AWS_REGION;
+    }
+    this.logger.info(`SQS Region: ${region}`);
+    this.client = new SQSClient({ region: region });
+  }
+
+  async pushToQueue(event: Object): Promise<any> {
+    if (process.env.SQS_QUEUE_URL === 'undefined') {
+      return { message: 'SQS_QUEUE_URL is undefined' };
+    }
+    const params: SendMessageCommandInput = {
+      MessageAttributes: {
+        Event: {
+          DataType: 'String',
+          StringValue: event['event'],
+        },
+        Time: {
+          DataType: 'String',
+          StringValue: event['timestamp']
+            ? event['timestamp']
+            : new Date().toISOString(),
+        },
+      },
+      QueueUrl: process.env.SQS_QUEUE_URL,
+      MessageBody: JSON.stringify(event),
+    };
+    const sendMessageCommand = new SendMessageCommand(params);
+    try {
+      const sendMessageResult = await this.client.send(sendMessageCommand);
+      this.logger.info(
+        `Response from SQS: ${JSON.stringify(sendMessageResult)}`
+      );
+      return sendMessageResult;
+    } catch (err) {
+      this.logger.error(err);
+      return err;
+    }
+  }
+
+  async pullFromQueue(): Promise<any> {
+    if (process.env.SQS_QUEUE_URL === 'undefined') {
+      return { message: 'SQS_QUEUE_URL is undefined' };
+    }
+    let maxMessages: number = 10;
+    if (typeof process.env.SQS_MAX_MESSAGES === 'number') {
+      maxMessages = process.env.SQS_MAX_MESSAGES;
+    }
+    let waitTime: number = 20;
+    if (typeof process.env.SQS_WAIT_TIME === 'number') {
+      waitTime = process.env.SQS_WAIT_TIME;
+    }
+    const params: ReceiveMessageCommandInput = {
+      QueueUrl: process.env.SQS_QUEUE_URL,
+      MaxNumberOfMessages: maxMessages,
+      MessageAttributeNames: ['All'],
+      WaitTimeSeconds: waitTime,
+    };
+    const receiveMessageCommand = new ReceiveMessageCommand(params);
+    try {
+      const receiveMessageResult = await this.client.send(
+        receiveMessageCommand
+      );
+      this.logger.info(
+        `Reserved Messages From SQS Count: ${
+          receiveMessageResult.Messages
+            ? receiveMessageResult.Messages.length
+            : 0
+        }`
+      );
+      if (!receiveMessageResult.Messages) {
+        return [];
+      }
+      return receiveMessageResult.Messages;
+    } catch (err) {
+      this.logger.error(err);
+      return err;
+    }
+  }
+
+  async removeFromQueue(queueMsg: Message) {
+    if (process.env.SQS_QUEUE_URL === 'undefined') {
+      return { message: 'SQS_QUEUE_URL is undefined' };
+    }
+    const params: DeleteMessageCommandInput = {
+      QueueUrl: process.env.SQS_QUEUE_URL,
+      ReceiptHandle: queueMsg.ReceiptHandle,
+    };
+    const deleteMessageCommand = new DeleteMessageCommand(params);
+    try {
+      const deleteMessageResult = await this.client.send(deleteMessageCommand);
+      this.logger.info(
+        `Response from SQS: ${JSON.stringify(deleteMessageResult)}`
+      );
+      return deleteMessageResult;
+    } catch (err) {
+      this.logger.error(JSON.stringify(err));
+      return err;
+    }
+  }
+
+  getEventJSONsFromMessages(messages: Message[]): any[] {
+    return messages.map((item) => (item.Body ? JSON.parse(item.Body) : {}));
+  }
+}

package/build/adapters/db/DynamoDBAdapter.d.ts

@@ -0,0 +1,14 @@
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import winston from 'winston';
+import { AbstractDBAdapter, IGetItemInput, IGetItems, IPutItemInput, IHandleErrorOutput } from '../../types/interfaces';
+export declare class DynamoDBAdapter implements AbstractDBAdapter {
+    logger: winston.Logger;
+    dbClient: DynamoDBClient;
+    constructor(logger: winston.Logger);
+    tableExists(name: string): Promise<boolean>;
+    putItem(params: IPutItemInput): Promise<boolean>;
+    getItem(params: IGetItemInput): Promise<any>;
+    deleteItem(params: IGetItemInput): Promise<boolean>;
+    getItemsBySession(params: IGetItems): Promise<any[]>;
+    handleError(errorObject: any): IHandleErrorOutput;
+}

package/build/adapters/db/DynamoDBAdapter.js

@@ -0,0 +1,138 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoDBAdapter = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const interfaces_1 = require("../../types/interfaces");
+class DynamoDBAdapter {
+    constructor(logger) {
+        this.dbClient = new client_dynamodb_1.DynamoDBClient({
+            region: process.env.AWS_REGION,
+            maxAttempts: 5,
+        });
+        this.logger = logger;
+    }
+    tableExists(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const params = { TableName: name };
+                const tablesData = yield this.dbClient.send(new client_dynamodb_1.DescribeTableCommand(params));
+                if (tablesData['Table'] && tablesData['Table'].TableStatus === 'ACTIVE')
+                    return true;
+                return false;
+            }
+            catch (awsError) {
+                if (awsError.name && awsError.name === 'ResourceNotFoundException') {
+                    return false;
+                }
+                else {
+                    this.logger.error(awsError);
+                    throw new Error(awsError);
+                }
+            }
+        });
+    }
+    putItem(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield this.dbClient.send(new client_dynamodb_1.PutItemCommand({
+                    TableName: params.tableName,
+                    Item: (0, util_dynamodb_1.marshall)(params.data),
+                }));
+                return data.$metadata.httpStatusCode === 200;
+            }
+            catch (err) {
+                throw this.handleError(err);
+            }
+        });
+    }
+    getItem(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield this.dbClient.send(new client_dynamodb_1.GetItemCommand({
+                    TableName: params.tableName,
+                    Key: (0, util_dynamodb_1.marshall)({
+                        sessionId: params.sessionId,
+                        timestamp: params.timestamp,
+                    }),
+                }));
+                this.logger.debug('Read Item from Table');
+                return data;
+            }
+            catch (err) {
+                throw this.handleError(err);
+            }
+        });
+    }
+    deleteItem(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const data = yield this.dbClient.send(new client_dynamodb_1.DeleteItemCommand({
+                    TableName: params.tableName,
+                    Key: (0, util_dynamodb_1.marshall)({
+                        sessionId: params.sessionId,
+                        timestamp: params.timestamp,
+                    }),
+                }));
+                this.logger.debug('Deleted Item from Table', data);
+                return data.$metadata.httpStatusCode === 200;
+            }
+            catch (err) {
+                throw this.handleError(err);
+            }
+        });
+    }
+    getItemsBySession(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const inputData = {
+                    TableName: params.tableName,
+                    KeyConditionExpression: '#sid = :sid',
+                    ExpressionAttributeNames: {
+                        '#sid': 'sessionId',
+                    },
+                    ExpressionAttributeValues: (0, util_dynamodb_1.marshall)({
+                        ':sid': params.sessionId,
+                    }),
+                };
+                const queryData = yield this.dbClient.send(new client_dynamodb_1.QueryCommand(inputData));
+                if (queryData.Items && queryData.Items.length > 0) {
+                    let items = [];
+                    for (let i = 0; i < queryData.Items.length; i++) {
+                        items[i] = (0, util_dynamodb_1.unmarshall)(queryData.Items[i]);
+                    }
+                    return items;
+                }
+                return [];
+            }
+            catch (err) {
+                throw this.handleError(err);
+            }
+        });
+    }
+    handleError(errorObject) {
+        this.logger.error(errorObject);
+        const errorOutput = {
+            errorType: interfaces_1.ErrorType.ABORT,
+            error: errorObject,
+        };
+        if (errorObject.name) {
+            if (errorObject.name === 'ResourceNotFoundException' ||
+                errorObject.name === 'ResourceInUseException') {
+                errorOutput['errorType'] = interfaces_1.ErrorType.CONTINUE;
+            }
+        }
+        return errorOutput;
+    }
+}
+exports.DynamoDBAdapter = DynamoDBAdapter;
+//# sourceMappingURL=DynamoDBAdapter.js.map

package/build/adapters/db/DynamoDBAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DynamoDBAdapter.js","sourceRoot":"","sources":["../../../adapters/db/DynamoDBAdapter.ts"],"names":[],"mappings":"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"}

package/build/adapters/db/MongoDBAdapter.d.ts

@@ -0,0 +1,16 @@
+import { Logger } from "winston";
+import { AbstractDBAdapter, IHandleErrorOutput, IPutItemInput, IGetItemInput, IGetItems } from "../../types/interfaces";
+import { MongoClient } from "mongodb";
+export declare class MongoDBAdapter implements AbstractDBAdapter {
+    logger: Logger;
+    dbClient: MongoClient;
+    constructor(logger: Logger);
+    private isConnected;
+    private connect;
+    tableExists(tableName: string): Promise<boolean>;
+    putItem({ tableName, data }: IPutItemInput): Promise<boolean>;
+    getItem({ sessionId, tableName, timestamp }: IGetItemInput): Promise<any>;
+    deleteItem({ sessionId, tableName, timestamp }: IGetItemInput): Promise<boolean>;
+    getItemsBySession({ tableName, sessionId }: IGetItems): Promise<any[]>;
+    handleError(error: any): IHandleErrorOutput;
+}