itrm-tools 1.3.5-viio.3 → 1.3.5

package/src/api/request/docs/DocumentationRequest.ts

@@ -1,132 +0,0 @@
-import { defaultBodySchema, defaultDocumentationSchema, httpStatusCodes, securityDeclaration, securitySchema } from "./DocumentationModels";
-import { APIRequest, GroupedParameters } from "../../APIRequest";
-import { ITRMAPIServiceGlobal } from "../../APIService";
-import { APIRouter } from "../../APIRouter";
-import { ISamples } from "../../APIRequestBuilder";
-
-export class DocumentationRequest {
-
-    constructor() { }
-
-    public init(): any {
-        const { name, port, routers, requests } = ITRMAPIServiceGlobal.service?.getServerInformation()!;
-        defaultDocumentationSchema.info.title = name;
-        defaultDocumentationSchema.servers = [{ url: `http://localhost:${port}` }];
-        defaultDocumentationSchema.tags = this.createTagsObject(routers, name);
-        defaultDocumentationSchema.paths = this.createPathsObject(requests, name);
-        defaultDocumentationSchema.components = securitySchema.components;
-        defaultDocumentationSchema.security = securityDeclaration.security;
-        return defaultDocumentationSchema;
-    }
-
-    private createTagsObject(routers: APIRouter[], name: string) {
-        let tags = [];
-        for (let router in routers)
-            tags.push({ name: router.replace("/", "") })
-        tags.push({ name: name });
-        return tags;
-    }
-
-    private createPathsObject(requests: any, name: string) {
-        let paths: any = {};
-        for (let request in requests) {
-            let buildRequest = this.buildRequest(requests[request], request, name);
-            paths[buildRequest.name] ? paths[buildRequest.name] : paths[buildRequest.name] = {};
-            paths[buildRequest.name][buildRequest.requestMethod] = {
-                tags: [buildRequest.tag],
-                operationId: buildRequest.requestMethod + " " + (buildRequest.name).toLowerCase(),
-                description: requests[request].details?.description ?? (buildRequest.name).toLowerCase(),
-                summary: requests[request].details?.description ?? (buildRequest.name).toLowerCase(),
-                parameters: buildRequest.params,
-                responses: this.buildResponses(requests[request])
-            };
-            if ((buildRequest.requestMethod === "post" || buildRequest.requestMethod === "put") && requests[request].bodyParams.length > 0)
-                paths[buildRequest.name][buildRequest.requestMethod].requestBody = this.buildBodyParams(requests[request].bodyParams);
-        }
-        return paths;
-    }
-
-    private buildRequest(request: APIRequest, requestName: string, serviceName: string) {
-        let name = requestName.replace(`${request.method}_`, "");
-        name = name.replace(/:([^/]+)/g, '{$1}');
-        let tag = name === request.path ? serviceName : name.split("/")[1];
-        let requestMethod = request.method.toLowerCase();
-        let buildParams = this.buildParams(request.getRequestDetails().params);
-        return { name, tag, requestMethod, params: buildParams };
-    }
-
-    private buildBodyParams(bodyParams: GroupedParameters[]) {
-        let bodySchema = structuredClone(defaultBodySchema);
-        for (let param of bodyParams) {
-            let parameter = param.properties;
-            parameter.forEach((element: any) => {
-                bodySchema.content["application/json"].schema.properties[element.name] = { type: element.type };
-            });
-        }
-        return bodySchema;
-    }
-
-    private buildParams(params: GroupedParameters[]) {
-        let parameters: any = [];
-        if (params.length > 0) {
-            for (let param of params) {
-                let parameter = param.properties;
-                parameter.forEach((element: any) => {
-                    if (param.context !== "body") {
-                        let body: any = {
-                            name: element.name,
-                            in: this.fixParamName(param.context),
-                            schema: {
-                                type: element.type
-                            }
-                        }
-                        if (param.context === "params") body.required = true;
-                        parameters.push(body);
-                    }
-                });
-            }
-            return parameters;
-        }
-        return [];
-    }
-
-    private fixParamName(name: string) {
-        switch (name) {
-            case "params":
-                return "path";
-            case "headers":
-                return "header";
-            default:
-                return name;
-        }
-    }
-
-    private buildResponses(request: APIRequest) {
-        let response: any = {};
-        if (request.details) {
-            for (let sample of request.details.samples) {
-                response[sample.status] = {
-                    description: httpStatusCodes[sample.status] ?? "response",
-                    content: {
-                        "application/json": {
-                            schema: {
-                                type: "object",
-                                properties: this.buildResponseProperties(sample)
-                            }
-                        }
-                    }
-                };
-            }
-            return response;
-        }
-        else
-            return { "200": { description: "Successful response" } }
-    }
-
-    private buildResponseProperties(sample: ISamples) {
-        let properties: { [key: string]: { type: any, example: any } } = {};
-        for (let key in sample.output)
-            properties[key] = { type: typeof (sample.output[key]), example: sample.output[key] };
-        return properties;
-    }
-}

