@eyevinn/player-analytics-shared 0.5.0

package/spec/adapters/DynamoDBAdapter.spec.ts

@@ -0,0 +1,275 @@
+import {
+  CreateTableCommand,
+  ListTablesCommand,
+  PutItemCommand,
+  DynamoDBClient,
+  GetItemCommand,
+  DeleteItemCommand,
+  CreateTableCommandOutput,
+  PutItemCommandOutput,
+  GetItemCommandOutput,
+  DeleteItemCommandOutput,
+  QueryCommand,
+  QueryCommandOutput,
+  DescribeTableCommand,
+  DescribeTableCommandOutput,
+} from '@aws-sdk/client-dynamodb';
+import { AwsError, mockClient } from 'aws-sdk-client-mock';
+import { DynamoDBAdapter } from '../../adapters/db/DynamoDBAdapter';
+import { ErrorType } from '../../types/interfaces';
+import Logger from '../../util/logger';
+
+const ddbMock = mockClient(DynamoDBClient);
+
+describe('Dynamo DB Adapter', () => {
+  beforeEach(() => {
+    process.env.AWS_REGION = 'us-east-1';
+    ddbMock.reset();
+  });
+
+  it('should return true if table exists in database', async () => {
+    const DDBReply: DescribeTableCommandOutput = {
+      Table: {
+        TableArn: 'arn:aws:dynamodb:us-west-2:123456789012:table/mock_table_1',
+        AttributeDefinitions: [
+          {
+            AttributeName: 'sessionId',
+            AttributeType: 'S',
+          },
+          {
+            AttributeName: 'timestamp',
+            AttributeType: 'N',
+          },
+        ],
+        KeySchema: [
+          {
+            AttributeName: 'sessionId',
+            KeyType: 'HASH',
+          },
+          {
+            AttributeName: 'timestamp',
+            KeyType: 'RANGE',
+          },
+        ],
+        LocalSecondaryIndexes: [],
+        ProvisionedThroughput: {
+          NumberOfDecreasesToday: 0,
+          ReadCapacityUnits: 5,
+          WriteCapacityUnits: 5,
+        },
+        TableName: 'mock_table_1',
+        TableSizeBytes: 0,
+        TableStatus: 'ACTIVE',
+      },
+      $metadata: {
+        httpStatusCode: 200,
+        requestId: 'df840ab9-e68b-5c0e-b4a0-5094f2dfaee8',
+      }
+    };
+    const adapter = new DynamoDBAdapter(Logger);
+    ddbMock.on(DescribeTableCommand).resolves(DDBReply);
+    const result = await adapter.tableExists('mock_table_1');
+    expect(result).toEqual(true);
+  });
+
+  it('should return false if table does not exists in database', async () => {
+    const DDBReply: AwsError = {
+      Type: 'Sender',
+      Code: 'ResourceNotFoundException',
+      name: 'ResourceNotFoundException',
+      $fault: 'client',
+      $metadata: {
+        httpStatusCode: 400,
+        requestId: 'df840ab9-e68b-5c0e-b4a0-5094f2dfaee8',
+        attempts: 1,
+        totalRetryDelay: 0,
+      },
+    };
+    const adapter = new DynamoDBAdapter(Logger);
+    ddbMock.on(DescribeTableCommand).resolves(DDBReply);
+    const result = await adapter.tableExists('mock_table_1');
+    expect(result).toEqual(false);
+  });
+
+  it('should put item to database', async () => {
+    const DDBReply: PutItemCommandOutput = {
+      $metadata: {
+        httpStatusCode: 200,
+      },
+    };
+    const adapter = new DynamoDBAdapter(Logger);
+    const mockEvent = {
+      event: 'loading',
+      timestamp: 0,
+      playhead: 0,
+      duration: 0,
+      host: 'mock.tenant.mock',
+    };
+    ddbMock.on(PutItemCommand).resolves(DDBReply);
+    const result = await adapter.putItem({
+      tableName: 'table_1',
+      data: mockEvent,
+    });
+    expect(result).toBeTrue();
+  });
+
+  it('should label errorType with "continue" when allowed error occurs', async () => {
+    const DDBReply: AwsError = {
+      Type: 'Sender',
+      Code: 'ResourceNotFoundException',
+      name: 'ResourceNotFoundException',
+      $fault: 'client',
+      $metadata: {
+        httpStatusCode: 400,
+        requestId: 'df840ab9-e68b-5c0e-b4a0-5094f2dfaee8',
+        attempts: 1,
+        totalRetryDelay: 0,
+      },
+    };
+    const adapter = new DynamoDBAdapter(Logger);
+    const mockEvent = {
+      event: 'loading',
+      timestamp: 0,
+      playhead: 0,
+      duration: 0,
+      host: 'mock.tenant.mock',
+    };
+    ddbMock.on(PutItemCommand).rejects(DDBReply);
+    try {
+      const result = await adapter.putItem({
+        tableName: 'table_1',
+        data: mockEvent,
+      });
+    } catch (err) {
+      expect(err.errorType).toEqual(ErrorType.CONTINUE);
+      expect(err.error.Code).toEqual('ResourceNotFoundException');
+    }
+  });
+
+  it('should label errorType with "abort" when non-allowed error occurs', async () => {
+    const DDBReply: AwsError = {
+      Type: 'Sender',
+      Code: 'RequestLimitExceeded',
+      name: 'RequestLimitExceeded',
+      $fault: 'client',
+      $metadata: {
+        httpStatusCode: 400,
+        requestId: 'df840ab9-e68b-5c0e-b4a0-5094f2dfaee8',
+        attempts: 1,
+        totalRetryDelay: 0,
+      },
+    };
+    const adapter = new DynamoDBAdapter(Logger);
+    const mockEvent = {
+      event: 'loading',
+      timestamp: 0,
+      playhead: 0,
+      duration: 0,
+      host: 'mock.tenant.mock',
+    };
+    ddbMock.on(PutItemCommand).rejects(DDBReply);
+    try {
+      const result = await adapter.putItem({
+        tableName: 'table_1',
+        data: mockEvent,
+      });
+    } catch (err) {
+      expect(err.errorType).toEqual(ErrorType.ABORT);
+      expect(err.error.Code).toEqual('RequestLimitExceeded');
+    }
+  });
+
+  it('should get item from database', async () => {
+    const DDBReply: GetItemCommandOutput = {
+      $metadata: {},
+      Item: { eventId: { S: '123-123-123-123' } },
+    };
+    const adapter = new DynamoDBAdapter(Logger);
+    const mockId = '123-123-123-123';
+    ddbMock.on(GetItemCommand).resolves(DDBReply);
+    const result = await adapter.getItem({
+      tableName: 'table_1',
+      sessionId: mockId,
+      timestamp: 0,
+    });
+    expect(result).toEqual({
+      $metadata: {},
+      Item: { eventId: { S: '123-123-123-123' } },
+    });
+  });
+
+  it('should delete item in database', async () => {
+    const DDBReply: DeleteItemCommandOutput = {
+      $metadata: {
+        httpStatusCode: 200,
+      },
+    };
+    const adapter = new DynamoDBAdapter(Logger);
+    const mockId = '123-123-123-123';
+    ddbMock.on(DeleteItemCommand).resolves(DDBReply);
+    const result = await adapter.deleteItem({
+      tableName: 'table_1',
+      sessionId: mockId,
+      timestamp: 0,
+    });
+    expect(result).toBeTrue();
+  });
+
+  it('should get items from db with a specific sessionId and convert them to valid event objects', async () => {
+    const DDBReply: QueryCommandOutput = {
+      $metadata: {},
+      Items: [
+        {
+          event: { S: 'playing' },
+          sessionId: { S: '123-214-234' },
+          timestamp: { N: '1640191099' },
+          playhead: { N: '1' },
+          duration: { N: '0' },
+        },
+        {
+          event: { S: 'playing' },
+          sessionId: { S: '123-214-234' },
+          timestamp: { N: '1640193099' },
+          playhead: { N: '3' },
+          duration: { N: '0' },
+        },
+        {
+          event: { S: 'paused' },
+          sessionId: { S: '123-214-234' },
+          timestamp: { N: '1640192099' },
+          playhead: { N: '2' },
+          duration: { N: '0' },
+        },
+      ],
+    };
+    const adapter = new DynamoDBAdapter(Logger);
+    ddbMock.on(QueryCommand).resolves(DDBReply);
+    const result = await adapter.getItemsBySession({
+      tableName: 'table_1',
+      sessionId: '123-214-234',
+    });
+    expect(result).toEqual([
+      {
+        event: 'playing',
+        sessionId: '123-214-234',
+        timestamp: 1640191099,
+        duration: 0,
+        playhead: 1,
+      },
+      {
+        event: 'playing',
+        sessionId: '123-214-234',
+        timestamp: 1640193099,
+        duration: 0,
+        playhead: 3,
+      },
+      {
+        event: 'paused',
+        sessionId: '123-214-234',
+        timestamp: 1640192099,
+        duration: 0,
+        playhead: 2,
+      },
+    ]);
+  });
+});

