axe-api 0.22.0 → 0.30.0-rc10

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

@@ -1,15 +1,17 @@
 import { Request } from "express";
-import { IModelService, IRelation, IHookParameter, IQuery } from "../Interfaces";
+import { IModelService, IRelation, IHookParameter, IQuery, IVersion } from "../Interfaces";
 import { Knex } from "knex";
 import { IWith } from "../Interfaces";
 import { HandlerTypes, HookFunctionTypes, TimestampColumns } from "../Enums";
 import { ModelListService } from "../Services";
+import { SerializationFunction } from "../Types";
 export declare const bindTimestampValues: (formData: Record<string, any>, columnTypes: TimestampColumns[] | undefined, model: IModelService) => 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 getParentColumn: (relation: IRelation | null) => string | null;
 export declare const addForeignKeyQuery: (request: Request, query: Knex.QueryBuilder, relation: IRelation | null, parentModel: IModelService | null) => void;
-export declare const serializeData: (itemArray: any[] | any, modelSerializer: (data: any, request: Request) => void, handler: HandlerTypes, request: Request) => Promise<any[]>;
+export declare const serializeData: (version: IVersion, itemArray: any[] | any, modelSerializer: SerializationFunction | null, handler: HandlerTypes, request: Request) => 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: (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: Request) => Promise<void>;
+export declare const isBoolean: (value: any) => boolean;

package/build/src/Handlers/Helpers.js

@@ -12,11 +12,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRelatedData = exports.addSoftDeleteQuery = exports.filterHiddenFields = exports.serializeData = exports.addForeignKeyQuery = exports.getParentColumn = exports.callHooks = exports.getMergedFormData = exports.bindTimestampValues = void 0;
+exports.isBoolean = exports.getRelatedData = exports.addSoftDeleteQuery = exports.filterHiddenFields = exports.serializeData = exports.addForeignKeyQuery = exports.getParentColumn = exports.callHooks = exports.getMergedFormData = exports.bindTimestampValues = void 0;
 const change_case_1 = require("change-case");
 const Enums_1 = require("../Enums");
 const ApiError_1 = __importDefault(require("../Exceptions/ApiError"));
 const Services_1 = require("../Services");
