axe-api 0.31.3 → 1.0.0-rc1

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

@@ -1,22 +1,22 @@
 import { HookFunctionTypes, Extensions } from "../Enums";
 import { IColumn, IModelService, IQueryLimitConfig, IRelation } from "../Interfaces";
 import Model from "./../Model";
-import { HookFunction, SerializationFunction } from "../Types";
+import { PhaseFunction, SerializationFunction } from "../Types";
 declare class ModelService implements IModelService {
     name: string;
     instance: Model;
     relations: IRelation[];
     columns: IColumn[];
     columnNames: string[];
-    hooks: Record<HookFunctionTypes, HookFunction>;
-    events: Record<HookFunctionTypes, HookFunction>;
+    hooks: Record<HookFunctionTypes, PhaseFunction>;
+    events: Record<HookFunctionTypes, PhaseFunction>;
     children: IModelService[];
     isRecursive: boolean;
     queryLimits: IQueryLimitConfig[];
     serialize: SerializationFunction | null;
     constructor(name: string, instance: Model);
     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;
     private setHooks;

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

@@ -12,7 +12,7 @@ declare class QueryService {
     applySorting(query: Knex.QueryBuilder, sort: ISortField[]): void;
     applyWheresInsideGroup(sub: Knex.QueryBuilder, ruleSet: NestedWhere | IWhere): void;
     applyWheres(query: Knex.QueryBuilder, ruleSet: NestedWhere): void;
-    get(query: any): IQuery;
+    get(query: URLSearchParams): IQuery;
     private getUsedColumns;
     private applyConditionRule;
     private applyRelatedQueryJoins;

package/build/src/Services/QueryService.js

@@ -164,12 +164,13 @@ class QueryService {
     }
     parseSections(sections) {
         var _a, _b, _c, _d;
-        if (sections.q) {
-            const queryContent = sections.q.replace(/%20/g, "").replace(/ /g, "");
+        let q = sections.get("q");
+        if (q) {
+            const queryContent = q.replace(/%20/g, "").replace(/ /g, "");
             // Users can send an unacceptable query string. We shouldn't allow them to
             // send unacceptable structure because of security reasons.
             try {
-                sections.q = JSON.parse(queryContent);
+                q = JSON.parse(queryContent);
             }
             catch (err) {
                 throw new ApiError_1.default(`Unacceptable query string: ${queryContent}`);
@@ -177,13 +178,15 @@ class QueryService {
         }
         const withQueryResolver = new Resolvers_1.WithQueryResolver(this.model, this.models);
         const query = {
-            page: this.parsePage(sections.page),
-            per_page: this.parsePerPage(sections.per_page),
-            fields: this.parseFields(sections.fields),
-            sort: this.parseSortingOptions(sections.sort),
-            q: this.parseCondition(sections.q),
-            with: withQueryResolver.resolve((sections === null || sections === void 0 ? void 0 : sections.with) || ""),
-            trashed: (sections === null || sections === void 0 ? void 0 : sections.trashed) ? (0, Helpers_1.isBoolean)(sections.trashed) : false,
+            page: this.parsePage(sections.get("page")),
+            per_page: this.parsePerPage(sections.get("per_page")),
+            fields: this.parseFields(sections.get("fields")),
+            sort: this.parseSortingOptions(sections.get("sort")),
+            q: this.parseCondition(q),
+            with: withQueryResolver.resolve(sections.get("with") || ""),
+            trashed: sections.get("trashed")
+                ? (0, Helpers_1.isBoolean)(sections.get("trashed"))
+                : false,
         };
         const configPerPage = ((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.query.defaults) === null || _b === void 0 ? void 0 : _b.perPage) ||
             ((_d = (_c = constants_1.DEFAULT_VERSION_CONFIG.query) === null || _c === void 0 ? void 0 : _c.defaults) === null || _d === void 0 ? void 0 : _d.perPage) ||
@@ -217,7 +220,7 @@ class QueryService {
             ((_j = constants_1.DEFAULT_VERSION_CONFIG.query.defaults) === null || _j === void 0 ? void 0 : _j.maxPerPage) ||
             100;
         if (isNaN(value) || value < minPerPage || value > maxPerPage) {
-            throw new ApiError_1.default(`Unacceptable 'per_page' value! Current value is '${value}'. It should be between ${minPerPage}-${maxPerPage}`);
+            throw new ApiError_1.default(`Unacceptable 'per_page' value! Current value is '${value}'. It should be between ${minPerPage}-${maxPerPage}`, Enums_1.StatusCodes.BAD_REQUEST);
         }
         return value;
     }
@@ -326,14 +329,6 @@ class QueryService {
             this.applySpecialCondition(where, "$between", Enums_1.ConditionTypes.Between);
             this.applySpecialCondition(where, "$notBetween", Enums_1.ConditionTypes.NotBetween);
         }
-        if (where.condition === Enums_1.ConditionTypes.In ||
-            where.condition === Enums_1.ConditionTypes.NotIn) {
-            where.value = where.value.split(",");
-        }
-        if (where.condition === Enums_1.ConditionTypes.Between ||
-            where.condition === Enums_1.ConditionTypes.NotBetween) {
-            where.value = where.value.split(":");
-        }
         if (where.condition === Enums_1.ConditionTypes.LIKE ||
             where.condition === Enums_1.ConditionTypes["NOT LIKE"]) {
             where.value = where.value.replace(/\*/g, "%");

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

@@ -0,0 +1,29 @@
+import { HandlerFunction, PhaseFunction } from "src/Types";
+import { IPhaseDefinition, IRouteData } from "../Interfaces";
+import AxeRequest from "./AxeRequest";
+interface Pair {
+    method: string;
+    pattern: string;
+    data: IRouteData;
+    phases: IPhaseDefinition[];
+    hasTransaction: boolean;
+    params?: any;
+    customHandler?: HandlerFunction;
+}
+declare class URLService {
+    private static urls;
+    static add(method: string, pattern: string, data: IRouteData, middlewares: PhaseFunction[]): Promise<void>;
+    static addHandler(method: string, pattern: string, customHandler: HandlerFunction): Promise<void>;
+    static match(request: AxeRequest): {
+        params: any;
+        method: string;
+        pattern: string;
+        data: IRouteData;
+        phases: IPhaseDefinition[];
+        hasTransaction: boolean;
+        customHandler?: HandlerFunction | undefined;
+    } | undefined;
+    static getAllURLs(): Pair[];
+    private static getDefaultPhases;
+}
+export default URLService;

package/build/src/Services/URLService.js

@@ -0,0 +1,116 @@
+"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 constants_1 = require("../constants");
+const Resolvers_1 = require("../Resolvers");
+const Enums_1 = require("../Enums");
+const check = (url, pattern) => {
+    // Escape special characters in the pattern and replace parameter placeholders with regular expression groups
+    const regexPattern = new RegExp("^" + pattern.replace(/:[a-zA-Z0-9_]+/g, "([a-zA-Z0-9_-]+)") + "$");
+    // Test if the URL matches the pattern
+    const match = url.match(regexPattern);
+    if (match) {
+        // Extract parameter values from the URL
+        const params = {};
+        const paramNames = pattern.match(/:[a-zA-Z0-9_]+/g) || [];
+        paramNames.forEach((param, index) => {
+            const paramName = param.slice(1); // Remove the leading ":"
+            params[paramName] = match[index + 1]; // index + 1 because match[0] is the whole matched string
+        });
+        return params;
+    }
+    return null; // URL does not match the pattern
+};
+class URLService {
+    static add(method, pattern, data, middlewares) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const phases = this.getDefaultPhases(middlewares);
+            if (data.handlerType && data.model) {
+                for (const cycle of constants_1.HANDLER_CYLES[data.handlerType]) {
+                    const item = cycle.get(data.model);
+                    if (item) {
+                        phases.push({
+                            isAsync: cycle.isAsync(),
+                            callback: item,
+                        });
+                    }
+                }
+            }
+            let hasTransaction = false;
+            if (data.version && data.model && data.handlerType) {
+                hasTransaction = yield new Resolvers_1.TransactionResolver(data.version).resolve(data.model, data.handlerType);
+            }
+            this.urls.push({
+                method,
+                pattern,
+                data,
+                phases,
+                hasTransaction,
+            });
+        });
+    }
+    static addHandler(method, pattern, customHandler) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const phases = this.getDefaultPhases([]);
+            const hasTransaction = false;
+            phases.push({
+                isAsync: false,
+                callback: (pack) => {
+                    customHandler(pack.req, pack.res);
+                },
+            });
+            this.urls.push({
+                method,
+                pattern,
+                phases,
+                hasTransaction,
+                customHandler,
+                data: {
+                    version: {},
+                    handlerType: Enums_1.HandlerTypes.INSERT,
+                    model: {},
+                    parentModel: null,
+                    relation: null,
+                },
+            });
+        });
+    }
+    static match(request) {
+        if (!request) {
+            return undefined;
+        }
+        for (const item of URLService.urls) {
+            const found = item.method === request.method &&
+                check(request.url.pathname, item.pattern);
+            if (found) {
+                return Object.assign(Object.assign({}, item), { params: found });
+            }
+        }
+    }
+    static getAllURLs() {
+        return this.urls;
+    }
+    static getDefaultPhases(middlewares) {
+        // Creating the phase array
+        const phases = [
+            // Internal middlewares
+            ...middlewares.map((middleware) => {
+                return {
+                    isAsync: true,
+                    callback: middleware,
+                };
+            }),
+        ];
+        return phases;
+    }
+}
+URLService.urls = [];
+exports.default = URLService;

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

@@ -1,4 +1,5 @@
 import APIService from "./APIService";
+import App from "./App";
 import DocumentationService from "./DocumentationService";
 import IoCService from "./IoCService";
 import { allow, deny } from "./LimitService";
@@ -7,4 +8,6 @@ import ModelListService from "./ModelListService";
 import ModelService from "./ModelService";
 import QueryService from "./QueryService";
 import SchemaValidatorService from "./SchemaValidatorService";
-export { DocumentationService, APIService, IoCService, LogService, ModelListService, ModelService, QueryService, SchemaValidatorService, allow, deny, };
+import AxeRequest from "./AxeRequest";
+import AxeResponse from "./AxeResponse";
+export { App, AxeRequest, AxeResponse, DocumentationService, APIService, IoCService, LogService, ModelListService, ModelService, QueryService, SchemaValidatorService, allow, deny, };

package/build/src/Services/index.js

@@ -3,9 +3,11 @@ 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.SchemaValidatorService = exports.QueryService = exports.ModelService = exports.ModelListService = exports.LogService = exports.IoCService = exports.APIService = exports.DocumentationService = void 0;
+exports.deny = exports.allow = exports.SchemaValidatorService = exports.QueryService = exports.ModelService = exports.ModelListService = exports.LogService = exports.IoCService = exports.APIService = exports.DocumentationService = exports.AxeResponse = exports.AxeRequest = exports.App = void 0;
 const APIService_1 = __importDefault(require("./APIService"));
 exports.APIService = APIService_1.default;
+const App_1 = __importDefault(require("./App"));
+exports.App = App_1.default;
 const DocumentationService_1 = __importDefault(require("./DocumentationService"));
 exports.DocumentationService = DocumentationService_1.default;
 const IoCService_1 = __importDefault(require("./IoCService"));
@@ -23,3 +25,7 @@ const QueryService_1 = __importDefault(require("./QueryService"));
 exports.QueryService = QueryService_1.default;
 const SchemaValidatorService_1 = __importDefault(require("./SchemaValidatorService"));
 exports.SchemaValidatorService = SchemaValidatorService_1.default;
+const AxeRequest_1 = __importDefault(require("./AxeRequest"));
+exports.AxeRequest = AxeRequest_1.default;
+const AxeResponse_1 = __importDefault(require("./AxeResponse"));
+exports.AxeResponse = AxeResponse_1.default;

package/build/src/Types.d.ts

@@ -1,8 +1,9 @@
-import { NextFunction, Request, Response } from "express";
-import { IRequestPack, IHookParameter } from "./Interfaces";
-export type SerializationFunction = (item: any, request: Request) => any;
-export type HandlerFunction = (pack: IRequestPack) => void;
-export type MiddlewareFunction = (req: Request, res: Response, next: NextFunction) => void;
+import { IRequestPack } from "./Interfaces";
+import AxeRequest from "./Services/AxeRequest";
+import AxeResponse from "./Services/AxeResponse";
+export type SerializationFunction = (item: any, request: AxeRequest) => any;
 export type ModelValidation = Record<string, string>;
 export type FieldList = string[];
-export type HookFunction = (pack: IHookParameter) => Promise<void>;
+export type PhaseFunction = (pack: IRequestPack) => void | Promise<void>;
+export type NextFunction = () => void;
+export type HandlerFunction = (request: AxeRequest, response: AxeResponse) => Promise<void> | void;

package/build/src/constants.d.ts

@@ -1,5 +1,6 @@
-import { ConditionTypes, HandlerTypes, QueryFeature, Relationships } from "./Enums";
-import { IVersionConfig } from "./Interfaces";
+import { ConditionTypes, HandlerTypes, HttpMethods, QueryFeature, Relationships } from "./Enums";
+import { IModelService, IVersionConfig } from "./Interfaces";
+import { PhaseFunction } from "./Types";
 export declare const LOG_COLORS: {
     fgBlack: string;
     fgRed: string;
@@ -27,3 +28,10 @@ export declare const API_ROUTE_TEMPLATES: {
 export declare const ConditionQueryFeatureMap: Record<ConditionTypes, QueryFeature>;
 export declare const RelationQueryFeatureMap: Record<Relationships, QueryFeature>;
 export declare const DEFAULT_VERSION_CONFIG: IVersionConfig;
+export declare const NUMERIC_PRIMARY_KEY_TYPES: string[];
+export declare const HANDLER_METHOD_MAP: Record<HandlerTypes, HttpMethods>;
+export interface ICycleDefinition {
+    get(model: IModelService): PhaseFunction;
+    isAsync(): boolean;
+}
+export declare const HANDLER_CYLES: Record<HandlerTypes, ICycleDefinition[]>;

package/build/src/constants.js

@@ -1,8 +1,21 @@
 "use strict";
+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.RelationQueryFeatureMap = exports.ConditionQueryFeatureMap = exports.API_ROUTE_TEMPLATES = exports.DEFAULT_METHODS_OF_MODELS = exports.DEFAULT_HANDLERS = exports.RESERVED_KEYWORDS = exports.LOG_COLORS = void 0;
+exports.HANDLER_CYLES = exports.HANDLER_METHOD_MAP = exports.NUMERIC_PRIMARY_KEY_TYPES = exports.DEFAULT_VERSION_CONFIG = exports.RelationQueryFeatureMap = exports.ConditionQueryFeatureMap = exports.API_ROUTE_TEMPLATES = exports.DEFAULT_METHODS_OF_MODELS = exports.DEFAULT_HANDLERS = exports.RESERVED_KEYWORDS = exports.LOG_COLORS = void 0;
 const Enums_1 = require("./Enums");
 const LimitService_1 = require("./Services/LimitService");
+const Single_1 = __importDefault(require("./Phases/Single"));
+const List_1 = __importDefault(require("./Phases/List"));
+const Paginate_1 = __importDefault(require("./Phases/Paginate"));
+const All_1 = __importDefault(require("./Phases/All"));
+const Show_1 = __importDefault(require("./Phases/Show"));
+const Store_1 = __importDefault(require("./Phases/Store"));
+const Update_1 = __importDefault(require("./Phases/Update"));
+const Patch_1 = __importDefault(require("./Phases/Patch"));
+const Delete_1 = __importDefault(require("./Phases/Delete"));
+const ForceDelete_1 = __importDefault(require("./Phases/ForceDelete"));
 exports.LOG_COLORS = {
     fgBlack: "\x1b[30m",
     fgRed: "\x1b[31m",
@@ -115,3 +128,152 @@ exports.DEFAULT_VERSION_CONFIG = {
         },
     },
 };
+exports.NUMERIC_PRIMARY_KEY_TYPES = ["integer", "bigint"];
+exports.HANDLER_METHOD_MAP = {
+    [Enums_1.HandlerTypes.INSERT]: Enums_1.HttpMethods.POST,
+    [Enums_1.HandlerTypes.PAGINATE]: Enums_1.HttpMethods.GET,
+    [Enums_1.HandlerTypes.SHOW]: Enums_1.HttpMethods.GET,
+    [Enums_1.HandlerTypes.UPDATE]: Enums_1.HttpMethods.PUT,
+    [Enums_1.HandlerTypes.DELETE]: Enums_1.HttpMethods.DELETE,
+    [Enums_1.HandlerTypes.FORCE_DELETE]: Enums_1.HttpMethods.DELETE,
+    [Enums_1.HandlerTypes.PATCH]: Enums_1.HttpMethods.PATCH,
+    [Enums_1.HandlerTypes.ALL]: Enums_1.HttpMethods.GET,
+};
+class Phase {
+    constructor(callback) {
+        this.callback = callback;
+    }
+    get() {
+        return this.callback;
+    }
+    isAsync() {
+        return true;
+    }
+}
+class Hook {
+    constructor(hookFunctionType) {
+        this.hookFunctionType = hookFunctionType;
+    }
+    get(model) {
+        return model.hooks[this.hookFunctionType];
+    }
+    isAsync() {
+        return true;
+    }
+}
+class Event {
+    constructor(hookFunctionType) {
+        this.hookFunctionType = hookFunctionType;
+    }
+    get(model) {
+        return model.events[this.hookFunctionType];
+    }
+    isAsync() {
+        return false;
+    }
+}
+exports.HANDLER_CYLES = {
+    [Enums_1.HandlerTypes.INSERT]: [
+        new Phase(Store_1.default.PreparePhase),
+        new Hook(Enums_1.HookFunctionTypes.onBeforeInsert),
+        new Event(Enums_1.HookFunctionTypes.onBeforeInsert),
+        new Phase(Store_1.default.ActionPhase),
+        new Hook(Enums_1.HookFunctionTypes.onAfterInsert),
+        new Event(Enums_1.HookFunctionTypes.onAfterInsert),
+        new Phase(Single_1.default.SerializePhase),
+        new Phase(Single_1.default.ResultPhase),
+    ],
+    [Enums_1.HandlerTypes.PAGINATE]: [
+        new Phase(Paginate_1.default.PreparePhase),
+        new Hook(Enums_1.HookFunctionTypes.onBeforePaginate),
+        new Event(Enums_1.HookFunctionTypes.onBeforePaginate),
+        new Phase(Paginate_1.default.FetchPhase),
+        new Phase(List_1.default.RelationalPhase),
+        new Hook(Enums_1.HookFunctionTypes.onAfterPaginate),
+        new Event(Enums_1.HookFunctionTypes.onAfterPaginate),
+        new Phase(List_1.default.SerializePhase),
+        new Phase(List_1.default.ResultPhase),
+    ],
+    [Enums_1.HandlerTypes.SHOW]: [
+        new Phase(Show_1.default.PreparePhase),
+        new Hook(Enums_1.HookFunctionTypes.onBeforeShow),
+        new Event(Enums_1.HookFunctionTypes.onBeforeShow),
+        new Phase(Show_1.default.FetchPhase),
+        new Phase(Single_1.default.RelationalPhase),
+        new Hook(Enums_1.HookFunctionTypes.onAfterShow),
+        new Event(Enums_1.HookFunctionTypes.onAfterShow),
+        new Phase(Single_1.default.SerializePhase),
+        new Phase(Single_1.default.ResultPhase),
+    ],
+    [Enums_1.HandlerTypes.UPDATE]: [
+        new Phase(Single_1.default.PrepareGetPhase),
+        new Hook(Enums_1.HookFunctionTypes.onBeforeUpdateQuery),
+        new Event(Enums_1.HookFunctionTypes.onBeforeUpdateQuery),
+        new Phase(Single_1.default.GetPhase),
+        new Hook(Enums_1.HookFunctionTypes.onAfterUpdateQuery),
+        new Event(Enums_1.HookFunctionTypes.onAfterUpdateQuery),
+        new Phase(Update_1.default.PrepareActionPhase),
+        new Hook(Enums_1.HookFunctionTypes.onBeforeUpdate),
+        new Event(Enums_1.HookFunctionTypes.onBeforeUpdate),
+        new Phase(Update_1.default.ActionPhase),
+        new Hook(Enums_1.HookFunctionTypes.onAfterUpdate),
+        new Event(Enums_1.HookFunctionTypes.onAfterUpdate),
+        new Phase(Single_1.default.SerializePhase),
+        new Phase(Single_1.default.ResultPhase),
+    ],
+    [Enums_1.HandlerTypes.DELETE]: [
+        new Phase(Delete_1.default.PreparePhase),
+        new Hook(Enums_1.HookFunctionTypes.onBeforeDeleteQuery),
+        new Event(Enums_1.HookFunctionTypes.onBeforeDeleteQuery),
+        new Phase(Delete_1.default.QueryPhase),
+        new Hook(Enums_1.HookFunctionTypes.onAfterDeleteQuery),
+        new Event(Enums_1.HookFunctionTypes.onAfterDeleteQuery),
+        new Hook(Enums_1.HookFunctionTypes.onBeforeDelete),
+        new Event(Enums_1.HookFunctionTypes.onBeforeDelete),
+        new Phase(Delete_1.default.ActionPhase),
+        new Hook(Enums_1.HookFunctionTypes.onAfterDelete),
+        new Event(Enums_1.HookFunctionTypes.onAfterDelete),
+        new Phase(Delete_1.default.ResponsePhase),
+    ],
+    [Enums_1.HandlerTypes.FORCE_DELETE]: [
+        new Phase(ForceDelete_1.default.PreparePhase),
+        new Hook(Enums_1.HookFunctionTypes.onBeforeForceDeleteQuery),
+        new Event(Enums_1.HookFunctionTypes.onBeforeForceDeleteQuery),
+        new Phase(ForceDelete_1.default.QueryPhase),
+        new Hook(Enums_1.HookFunctionTypes.onAfterForceDeleteQuery),
+        new Event(Enums_1.HookFunctionTypes.onAfterForceDeleteQuery),
+        new Hook(Enums_1.HookFunctionTypes.onBeforeForceDelete),
+        new Event(Enums_1.HookFunctionTypes.onBeforeForceDelete),
+        new Phase(ForceDelete_1.default.ActionPhase),
+        new Hook(Enums_1.HookFunctionTypes.onAfterForceDelete),
+        new Event(Enums_1.HookFunctionTypes.onAfterForceDelete),
+        new Phase(Delete_1.default.ResponsePhase),
+    ],
+    [Enums_1.HandlerTypes.PATCH]: [
+        new Phase(Single_1.default.PrepareGetPhase),
+        new Hook(Enums_1.HookFunctionTypes.onBeforeUpdateQuery),
+        new Event(Enums_1.HookFunctionTypes.onBeforeUpdateQuery),
+        new Phase(Single_1.default.GetPhase),
+        new Hook(Enums_1.HookFunctionTypes.onAfterUpdateQuery),
+        new Event(Enums_1.HookFunctionTypes.onAfterUpdateQuery),
+        new Phase(Patch_1.default.PrepareActionPhase),
+        new Hook(Enums_1.HookFunctionTypes.onBeforeUpdate),
+        new Event(Enums_1.HookFunctionTypes.onBeforeUpdate),
+        new Phase(Update_1.default.ActionPhase),
+        new Hook(Enums_1.HookFunctionTypes.onAfterUpdate),
+        new Event(Enums_1.HookFunctionTypes.onAfterUpdate),
+        new Phase(Single_1.default.SerializePhase),
+        new Phase(Single_1.default.ResultPhase),
+    ],
+    [Enums_1.HandlerTypes.ALL]: [
+        new Phase(Paginate_1.default.PreparePhase),
+        new Hook(Enums_1.HookFunctionTypes.onBeforePaginate),
+        new Event(Enums_1.HookFunctionTypes.onBeforePaginate),
+        new Phase(All_1.default.FetchPhase),
+        new Phase(List_1.default.RelationalPhase),
+        new Hook(Enums_1.HookFunctionTypes.onAfterPaginate),
+        new Event(Enums_1.HookFunctionTypes.onAfterPaginate),
+        new Phase(List_1.default.SerializePhase),
+        new Phase(List_1.default.ResultPhase),
+    ],
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "axe-api",
-  "version": "0.31.3",
+  "version": "1.0.0-rc1",
   "description": "AXE API is a simple tool which has been created based on Express and Knex.js to create Rest APIs quickly.",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -39,14 +39,19 @@
     "lint:watch": "esw --watch --color",
     "prepare:integration": "nodemon --ignore \"./tests/**\" ./scripts/run-integration-test.js",
     "test:postgres": "sh ./scripts/test-postgres.sh",
+    "test:cockroach": "sh ./scripts/test-cockroach.sh",
     "test:mysql57": "sh ./scripts/test-mysql57.sh",
     "test:mysql8": "sh ./scripts/test-mysql8.sh",
+    "test:mariadb": "sh ./scripts/test-mariadb.sh",
+    "test:sqlite": "sh ./scripts/test-sqlite.sh",
     "prettier:check": "prettier --check .",
     "prepare": "husky install"
   },
   "dependencies": {
+    "body-parser": "^1.20.2",
     "chalk": "^4.1.2",
     "change-case": "^4.1.2",
+    "connect": "^3.7.0",
     "dotenv": "^16.3.1",
     "knex": "^2.4.2",
     "knex-paginate": "^3.1.1",
@@ -59,6 +64,8 @@
     "@babel/preset-env": "^7.20.2",
     "@babel/preset-typescript": "^7.21.0",
     "@types/accept-language-parser": "^1.5.3",
+    "@types/aws-lambda": "^8.10.119",
+    "@types/cors": "^2.8.13",
     "@types/express": "^4.17.17",
     "@types/multer": "^1.4.7",
     "@types/pluralize": "^0.0.29",
@@ -66,6 +73,7 @@
     "@typescript-eslint/eslint-plugin": "^5.61.0",
     "@typescript-eslint/parser": "^5.61.0",
     "babel-jest": "^29.5.0",
+    "cors": "^2.8.5",
     "eslint": "^7.32.0",
     "eslint-config-standard": "^16.0.3",
     "eslint-plugin-import": "^2.27.5",

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

@@ -1,3 +0,0 @@
-import { IRequestPack } from "../Interfaces";
-declare const _default: (pack: IRequestPack) => Promise<import("express").Response<any, Record<string, any>>>;
-export default _default;

package/build/src/Handlers/AllHandler.js

@@ -1,45 +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 Helpers_1 = require("./Helpers");
-const Services_1 = require("../Services");
-const Enums_1 = require("../Enums");
-exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
-    const { version, model, req, res, database, relation, parentModel } = pack;
-    const queryParser = new Services_1.QueryService(model, version.modelList.get(), version.config);
-    // We should parse URL query string to use as condition in Lucid query
-    const conditions = queryParser.get(req.query);
-    // Creating a new database query
-    const query = database.from(model.instance.table);
-    // If there is a deletedAtColumn, it means that this table support soft-delete
-    (0, Helpers_1.addSoftDeleteQuery)(model, conditions, query);
-    // Users should be able to select some fields to show.
-    queryParser.applyFields(query, conditions.fields);
-    // Binding parent id if there is.
-    (0, Helpers_1.addForeignKeyQuery)(req, query, relation, parentModel);
-    // Users should be able to filter records
-    queryParser.applyWheres(query, conditions.q);
-    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeAll, Object.assign(Object.assign({}, pack), { conditions,
-        query }));
-    // User should be able to select sorting fields and types
-    queryParser.applySorting(query, conditions.sort);
-    let result = yield query;
-    // We should try to get related data if there is any
-    yield (0, Helpers_1.getRelatedData)(version, result, conditions.with, model, version.modelList, database, Enums_1.HandlerTypes.ALL, req);
-    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterAll, Object.assign(Object.assign({}, pack), { result,
-        conditions,
-        query }));
-    // Serializing the data by the model's serialize method
-    result = yield (0, Helpers_1.serializeData)(version, result, model.serialize, Enums_1.HandlerTypes.ALL, req);
-    // Filtering hidden fields from the response data.
-    (0, Helpers_1.filterHiddenFields)(result, model.instance.hiddens);
-    return res.json(result);
-});

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

