itrm-tools 1.3.2 → 1.3.5-viio.1

package/src/api/check/APIChecker.ts

@@ -0,0 +1,50 @@
+import { Request, Response, NextFunction } from "express";
+
+export declare interface APICheckResult {
+    approved: boolean,
+    payload?: any,
+    rejection?: {
+        code: number,
+        payload: any
+    }
+}
+
+export declare interface APICheckConfig {
+    check: string
+}
+
+export interface APICheck {
+    getConfig(): APICheckConfig;
+    apply(config: APICheckConfig, req: Request): PromiseLike<APICheckResult>;
+}
+
+export interface Checkable {
+    addCheck(check: APICheck): void;
+    check(req: Request, res: Response, next: NextFunction): PromiseLike<void | Response>;
+}
+
+export class APIChecker {
+    private checks: APICheck[] = [];
+
+    public addCheck(check: APICheck) {
+        this.checks.push(check);
+    }
+
+    public async applyChecks(req: Request): Promise<APICheckResult> {
+        if (!req.body || !req.body.checkResults)
+            req.body = { ...(req.body ?? {}), checkResults: {} };
+        for (let check of this.checks) {
+            let result = await check.apply(check.getConfig(), req);
+            req.body.checkResults[check.getConfig().check] = result.payload;
+            if (!result.approved)
+                return result;
+        }
+        return { approved: true };
+    }
+
+    public reject(res: Response, result: APICheckResult) {
+        if (result.rejection)
+            return res.status(result.rejection.code).json(result.rejection.payload);
+        return res.status(401).json({ message: 'Unknown reason' });
+    }
+}

package/src/api/check/CheckableAPIRequest.ts

@@ -0,0 +1,33 @@
+import { Request, Response, NextFunction } from "express";
+import { APIRequest, APIRequestConfig, RequestMethod } from "../APIRequest";
+import { ITRMAPIServiceGlobal } from "../APIService";
+import { APICheckResult, APIChecker, APICheck, Checkable } from "./APIChecker";
+
+export abstract class CheckableAPIRequest extends APIRequest implements Checkable {
+    private checker: APIChecker = new APIChecker();
+
+    constructor(method: RequestMethod, config: APIRequestConfig) {
+        super(method, config);
+    }
+
+    public addCheck(check: APICheck) {
+        this.checker.addCheck(check);
+    }
+
+    public async check(req: Request, res: Response | any, next: NextFunction) {
+        try {
+            let request: CheckableAPIRequest = ITRMAPIServiceGlobal.requests[APIRequest.buildKey(req)];
+            let result: APICheckResult = await request.checker.applyChecks(req);
+            if (result.approved)
+                return next();
+            return request.checker.reject(res, result);
+        } catch (error: any) {
+            console.log("> error:", error);
+            return await res.status(error?.response?.status ?? 500).json({
+                type: 'InternalRequestCheckError',
+                error: 'An error has ocurred when runing the checks for the request',
+                payload: error?.response?.data ?? error
+            });
+        }
+    }
+}

package/src/api/check/CheckableAPIRouter.ts

@@ -0,0 +1,39 @@
+import { RouterOptions, Request, Response, NextFunction } from "express";
+import { APIRouter } from "../APIRouter";
+import { ITRMAPIServiceGlobal } from "../APIService";
+import { APICheck, APIChecker, APICheckResult, Checkable } from "./APIChecker";
+
+export abstract class CheckableAPIRouter extends APIRouter  implements Checkable {
+    private checker: APIChecker = new APIChecker();
+    
+    constructor(path: string, options?: RouterOptions) {
+        super(path, options);
+    }
+
+    public init() {
+        this.router.use(this.check);
+    }
+
+    public addCheck(checker: APICheck) {
+        this.checker.addCheck(checker);
+    }
+
+    public async check(req: Request, res: Response, next: NextFunction): Promise<void | Response | any> {
+        try {
+            let route: CheckableAPIRouter = ITRMAPIServiceGlobal.routers[req.baseUrl];
+            route.setHeaders(res);
+            let result: APICheckResult = await route.checker.applyChecks(req)
+            if (result.approved)
+                return route.runMiddleware(req, res, next);
+            return route.checker.reject(res, result);
+        } catch (error: any) {
+            return await res.status(error?.response?.status ?? 500).json({
+                type: 'InternalRouterCheckError',
+                error: 'An error has ocurred when runing the checks for the router',
+                payload: error?.response?.data ?? error
+            });
+        }
+    }
+
+    protected abstract setHeaders(res: Response) : void;
+}

