axe-api 1.0.0-rc9 → 1.0.0

package/build/src/Services/App.d.ts

@@ -1,14 +1,100 @@
-import connect from "connect";
-import { DynamicFunctionType } from "../Types";
+import connect, { NextHandleFunction, ErrorHandleFunction } from "connect";
+import { GeneralFunction } from "../Types";
 declare class App {
     private connect;
+    private docs;
     constructor();
+    /**
+     * Get the `connect` instance
+     *
+     * @readonly
+     * @memberof App
+     */
     get instance(): connect.Server;
-    use(middleware: connect.NextHandleFunction): void;
-    get(url: string, ...args: DynamicFunctionType): void;
-    post(url: string, ...args: DynamicFunctionType): void;
-    put(url: string, ...args: DynamicFunctionType): void;
-    patch(url: string, ...args: DynamicFunctionType): void;
-    delete(url: string, ...args: DynamicFunctionType): void;
+    /**
+     * Add a global connect middleware
+     *
+     * @param middleware
+     * @example
+     *  app.use((req: IncomingMessage, res: ServerResponse, next: any) => {
+     *    next()
+     *  })
+     */
+    use(middleware: NextHandleFunction | ErrorHandleFunction): void;
+    /**
+     * Add a GET request handler with middleware support
+     *
+     * @param url
+     * @param args
+     * @example
+     *  app.get(
+     *    "/api/v1/health",
+     *    myHandler,
+     *    async (req: AxeRequest, res: AxeResponse) => {
+     *      res.json({});
+     *    }
+     * );
+     */
+    get(url: string, ...args: GeneralFunction[]): void;
+    /**
+     * Add a POST request handler with middleware support
+     *
+     * @param url
+     * @param args
+     * @example
+     *  app.post(
+     *    "/api/v1/health",
+     *    myHandler,
+     *    async (req: AxeRequest, res: AxeResponse) => {
+     *      res.json({});
+     *    }
+     * );
+     */
+    post(url: string, ...args: GeneralFunction[]): void;
+    /**
+     * Add a PUT request handler with middleware support
+     *
+     * @param url
+     * @param args
+     * @example
+     *  app.put(
+     *    "/api/v1/health",
+     *    myHandler,
+     *    async (req: AxeRequest, res: AxeResponse) => {
+     *      res.json({});
+     *    }
+     * );
+     */
+    put(url: string, ...args: GeneralFunction[]): void;
+    /**
+     * Add a PATCH request handler with middleware support
+     *
+     * @param url
+     * @param args
+     * @example
+     *  app.patch(
+     *    "/api/v1/health",
+     *    myHandler,
+     *    async (req: AxeRequest, res: AxeResponse) => {
+     *      res.json({});
+     *    }
+     * );
+     */
+    patch(url: string, ...args: GeneralFunction[]): void;
+    /**
+     * Add a DELETE request handler with middleware support
+     *
+     * @param url
+     * @param args
+     * @example
+     *  app.delete(
+     *    "/api/v1/health",
+     *    myHandler,
+     *    async (req: AxeRequest, res: AxeResponse) => {
+     *      res.json({});
+     *    }
+     * );
+     */
+    delete(url: string, ...args: GeneralFunction[]): void;
 }
 export default App;

package/build/src/Services/App.js

@@ -1,27 +1,4 @@
 "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;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -30,12 +7,14 @@ const connect_1 = __importDefault(require("connect"));
 const body_parser_1 = __importDefault(require("body-parser"));
 const URLService_1 = __importDefault(require("./URLService"));
 const LogService_1 = __importDefault(require("./LogService"));
-const RateLimit_1 = __importStar(require("../Middlewares/RateLimit"));
+const RateLimit_1 = require("../Middlewares/RateLimit");
 const APIService_1 = __importDefault(require("./APIService"));
 const ConverterService_1 = require("./ConverterService");
