axe-api 0.31.4 → 1.0.0-rc10

package/build/src/Interfaces.d.ts

@@ -1,10 +1,17 @@
+/// <reference types="node" />
+/// <reference types="express" />
 import { Knex } from "knex";
-import { Express, Request, Response, NextFunction } from "express";
+import { Options as FormOptions } from "formidable";
 import { Column } from "knex-schema-inspector/lib/types/column";
-import { HandlerTypes, LogLevels, HttpMethods, HookFunctionTypes, Extensions, Relationships, SortTypes, ConditionTypes, DependencyTypes, QueryFeature, QueryFeatureType } from "./Enums";
+import { HandlerTypes, 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 { AdaptorTypes, HandlerFunction, HookFunctions, MiddlewareFunction, StepTypes, PhaseFunction, SerializationFunction } from "./Types";
+import { ModelListService, QueryService } from "./Services";
+import AxeRequest from "./Services/AxeRequest";
+import AxeResponse from "./Services/AxeResponse";
+import App from "./Services/App";
+import { LoggerOptions } from "pino";
+import { IncomingMessage } from "http";
 export interface IColumn extends Column {
     table_name: string;
 }
@@ -16,7 +23,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;
@@ -32,20 +39,44 @@ export interface IQueryConfig {
     limits: Array<IQueryLimitConfig[]>;
     defaults?: IQueryDefaultConfig;
 }
-export interface IVersionConfig {
+export interface IRedisOptions {
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+}
+export interface IRateLimitAdaptorConfig {
+    type: AdaptorTypes;
+    redis?: IRedisOptions;
+}
+export interface IRateLimitOptions {
+    maxRequests: number;
+    windowInSeconds: number;
+}
+export interface IRateLimitConfig extends IRateLimitOptions {
+    enabled: boolean;
+    adaptor: IRateLimitAdaptorConfig;
+    trustProxyIP: boolean;
+    keyGenerator?: (req: IncomingMessage) => string;
+}
+export interface AxeVersionConfig {
     transaction: boolean | IHandlerBasedTransactionConfig | IHandlerBasedTransactionConfig[];
-    serializers: ((data: any, request: Request) => void)[] | IHandlerBasedSerializer[];
+    serializers: ((data: any, request: AxeRequest) => void)[] | IHandlerBasedSerializer[];
     supportedLanguages: string[];
     defaultLanguage: string;
     query: IQueryConfig;
+    formidable: FormOptions;
 }
-export interface IApplicationConfig extends IConfig {
+export type IVersionConfig = Partial<AxeVersionConfig>;
+export interface AxeConfig extends IConfig {
     env: string;
     port: number;
-    logLevel: LogLevels;
     prefix: string;
     database: IDatabaseConfig;
+    pino: LoggerOptions;
+    rateLimit: IRateLimitConfig;
 }
+export type IApplicationConfig = Partial<AxeConfig>;
 export interface ILanguage {
     title: string;
     language: string;
@@ -67,7 +98,7 @@ export interface IVersionFolder {
 }
 export interface IVersion {
     name: string;
-    config: IVersionConfig;
+    config: AxeVersionConfig;
     folders: IVersionFolder;
     modelList: ModelListService;
     modelTree: IModelService[];
@@ -76,29 +107,15 @@ export interface IAPI {
     rootFolder: string;
     appFolder: string;
     versions: IVersion[];
-    config: IApplicationConfig;
+    config: AxeConfig;
 }
 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: StepTypes;
 }
 export interface IMethodBaseConfig {
     [HttpMethods.POST]?: string[];
@@ -115,14 +132,14 @@ export interface IModelService {
     relations: IRelation[];
     columns: IColumn[];
     columnNames: string[];
-    hooks: Record<HookFunctionTypes, HookFunction>;
-    events: Record<HookFunctionTypes, HookFunction>;
+    hooks: HookFunctions;
+    events: HookFunctions;
     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 +150,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 +228,17 @@ export interface IDependency {
     callback: any;
     instance: any;
 }
+export interface IPhaseDefinition {
+    name: string;
+    isAsync: boolean;
+    callback: PhaseFunction;
+}
+export interface AxeRequestResponsePair {
+    axeRequest: AxeRequest;
+    axeResponse: AxeResponse;
+}
+export interface MiddlewareResolution {
+    middlewares: (MiddlewareFunction | HandlerFunction)[];
+    handler: HandlerFunction;
+}
 export {};

package/build/src/Middlewares/RateLimit/AdaptorFactory.d.ts

@@ -0,0 +1,6 @@
+import { AdaptorTypes } from "../../Types";
+import RedisAdaptor from "./RedisAdaptor";
+import MemoryAdaptor from "./MemoryAdaptor";
+import { IRedisOptions } from "src/Interfaces";
+declare const _default: (adaptor: AdaptorTypes, redisOptions: IRedisOptions | undefined, prefix: string) => RedisAdaptor | MemoryAdaptor;
+export default _default;

package/build/src/Middlewares/RateLimit/AdaptorFactory.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RedisAdaptor_1 = __importDefault(require("./RedisAdaptor"));
+const MemoryAdaptor_1 = __importDefault(require("./MemoryAdaptor"));
+exports.default = (adaptor, redisOptions, prefix) => {
+    switch (adaptor) {
+        case "redis":
+            return new RedisAdaptor_1.default(redisOptions, prefix);
+        case "memory":
+            return new MemoryAdaptor_1.default(prefix);
+        default:
+            throw new Error(`Adaptor type is not found: ${adaptor}`);
+    }
+};

package/build/src/Middlewares/RateLimit/IAdaptor.d.ts

@@ -0,0 +1,6 @@
+interface IAdaptor {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ttl: number): Promise<void>;
+    decr(key: string, ttl: number): Promise<void>;
+}
+export default IAdaptor;

package/build/src/Middlewares/RateLimit/IAdaptor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/src/Middlewares/RateLimit/MemoryAdaptor.d.ts

@@ -0,0 +1,10 @@
+import IAdaptor from "./IAdaptor";
+declare class MemoryAdaptor implements IAdaptor {
+    private client;
+    private prefix;
+    constructor(prefix: string);
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ttl: number): Promise<void>;
+    decr(key: string, ttl: number): Promise<void>;
+}
+export default MemoryAdaptor;

package/build/src/Middlewares/RateLimit/MemoryAdaptor.js

@@ -0,0 +1,41 @@
+"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 node_cache_1 = __importDefault(require("node-cache"));
+class MemoryAdaptor {
+    constructor(prefix) {
+        this.client = new node_cache_1.default();
+        this.prefix = prefix;
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.get(`${this.prefix}${key}`) || null;
+        });
+    }
+    set(key, value, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.client.set(`${this.prefix}${key}`, value, ttl);
+        });
+    }
+    decr(key, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const value = yield this.get(key);
+            if (value) {
+                const newValue = parseInt(value) - 1;
+                this.set(key, newValue.toString(), ttl);
+            }
+        });
+    }
+}
+exports.default = MemoryAdaptor;