package/spec/adapters/MongoDBAdapter.spec.ts

@@ -0,0 +1,170 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoDBAdapter } from '../../adapters/db/MongoDBAdapter';
+import Logger from '../../util/logger';
+
+describe('Mongo DB Adapter', () => {
+  let adapter: MongoDBAdapter;
+  beforeAll(async () => {
+    const instance = await MongoMemoryServer.create();
+    const uri = instance.getUri();
+    (global as any).__MONGOINSTANCE = instance;
+    process.env.MONGODB_URI = uri.slice(0, uri.lastIndexOf('/'));
+    adapter = new MongoDBAdapter(Logger);
+  });
+
+  beforeEach(async () => {
+    const collections = await adapter.dbClient.db().collections();
+    for (const collection of collections) {
+      const c = await adapter.dbClient
+        .db()
+        .collection(collection.collectionName);
+      await c.drop();
+    }
+  });
+
+  afterAll(async () => {
+    const collections = [];
+    for (const collection of collections) {
+      const c = await adapter.dbClient.db().collection(collection);
+      await c.drop();
+    }
+    await adapter.dbClient.close();
+  });
+
+  it('should return true if table exists in database', async () => {
+    const res = await adapter.dbClient.db().createCollection('test_table_1');
+    setTimeout(async () => {
+      const result = await adapter.tableExists('test_table_1');
+      expect(result).toEqual(true);
+    }, 1000);
+  });
+
+  it('should return false if table does not exists in database', async () => {
+    const result = await adapter.tableExists('test_table_1');
+    expect(result).toEqual(false);
+  });
+
+  it('should put item to database', async () => {
+    const mockEvent = {
+      event: 'loading',
+      timestamp: 0,
+      playhead: 0,
+      duration: 0,
+      host: 'mock.tenant.mock',
+    };
+    const result = await adapter.putItem({
+      tableName: 'test_table_1',
+      data: mockEvent,
+    });
+    expect(result).toBeTrue();
+  });
+
+  it('should get item from database', async () => {
+    const mockId = '123-123-123-123';
+    await adapter.putItem({
+      tableName: 'test_table_1',
+      data: {
+        event: 'loading',
+        timestamp: 0,
+        playhead: 0,
+        duration: 0,
+        host: 'mock.tenant.mock',
+        sessionId: mockId,
+      },
+    });
+    const result = await adapter.getItem({
+      tableName: 'test_table_1',
+      sessionId: mockId,
+      timestamp: 0,
+    });
+    expect(result).toBeDefined();
+    expect(result.sessionId).toEqual(mockId);
+    expect(result.host).toEqual('mock.tenant.mock');
+  });
+
+  it('should delete item in database', async () => {
+    const mockId = '123-123-123-123';
+    await adapter.putItem({
+      tableName: 'test_table_1',
+      data: {
+        event: 'loading',
+        timestamp: 0,
+        playhead: 0,
+        duration: 0,
+        host: 'mock.tenant.mock',
+        sessionId: mockId,
+      },
+    });
+    const result = await adapter.deleteItem({
+      tableName: 'test_table_1',
+      sessionId: mockId,
+      timestamp: 0,
+    });
+    expect(result).toBeTrue();
+  });
+
+  it('should get items from db with a specific sessionId and convert them to valid event objects', async () => {
+    const mockItems = [
+      {
+        event: 'playing',
+        sessionId: '123-214-234',
+        timestamp: 1640191099,
+        playhead: 1,
+        duration: 0,
+      },
+      {
+        event: 'playing',
+        sessionId: '123-214-234',
+        timestamp: 1640193099,
+        playhead: 3,
+        duration: 0,
+      },
+      {
+        event: 'paused',
+        sessionId: '123-214-234',
+        timestamp: 1640192099,
+        playhead: 2,
+        duration: 0,
+      },
+    ];
+    // for each mock items, put them to db
+    for (const mockItem of mockItems) {
+      await adapter.putItem({
+        tableName: 'test_table_1',
+        data: mockItem,
+      });
+    }
+    const result = await adapter.getItemsBySession({
+      tableName: 'test_table_1',
+      sessionId: '123-214-234',
+    });
+    // remove the mongodb id to be able to compare by equality
+    const cleanedResult = result.map((item) => {
+      delete item._id;
+      return item;
+    });
+    expect(cleanedResult).toEqual([
+      {
+        event: 'playing',
+        sessionId: '123-214-234',
+        timestamp: 1640191099,
+        duration: 0,
+        playhead: 1,
+      },
+      {
+        event: 'playing',
+        sessionId: '123-214-234',
+        timestamp: 1640193099,
+        duration: 0,
+        playhead: 3,
+      },
+      {
+        event: 'paused',
+        sessionId: '123-214-234',
+        timestamp: 1640192099,
+        duration: 0,
+        playhead: 2,
+      },
+    ]);
+  });
+});

