added based middleware for catch exceptions, http transport logic, helpers

Author: piotr-szewczyk

packages/commons/package.json

@@ -10,6 +10,8 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "lint": "run-s lint:prettier",
+    "lint:prettier": "prettier */**/*.{js,ts,tsx} --write",
     "test": "jest",
     "test:watch": "jest --watch --notify"
   },

packages/commons/src/http.ts

@@ -0,0 +1,58 @@
+import * as http from "http";
+
+type RequestType = "" | "" | "";
+
+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 baseOptions: RequestOptions = {
+    hostname: KLEPPER_API!,
+    method: "POST",
+    port: +KLEPPER_PORT!,
+  };
+
+  return {
+    path: getRequestPath(url),
+    ...baseOptions,
+  };
+};
+
+/**
+ * Send data to Klepper server
+ * 
+ * @param payload 
+ */
+export const sendHttpRequest = (payload: RequestPayload) => {
+  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);
+};

packages/commons/tslint.json

@@ -0,0 +1,3 @@
+{
+    "extends": "../../tslint.json"
+}

packages/config/tslint.json

@@ -0,0 +1,17 @@
+{
+    "extends": ["tslint:all", "tslint-config-prettier"],
+    "rules": {
+      "no-unused-variable": false,
+      "no-submodule-imports": false,
+        "newline-before-return": false,
+      "no-any": false,
+      "no-magic-numbers": false,
+      "no-parameter-properties": false,
+      "no-require-imports": false,
+      "prefer-function-over-method": [false],
+      "strict-boolean-expressions": false,
+      "no-inferrable-types": false,
+      "no-console": [true, "log"]
+    }
+  }
+  

packages/node/package.json

@@ -4,17 +4,16 @@
   "description": "",
   "author": "",
   "license": "MIT",
-  "engines": {
-    "node": ">=6"
-  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
+    "@klepper/commons": "0.0.1",
     "@klepper/transport": "0.0.1",
-    "@klepper/commons": "0.0.1"
+    "@types/stack-trace": "^0.0.29",
+    "stack-trace": "0.0.10"
   },
   "devDependencies": {
-    "jest": "^22.4.3",
+    "jest": "^26.5.5",
     "npm-run-all": "^4.1.2",
     "prettier": "^1.14.0",
     "prettier-check": "^2.0.0",
@@ -24,7 +23,23 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "lint": "run-s lint:prettier",
+    "lint:prettier": "prettier */**/*.{js,ts,tsx} --write",
     "test": "jest",
     "test:watch": "jest --watch --notify"
+  },
+  "jest": {
+    "verbose": false,
+    "testURL": "http://localhost/",
+    "transform": {
+      "^.+\\.ts$": "ts-jest"
+    },
+    "moduleFileExtensions": [
+      "js",
+      "ts"
+    ],
+    "testMatch": [
+      "**/*.test.ts"
+    ]
   }
-}
+}

packages/node/src/handlers.ts

@@ -0,0 +1,101 @@
+import { BaseObject, KlepperIncomingMessage, KlepperRequest, KlepperResponse, KlepperStackFrame } from "@klepper/transport";
+import { StackFrame } from "stack-trace";
+
+const mapStackFrames = (stackFrames: StackFrame[], onlyInternal: boolean = true) => {
+    const frames: KlepperStackFrame[] = [];
+
+    const parse = (stackFrame: StackFrame): KlepperStackFrame => {
+        return {
+            functionName: stackFrame.getFunctionName(),
+            lineNumber: stackFrame.getLineNumber(),
+            columnNumber: stackFrame.getColumnNumber(),
+            fileName: stackFrame.getFileName(),
+            methodName: stackFrame.getMethodName(),
+        }
+    }
+
+    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 createPayloadFromRequest = (req: KlepperRequest, res: KlepperResponse) => {
+    return {
+        request: req,
+        response: res,
+        date: new Date().getDate()
+    }
+}
+
+const mapRequestData = (req: BaseObject): KlepperRequest => {
+    const headersData = req.headers || req.header || {};
+
+    const method = req.method;
+    const host = headersData["host"] || '<no host>';
+
+    const protocol = getProtocol(req.protocol)
+
+    const originalUrl = (req.originalUrl || req.url) as string;
+    const absoluteUrl = `${protocol}://${host}${originalUrl}`;
+    const origin = headersData["origin"];
+    const query = req.query;
+    const payload = req.body || {};
+    const ip = getIp(req as KlepperIncomingMessage);
+
+    const connections = {
+        absoluteUrl,
+        origin,
+        protocol
+    };
+
+    const headers = {
+        host,
+        connection: headersData["connection"],
+        origin: headersData["origin"]
+    }
+
+    const request = {
+        payload,
+        headers,
+        method,
+        query,
+        ip,
+        url: connections,
+    };
+
+    return request;
+}
+
+const getIp = (req: KlepperIncomingMessage): string | string[] | undefined => {
+    return req.headers['x-forwarded-for'] || req.socket.remoteAddress;
+}
+
+const isLocalhost = (req: KlepperIncomingMessage): boolean => {
+    const ip = getIp(req);
+    return ip === "::1" || ip === "127.0.0.1" ? true : false;
+}
+
+const getProtocol = (req: KlepperIncomingMessage): string => {
+    return req.protocol === 'https' || req.secure
+        ? 'https'
+        : 'http';
+}
+
+
+export const helpers = {
+    getIp,
+    createPayloadFromRequest,
+    mapRequestData,
+    mapStackFrames,
+    getProtocol,
+    isLocalhost
+}

packages/node/src/helpers.ts

@@ -1,5 +1,28 @@
-import { Klepper } from "./klepper";
-
-const klepper = Klepper.connect({ apiKey: "=== API KEY 1111 ===", secretKey: "=== SECRET KEY 2222 ===" });
-klepper.errorHandler;
-klepper.requestHandler;
+import * as Middleware from "./middlewares/index";
+import * as Klepper from "./main";
+
+export { Middleware, Klepper }
+
+
+/**
+ * TODO:
+ * 
+ * 1. captureException function which is placed in catch clause in code when we want to capture an error
+ * 2. communication between library and server, send exceptions to server
+ * 3. ENDING OF ERROR HANDLER, CREATE EXCEPTION OBJECT
+ * 
+ */
+
+/**
+ * IDEAS:
+ * 
+ * 1. add parameters of exceptions which client want to handle
+ * 2. 
+ */
+
+/**
+ * PROBLEMS:
+ * 
+ * 1. do we need to capture also requests and not only exceptions?
+ * 2. do we need to parse stack objects from exceptions and then send to server or we can send whole exception stack, name and description?
+ */

packages/node/src/index.ts

@@ -0,0 +1,5 @@
+import { KlepperOptions } from "@klepper/transport";
+
+export const connect = (_options?: KlepperOptions): void => {
+    //TO IMPLEMENT!
+}