finished error handling, added http transport to Klepper server, handling client options in NodeJS global scope

Author: piotr-szewczyk

package-lock.json

@@ -3,10 +3,13 @@
   "private": true,
   "workspaces": [
     "packages/node",
-    "packages/transport"
+    "packages/transport",
+    "packages/commons"
   ],
   "scripts": {
-    "build": "lerna run build"
+    "build": "lerna run build",
+    "lint": "lerna run lint",
+    "test": "lerna run test"
   },
   "dependencies": {},
   "devDependencies": {

package.json

@@ -1,6 +1,8 @@
 {
   "name": "@klepper/commons",
   "version": "0.0.1",
+  "description": "",
+  "author": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "private": "false",
@@ -16,7 +18,22 @@
     "test:watch": "jest --watch --notify"
   },
   "dependencies": {
+    "@klepper/transport": "0.0.1",
     "tslint": "^6.1.3",
     "typescript": "^4.6.2"
+  },
+  "jest": {
+    "verbose": false,
+    "testURL": "http://localhost/",
+    "transform": {
+      "^.+\\.ts$": "ts-jest"
+    },
+    "moduleFileExtensions": [
+      "js",
+      "ts"
+    ],
+    "testMatch": [
+      "**/*.test.ts"
+    ]
   }
 }

packages/commons/package.json

@@ -0,0 +1,14 @@
+import { KlepperGlobal } from "@klepper/transport";
+
+export const getGlobalClientData = (): KlepperGlobal => global.__KLEPPER__ || {};
+
+export const setGlobalClientData = (data: KlepperGlobal): void => {
+    global.__KLEPPER__ = { ...data };
+}
+
+export const clearGlobalClientData = (): void => {
+    setGlobalClientData({
+        environment: undefined,
+        privateKey: undefined
+    })
+}

packages/commons/src/global.ts

@@ -1,58 +1,90 @@
+import { RequestPayload, RequestOptions, KlepperResponse, KlepperIncomingMessage, RequestStatus } from "@klepper/transport";
 import * as http from "http";
+import { getGlobalClientData } from "./global";
 
-type RequestType = "" | "" | "";
+const KLEPPER_HOST = process.env.KLEPPER_HOST || "localhost";
+const KLEPPER_API = process.env.KLEPPER_API || "/test";
+const KLEPPER_PORT = process.env.KLEPPER_PORT  || 3000;
 
-type HttpMethodType = "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
-
-const KLEPPER_API = process.env.KLEPPER_API;
-const KLEPPER_PORT = process.env.KLEPPER_PORT;
-
-export interface RequestOptions extends http.RequestOptions {
-  hostname: string;
-  port: number;
-  method: HttpMethodType;
-  path?: string;
-  headers?: { [key: string]: string };
-}
-
-export interface RequestPayload {
-  data: string;
-  type: RequestType;
-  url: string;
-}
-
-export const getRequestPath = (path: string) =>
-  `http://api.klepper.io/api/${path}`;
-
-export const getRequestHeaders = () => {};
-
-export const createHttpOptions = (payload: RequestPayload): RequestOptions => {
-  const { url } = payload;
+const createHttpOptions = (payload: RequestPayload): http.RequestOptions => {
+  const client = getGlobalClientData();
+  const { privateKey } = client;
+  const { data } = payload;
   const baseOptions: RequestOptions = {
-    hostname: KLEPPER_API!,
-    method: "POST",
-    port: +KLEPPER_PORT!,
+    hostname: KLEPPER_HOST,
+    port: +KLEPPER_PORT,
+    method: 'POST',
+    headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': `${Buffer.byteLength(JSON.stringify(data))}`,
+        'Klepper-Project-Key': privateKey as string
+    }
   };
 
   return {
-    path: getRequestPath(url),
+    path: KLEPPER_API,
     ...baseOptions,
   };
 };
 
+const statusFromCode = (code: number) => code >= 200 && code <= 299 ? RequestStatus.SUCCESS : RequestStatus.ERROR; 
+
 /**
  * Send data to Klepper server
  * 
  * @param payload 
  */