package/spec/adapters/SqsQueueAdapter.spec.ts

@@ -0,0 +1,149 @@
+import {
+  DeleteMessageCommand,
+  Message,
+  ReceiveMessageCommand,
+  SendMessageCommand,
+  SQSClient,
+} from '@aws-sdk/client-sqs';
+import { AwsError, mockClient } from 'aws-sdk-client-mock';
+import { SqsQueueAdapter } from '../../adapters/queue/SqsQueueAdapter';
+import Logger from '../../util/logger';
+
+const sqsMock = mockClient(SQSClient);
+
+describe('SQS Queue Adapter', () => {
+  beforeEach(() => {
+    process.env.AWS_REGION = 'us-east-1';
+    process.env.QUEUE_TYPE = 'SQS';
+    process.env.SQS_QUEUE_URL =
+      'https://sqs.us-east-1.amazonaws.com/1234/test-queue';
+    sqsMock.reset();
+  });
+
+  afterEach(() => {
+    delete process.env.AWS_REGION;
+    delete process.env.QUEUE_TYPE;
+    delete process.env.QUEUE_REGION;
+    delete process.env.SQS_QUEUE_URL;
+  });
+
+  it('should push to queue if default env is set', async () => {
+    const sqsResp = { MessageId: '12345678-4444-5555-6666-111122223333' };
+    const adapter = new SqsQueueAdapter(Logger);
+    const event = {
+      event: 'loading',
+      timestamp: 0,
+      playhead: 0,
+      duration: 0,
+    };
+    sqsMock.on(SendMessageCommand).resolves(sqsResp);
+    const result = await adapter.pushToQueue(event);
+    expect(result).toEqual(sqsResp);
+  });
+
+  it('should push to queue if QUEUE_REGION env is set and AWS_REGION is undefined', async () => {
+    process.env.QUEUE_REGION = 'eu-north-1';
+    process.env.AWS_REGION = undefined;
+    const sqsResp = { MessageId: '12345678-4444-5555-6666-111122223333' };
+    const adapter = new SqsQueueAdapter(Logger);
+    const event = {
+      event: 'loading',
+      timestamp: 0,
+      playhead: 0,
+      duration: 0,
+    };
+    sqsMock.on(SendMessageCommand).resolves(sqsResp);
+    const result = await adapter.pushToQueue(event);
+    expect(result).toEqual(sqsResp);
+  });
+
+  it('should not push to queue if sqs queue env is not set', async () => {
+    process.env.SQS_QUEUE_URL = undefined;
+    const queueAdapter = new SqsQueueAdapter(Logger);
+    const mockEvent = {
+      event: 'loading',
+      timestamp: 0,
+      playhead: 0,
+      duration: 0,
+    };
+    let result = await queueAdapter.pushToQueue(mockEvent);
+    expect(result).toEqual({ message: 'SQS_QUEUE_URL is undefined' });
+  });
+
+  it('should not read from queue if sqs queue env is not set', async () => {
+    process.env.SQS_QUEUE_URL = undefined;
+    const queueAdapter = new SqsQueueAdapter(Logger);
+    let result = await queueAdapter.pullFromQueue();
+    expect(result).toEqual({ message: 'SQS_QUEUE_URL is undefined' });
+  });
+
+  it('should not remove from queue if sqs queue env is not set', async () => {
+    process.env.SQS_QUEUE_URL = undefined;
+    const queueAdapter = new SqsQueueAdapter(Logger);
+    const mockSQSMessage: Message = {
+      MessageId: '62686810-05ba-4b43-62730ff3156g7jd3',
+      ReceiptHandle:
+        'MbZj6wDWli+JvwwJaBV+3dcjk2YW2vA3' +
+        '+STFFljTM8tJJg6HRG6PYSasuWXPJB+C' +
+        'wLj1FjgXUv1uSj1gUPAWV66FU/WeR4mq' +
+        '2OKpEGYWbnLmpRCJVAyeMjeU5ZBdtcQ+' +
+        'QEauMZc8ZRv37sIW2iJKq3M9MFx1YvV11A2x/KSbkJ0=',
+      MD5OfBody: 'fafb00f5732ab283681e124bf8747ed1',
+      Body: JSON.stringify({
+        event: 'loading',
+        timestamp: 0,
+        playhead: 0,
+        duration: 0,
+      }),
+    };
+    let result = await queueAdapter.removeFromQueue(mockSQSMessage);
+    expect(result).toEqual({ message: 'SQS_QUEUE_URL is undefined' });
+  });
+
+  it('should catch error when sending message fails', async () => {
+    const errMsg: AwsError = {
+      Type: 'Sender',
+      Code: 'AWS.SimpleQueueService.NonExistentQueue',
+      name: 'AWS.SimpleQueueService.NonExistentQueue',
+      $fault: 'client',
+      $metadata: {
+        httpStatusCode: 400,
+        requestId: 'df840ab9-e68b-5c0e-b4a0-5094f2dfaee8',
+        attempts: 1,
+        totalRetryDelay: 0,
+      },
+    };
+    const mockSQSMessage: Message = {
+      MessageId: '62686810-05ba-4b43-62730ff3156g7jd3',
+      ReceiptHandle:
+        'MbZj6wDWli+JvwwJaBV+3dcjk2YW2vA3' +
+        '+STFFljTM8tJJg6HRG6PYSasuWXPJB+C' +
+        'wLj1FjgXUv1uSj1gUPAWV66FU/WeR4mq' +
+        '2OKpEGYWbnLmpRCJVAyeMjeU5ZBdtcQ+' +
+        'QEauMZc8ZRv37sIW2iJKq3M9MFx1YvV11A2x/KSbkJ0=',
+      MD5OfBody: 'fafb00f5732ab283681e124bf8747ed1',
+      Body: JSON.stringify({
+        event: 'loading',
+        timestamp: 0,
+        playhead: 0,
+        duration: 0,
+      }),
+    };
+    const mockEvent = {
+      event: 'loading',
+      timestamp: 0,
+      playhead: 0,
+      duration: 0,
+    };
+    sqsMock.on(SendMessageCommand).rejects(errMsg);
+    sqsMock.on(ReceiveMessageCommand).rejects(errMsg);
+    sqsMock.on(DeleteMessageCommand).rejects(errMsg);
+    const queueAdapter = new SqsQueueAdapter(Logger);
+    let pushResult = await queueAdapter.pushToQueue(mockEvent);
+    let readResult = await queueAdapter.pullFromQueue();
+    let removeResult = await queueAdapter.removeFromQueue(mockSQSMessage);
+    expect(pushResult.toString()).toEqual(errMsg.Code);
+    expect(readResult.toString()).toEqual(errMsg.Code);
+    expect(removeResult.toString()).toEqual(errMsg.Code);
+  });
+});

