axe-api 1.0.0-rc4 → 1.0.0-rc6

package/build/src/Handlers/RequestHandler.js

@@ -14,40 +14,15 @@ var __importDefault = (this && this.__importDefault) || function (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 ConverterService_1 = require("../Services/ConverterService");
 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* () {
-    Services_1.LogService.debug(`${request.method} ${request.url}`);
-    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) {
-        Services_1.LogService.warn(`The URL is not matched! ${request.method} ${request.url}`);
-        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) {
-        Services_1.LogService.warn("\tDB transaction created");
-        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) {
+const callPhases = (phases, pack, match, trx, axeResponse) => __awaiter(void 0, void 0, void 0, function* () {
+    for (const phase of phases) {
         // If there is an non-async phase, it should be an Event function
         if (phase.isAsync === false) {
             Services_1.LogService.debug(`\t${phase.name}()`);
@@ -100,3 +75,25 @@ exports.default = (request, response) => __awaiter(void 0, void 0, void 0, funct
         break;
     }
 });
+exports.default = (request, response) => __awaiter(void 0, void 0, void 0, function* () {
+    Services_1.LogService.debug(`${request.method} ${request.url}`);
+    const { axeRequest, axeResponse } = (0, ConverterService_1.toAxeRequestResponsePair)(request, response);
+    const match = URLService_1.default.match(axeRequest);
+    if (!match) {
+        Services_1.LogService.warn(`The URL is not matched! ${request.method} ${request.url}`);
+        return return404(response);
+    }
+    // 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) {
+        Services_1.LogService.warn("\tDB transaction created");
+        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");
+    yield callPhases(match.phases, pack, match, trx, axeResponse);
+});

package/build/src/Interfaces.d.ts

@@ -4,7 +4,7 @@ import { Knex } from "knex";
 import { Column } from "knex-schema-inspector/lib/types/column";
 import { HandlerTypes, HttpMethods, HookFunctionTypes, Extensions, Relationships, SortTypes, ConditionTypes, DependencyTypes, QueryFeature, QueryFeatureType } from "./Enums";
 import Model from "./Model";
-import { AdaptorTypes, PhaseFunction, SerializationFunction } from "./Types";
+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";
@@ -111,7 +111,7 @@ export interface IGeneralHooks {
 }
 export interface IHandlerBaseMiddleware {
     handler: HandlerTypes[];
-    middleware: PhaseFunction;
+    middleware: StepTypes;
 }
 export interface IMethodBaseConfig {
     [HttpMethods.POST]?: string[];
@@ -128,8 +128,8 @@ export interface IModelService {
     relations: IRelation[];
     columns: IColumn[];
     columnNames: string[];
-    hooks: Record<HookFunctionTypes, PhaseFunction>;
-    events: Record<HookFunctionTypes, PhaseFunction>;
+    hooks: HookFunctions;
+    events: HookFunctions;
     isRecursive: boolean;
     children: IModelService[];
     queryLimits: IQueryLimitConfig[];
@@ -229,4 +229,12 @@ export interface IPhaseDefinition {
     isAsync: boolean;
     callback: PhaseFunction;
 }
+export interface AxeRequestResponsePair {
+    axeRequest: AxeRequest;
+    axeResponse: AxeResponse;
+}
+export interface MiddlewareResolution {
+    middlewares: MiddlewareFunction[];
+    handler: HandlerFunction;
+}
 export {};

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, ModelValidation, PhaseFunction } 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(): PhaseFunction[] | 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): PhaseFunction[];
+    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/Services/App.d.ts

@@ -1,14 +1,14 @@
 import connect from "connect";
-import { HandlerFunction } from "../Types";
+import { DynamicFunctionType } from "../Types";
 declare class App {
     private connect;
     constructor();
     get instance(): connect.Server;
     use(middleware: connect.NextHandleFunction): void;
-    get(url: string, handler: HandlerFunction): void;
-    post(url: string, handler: HandlerFunction): void;
-    put(url: string, handler: HandlerFunction): void;
-    patch(url: string, handler: HandlerFunction): void;
-    delete(url: string, handler: HandlerFunction): void;
+    get(url: string, ...args: DynamicFunctionType): void;
+    post(url: string, ...args: DynamicFunctionType): void;
+    put(url: string, ...args: DynamicFunctionType): void;
+    patch(url: string, ...args: DynamicFunctionType): void;
+    delete(url: string, ...args: DynamicFunctionType): void;
 }
 export default App;

package/build/src/Services/App.js

@@ -32,6 +32,7 @@ const URLService_1 = __importDefault(require("./URLService"));
 const LogService_1 = __importDefault(require("./LogService"));
 const RateLimit_1 = __importStar(require("../Middlewares/RateLimit"));
 const APIService_1 = __importDefault(require("./APIService"));
+const ConverterService_1 = require("./ConverterService");
 class App {
     constructor() {
         var _a;
@@ -55,20 +56,25 @@ class App {
         this.connect.use(middleware);
         LogService_1.default.debug(`New middleware: ${middleware.name || "anonymous"}()`);
     }
-    get(url, handler) {
-        URLService_1.default.addHandler("GET", url, handler);
+    get(url, ...args) {
+        const { handler, middlewares } = (0, ConverterService_1.resolveMiddlewares)(args);
+        URLService_1.default.addHandler("GET", url, handler, middlewares);
     }
-    post(url, handler) {
-        URLService_1.default.addHandler("POST", url, handler);
+    post(url, ...args) {
+        const { handler, middlewares } = (0, ConverterService_1.resolveMiddlewares)(args);
+        URLService_1.default.addHandler("POST", url, handler, middlewares);
     }
-    put(url, handler) {
-        URLService_1.default.addHandler("PUT", url, handler);
+    put(url, ...args) {
+        const { handler, middlewares } = (0, ConverterService_1.resolveMiddlewares)(args);
+        URLService_1.default.addHandler("PUT", url, handler, middlewares);
     }
-    patch(url, handler) {
-        URLService_1.default.addHandler("PATCH", url, handler);
+    patch(url, ...args) {
+        const { handler, middlewares } = (0, ConverterService_1.resolveMiddlewares)(args);
+        URLService_1.default.addHandler("PATCH", url, handler, middlewares);
     }
-    delete(url, handler) {
-        URLService_1.default.addHandler("DELETE", url, handler);
+    delete(url, ...args) {
+        const { handler, middlewares } = (0, ConverterService_1.resolveMiddlewares)(args);
+        URLService_1.default.addHandler("DELETE", url, handler, middlewares);
     }
 }
 exports.default = App;

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

@@ -0,0 +1,9 @@
+import { IncomingMessage, ServerResponse } from "http";
+import { AxeRequestResponsePair, MiddlewareResolution } from "../Interfaces";
+import { DynamicFunctionType, PhaseFunction, StepTypes } from "src/Types";
+export declare const toAxeRequestResponsePair: (request: IncomingMessage, response: ServerResponse) => AxeRequestResponsePair;
+export declare const resolveMiddlewares: (args: DynamicFunctionType) => MiddlewareResolution;
+export declare const isMiddlewareFunction: (callback: any) => boolean;
+export declare const isHandlerFunction: (callback: any) => boolean;
+export declare const isPhaseFunction: (callback: any) => boolean;
+export declare const toPhaseFunction: (callback: StepTypes) => PhaseFunction;

package/build/src/Services/ConverterService.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPhaseFunction = exports.isPhaseFunction = exports.isHandlerFunction = exports.isMiddlewareFunction = exports.resolveMiddlewares = exports.toAxeRequestResponsePair = void 0;
+const util_1 = require("util");
+const AxeRequest_1 = __importDefault(require("./AxeRequest"));
+const AxeResponse_1 = __importDefault(require("./AxeResponse"));
+const toAxeRequestResponsePair = (request, response) => {
+    const axeRequest = new AxeRequest_1.default(request);
+    const axeResponse = new AxeResponse_1.default(response, axeRequest.currentLanguage);
+    return {
+        axeRequest,
+        axeResponse,
+    };
+};
+exports.toAxeRequestResponsePair = toAxeRequestResponsePair;
+const resolveMiddlewares = (args) => {
+    const middlewares = args.slice(0, -1);
+    const handler = args.at(-1);
+    return {
+        middlewares,
+        handler,
+    };
+};
+exports.resolveMiddlewares = resolveMiddlewares;
+const isMiddlewareFunction = (callback) => {
+    return callback.length === 3;
+};
+exports.isMiddlewareFunction = isMiddlewareFunction;
+const isHandlerFunction = (callback) => {
+    return callback.length === 2;
+};
+exports.isHandlerFunction = isHandlerFunction;
+const isPhaseFunction = (callback) => {
+    return callback.length === 1;
+};
+exports.isPhaseFunction = isPhaseFunction;
+const toPhaseFunction = (callback) => {
+    if ((0, exports.isMiddlewareFunction)(callback)) {
+        return (0, util_1.promisify)((context, next) => callback(context.req.original, context.res.original, next));
+    }
+    if ((0, exports.isHandlerFunction)(callback)) {
+        return (context) => callback(context.req, context.res);
+    }
+    return callback;
+};
+exports.toPhaseFunction = toPhaseFunction;

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

@@ -1,15 +1,15 @@
 import { HookFunctionTypes, Extensions } from "../Enums";
 import { IColumn, IModelService, IQueryLimitConfig, IRelation } from "../Interfaces";
 import Model from "./../Model";
-import { PhaseFunction, SerializationFunction } from "../Types";
+import { HookFunctions, PhaseFunction, SerializationFunction } from "../Types";
 declare class ModelService implements IModelService {
     name: string;
     instance: Model;
     relations: IRelation[];
     columns: IColumn[];
     columnNames: string[];
-    hooks: Record<HookFunctionTypes, PhaseFunction>;
-    events: Record<HookFunctionTypes, PhaseFunction>;
+    hooks: HookFunctions;
+    events: HookFunctions;
     children: IModelService[];
     isRecursive: boolean;
     queryLimits: IQueryLimitConfig[];

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

@@ -1,4 +1,4 @@
-import { HandlerFunction, PhaseFunction } from "src/Types";
+import { HandlerFunction, MiddlewareFunction, StepTypes } from "../Types";
 import { IPhaseDefinition, IRouteData } from "../Interfaces";
 import AxeRequest from "./AxeRequest";
 interface Pair {
@@ -12,8 +12,8 @@ interface Pair {
 }
 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 add(method: string, pattern: string, data: IRouteData, middlewares: StepTypes[]): Promise<void>;
+    static addHandler(method: string, pattern: string, customHandler: HandlerFunction, middlewares: MiddlewareFunction[]): Promise<void>;
     static match(request: AxeRequest): {
         params: any;
         method: string;

package/build/src/Services/URLService.js

@@ -12,10 +12,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("util");
 const constants_1 = require("../constants");
 const Resolvers_1 = require("../Resolvers");
 const Enums_1 = require("../Enums");
 const LogService_1 = __importDefault(require("./LogService"));
+const ConverterService_1 = require("./ConverterService");
 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_-]+)") + "$");
@@ -63,17 +65,26 @@ class URLService {
             });
         });
     }
-    static addHandler(method, pattern, customHandler) {
+    static addHandler(method, pattern, customHandler, middlewares) {
         return __awaiter(this, void 0, void 0, function* () {
             LogService_1.default.info(`${method} ${pattern}`);
-            const phases = this.getDefaultPhases([]);
+            const phases = middlewares.map((middleware) => {
+                return {
+                    isAsync: false,
+                    name: `middleware:test`,
+                    callback: (pack) => __awaiter(this, void 0, void 0, function* () {
+                        const caller = (0, util_1.promisify)((pack, next) => middleware(pack.req.original, pack.res.original, next));
+                        yield caller(pack);
+                    }),
+                };
+            });
             const hasTransaction = false;
             phases.push({
                 isAsync: false,
                 name: "customHandler",
-                callback: (pack) => {
+                callback: (pack) => __awaiter(this, void 0, void 0, function* () {
                     customHandler(pack.req, pack.res);
-                },
+                }),
             });
             this.urls.push({
                 method,
@@ -107,14 +118,15 @@ class URLService {
         return this.urls;
     }
     static getDefaultPhases(middlewares) {
-        // Creating the phase array
+        // We should convert to all StepTypes functions to PhaseFunctions
+        const callbacks = middlewares.map(ConverterService_1.toPhaseFunction);
         const phases = [
             // Internal middlewares
-            ...middlewares.map((middleware) => {
+            ...callbacks.map((callback) => {
                 return {
                     isAsync: true,
-                    name: `middleware:${middleware.name || "anonymous"}`,
-                    callback: middleware,
+                    name: `middleware:${callback.name || "anonymous"}`,
+                    callback,
                 };
             }),
         ];

package/build/src/Types.d.ts

@@ -1,10 +1,20 @@
-import { IRequestPack } from "./Interfaces";
+/// <reference types="node" />
+/// <reference types="express" />
+import { IncomingMessage, ServerResponse } from "http";
+import { IHandlerBaseMiddleware, IRequestPack } from "./Interfaces";
 import AxeRequest from "./Services/AxeRequest";
 import AxeResponse from "./Services/AxeResponse";
-export type SerializationFunction = (item: any, request: AxeRequest) => any;
+import { HookFunctionTypes } from "./Enums";
 export type ModelValidation = Record<string, string>;
 export type FieldList = string[];
-export type PhaseFunction = (pack: IRequestPack) => void | Promise<void>;
-export type NextFunction = () => void;
-export type HandlerFunction = (request: AxeRequest, response: AxeResponse) => Promise<void> | void;
+export type DefaultResponse = Promise<void> | void | undefined;
 export type AdaptorTypes = "redis" | "memory";
+export type MiddlewareFunction = (req: IncomingMessage, res: ServerResponse, next: NextFunction) => DefaultResponse;
+export type HandlerFunction = (request: AxeRequest, response: AxeResponse) => DefaultResponse;
+export type PhaseFunction = (pack: IRequestPack) => DefaultResponse;
+export type SerializationFunction = (item: any, request: AxeRequest) => any;
+export type HookFunctions = Record<HookFunctionTypes, PhaseFunction>;
+export type NextFunction = (error: any) => void;
+export type DynamicFunctionType = (MiddlewareFunction | HandlerFunction)[];
+export type StepTypes = MiddlewareFunction | HandlerFunction | PhaseFunction;
+export type ModelMiddlewareDefinition = Array<StepTypes | IHandlerBaseMiddleware>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "axe-api",
-  "version": "1.0.0-rc4",
+  "version": "1.0.0-rc6",
   "description": "AXE API is a simple tool to create Rest APIs quickly.",
   "main": "build/index.js",
   "types": "build/index.d.ts",