+const LimitService_1 = require("../Services/LimitService");
+const constants_1 = require("../constants");
 const bindTimestampValues = (formData, columnTypes = [], model) => {
     if (columnTypes.includes(Enums_1.TimestampColumns.CREATED_AT) &&
         model.instance.createdAtColumn) {
@@ -30,7 +32,7 @@ const bindTimestampValues = (formData, columnTypes = [], model) => {
 exports.bindTimestampValues = bindTimestampValues;
 const getMergedFormData = (req, fillables) => {
     const formData = {};
-    Object.keys(req.body).forEach((key) => {
+    Object.keys((req === null || req === void 0 ? void 0 : req.body) || {}).forEach((key) => {
         if (fillables.includes(key)) {
             formData[key] = req.body[key];
         }
@@ -92,14 +94,13 @@ const serialize = (data, callback, request) => {
     }
     return callback(data, request);
 };
-const globalSerializer = (itemArray, handler, request) => __awaiter(void 0, void 0, void 0, function* () {
-    const Application = yield Services_1.IoCService.useByType("Config");
-    if (!Application.serializers) {
+const globalSerializer = (version, itemArray, handler, request) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!version.config.serializers) {
         return itemArray;
     }
     const callbacks = [];
     // Push all runable serializer into callbacks.
-    Application.serializers.map((configSerializer) => {
+    version.config.serializers.map((configSerializer) => {
         // Serialize data for all requests types.
         if (typeof configSerializer === "function") {
             callbacks.push(configSerializer);
@@ -116,9 +117,9 @@ const globalSerializer = (itemArray, handler, request) => __awaiter(void 0, void
     });
     return itemArray;
 });
-const serializeData = (itemArray, modelSerializer, handler, request) => __awaiter(void 0, void 0, void 0, function* () {
+const serializeData = (version, itemArray, modelSerializer, handler, request) => __awaiter(void 0, void 0, void 0, function* () {
     itemArray = serialize(itemArray, modelSerializer, request);
-    itemArray = yield globalSerializer(itemArray, handler, request);
+    itemArray = yield globalSerializer(version, itemArray, handler, request);
     return itemArray;
 });
 exports.serializeData = serializeData;
@@ -139,14 +140,16 @@ const filterHiddenFields = (itemArray, hiddens) => {
 };
 exports.filterHiddenFields = filterHiddenFields;
 const addSoftDeleteQuery = (model, conditions, query) => {
-    // TODO: Trashed feature will be implemented later
-    // (conditions === null || conditions?.trashed === false)
+    if (conditions !== null && (conditions === null || conditions === void 0 ? void 0 : conditions.trashed) === true) {
+        (0, LimitService_1.valideteQueryFeature)(model, Enums_1.QueryFeature.Trashed);
+        return;
+    }
     if (model.instance.deletedAtColumn) {
         query.whereNull(model.instance.deletedAtColumn);
     }
 };
 exports.addSoftDeleteQuery = addSoftDeleteQuery;
-const getRelatedData = (data, withArray, model, modelList, database, handler, request) => __awaiter(void 0, void 0, void 0, function* () {
+const getRelatedData = (version, data, withArray, model, modelList, database, handler, request) => __awaiter(void 0, void 0, void 0, function* () {
     if (withArray.length === 0) {
         return;
     }
@@ -163,6 +166,8 @@ const getRelatedData = (data, withArray, model, modelList, database, handler, re
         if (!foreignModel) {
             continue;
         }
+        // Validating the query limit
+        (0, LimitService_1.valideteQueryFeature)(model, constants_1.RelationQueryFeatureMap[definedRelation.type], `${model.instance.table}.${definedRelation.name}`, `${model.instance.table}.${definedRelation.name}`);
         let dataField = "primaryKey";
         let searchField = "foreignKey";
         if (definedRelation.type !== Enums_1.Relationships.HAS_MANY) {
@@ -208,12 +213,12 @@ const getRelatedData = (data, withArray, model, modelList, database, handler, re
         // Fetching related records by foreignKey and primary key values.
         let relatedRecords = yield foreignModelQuery.whereIn(searchFieldKey, parentPrimaryKeyValues);
         // We should serialize related data if there is any serialization function
-        relatedRecords = yield (0, exports.serializeData)(relatedRecords, foreignModel.instance.serialize, handler, request);
+        relatedRecords = yield (0, exports.serializeData)(version, relatedRecords, foreignModel.serialize, handler, request);
         // We should hide hidden fields if there is any
         (0, exports.filterHiddenFields)(relatedRecords, foreignModel.instance.hiddens);
         // We should try to get child data if there is any on the query
         if (clientQuery.children.length > 0) {
-            yield (0, exports.getRelatedData)(relatedRecords, clientQuery.children, foreignModel, modelList, database, handler, request);
+            yield (0, exports.getRelatedData)(version, relatedRecords, clientQuery.children, foreignModel, modelList, database, handler, request);
         }
         // Binding relation data to the parent rows.
         data.forEach((row) => {
@@ -226,3 +231,14 @@ const getRelatedData = (data, withArray, model, modelList, database, handler, re
     }
 });
 exports.getRelatedData = getRelatedData;
+const isBoolean = (value) => {
+    if (value === undefined || value === null) {
+        return false;
+    }
+    value = (value || "").trim().toLocaleLowerCase();
+    if (value === "true" || value === "1" || value === "on" || value === "yes") {
+        return true;
+    }
+    return false;
+};
+exports.isBoolean = isBoolean;

package/build/src/Handlers/PaginateHandler.js

@@ -13,9 +13,8 @@ const Helpers_1 = require("./Helpers");
 const Enums_1 = require("../Enums");
 const Services_1 = require("../Services");
 exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
-    const modelList = yield Services_1.IoCService.useByType("ModelListService");
-    const { model, req, database, relation, parentModel } = pack;
-    const queryParser = new Services_1.QueryService(model, modelList.get());
+    const { version, model, req, 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
@@ -38,12 +37,12 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
         isLengthAware: true,
     });
     // We should try to get related data if there is any
-    yield (0, Helpers_1.getRelatedData)(result.data, conditions.with, model, modelList, database, Enums_1.HandlerTypes.PAGINATE, req);
+    yield (0, Helpers_1.getRelatedData)(version, result.data, conditions.with, model, version.modelList, database, Enums_1.HandlerTypes.PAGINATE, req);
     yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterPaginate, Object.assign(Object.assign({}, pack), { conditions,
         result,
         query }));
     // Serializing the data by the model's serialize method
-    result.data = yield (0, Helpers_1.serializeData)(result.data, model.instance.serialize, Enums_1.HandlerTypes.PAGINATE, req);
+    result.data = yield (0, Helpers_1.serializeData)(version, result.data, model.serialize, Enums_1.HandlerTypes.PAGINATE, req);
     // Filtering hidden fields from the response data.
     (0, Helpers_1.filterHiddenFields)(result.data, model.instance.hiddens);
     return pack.res.json(result);

package/build/src/Handlers/PatchHandler.js

@@ -17,7 +17,7 @@ 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;
+    const { version, model, req, res, database, relation, parentModel } = pack;
     const query = database.from(model.instance.table);
     // If there is a relation, we should bind it
     (0, Helpers_1.addForeignKeyQuery)(req, query, relation, parentModel);
@@ -60,7 +60,7 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
         formData,
         query }));
     // Serializing the data by the model's serialize method
-    item = yield (0, Helpers_1.serializeData)(item, model.instance.serialize, Enums_1.HandlerTypes.PATCH, req);
+    item = yield (0, Helpers_1.serializeData)(version, item, model.serialize, Enums_1.HandlerTypes.PATCH, req);
     // Filtering hidden fields from the response data.
     (0, Helpers_1.filterHiddenFields)([item], model.instance.hiddens);
     return res.json(item);

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

@@ -0,0 +1,3 @@
+import { Request, Response } from "express";
+declare const _default: (req: Request, res: Response) => Promise<void>;
+export default _default;

package/build/src/Handlers/RoutesHandler.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 });
+const Services_1 = require("../Services");
+exports.default = (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const docs = Services_1.DocumentationService.getInstance();
+    res.json(docs.get().map((route) => `${route.method} ${route.url}`));
+});

package/build/src/Handlers/ShowHandler.js

@@ -17,9 +17,8 @@ const Enums_1 = require("../Enums");
 const ApiError_1 = __importDefault(require("../Exceptions/ApiError"));
 const Services_1 = require("../Services");
 exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
-    const modelList = yield Services_1.IoCService.useByType("ModelListService");
-    const { model, req, res, database, relation, parentModel } = pack;
-    const queryParser = new Services_1.QueryService(model, modelList.get());
+    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);
     // Fetching item
@@ -41,12 +40,12 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
         throw new ApiError_1.default(`The item is not found on ${model.name}.`);
     }
     // We should try to get related data if there is any
-    yield (0, Helpers_1.getRelatedData)([item], conditions.with, model, modelList, database, Enums_1.HandlerTypes.ALL, req);
+    yield (0, Helpers_1.getRelatedData)(version, [item], conditions.with, model, version.modelList, database, Enums_1.HandlerTypes.ALL, req);
     yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterShow, Object.assign(Object.assign({}, pack), { query,
         conditions,
         item }));
     // Serializing the data by the model's serialize method
-    item = yield (0, Helpers_1.serializeData)(item, model.instance.serialize, Enums_1.HandlerTypes.SHOW, req);
+    item = yield (0, Helpers_1.serializeData)(version, item, model.serialize, Enums_1.HandlerTypes.SHOW, req);
     // Filtering hidden fields from the response data.
     (0, Helpers_1.filterHiddenFields)([item], model.instance.hiddens);
     return res.json(item);

package/build/src/Handlers/StoreHandler.js

@@ -16,7 +16,7 @@ const validatorjs_1 = __importDefault(require("validatorjs"));
 const Helpers_1 = require("./Helpers");
 const Enums_1 = require("../Enums");
 exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
-    const { model, req, res, database, relation, parentModel } = pack;
+    const { version, model, req, res, database, relation, parentModel } = pack;
     const requestMethod = req.method;
     const fillables = model.instance.getFillableFields(requestMethod);
     const formData = (0, Helpers_1.getMergedFormData)(req, fillables);
@@ -55,7 +55,7 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
     yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterInsert, Object.assign(Object.assign({}, pack), { formData,
         item }));
     // Serializing the data by the model's serialize method
-    item = yield (0, Helpers_1.serializeData)(item, model.instance.serialize, Enums_1.HandlerTypes.INSERT, req);
+    item = yield (0, Helpers_1.serializeData)(version, item, model.serialize, Enums_1.HandlerTypes.INSERT, req);
     // Filtering hidden fields from the response data.
     (0, Helpers_1.filterHiddenFields)([item], model.instance.hiddens);
     return res.json(item);

package/build/src/Handlers/UpdateHandler.js

@@ -17,7 +17,7 @@ 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;
+    const { version, model, req, res, database, relation, parentModel } = pack;
     const query = database.from(model.instance.table);
     // If there is a relation, we should bind it
     (0, Helpers_1.addForeignKeyQuery)(req, query, relation, parentModel);
@@ -60,7 +60,7 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
         formData,
         query }));
     // Serializing the data by the model's serialize method
-    item = yield (0, Helpers_1.serializeData)(item, model.instance.serialize, Enums_1.HandlerTypes.UPDATE, req);
+    item = yield (0, Helpers_1.serializeData)(version, item, model.serialize, Enums_1.HandlerTypes.UPDATE, req);
     // Filtering hidden fields from the response data.
     (0, Helpers_1.filterHiddenFields)([item], model.instance.hiddens);
     return res.json(item);

package/build/src/Helpers.d.ts

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

package/build/src/Helpers.js

@@ -0,0 +1,78 @@
+"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.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* () {
+    // 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;
+    });
+    if (!matchedVersion) {
+        throw new Error(`Version is not matched: ${req.path}`);
+    }
+    return matchedVersion;
+});
+exports.getVersionByRequest = getVersionByRequest;
+const consoleAxeError = (error) => {
+    const putWithSpace = (text, max) => {
+        const diff = max - text.length + 3;
+        for (let index = 0; index <= diff; index++) {
+            text = `${text} `;
+        }
+        text = `   ${text}`;
+        if (text.length > 77) {
+            let lines = [];
+            text = text.trim();
+            for (let step = 0; step < text.length / 70; step++) {
+                lines.push(text.substring(0, 70));
+                text = text.substring(70);
+            }
+            lines.push(text);
+            lines = lines.map((line) => putWithSpace(line, max));
+            return lines.flat();
+        }
+        return [text];
+    };
+    const getMaxLength = (code, message) => {
+        let maxLength = message.length;
+        if (code.length > message.length) {
+            maxLength = code.length;
+        }
+        if (maxLength > 70) {
+            maxLength = 70;
+        }
+        return maxLength;
+    };
+    const maxLength = getMaxLength(error.code, error.message);
+    const messages = [
+        "\n",
+        ...putWithSpace(" ", maxLength),
+        ...putWithSpace(`[${error.code}]`, maxLength),
+        ...putWithSpace(" ", maxLength),
+        ...putWithSpace(error.message, maxLength),
+        ...putWithSpace(" ", maxLength),
+    ];
+    console.log(chalk_1.default.bgRed.white(messages.join("\n")));
+    console.log(chalk_1.default.cyan([
+        "\n",
+        "You can find more in the documentation;",
+        `https://axe-api.com/errors.html#${(0, change_case_1.paramCase)(error.code)}`,
+    ].join("\n")));
+};
+exports.consoleAxeError = consoleAxeError;

package/build/src/Interfaces.d.ts

@@ -1,8 +1,10 @@
 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 } from "./Enums";
