badmfck-api-server 3.0.7 → 3.0.8

package/dist/apiServer/APIService.d.ts

@@ -34,6 +34,10 @@ export interface APIServiceOptions {
     interceptor?: IBaseEndpoint;
     postproducer?: (req: HTTPRequestVO | undefined | null, res: Response, data: TransferPacketVO<any>, requestTime: number, endpoint?: string, log?: APIServiceNetworkLogItem | null) => Promise<TransferPacketVO>;
     preproducer?: (req: HTTPRequestVO | undefined | null) => any;
+    access: {
+        monitor?: IMonitorUser[];
+        documentation?: IMonitorUser[];
+    };
     monitor?: IMonitorUser[];
     appVersion?: string;
     fileTempDir: string;
@@ -49,6 +53,7 @@ export declare const REQ_HTTP_SERVER: Req<void, {
 }>;
 export declare const REQ_INTERNAL_CALL: Req<HTTPRequestVO, IError | any>;
 export declare const REQ_MONITOR_USERS: Req<void, IMonitorUser[]>;
+export declare const REQ_DOC_USERS: Req<void, IMonitorUser[]>;
 export declare function Initializer(services: IBaseService[]): Promise<void>;
 export declare class APIService extends BaseService {
     private static nextLogID;

package/dist/apiServer/APIService.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.APIService = exports.Initializer = exports.REQ_MONITOR_USERS = exports.REQ_INTERNAL_CALL = exports.REQ_HTTP_SERVER = exports.REQ_HTTP_REQUESTS_COUNT = exports.REQ_HTTP_LOG = exports.REQ_CREATE_NET_LOG = exports.getDefaultOptions = void 0;
+exports.APIService = exports.Initializer = exports.REQ_DOC_USERS = exports.REQ_MONITOR_USERS = exports.REQ_INTERNAL_CALL = exports.REQ_HTTP_SERVER = exports.REQ_HTTP_REQUESTS_COUNT = exports.REQ_HTTP_LOG = exports.REQ_CREATE_NET_LOG = exports.getDefaultOptions = void 0;
 const express_1 = __importDefault(require("express"));
 const BaseService_1 = require("./BaseService");
 const cors_1 = __importDefault(require("cors"));
@@ -47,9 +47,15 @@ const StatService_1 = require("./StatService");
 const ExternalServiceEndpoint_1 = require("./external/ExternalServiceEndpoint");
 const MonitorService_1 = require("./MonitorService");
 const MysqlAdapter_1 = require("./db/MysqlAdapter");
+const DocumentService_1 = require("./DocumentService");
+const Documentation_1 = require("./documentation/Documentation");
 function getDefaultOptions() {
     return {
         port: 8091,
+        access: {
+            monitor: [],
+            documentation: [],
+        },
         baseEndPoint: '/api/',
         corsHostWhiteList: [
             'http://localhost:3000',
@@ -74,6 +80,7 @@ exports.REQ_HTTP_REQUESTS_COUNT = new badmfck_signal_1.Req(undefined, "REQ_HTTP_
 exports.REQ_HTTP_SERVER = new badmfck_signal_1.Req(undefined, "REQ_HTTP_SERVER");
 exports.REQ_INTERNAL_CALL = new badmfck_signal_1.Req(undefined, "REQ_INTERNAL_CALL");
 exports.REQ_MONITOR_USERS = new badmfck_signal_1.Req(undefined, "REQ_MONITOR_USERS");
+exports.REQ_DOC_USERS = new badmfck_signal_1.Req(undefined, "REQ_MONITOR_USERS");
 const activeServices = [];
 async function Initializer(services) {
     services.push(new StatService_1.StatService());
@@ -106,11 +113,13 @@ class APIService extends BaseService_1.BaseService {
         if (!this.options.corsHostWhiteList.find(val => val === self))
             this.options.corsHostWhiteList.push();
         if (this.options.monitor && this.options.monitor.length > 0) {
-            exports.REQ_MONITOR_USERS.listener = async () => this.options.monitor ?? [];
+            exports.REQ_MONITOR_USERS.listener = async () => this.options.access.monitor ?? this.options.monitor ?? [];
+            exports.REQ_DOC_USERS.listener = async () => this.options.access.documentation ?? [];
             this.monitor = new MonitorService_1.MonitorService();
             this.monitor.init();
             this.options.endpoints.push(new Monitor_1.Monitor());
         }
+        this.options.endpoints.push(new Documentation_1.Documentation());
         this.options.endpoints.push(new ExternalServiceEndpoint_1.ExternalServiceEndpoint());
         this.options.endpoints.push(new Liveness_1.Liveness(this.started), new Readiness_1.Readiness(this.started));
         exports.REQ_HTTP_REQUESTS_COUNT.listener = async () => this.requestsCount;
@@ -369,6 +378,7 @@ class APIService extends BaseService_1.BaseService {
         server.listen(this.options.port, () => {
             (0, LogService_1.logCrit)('${APIService.js}', 'API Service started at: ' + this.options.port + ", with base endpoint:" + this.options.baseEndPoint + ", ver.: " + this.version);
         });
+        new DocumentService_1.DocumentGenerator(this.options.endpoints);
     }
     async sendResponse(ref, res, data, requestTime, endpoint, log, req) {
         if (data.blockResponse) {

package/dist/apiServer/BaseEndpoint.d.ts

@@ -8,28 +8,38 @@ export interface IBaseEndpoint {
 }
 declare const httpMethods: string[];
 type HTTPMethod = typeof httpMethods[number];
-type IHandler = Record<HTTPMethod, ((req: HTTPRequestVO) => Promise<TransferPacketVO<any>>) | {
+export type IHandler = Record<HTTPMethod, ((req: HTTPRequestVO) => Promise<TransferPacketVO<any>>) | {
     controller: (req: HTTPRequestVO) => Promise<TransferPacketVO<any>>;
     ignoreInterceptor?: boolean;
     allowInterceptorError?: boolean;
     validationModel?: any;
     asStream?: boolean;
+    ignoreInDocumentation?: boolean;
+    ignoreHttpLogging?: boolean;
+    description?: string;
+    title?: string;
 }>;
 export interface IEndpointHandler {
     endpoint: string;
     handler?: ((req: HTTPRequestVO) => Promise<TransferPacketVO<any>>) | IHandler;
     ignoreInterceptor?: boolean;
+    ignoreInDocumentation?: boolean;
+    ignoreHttpLogging?: boolean;
     independed?: boolean;
     allowInterceptorError?: boolean;
     asStream?: boolean;
+    description?: string;
+    title?: string;
     validationModel?: any;
 }
 export declare class BaseEndpoint implements IBaseEndpoint {
     private inializedEndpointNames;
+    description: string;
     endpoints?: IEndpointHandler[];
     ignoreHttpLogging: boolean;
+    ignoreInDocumentation: boolean;
     private static entrypoint;
-    private endpoint;
+    endpoint: string;
     static setEntryPoint: (ep: string) => void;
     static getEntryPoint: () => string;
     constructor(endpoint: string);

package/dist/apiServer/BaseEndpoint.js

@@ -11,8 +11,10 @@ const stream_1 = require("stream");
 const httpMethods = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD", "TRACE", "CONNECT"];
 class BaseEndpoint {
     inializedEndpointNames = [];
+    description = "no description";
     endpoints;
     ignoreHttpLogging = false;
+    ignoreInDocumentation = false;
     static entrypoint = "/";
     endpoint = "";
     static setEntryPoint = (ep) => {

package/dist/apiServer/DocumentService.d.ts

@@ -1,42 +1,9 @@
-declare type DocumentGeneratorConfig = {
-    sourcePath: string;
-    apiEndpoint: string;
-    savePath: string;
-    savePathFileName: string;
-};
-declare type DocumentGeneratorDocumentation = {
-    [baseEndpointName: string]: {
-        [endPointName: string]: DocumentGeneratorDocumentationEndpoint;
-    };
-};
-declare type DocumentGeneratorDocumentationEndpoint = {
-    handler: string;
-    fullPath: string;
-    ignoreInterceptor?: string;
-    description?: string;
-    parameters: DocumentGeneratorDocumentationEndpointParameter[];
-    returns?: Omit<DocumentGeneratorDocumentationEndpointParameter, "optional">;
-    example?: string[];
-    throws?: Omit<DocumentGeneratorDocumentationEndpointParameter, "optional">[];
-};
-declare type DocumentGeneratorDocumentationEndpointParameter = {
-    name: string;
-    type: string;
-    description: string;
-    optional?: boolean;
-};
+import { Req } from "badmfck-signal";
+import { BaseEndpoint } from "./BaseEndpoint";
+export declare const REQ_DOC: Req<void, Record<string, any>[]>;
 export declare class DocumentGenerator {
-    private documentation;
-    private config;
-    constructor(config: DocumentGeneratorConfig);
-    private getFiles;
-    private getFileContent;
+    endpoints: BaseEndpoint[];
+    documentation: Record<string, any>[];
+    constructor(endpoints: BaseEndpoint[]);
     private generateDocumentation;
-    private getCommentsByEndpoint;
-    private parseEndPointComments;
-    private tagToEndpoint;
-    private tagModifications;
-    private saveDocumentation;
-    getDocumentation(): DocumentGeneratorDocumentation;
 }
-export {};

package/dist/apiServer/DocumentService.js

@@ -1,182 +1,57 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocumentGenerator = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const comment_parser_1 = require("comment-parser");
+exports.DocumentGenerator = exports.REQ_DOC = void 0;
+const badmfck_signal_1 = require("badmfck-signal");
+exports.REQ_DOC = new badmfck_signal_1.Req(undefined, "REQ_DOC");
 class DocumentGenerator {
-    documentation = {};
-    config;
-    constructor(config) {
-        this.config = config;
+    endpoints = [];
+    documentation = [];
+    constructor(endpoints) {
+        this.endpoints = endpoints;
         this.generateDocumentation();
-    }
-    getFiles() {
-        return fs.readdirSync(this.config.sourcePath);
-    }
-    getFileContent(file) {
-        return fs.readFileSync(path.resolve(this.config.sourcePath, file), "utf-8");
+        exports.REQ_DOC.listener = async () => this.documentation;
     }
     generateDocumentation = () => {
-        for (const file of this.getFiles()) {
-            const fileContent = this.getFileContent(file);
-            const baseEndpoint = fileContent.match(/super\(['"](.*?)['"]\)/);
-            if (!baseEndpoint) {
-                console.error(`No base endpoint found in ${file}`);
+        for (let i of this.endpoints) {
+            if (i.ignoreInDocumentation || i.ignoreHttpLogging)
                 continue;
-            }
-            const nodeEndpoint = this.config.apiEndpoint + "/" + baseEndpoint[1];
-            const regex = /{\s*endpoint:\s*"(.*?)",\s*handler:\s*this\.(.*?)(?:,\s*ignoreInterceptor:\s*(true|false))?\s*}/g;
-            const endpoints = fileContent.matchAll(regex);
-            for (const match of endpoints) {
-                const endpointName = match[1];
-                const handler = match[2];
-                const ignoreInterceptor = match[3];
-                if (!this.documentation.hasOwnProperty(nodeEndpoint)) {
-                    this.documentation[nodeEndpoint] = {};
+            const branch = {
+                name: i.endpoint,
+                description: i.description,
+                endpoints: []
+            };
+            this.documentation.push(branch);
+            for (let j of i.endpoints || []) {
+                if (j.ignoreInDocumentation || j.ignoreHttpLogging)
+                    continue;
+                const endpoint = {};
+                endpoint.name = i.endpoint + "/" + j.endpoint;
+                endpoint.methods = {};
+                if (typeof j.handler === "function") {
+                    const method = j.validationModel ? "POST" : "GET";
+                    endpoint.methods[method] = {
+                        title: j.title || "",
+                        description: j.description,
+                        parameters: j.validationModel ?? {},
+                        authorized: !j.ignoreInterceptor
+                    };
                 }
-                const endpoint = {
-                    handler,
-                    ignoreInterceptor,
-                    fullPath: nodeEndpoint + "/" + endpointName,
-                    description: "",
-                    parameters: [],
-                };
-                this.documentation[nodeEndpoint][endpointName] = this.parseEndPointComments(this.getCommentsByEndpoint(fileContent, handler), endpoint);
-            }
-        }
-        this.saveDocumentation();
-        console.log("Documentation generated and saved successfully");
-    };
-    getCommentsByEndpoint(fileContent, handler) {
-        let comments = "";
-        const regex = new RegExp(`(async )*${handler}(\\s*)\\(`, "g");
-        const match = fileContent.match(regex);
-        if (match) {
-            const indexHandler = fileContent.indexOf(`${match[0]}`);
-            if (indexHandler != -1) {
-                const indexCommentStart = fileContent.lastIndexOf("/**", indexHandler);
-                if (indexCommentStart != -1) {
-                    const indexCommentEnd = fileContent.indexOf("*/", indexCommentStart);
-                    if (indexCommentEnd != -1) {
-                        const commentsSubstring = fileContent.substring(indexCommentStart, indexCommentEnd + 2);
-                        if (commentsSubstring) {
-                            const regexToCheckCommentWithMethod = new RegExp(`${commentsSubstring.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([\\s]*?)(async )*${handler}(\\s*)\\(`, "g");
-                            const matchToCheckCommentWithMethod = fileContent.match(regexToCheckCommentWithMethod);
-                            if (matchToCheckCommentWithMethod) {
-                                comments = commentsSubstring;
-                            }
-                        }
+                else if (typeof j.handler === "object") {
+                    for (let method in j.handler) {
+                        const handler = j.handler;
+                        if (handler.ignoreInDocumentation || handler.ignoreHttpLogging)
+                            continue;
+                        endpoint.methods[method] = {
+                            title: handler.title || j.title || "",
+                            description: handler.description || j.description,
+                            parameters: handler.validationModel || {},
+                            authorized: !handler.ignoreInterceptor
+                        };
                     }
                 }
+                branch.endpoints.push(endpoint);
             }
         }
-        return comments;
-    }
-    parseEndPointComments(comments, endpoint) {
-        if (comments) {
-            const parsed = (0, comment_parser_1.parse)(comments, { spacing: "preserve" });
-            if (parsed[0]) {
-                const firstParsed = parsed[0];
-                endpoint.description = this.tagModifications(firstParsed.description);
-                firstParsed.tags.forEach((tag) => {
-                    endpoint = this.tagToEndpoint(tag, endpoint);
-                });
-            }
-        }
-        return endpoint;
-    }
-    tagToEndpoint(tag, endpoint) {
-        switch (tag.tag) {
-            case "param":
-                endpoint.parameters.push({
-                    name: this.tagModifications(tag.name, "name"),
-                    type: tag.type,
-                    description: this.tagModifications(tag.description),
-                    optional: tag.optional,
-                });
-                break;
-            case "description":
-                endpoint.description = this.tagModifications(tag.description);
-                break;
-            case "example":
-                if (!endpoint.example) {
-                    endpoint.example = [];
-                }
-                endpoint.example.push(this.tagModifications(tag.description));
-                break;
-            case "returns":
-                endpoint.returns = {
-                    name: this.tagModifications(tag.name, "name"),
-                    type: tag.type,
-                    description: this.tagModifications(tag.description),
-                };
-                break;
-            case "throws":
-                if (!endpoint.throws) {
-                    endpoint.throws = [];
-                }
-                endpoint.throws.push({
-                    name: this.tagModifications(tag.name, "name"),
-                    type: tag.type,
-                    description: this.tagModifications(tag.description),
-                });
-                break;
-        }
-        return endpoint;
-    }
-    tagModifications(text, field = "description") {
-        switch (field) {
-            case "description":
-                text = text
-                    .trim()
-                    .replace(/^(\-.)/, "")
-                    .trim();
-                break;
-            case "name":
-                if (text === "-") {
-                    text = "";
-                }
-                break;
-        }
-        return text;
-    }
-    saveDocumentation() {
-        const formatForSave = this.documentation;
-        const filePath = this.config.savePath + this.config.savePathFileName;
-        fs.writeFileSync(filePath, JSON.stringify(formatForSave, null, 2));
-    }
-    getDocumentation() {
-        return this.documentation;
-    }
+    };
 }
 exports.DocumentGenerator = DocumentGenerator;
-new DocumentGenerator({
-    sourcePath: "./src/api",
-    apiEndpoint: "api/v1",
-    savePath: "./bin/",
-    savePathFileName: "doc.json",
-});

package/dist/apiServer/documentation/Documentation.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { BaseEndpoint } from "../BaseEndpoint";
+import { HTTPRequestVO, TransferPacketVO } from "../structures/Interfaces";
+export declare class Documentation extends BaseEndpoint {
+    indexHtmlFile: Buffer | null;
+    constructor();
+    json(req: HTTPRequestVO): Promise<{
+        data: Record<string, any>[];
+    }>;
+    html(req: HTTPRequestVO): Promise<TransferPacketVO<any>>;
+    checkAuthorization(req: HTTPRequestVO): Promise<void>;
+}

package/dist/apiServer/documentation/Documentation.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Documentation = void 0;
+const APIService_1 = require("../APIService");
+const BaseEndpoint_1 = require("../BaseEndpoint");
+const DocumentService_1 = require("../DocumentService");
+const DefaultErrors_1 = __importDefault(require("../structures/DefaultErrors"));
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class Documentation extends BaseEndpoint_1.BaseEndpoint {
+    indexHtmlFile = null;
+    constructor() {
+        super("doc");
+        this.registerEndpoints([{
+                ignoreInDocumentation: true,
+                endpoint: "json",
+                handler: this.json,
+                ignoreInterceptor: true
+            },
+            {
+                ignoreInDocumentation: true,
+                endpoint: "html",
+                handler: this.html,
+                ignoreInterceptor: true
+            }]);
+    }
+    async json(req) {
+        this.checkAuthorization(req);
+        const doc = await DocumentService_1.REQ_DOC.request();
+        return { data: doc };
+    }
+    async html(req) {
+        if (!this.indexHtmlFile)
+            this.indexHtmlFile = fs_1.default.readFileSync(path_1.default.resolve(__dirname, "index.html"));
+        return {
+            rawResponse: true,
+            data: this.indexHtmlFile,
+            headers: {
+                "Content-Type": "text/html",
+                "Content-Length": this.indexHtmlFile.byteLength.toString()
+            }
+        };
+    }
+    async checkAuthorization(req) {
+        const users = await APIService_1.REQ_DOC_USERS.request();
+        if (!users || users.length == 0)
+            throw { ...DefaultErrors_1.default.UNAUTHORIZED, details: "No users found for documentation access" };
+        let header = req.headers['authorization'];
+        if (!header)
+            throw { ...DefaultErrors_1.default.UNAUTHORIZED, details: "No authorization header found" };
+        header = header.split(" ").pop() ?? "";
+        for (let i of users) {
+            const hash = crypto_1.default.createHash("sha256").update(i.login + ":" + i.password).digest("hex");
+            if (hash === header) {
+                return;
+            }
+        }
+        throw { ...DefaultErrors_1.default.UNAUTHORIZED, details: "Invalid user" };
+    }
+}
+exports.Documentation = Documentation;

package/dist/apiServer/external/ExternalServiceEndpoint.js

@@ -7,6 +7,7 @@ const ExternalService_1 = require("./ExternalService");
 class ExternalServiceEndpoint extends BaseEndpoint_1.BaseEndpoint {
     constructor() {
         super("external");
+        this.ignoreInDocumentation = true;
         this.registerEndpoints([
             { endpoint: "call/:id", handler: this.handler, ignoreInterceptor: true }
         ]);

package/dist/apiServer/monitor/Monitor.d.ts

@@ -13,6 +13,7 @@ interface IStatObject {
 export declare const S_MONITOR_REGISTRATE_ACTION: Signal<IUserAction>;
 export declare class Monitor extends BaseEndpoint {
     ignoreHttpLogging: boolean;
+    ignoreInDocumentation: boolean;
     users: Map<string, IStatObject>;
     constructor();
     controllers(req: HTTPRequestVO): Promise<TransferPacketVO>;

package/dist/apiServer/monitor/Monitor.js

@@ -15,6 +15,7 @@ const MonitorService_1 = require("../MonitorService");
 exports.S_MONITOR_REGISTRATE_ACTION = new badmfck_signal_1.Signal();
 class Monitor extends BaseEndpoint_1.BaseEndpoint {
     ignoreHttpLogging = true;
+    ignoreInDocumentation = true;
     users = new Map();
     constructor() {
         super("--sys-monitor");

package/dist/apiServer/routes/Readiness.js

@@ -8,6 +8,7 @@ class Readiness extends BaseEndpoint_1.BaseEndpoint {
     constructor(stated) {
         super("readiness");
         this.started = stated;
+        this.ignoreInDocumentation = true;
         this.registerEndpoints([{ endpoint: "", handler: this.checkReadiness, ignoreInterceptor: true }]);
     }
     async checkReadiness(req) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "badmfck-api-server",
-  "version": "3.0.7",
+  "version": "3.0.8",
   "description": "Simple API http server based on express",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",