package/src/api/check/request/CheckableDeleteRequest.ts

@@ -0,0 +1,17 @@
+import { Express, Router } from "express";
+import { APIRequestConfig, RequestMethod } from "../../APIRequest";
+import { CheckableAPIRequest } from "../CheckableAPIRequest";
+
+export abstract class CheckableDeleteRequest extends CheckableAPIRequest {
+    constructor(config: APIRequestConfig) {
+        super(RequestMethod.DELETE, config);
+    }
+
+    public addToApp(app: Express): void {
+        app.delete(this.path, this.check, this.process);
+    }
+
+    public addToRouter(router: Router): void {
+        router.delete(this.path, this.check, this.process);
+    }
+}

package/src/api/check/request/CheckableFileUploadingPostRequest.ts

@@ -0,0 +1,26 @@
+import { Express, Router } from "express";
+import { APIRequestConfig, RequestMethod } from "../../APIRequest";
+import { CheckableAPIRequest } from "../CheckableAPIRequest";
+import { Multer, StorageEngine } from "multer";
+import { ITRMAPIServiceGlobal } from "../../APIService";
+import { initializeFileUploadingGlobalVars } from "../../express/ExpressFileUploadingConfiguration";
+
+export abstract class CheckableFileUploadingPostRequest extends CheckableAPIRequest {
+    protected upload: Multer;
+    protected storage: StorageEngine;
+
+    constructor(config: APIRequestConfig) {
+        super(RequestMethod.GET, config);
+        initializeFileUploadingGlobalVars();
+        this.upload = ITRMAPIServiceGlobal.tools.file.upload;
+        this.storage = ITRMAPIServiceGlobal.tools.file.storage;
+    }
+    
+    public addToApp(app: Express): void {
+        app.post(this.path, this.upload.single("file"), this.check, this.process);
+    }
+
+    public addToRouter(router: Router): void {
+        router.post(this.path, this.upload.single("file"), this.check, this.process);
+    }
+}

package/src/api/check/request/CheckableGetRequest.ts

@@ -0,0 +1,17 @@
+import { Express, Router } from "express";
+import { APIRequestConfig, RequestMethod } from "../../APIRequest";
+import { CheckableAPIRequest } from "../CheckableAPIRequest";
+
+export abstract class CheckableGetRequest extends CheckableAPIRequest {
+    constructor(config: APIRequestConfig) {
+        super(RequestMethod.GET, config);
+    }
+    
+    public addToApp(app: Express): void {
+        app.get(this.path, this.check, this.process);
+    }
+
+    public addToRouter(router: Router): void {
+        router.get(this.path, this.check, this.process);
+    }
+}

package/src/api/check/request/CheckablePostRequest.ts

@@ -0,0 +1,17 @@
+import { Express, Router } from "express";
+import { APIRequestConfig, RequestMethod } from "../../APIRequest";
+import { CheckableAPIRequest } from "../CheckableAPIRequest";
+
+export abstract class CheckablePostRequest extends CheckableAPIRequest {
+    constructor(config: APIRequestConfig) {
+        super(RequestMethod.POST, config);
+    }
+    
+    public addToApp(app: Express): void {
+        app.post(this.path, this.check, this.process);
+    }
+
+    public addToRouter(router: Router): void {
+        router.post(this.path, this.check, this.process);
+    }
+}

package/src/api/check/request/CheckablePutRequest.ts