package/src/api/route/SimpleAPIRouter.ts

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

package/src/database/mongoose/MongooseModelManager.ts

@@ -1,65 +0,0 @@
-import { DefaultSchemaOptions, FilterQuery, Model, model, MongooseBulkWriteOptions, ObtainDocumentType, ResolveSchemaOptions, Schema, SchemaDefinition, SchemaDefinitionType, SchemaOptions, UpdateQuery, UpdateWithAggregationPipeline } from "mongoose";
-
-export class MongooseModelManager<S> {
-    public collection: string;
-    protected model: Model<S>;
-
-    constructor(collection: string, definition: ObtainDocumentType<any, S, DefaultSchemaOptions> | SchemaDefinition<SchemaDefinitionType<S>>, options?: SchemaOptions | ResolveSchemaOptions<any>) {
-        this.collection = collection;
-        let schema = new Schema<S>(definition, options);
-        this.model = model<S>(collection, schema);
-    }
-
-    public async create(datum: S) {
-        let token = await new this.model(datum);
-        return token.save();
-    }
-
-    public createMany(data: S[]): Promise<any> {
-        let writes: any[] = [];
-        for (let datum of data) {
-            writes.push({
-                insertOne: {
-                    document: datum
-                }
-            });
-        }
-        return this.model.bulkWrite(writes);
-    }
-
-    public exists(filter: FilterQuery<S>): any {
-        return this.model.exists(filter);
-    }
-
-    public find(filter: FilterQuery<S>) {
-        return this.model.findOne(filter);
-    }
-
-    public findMany(filter: FilterQuery<S>) {
-        return this.model.find(filter);
-    }
-
-    public batch(filter: FilterQuery<S>, from: number, size: number) {
-        return this.model.find(filter).skip(from).limit(size);
-    }
-
-    public updateOne(filter: FilterQuery<S>, data: UpdateWithAggregationPipeline | UpdateQuery<S>): any {
-        return this.model.updateOne(filter, data);
-    }
-
-    public bulkWrite(writes: any[], options?: MongooseBulkWriteOptions): Promise<any> {
-        return this.model.bulkWrite(writes, options);
-    }
-
-    public delete(filter: FilterQuery<S>): any {
-        return this.model.deleteOne(filter);
-    }
-
-    public deleteMany(filter: FilterQuery<S>): any {
-        return this.model.deleteMany(filter);
-    }
-
-    public countDocuments(filter: FilterQuery<S>) {
-        return this.model.countDocuments(filter);
-    }
-}

package/src/database/redis/RedisConnection.ts

@@ -1,18 +0,0 @@
-import { createClient, RedisClientOptions, RedisClientType, RedisFunctions, RedisModules, RedisScripts } from 'redis';
-
-export class RedisConnection {
-    private client: RedisClientType<RedisModules, RedisFunctions, RedisScripts>;
-
-    constructor(clientOptions?: RedisClientOptions) {
-        this.client = createClient();
-    }
-
-    public connect() {
-        this.client.on("error", (error: any) => { throw error; });
-        return this.client.connect();
-    }
-
-    public disconnect() {
-        return this.client.disconnect();
-    }
-}

package/src/database/redis/RedisModelManager.ts

