axe-api 0.31.4 → 1.0.0-rc1

package/build/dev-kit.d.ts

@@ -0,0 +1 @@
+export {};

package/build/dev-kit.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_color_log_1 = __importDefault(require("node-color-log"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const path_1 = __importDefault(require("path"));
+const index_1 = require("./index");
+node_color_log_1.default.bgColor("yellow").color("black").log("Axe API dev-kit (1.0.1)");
+node_color_log_1.default
+    .color("blue")
+    .log("Docs: https://axe-api.com/contribution/fundamentals.html \n");
+dotenv_1.default.config();
+const server = new index_1.Server();
+server.start(path_1.default.join(__dirname, "dev-kit"));

package/build/index.d.ts

@@ -2,7 +2,7 @@ import Server from "./src/Server";
 import Model from "./src/Model";
 import ApiError from "./src/Exceptions/ApiError";
 import { DEFAULT_HANDLERS, DEFAULT_VERSION_CONFIG } from "./src/constants";
-import { IoCService, allow, deny } from "./src/Services";
+import { IoCService, allow, deny, App, AxeRequest, AxeResponse } from "./src/Services";
 export * from "./src/Enums";
 export * from "./src/Interfaces";
-export { Server, Model, ApiError, DEFAULT_HANDLERS, DEFAULT_VERSION_CONFIG, IoCService, allow, deny, };
+export { App, AxeRequest, AxeResponse, Server, Model, ApiError, DEFAULT_HANDLERS, DEFAULT_VERSION_CONFIG, IoCService, allow, deny, };

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 = void 0;
+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"));
@@ -31,5 +31,8 @@ const Services_1 = require("./src/Services");
 Object.defineProperty(exports, "IoCService", { enumerable: true, get: function () { return Services_1.IoCService; } });
 Object.defineProperty(exports, "allow", { enumerable: true, get: function () { return Services_1.allow; } });
 Object.defineProperty(exports, "deny", { enumerable: true, get: function () { return Services_1.deny; } });
+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; } });
 __exportStar(require("./src/Enums"), exports);
 __exportStar(require("./src/Interfaces"), exports);

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

@@ -7,11 +7,7 @@ declare class RouterBuilder {
     private createRouteByModel;
     private createNestedRoutes;
     private createChildRoutes;
-    private getPrimaryKeyName;
-    private ucFirst;
     private addExpressRoute;
-    private requestHandler;
-    private sendErrorAsResponse;
     private getResourcePath;
     private getRootPrefix;
 }

package/build/src/Builders/RouterBuilder.js

@@ -17,21 +17,13 @@ const change_case_1 = require("change-case");
 const Resolvers_1 = require("../Resolvers");
 const constants_1 = require("../constants");
 const Enums_1 = require("../Enums");
-const HandlerFactory_1 = __importDefault(require("../Handlers/HandlerFactory"));
 const Services_1 = require("../Services");