package/build/src/Middlewares/RateLimit/RedisAdaptor.d.ts

@@ -0,0 +1,11 @@
+import IAdaptor from "./IAdaptor";
+import { IRedisOptions } from "../../Interfaces";
+declare class RedisAdaptor implements IAdaptor {
+    private client;
+    private prefix;
+    constructor(options: IRedisOptions | undefined, prefix: string);
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ttl: number): Promise<void>;
+    decr(key: string): Promise<void>;
+}
+export default RedisAdaptor;

package/build/src/Middlewares/RateLimit/RedisAdaptor.js

@@ -0,0 +1,35 @@
+"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 redis_1 = require("redis");
+class RedisAdaptor {
+    constructor(options, prefix) {
+        this.client = (0, redis_1.createClient)(options);
+        this.prefix = prefix;
+        this.client.connect();
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.client.get(`${this.prefix}${key}`);
+        });
+    }
+    set(key, value, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.client.setEx(`${this.prefix}${key}`, ttl, value);
+        });
+    }
+    decr(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.client.decr(`${this.prefix}${key}`);
+        });
+    }
+}
+exports.default = RedisAdaptor;

package/build/src/Middlewares/RateLimit/index.d.ts

@@ -0,0 +1,6 @@
+import { IncomingMessage, ServerResponse } from "http";
+import { AxeConfig, IRateLimitOptions, IRequestPack } from "../../Interfaces";
+export declare const setupRateLimitAdaptors: (config: AxeConfig) => void;
+export declare const rateLimit: (options?: IRateLimitOptions) => (context: IRequestPack) => Promise<void>;
+declare const _default: (req: IncomingMessage, res: ServerResponse, next: any) => Promise<any>;
+export default _default;

