axe-api 0.22.0 → 0.30.0-rc10

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

@@ -1,8 +1,10 @@
 import { IModelService, IRouteDocumentation } from "../Interfaces";
 import { HttpMethods } from "../Enums";
 declare class DocumentationService {
-    routes: IRouteDocumentation[];
+    private static instance;
+    private routes;
     constructor();
+    static getInstance(): DocumentationService;
     push(method: HttpMethods, url: string, model: IModelService): void;
     get(): IRouteDocumentation[];
 }

package/build/src/Services/DocumentationService.js

@@ -4,6 +4,12 @@ class DocumentationService {
     constructor() {
         this.routes = [];
     }
+    static getInstance() {
+        if (!DocumentationService.instance) {
+            DocumentationService.instance = new DocumentationService();
+        }
+        return DocumentationService.instance;
+    }
     push(method, url, model) {
         this.routes.push({
             model: model.name,

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

@@ -0,0 +1,5 @@
+import { QueryFeature } from "../Enums";
+import { IModelService, IQueryLimitConfig } from "../Interfaces";
+export declare const allow: (feature: QueryFeature, keys?: string[]) => IQueryLimitConfig[];
+export declare const deny: (feature: QueryFeature, keys?: string[]) => IQueryLimitConfig[];
+export declare const valideteQueryFeature: (model: IModelService, feature: QueryFeature, key?: string | null, errorDescription?: string) => void;

package/build/src/Services/LimitService.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.valideteQueryFeature = exports.deny = exports.allow = void 0;
+const Enums_1 = require("../Enums");
+const ApiError_1 = __importDefault(require("../Exceptions/ApiError"));
+const QueryFeatureMap = {
+    [Enums_1.QueryFeature.All]: [
+        Enums_1.QueryFeature.FieldsAll,
+        Enums_1.QueryFeature.Sorting,
+        Enums_1.QueryFeature.Limits,
+        Enums_1.QueryFeature.WhereEqual,
+        Enums_1.QueryFeature.WhereNotEqual,
+        Enums_1.QueryFeature.WhereGt,
+        Enums_1.QueryFeature.WhereGte,
+        Enums_1.QueryFeature.WhereLt,
+        Enums_1.QueryFeature.WhereLte,
+        Enums_1.QueryFeature.WhereLike,
+        Enums_1.QueryFeature.WhereNotLike,
+        Enums_1.QueryFeature.WhereIn,
+        Enums_1.QueryFeature.WhereNotIn,
+        Enums_1.QueryFeature.WhereBetween,
+        Enums_1.QueryFeature.WhereNotBetween,
+        Enums_1.QueryFeature.WhereNull,
+        Enums_1.QueryFeature.WhereNotNull,
+        Enums_1.QueryFeature.Trashed,
+        Enums_1.QueryFeature.WithHasOne,
+        Enums_1.QueryFeature.WithHasMany,
+    ],
+    [Enums_1.QueryFeature.FieldsAll]: [Enums_1.QueryFeature.FieldsAll],
+    [Enums_1.QueryFeature.Sorting]: [Enums_1.QueryFeature.Sorting],
+    [Enums_1.QueryFeature.Limits]: [Enums_1.QueryFeature.Limits],
+    [Enums_1.QueryFeature.WhereAll]: [
+        Enums_1.QueryFeature.WhereEqual,
+        Enums_1.QueryFeature.WhereNotEqual,
+        Enums_1.QueryFeature.WhereGt,
+        Enums_1.QueryFeature.WhereGte,
+        Enums_1.QueryFeature.WhereLt,
+        Enums_1.QueryFeature.WhereLte,
+        Enums_1.QueryFeature.WhereLike,
+        Enums_1.QueryFeature.WhereNotLike,
+        Enums_1.QueryFeature.WhereIn,
+        Enums_1.QueryFeature.WhereNotIn,
+        Enums_1.QueryFeature.WhereBetween,
+        Enums_1.QueryFeature.WhereNotBetween,
+        Enums_1.QueryFeature.WhereNull,
+        Enums_1.QueryFeature.WhereNotNull,
+    ],
+    [Enums_1.QueryFeature.WhereEqual]: [Enums_1.QueryFeature.WhereEqual],
+    [Enums_1.QueryFeature.WhereNotEqual]: [Enums_1.QueryFeature.WhereNotEqual],
+    [Enums_1.QueryFeature.WhereGt]: [Enums_1.QueryFeature.WhereGt],
+    [Enums_1.QueryFeature.WhereGte]: [Enums_1.QueryFeature.WhereGte],
+    [Enums_1.QueryFeature.WhereLt]: [Enums_1.QueryFeature.WhereLt],
+    [Enums_1.QueryFeature.WhereLte]: [Enums_1.QueryFeature.WhereLte],
+    [Enums_1.QueryFeature.WhereLike]: [Enums_1.QueryFeature.WhereLike],
+    [Enums_1.QueryFeature.WhereNotLike]: [Enums_1.QueryFeature.WhereNotLike],
+    [Enums_1.QueryFeature.WhereIn]: [Enums_1.QueryFeature.WhereIn],
+    [Enums_1.QueryFeature.WhereNotIn]: [Enums_1.QueryFeature.WhereNotIn],
+    [Enums_1.QueryFeature.WhereBetween]: [Enums_1.QueryFeature.WhereBetween],
+    [Enums_1.QueryFeature.WhereNotBetween]: [Enums_1.QueryFeature.WhereNotBetween],
+    [Enums_1.QueryFeature.WhereNull]: [Enums_1.QueryFeature.WhereNull],
+    [Enums_1.QueryFeature.WhereNotNull]: [Enums_1.QueryFeature.WhereNotNull],
+    [Enums_1.QueryFeature.Trashed]: [Enums_1.QueryFeature.Trashed],
+    [Enums_1.QueryFeature.WithAll]: [Enums_1.QueryFeature.WithHasOne, Enums_1.QueryFeature.WithHasMany],
+    [Enums_1.QueryFeature.WithHasOne]: [Enums_1.QueryFeature.WithHasOne],
+    [Enums_1.QueryFeature.WithHasMany]: [Enums_1.QueryFeature.WithHasMany],
+};
+const generatePermission = (type, feature, keys = []) => {
+    const features = QueryFeatureMap[feature];
+    if (keys.length === 0) {
+        keys = [null];
+    }
+    return features
+        .map((subFeature) => {
+        return keys.map((key) => {
+            return {
+                type,
+                feature: subFeature,
+                key,
+            };
+        });
+    })
+        .flat();
+};
+const allow = (feature, keys = []) => {
+    return generatePermission(Enums_1.QueryFeatureType.Allow, feature, keys);
+};
+exports.allow = allow;
+const deny = (feature, keys = []) => {
+    return generatePermission(Enums_1.QueryFeatureType.Deny, feature, keys);
+};
+exports.deny = deny;
+const valideteQueryFeature = (model, feature, key = null, errorDescription) => {
+    const errorDetail = errorDescription ? ` (${errorDescription})` : "";
+    const rules = model.queryLimits.filter((limit) => limit.feature === feature && limit.key === null);
+    if (key) {
+        const keyRules = model.queryLimits.filter((limit) => limit.feature === feature && limit.key === key);
+        if (keyRules.length > 0) {
+            const lastKeyRule = keyRules[keyRules.length - 1];
+            if ((lastKeyRule === null || lastKeyRule === void 0 ? void 0 : lastKeyRule.type) === Enums_1.QueryFeatureType.Deny) {
+                throw new ApiError_1.default(`Unsupported query feature${errorDetail}: ${feature.toString()} [${key}]`);
+            }
+            return;
+        }
+    }
+    if (rules.length === 0) {
+        throw new ApiError_1.default(`Unsupported query feature${errorDetail}: ${feature.toString()}`);
+    }
+    const lastRule = rules[rules.length - 1];
+    if ((lastRule === null || lastRule === void 0 ? void 0 : lastRule.type) === Enums_1.QueryFeatureType.Deny) {
+        throw new ApiError_1.default(`Unsupported query feature${errorDetail}: ${feature.toString()}`);
+    }
+};
+exports.valideteQueryFeature = valideteQueryFeature;

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

@@ -1,7 +1,10 @@
 import { LogLevels } from "../Enums";
 declare class LogService {
-    level: LogLevels;
+    private static instance;
+    private level;
     constructor(level: LogLevels);
+    static setInstance(level: LogLevels): void;
+    static getInstance(): LogService;
     error(message: string): void;
     warn(message: string): void;
     info(message: string): void;

package/build/src/Services/LogService.js

@@ -7,6 +7,12 @@ class LogService {
     constructor(level) {
         this.level = level;
     }
+    static setInstance(level) {
+        LogService.instance = new LogService(level);
+    }
+    static getInstance() {
+        return LogService.instance;
+    }
     error(message) {
         if (this.level >= Enums_1.LogLevels.ERROR) {
             console.error(fgRed, "[axe]", message, fgReset);

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

@@ -1,6 +1,7 @@
 import { HookFunctionTypes, Extensions } from "../Enums";
-import { IColumn, IHookParameter, IModelService, IRelation } from "../Interfaces";
+import { IColumn, IHookParameter, IModelService, IQueryLimitConfig, IRelation } from "../Interfaces";
 import Model from "./../Model";
+import { SerializationFunction } from "../Types";
 declare class ModelService implements IModelService {
     name: string;
     instance: Model;
@@ -11,9 +12,13 @@ declare class ModelService implements IModelService {
     events: Record<HookFunctionTypes, (params: IHookParameter) => void>;
     children: IModelService[];
     isRecursive: boolean;
+    queryLimits: IQueryLimitConfig[];
+    serialize: SerializationFunction | null;
     constructor(name: string, instance: Model);
     setColumns(columns: IColumn[]): void;
     setExtensions(type: Extensions, hookFunctionType: HookFunctionTypes, data: (params: IHookParameter) => void): void;
+    setQueryLimits(limits: IQueryLimitConfig[]): void;
+    setSerialization(callback: SerializationFunction): void;
     private setHooks;
     private setEvents;
 }

package/build/src/Services/ModelService.js

@@ -12,6 +12,8 @@ class ModelService {
         this.columnNames = [];
         this.children = [];
         this.isRecursive = false;
+        this.queryLimits = [];
+        this.serialize = null;
     }
     setColumns(columns) {
         this.columns = columns;
@@ -28,6 +30,12 @@ class ModelService {
             throw new Error("Undefined hook type.");
         }
     }
+    setQueryLimits(limits) {
+        this.queryLimits = limits;
+    }
+    setSerialization(callback) {
+        this.serialize = callback;
+    }
     setHooks(hookFunctionType, data) {
         this.hooks[hookFunctionType] = data;
     }

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

@@ -1,4 +1,4 @@
-import { IQuery, ISortField, NestedWhere, IWhere, IModelService } from "../Interfaces";
+import { IQuery, ISortField, NestedWhere, IWhere, IModelService, IVersionConfig } from "../Interfaces";
 import { Knex } from "knex";
 declare class QueryService {
     model: IModelService;
@@ -6,7 +6,8 @@ declare class QueryService {
     usedConditionColumns: string[];
     relationColumns: string[];
     createdJoins: string[];
-    constructor(model: IModelService, models: IModelService[]);
+    config: IVersionConfig;
+    constructor(model: IModelService, models: IModelService[], config: IVersionConfig);
     applyFields(query: Knex.QueryBuilder, fields: string[]): void;
     applySorting(query: Knex.QueryBuilder, sort: ISortField[]): void;
     applyWheresInsideGroup(sub: Knex.QueryBuilder, ruleSet: NestedWhere | IWhere): void;

package/build/src/Services/QueryService.js

@@ -6,10 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const Enums_1 = require("../Enums");
 const ApiError_1 = __importDefault(require("../Exceptions/ApiError"));
 const Resolvers_1 = require("../Resolvers");
+const constants_1 = require("../constants");
+const LimitService_1 = require("./LimitService");
+const Helpers_1 = require("../Handlers/Helpers");
 class QueryService {
-    constructor(model, models) {
+    constructor(model, models, config) {
         this.model = model;
         this.models = models;
+        this.config = config;
         this.createdJoins = [];
         this.relationColumns = [];
         this.usedConditionColumns = [];
@@ -17,6 +21,7 @@ class QueryService {
     applyFields(query, fields) {
         // Users should be able to select some fields to show.
         if (fields.length === 0 || (fields.length === 1 && fields[0] === "*")) {
+            (0, LimitService_1.valideteQueryFeature)(this.model, Enums_1.QueryFeature.FieldsAll);
             query.select(`${this.model.instance.table}.*`);
         }
         else {
@@ -33,7 +38,9 @@ class QueryService {
         if (sort.length === 0) {
             return;
         }
+        (0, LimitService_1.valideteQueryFeature)(this.model, Enums_1.QueryFeature.Sorting);
         sort.forEach((item) => {
+            (0, LimitService_1.valideteQueryFeature)(this.model, Enums_1.QueryFeature.Sorting, `${this.model.instance.table}.${item.name}`);
             query.orderBy(item.name, item.type);
         });
     }
@@ -156,6 +163,7 @@ class QueryService {
         this.createdJoins.push(relation.name);
     }
     parseSections(sections) {
+        var _a, _b, _c, _d;
         if (sections.q) {
             const queryContent = sections.q.replace(/%20/g, "").replace(/ /g, "");
             // Users can send an unacceptable query string. We shouldn't allow them to
@@ -175,10 +183,14 @@ class QueryService {
             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)
-                ? sections.trashed.trim() === "true" || sections.trashed.trim() === "1"
-                : false,
+            trashed: (sections === null || sections === void 0 ? void 0 : sections.trashed) ? (0, Helpers_1.isBoolean)(sections.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) ||
+            10;
+        if (query.per_page !== configPerPage) {
+            (0, LimitService_1.valideteQueryFeature)(this.model, Enums_1.QueryFeature.Limits);
+        }
         this.addRelationColumns(query.with);
         return query;
     }
@@ -193,9 +205,21 @@ class QueryService {
         return value;
     }
     parsePerPage(content) {
-        const value = parseInt(content);
-        if (isNaN(value) || value <= 1 || value > 10000) {
-            return 10;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        const value = parseInt(content ||
+            ((_b = (_a = this.config.query) === null || _a === void 0 ? void 0 : _a.defaults) === null || _b === void 0 ? void 0 : _b.perPage) ||
+            ((_c = constants_1.DEFAULT_VERSION_CONFIG.query.defaults) === null || _c === void 0 ? void 0 : _c.perPage) ||
+            10);
+        const minPerPage = ((_e = (_d = this.config.query) === null || _d === void 0 ? void 0 : _d.defaults) === null || _e === void 0 ? void 0 : _e.minPerPage) ||
+            ((_f = constants_1.DEFAULT_VERSION_CONFIG.query.defaults) === null || _f === void 0 ? void 0 : _f.minPerPage) ||
+            1;
+        const maxPerPage = ((_h = (_g = this.config.query) === null || _g === void 0 ? void 0 : _g.defaults) === null || _h === void 0 ? void 0 : _h.maxPerPage) ||
+            ((_j = constants_1.DEFAULT_VERSION_CONFIG.query.defaults) === null || _j === void 0 ? void 0 : _j.maxPerPage) ||
+            100;
+        if (isNaN(value) || value <= minPerPage || value > maxPerPage) {
+            return (((_l = (_k = this.config.query) === null || _k === void 0 ? void 0 : _k.defaults) === null || _l === void 0 ? void 0 : _l.perPage) ||
+                ((_m = constants_1.DEFAULT_VERSION_CONFIG.query.defaults) === null || _m === void 0 ? void 0 : _m.perPage) ||
+                10);
         }
         return value;
     }
@@ -332,6 +356,7 @@ class QueryService {
             where.relation = relation;
             where.field = field;
         }
+        (0, LimitService_1.valideteQueryFeature)(this.model, constants_1.ConditionQueryFeatureMap[where.condition], `${where.table}.${where.field}`);
         this.shouldBeAcceptableColumn(where.field);
         this.usedConditionColumns.push(`${where.table}.${where.field}`);
         return where;

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

@@ -1,6 +1,13 @@
+import { IVersion } from "../Interfaces";
 declare class SchemaValidatorService {
+    private version;
+    constructor(version: IVersion);
     validate(): Promise<void>;
     private checkModelColumnsOrFail;
+    private checkRelationNamesOrFail;
+    private getQueryLimitRelations;
+    private getQueryLimitColumns;
+    private getQueryLimitKeyByFilter;
     private getModelFillableColumns;
     private getModelFormValidationColumns;
     private getModelHiddenColumns;

package/build/src/Services/SchemaValidatorService.js

@@ -8,11 +8,55 @@ 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 AxeError_1 = __importDefault(require("../Exceptions/AxeError"));
 const Enums_1 = require("../Enums");
 const Services_1 = require("../Services");
+const COLUMN_BASED_QUERY_LIMITS = [
+    Enums_1.QueryFeature.Sorting,
+    Enums_1.QueryFeature.WhereEqual,
+    Enums_1.QueryFeature.WhereNotEqual,
+    Enums_1.QueryFeature.WhereGt,
+    Enums_1.QueryFeature.WhereGte,
+    Enums_1.QueryFeature.WhereLt,
+    Enums_1.QueryFeature.WhereLte,
+    Enums_1.QueryFeature.WhereLike,
+    Enums_1.QueryFeature.WhereNotLike,
+    Enums_1.QueryFeature.WhereIn,
+    Enums_1.QueryFeature.WhereNotIn,
+    Enums_1.QueryFeature.WhereBetween,
+    Enums_1.QueryFeature.WhereNotBetween,
+    Enums_1.QueryFeature.WhereNull,
+    Enums_1.QueryFeature.WhereNotNull,
+];
+const RELATION_BASED_QUERY_LIMITS = [
+    Enums_1.QueryFeature.WithHasMany,
+    Enums_1.QueryFeature.WithHasOne,
+];
 class SchemaValidatorService {
-    constructor() {
+    constructor(version) {
+        this.getQueryLimitRelations = (model) => {
+            return this.getQueryLimitKeyByFilter(model, RELATION_BASED_QUERY_LIMITS);
+        };
+        this.getQueryLimitColumns = (model) => {
+            return this.getQueryLimitKeyByFilter(model, COLUMN_BASED_QUERY_LIMITS);
+        };
+        this.getQueryLimitKeyByFilter = (model, filter) => {
+            const items = model.queryLimits
+                .filter((limit) => limit.key && filter.includes(limit.feature))
+                .map((limit) => limit.key)
+                .map((key) => {
+                if (!key) {
+                    return "";
+                }
+                const [, field] = key === null || key === void 0 ? void 0 : key.split(".");
+                return field;
+            });
+            return items;
+        };
         this.getModelFillableColumns = (model) => {
             const fillable = model.instance.fillable;
             if (!fillable) {
@@ -66,30 +110,40 @@ class SchemaValidatorService {
             this.checkModelColumnsOrFail(model, [relation.primaryKey]);
             const relatedModel = modelList.find(relation.model);
             if (!relatedModel) {
-                throw new Error(`Undefined related model: ${relation.model}`);
+                throw new AxeError_1.default(Enums_1.AxeErrorCode.UNDEFINED_RELATION_MODEL, `Undefined related model: ${relation.model} (${model.name}.${relation.name})`);
             }
             this.checkModelColumnsOrFail(relatedModel, [relation.foreignKey]);
         };
+        this.version = version;
     }
     validate() {
         return __awaiter(this, void 0, void 0, function* () {
-            const logger = yield Services_1.IoCService.useByType("LogService");
-            const modelList = yield Services_1.IoCService.useByType("ModelListService");
-            modelList.get().forEach((model) => {
+            const logger = Services_1.LogService.getInstance();
+            this.version.modelList.get().forEach((model) => {
                 this.checkModelColumnsOrFail(model, this.getModelFillableColumns(model));
                 this.checkModelColumnsOrFail(model, this.getModelFormValidationColumns(model));
                 this.checkModelColumnsOrFail(model, this.getModelHiddenColumns(model));
                 this.checkModelColumnsOrFail(model, this.getTimestampsColumns(model));
+                this.checkModelColumnsOrFail(model, this.getQueryLimitColumns(model));
                 this.checkModelColumnsOrFail(model, [model.instance.primaryKey]);
-                this.checkRelationColumnsOrFail(modelList, model);
+                this.checkRelationNamesOrFail(model, this.getQueryLimitRelations(model));
+                this.checkRelationColumnsOrFail(this.version.modelList, model);
             });
-            logger.info("Database schema has been validated.");
+            logger.info(`[${this.version.name}] Database schema has been validated.`);
         });
     }
     checkModelColumnsOrFail(model, modelColumns) {
         const undefinedColumns = modelColumns.filter((modelColumn) => !model.columnNames.includes(modelColumn));
         if (undefinedColumns.length > 0) {
-            throw new Error(`${model.name} model doesn't have the following columns on the database; "${model.instance.table}.${undefinedColumns.join(",")}"`);
+            throw new AxeError_1.default(Enums_1.AxeErrorCode.UNDEFINED_COLUMN, `${model.name} model doesn't have the following columns on the database; "${model.instance.table}.${undefinedColumns.join(",")}"`);
+        }
+    }
+    checkRelationNamesOrFail(model, names) {
+        const undefinedRelationNames = names.filter((name) => {
+            return !model.relations.map((relation) => relation.name).includes(name);
+        });
+        if (undefinedRelationNames.length > 0) {
+            throw new AxeError_1.default(Enums_1.AxeErrorCode.UNDEFINED_RELATION_NAME, `${model.name} model doesn't have a valid relation name that is defined in query limits; "${undefinedRelationNames.join(",")}"`);
         }
     }
     checkRelationColumnsOrFail(modelList, model) {

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

@@ -1,8 +1,10 @@
+import APIService from "./APIService";
 import DocumentationService from "./DocumentationService";
 import IoCService from "./IoCService";
+import { allow, deny } from "./LimitService";
 import LogService from "./LogService";
 import ModelListService from "./ModelListService";
 import ModelService from "./ModelService";
 import QueryService from "./QueryService";
 import SchemaValidatorService from "./SchemaValidatorService";
-export { DocumentationService, IoCService, LogService, ModelListService, ModelService, QueryService, SchemaValidatorService, };
+export { DocumentationService, APIService, IoCService, LogService, ModelListService, ModelService, QueryService, SchemaValidatorService, allow, deny, };

package/build/src/Services/index.js

@@ -3,11 +3,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaValidatorService = exports.QueryService = exports.ModelService = exports.ModelListService = exports.LogService = exports.IoCService = exports.DocumentationService = void 0;
+exports.deny = exports.allow = exports.SchemaValidatorService = exports.QueryService = exports.ModelService = exports.ModelListService = exports.LogService = exports.IoCService = exports.APIService = exports.DocumentationService = void 0;
+const APIService_1 = __importDefault(require("./APIService"));
+exports.APIService = APIService_1.default;
 const DocumentationService_1 = __importDefault(require("./DocumentationService"));
 exports.DocumentationService = DocumentationService_1.default;
 const IoCService_1 = __importDefault(require("./IoCService"));
 exports.IoCService = IoCService_1.default;
+const LimitService_1 = require("./LimitService");
+Object.defineProperty(exports, "allow", { enumerable: true, get: function () { return LimitService_1.allow; } });
+Object.defineProperty(exports, "deny", { enumerable: true, get: function () { return LimitService_1.deny; } });
 const LogService_1 = __importDefault(require("./LogService"));
 exports.LogService = LogService_1.default;
 const ModelListService_1 = __importDefault(require("./ModelListService"));

package/build/src/Types.d.ts

@@ -0,0 +1,2 @@
+import { Request } from "express";
+export type SerializationFunction = (item: any, request: Request) => any;

package/build/src/Types.js

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

package/build/src/constants.d.ts

@@ -1,4 +1,5 @@
-import { HandlerTypes } from "./Enums";
+import { ConditionTypes, HandlerTypes, QueryFeature, Relationships } from "./Enums";
+import { IVersionConfig } from "./Interfaces";
 export declare const LOG_COLORS: {
     fgBlack: string;
     fgRed: string;
@@ -22,3 +23,6 @@ export declare const API_ROUTE_TEMPLATES: {
     destroy: (prefix: string, parentUrl: string, resource: string, primaryKey: string) => string;
     force_delete: (prefix: string, parentUrl: string, resource: string, primaryKey: string) => string;
 };
+export declare const ConditionQueryFeatureMap: Record<ConditionTypes, QueryFeature>;
+export declare const RelationQueryFeatureMap: Record<Relationships, QueryFeature>;
+export declare const DEFAULT_VERSION_CONFIG: IVersionConfig;

package/build/src/constants.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.API_ROUTE_TEMPLATES = exports.DEFAULT_METHODS_OF_MODELS = exports.DEFAULT_HANDLERS = exports.LOG_COLORS = void 0;
+exports.DEFAULT_VERSION_CONFIG = exports.RelationQueryFeatureMap = exports.ConditionQueryFeatureMap = exports.API_ROUTE_TEMPLATES = exports.DEFAULT_METHODS_OF_MODELS = exports.DEFAULT_HANDLERS = exports.LOG_COLORS = void 0;
 const Enums_1 = require("./Enums");
+const LimitService_1 = require("./Services/LimitService");
 exports.LOG_COLORS = {
     fgBlack: "\x1b[30m",
     fgRed: "\x1b[31m",
@@ -26,7 +27,6 @@ exports.DEFAULT_METHODS_OF_MODELS = [
     "hasMany",
     "hasOne",
     "belongsTo",
-    "serialize",
     "__defineGetter__",
     "__defineSetter__",
     "hasOwnProperty",
@@ -49,6 +49,7 @@ exports.DEFAULT_METHODS_OF_MODELS = [
     "deletedAtColumn",
     "transaction",
     "ignore",
+    "limits",
     "getFillableFields",
     "getValidationRules",
 ];
@@ -62,3 +63,43 @@ exports.API_ROUTE_TEMPLATES = {
     [Enums_1.HandlerTypes.DELETE]: (prefix, parentUrl, resource, primaryKey) => `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
     [Enums_1.HandlerTypes.FORCE_DELETE]: (prefix, parentUrl, resource, primaryKey) => `/${prefix}/${parentUrl}${resource}/:${primaryKey}/force`,
 };
+exports.ConditionQueryFeatureMap = {
+    [Enums_1.ConditionTypes.NotNull]: Enums_1.QueryFeature.WhereNotNull,
+    [Enums_1.ConditionTypes.Null]: Enums_1.QueryFeature.WhereNull,
+    [Enums_1.ConditionTypes["="]]: Enums_1.QueryFeature.WhereEqual,
+    [Enums_1.ConditionTypes["<>"]]: Enums_1.QueryFeature.WhereNotEqual,
+    [Enums_1.ConditionTypes[">"]]: Enums_1.QueryFeature.WhereGt,
+    [Enums_1.ConditionTypes[">="]]: Enums_1.QueryFeature.WhereGte,
+    [Enums_1.ConditionTypes["<"]]: Enums_1.QueryFeature.WhereLt,
+    [Enums_1.ConditionTypes["<="]]: Enums_1.QueryFeature.WhereLte,
+    [Enums_1.ConditionTypes["LIKE"]]: Enums_1.QueryFeature.WhereLike,
+    [Enums_1.ConditionTypes["NOT LIKE"]]: Enums_1.QueryFeature.WhereNotLike,
+    [Enums_1.ConditionTypes["In"]]: Enums_1.QueryFeature.WhereIn,
+    [Enums_1.ConditionTypes["NotIn"]]: Enums_1.QueryFeature.WhereNotIn,
+    [Enums_1.ConditionTypes["Between"]]: Enums_1.QueryFeature.WhereBetween,
+    [Enums_1.ConditionTypes["NotBetween"]]: Enums_1.QueryFeature.WhereNotBetween,
+};
+exports.RelationQueryFeatureMap = {
+    [Enums_1.Relationships.HAS_ONE]: Enums_1.QueryFeature.WithHasOne,
+    [Enums_1.Relationships.HAS_MANY]: Enums_1.QueryFeature.WithHasMany,
+};
+exports.DEFAULT_VERSION_CONFIG = {
+    transaction: false,
+    serializers: [],
+    supportedLanguages: ["en"],
+    defaultLanguage: "en",
+    query: {
+        limits: [
+            (0, LimitService_1.allow)(Enums_1.QueryFeature.All),
+            (0, LimitService_1.deny)(Enums_1.QueryFeature.WithHasMany),
+            (0, LimitService_1.deny)(Enums_1.QueryFeature.WhereLike),
+            (0, LimitService_1.deny)(Enums_1.QueryFeature.WhereNotLike),
+            (0, LimitService_1.deny)(Enums_1.QueryFeature.Trashed),
+        ],
+        defaults: {
+            perPage: 10,
+            minPerPage: 1,
+            maxPerPage: 100,
+        },
+    },
+};