@@ -1,23 +0,0 @@
-import { RedisClientType, RedisFunctions, RedisModules, RedisScripts } from 'redis';
-
-export declare interface RedisItem<D> {
-    key: string,
-    data: D
-}
-
-export class RedisModelManager<D> {
-    private client: RedisClientType<RedisModules, RedisFunctions, RedisScripts>;
-
-    constructor(client: RedisClientType<RedisModules, RedisFunctions, RedisScripts>) {
-        this.client = client;
-    }
-
-    public create(datum: D) {
-        //this.client.set("key", {});
-        /*this.client.set();
-        this.client.get();
-        this.client.del();*/
-        //set: <CommandOptions<ClientCommandOptions>>(...args: [key: RedisCommandArgument, value: number
-        //| RedisCommandArgument, options?: SetOptions | undefined] | [options: ...]) => Promise<...>
-    }
-}

package/src/database/sequelize/SequelizeConnection.ts

@@ -1,45 +0,0 @@
-import { AbstractDialect, ModelAttributes, ModelOptions, Options, Sequelize } from "@sequelize/core";
-
-export declare interface SequelizeConnectionConfig {
-    host: string;
-    username: string;
-    password: string;
-    database: string;
-    engine: string;
-}
-
-export class SequelizeConnection {
-    private connection: Sequelize;
-
-    constructor(config: Options<any>) {
-        this.connection = new Sequelize(config);
-    }
-
-    public connect(): Promise<void> {
-        return this.connection.authenticate();
-    }
-
-    public define(name: string, attributes: ModelAttributes, options?: ModelOptions) {
-        return this.connection.define(name, attributes, options);
-    }
-
-    public sync(syncOptions?: any) {
-        return this.connection.sync(syncOptions);
-    }
-
-    public transaction<T>(callback: (response: any) => Promise<T>): Promise<T> {
-        return this.connection.transaction(callback);
-    }
-
-    public query(query: string, options?: any) {
-        return this.connection.query(query, options);
-    }
-
-    public disconnect(): Promise<void> {
-        return this.connection.close();
-    }
-
-    public disconnectAll(): Promise<void> {
-        return this.connection.pool.destroyAllNow();
-    }
-}

package/src/database/sequelize/SequelizeModelManager.ts

@@ -1,71 +0,0 @@
-import { BelongsToManyOptions, BelongsToOptions, CountOptions, DestroyOptions, FindOptions, HasManyOptions, HasOneOptions, ModelAttributes, ModelOptions, UpdateOptions } from "@sequelize/core";
-import { SequelizeConnection } from "./SequelizeConnection";
-
-export declare interface ModelDefinition {
-    name: string,
-    attributes: ModelAttributes,
-    options?: ModelOptions
-}
-
-export class SequelizeModelManager<S> {
-    private definition: ModelDefinition;
-    public model: any;
-
-    constructor(definition: ModelDefinition) {
-        this.definition = definition;
-    }
-
-    public async define(connection: SequelizeConnection) {
-        let model = await connection.define(this.definition.name, this.definition.attributes, this.definition.options);
-        this.model = model;
-        return model;
-    }
-
-    public sync(syncOptions?: any) {
-        return this.model.sync(syncOptions);
-    }
-
-    public create(values: S) {
-        return this.model.create(values);
-    }
-
-    public bulkCreate(values: S[]) {
-        return this.model.bulkCreate(values);
-    }
-
-    public findAll(options?: FindOptions) {
-        return this.model.findAll(options);
-    }
-
-    public findAndCountAll(options?: FindOptions) {
-        return this.model.findAndCountAll(options);
-    }
-
-    public count(options?: Omit<CountOptions<any>, "group">) {
-        return this.model.count(options);
-    }
-
-    public update(values: { [x: string]: any; }, options: UpdateOptions) {
-        return this.model.update(values, options);
-    }
-
-    public destroy(options?: DestroyOptions) {
-        return this.model.destroy(options);
-    }
-
-    public hasOne(manager: SequelizeModelManager<any>, options?: HasOneOptions<string, string>) {
-        return this.model.hasOne(manager.model, options);
-    }
-
-    public hasMany(manager: SequelizeModelManager<any>, options?: HasManyOptions<string, string>) {
-        return this.model.hasMany(manager.model, options);
-    }
-
-    public belongsTo(manager: SequelizeModelManager<any>, options?: BelongsToOptions<string, string>) {
-        return this.model.belongsTo(manager.model, options);
-    }
-
-    public belongsToMany(manager: SequelizeModelManager<any>, options?: BelongsToManyOptions) {
-        return this.model.belongsToMany(manager.model, options);
-    }
-}

package/src/index.ts

