Initial commit

Author: jaxxreal

.editorconfig

@@ -0,0 +1,7 @@
+root = true
+
+[*.*]
+indent_style = space
+indent_size = 2
+
+insert_final_newline = true

.gitignore

@@ -0,0 +1,2 @@
+node_modules
+.idea

.prettierrc.json

@@ -0,0 +1,7 @@
+{
+  "trailingComma": "all",
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": true,
+  "printWidth": 140
+}

jest.config.ts

@@ -0,0 +1,17 @@
+/*
+ * For a detailed explanation regarding each configuration property and type check, visit:
+ * https://jestjs.io/docs/en/configuration.html
+ */
+
+export default {
+  preset: 'ts-jest',
+  transform: {
+    '^.+\\.ts$': 'ts-jest',
+  },
+
+  // The directory where Jest should output its coverage files
+  coverageDirectory: 'coverage',
+
+  // The test environment that will be used for testing
+  testEnvironment: 'node',
+};

package.json

@@ -0,0 +1,20 @@
+{
+  "name": "http-forwarder",
+  "version": "1.0.0",
+  "main": "index.js",
+  "license": "MIT",
+  "devDependencies": {
+    "jest": "^26.6.1",
+    "prettier": "^2.1.2",
+    "ts-jest": "^26.4.3",
+    "ts-node": "^9.0.0",
+    "typescript": "^4.0.5"
+  },
+  "scripts": {
+    "test": "jest"
+  },
+  "dependencies": {
+    "axios": "^0.21.0",
+    "axios-logger": "^2.4.0"
+  }
+}

src/controllers/RootController.ts

@@ -0,0 +1,29 @@
+import { IDashboardServices, TrackingEvent } from '../services/IDashboardServices';
+import { IncomingMessage, ServerResponse } from 'http';
+
+type EventsPayload = { events: TrackingEvent[] };
+
+export class RootController {
+  constructor(private request: IncomingMessage, private response: ServerResponse, private dashboardServices: IDashboardServices[]) {}
+
+  handleRequest(data: unknown) {
+    if (this.request.url === '/' && this.request.method === 'POST') {
+      this.processEvents(data as EventsPayload);
+    } else {
+      this.response.writeHead(404);
+      this.response.end('Not found');
+    }
+  }
+
+  private async processEvents({ events }: EventsPayload) {
+    const promises = [];
+
+    events.forEach(event => {
+      promises.push(...this.dashboardServices.map(service => service.send(event)));
+    });
+
+    await Promise.all(promises);
+    this.response.writeHead(200);
+    this.response.end('OK');
+  }
+}

src/index.ts

@@ -0,0 +1,26 @@
+import * as http from 'http';
+import { RootController } from './controllers/RootController';
+import { MonitorService } from './services/MonitorService';
+import { SkyAnalyticsService } from './services/SkyAnalyticsService';
+import { MapcodeService } from './services/MapcodeService';
+import { SpaceshipService } from './services/SpaceshipService';
+
+http.createServer((request, response) => {
+  let chunks = '';
+  request.on('data', chunk => {
+    chunks += chunk;
+    if (chunks.length > 1e6) {
+      // kill the request if a payload too big
+      request.connection.destroy();
+    }
+  });
+  request.on('end', () => {
+    const data = JSON.parse(chunks);
+
+    new RootController(request, response, [
+      new MonitorService(),
+      new SkyAnalyticsService(new MapcodeService()),
+      new SpaceshipService(),
+    ]).handleRequest(data);
+  })
+}).listen(1337);

src/mocks/testEvents.ts

@@ -0,0 +1,27 @@
+import { TrackingEvent } from '../services/IDashboardServices';
+
+export const testEvent1: TrackingEvent = {
+  t: 'lift-off',
+  engines: 4,
+  fuel: 78,
+  successful: true,
+  temperature: {
+    engine: 80,
+    cabin: 31,
+  },
+  timestamp: 1595244264059,
+  'lat-lon': [-16.270183, 168.110748],
+};
+
+export const testEvent2: TrackingEvent = {
+  t: 'landing',
+  engines: 1,
+  fuel: 26,
+  successful: true,
+  temperature: {
+    engine: 80,
+    cabin: 31,
+  },
+  timestamp: 1595524813145,
+  'lat-lon': [51.769455, 182.81861],
+};

