axe-api 1.0.0-rc12 → 1.0.0-rc15

package/build/index.d.ts

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

package/build/index.js

@@ -38,3 +38,4 @@ 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/RouterBuilder.js

@@ -91,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);
             }
         });
     }
@@ -106,7 +107,8 @@ 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);
                 }
             }
         });
@@ -124,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,553 @@
+"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();
+    const swaggerBasePath = path_1.default.join(api.rootFolder, "swagger", "index.ts");
+    let baseSchema = {
+        info: {
+            title: "Axe API",
+            description: "Edit your swagger/index.ts file",
+        },
+        servers: [
+            {
+                url: "http://localhost:3000",
+            },
+        ],
+    };
+    if (fs_1.default.existsSync(swaggerBasePath)) {
+        const { default: userDefinedSchema } = yield Promise.resolve(`${swaggerBasePath}`).then(s => __importStar(require(s)));
+        baseSchema = userDefinedSchema;
+    }
+    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.1.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/Handlers/Helpers.d.ts

@@ -7,7 +7,7 @@ import AxeRequest from "src/Services/AxeRequest";
 export declare const bindTimestampValues: (formData: Record<string, any>, model: IModelService, columnTypes?: TimestampColumns[]) => void;
 export declare const getMergedFormData: (req: AxeRequest, fillables: string[]) => Record<string, any>;
 export declare const callHooks: (model: IModelService, type: HookFunctionTypes, params: IContext) => Promise<void>;
-export declare const getParentColumn: (relation: IRelation | null) => string | null;
+export declare const getParentColumn: (model: IModelService, relation: IRelation | null) => string | null;
 export declare const checkPrimaryKeyValueType: (model: IModelService, value: any) => void;
 export declare const addForeignKeyQuery: (request: AxeRequest, query: Knex.QueryBuilder, relation: IRelation | null, parentModel: IModelService | null) => void;
 export declare const serializeData: (version: IVersion, itemArray: any, modelSerializer: SerializationFunction | null, handler: HandlerTypes, request: AxeRequest) => Promise<any[]>;

package/build/src/Handlers/Helpers.js

@@ -57,11 +57,11 @@ const callHooks = (model, type, params) => __awaiter(void 0, void 0, void 0, fun
     }
 });
 exports.callHooks = callHooks;