-const Middlewares_1 = require("../Middlewares");
+const URLService_1 = __importDefault(require("../Services/URLService"));
 class RouterBuilder {
     constructor(version) {
-        this.getPrimaryKeyName = (model) => {
-            return (pluralize_1.default.singular(model.name).toLowerCase() +
-                this.ucFirst(model.instance.primaryKey));
-        };
-        this.ucFirst = (value) => {
-            return value.charAt(0).toUpperCase() + value.slice(1);
-        };
         this.getRootPrefix = () => __awaiter(this, void 0, void 0, function* () {
             const api = Services_1.APIService.getInstance();
-            let prefix = api.config.prefix || "api";
+            let prefix = api.config.prefix;
             if (prefix.startsWith("/")) {
                 prefix = prefix.substring(1);
             }
@@ -82,7 +74,6 @@ class RouterBuilder {
                 // internal middlewares such as `Accept Language Middleware` which parse
                 // the "accept-language" header to use in the application general.
                 const middlewares = [
-                    Middlewares_1.acceptLanguageMiddleware,
                     ...model.instance.getMiddlewares(handlerType),
                 ];
                 // Adding the route to the express
@@ -124,104 +115,19 @@ class RouterBuilder {
     addExpressRoute(handlerType, url, middlewares, model, parentModel, relation) {
         return __awaiter(this, void 0, void 0, function* () {
             const docs = Services_1.DocumentationService.getInstance();
-            const app = yield Services_1.IoCService.useByType("App");
-            const handler = (req, res, next) => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    yield this.requestHandler(handlerType, req, res, model, parentModel, relation);
-                }
-                catch (error) {
-                    // Catch error then pass it to the express error handler
-                    next(error);
-                }
-            });
-            switch (handlerType) {
-                case Enums_1.HandlerTypes.ALL:
-                    app.get(url, middlewares, handler);
-                    docs.push(this.version, Enums_1.HandlerTypes.ALL, Enums_1.HttpMethods.GET, url, model);
-                    break;
-                case Enums_1.HandlerTypes.DELETE:
-                    app.delete(url, middlewares, handler);
-                    docs.push(this.version, Enums_1.HandlerTypes.DELETE, Enums_1.HttpMethods.DELETE, url, model);
-                    break;
-                case Enums_1.HandlerTypes.FORCE_DELETE:
-                    app.delete(url, middlewares, handler);
-                    docs.push(this.version, Enums_1.HandlerTypes.FORCE_DELETE, Enums_1.HttpMethods.DELETE, url, model);
-                    break;
-                case Enums_1.HandlerTypes.INSERT:
-                    app.post(url, middlewares, handler);
-                    docs.push(this.version, Enums_1.HandlerTypes.INSERT, Enums_1.HttpMethods.POST, url, model);
-                    break;
-                case Enums_1.HandlerTypes.PAGINATE:
-                    app.get(url, middlewares, handler);
-                    docs.push(this.version, Enums_1.HandlerTypes.PAGINATE, Enums_1.HttpMethods.GET, url, model);
-                    break;
-                case Enums_1.HandlerTypes.PATCH:
-                    app.patch(url, middlewares, handler);
-                    docs.push(this.version, Enums_1.HandlerTypes.PATCH, Enums_1.HttpMethods.PATCH, url, model);
-                    break;
-                case Enums_1.HandlerTypes.SHOW:
-                    app.get(url, middlewares, handler);
-                    docs.push(this.version, Enums_1.HandlerTypes.SHOW, Enums_1.HttpMethods.GET, url, model);
-                    break;
-                case Enums_1.HandlerTypes.UPDATE:
-                    app.put(url, middlewares, handler);
-                    docs.push(this.version, Enums_1.HandlerTypes.UPDATE, Enums_1.HttpMethods.PUT, url, model);
-                    break;
-                default:
-                    throw new Error("Undefined handler type");
-            }
+            const data = {
+                version: this.version,
+                handlerType,
+                model,
+                parentModel,
+                relation,
+            };
+            // 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);
         });
     }
-    requestHandler(handlerType, req, res, model, parentModel, relation) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let trx = null;
-            let hasTransaction = false;
-            try {
-                const database = (yield Services_1.IoCService.use("Database"));
-                const api = Services_1.APIService.getInstance();
-                hasTransaction = yield new Resolvers_1.TransactionResolver(this.version).resolve(model, handlerType);
-                if (hasTransaction) {
-                    trx = yield database.transaction();
-                }
-                const handler = HandlerFactory_1.default.get(handlerType);
-                const pack = {
-                    api,
-                    version: this.version,
-                    req,
-                    res,
-                    handlerType,
-                    model,
-                    parentModel,
-                    relation,
-                    database: hasTransaction && trx ? trx : database,
-                };
-                yield handler(pack);
-                if (hasTransaction && trx) {
-                    trx.commit();
-                }
-            }
-            catch (error) {
-                if (hasTransaction && trx) {
-                    trx.rollback();
-                }
-                this.sendErrorAsResponse(res, error);
-            }
-        });
-    }
-    sendErrorAsResponse(res, error) {
-        const type = error.type;
-        if (type === "ApiError") {
-            // eslint-disable-next-line no-case-declarations
-            const apiError = error;
-            res.status(apiError.status).json({
-                error: apiError.message,
-            });
-            return;
-        }
-        // We should log error and send general error response
-        Services_1.LogService.getInstance().error(`SERVER ERROR: ${JSON.stringify(Object.assign(Object.assign({}, error), { message: error.message }), null, "  ")}`);
-        throw error;
-    }
     getResourcePath(model, relation) {
         return relation
             ? (0, change_case_1.paramCase)(relation.name)

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

@@ -1,3 +1,4 @@
-import { Request, Response } from "express";
-declare const _default: (req: Request, res: Response) => Promise<void>;
+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/Helpers.d.ts

@@ -1,17 +1,17 @@
-import { Request } from "express";
-import { IModelService, IRelation, IHookParameter, IQuery, IVersion, IWith } from "../Interfaces";
+import { IModelService, IRelation, IQuery, IVersion, IWith, IRequestPack } from "../Interfaces";
 import { Knex } from "knex";
 import { HandlerTypes, HookFunctionTypes, TimestampColumns } from "../Enums";
 import { ModelListService } from "../Services";
 import { SerializationFunction } from "../Types";
+import AxeRequest from "src/Services/AxeRequest";
 export declare const bindTimestampValues: (formData: Record<string, any>, model: IModelService, columnTypes?: TimestampColumns[]) => void;
-export declare const getMergedFormData: (req: Request, fillables: string[]) => Record<string, any>;
-export declare const callHooks: (model: IModelService, type: HookFunctionTypes, params: IHookParameter) => Promise<void>;
+export declare const getMergedFormData: (req: AxeRequest, fillables: string[]) => Record<string, any>;
+export declare const callHooks: (model: IModelService, type: HookFunctionTypes, params: IRequestPack) => Promise<void>;
 export declare const getParentColumn: (relation: IRelation | null) => string | null;
 export declare const checkPrimaryKeyValueType: (model: IModelService, value: any) => void;
-export declare const addForeignKeyQuery: (request: Request, query: Knex.QueryBuilder, relation: IRelation | null, parentModel: IModelService | null) => void;
-export declare const serializeData: (version: IVersion, itemArray: any, modelSerializer: SerializationFunction | null, handler: HandlerTypes, request: Request) => Promise<any[]>;
+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[]>;
 export declare const filterHiddenFields: (itemArray: any[], hiddens: string[] | null) => void;
 export declare const addSoftDeleteQuery: (model: IModelService, conditions: IQuery | null, query: Knex.QueryBuilder) => void;
-export declare const getRelatedData: (version: IVersion, data: any[], withArray: IWith[], model: IModelService, modelList: ModelListService, database: Knex | Knex.Transaction, handler: HandlerTypes, request: Request) => Promise<void>;
+export declare const getRelatedData: (version: IVersion, data: any[], withArray: IWith[], model: IModelService, modelList: ModelListService, database: Knex | Knex.Transaction, handler: HandlerTypes, request: AxeRequest) => Promise<void>;
 export declare const isBoolean: (value: any) => boolean;

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

@@ -1,3 +1,4 @@
-import { Request, Response } from "express";
-declare const _default: (req: Request, res: Response) => Promise<void>;
+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/RequestHandler.d.ts

@@ -0,0 +1,3 @@
+import { IncomingMessage, ServerResponse } from "http";
+declare const _default: (request: IncomingMessage, response: ServerResponse) => Promise<void>;
+export default _default;

package/build/src/Handlers/RequestHandler.js

@@ -0,0 +1,89 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Services_1 = require("../Services");
+const URLService_1 = __importDefault(require("../Services/URLService"));
+const AxeRequest_1 = __importDefault(require("../Services/AxeRequest"));
+const AxeResponse_1 = __importDefault(require("../Services/AxeResponse"));
+const api = Services_1.APIService.getInstance();
+const return404 = (response) => {
+    response.statusCode = 404;
+    response.write(JSON.stringify({ error: "Resource not found" }));
+    response.end();
+};
+exports.default = (request, response) => __awaiter(void 0, void 0, void 0, function* () {
+    const axeRequest = new AxeRequest_1.default(request);
+    const match = URLService_1.default.match(axeRequest);
+    const axeResponse = new AxeResponse_1.default(response, axeRequest.currentLanguage);
+    if (!match) {
+        return return404(response);
+    }
+    if (match.customHandler) {
+        match.customHandler(axeRequest, axeResponse);
+        return;
+    }
+    // We should set the params
+    axeRequest.params = match.params;
+    const database = (yield Services_1.IoCService.use("Database"));
+    // Prepare the database by the transaction option
+    let trx = null;
+    if (match.hasTransaction) {
+        trx = yield database.transaction();
+    }
+    const pack = Object.assign(Object.assign({}, match.data), { params: match.params, api, req: axeRequest, res: axeResponse, database: match.hasTransaction && trx ? trx : database });
+    response.setHeader("Content-Type", "application/json");
+    response.setHeader("x-powered-by", "Axe API");
+    for (const phase of match.phases) {
+        // If there is an non-async phase, it should be an Event function
+        if (phase.isAsync === false) {
+            yield phase.callback(pack);
+            continue;
+        }
+        // Middleware and hook calls
+        try {
+            yield phase.callback(pack);
+        }
+        catch (error) {
+            // Rollback transaction
+            if (match.hasTransaction && trx) {
+                trx.rollback();
+            }
+            if (error.type === "ApiError") {
+                const apiError = error;
+                return axeResponse.json({ error: apiError.message }, apiError.status);
+            }
+            // TODO: We need an error handler.
+            axeResponse.json({ error: error.toString() }, 500);
+            break;
+        }
+        // If the response is not created, we should go to the next phase
+        if (pack.res.isResponded() === false) {
+            continue;
+        }
+        // If the response is an error, and we have an active transaction,
+        // we should rollback it before the HTTP request end.
+        if (pack.res.statusCode() >= 400 && pack.res.statusCode() < 599) {
+            if (match.hasTransaction && trx) {
+                trx.rollback();
+            }
+            break;
+        }
+        // If there is a valid transaction, we should commit it
+        if (match.hasTransaction && trx) {
+            trx.commit();
+        }
+        // We should brake the for-loop
+        break;
+    }
+});

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

@@ -1,3 +1,4 @@
-import { Request, Response } from "express";
-declare const _default: (req: Request, res: Response) => Promise<void>;
+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/Helpers.d.ts

@@ -1,4 +1,3 @@
-import { Request } from "express";
 import { IVersion } from "./Interfaces";
-export declare const getVersionByRequest: (req: Request) => Promise<IVersion>;
+export declare const getVersionByRequest: (urlObject: URL) => IVersion | undefined;
 export declare const consoleAxeError: (error: any) => void;

package/build/src/Helpers.js

@@ -1,13 +1,4 @@
 "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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -16,18 +7,15 @@ exports.consoleAxeError = exports.getVersionByRequest = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const change_case_1 = require("change-case");
 const Services_1 = require("./Services");
-const getVersionByRequest = (req) => __awaiter(void 0, void 0, void 0, function* () {
+const getVersionByRequest = (urlObject) => {
     // Application configuration is need for the default setting.
     const api = Services_1.APIService.getInstance();
     const matchedVersion = api.versions.find((version) => {
         const path = `/${api.config.prefix}/${version.name}`;
-        return req.path.indexOf(path) === 0;
+        return urlObject.pathname.startsWith(path);
     });
-    if (!matchedVersion) {
-        throw new Error(`Version is not matched: ${req.path}`);
-    }
     return matchedVersion;
-});
+};
 exports.getVersionByRequest = getVersionByRequest;
 const consoleAxeError = (error) => {
     const putWithSpace = (text, max) => {

package/build/src/Interfaces.d.ts

@@ -1,10 +1,12 @@
 import { Knex } from "knex";
-import { Express, Request, Response, NextFunction } from "express";
 import { Column } from "knex-schema-inspector/lib/types/column";
 import { HandlerTypes, LogLevels, HttpMethods, HookFunctionTypes, Extensions, Relationships, SortTypes, ConditionTypes, DependencyTypes, QueryFeature, QueryFeatureType } from "./Enums";
 import Model from "./Model";
-import { HookFunction, SerializationFunction } from "./Types";
-import { ModelListService } from "./Services";
+import { PhaseFunction, SerializationFunction } from "./Types";
+import { ModelListService, QueryService } from "./Services";
+import AxeRequest from "./Services/AxeRequest";
+import AxeResponse from "./Services/AxeResponse";
+import App from "./Services/App";
 export interface IColumn extends Column {
     table_name: string;
 }
@@ -16,7 +18,7 @@ export interface IHandlerBasedTransactionConfig {
 }
 interface IHandlerBasedSerializer {
     handler: HandlerTypes[];
-    serializer: ((data: any, request: Request) => void)[];
+    serializer: ((data: any, request: AxeRequest) => void)[];
 }
 export interface IQueryLimitConfig {
     feature: QueryFeature;
@@ -34,7 +36,7 @@ export interface IQueryConfig {
 }
 export interface IVersionConfig {
     transaction: boolean | IHandlerBasedTransactionConfig | IHandlerBasedTransactionConfig[];
-    serializers: ((data: any, request: Request) => void)[] | IHandlerBasedSerializer[];
+    serializers: ((data: any, request: AxeRequest) => void)[] | IHandlerBasedSerializer[];
     supportedLanguages: string[];
     defaultLanguage: string;
     query: IQueryConfig;
@@ -79,26 +81,12 @@ export interface IAPI {
     config: IApplicationConfig;
 }
 export interface IGeneralHooks {
-    onBeforeInit: (app: Express) => void | null;
-    onAfterInit: (app: Express) => void | null;
+    onBeforeInit: (app: App) => void | null;
+    onAfterInit: (app: App) => void | null;
 }
 export interface IHandlerBaseMiddleware {
     handler: HandlerTypes[];
-    middleware: (req: Request, res: Response, next: NextFunction) => void | Promise<void>;
-}
-export interface IHookParameter {
-    req: Request;
-    res: Response;
-    handlerType: HandlerTypes;
-    model: IModelService;
-    parentModel: IModelService | null;
-    relation: IRelation | null;
-    database: Knex | Knex.Transaction;
-    conditions: IQuery | null;
-    query: Knex.QueryBuilder | null;
-    result: any;
-    item: any;
-    formData: any;
+    middleware: (context: IRequestPack) => Promise<void>;
 }
 export interface IMethodBaseConfig {
     [HttpMethods.POST]?: string[];
@@ -115,14 +103,14 @@ export interface IModelService {
     relations: IRelation[];
     columns: IColumn[];
     columnNames: string[];
-    hooks: Record<HookFunctionTypes, HookFunction>;
-    events: Record<HookFunctionTypes, HookFunction>;
+    hooks: Record<HookFunctionTypes, PhaseFunction>;
+    events: Record<HookFunctionTypes, PhaseFunction>;
     isRecursive: boolean;
     children: IModelService[];
     queryLimits: IQueryLimitConfig[];
     serialize: SerializationFunction | null;
     setColumns(columns: IColumn[]): void;
-    setExtensions(type: Extensions, hookFunctionType: HookFunctionTypes, data: HookFunction): void;
+    setExtensions(type: Extensions, hookFunctionType: HookFunctionTypes, data: PhaseFunction): void;
     setQueryLimits(limits: IQueryLimitConfig[]): void;
     setSerialization(callback: SerializationFunction): void;
 }
@@ -133,16 +121,25 @@ export interface IRelation {
     primaryKey: string;
     foreignKey: string;
 }
-export interface IRequestPack {
-    api: IAPI;
+export interface IRouteData {
     version: IVersion;
-    req: Request;
-    res: Response;
     handlerType: HandlerTypes;
     model: IModelService;
     parentModel: IModelService | null;
     relation: IRelation | null;
+}
+export interface IRequestPack extends IRouteData {
+    api: IAPI;
+    req: AxeRequest;
+    res: AxeResponse;
     database: Knex | Knex.Transaction;
+    queryParser?: QueryService;
+    conditions?: IQuery;
+    query?: Knex.QueryBuilder;
+    params?: any;
+    result?: any;
+    item?: any;
+    formData?: any;
 }
 export interface IRouteDocumentation {
     version: string;
@@ -202,4 +199,8 @@ export interface IDependency {
     callback: any;
     instance: any;
 }
+export interface IPhaseDefinition {
+    isAsync: boolean;
+    callback: PhaseFunction;
+}
 export {};

package/build/src/Model.d.ts

@@ -1,13 +1,13 @@
 import { IRelation, IMethodBaseConfig, IMethodBaseValidations, IHandlerBaseMiddleware, IHandlerBasedTransactionConfig, IQueryLimitConfig } from "./Interfaces";
 import { HandlerTypes, HttpMethods } from "./Enums";
-import { FieldList, MiddlewareFunction, ModelValidation } from "./Types";
+import { FieldList, ModelValidation, PhaseFunction } from "./Types";
 declare class Model {
     get primaryKey(): string;
     get table(): string;
     get fillable(): FieldList | IMethodBaseConfig;
     get validations(): IMethodBaseValidations | ModelValidation;
     get handlers(): HandlerTypes[];
-    get middlewares(): MiddlewareFunction[] | IHandlerBaseMiddleware[] | IHandlerBaseMiddleware;
+    get middlewares(): PhaseFunction[] | IHandlerBaseMiddleware[] | IHandlerBaseMiddleware;
     get hiddens(): FieldList;
     get createdAtColumn(): string | null;
     get updatedAtColumn(): string | null;
@@ -17,7 +17,7 @@ declare class Model {
     get limits(): Array<IQueryLimitConfig[]>;
     getFillableFields(methodType: HttpMethods): string[];
     getValidationRules(methodType: HttpMethods): ModelValidation | null;
-    getMiddlewares(handlerType: HandlerTypes): MiddlewareFunction[];
+    getMiddlewares(handlerType: HandlerTypes): PhaseFunction[];
     hasMany(relatedModel: string, primaryKey?: string, foreignKey?: string): IRelation;
     hasOne(relatedModel: string, primaryKey?: string, foreignKey?: string): IRelation;
     belongsTo(relatedModel: string, primaryKey: string, foreignKey: string): IRelation;

package/build/src/Phases/All/FetchPhase.d.ts

@@ -0,0 +1,3 @@
+import { IRequestPack } from "../../Interfaces";
+declare const _default: (context: IRequestPack) => Promise<void>;
+export default _default;

package/build/src/Phases/All/FetchPhase.js

@@ -0,0 +1,16 @@
+"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 });
+exports.default = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    if (context.query) {
+        context.result = yield context.query;
+    }
+});

package/build/src/Phases/All/PreparePhase.d.ts

@@ -0,0 +1,3 @@
+import { IRequestPack } from "../../Interfaces";
+declare const _default: (context: IRequestPack) => Promise<void>;
+export default _default;

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

@@ -0,0 +1,30 @@
+"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");
+const Helpers_1 = require("../../Handlers/Helpers");
+exports.default = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    context.queryParser = new Services_1.QueryService(context.model, context.version.modelList.get(), context.version.config);
+    // We should parse URL query string to use as condition in Lucid query
+    context.conditions = context.queryParser.get(context.req.query);
+    // Creating a new database query
+    context.query = context.database.from(context.model.instance.table);
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    (0, Helpers_1.addSoftDeleteQuery)(context.model, context.conditions, context.query);
+    // Users should be able to select some fields to show.
+    context.queryParser.applyFields(context.query, context.conditions.fields);
+    // Binding parent id if there is.
+    (0, Helpers_1.addForeignKeyQuery)(context.req, context.query, context.relation, context.parentModel);
+    // Users should be able to filter records
+    context.queryParser.applyWheres(context.query, context.conditions.q);
+    // User should be able to select sorting fields and types
+    context.queryParser.applySorting(context.query, context.conditions.sort);
+});

package/build/src/Phases/All/index.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    FetchPhase: (context: import("../../Interfaces").IRequestPack) => Promise<void>;
+};
+export default _default;

package/build/src/{Middlewares → Phases/All}/index.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.acceptLanguageMiddleware = void 0;
-const acceptLanguageMiddleware_1 = __importDefault(require("./acceptLanguageMiddleware"));
-exports.acceptLanguageMiddleware = acceptLanguageMiddleware_1.default;
+const FetchPhase_1 = __importDefault(require("./FetchPhase"));
+exports.default = {
+    FetchPhase: FetchPhase_1.default,
+};

package/build/src/Phases/Delete/ActionPhase.d.ts

@@ -0,0 +1,3 @@
+import { IRequestPack } from "../../Interfaces";
+declare const _default: (context: IRequestPack) => Promise<void>;
+export default _default;