+import { HandlerTypes, LogLevels, HttpMethods, HookFunctionTypes, Extensions, Relationships, SortTypes, ConditionTypes, DependencyTypes, QueryFeature, QueryFeatureType } from "./Enums";
 import Model from "./Model";
+import { SerializationFunction } from "./Types";
+import { ModelListService } from "./Services";
 export interface IColumn extends Column {
     table_name: string;
 }
@@ -16,15 +18,33 @@ interface IHandlerBasedSerializer {
     handler: HandlerTypes[];
     serializer: ((data: any, request: Request) => void)[];
 }
+export interface IQueryLimitConfig {
+    feature: QueryFeature;
+    type: QueryFeatureType;
+    key: string | null;
+}
+export interface IQueryDefaultConfig {
+    perPage?: number;
+    minPerPage?: number;
+    maxPerPage?: number;
+}
+export interface IQueryConfig {
+    limits: Array<IQueryLimitConfig[]>;
+    defaults?: IQueryDefaultConfig;
+}
+export interface IVersionConfig {
+    transaction: boolean | IHandlerBasedTransactionConfig | IHandlerBasedTransactionConfig[];
+    serializers: ((data: any, request: Request) => void)[] | IHandlerBasedSerializer[];
+    supportedLanguages: string[];
+    defaultLanguage: string;
+    query: IQueryConfig;
+}
 export interface IApplicationConfig extends IConfig {
     env: string;
     port: number;
     logLevel: LogLevels;
     prefix: string;
-    transaction: boolean | IHandlerBasedTransactionConfig | IHandlerBasedTransactionConfig[];
-    serializers: ((data: any, request: Request) => void)[] | IHandlerBasedSerializer[];
-    supportedLanguages: string[];
-    defaultLanguage: string;
+    database: IDatabaseConfig;
 }
 export interface ILanguage {
     title: string;
@@ -35,14 +55,28 @@ export interface IAcceptedLanguage {
     language: ILanguage;
     quality: number;
 }
-export declare type IDatabaseConfig = Knex.Config;
-export interface IFolders {
-    App: string;
-    Config: string;
-    Events: string;
-    Hooks: string;
-    Middlewares: string;
-    Models: string;
+export type IDatabaseConfig = Knex.Config;
+export interface IVersionFolder {
+    root: string;
+    config: string;
+    events: string;
+    hooks: string;
+    middlewares: string;
+    models: string;
+    serialization: string;
+}
+export interface IVersion {
+    name: string;
+    config: IVersionConfig;
+    folders: IVersionFolder;
+    modelList: ModelListService;
+    modelTree: IModelService[];
+}
+export interface IAPI {
+    rootFolder: string;
+    appFolder: string;
+    versions: IVersion[];
+    config: IApplicationConfig;
 }
 export interface IGeneralHooks {
     onBeforeInit: (app: Express) => void | null;
@@ -85,8 +119,12 @@ export interface IModelService {
     events: Record<HookFunctionTypes, (params: IHookParameter) => void>;
     isRecursive: boolean;
     children: IModelService[];
+    queryLimits: IQueryLimitConfig[];
+    serialize: SerializationFunction | null;
     setColumns(columns: IColumn[]): void;
     setExtensions(type: Extensions, hookFunctionType: HookFunctionTypes, data: (params: IHookParameter) => void): void;
+    setQueryLimits(limits: IQueryLimitConfig[]): void;
+    setSerialization(callback: SerializationFunction): void;
 }
 export interface IRelation {
     type: Relationships;
@@ -96,6 +134,8 @@ export interface IRelation {
     foreignKey: string;
 }
 export interface IRequestPack {
+    api: IAPI;
+    version: IVersion;
     req: Request;
     res: Response;
     handlerType: HandlerTypes;
@@ -150,7 +190,7 @@ export interface IWhere {
     value: any;
     relation: IRelation | null;
 }
-export declare type NestedWhere = Array<NestedWhere | IWhere>;
+export type NestedWhere = Array<NestedWhere | IWhere>;
 export interface IDependency {
     type: DependencyTypes;
     callback: any;

package/build/src/Middlewares/acceptLanguageMiddleware.js

@@ -9,15 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const Services_1 = require("../Services");
 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 configs = yield Services_1.IoCService.use("Config");
-    const application = configs.Application;
-    const { supportedLanguages, defaultLanguage } = application;
+    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") || "", supportedLanguages || ["en"], defaultLanguage || "en");
+    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();

package/build/src/Model.d.ts

@@ -1,5 +1,5 @@
 import { Request, Response, NextFunction } from "express";
-import { IRelation, IMethodBaseConfig, IMethodBaseValidations, IHandlerBaseMiddleware, IHandlerBasedTransactionConfig } from "./Interfaces";
+import { IRelation, IMethodBaseConfig, IMethodBaseValidations, IHandlerBaseMiddleware, IHandlerBasedTransactionConfig, IQueryLimitConfig } from "./Interfaces";
 import { HandlerTypes, HttpMethods } from "./Enums";
 declare class Model {
     get primaryKey(): string;
@@ -14,13 +14,13 @@ declare class Model {
     get deletedAtColumn(): string | null;
     get transaction(): boolean | IHandlerBasedTransactionConfig | IHandlerBasedTransactionConfig[] | null;
     get ignore(): boolean;
+    get limits(): Array<IQueryLimitConfig[]>;
     getFillableFields(methodType: HttpMethods): string[];
     getValidationRules(methodType: HttpMethods): Record<string, string> | null;
     getMiddlewares(handlerType: HandlerTypes): ((req: Request, res: Response, next: NextFunction) => void)[];
     hasMany(relatedModel: string, primaryKey?: string, foreignKey?: string): IRelation;
     hasOne(relatedModel: string, primaryKey?: string, foreignKey?: string): IRelation;
     belongsTo(relatedModel: string, primaryKey: string, foreignKey: string): IRelation;
-    serialize(data: any, request: Request): any;
     private hasStringValue;
 }
 export default Model;

package/build/src/Model.js

@@ -44,6 +44,9 @@ class Model {
     get ignore() {
         return false;
     }
+    get limits() {
+        return [];
+    }
     getFillableFields(methodType) {
         if (this.fillable === null) {
             return [];
@@ -130,10 +133,6 @@ class Model {
     belongsTo(relatedModel, primaryKey, foreignKey) {
         return this.hasOne(relatedModel, foreignKey, primaryKey);
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    serialize(data, request) {
-        return data;
-    }
     hasStringValue() {
         const tester = this.validations;
         let status = false;

package/build/src/Resolvers/FileResolver.js

@@ -50,7 +50,7 @@ class FileResolver {
                 .map((item) => item.name);
             for (const file of files) {
                 const configFile = path_1.default.join(directory, file);
-                const { default: content } = yield Promise.resolve().then(() => __importStar(require(configFile)));
+                const { default: content } = yield Promise.resolve(`${configFile}`).then(s => __importStar(require(s)));
                 const key = file.replace(".ts", "").replace(".js", "");
                 if (content === null || content === void 0 ? void 0 : content.prototype) {
                     results[key] = new content();
@@ -74,7 +74,7 @@ class FileResolver {
                 .map((item) => item.name);
             for (const file of files) {
                 const configFile = path_1.default.join(directory, file);
-                const content = yield Promise.resolve().then(() => __importStar(require(configFile)));
+                const content = yield Promise.resolve(`${configFile}`).then(s => __importStar(require(s)));
                 const key = file.replace(".ts", "").replace(".js", "");
                 results[key] = content;
             }

package/build/src/Resolvers/GeneralHookResolver.d.ts

@@ -1,5 +1,7 @@
-import { IGeneralHooks } from "../Interfaces";
+import { IGeneralHooks, IVersion } from "../Interfaces";
 declare class GeneralHookResolver {
-    static resolve(): Promise<IGeneralHooks>;
+    private version;
+    constructor(version: IVersion);
+    resolve(): Promise<IGeneralHooks>;
 }
 export default GeneralHookResolver;

package/build/src/Resolvers/GeneralHookResolver.js

@@ -8,19 +8,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
-const Services_1 = require("../Services");
 const _1 = require(".");
 class GeneralHookResolver {
-    static resolve() {
+    constructor(version) {
+        this.version = version;
+    }
+    resolve() {
         return __awaiter(this, void 0, void 0, function* () {
-            const folders = (yield Services_1.IoCService.use("Folders"));
             const fileResolver = new _1.FileResolver();
-            const content = yield fileResolver.resolveContent(path_1.default.join(folders.App, "app"));
+            const content = yield fileResolver.resolveContent(this.version.folders.root);
             if (content && content.init) {
                 const { onBeforeInit = null, onAfterInit = null } = content.init;
                 return { onBeforeInit, onAfterInit };

package/build/src/Resolvers/ModelResolver.d.ts

@@ -1,9 +1,16 @@
+import { IVersion } from "../Interfaces";
 declare class ModelResolver {
+    private version;
+    constructor(version: IVersion);
     resolve(): Promise<void>;
     private setModelRelations;
     private getModelList;
     private setDatabaseColumns;
     private setModelHooks;
+    private getDirectories;
+    private checkOldStyleHookFiles;
+    private setModelSerializations;
+    private setModelQueryLimits;
     private getInstanceMethods;
 }
 export default ModelResolver;