@@ -0,0 +1,17 @@
+import { Express, Router } from "express";
+import { APIRequestConfig, RequestMethod } from "../../APIRequest";
+import { CheckableAPIRequest } from "../CheckableAPIRequest";
+
+export abstract class CheckablePutRequest extends CheckableAPIRequest {
+    constructor(config: APIRequestConfig) {
+        super(RequestMethod.PUT, config);
+    }
+    
+    public addToApp(app: Express): void {
+        app.put(this.path, this.check, this.process);
+    }
+
+    public addToRouter(router: Router): void {
+        router.put(this.path, this.check, this.process);
+    }
+}

package/src/api/check/route/CorsCheckApiRouter.ts

@@ -0,0 +1,22 @@
+import { NextFunction, Request, Response, RouterOptions } from "express";
+import { CheckableAPIRouter } from "../CheckableAPIRouter";
+
+export class CorsCheckApiRouter extends CheckableAPIRouter {
+  constructor(path: string, options?: RouterOptions) {
+    super(path, options);
+  }
+
+  protected setHeaders(res: Response<any, Record<string, any>>): void {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type,Authorization,platform");
+  }
+
+  protected async runMiddleware(
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ): Promise<void | Response> {
+    return next();
+  }
+}

package/src/api/check/route/SimpleCheckableAPIRouter.ts

@@ -0,0 +1,14 @@
+import { NextFunction, Request, Response, RouterOptions } from "express";
+import { CheckableAPIRouter } from "../CheckableAPIRouter";
+
+export class SimpleCheckableAPIRouter extends CheckableAPIRouter {
+    constructor(path: string, options?: RouterOptions) {
+        super(path, options);
+    }
+
+    protected setHeaders(res: Response<any, Record<string, any>>): void { }
+
+    protected async runMiddleware(req: Request, res: Response, next: NextFunction): Promise<void | Response> {
+        return next();
+    }
+}

package/src/api/express/ExpressFileUploadingConfiguration.ts

@@ -0,0 +1,22 @@
+import { ExpressStandardConfiguration } from "./ExpressStandardConfiguration";
+import { ITRMAPIServiceGlobal } from "../APIService";
+import { Express } from "express";
+import multer from "multer";
+
+export function initializeFileUploadingGlobalVars() {
+    if (!ITRMAPIServiceGlobal.tools.file) {
+        const storage = multer.memoryStorage();
+        ITRMAPIServiceGlobal.tools.file = {
+            storage: storage,
+            upload: multer({ storage })
+        };
+    }
+}
+
+export class ExpressFileUploadingConfiguration extends ExpressStandardConfiguration {
+    public apply(app: Express): void {
+        super.apply(app);
+        initializeFileUploadingGlobalVars();
+        app.use(ITRMAPIServiceGlobal.tools.file.upload.array('file'));
+    }
+}

package/src/api/express/ExpressLogableConfig.ts

@@ -0,0 +1,11 @@
+import { Express } from "express";
+import morgan from "morgan";
+import { ExpressStandardConfiguration } from "./ExpressStandardConfiguration";
+
+export class ExpressLogableConfig extends ExpressStandardConfiguration {
+    apply(app: Express): void {
+        super.apply(app);
+
+        app.use(morgan(':remote-addr - :remote-user [:date[web]] ":method :url HTTP/:http-version" :status :res[content-length]'));
+    }
+}

package/src/api/express/ExpressStandardConfiguration.ts

@@ -0,0 +1,25 @@
+import express, { Express } from "express";
+import { ExpressConfiguration } from "../ExpressConfiguration";
+import { ITRMAPIServiceGlobal } from "../APIService";
+import cors from 'cors';
+
+export class ExpressStandardConfiguration implements ExpressConfiguration {
+    public apply(app: Express): void {
+        app.use(ExpressStandardConfiguration.getCorsConfiguration());
+        app.use(express.json({ limit: '50mb' }));
+        app.use(express.urlencoded({ limit: '50mb', extended: true }));
+        //app.use(urlencoded({ extended: true }));
+    }
+
+    public static getCorsConfiguration() {
+        return cors({
+            origin: function (origin: any, callback: any) {
+                let whitelist = ITRMAPIServiceGlobal.whitelist;
+                if (whitelist.length == 0 || (origin && whitelist.indexOf(origin) !== -1))
+                    callback(null, true);
+                else
+                    callback(new Error('Not allowed by CORS'), false);
+            }
+        });
+    }
+}