src/services/IDashboardServices.ts

@@ -0,0 +1,22 @@
+import { AxiosInstance } from 'axios';
+
+export interface TrackingEvent {
+  t: string;
+  engines: number;
+  fuel: number;
+  successful: boolean;
+  temperature: Temperature;
+  timestamp: number;
+  'lat-lon': [number, number];
+}
+
+export interface Temperature {
+  engine: number;
+  cabin: number;
+}
+
+export interface IDashboardServices {
+  URL: string;
+  client: AxiosInstance;
+  send(payload: TrackingEvent): Promise<any>;
+}

src/services/MapcodeService.ts

@@ -0,0 +1,40 @@
+import axios, { AxiosInstance } from 'axios';
+import * as AxiosLogger from 'axios-logger';
+
+type LatLon = [number, number];
+
+export interface IMapcodeService {
+  convertLocationToMapcode(location: LatLon): Promise<Mapcode>;
+}
+
+export class MapcodeService implements IMapcodeService {
+  client: AxiosInstance;
+
+  constructor() {
+    this.client = axios.create({
+      baseURL: 'https://api.mapcode.com/mapcode',
+    });
+    this.client.interceptors.response.use(AxiosLogger.responseLogger);
+    this.client.interceptors.request.use(AxiosLogger.requestLogger);
+  }
+
+  async convertLocationToMapcode(location: LatLon) {
+    const response = await this.client.get<Mapcode>(`/codes/${location.join(',')}`);
+    return response.data;
+  }
+}
+
+export interface Mapcode {
+  international: International;
+  local: Local;
+  mapcodes: Local[];
+}
+
+export interface International {
+  mapcode: string;
+}
+
+export interface Local {
+  mapcode: string;
+  territory?: string;
+}

src/services/MonitorService.test.ts

@@ -0,0 +1,41 @@
+import axios, { AxiosInstance } from 'axios';
+
+import { MonitorService } from './MonitorService';
+import { testEvent1, testEvent2 } from '../mocks/testEvents';
+
+let monitorService: MonitorService;
+let axiosInstanceMock: AxiosInstance;
+const testEvent1Transformed = { ...testEvent1 };
+delete testEvent1Transformed.timestamp;
+
+const testEvent2Transformed = { ...testEvent2 };
+delete testEvent2Transformed.timestamp;
+
+beforeEach(() => {
+  axiosInstanceMock = {
+    put: jest.fn().mockResolvedValue('OK'),
+  } as any;
+  (axios as any).create = jest.fn(() => axiosInstanceMock);
+  monitorService = new MonitorService();
+});
+
+describe('MonitorService', () => {
+  test('should exist', () => {
+    expect(monitorService).toBeTruthy();
+  });
+
+  test.each([
+    ['event1', testEvent1, testEvent1Transformed],
+    ['event2', testEvent2, testEvent2Transformed],
+  ])('should send tracking event "%s" properly', async (eventName, input, result) => {
+    expect(await monitorService.send(input)).toBe('OK');
+
+    expect((axios as any).create).toBeCalledWith({
+      baseURL: monitorService.URL,
+    });
+
+    const timestamp = (input.timestamp / 1000).toFixed(0);
+
+    expect(axiosInstanceMock.put).toBeCalledWith(timestamp, result);
+  });
+});

src/services/MonitorService.ts

@@ -0,0 +1,27 @@
+import { IDashboardServices, TrackingEvent } from './IDashboardServices';
+import axios, { AxiosInstance } from 'axios';
+import * as AxiosLogger from 'axios-logger';
+
+export class MonitorService implements IDashboardServices {
+  URL = 'https://sweeps.proxy.beeceptor.com/m0nit0r.com/track_ship/';
+
+  client: AxiosInstance;
+
+  constructor() {
+    this.client = axios.create({
+      baseURL: this.URL,
+    });
+    this.client.interceptors.response.use(AxiosLogger.responseLogger);
+    this.client.interceptors.request.use(AxiosLogger.requestLogger);
+  }
+
+  transformData(payload: TrackingEvent) {
+    const { timestamp, ..._payload } = payload;
+    return { timestamp: (timestamp / 1000).toFixed(0), payload: _payload };
+  }
+
+  async send(payload: TrackingEvent) {
+    const { timestamp, payload: event } = this.transformData(payload);
+    return this.client.put(timestamp, event);
+  }
+}