package/build/src/Middlewares/RateLimit/index.js

@@ -0,0 +1,118 @@
+"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 });
+exports.rateLimit = exports.setupRateLimitAdaptors = void 0;
+const AdaptorFactory_1 = __importDefault(require("./AdaptorFactory"));
+const Services_1 = require("../../Services");
+const nanoid_1 = require("nanoid");
+let adaptor;
+const checkRateLimit = function (clientKey, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Getting the last value from cache
+        const reply = yield adaptor.get(clientKey);
+        if (!reply) {
+            // First request from this IP, set initial values
+            yield adaptor.set(clientKey, (options.maxRequests - 1).toString(), options.windowInSeconds);
+            return {
+                success: true,
+                limit: options.maxRequests,
+                remaining: options.maxRequests - 1,
+            };
+        }
+        // Is there any remaining request right
+        const remainingRequests = parseInt(reply);
+        if (remainingRequests > 0) {
+            // Set the new value to the cache
+            yield adaptor.decr(clientKey, options.windowInSeconds);
+            return {
+                success: true,
+                limit: options.maxRequests,
+                remaining: remainingRequests - 1,
+            };
+        }
+        // Client has exceeded rate limit
+        return {
+            success: false,
+            limit: options.maxRequests,
+            remaining: 0,
+        };
+    });
+};
+const getClientKeyByConfigurations = (req, config) => {
+    if (config === null || config === void 0 ? void 0 : config.keyGenerator) {
+        return config === null || config === void 0 ? void 0 : config.keyGenerator(req);
+    }
+    if (config === null || config === void 0 ? void 0 : config.trustProxyIP) {
+        // Getting the x-forwarded-for value for the Proxy servers.
+        let headerValue = req.headers["x-forwarded-for"];
+        if (Array.isArray(headerValue)) {
+            headerValue = headerValue[0];
+        }
+        return `axe-api-rate-limit:${headerValue || ""}`;
+    }
+    return `axe-api-rate-limit:${req.socket.remoteAddress || ""}`;
+};
+const setupRateLimitAdaptors = (config) => {
+    var _a, _b;
+    // Creating the correct adaptor by the configuration
+    adaptor = (0, AdaptorFactory_1.default)(((_a = config.rateLimit) === null || _a === void 0 ? void 0 : _a.adaptor.type) || "memory", (_b = config.rateLimit) === null || _b === void 0 ? void 0 : _b.adaptor.redis, "");
+};
+exports.setupRateLimitAdaptors = setupRateLimitAdaptors;
+const rateLimit = (options) => {
+    // For each model middleware, we should use a different ID for the cache key
+    const id = (0, nanoid_1.nanoid)();
+    return (context) => __awaiter(void 0, void 0, void 0, function* () {
+        // API configuration fetching
+        const api = Services_1.APIService.getInstance();
+        // Creating a clientkey by the client key configurations
+        const clientKey = getClientKeyByConfigurations(context.req.original, api.config.rateLimit);
+        // Developers are able to set different rate limit options
+        // in model files. That's why we should create a new option object.
+        const selectedOptions = Object.assign(Object.assign({}, api.config.rateLimit), options);
+        // Checking the rate limit
+        const isAllowed = yield checkRateLimit(`${clientKey}:${id}`, selectedOptions);
+        // Setting the headers
+        context.res.original.setHeader("X-RateLimit-Limit", isAllowed.limit);
+        context.res.original.setHeader("X-RateLimit-Remaining", isAllowed.remaining);
+        // Sending an error message if there is an error
+        if (isAllowed.success === false) {
+            Services_1.LogService.warn(`Rate limit exceeded: ${context.req.url}`);
+            context.res.status(429).json({ error: "Rate limit exceeded." });
+        }
+    });
+};
+exports.rateLimit = rateLimit;
+exports.default = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    const api = Services_1.APIService.getInstance();
+    // Generating the client key
+    const clientKey = getClientKeyByConfigurations(req, api.config.rateLimit);
+    // Checking the rate limits.
+    const isAllowed = yield checkRateLimit(clientKey, {
+        maxRequests: api.config.rateLimit.maxRequests,
+        windowInSeconds: api.config.rateLimit.windowInSeconds,
+    });
+    // Setting the HTTP Response headers.
+    res.setHeader("X-RateLimit-Limit", isAllowed.limit);
+    res.setHeader("X-RateLimit-Remaining", isAllowed.remaining);
+    // If it is allowed, the next function would be called.
+    if (isAllowed.success) {
+        return next();
+    }
+    // Sending an error message.
+    Services_1.LogService.warn(`Rate limit exceeded: ${req.url}`);
+    res.writeHead(429, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({
+        error: "Rate limit exceeded.",
+    }));
+});