package/src/api/external/ExternalApiSigner.ts

@@ -0,0 +1,29 @@
+import { RequestMethod } from "../APIRequest";
+import { HmacSHA256, enc } from 'crypto-js';
+
+export interface ApiKeyPair {
+    publicKey: string;
+    secretKey: string;
+}
+
+export class ExternalApiSigner {
+    private keys: ApiKeyPair;
+    private service: string;
+
+    constructor(service: string, keys: ApiKeyPair) {
+        this.service = service;
+        this.keys = keys;
+    }
+
+    public sign(method: RequestMethod, path: string, body?: any) {
+        let nonce = Date.now();
+        let message = nonce + method + path.replace(/ /g, '%20') + (body ? JSON.stringify(body) : "{}");
+        const hash = HmacSHA256(message, this.keys.secretKey);
+        let signature = enc.Hex.stringify(hash);
+        return {
+            headers: {
+                Authorization: `${this.service} ${this.keys.publicKey}:${nonce}:${signature}`
+            }
+        };
+    }
+}

package/src/api/external/cetus/CetusStrategyApiManager.ts

@@ -0,0 +1,48 @@
+import { AxiosRequestConfig } from "axios";
+import { ApiKeyPair, ExternalApiSigner } from "../ExternalApiSigner";
+import { RequestMethod } from "../../APIRequest";
+import { RequestAxiosCall } from "../../request/RequestAxiosCall";
+
+export interface CetusRate {
+    symbol: string;
+    source: string;
+    bid?: number;
+    ask?: number;
+    spot?: number;
+    prevDayClose?: number;
+};
+
+export enum CetusPair {
+    USDCOP = "USDCOP"
+}
+
+export interface CetusStrategy {
+    id: number;
+    name: string;
+    settings: any;
+    memory: any;
+    account: string;
+    pair: string;
+    intermediary: string;
+    status: string;
+}
+
+export class CetusStrategyApiManager extends ExternalApiSigner {
+    private apiUrl: string;
+
+    constructor(keys: ApiKeyPair, apiUrl: string) {
+        super('cetus', keys);
+        this.apiUrl = apiUrl;
+    }
+
+    public async getRates() {
+        let signature: AxiosRequestConfig = this.sign(RequestMethod.GET, '/v1/rates');
+        return ((await RequestAxiosCall.get(`${this.apiUrl}/v1/rates`, signature)) as { status: string; rates: CetusRate[]; }).rates;
+    }
+
+    public async getStrategies(name: string, pair: CetusPair, account: string) {
+        let url = `/v1/strategies?name=${name}&pair=${pair}&account=${account}`;
+        let signature: AxiosRequestConfig = this.sign(RequestMethod.GET, url);
+        return (((await RequestAxiosCall.get(`${this.apiUrl}${url}`, signature)) as any).result) as CetusStrategy[];
+    }
+}

package/src/api/request/DeleteRequest.ts

@@ -0,0 +1,16 @@
+import { Express, Router } from "express";
+import { APIRequest, APIRequestConfig, RequestMethod } from "../APIRequest";
+
+export abstract class DeleteRequest extends APIRequest {
+    constructor(config: APIRequestConfig) {
+        super(RequestMethod.DELETE, config);
+    }
+
+    public addToApp(app: Express): void {
+        app.delete(this.path, this.process);
+    }
+
+    public addToRouter(router: Router): void {
+        router.delete(this.path, this.process);
+    }
+}

package/src/api/request/GetRequest.ts