+const DocumentationService_1 = __importDefault(require("./DocumentationService"));
+const Enums_1 = require("../Enums");
 class App {
     constructor() {
-        var _a;
+        this.docs = DocumentationService_1.default.getInstance();
         this.connect = (0, connect_1.default)();
         LogService_1.default.debug("Created a new connect() instance");
         this.connect.use(body_parser_1.default.urlencoded({ extended: true }));
@@ -44,37 +23,123 @@ class App {
         // Activate the Rate Limit middleware
         const api = APIService_1.default.getInstance();
         (0, RateLimit_1.setupRateLimitAdaptors)(api.config);
-        if ((_a = api.config.rateLimit) === null || _a === void 0 ? void 0 : _a.enabled) {
-            LogService_1.default.debug("New middleware: rateLimit()");
-            this.connect.use(RateLimit_1.default);
-        }
     }
+    /**
+     * Get the `connect` instance
+     *
+     * @readonly
+     * @memberof App
+     */
     get instance() {
         return this.connect;
     }
+    /**
+     * Add a global connect middleware
+     *
+     * @param middleware
+     * @example
+     *  app.use((req: IncomingMessage, res: ServerResponse, next: any) => {
+     *    next()
+     *  })
+     */
     use(middleware) {
         this.connect.use(middleware);
         LogService_1.default.debug(`New middleware: ${middleware.name || "anonymous"}()`);
     }
+    /**
+     * Add a GET request handler with middleware support
+     *
+     * @param url
+     * @param args
+     * @example
+     *  app.get(
+     *    "/api/v1/health",
+     *    myHandler,
+     *    async (req: AxeRequest, res: AxeResponse) => {
+     *      res.json({});
+     *    }
+     * );
+     */
     get(url, ...args) {
         const { handler, middlewares } = (0, ConverterService_1.resolveMiddlewares)(args);
         URLService_1.default.addHandler("GET", url, handler, middlewares);
+        this.docs.pushCustom(Enums_1.HttpMethods.GET, url);
     }
+    /**
+     * Add a POST request handler with middleware support
+     *
+     * @param url
+     * @param args
+     * @example
+     *  app.post(
+     *    "/api/v1/health",
+     *    myHandler,
+     *    async (req: AxeRequest, res: AxeResponse) => {
+     *      res.json({});
+     *    }
+     * );
+     */
     post(url, ...args) {
         const { handler, middlewares } = (0, ConverterService_1.resolveMiddlewares)(args);
         URLService_1.default.addHandler("POST", url, handler, middlewares);
+        this.docs.pushCustom(Enums_1.HttpMethods.POST, url);
     }
+    /**
+     * Add a PUT request handler with middleware support
+     *
+     * @param url
+     * @param args
+     * @example
+     *  app.put(
+     *    "/api/v1/health",
+     *    myHandler,
+     *    async (req: AxeRequest, res: AxeResponse) => {
+     *      res.json({});
+     *    }
+     * );
+     */
     put(url, ...args) {
         const { handler, middlewares } = (0, ConverterService_1.resolveMiddlewares)(args);
         URLService_1.default.addHandler("PUT", url, handler, middlewares);
+        this.docs.pushCustom(Enums_1.HttpMethods.PUT, url);
     }
+    /**
+     * Add a PATCH request handler with middleware support
+     *
+     * @param url
+     * @param args
+     * @example
+     *  app.patch(
+     *    "/api/v1/health",
+     *    myHandler,
+     *    async (req: AxeRequest, res: AxeResponse) => {
+     *      res.json({});
+     *    }
+     * );
+     */
     patch(url, ...args) {
         const { handler, middlewares } = (0, ConverterService_1.resolveMiddlewares)(args);
         URLService_1.default.addHandler("PATCH", url, handler, middlewares);
+        this.docs.pushCustom(Enums_1.HttpMethods.PATCH, url);
     }
+    /**
+     * Add a DELETE request handler with middleware support
+     *
+     * @param url
+     * @param args
+     * @example
+     *  app.delete(
+     *    "/api/v1/health",
+     *    myHandler,
+     *    async (req: AxeRequest, res: AxeResponse) => {
+     *      res.json({});
+     *    }
+     * );
+     */
     delete(url, ...args) {
         const { handler, middlewares } = (0, ConverterService_1.resolveMiddlewares)(args);
         URLService_1.default.addHandler("DELETE", url, handler, middlewares);
+        this.docs.pushCustom(Enums_1.HttpMethods.DELETE, url);
     }
 }
 exports.default = App;

package/build/src/Services/AxeRequest.d.ts

@@ -10,17 +10,66 @@ declare class AxeRequest {
     private privateParams;
     private version;
     constructor(request: IncomingMessage);
+    /**
+     * Get the URL Object
+     *
+     * @memberof AxeRequest
+     */
     get url(): URL;
+    /**
+     * Get the URL params
+     *
+     * @memberof AxeRequest
+     * @example
+     *  GET api/v1/users/123
+     *  { "id": 123 }
+     */
     get params(): any;
     set params(value: any);
+    /**
+     * Get the URLSearchParams
+     *
+     * @memberof AxeRequest
+     */
     get query(): URLSearchParams;
-    get path(): string;
+    /**
+     * Get the HTTP Method
+     *
+     * @memberof AxeRequest
+     */
     get method(): string;
+    /**
+     * Get the request form body
+     *
+     * @memberof AxeRequest
+     */
     get body(): any;
+    /**
+     * Get the current langugage
+     *
+     * @memberof AxeRequest
+     */
     get currentLanguage(): ILanguage;
     set currentLanguage(language: ILanguage);
+    /**
+     * Get a HTTP Request Header value
+     *
+     * @param key
+     * @returns
+     */
     header(key: string): string | string[] | undefined;
-    files(options?: FormOptions): Promise<[formidable.Fields, formidable.Files]>;
+    /**
+     * Parse and get uploaded files. It uses `formidable` internally.
+     *
+     * @param options
+     * @returns
+     */
+    files(options?: FormOptions): Promise<[formidable.Fields<string>, formidable.Files<string>]>;
+    /**
+     * Get the original `IncomingMessage` request.
+     *
+     * @memberof AxeRequest
+     */
     get original(): IncomingMessage;
 }
 export default AxeRequest;

package/build/src/Services/AxeRequest.js

@@ -20,6 +20,7 @@ class AxeRequest {
     constructor(request) {
         this.privateParams = {};
         this.request = request;
+        this.request.tags = [];
         this.urlObject = new URL(request.url || "", "http://127.0.0.1");
         // Application configuration is need for the default setting.
         this.version = (0, Helpers_1.getVersionByRequest)(this.urlObject);
@@ -35,37 +36,78 @@ class AxeRequest {
             };
         }
     }
+    /**
+     * Get the URL Object
+     *
+     * @memberof AxeRequest
+     */
     get url() {
         return this.urlObject;
     }
+    /**
+     * Get the URL params
+     *
+     * @memberof AxeRequest
+     * @example
+     *  GET api/v1/users/123
+     *  { "id": 123 }
+     */
     get params() {
         return this.privateParams;
     }
     set params(value) {
         this.privateParams = value;
     }
+    /**
+     * Get the URLSearchParams
+     *
+     * @memberof AxeRequest
+     */
     get query() {
         return this.urlObject.searchParams;
     }
-    get path() {
-        // TODO: Path
-        return this.request.url || "";
-    }
+    /**
+     * Get the HTTP Method
+     *
+     * @memberof AxeRequest
+     */
     get method() {
         return this.request.method || "GET";
     }
+    /**
+     * Get the request form body
+     *
+     * @memberof AxeRequest
+     */
     get body() {
         return this.request.body;
     }
+    /**
+     * Get the current langugage
+     *
+     * @memberof AxeRequest
+     */
     get currentLanguage() {
         return this.language;
     }
     set currentLanguage(language) {
         this.language = language;
     }
+    /**
+     * Get a HTTP Request Header value
+     *
+     * @param key
+     * @returns
+     */
     header(key) {
         return this.request.headers[key];
     }
+    /**
+     * Parse and get uploaded files. It uses `formidable` internally.
+     *
+     * @param options
+     * @returns
+     */
     files(options) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
@@ -78,6 +120,11 @@ class AxeRequest {
             return yield form.parse(this.request);
         });
     }