@@ -1,3 +0,0 @@
-import { IRequestPack } from "../Interfaces";
-declare const _default: (pack: IRequestPack) => Promise<import("express").Response<any, Record<string, any>>>;
-export default _default;

package/build/src/Handlers/DestroyHandler.js

@@ -1,51 +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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Helpers_1 = require("./Helpers");
-const Enums_1 = require("../Enums");
-const ApiError_1 = __importDefault(require("../Exceptions/ApiError"));
-exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
-    const { model, req, res, database, relation, parentModel } = pack;
-    // We should check the parameter type
-    const value = req.params[model.instance.primaryKey];
-    (0, Helpers_1.checkPrimaryKeyValueType)(model, value);
-    // Adding the main query
-    const query = database
-        .from(model.instance.table)
-        .where(model.instance.primaryKey, value);
-    // If there is a deletedAtColumn, it means that this table support soft-delete
-    (0, Helpers_1.addSoftDeleteQuery)(model, null, query);
-    // If there is a relation, we should bind it
-    (0, Helpers_1.addForeignKeyQuery)(req, query, relation, parentModel);
-    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeDeleteQuery, Object.assign(Object.assign({}, pack), { query }));
-    const item = yield query.first();
-    if (!item) {
-        throw new ApiError_1.default(`The item is not found on ${model.name}.`, Enums_1.StatusCodes.NOT_FOUND);
-    }
-    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterDeleteQuery, Object.assign(Object.assign({}, pack), { query,
-        item }));
-    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeDelete, Object.assign(Object.assign({}, pack), { query,
-        item }));
-    // If there is a deletedAtColumn, it means that this table support soft-delete
-    if (model.instance.deletedAtColumn) {
-        yield query.update({
-            [model.instance.deletedAtColumn]: new Date(),
-        });
-    }
-    else {
-        yield query.delete();
-    }
-    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterDelete, Object.assign(Object.assign({}, pack), { item }));
-    return res.json();
-});

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

@@ -1,3 +0,0 @@
-import { IRequestPack } from "../Interfaces";
-declare const _default: (pack: IRequestPack) => Promise<import("express").Response<any, Record<string, any>>>;
-export default _default;