@@ -0,0 +1,16 @@
+import { Express, Router } from "express";
+import { APIRequest, APIRequestConfig, RequestMethod } from "../APIRequest";
+
+export abstract class GetRequest extends APIRequest {
+    constructor(config: APIRequestConfig) {
+        super(RequestMethod.GET, config);
+    }
+
+    public addToApp(app: Express): void {
+        app.get(this.path, this.process);
+    }
+
+    public addToRouter(router: Router): void {
+        router.get(this.path, this.process);
+    }
+}

package/src/api/request/PostRequest.ts

@@ -0,0 +1,16 @@
+import { Express, Router } from "express";
+import { APIRequest, APIRequestConfig, RequestMethod } from "../APIRequest";
+
+export abstract class PostRequest extends APIRequest {
+    constructor(config: APIRequestConfig) {
+        super(RequestMethod.POST, config);
+    }
+
+    public addToApp(app: Express): void {
+        app.post(this.path, this.process);
+    }
+
+    public addToRouter(router: Router): void {
+        router.post(this.path, this.process);
+    }
+}

package/src/api/request/PutRequest.ts

@@ -0,0 +1,16 @@
+import { Express, Router } from "express";
+import { APIRequest, APIRequestConfig, RequestMethod } from "../APIRequest";
+
+export abstract class PutRequest extends APIRequest {
+    constructor(config: APIRequestConfig) {
+        super(RequestMethod.PUT, config);
+    }
+
+    public addToApp(app: Express): void {
+        app.put(this.path, this.process);
+    }
+
+    public addToRouter(router: Router): void {
+        router.put(this.path, this.process);
+    }
+}

package/src/api/request/RequestAxiosCall.ts

@@ -0,0 +1,38 @@
+import axios, { AxiosRequestConfig } from "axios";
+import axiosRetry from 'axios-retry';
+
+axiosRetry(axios, { retries: 3, retryDelay: (retryCount) => { return 2000; } });
+
+export class RequestAxiosCall {
+    public static async get(url: string, config?: AxiosRequestConfig<any>) {
+        return new Promise((resolve, reject) => {
+            axios.get(url, config ?? { headers: { 'Content-Type': 'application/json' } })
+            .then(response => { resolve(response.data) })
+            .catch(err => { reject(err) });
+        });
+    }
+    
+    public static async post(url: string, body: any, config?: AxiosRequestConfig) {
+        return new Promise((resolve, reject) => {
+            axios.post(url, body, config ?? { headers: { 'Content-Type': 'application/json' } })
+            .then(response => { resolve(response.data) })
+            .catch(err => { reject(err) });
+        });
+    }
+    
+    public static async put(url: string, body: any, config?: AxiosRequestConfig) {
+        return new Promise((resolve, reject) => {
+            axios.put(url, body, config ?? { headers: { 'Content-Type': 'application/json' } })
+            .then(response => { resolve(response.data) })
+            .catch(err => { reject(err) });
+        });
+    }
+    
+    public static async delete(url: string, config?: AxiosRequestConfig) {
+        return new Promise((resolve, reject) => {
+            axios.delete(url, config ?? { headers: { 'Content-Type': 'application/json' } })
+            .then(response => { resolve(response.data) })
+            .catch(err => { reject(err) });
+        });
+    }
+}

package/src/api/request/crud/CrudManager.ts

@@ -0,0 +1,11 @@
+export interface CrudManager<A, D, I> {
+    find(details: D): Promise<I | undefined>;
+    findAll(details: D): Promise<I[] | undefined>;
+    findById(id: A): Promise<I | undefined>;
+    findOrCreate(details: D): Promise<I | undefined>;
+    create(details: D): Promise<I | undefined>;
+    createMany(details: D): Promise<I[] | undefined>;
+    count(details: D):Promise<{ result: number }>;
+    modify(item: I): Promise<any>;
+    destroy(item: I): Promise<any>;
+}

package/src/api/request/crud/CrudServiceManager.ts