+    /**
+     * Get the original `IncomingMessage` request.
+     *
+     * @memberof AxeRequest
+     */
     get original() {
         return this.request;
     }

package/build/src/Services/AxeResponse.d.ts

@@ -1,18 +1,45 @@
 /// <reference types="node" />
 /// <reference types="express" />
 import { ServerResponse } from "http";
+import { StatusCodes } from "src/Enums";
 import { ILanguage } from "src/Interfaces";
 declare class AxeResponse {
     private response;
     private responseStatus;
     private language;
     constructor(response: ServerResponse, language: ILanguage);
+    /**
+     * Get the original `ServerResponse` value
+     *
+     * @readonly
+     * @memberof AxeResponse
+     */
     get original(): ServerResponse<import("http").IncomingMessage>;
-    status(statusCode: number): this;
+    /**
+     * Set the HTTP Response Status Code
+     *
+     * @param statusCode
+     * @returns
+     */
+    status(statusCode: StatusCodes): this;
+    /**
+     * Set the HTTP Response Data as JSON
+     *
+     * @param data
+     */
     json(data: object): void;
+    /**
+     * Set the HTTP Response Data as string
+     *
+     * @param data
+     */
     send(content: string): void;
+    /**
+     * Set the no-content to the HTTP Response with 204 status code.
+     */
     noContent(): void;
     isResponded(): boolean;
     statusCode(): number;
+    header(key: string, value: string): void;
 }
 export default AxeResponse;