package/spec/support/jasmine.json

@@ -0,0 +1,11 @@
+{
+  "spec_dir": "spec",
+  "spec_files": [
+    "**/*[sS]pec.ts"
+  ],
+  "helpers": [
+    "helpers/**/*.ts"
+  ],
+  "stopSpecOnExpectationFailure": false,
+  "random": true
+}

package/tsconfig-build.json

@@ -0,0 +1,6 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": [
+    "spec/**/*.spec.ts"
+  ]
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "esModuleInterop": true,
+    "target": "es6",
+    "moduleResolution": "node",
+    "sourceMap": true,
+    "outDir": "build",
+    "resolveJsonModule": true,
+    "strictNullChecks": true,
+    "declaration": true,
+    "declarationDir": "./build"
+  },
+  "lib": ["es2015"],
+  "exclude": [
+    "../node_modules"
+  ],
+  "include": [
+    "./**/*.ts"
+  ]
+}

package/tslint.json

@@ -0,0 +1,9 @@
+{
+  "defaultSeverity": "error",
+  "extends": [
+      "tslint:recommended"
+  ],
+  "jsRules": {},
+  "rules": {},
+  "rulesDirectory": []
+}

package/types/db.ts

@@ -0,0 +1,39 @@
+import winston from 'winston';
+
+export enum ErrorType {
+  'ABORT' = 0,
+  'CONTINUE' = 1,
+}
+
+export interface IHandleErrorOutput {
+  errorType: ErrorType;
+  error: Object;
+}
+
+export interface IPutItemInput {
+  tableName: string;
+  data: Object;
+}
+
+export interface IGetItems {
+  sessionId: string;
+  tableName: string;
+}
+
+export interface IGetItemInput {
+  tableName: string;
+  sessionId: string;
+  timestamp: number;
+}
+
+export abstract class AbstractDBAdapter {
+  logger: winston.Logger;
+  dbClient: any;
+
+  abstract tableExists(name: string): Promise<boolean>;
+  abstract putItem(params: IPutItemInput): Promise<boolean>;
+  abstract getItem(params: IGetItemInput): Promise<any>;
+  abstract deleteItem(params: IGetItemInput): Promise<boolean>;
+  abstract getItemsBySession(params: IGetItems): Promise<any[]>;
+  abstract handleError(error: any): IHandleErrorOutput;
+}

package/types/interfaces.ts

@@ -0,0 +1,2 @@
+export * from './db';
+export * from './queue';

package/types/queue.ts

@@ -0,0 +1,17 @@
+import winston from 'winston';
+
+export interface EventValidator {
+  logger: winston.Logger;
+  eventSchema: any;
+  validateEvent(event: Object): any;
+  validateEventList(eventList: Array<Object>): any;
+}
+
+export abstract class AbstractQueueAdapter {
+  logger: winston.Logger;
+  client: any;
+  abstract pushToQueue(body: Object): Promise<Object>;
+  abstract pullFromQueue(): Promise<Object>;
+  abstract removeFromQueue(body: Object): Promise<Object>;
+  abstract getEventJSONsFromMessages(body: any[]): Object[];
+}