axe-api 1.0.0-rc2 → 1.0.0-rc20

package/build/index.d.ts

@@ -3,6 +3,8 @@ import Model from "./src/Model";
 import ApiError from "./src/Exceptions/ApiError";
 import { DEFAULT_HANDLERS, DEFAULT_VERSION_CONFIG } from "./src/constants";
 import { IoCService, allow, deny, App, AxeRequest, AxeResponse } from "./src/Services";
+import { rateLimit } from "./src/Middlewares/RateLimit";
 export * from "./src/Enums";
 export * from "./src/Interfaces";
-export { App, AxeRequest, AxeResponse, Server, Model, ApiError, DEFAULT_HANDLERS, DEFAULT_VERSION_CONFIG, IoCService, allow, deny, };
+export * from "./src/Types";
+export { App, AxeRequest, AxeResponse, Server, Model, ApiError, DEFAULT_HANDLERS, DEFAULT_VERSION_CONFIG, IoCService, allow, deny, rateLimit, };

package/build/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deny = exports.allow = exports.IoCService = exports.DEFAULT_VERSION_CONFIG = exports.DEFAULT_HANDLERS = exports.ApiError = exports.Model = exports.Server = exports.AxeResponse = exports.AxeRequest = exports.App = void 0;
+exports.rateLimit = exports.deny = exports.allow = exports.IoCService = exports.DEFAULT_VERSION_CONFIG = exports.DEFAULT_HANDLERS = exports.ApiError = exports.Model = exports.Server = exports.AxeResponse = exports.AxeRequest = exports.App = void 0;
 const Server_1 = __importDefault(require("./src/Server"));
 exports.Server = Server_1.default;
 const Model_1 = __importDefault(require("./src/Model"));