@@ -0,0 +1,117 @@
+import { AxiosRequestConfig } from "axios";
+import { CrudManager } from "./CrudManager";
+import { RequestAxiosCall } from "../RequestAxiosCall";
+
+export interface StandardIdRequestDefinition {
+    id: number,
+    config?: AxiosRequestConfig
+}
+
+export abstract class CrudServiceManager<D, I> implements CrudManager<StandardIdRequestDefinition, D, I> {
+    public async findOrCreate(details: D): Promise<I | undefined> {
+        let item: any = await this.find(details);
+        if (!item)
+            item = await this.create(details);
+        return item;
+    }
+
+    protected extractItem(response: any, key: string) {
+        if (response[key] && response[key].length > 0)
+            return response[key][0];
+        return undefined;
+    }
+
+    protected extractItems(response: any, key: string) {
+        let result = [];
+        if (response[key] && response[key].length > 0)
+            for (let item of response[key])
+                result.push(item);
+        return result;
+    }
+
+    protected sendFinding(url: string, config?: AxiosRequestConfig) {
+        return new Promise<I | undefined>((resolve, reject) => {
+            RequestAxiosCall.get(url, config)
+            .then((response: any) => {
+                resolve(this.extractItem(response, 'result'));
+            }).catch((err: any) => {
+                reject(err);
+            });
+        });
+    }
+
+    protected sendAllFinding(url: string, config?: AxiosRequestConfig) {
+        return new Promise<I[] | undefined>((resolve, reject) => {
+            RequestAxiosCall.get(url, config)
+            .then((response: any) => {
+                resolve(this.extractItems(response, 'result'));
+            }).catch((err: any) => {
+                reject(err);
+            });
+        });
+    }
+
+    protected sendCreation(url: string, body: any, config?: AxiosRequestConfig) {
+        return new Promise<I | undefined>((resolve, reject) => {
+            RequestAxiosCall.post(url, body, config)
+            .then((response: any) => {
+                resolve(this.extractItem(response, 'items'));
+            }).catch((err: any) => {
+                reject(err);
+            });
+        });
+    }
+
+    protected sendCreationMany(url: string, values: any[], config?: AxiosRequestConfig) {
+        return new Promise<I[] | undefined>((resolve, reject) => {
+            RequestAxiosCall.post(url, { values: values }, config)
+            .then((response: any) => {
+                resolve(this.extractItems(response, 'items'));
+            }).catch((err: any) => {
+                reject(err);
+            });
+        });
+    }
+
+    protected sendCounting(url: string, config?: AxiosRequestConfig) {
+        return new Promise<{ result: number; } | undefined >((resolve, reject) => {
+            RequestAxiosCall.get(`${url}${url.indexOf('?') !== -1 ? '&' : '?'}count=true`, config)
+            .then((response: any) => {
+                resolve(response);
+            }).catch((err: any) => {
+                reject(err);
+            });
+        });
+    }
+
+    protected sendModification(url: string, modification: I, config?: AxiosRequestConfig) {
+        return new Promise<any>((resolve, reject) => {
+            RequestAxiosCall.put(url, { ...modification }, config)
+            .then((response: any) => {
+                resolve(response);
+            }).catch((err: any) => {
+                reject(err);
+            });
+        });
+    }
+
+    protected sendDestruction(url: string, config?: AxiosRequestConfig) {
+        return new Promise<any>((resolve, reject) => {
+            RequestAxiosCall.delete(url, config)
+            .then((response: any) => {
+                resolve(response);
+            }).catch((err: any) => {
+                reject(err);
+            });
+        });
+    }
+
+    public abstract find(details: D): Promise<I | undefined>;
+    public abstract findAll(details: D): Promise<I[] | undefined>;
+    public abstract findById(id: StandardIdRequestDefinition): Promise<I | undefined>;
+    public abstract create(details: D): Promise<I | undefined>;
+    public abstract createMany(details: D): Promise<I[] | undefined>;
+    public abstract count(details: D): Promise<{ result: number }>;
+    public abstract modify(item: I): Promise<any>;
+    public abstract destroy(item: I): Promise<any>;
+}