-const getParentColumn = (relation) => {
+const getParentColumn = (model, relation) => {
     if (!relation) {
         return null;
     }
-    return (0, change_case_1.camelCase)(relation.foreignKey);
+    return (0, change_case_1.camelCase)(`${model.name}-${relation.primaryKey}`);
 };
 exports.getParentColumn = getParentColumn;
 const checkPrimaryKeyValueType = (model, value) => {
@@ -75,7 +75,7 @@ const checkPrimaryKeyValueType = (model, value) => {
 exports.checkPrimaryKeyValueType = checkPrimaryKeyValueType;
 const addForeignKeyQuery = (request, query, relation, parentModel) => {
     if (relation && parentModel) {
-        const parentColumn = (0, exports.getParentColumn)(relation);
+        const parentColumn = (0, exports.getParentColumn)(parentModel, relation);
         if (parentColumn) {
             query.where(relation.foreignKey, request.params[parentColumn]);
         }

package/build/src/Handlers/RequestHandler.js

@@ -22,7 +22,7 @@ const return404 = (response) => {
     response.end();
 };
 exports.default = (request, response, next) => __awaiter(void 0, void 0, void 0, function* () {
-    Services_1.LogService.debug(`${request.method} ${request.url}`);
+    Services_1.LogService.debug(`📥 ${request.method} ${request.url}`);
     const { axeRequest, axeResponse } = (0, ConverterService_1.toAxeRequestResponsePair)(request, response);
     const match = URLService_1.default.match(axeRequest);
     if (!match) {
@@ -83,7 +83,7 @@ exports.default = (request, response, next) => __awaiter(void 0, void 0, void 0,
             Services_1.LogService.debug(`\tResponse ${context.res.statusCode()}`);
             break;
         }
-        Services_1.LogService.debug(`\tResponse ${context.res.statusCode()}`);
+        Services_1.LogService.debug(`\t🟢 Response ${context.res.statusCode()}`);
         // We should brake the for-loop
         break;
     }

package/build/src/Handlers/{DocsHTMLHandler.js → SwaggerHandler.js}

@@ -8,17 +8,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 });
-const CLOUD_FRONT_DOMAIN = "https://dw7lgbuj348m4.cloudfront.net/v1";
+const SwaggerBuilder_1 = __importDefault(require("../Builders/SwaggerBuilder"));
 exports.default = (req, res) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const result = yield fetch(`${CLOUD_FRONT_DOMAIN}/index.html`);
-        const content = (yield result.text())
-            .replaceAll(`src="`, `src="${CLOUD_FRONT_DOMAIN}`)
-            .replaceAll(`href="`, `href="${CLOUD_FRONT_DOMAIN}`);
-        res.send(content);
+        res.json(yield (0, SwaggerBuilder_1.default)());
     }
     catch (error) {
-        res.send("404");
+        res.status(500).json({ error: "An error occurred!" });
     }
 });

package/build/src/Interfaces.d.ts

@@ -77,6 +77,7 @@ export interface AxeConfig extends IConfig {
     pino: LoggerOptions;
     rateLimit: IRateLimitConfig;
     errorHandler: ErrorHandleFunction;
+    docs: boolean;
 }
 export type IApplicationConfig = Partial<AxeConfig>;
 export interface ILanguage {
@@ -171,6 +172,8 @@ export interface IContext extends IRouteData {
 export interface IRouteDocumentation {
     version: string;
     handler: string;
+    modelService: IModelService;
+    parentModel: IModelService | null;
     model: string;
     table: string;
     columns: IColumn[];
@@ -183,6 +186,10 @@ export interface IRouteDocumentation {
     queryLimits: IQueryLimitConfig[];
     queryDefaults: IQueryDefaultConfig;
 }
+export interface ICustomRouteDocumentation {
+    method: HttpMethods;
+    url: string;
+}
 export interface IRawQuery {
     q: string | null;
     page: string | null;

package/build/src/Phases/Store/PreparePhase.js

@@ -32,7 +32,7 @@ exports.default = (context) => __awaiter(void 0, void 0, void 0, function* () {
         }
     }
     if (context.relation && context.parentModel) {
-        const parentColumn = (0, Helpers_1.getParentColumn)(context.relation);
+        const parentColumn = (0, Helpers_1.getParentColumn)(context.parentModel, context.relation);
         if (parentColumn) {
             context.formData[context.relation.foreignKey] =
                 context.params[parentColumn];

package/build/src/Resolvers/VersionResolver.js

@@ -23,6 +23,7 @@ const RESERVED_VERSION_FOLDERS = [
     "Hooks",
     "Models",
     "Serialization",
+    "Swagger",
 ];
 class VersionResolver {
     resolve() {

package/build/src/Server.js

@@ -43,8 +43,7 @@ const knex_schema_inspector_1 = __importDefault(require("knex-schema-inspector")
 const knex_paginate_1 = require("knex-paginate");
 const Builders_1 = require("./Builders");
 const Services_1 = require("./Services");
-const MetadataHandler_1 = __importDefault(require("./Handlers/MetadataHandler"));
-const DocsHTMLHandler_1 = __importDefault(require("./Handlers/DocsHTMLHandler"));
+const SwaggerHandler_1 = __importDefault(require("./Handlers/SwaggerHandler"));
 const RoutesHandler_1 = __importDefault(require("./Handlers/RoutesHandler"));
 const http_1 = __importDefault(require("http"));
 const RequestHandler_1 = __importDefault(require("./Handlers/RequestHandler"));
@@ -131,9 +130,8 @@ class Server {
             server.on("error", function (e) {
                 Services_1.LogService.error(e.message);
             });
-            if (api.config.env === "development") {
-                app.get("/metadata", MetadataHandler_1.default);
-                app.get("/docs", DocsHTMLHandler_1.default);
+            if (api.config.docs) {
+                app.get("/swagger", SwaggerHandler_1.default);
                 app.get("/routes", RoutesHandler_1.default);
             }
             server.listen(api.config.port);

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

@@ -2,6 +2,7 @@ import connect, { NextHandleFunction, ErrorHandleFunction } from "connect";
 import { GeneralFunction } from "../Types";
 declare class App {
     private connect;
+    private docs;
     constructor();
     /**
      * Get the `connect` instance

package/build/src/Services/App.js

@@ -33,9 +33,12 @@ const LogService_1 = __importDefault(require("./LogService"));
 const RateLimit_1 = __importStar(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 }));
@@ -88,6 +91,7 @@ class App {
     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
@@ -106,6 +110,7 @@ class App {
     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
@@ -124,6 +129,7 @@ class App {
     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
@@ -142,6 +148,7 @@ class App {
     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
@@ -160,6 +167,7 @@ class App {
     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

@@ -64,7 +64,7 @@ declare class AxeRequest {
      * @param options
      * @returns
      */
-    files(options?: FormOptions): Promise<[formidable.Fields, formidable.Files]>;
+    files(options?: FormOptions): Promise<[formidable.Fields<string>, formidable.Files<string>]>;
     /**
      * Get the original `IncomingMessage` request.
      *

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

@@ -40,5 +40,6 @@ declare class AxeResponse {
     noContent(): void;
     isResponded(): boolean;
     statusCode(): number;
+    header(key: string, value: string): void;
 }
 export default AxeResponse;

package/build/src/Services/AxeResponse.js

@@ -62,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/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/QueryService.js

@@ -331,6 +331,11 @@ class QueryService {
         }
         if (where.condition === Enums_1.ConditionTypes.LIKE ||
             where.condition === Enums_1.ConditionTypes["NOT LIKE"]) {
+            const queryColumn = where.model.columns.find((column) => column.name === where.field);
+            if (queryColumn &&
+                !constants_1.STRING_COLUMN_TYPES.includes(queryColumn.data_type.toLowerCase())) {
+                throw new ApiError_1.default(`Query field need to be string. Unacceptable query field: ${where.field}`);
+            }
             where.value = where.value.replace(/\*/g, "%");
         }
         // This means that the condition is related with another table

package/build/src/constants.d.ts

@@ -16,6 +16,7 @@ export declare const API_ROUTE_TEMPLATES: {
 export declare const ConditionQueryFeatureMap: Record<ConditionTypes, QueryFeature>;
 export declare const RelationQueryFeatureMap: Record<Relationships, QueryFeature>;
 export declare const NUMERIC_PRIMARY_KEY_TYPES: string[];
+export declare const STRING_COLUMN_TYPES: string[];
 export declare const HANDLER_METHOD_MAP: Record<HandlerTypes, HttpMethods>;
 export declare const HANDLER_CYLES: Record<HandlerTypes, IStepDefinition[]>;
 export declare const DEFAULT_APP_CONFIG: AxeConfig;

package/build/src/constants.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_VERSION_CONFIG = exports.DEFAULT_APP_CONFIG = exports.HANDLER_CYLES = exports.HANDLER_METHOD_MAP = exports.NUMERIC_PRIMARY_KEY_TYPES = exports.RelationQueryFeatureMap = exports.ConditionQueryFeatureMap = exports.API_ROUTE_TEMPLATES = exports.DEFAULT_METHODS_OF_MODELS = exports.DEFAULT_HANDLERS = exports.RESERVED_KEYWORDS = void 0;
+exports.DEFAULT_VERSION_CONFIG = exports.DEFAULT_APP_CONFIG = exports.HANDLER_CYLES = exports.HANDLER_METHOD_MAP = exports.STRING_COLUMN_TYPES = exports.NUMERIC_PRIMARY_KEY_TYPES = exports.RelationQueryFeatureMap = exports.ConditionQueryFeatureMap = exports.API_ROUTE_TEMPLATES = exports.DEFAULT_METHODS_OF_MODELS = exports.DEFAULT_HANDLERS = exports.RESERVED_KEYWORDS = void 0;
 const Enums_1 = require("./Enums");
 const LimitService_1 = require("./Services/LimitService");
 const Single_1 = __importDefault(require("./Phases/Single"));
@@ -31,6 +31,7 @@ exports.RESERVED_KEYWORDS = [
     "event",
     "events",
     "all",
+    "swagger",
 ];
 exports.DEFAULT_HANDLERS = [
     Enums_1.HandlerTypes.INSERT,
@@ -102,6 +103,16 @@ exports.RelationQueryFeatureMap = {
     [Enums_1.Relationships.HAS_MANY]: Enums_1.QueryFeature.WithHasMany,
 };
 exports.NUMERIC_PRIMARY_KEY_TYPES = ["integer", "bigint"];
+exports.STRING_COLUMN_TYPES = [
+    "CHAR",
+    "VARCHAR",
+    "BINARY",
+    "VARBINARY",
+    "BLOB",
+    "TEXT",
+    "ENUM",
+    "SET",
+].map((item) => item.toLowerCase());
 exports.HANDLER_METHOD_MAP = {
     [Enums_1.HandlerTypes.INSERT]: Enums_1.HttpMethods.POST,
     [Enums_1.HandlerTypes.PAGINATE]: Enums_1.HttpMethods.GET,
@@ -221,6 +232,7 @@ exports.DEFAULT_APP_CONFIG = {
     prefix: "api",
     env: "production",
     port: 3000,
+    docs: true,
     pino: {
         level: "error",
         transport: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "axe-api",
-  "version": "1.0.0-rc12",
+  "version": "1.0.0-rc15",
   "description": "AXE API is a simple tool to create Rest APIs quickly.",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -33,7 +33,9 @@
     "dev-kit": "ts-node-dev --respawn --clear dev-kit.ts",
     "dev-kit:install": "node ./scripts/dev-kit-install.js",
     "dev-kit:remove": "node ./scripts/dev-kit-remove.js",
+    "dev-kit:docs": "open-swagger-ui http://localhost:3000/swagger",
     "test": "jest --runInBand",
+    "test:all": "npm run lint && npm run prettier:check && npm run test && npm run test:sqlite",
     "test:dev": "jest --watch",
     "lint": "eslint --max-warnings=0 .",
     "lint:watch": "esw --watch --color",
@@ -49,6 +51,7 @@
     "test:mariadb": "sh ./scripts/test-mariadb.sh",
     "test:sqlite": "sh ./scripts/test-sqlite.sh",
     "prettier:check": "prettier --check .",
+    "prettier:write": "prettier --write .",
     "prepare": "husky install"
   },
   "dependencies": {
@@ -56,6 +59,7 @@
     "change-case": "^4.1.2",
     "connect": "^3.7.0",
     "dotenv": "^16.3.1",
+    "formidable": "^3.5.1",
     "knex": "^2.5.1",
     "knex-paginate": "^3.1.1",
     "knex-schema-inspector": "^3.0.1",
@@ -66,44 +70,44 @@
     "validatorjs": "^3.22.1"
   },
   "devDependencies": {
-    "@babel/core": "^7.22.10",
-    "@babel/preset-env": "^7.22.10",
-    "@babel/preset-typescript": "^7.22.5",
+    "@babel/core": "^7.22.11",
+    "@babel/preset-env": "^7.22.14",
+    "@babel/preset-typescript": "^7.22.11",
     "@types/accept-language-parser": "^1.5.3",
     "@types/aws-lambda": "^8.10.119",
     "@types/cors": "^2.8.13",
-    "@types/formidable": "^3.4.1",
+    "@types/formidable": "^3.4.2",
     "@types/multer": "^1.4.7",
     "@types/pluralize": "^0.0.30",
     "@types/validatorjs": "^3.15.0",
-    "@typescript-eslint/eslint-plugin": "^5.62.0",
-    "@typescript-eslint/parser": "^5.62.0",
-    "babel-jest": "^29.6.2",
+    "@typescript-eslint/eslint-plugin": "^6.5.0",
+    "@typescript-eslint/parser": "^6.5.0",
+    "babel-jest": "^29.6.4",
     "cors": "^2.8.5",
-    "eslint": "^7.32.0",
-    "eslint-config-standard": "^16.0.3",
+    "eslint": "^8.48.0",
+    "eslint-config-standard": "^17.1.0",
     "eslint-plugin-import": "^2.28.1",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^5.1.0",
-    "eslint-plugin-unicorn": "^33.0.1",
-    "eslint-watch": "^7.0.0",
-    "formidable": "^3.5.1",
-    "glob": "^9.3.5",
+    "eslint-plugin-promise": "^6.1.1",
+    "eslint-plugin-unicorn": "^48.0.1",
+    "eslint-watch": "^8.0.0",
+    "glob": "^10.3.4",
     "husky": "^8.0.3",
-    "jest": "^29.6.2",
-    "lint-staged": "^13.3.0",
+    "jest": "^29.6.4",
+    "lint-staged": "^14.0.1",
     "multer": "^1.4.5-lts.1",
     "mysql": "^2.18.1",
     "node-cache": "^5.1.2",
     "node-color-log": "^10.0.2",
-    "nodemon": "^2.0.22",
+    "nodemon": "^3.0.1",
+    "open-swagger-ui": "^1.2.0",
     "pg": "^8.11.3",
-    "prettier": "^2.8.8",
-    "redis": "^4.6.7",
+    "prettier": "^3.0.3",
+    "redis": "^4.6.8",
     "set-value": ">=4.1.0",
     "sqlite3": "^5.1.6",
     "ts-node": "^10.9.1",
-    "typescript": "^5.1.6"
+    "typescript": "^5.2.2"
   },
   "lint-staged": {
     "**/*": "prettier --write --ignore-unknown"

package/build/src/Handlers/MetadataHandler.d.ts

@@ -1,4 +0,0 @@
-import AxeRequest from "../Services/AxeRequest";
-import AxeResponse from "../Services/AxeResponse";
-declare const _default: (req: AxeRequest, res: AxeResponse) => Promise<void>;
-export default _default;

package/build/src/Handlers/MetadataHandler.js

@@ -1,22 +0,0 @@
-"use strict";
-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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Services_1 = require("../Services");
-exports.default = (req, res) => __awaiter(void 0, void 0, void 0, function* () {
-    const docs = Services_1.DocumentationService.getInstance();
-    const api = Services_1.APIService.getInstance();
-    res.json({
-        routes: docs.get(),
-        versions: api.versions.map((version) => {
-            return Object.assign(Object.assign({}, version), { config: Object.assign(Object.assign({}, version.config), { transaction: undefined }), folders: undefined, modelList: undefined, models: version.modelList.get() });
-        }),
-    });
-});