src/services/SkyAnalyticsService.test.ts

@@ -0,0 +1,76 @@
+import axios, { AxiosInstance } from 'axios';
+
+import { testEvent1, testEvent2 } from '../mocks/testEvents';
+import { SkyAnalyticsService } from './SkyAnalyticsService';
+import { IMapcodeService } from './MapcodeService';
+
+let skyAnalyticsService: SkyAnalyticsService;
+let mapcodeService: IMapcodeService;
+let axiosInstanceMock: AxiosInstance;
+
+const testEvent1Transformed = {
+  t: 'lift-off',
+  Engines: 4,
+  Fuel: 78,
+  Successful: true,
+  Temperature: {
+    engine: 80,
+    cabin: 31,
+  },
+  Timestamp: 1595244264059,
+  'Lat-lon': 'CYZ7V.DYDG',
+};
+
+const testEvent2Transformed = {
+  t: 'landing',
+  Engines: 1,
+  Fuel: 26,
+  Successful: true,
+  Temperature: {
+    engine: 80,
+    cabin: 31,
+  },
+  Timestamp: 1595524813145,
+  'Lat-lon': 'V07HV.VS2D',
+};
+
+beforeEach(() => {
+  axiosInstanceMock = {
+    request: jest.fn().mockResolvedValue('OK'),
+  } as any;
+  (axios as any).create = jest.fn(() => axiosInstanceMock);
+  mapcodeService = {
+    convertLocationToMapcode: jest.fn((input) => {
+      switch (input.join(',')) {
+        case '-16.270183,168.110748':
+          return { international: { mapcode: 'CYZ7V.DYDG' } };
+        case '51.769455,182.81861':
+          return { international: { mapcode: 'V07HV.VS2D' } };
+      }
+    }),
+  } as any;
+
+  skyAnalyticsService = new SkyAnalyticsService(mapcodeService);
+});
+
+describe('SkyAnalyticsService', () => {
+  test('should exist', () => {
+    expect(skyAnalyticsService).toBeTruthy();
+  });
+
+  test.each([
+    ['event1', testEvent1, testEvent1Transformed],
+    ['event2', testEvent2, testEvent2Transformed],
+  ])('should send tracking event "%s" properly', async (eventName, input, result) => {
+    expect(await skyAnalyticsService.send(input)).toBe('OK');
+
+    expect((axios as any).create).toBeCalledWith({
+      baseURL: skyAnalyticsService.URL,
+    });
+
+    expect(axiosInstanceMock.request).toBeCalledWith({
+      method: 'POST',
+      data: result,
+    });
+  });
+});

src/services/SkyAnalyticsService.ts

@@ -0,0 +1,44 @@
+import { IDashboardServices, TrackingEvent } from './IDashboardServices';
+import axios, { AxiosInstance } from 'axios';
+import { IMapcodeService } from './MapcodeService';
+import { capitalize } from '../utils';
+import * as AxiosLogger from 'axios-logger';
+
+export class SkyAnalyticsService implements IDashboardServices {
+  URL = 'https://sweeps.proxy.beeceptor.com/skyanalytics/get';
+
+  client: AxiosInstance;
+
+  constructor(private mapcodeService: IMapcodeService) {
+    this.client = axios.create({
+      baseURL: this.URL,
+    });
+    this.client.interceptors.response.use(AxiosLogger.responseLogger);
+    this.client.interceptors.request.use(AxiosLogger.requestLogger);
+  }
+
+  async transformData(payload: TrackingEvent) {
+    const { international } = await this.mapcodeService.convertLocationToMapcode(payload['lat-lon']);
+
+    return Object.keys(payload).reduce((res, key) => {
+      if (key === 't') {
+        return { ...res, t: payload[key] };
+      }
+
+      if (key === 'lat-lon') {
+        res[capitalize(key)] = international.mapcode;
+      } else {
+        res[capitalize(key)] = payload[key];
+      }
+
+      return res;
+    }, {});
+  }
+
+  async send(payload: TrackingEvent) {
+    return this.client.request({
+      method: 'POST',
+      data: await this.transformData(payload),
+    });
+  }
+}