feat(core): addbasic fn

Author: PxyUp

package-lock.json

@@ -2,10 +2,33 @@
   "name": "root",
   "private": true,
   "scripts": {
-    "lerna": "lerna"
+    "lerna": "lerna",
+    "format:code": "prettier --write \"packages/**/*.{ts,js,?css}\"",
+    "format": "npm-run-all -p format:code"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "packages/**/*.{ts,js,?css,json}": [
+      "prettier --write",
+      "git add"
+    ],
+    "packages/**/*.{ts,js}": [
+      "tslint -p tsconfig.json -c tslint.json --fix",
+      "git add"
+    ]
   },
   "devDependencies": {
-    "lerna": "^3.21.0"
+    "codelyzer": "^5.2.2",
+    "husky": "^4.2.5",
+    "lerna": "^3.21.0",
+    "lint-staged": "^10.2.6",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.0.5",
+    "tslint": "^6.1.2"
   },
   "dependencies": {
     "@types/node": "^14.0.5",

package.json

@@ -1,24 +1,42 @@
-import fetch from 'cross-fetch';
-import { Transaction } from '../transaction/transaction';
+import fetch from "cross-fetch";
+import { Transaction } from "../transaction/transaction";
+import { Type } from "../enums/enums";
 
-class Application {
-    constructor(private id: string, private parentId: string = "") {}
-
-    createTransaction(name: string): Transaction {
-        return new Transaction(name, this.id)
-    }
+export class Application {
+  constructor(private id: string) {}
 
+  createTransaction<T>(
+    name: string,
+    type: Type,
+    fn: (trx: Transaction<T>) => T
+  ): Transaction<T> {
+    return new Transaction(
+      {
+        name,
+        applicationId: this.id,
+        type,
+      },
+      fn
+    );
+  }
 }
 
-export function createApplication(monitoringHost: string, name: string, host: string): Promise<Application> {
-    return fetch(`${monitoringHost}/v1/applications`, {
-        method: "POST",
-        body: JSON.stringify({
-            name,
-            host,
-        })
-    }).then<{data: {
-        application_id: string
-    }}>((body) => body.json())
-    .then((res) => new Application(res.data.application_id))
-}
+export function createApplication(
+  monitoringHost: string,
+  name: string,
+  host: string
+): Promise<Application> {
+  return fetch(`${monitoringHost}/v1/applications`, {
+    method: "POST",
+    body: JSON.stringify({
+      name,
+      host,
+    }),
+  })
+    .then<{
+      data: {
+        application_id: string;
+      };
+    }>((body) => body.json())
+    .then((res) => new Application(res.data.application_id));
+}

packages/core/lib/application/application.ts

@@ -0,0 +1,16 @@
+export enum Status {
+  TRANSACTION_SUCCESSFUL = 1,
+  TRANSACTION_FAILED = 2,
+}
+
+export enum Type {
+  TRANSACTION_TYPE_UNSPECIFIED = 0,
+  TRANSACTION_TYPE_XHR = 1,
+  TRANSACTION_TYPE_FETCH = 2,
+  TRANSACTION_TYPE_WEBSOCKET = 3,
+  TRANSACTION_TYPE_HTTP = 4,
+  TRANSACTION_TYPE_GRPC = 5,
+  TRANSACTION_TYPE_DB = 6,
+  TRANSACTION_TYPE_INTERNAL = 7,
+  TRANSACTION_TYPE_ROUTER = 8,
+}

packages/core/lib/enums/enums.ts

@@ -0,0 +1,3 @@
+export * from "./application/application";
+export * from "./enums/enums";
+export * from "./transaction/transaction";

packages/core/lib/index.ts

@@ -1,17 +1,70 @@
-import { nanoid } from 'nanoid'
+import { nanoid } from "nanoid";
+import { Type, Status } from "../enums/enums";
 
-export class Transaction {
+export interface TransactionOpts {
+  name: string;
+  applicationId: string;
+  parent?: Transaction<any>;
+  type: Type;
+}
 
-    private id = nanoid()
+export interface CommitMsg {
+  error?: Error;
+  meta?: {
+    host: string;
+    path: string;
+  };
+  status: Status;
+}
 
-    constructor(
-        private name: string,
-        private applicationId: string,
-        private parentId: string = ""
-        ){
-    }
+export class Transaction<T> {
+  protected id = nanoid();
+
+  constructor(
+    protected opts: TransactionOpts,
+    protected fn: (trx: Transaction<T>) => T
+  ) {}
 
-    createTransaction(name: string): Transaction {
-        return new Transaction(name, this.applicationId, this.id)
+  commit(): T {
+    const startTime = new Date();
+    try {
+      // if okey
+      const result = this.fn(this);
+      this._commit(startTime, new Date());
+      return result;
+    } catch (err) {
+      // if throw error commit and send error
+      this._commit(startTime, new Date(), {
+        status: Status.TRANSACTION_FAILED,
+        error: err,
+      });
+      throw err;
     }
-}
+  }
+
+  getId() {
+    return this.id;
+  }
+
+  getApplicationId() {
+    return this.opts.applicationId;
+  }
+
+  protected _commit(from: Date, to: Date, msg?: CommitMsg) {}
+
+  createTransaction<R>(
+    name: string,
+    type: Type,
+    fn: (trx: Transaction<R>) => R
+  ): Transaction<R> {
+    return new Transaction(
+      {
+        name,
+        parent: this,
+        applicationId: this.opts.applicationId,
+        type,
+      },
+      fn
+    );
+  }
+}

packages/core/lib/transaction/transaction.ts

@@ -0,0 +1,11 @@
+# `express`
+
+> TODO: description
+
+## Usage
+
+```
+const express = require('express');
+
+// TODO: DEMONSTRATE API
+```

packages/express/README.md

@@ -0,0 +1,22 @@
+import { Request, Response, NextFunction, response } from "express";
+import { Application, Type, Transaction } from "@squzy/core";
+
+class ExpressTransaction<T> extends Transaction<T> {
+  commit() {
+    const startTime = new Date();
+    const res = this.fn(this);
+    return res;
+  }
+}
+
+export function createMiddleware(app: Application) {
+  return (req: Request, res: Response, next: NextFunction) => {
+    const trx = app.createTransaction(
+      req.baseUrl + req.path,
+      Type.TRANSACTION_TYPE_ROUTER,
+      () => next()
+    );
+    response.locals.__squzy_transaction = trx;
+    trx.commit();
+  };
+}