@@ -1,51 +0,0 @@
-export { EncryptionAlgorithm } from './algorithm/encryption/EncryptionAlgorithm';
-
-export { AlegraConnectionManager as AlegraConnectionManager } from './api/alegra/AlegraConnectionManager';
-export { IAlegraContact as IAlegraContact, IAlegraPayment as IAlegraPayment, IAlegraCategory as IAlegraCategory, IAlegraJournal as IAlegraJournal, IAlegraEntry as IAlegraEntry, IAlegraResult as IAlegraResult } from './api/alegra/AlegraTypes';
-
-export { APIServiceConfig as APIServiceConfig, APIService as APIService, APIServiceResponse as APIServiceResponse, ITRMAPIServiceGlobal as ITRMAPIServiceGlobal } from './api/APIService';
-export { HttpsAPIService as HttpsAPIService } from './api/HttpsAPIService';
-export { ExpressConfiguration as ExpressConfiguration } from './api/ExpressConfiguration';
-export { StandardGetRequestBuilder as StandardGetRequestBuilder } from './api/builder/StandardGetRequestBuilder';
-export { ExpressLogableConfig as ExpressLogableConfig } from './api/express/ExpressLogableConfig';
-export { ExpressStandardConfiguration as ExpressStandardConfiguration } from './api/express/ExpressStandardConfiguration';
-export { ExpressFileUploadingConfiguration as ExpressFileUploadingConfiguration } from './api/express/ExpressFileUploadingConfiguration';
-export { ExternalApiSigner as ExternalApiSigner, ApiKeyPair as ApiKeyPair } from './api/external/ExternalApiSigner';
-export { CetusStrategyApiManager as CetusStrategyApiManager, CetusPair as CetusPair, CetusRate as CetusRate, CetusStrategy as CetusStrategy } from './api/external/cetus/CetusStrategyApiManager';
-export { APIRequest as APIRequest, RequestMethod as RequestMethod, RequestContext as RequestContext, GroupedParameters as GroupedParameters, APIRequestConfig as APIRequestConfig, RequestParameterType as RequestParameterType } from './api/APIRequest';
-export { APIRequestBuilder as APIRequestBuilder, DocDetails as DocDetails, ISamples as ISamples } from './api/APIRequestBuilder';
-export { APIRouter as APIRouter } from './api/APIRouter';
-export { SimpleAPIRouter as SimpleAPIRouter} from './api/route/SimpleAPIRouter';
-export { RequestAxiosCall as RequestAxiosCall } from './api/request/RequestAxiosCall';
-export { GetRequest as GetRequest } from './api/request/GetRequest';
-export { PostRequest as PostRequest } from './api/request/PostRequest';
-export { PutRequest as PutRequest } from './api/request/PutRequest';
-export { DeleteRequest as DeleteRequest } from './api/request/DeleteRequest';
-export { CheckableAPIRequest as CheckableAPIRequest } from './api/check/CheckableAPIRequest';
-export { Checkable as Checkable, APICheckResult as APICheckResult, APICheck as APICheck, APIChecker as APIChecker, APICheckConfig as APICheckConfig } from './api/check/APIChecker';
-export { CheckableDeleteRequest as CheckableDeleteRequest } from './api/check/request/CheckableDeleteRequest';
-export { CheckableGetRequest as CheckableGetRequest } from './api/check/request/CheckableGetRequest';
-export { CheckablePostRequest as CheckablePostRequest } from './api/check/request/CheckablePostRequest';
-export { CheckablePutRequest as CheckablePutRequest } from './api/check/request/CheckablePutRequest';
-export { CheckableFileUploadingPostRequest as CheckableFileUploadingPostRequest } from './api/check/request/CheckableFileUploadingPostRequest';
-export { CheckableAPIRouter as CheckableAPIRouter } from './api/check/CheckableAPIRouter';
-export { CorsCheckApiRouter as CorsCheckApiRouter } from './api/check/route/CorsCheckApiRouter';
-export { SimpleCheckableAPIRouter as SimpleCheckableAPIRouter } from './api/check/route/SimpleCheckableAPIRouter';
-
-export { CrudManager as CrudManager } from './api/request/crud/CrudManager';
-export { CrudServiceManager as CrudServiceManager, StandardIdRequestDefinition as StandardIdRequestDefinition } from './api/request/crud/CrudServiceManager';
-
-export { MongooseModelManager as MongooseModelManager } from './database/mongoose/MongooseModelManager';
-export { SequelizeConnection as SequelizeConnection } from './database/sequelize/SequelizeConnection';
-export { SequelizeModelManager as SequelizeModelManager } from './database/sequelize/SequelizeModelManager';
-
-export { Logger as Logger } from './log/Logger';
-export { LoggerManager as LoggerManager } from './log/LoggerManager';
-export { LoggerWebSocket as LoggerWebSocket } from './log/LoggerWebSocket';
-
-export { Coin as Coin } from './web3/Coin';
-export { CoingeckoPriceFinder as CoingeckoPriceFinder } from './web3/coingecko/CoingeckoPriceFinder';
-
-export { round as round } from './math/Utils';
-
-export { BANKS as BANKS, DOCUMENT_TYPES as DOCUMENT_TYPES, PAYMENT_TYPES as PAYMENT_TYPES } from './types/payments';