package/build/src/Model.d.ts

@@ -1,13 +1,13 @@
-import { IRelation, IMethodBaseConfig, IMethodBaseValidations, IHandlerBaseMiddleware, IHandlerBasedTransactionConfig, IQueryLimitConfig } from "./Interfaces";
+import { IRelation, IMethodBaseConfig, IMethodBaseValidations, IHandlerBasedTransactionConfig, IQueryLimitConfig } from "./Interfaces";
 import { HandlerTypes, HttpMethods } from "./Enums";
-import { FieldList, MiddlewareFunction, ModelValidation } from "./Types";
+import { FieldList, ModelMiddlewareDefinition, StepTypes, ModelValidation } 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(): ModelMiddlewareDefinition;
     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): StepTypes[];
     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/{Middlewares/acceptLanguageMiddleware.js → Phases/All/FetchPhase.js}

@@ -9,14 +9,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const Resolvers_1 = require("../Resolvers");
-const Helpers_1 = require("../Helpers");
-exports.default = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
-    // Application configuration is need for the default setting.
-    const version = yield (0, Helpers_1.getVersionByRequest)(req);
-    // Setting the current language by the supported, default and the client prefences
-    req.currentLanguage = Resolvers_1.AcceptLanguageResolver.resolve(req.get("accept-language") || "", version.config.supportedLanguages || ["en"], version.config.defaultLanguage || "en");
-    // Adding the `Content-Language` header to the response object
-    res.setHeader("Content-Language", req.currentLanguage.title);
-    next();
+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;

package/build/src/Phases/Delete/ActionPhase.js

@@ -0,0 +1,24 @@
+"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) {
+        // If there is a deletedAtColumn, it means that this table support soft-delete
+        if (context.model.instance.deletedAtColumn) {
+            yield context.query.update({
+                [context.model.instance.deletedAtColumn]: new Date(),
+            });
+        }
+        else {
+            yield context.query.delete();
+        }
+    }
+});

package/build/src/Phases/Delete/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/Delete/PreparePhase.js

@@ -0,0 +1,25 @@
+"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 Helpers_1 = require("../../Handlers/Helpers");
+exports.default = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    // We should check the parameter type
+    const value = context.req.params[context.model.instance.primaryKey];
+    (0, Helpers_1.checkPrimaryKeyValueType)(context.model, value);
+    // Adding the main query
+    context.query = context.database
+        .from(context.model.instance.table)
+        .where(context.model.instance.primaryKey, value);
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    (0, Helpers_1.addSoftDeleteQuery)(context.model, null, context.query);
+    // If there is a relation, we should bind it
+    (0, Helpers_1.addForeignKeyQuery)(context.req, context.query, context.relation, context.parentModel);
+});

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

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

package/build/src/Phases/Delete/QueryPhase.js

@@ -0,0 +1,22 @@
+"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 Enums_1 = require("../../Enums");
+exports.default = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    if (context.query) {
+        context.item = yield context.query.first();
+        if (!context.item) {
+            context.res
+                .status(Enums_1.StatusCodes.NOT_FOUND)
+                .json({ error: `The item is not found on ${context.model.name}.` });
+        }
+    }
+});

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

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