package/build/src/Services/AxeResponse.js

@@ -7,13 +7,30 @@ class AxeResponse {
         this.response.statusCode = 200;
         this.language = language;
     }
+    /**
+     * Get the original `ServerResponse` value
+     *
+     * @readonly
+     * @memberof AxeResponse
+     */
     get original() {
         return this.response;
     }
+    /**
+     * Set the HTTP Response Status Code
+     *
+     * @param statusCode
+     * @returns
+     */
     status(statusCode) {
         this.response.statusCode = statusCode;
         return this;
     }
+    /**
+     * Set the HTTP Response Data as JSON
+     *
+     * @param data
+     */
     json(data) {
         this.response.setHeader("Content-Type", "application/json");
         this.response.setHeader("Content-Language", this.language.language);
@@ -21,11 +38,19 @@ class AxeResponse {
         this.response.end();
         this.responseStatus = true;
     }
+    /**
+     * Set the HTTP Response Data as string
+     *
+     * @param data
+     */
     send(content) {
         this.response.write(content);
         this.response.end();
         this.responseStatus = true;
     }
+    /**
+     * Set the no-content to the HTTP Response with 204 status code.
+     */
     noContent() {
         this.response.statusCode = 204;
         this.response.end();
@@ -37,5 +62,8 @@ class AxeResponse {
     statusCode() {
         return this.response.statusCode;
     }
+    header(key, value) {
+        this.original.setHeader(key, value);
+    }
 }
 exports.default = AxeResponse;

package/build/src/Services/ConverterService.d.ts

@@ -1,9 +1,11 @@
+/// <reference types="node" />
+/// <reference types="express" />
 import { IncomingMessage, ServerResponse } from "http";
 import { AxeRequestResponsePair, MiddlewareResolution } from "../Interfaces";
-import { DynamicFunctionType, PhaseFunction, StepTypes } from "src/Types";
+import { GeneralFunction, PhaseFunction, AxeFunction } from "src/Types";
 export declare const toAxeRequestResponsePair: (request: IncomingMessage, response: ServerResponse) => AxeRequestResponsePair;
-export declare const resolveMiddlewares: (args: DynamicFunctionType) => MiddlewareResolution;
+export declare const resolveMiddlewares: (args: GeneralFunction[]) => MiddlewareResolution;
 export declare const isMiddlewareFunction: (callback: any) => boolean;
 export declare const isHandlerFunction: (callback: any) => boolean;
 export declare const isPhaseFunction: (callback: any) => boolean;
-export declare const toPhaseFunction: (callback: StepTypes) => PhaseFunction;
+export declare const toPhaseFunction: (callback: AxeFunction) => PhaseFunction;

package/build/src/Services/DocumentationService.d.ts

@@ -1,11 +1,14 @@
-import { IModelService, IRouteDocumentation, IVersion } from "../Interfaces";
+import { ICustomRouteDocumentation, IModelService, IRouteDocumentation, IVersion } from "../Interfaces";
 import { HandlerTypes, HttpMethods } from "../Enums";
 declare class DocumentationService {
     private static instance;
     private routes;
+    private customRoutes;
     constructor();
     static getInstance(): DocumentationService;
-    push(version: IVersion, handler: HandlerTypes, method: HttpMethods, url: string, model: IModelService): void;
+    push(version: IVersion, handler: HandlerTypes, method: HttpMethods, url: string, model: IModelService, parentModel: IModelService | null): void;
+    pushCustom(method: HttpMethods, url: string): void;
     get(): IRouteDocumentation[];
+    getCustoms(): ICustomRouteDocumentation[];
 }
 export default DocumentationService;

package/build/src/Services/DocumentationService.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 class DocumentationService {
     constructor() {
         this.routes = [];
+        this.customRoutes = [];
     }
     static getInstance() {
         if (!DocumentationService.instance) {
@@ -10,11 +11,13 @@ class DocumentationService {
         }
         return DocumentationService.instance;
     }
-    push(version, handler, method, url, model) {
+    push(version, handler, method, url, model, parentModel) {
         var _a, _b, _c;
         this.routes.push({
             version: version.name,
             handler,
+            modelService: model,
+            parentModel,
             model: model.name,
             table: model.instance.table,
             columns: model.columns,
@@ -28,8 +31,17 @@ class DocumentationService {
             queryDefaults: (_c = (_b = (_a = version.config) === null || _a === void 0 ? void 0 : _a.query) === null || _b === void 0 ? void 0 : _b.defaults) !== null && _c !== void 0 ? _c : {},
         });
     }
+    pushCustom(method, url) {
+        this.customRoutes.push({
+            method,
+            url,
+        });
+    }
     get() {
         return this.routes;
     }
+    getCustoms() {
+        return this.customRoutes;
+    }
 }
 exports.default = DocumentationService;

package/build/src/Services/ElasticService.d.ts

@@ -0,0 +1,14 @@
+import { ClientOptions } from "@elastic/elasticsearch";
+import { ISearchConfigutation } from "src/Interfaces";
+declare class ElasticService {
+    private config;
+    private client;
+    constructor(config: ISearchConfigutation, options: ClientOptions);
+    createIndex(modelName: string): Promise<void>;
+    insert(modelName: string, id: string, body: any): Promise<import("@elastic/elasticsearch/lib/api/types").WriteResponseBase>;
+    update(modelName: string, id: string, doc: any): Promise<import("@elastic/elasticsearch/lib/api/types").UpdateResponse<unknown>>;
+    delete(modelName: string, id: string): Promise<import("@elastic/elasticsearch/lib/api/types").WriteResponseBase>;
+    search(modelName: string, page: number, size: number, body: any): Promise<import("@elastic/elasticsearch/lib/api/types").SearchResponse<unknown, Record<string, import("@elastic/elasticsearch/lib/api/types").AggregationsAggregate>>>;
+    private toIndex;
+}
+export default ElasticService;