package/src/log/Logger.ts

@@ -1,27 +0,0 @@
-import axios from 'axios';
-
-export class Logger {
-    private executor: string;
-    private url: string;
-
-    constructor(executor: string, url: string) {
-        this.executor = executor;
-        this.url = url;
-    }
-
-    public requestExecutionId(): Promise<any> {
-        return new Promise((resolve, reject) => {
-            axios.post(this.executor + "/generateid", {}, { headers: { 'Content-Type': 'application/json' }})
-            .then(response => { resolve(response.data); })
-            .catch(err => { reject(err); });
-        });
-    }
-
-    public send(log: any): Promise<any> {
-        return new Promise((resolve, reject) => {
-            axios.post(this.url, { log: log }, { headers: { 'Content-Type': 'application/json' }})
-            .then(response => { resolve(response.data); })
-            .catch(err => { reject(err); });
-        });
-    }
-}

package/src/log/LoggerManager.ts

@@ -1,50 +0,0 @@
-import { LoggerWebSocket } from "./LoggerWebSocket";
-
-export class LoggerManager {
-    private url: string;
-
-    constructor(url: string) {
-        this.url = url;
-    }
-
-    public connect(): Promise<LoggerWebSocket> {
-        return new Promise((resolve, reject) => {
-            let client = new LoggerWebSocket(this.url);
-            client.on('open', () => {
-                console.log("> client connected");
-                resolve(client);
-            });
-            client.on('message', function(data: any) {
-                let message = data.toString();
-                let datum = JSON.parse(message);
-                if (datum.action === 'LOG') {
-                    delete datum.payload.log._id;
-                    if (datum.payload.log.timestamp >= client.from)
-                        client.transactions.push(datum.payload.log);
-                } else if (datum.action === 'FINISHED') {
-                    console.log("> finished");
-                    client.resolve(client.transactions);
-                } else if (datum.action === 'EMPTY_ID') {
-                    console.log("> EMPTY_ID: ", datum.payload.message);
-                    client.resolve([]);
-                } else {
-                    console.log("> unrecognizeable message: ", message);
-                    client.resolve([]);
-                }
-            });
-        });
-    }
-
-    public async requestNextLogs(client: LoggerWebSocket, executionId: string): Promise<any[]> {
-        client.transactions = [];
-        let logs: any[] = await new Promise((resolve, reject) => {
-            client.resolve = resolve;
-            client.reject = reject;
-            console.log("> requesting:", executionId);
-            client.send(executionId);
-        });
-        logs.sort(function(a, b) { return a.timestamp - b.timestamp });
-        console.log("> logs:", logs.length);
-        return logs;
-    }
-}

package/src/log/LoggerWebSocket.ts

@@ -1,13 +0,0 @@
-import { ClientRequestArgs } from 'http';
-import WebSocket from 'ws';
-
-export class LoggerWebSocket extends WebSocket {
-    public from: number = 0;
-    public transactions: any[] = [];
-    public resolve: any;
-    public reject: any;
-
-    constructor(address: string, options?: WebSocket.ClientOptions | ClientRequestArgs | undefined) {
-        super(address, options);
-    }
-}

package/src/math/Utils.ts

@@ -1,4 +0,0 @@
-export function round(value: number, decimals: number) {
-    let aux = Math.pow(10, decimals);
-    return Math.round(value * aux) / aux;
-}