-export const sendHttpRequest = (payload: RequestPayload) => {
+export const sendEvent = async (payload: RequestPayload): Promise<KlepperResponse> => {
   const { data } = payload;
-  const options = createHttpOptions(payload);
-  const request = http.request(options, (res: http.IncomingMessage) => {
-    res.setEncoding("utf8");
-
-    res.on("data", () => {});
-    res.on("end", () => {});
-  });
-  request.end(data);
+
+  // global.Object = Object({ test: "test" })
+  // console.log("GLOBAL: ", global.Object);
+
+  /**
+   * IMPORTANT TO HANDLE GLOBAL DATA
+   */
+
+  try {
+    return new Promise<KlepperResponse>((resolve, reject) => {
+      const httpOptions = createHttpOptions(payload);
+      const client = getGlobalClientData();
+
+      if (!httpOptions) {
+        reject(new Error("NO HTTP OPTIONS"))
+      }
+
+      if (!client) {
+        reject(new Error("NO CLIENT DATA IN GLOBAL OBJECT"))
+      }
+
+      const request = http.request(httpOptions, (res: KlepperIncomingMessage) => {
+        res.setEncoding("utf8");
+
+        const status = statusFromCode(res?.statusCode as number);
+        const isSuccess = status === RequestStatus.SUCCESS;
+
+        if (!isSuccess) {
+          reject(new Error("HTTP ERROR: ${res.statusCode}"))
+        } else {
+          resolve({
+            statusCode: res?.statusCode as number,
+            statusMessage: "Event successfully sended to Klepper"
+          })
+        }
+    
+        res.on("error", reject);
+      });
+      request.on("error", reject);
+
+      request.on('timeout', () => {
+        request.destroy()
+        reject(new Error("TIMEOUT"));
+      })
+
+      request.write(JSON.stringify(data));
+      request.end();
+    })
+  } catch (error) {
+    throw new Error(""); //to properly handling
+  }
 };

packages/commons/src/http.ts

@@ -0,0 +1,4 @@
+import * as http from "./http";
+import * as global from "./global";
+
+export { http, global };

packages/commons/src/index.ts

@@ -0,0 +1,6 @@
+import { KlepperGlobal } from "@klepper/transport";
+
+declare global {
+    var __KLEPPER__: KlepperGlobal;
+}
+export { };

packages/commons/src/types/global.d.ts

@@ -0,0 +1,34 @@
+import { RequestPayload, KlepperEvent, KlepperRequest, KlepperResponse } from "@klepper/transport";
+import { sendEvent } from "../src/http"
+
+describe("send()", () => {
+
+    let payload: RequestPayload;
+
+    const event: KlepperEvent = {
+        date: new Date().getDate(),
+        message: "OMG IT NOT WORK",
+        type: "OMG",
+        traces: [],
+        requestData: {
+            headers: {
+                hello: "guys"
+            },
+            query: "/hello",
+            method: "POST"
+        }
+    }
+
+    beforeEach(() => {
+        payload = {
+            data: event
+        }
+    });
+
+    it("should send a sample request", async () => {
+        const response: KlepperResponse = await sendEvent(payload);
+
+        expect(response?.statusCode).toBeDefined();
+        expect(response?.statusCode).toBe(200);
+    });
+})

packages/commons/test/http.test.ts

@@ -14,8 +14,8 @@
     "noImplicitReturns": true,
     "noImplicitThis": true,
     "noImplicitUseStrict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
     "preserveWatchOutput": true,
     "pretty": true,
     "sourceMap": true,

packages/config/tsconfig.json

@@ -1,40 +1,23 @@
-import { BaseObject, KlepperIncomingMessage, KlepperRequest, KlepperResponse, KlepperStackFrame } from "@klepper/transport";
+import { BaseObject, KlepperIncomingMessage, KlepperRequest, Trace } from "@klepper/transport";
 import { StackFrame } from "stack-trace";
 
-const mapStackFrames = (stackFrames: StackFrame[], onlyInternal: boolean = true) => {
-    const frames: KlepperStackFrame[] = [];
-
-    const parse = (stackFrame: StackFrame): KlepperStackFrame => {
+const prepareStackTraces = (stackFrames: StackFrame[]): Trace[] => {
+    const parseTraces = (frame: StackFrame): Trace => {
         return {
-            functionName: stackFrame.getFunctionName(),
-            lineNumber: stackFrame.getLineNumber(),
-            columnNumber: stackFrame.getColumnNumber(),
-            fileName: stackFrame.getFileName(),
-            methodName: stackFrame.getMethodName(),
+            functionName: frame.getFunctionName(), //return absolut path, need to extract also function name
+            rowNo: frame.getLineNumber(),
+            colNo: frame.getColumnNumber(),
+            fileName: frame.getFileName(),
+            absolutePath: frame.getFunctionName(),
+            isInternal: isInternal(frame.getFileName()),
         }
     }
 
-    stackFrames.map((f) => {
-        if (onlyInternal) {
-            const fileName = f.getFileName();
-            const isInternal = fileName && !fileName.includes('node_modules') && !fileName.startsWith('/') && !fileName.startsWith('node:') && fileName.includes(":\\");
-
-            isInternal ? frames.push(parse(f)) : null;
-        } else {
-            frames.push(parse(f));
-        }
-    });
-
-    return frames;
+    const traces = stackFrames.map((frame) => parseTraces(frame)) || [];
+    return traces;
 }
 
-const createPayloadFromRequest = (req: KlepperRequest, res: KlepperResponse) => {
-    return {
-        request: req,
-        response: res,
-        date: new Date().getDate()
-    }
-}
+const isInternal = (fileName: string): boolean => !!fileName && !fileName.includes('node_modules') && !fileName.startsWith('/') && !fileName.startsWith('node:') && fileName.includes(":\\");
 
 const mapRequestData = (req: BaseObject): KlepperRequest => {
     const headersData = req.headers || req.header || {};
@@ -93,9 +76,8 @@ const getProtocol = (req: KlepperIncomingMessage): string => {
 
 export const helpers = {
     getIp,
-    createPayloadFromRequest,
     mapRequestData,
-    mapStackFrames,
+    prepareStackTraces,
     getProtocol,
     isLocalhost
 }