@@ -34,5 +34,8 @@ Object.defineProperty(exports, "deny", { enumerable: true, get: function () { re
 Object.defineProperty(exports, "App", { enumerable: true, get: function () { return Services_1.App; } });
 Object.defineProperty(exports, "AxeRequest", { enumerable: true, get: function () { return Services_1.AxeRequest; } });
 Object.defineProperty(exports, "AxeResponse", { enumerable: true, get: function () { return Services_1.AxeResponse; } });
+const RateLimit_1 = require("./src/Middlewares/RateLimit");
+Object.defineProperty(exports, "rateLimit", { enumerable: true, get: function () { return RateLimit_1.rateLimit; } });
 __exportStar(require("./src/Enums"), exports);
 __exportStar(require("./src/Interfaces"), exports);
+__exportStar(require("./src/Types"), exports);

package/build/src/Builders/ModelTreeBuilder.js

@@ -17,12 +17,11 @@ class ModelTreeBuilder {
     }
     build() {
         return __awaiter(this, void 0, void 0, function* () {
-            const logger = Services_1.LogService.getInstance();
             const tree = this.getRootLevelOfTree();
             this.createRecursiveTree(tree);
             this.addNestedRoutes(tree);
             this.version.modelTree = tree;
-            logger.info(`[${this.version.name}] Model tree has been created.`);
+            Services_1.LogService.debug(`[${this.version.name}] Model tree has been created.`);
         });
     }
     getRootLevelOfTree() {

package/build/src/Builders/RouterBuilder.d.ts

@@ -7,7 +7,7 @@ declare class RouterBuilder {
     private createRouteByModel;
     private createNestedRoutes;
     private createChildRoutes;
-    private addExpressRoute;
+    private addRoute;
     private getResourcePath;
     private getRootPrefix;
 }

package/build/src/Builders/RouterBuilder.js

@@ -36,14 +36,13 @@ class RouterBuilder {
     }
     build() {
         return __awaiter(this, void 0, void 0, function* () {
-            const app = yield Services_1.IoCService.useByType("App");
-            const logger = Services_1.LogService.getInstance();
+            const app = yield Services_1.IoCService.use("App");
             const generalHooks = yield new Resolvers_1.GeneralHookResolver(this.version).resolve();
             if (generalHooks.onBeforeInit) {
                 generalHooks.onBeforeInit(app);
             }
             yield this.createRoutesByModelTree();
-            logger.info(`[${this.version.name}] Express routes have been created.`);
+            Services_1.LogService.debug(`[${this.version.name}] All endpoints have been created.`);
             if (generalHooks.onAfterInit) {
                 generalHooks.onAfterInit(app);
             }
@@ -76,8 +75,8 @@ class RouterBuilder {
                 const middlewares = [
                     ...model.instance.getMiddlewares(handlerType),
                 ];
-                // Adding the route to the express
-                yield this.addExpressRoute(handlerType, url, middlewares, model, parentModel, relation);
+                // Adding the endpoint
+                yield this.addRoute(handlerType, url, middlewares, model, parentModel, relation);
             }
             yield this.createChildRoutes(model, resource, urlPrefix);
             yield this.createNestedRoutes(model, allowRecursive, urlPrefix, resource);
@@ -92,7 +91,8 @@ class RouterBuilder {
             const relation = model.relations.find((relation) => relation.model === model.name &&
                 relation.type === Enums_1.Relationships.HAS_MANY);
             if (relation) {
-                yield this.createRouteByModel(model, `${urlPrefix}${resource}/:${(0, change_case_1.camelCase)(relation.foreignKey)}/`, model, relation, false);
+                const paramName = (0, change_case_1.camelCase)(`${model.name}-${relation.primaryKey}`);
+                yield this.createRouteByModel(model, `${urlPrefix}${resource}/:${paramName}/`, model, relation, false);
             }
         });
     }
@@ -107,12 +107,13 @@ class RouterBuilder {
                 const child = model.children.find((item) => item.name === relation.model);
                 // It should be recursive
                 if (child) {
-                    yield this.createRouteByModel(child, `${urlPrefix}${resource}/:${(0, change_case_1.camelCase)(relation.foreignKey)}/`, model, relation);
+                    const paramName = (0, change_case_1.camelCase)(`${model.name}-${relation.primaryKey}`);
+                    yield this.createRouteByModel(child, `${urlPrefix}${resource}/:${paramName}/`, model, relation);
                 }
             }
         });
     }
-    addExpressRoute(handlerType, url, middlewares, model, parentModel, relation) {
+    addRoute(handlerType, url, middlewares, model, parentModel, relation) {
         return __awaiter(this, void 0, void 0, function* () {
             const docs = Services_1.DocumentationService.getInstance();
             const data = {
@@ -125,7 +126,7 @@ class RouterBuilder {
             // Adding the route
             yield URLService_1.default.add(constants_1.HANDLER_METHOD_MAP[handlerType], url, data, middlewares);
             // Documentation
-            docs.push(this.version, handlerType, constants_1.HANDLER_METHOD_MAP[handlerType], url, model);
+            docs.push(this.version, handlerType, constants_1.HANDLER_METHOD_MAP[handlerType], url, model, parentModel);
         });
     }
     getResourcePath(model, relation) {

package/build/src/Builders/SwaggerBuilder.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<any>;
+export default _default;

package/build/src/Builders/SwaggerBuilder.js

@@ -0,0 +1,558 @@
+"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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-prototype-builtins */
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const change_case_1 = require("change-case");
+const Enums_1 = require("../Enums");
+const node_cache_1 = __importDefault(require("node-cache"));
+const Services_1 = require("../Services");
+const cache = new node_cache_1.default();
+const DATA_TYPE_MAP = [
+    {
+        type: "string",
+        values: [
+            "char",
+            "varchar",
+            "text",
+            "tinytext",
+            "mediumtext",
+            "longtext",
+            "enum",
+            "set",
+            "varbinary",
+            "blob",
+            "tinyblob",
+            "mediumblob",
+            "longblob",
+            "date",
+            "datetime",
+            "timestamp",
+            "time",
+            "year",
+        ],
+    },
+    {
+        type: "number",
+        values: [
+            "tinyint",
+            "smallint",
+            "mediumint",
+            "int",
+            "integer",
+            "bigint",
+            "float",
+            "double",
+            "decimal",
+            "numeric",
+        ],
+    },
+    {
+        type: "boolean",
+        values: ["boolean", "binary"],
+    },
+];
+const SUMMARY_TEXTS = {
+    [Enums_1.HandlerTypes.INSERT]: "Add a new {model}",
+    [Enums_1.HandlerTypes.PAGINATE]: "Retrieve a paginated list of {model}s",
+    [Enums_1.HandlerTypes.SHOW]: "Retrieve details of a {model}",
+    [Enums_1.HandlerTypes.UPDATE]: "Update an existing {model}",
+    [Enums_1.HandlerTypes.DELETE]: "Delete a {model}",
+    [Enums_1.HandlerTypes.FORCE_DELETE]: "Force delete a {model}",
+    [Enums_1.HandlerTypes.PATCH]: "Apply partial updates to a {model}",
+    [Enums_1.HandlerTypes.ALL]: "Get all items on {model}",
+};
+const DESCRIPTION_TEXTS = {
+    [Enums_1.HandlerTypes.INSERT]: "Add a new {model}",
+    [Enums_1.HandlerTypes.PAGINATE]: "Retrieve a paginated list of {model}s",
+    [Enums_1.HandlerTypes.SHOW]: "Retrieve details of a {model} by primary key",
+    [Enums_1.HandlerTypes.UPDATE]: "Update an existing {model} by primary key",
+    [Enums_1.HandlerTypes.DELETE]: "Delete a {model} by primary key",
+    [Enums_1.HandlerTypes.FORCE_DELETE]: "Force delete a {model} by primary key",
+    [Enums_1.HandlerTypes.PATCH]: "Apply partial updates to a {model} by primary key",
+    [Enums_1.HandlerTypes.ALL]: "Get all items on {model}",
+};
+const SINGLE_RETURN_ENDPOINTS = [
+    Enums_1.HandlerTypes.INSERT,
+    Enums_1.HandlerTypes.PATCH,
+    Enums_1.HandlerTypes.SHOW,
+    Enums_1.HandlerTypes.UPDATE,
+];
+const ALLOWED_2XX_HANDLERS = [
+    Enums_1.HandlerTypes.ALL,
+    Enums_1.HandlerTypes.PAGINATE,
+    Enums_1.HandlerTypes.PATCH,
+    Enums_1.HandlerTypes.SHOW,
+    Enums_1.HandlerTypes.UPDATE,
+];
+const POSSIBLE_404_HANDLERS = [
+    Enums_1.HandlerTypes.DELETE,
+    Enums_1.HandlerTypes.FORCE_DELETE,
+    Enums_1.HandlerTypes.PATCH,
+    Enums_1.HandlerTypes.SHOW,
+    Enums_1.HandlerTypes.UPDATE,
+];
+const NO_CONTENT_HANDLERS = [
+    Enums_1.HandlerTypes.DELETE,
+    Enums_1.HandlerTypes.FORCE_DELETE,
+];
+const ALLOWED_REQUEST_BODY_HANDLERS = [
+    Enums_1.HandlerTypes.INSERT,
+    Enums_1.HandlerTypes.UPDATE,
+    Enums_1.HandlerTypes.PATCH,
+];
+const ALLOWED_QUERY_HANDLERS = [
+    Enums_1.HandlerTypes.ALL,
+    Enums_1.HandlerTypes.SHOW,
+    Enums_1.HandlerTypes.PAGINATE,
+];
+const PAGINATION_SCHEMA = {
+    type: "object",
+    properties: {
+        total: {
+            type: "integer",
+            default: 1,
+        },
+        lastPage: {
+            type: "integer",
+            default: 1,
+        },
+        perPage: {
+            type: "integer",
+            default: 10,
+        },
+        currentPage: {
+            type: "integer",
+            default: 1,
+        },
+        from: {
+            type: "integer",
+            default: 0,
+        },
+        to: {
+            type: "integer",
+            default: 10,
+        },
+    },
+};
+const ERROR_SCHEMA = {
+    type: "object",
+    properties: {
+        error: {
+            type: "string",
+            default: "An error occorred",
+        },
+    },
+};
+const VALIDATION_ERROR_SCHEMA = {
+    type: "object",
+    properties: {
+        errors: {
+            type: "object",
+        },
+    },
+};
+const toPropertyType = (datatype) => {
+    for (const item of DATA_TYPE_MAP) {
+        if (item.values.includes(datatype)) {
+            return item.type;
+        }
+    }
+    return datatype;
+};
+const toEndpointSummary = (endpoint) => {
+    const value = SUMMARY_TEXTS[endpoint.handler] || "";
+    return value.replace("{model}", endpoint.model.toLowerCase());
+};
+const toEndpointDescription = (endpoint) => {
+    const value = DESCRIPTION_TEXTS[endpoint.handler] || "";
+    return value.replace("{model}", endpoint.model.toLowerCase());
+};
+const to2XXResponse = (endpoint) => {
+    // Single item response
+    if (SINGLE_RETURN_ENDPOINTS.includes(endpoint.handler)) {
+        return {
+            content: {
+                "application/json": {
+                    schema: {
+                        $ref: `#/components/schemas/${endpoint.model}`,
+                    },
+                },
+            },
+        };
+    }
+    // All response
+    if (endpoint.handler === Enums_1.HandlerTypes.ALL) {
+        return {
+            content: {
+                "application/json": {
+                    schema: {
+                        type: "array",
+                        items: {
+                            $ref: `#/components/schemas/${endpoint.model}`,
+                        },
+                    },
+                },
+            },
+        };
+    }
+    return {
+        content: {
+            "application/json": {
+                schema: {
+                    type: "object",
+                    properties: {
+                        data: {
+                            type: "array",
+                            items: {
+                                $ref: `#/components/schemas/${endpoint.model}`,
+                            },
+                        },
+                        pagination: {
+                            $ref: `#/components/schemas/Pagination`,
+                        },
+                    },
+                },
+            },
+        },
+    };
+};
+const toEndpointResponse = (endpoint) => {
+    const response = {};
+    if (ALLOWED_2XX_HANDLERS.includes(endpoint.handler)) {
+        response["200"] = Object.assign(Object.assign({}, to2XXResponse(endpoint)), { description: "OK" });
+    }
+    if (endpoint.handler === Enums_1.HandlerTypes.INSERT) {
+        response["201"] = Object.assign(Object.assign({}, to2XXResponse(endpoint)), { description: "Created" });
+        response["400"] = {
+            description: "Bad request",
+            content: {
+                "application/json": {
+                    schema: {
+                        $ref: `#/components/schemas/ValidationError`,
+                    },
+                },
+            },
+        };
+    }
+    if (NO_CONTENT_HANDLERS.includes(endpoint.handler)) {
+        response["204"] = {
+            description: "No Content",
+        };
+    }
+    if (POSSIBLE_404_HANDLERS.includes(endpoint.handler) ||
+        endpoint.parentModel) {
+        response["404"] = {
+            description: "Not Found",
+            content: {
+                "application/json": {
+                    schema: {
+                        $ref: `#/components/schemas/Error`,
+                    },
+                },
+            },
+        };
+    }
+    return response;
+};
+const toFillableFieldProperties = (model) => {
+    const fields = model.instance.getFillableFields(Enums_1.HttpMethods.POST);
+    const properties = {};
+    for (const field of fields) {
+        const column = model.columns.find((item) => item.name === field);
+        if (column) {
+            properties[column.name] = {
+                type: toPropertyType(column.data_type),
+                format: column.data_type,
+            };
+        }
+    }
+    return properties;
+};
+const toRequestBody = (endpoint) => {
+    if (ALLOWED_REQUEST_BODY_HANDLERS.includes(endpoint.handler) === false) {
+        return undefined;
+    }
+    const bodySchema = `${endpoint.model}${(0, change_case_1.pascalCase)(endpoint.method)}Body`;
+    return {
+        description: "Update an existent pet in the store",
+        content: {
+            "application/json": {
+                schema: {
+                    $ref: `#/components/requestBodies/${bodySchema}`,
+                },
+            },
+        },
+        required: true,
+    };
+};
+const toRequestParameters = (endpoint) => {
+    const parameters = [
+        {
+            in: "header",
+            name: "Accept-Language",
+            schema: {
+                type: "string",
+                example: "en;q=0.8, de;q=0.7, *;q=0.5",
+            },
+            required: false,
+        },
+    ];
+    if (endpoint.url.includes(":")) {
+        const sections = endpoint.url
+            .split("/")
+            .filter((item) => item.includes(":"))
+            .map((item) => item.replace(":", ""));
+        for (const section of sections) {
+            parameters.push({
+                in: "path",
+                name: section,
+                required: true,
+            });
+        }
+    }
+    if (endpoint.handler === Enums_1.HandlerTypes.PAGINATE) {
+        parameters.push(...[
+            {
+                name: "page",
+                in: "query",
+                description: "The page number to list",
+                required: false,
+                schema: {
+                    type: "integer",
+                    default: 1,
+                },
+            },
+            {
+                name: "per_page",
+                in: "query",
+                description: "Number of records to list on a page",
+                required: false,
+                schema: {
+                    type: "integer",
+                    default: 10,
+                },
+            },
+            {
+                name: "sort",
+                in: "query",
+                description: "The field to sort the data (ASC: id, DESC: -id)",
+                required: false,
+                schema: {
+                    type: "string",
+                },
+            },
+        ]);
+    }
+    if (ALLOWED_QUERY_HANDLERS.includes(endpoint.handler)) {
+        parameters.push(...[
+            {
+                name: "fields",
+                in: "query",
+                description: "The model fields that can be fetched",
+                required: false,
+                schema: {
+                    type: "string",
+                },
+            },
+            {
+                name: "with",
+                in: "query",
+                description: "Listable related models",
+                required: false,
+                schema: {
+                    type: "string",
+                },
+            },
+            {
+                name: "trashed",
+                in: "query",
+                description: "List of deleted data with soft-delete",
+                required: false,
+                schema: {
+                    type: "integer",
+                    default: 0,
+                },
+            },
+            {
+                name: "q",
+                in: "query",
+                description: "JSON query to filter data",
+                required: false,
+                schema: {
+                    type: "string",
+                },
+            },
+        ]);
+    }
+    return parameters;
+};
+const deepMerge = (base, source) => {
+    // Check if either base or source is not an object, or if source is null
+    if (typeof base !== "object" ||
+        typeof source !== "object" ||
+        source === null) {
+        return source;
+    }
+    // Create a copy of the base object to avoid modifying it directly
+    const merged = Object.assign({}, base);
+    // Loop through all properties in the source object
+    for (const key in source) {
+        if (source.hasOwnProperty(key)) {
+            // If the key exists in the base object and both values are objects, merge recursively
+            if (base.hasOwnProperty(key) &&
+                typeof base[key] === "object" &&
+                typeof source[key] === "object") {
+                merged[key] = deepMerge(base[key], source[key]);
+            }
+            else {
+                // If the key does not exist in the base object or one of the values is not an object, assign the source value to the merged object
+                merged[key] = source[key];
+            }
+        }
+    }
+    return merged;
+};
+const generateDocumentation = () => __awaiter(void 0, void 0, void 0, function* () {
+    const docs = Services_1.DocumentationService.getInstance();
+    const api = Services_1.APIService.getInstance();
+    let baseSchema = {
+        info: {
+            title: "Axe API",
+            description: "Edit your swagger/index.ts file",
+        },
+        servers: [
+            {
+                url: "http://localhost:3000",
+            },
+        ],
+    };
+    const swaggerBasePath = path_1.default.join(api.appFolder, "swagger");
+    if (fs_1.default.existsSync(`${swaggerBasePath}.ts`) ||
+        fs_1.default.existsSync(`${swaggerBasePath}.js`)) {
+        const { default: userDefinedSchema, DOCUMENTATION_SERVER } = yield Promise.resolve(`${swaggerBasePath}`).then(s => __importStar(require(s)));
+        baseSchema = userDefinedSchema;
+        if (!DOCUMENTATION_SERVER) {
+            throw new Error("`DOCUMENTATION_SERVER` URL should be exported");
+        }
+        api.setDocumentationServer(DOCUMENTATION_SERVER);
+    }
+    const schemas = {};
+    const requestBodies = {};
+    const firstVersion = api.versions.at(0);
+    if (!firstVersion) {
+        throw new Error("The version is not found!");
+    }
+    for (const model of firstVersion.modelList.get()) {
+        const properties = {};
+        for (const column of model.columns) {
+            properties[column.name] = {
+                type: toPropertyType(column.data_type),
+                format: column.data_type,
+            };
+        }
+        schemas[model.name] = {
+            type: "object",
+            properties,
+        };
+        if (model.instance.handlers.includes(Enums_1.HandlerTypes.INSERT)) {
+            requestBodies[`${model.name}${(0, change_case_1.pascalCase)(Enums_1.HttpMethods.POST)}Body`] = {
+                type: "object",
+                properties: toFillableFieldProperties(model),
+            };
+        }
+        if (model.instance.handlers.includes(Enums_1.HandlerTypes.UPDATE)) {
+            requestBodies[`${model.name}${(0, change_case_1.pascalCase)(Enums_1.HttpMethods.PUT)}Body`] = {
+                type: "object",
+                properties: toFillableFieldProperties(model),
+            };
+        }
+        if (model.instance.handlers.includes(Enums_1.HandlerTypes.PATCH)) {
+            requestBodies[`${model.name}${(0, change_case_1.pascalCase)(Enums_1.HttpMethods.PATCH)}Body`] = {
+                type: "object",
+                properties: toFillableFieldProperties(model),
+            };
+        }
+    }
+    const paths = {};
+    for (const endpoint of docs.get()) {
+        if (paths[endpoint.url] === undefined) {
+            paths[endpoint.url] = {};
+        }
+        const path = {
+            tags: [endpoint.model],
+            summary: toEndpointSummary(endpoint),
+            description: toEndpointDescription(endpoint),
+            operationId: `${endpoint.handler}${endpoint.model}`,
+            responses: toEndpointResponse(endpoint),
+            parameters: toRequestParameters(endpoint),
+        };
+        const requestBody = toRequestBody(endpoint);
+        if (requestBody) {
+            path.requestBody = requestBody;
+        }
+        paths[endpoint.url][endpoint.method.toLowerCase()] = path;
+    }
+    // Added custom endpoint
+    for (const custom of docs.getCustoms()) {
+        if (paths[custom.url] === undefined) {
+            paths[custom.url] = {};
+        }
+        paths[custom.url][custom.method.toLowerCase()] = {
+            description: "Custom endpoint",
+        };
+    }
+    const builded = {
+        openapi: "3.0.0",
+        paths,
+        components: {
+            schemas: Object.assign(Object.assign({}, schemas), { Pagination: PAGINATION_SCHEMA, Error: ERROR_SCHEMA, ValidationError: VALIDATION_ERROR_SCHEMA }),
+            requestBodies,
+        },
+    };
+    return deepMerge(baseSchema, builded);
+});
+exports.default = () => __awaiter(void 0, void 0, void 0, function* () {
+    const cached = cache.get("axe-api-documentation");
+    if (cached) {
+        return JSON.parse(cached);
+    }
+    const documentation = yield generateDocumentation();
+    cache.set("axe-api-documentation", JSON.stringify(documentation));
+    return documentation;
+});

package/build/src/Enums.d.ts

@@ -61,13 +61,6 @@ export declare enum HttpMethods {
     GET = "GET",
     DELETE = "DELETE"
 }
-export declare enum LogLevels {
-    NONE = 0,
-    ERROR = 1,
-    WARNING = 2,
-    INFO = 3,
-    ALL = 4
-}
 export declare enum Relationships {
     HAS_ONE = "HAS_ONE",
     HAS_MANY = "HAS_MANY"