@edirect/rate-limit-module 11.0.62 → 11.0.64

package/dist/src/guards/rate-limiting.guard.js

@@ -0,0 +1,248 @@
+"use strict";
+var RateLimitingRuleGuard_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitingRuleGuard = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const rate_limiting_rule_decorator_1 = require("../decorators/rate-limiting-rule.decorator");
+const object_utils_1 = require("../object.utils");
+const rule_service_1 = require("../rules/rule.service");
+const rule_engine_service_1 = require("../shared/rule-engine/rule-engine.service");
+let RateLimitingRuleGuard = RateLimitingRuleGuard_1 = class RateLimitingRuleGuard {
+    reflector;
+    ruleService;
+    ruleEngine;
+    logger = new common_1.Logger(RateLimitingRuleGuard_1.name);
+    constructor(reflector, ruleService, ruleEngine) {
+        this.reflector = reflector;
+        this.ruleService = ruleService;
+        this.ruleEngine = ruleEngine;
+    }
+    async canActivate(context) {
+        try {
+            const handler = context.getHandler();
+            const ruleMetaData = this.reflector.get(rate_limiting_rule_decorator_1.RULE_METADATA, handler);
+            if (!ruleMetaData)
+                return true;
+            const req = context.switchToHttp().getRequest();
+            const entity = req.body;
+            const { action, partnerPath, providerPath, productTypePath, marketPath } = ruleMetaData;
+            const partner = this._getValueFromPathOrRoot(entity, partnerPath);
+            if (!partner)
+                return true;
+            const provider = this._getValueFromPathOrRoot(entity, providerPath);
+            const productType = this._getValueFromPathOrRoot(entity, productTypePath);
+            const market = this._getValueFromPathOrRoot(entity, marketPath);
+            const parameters = {
+                enabled: 'true',
+                partner: partner,
+                provider: provider,
+                market: market,
+                targetAction: action,
+                productType: productType,
+                page: 1,
+                limit: 10,
+            };
+            const rules = await this.ruleService.findAllWithoutPagination(parameters);
+            this.logger.debug(`[RATE LIMITER] ${rules?.length} rules found - ${JSON.stringify(rules)}`);
+            if (!rules || !rules?.length)
+                return true;
+            for (const rule of rules) {
+                await this._injectFnsResults(rule.variables, entity);
+                const contextVars = this._resolveVariables(rule.variables, entity);
+                const invalidExpressionMessage = this.ruleService.validateRuleExpression(rule.expression);
+                if (invalidExpressionMessage && invalidExpressionMessage.length) {
+                    throw new common_1.HttpException(invalidExpressionMessage, common_1.HttpStatus.TOO_MANY_REQUESTS);
+                }
+                const invalidFunctions = this.ruleEngine.validateFunctionsAreValid(rule.expression);
+                if (invalidFunctions && invalidFunctions.length) {
+                    throw new common_1.HttpException(`these functions are not allowed ${invalidFunctions.join(', ')}`, common_1.HttpStatus.TOO_MANY_REQUESTS);
+                }
+                if (rule.variablesRequired) {
+                    const missingVars = await this.ruleEngine.validateExpressionVariables(rule.expression, contextVars);
+                    if (missingVars && missingVars.length) {
+                        this.logger.debug(`[RATE LIMITER] rule - ${rule.name} requires theses variables ${JSON.stringify(missingVars)}`);
+                        throw new common_1.HttpException(`For rate limiting validation these variables are required ${JSON.stringify(missingVars)}`, common_1.HttpStatus.TOO_MANY_REQUESTS);
+                    }
+                }
+                const safeContextVars = (0, object_utils_1.withDefaultNull)(contextVars ?? {});
+                const notAllowed = await this.ruleEngine.evaluate(rule.expression, safeContextVars);
+                this.logger.debug(`[RATE LIMITER] rule - ${rule.name} reached the limit`);
+                if (notAllowed)
+                    throw new common_1.HttpException(rule.errorMessage || `Rate Limiting rule reached limit`, common_1.HttpStatus.TOO_MANY_REQUESTS);
+            }
+            return true;
+        }
+        catch (err) {
+            if (err instanceof common_1.HttpException && err.getStatus?.() === 429) {
+                throw err;
+            }
+            return true;
+        }
+    }
+    _getValueFromPathOrRoot(obj, path) {
+        if (!obj)
+            return undefined;
+        const valueFromPath = path
+            .split('.')
+            .reduce((acc, key) => acc && typeof acc === 'object' && key in acc
+            ? acc[key]
+            : undefined, obj);
+        if (valueFromPath !== undefined) {
+            return valueFromPath;
+        }
+        return obj[path];
+    }
+    _resolveDateExpr(expr) {
+        const match = expr.match(/^date\(([-\d]+)([dMy])?\)$/);
+        if (!match)
+            return expr;
+        const amount = parseInt(match[1], 10);
+        const unit = match[2] || 'd';
+        const date = new Date();
+        switch (unit) {
+            case 'd':
+                date.setDate(date.getDate() + amount);
+                break;
+            case 'M':
+                date.setMonth(date.getMonth() + amount);
+                break;
+            case 'y':
+                date.setFullYear(date.getFullYear() + amount);
+                break;
+        }
+        if (amount !== 0) {
+            date.setHours(0, 0, 0, 0);
+        }
+        return date.toISOString();
+    }
+    _resolveValue(raw, context, defaultValue) {
+        if (typeof raw === 'string') {
+            if (!raw) {
+                if (defaultValue)
+                    return this._resolveValue(defaultValue, context);
+                return;
+            }
+            if (raw.startsWith(':')) {
+                const path = raw.slice(1);
+                const val = this._getByPath(context, path);
+                return this._resolveValue(val, context);
+            }
+            if (/^\s*fn:/.test(raw)) {
+                return;
+            }
+            if (raw.startsWith('date(')) {
+                return this._resolveDateExpr(raw);
+            }
+            return raw;
+        }
+        if (typeof raw === 'object' &&
+            raw !== null &&
+            'from' in raw &&
+            'to' in raw) {
+            const obj = raw;
+            return {
+                from: this._resolveValue(obj.from, context),
+                to: this._resolveValue(obj.to, context),
+            };
+        }
+        return raw;
+    }
+    _resolveVariables(vars, context) {
+        if (!vars ||
+            !vars.queries ||
+            !Array.isArray(vars.queries) ||
+            !vars.queries.length)
+            return vars;
+        return {
+            queries: vars.queries.map((q) => ({
+                ...q,
+                query: Array.isArray(q.query)
+                    ? q.query.map(entry => ({
+                        ...entry,
+                        value: this._resolveValue(entry.value, context ?? {}, entry?.defaultValue),
+                    }))
+                    : [],
+            })),
+        };
+    }
+    _resolveParams(vars, context) {
+        if (!vars.variables ||
+            !vars.variables.queries ||
+            !vars.variables.queries.length)
+            return {};
+        return {
+            ...vars.variables,
+            queries: vars.variables.queries.map(q => ({
+                ...q,
+                value: this._resolveValue(q.value, context, q?.defaultValue),
+            })),
+        };
+    }
+    _getByPath(obj, path) {
+        if (!path)
+            return undefined;
+        const parts = path.replace(/\[(\d+)\]/g, '.$1').split('.');
+        return parts.reduce((acc, key) => {
+            if (acc && typeof acc === 'object') {
+                return acc[key];
+            }
+            return undefined;
+        }, obj);
+    }
+    async _injectFnsResults(variables, entity) {
+        if (!variables || !variables.functions)
+            return;
+        const fns = variables.functions;
+        for (const fn of fns) {
+            const contextVars = this._resolveParams(fn, entity);
+            const value = await this.ruleEngine.getResultCustomFunction(fn.fn, contextVars);
+            this._updateFnsResults(variables, fn.name, value);
+        }
+    }
+    _updateFnsResults(vars, fnName, value) {
+        if (!vars.queries || !Array.isArray(vars.queries))
+            return;
+        vars.queries.forEach((q) => {
+            if (!Array.isArray(q.query))
+                return;
+            q.query.forEach(cond => {
+                if (/^\s*fn:/.test(cond.value) || typeof cond.value === 'object') {
+                    if (typeof cond.value === 'object') {
+                        if (cond.value.to.replace(/^fn:/, '') === fnName) {
+                            if (value) {
+                                cond.value.to = value;
+                            }
+                            else {
+                                cond.value.to = cond?.defaultValue?.to;
+                            }
+                        }
+                        const fromStr = typeof cond.value?.from === 'string' ? cond.value.from : '';
+                        if (fromStr.replace(/^fn:/, '') === fnName) {
+                            if (value) {
+                                cond.value.from = value;
+                            }
+                            else {
+                                cond.value.from = cond?.defaultValue?.from;
+                            }
+                        }
+                        return;
+                    }
+                    const name = cond.value.replace(/^fn:/, '');
+                    if (name === fnName) {
+                        cond.value = value;
+                    }
+                }
+            });
+        });
+    }
+};
+exports.RateLimitingRuleGuard = RateLimitingRuleGuard;
+exports.RateLimitingRuleGuard = RateLimitingRuleGuard = RateLimitingRuleGuard_1 = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(2, (0, common_1.Inject)('RULE_ENGINE_INSTANCE')),
+    tslib_1.__metadata("design:paramtypes", [core_1.Reflector,
+        rule_service_1.RuleService,
+        rule_engine_service_1.RuleEngineService])
+], RateLimitingRuleGuard);

package/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+export * from './decorators/rate-limiting-rule.decorator';
+export * from './guards/rate-limiting.guard';
+export * from './rate-limiting.module';
+export * from './rules/rule.service';
+export * from './shared/dsl/dsl.interface';
+export * from './shared/dsl/dsl.service';
+export * from './shared/rule-engine/rule-engine.module';
+export * from './validators/rule.constraint';
+export declare const RULE_ENGINE_INSTANCE = "RULE_ENGINE_INSTANCE";
+export declare const CUSTOM_RULE_FUNCTIONS = "CUSTOM_RULE_FUNCTIONS";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,2CAA2C,CAAC;AAC1D,cAAc,8BAA8B,CAAC;AAC7C,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0BAA0B,CAAC;AACzC,cAAc,yCAAyC,CAAC;AACxD,cAAc,8BAA8B,CAAC;AAE7C,eAAO,MAAM,oBAAoB,yBAAyB,CAAC;AAC3D,eAAO,MAAM,qBAAqB,0BAA0B,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUSTOM_RULE_FUNCTIONS = exports.RULE_ENGINE_INSTANCE = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./decorators/rate-limiting-rule.decorator"), exports);
+tslib_1.__exportStar(require("./guards/rate-limiting.guard"), exports);
+tslib_1.__exportStar(require("./rate-limiting.module"), exports);
+tslib_1.__exportStar(require("./rules/rule.service"), exports);
+tslib_1.__exportStar(require("./shared/dsl/dsl.interface"), exports);
+tslib_1.__exportStar(require("./shared/dsl/dsl.service"), exports);
+tslib_1.__exportStar(require("./shared/rule-engine/rule-engine.module"), exports);
+tslib_1.__exportStar(require("./validators/rule.constraint"), exports);
+exports.RULE_ENGINE_INSTANCE = 'RULE_ENGINE_INSTANCE';
+exports.CUSTOM_RULE_FUNCTIONS = 'CUSTOM_RULE_FUNCTIONS';

package/dist/src/main.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=main.d.ts.map

package/dist/src/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.ts"],"names":[],"mappings":""}

package/dist/src/main.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@nestjs/core");
+const rate_limiting_module_1 = require("./rate-limiting.module");
+async function bootstrap() {
+    const app = await core_1.NestFactory.create(rate_limiting_module_1.RateLimitingModule);
+    await app.listen(process.env.PORT ?? 3040);
+}
+bootstrap();

package/dist/src/object.utils.d.ts

@@ -0,0 +1,3 @@
+export declare const withDefaultNull: <T extends object>(context: T) => T;
+export declare const calculateDepth: (expression: string) => number | undefined;
+//# sourceMappingURL=object.utils.d.ts.map

package/dist/src/object.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.utils.d.ts","sourceRoot":"","sources":["../../src/object.utils.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe,GAAI,CAAC,SAAS,MAAM,EAAE,SAAS,CAAC,KAAG,CAqB9D,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,YAAY,MAAM,KAAG,MAAM,GAAG,SAgB5D,CAAC"}

package/dist/src/object.utils.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateDepth = exports.withDefaultNull = void 0;
+const withDefaultNull = (context) => {
+    return new Proxy(context, {
+        get(target, prop, receiver) {
+            const value = Reflect.get(target, prop, receiver);
+            if (value === undefined) {
+                return null;
+            }
+            if (value !== null &&
+                typeof value === 'object' &&
+                !Array.isArray(value) &&
+                value.constructor === Object) {
+                return (0, exports.withDefaultNull)(value);
+            }
+            return value;
+        },
+    });
+};
+exports.withDefaultNull = withDefaultNull;
+const calculateDepth = (expression) => {
+    if (!expression)
+        return;
+    let depth = 0;
+    let maxDepth = 0;
+    for (const char of expression) {
+        if (char === '(') {
+            depth++;
+            maxDepth = Math.max(maxDepth, depth);
+        }
+        else if (char === ')') {
+            depth--;
+        }
+    }
+    return depth;
+};
+exports.calculateDepth = calculateDepth;

package/dist/src/rate-limiting.module.d.ts

@@ -0,0 +1,6 @@
+import { DynamicModule } from '@nestjs/common';
+export declare const RATE_LIMIT_DB_CONNECTION = "RATE_LIMIT_DB_CONNECTION";
+export declare class RateLimitingModule {
+    static forRoot(connectionToken?: string): DynamicModule;
+}
+//# sourceMappingURL=rate-limiting.module.d.ts.map

package/dist/src/rate-limiting.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rate-limiting.module.d.ts","sourceRoot":"","sources":["../../src/rate-limiting.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,aAAa,EAAU,MAAM,gBAAgB,CAAC;AAK/D,eAAO,MAAM,wBAAwB,6BAA6B,CAAC;AAEnE,qBAEa,kBAAkB;IAC7B,MAAM,CAAC,OAAO,CAAC,eAAe,SAAwB,GAAG,aAAa;CASvE"}

package/dist/src/rate-limiting.module.js

@@ -0,0 +1,26 @@
+"use strict";
+var RateLimitingModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitingModule = exports.RATE_LIMIT_DB_CONNECTION = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const rule_module_1 = require("./rules/rule.module");
+const rule_constraint_1 = require("./validators/rule.constraint");
+exports.RATE_LIMIT_DB_CONNECTION = 'RATE_LIMIT_DB_CONNECTION';
+let RateLimitingModule = RateLimitingModule_1 = class RateLimitingModule {
+    static forRoot(connectionToken = 'DATABASE_CONNECTION') {
+        return {
+            global: true,
+            module: RateLimitingModule_1,
+            imports: [rule_module_1.RuleModule.register(connectionToken)],
+            providers: [core_1.Reflector, rule_constraint_1.IsValidExpressionConstraint],
+            exports: [rule_module_1.RuleModule, core_1.Reflector],
+        };
+    }
+};
+exports.RateLimitingModule = RateLimitingModule;
+exports.RateLimitingModule = RateLimitingModule = RateLimitingModule_1 = tslib_1.__decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], RateLimitingModule);

package/dist/src/rules/dto/pagination.dto.d.ts

@@ -0,0 +1,6 @@
+export declare class PaginationDTO {
+    page: number;
+    order?: number | undefined;
+    limit: number;
+}
+//# sourceMappingURL=pagination.dto.d.ts.map

package/dist/src/rules/dto/pagination.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.dto.d.ts","sourceRoot":"","sources":["../../../../src/rules/dto/pagination.dto.ts"],"names":[],"mappings":"AAKA,qBAAa,aAAa;IAWxB,IAAI,SAAK;IAUT,KAAK,CAAC,qBAAM;IAIZ,KAAK,SAAM;CACZ"}

package/dist/src/rules/dto/pagination.dto.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginationDTO = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+class PaginationDTO {
+    page = 1;
+    order = -1;
+    limit = 10;
+}
+exports.PaginationDTO = PaginationDTO;
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: Number, required: false }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsInt)(),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_transformer_1.Transform)(({ value }) => {
+        const parsed = Number.parseInt(value);
+        if (parsed === 0)
+            throw new common_1.BadRequestException('Page needs to be bigger than 0');
+        return parsed;
+    }),
+    tslib_1.__metadata("design:type", Object)
+], PaginationDTO.prototype, "page", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: Number,
+        required: false,
+        default: -1,
+        description: 'You can add more than one field by using trailing commas ex: 1,-1',
+    }),
+    (0, class_validator_1.IsOptional)(),
+    tslib_1.__metadata("design:type", Object)
+], PaginationDTO.prototype, "order", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({ type: Number, required: false, default: 10 }),
+    (0, class_validator_1.IsOptional)(),
+    tslib_1.__metadata("design:type", Object)
+], PaginationDTO.prototype, "limit", void 0);

package/dist/src/rules/dto/rule.dto.d.ts

@@ -0,0 +1,24 @@
+import { IFindRule, IRule } from '../interface/rule.interface';
+import { PaginationDTO } from './pagination.dto';
+export declare class CreateRuleDTO implements IRule {
+    name: string;
+    expression: string;
+    targetAction: string;
+    errorMessage?: string;
+    variables?: Record<string, unknown>;
+    variablesRequired?: boolean;
+    productType?: string;
+    partner?: string;
+    market?: string;
+    provider?: string;
+}
+export declare class FindRuleDTO extends PaginationDTO implements IFindRule {
+    name?: string;
+    targetAction?: string;
+    partner?: string;
+    productType?: string;
+    isEnabled?: boolean;
+    provider?: string;
+    market?: string;
+}
+//# sourceMappingURL=rule.dto.d.ts.map

package/dist/src/rules/dto/rule.dto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.dto.d.ts","sourceRoot":"","sources":["../../../../src/rules/dto/rule.dto.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,qBAAa,aAAc,YAAW,KAAK;IAOzC,IAAI,EAAG,MAAM,CAAC;IASd,UAAU,EAAG,MAAM,CAAC;IAQpB,YAAY,EAAG,MAAM,CAAC;IAStB,YAAY,CAAC,EAAE,MAAM,CAAC;IAStB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IASpC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAS5B,WAAW,CAAC,EAAE,MAAM,CAAC;IAQrB,OAAO,CAAC,EAAE,MAAM,CAAC;IASjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAShB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,qBAAa,WAAY,SAAQ,aAAc,YAAW,SAAS;IAQjE,IAAI,CAAC,EAAE,MAAM,CAAC;IASd,YAAY,CAAC,EAAE,MAAM,CAAC;IAStB,OAAO,CAAC,EAAE,MAAM,CAAC;IASjB,WAAW,CAAC,EAAE,MAAM,CAAC;IASrB,SAAS,CAAC,EAAE,OAAO,CAAC;IASpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IASlB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/dist/src/rules/dto/rule.dto.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FindRuleDTO = exports.CreateRuleDTO = void 0;
+const tslib_1 = require("tslib");
+const swagger_1 = require("@nestjs/swagger");
+const class_validator_1 = require("class-validator");
+const rule_validator_1 = require("../../validators/rule.validator");
+const pagination_dto_1 = require("./pagination.dto");
+class CreateRuleDTO {
+    name;
+    expression;
+    targetAction;
+    errorMessage;
+    variables;
+    variablesRequired;
+    productType;
+    partner;
+    market;
+    provider;
+}
+exports.CreateRuleDTO = CreateRuleDTO;
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: String,
+        required: true,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    tslib_1.__metadata("design:type", String)
+], CreateRuleDTO.prototype, "name", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: String,
+        required: true,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    (0, rule_validator_1.IsValidExpression)(),
+    tslib_1.__metadata("design:type", String)
+], CreateRuleDTO.prototype, "expression", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: String,
+        required: true,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    tslib_1.__metadata("design:type", String)
+], CreateRuleDTO.prototype, "targetAction", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: String,
+        required: false,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    tslib_1.__metadata("design:type", String)
+], CreateRuleDTO.prototype, "errorMessage", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: Object,
+        required: false,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsObject)(),
+    (0, class_validator_1.IsOptional)(),
+    tslib_1.__metadata("design:type", Object)
+], CreateRuleDTO.prototype, "variables", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: Boolean,
+        required: false,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsBoolean)(),
+    (0, class_validator_1.IsOptional)(),
+    tslib_1.__metadata("design:type", Boolean)
+], CreateRuleDTO.prototype, "variablesRequired", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: String,
+        required: false,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    tslib_1.__metadata("design:type", String)
+], CreateRuleDTO.prototype, "productType", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: String,
+        required: true,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    tslib_1.__metadata("design:type", String)
+], CreateRuleDTO.prototype, "partner", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: String,
+        required: true,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    tslib_1.__metadata("design:type", String)
+], CreateRuleDTO.prototype, "market", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: String,
+        required: false,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    tslib_1.__metadata("design:type", String)
+], CreateRuleDTO.prototype, "provider", void 0);
+class FindRuleDTO extends pagination_dto_1.PaginationDTO {
+    name;
+    targetAction;
+    partner;
+    productType;
+    isEnabled;
+    provider;
+    market;
+}
+exports.FindRuleDTO = FindRuleDTO;
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: String,
+        required: false,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    tslib_1.__metadata("design:type", String)
+], FindRuleDTO.prototype, "name", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: String,
+        required: false,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    tslib_1.__metadata("design:type", String)
+], FindRuleDTO.prototype, "targetAction", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: String,
+        required: true,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    tslib_1.__metadata("design:type", String)
+], FindRuleDTO.prototype, "partner", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: String,
+        required: true,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    tslib_1.__metadata("design:type", String)
+], FindRuleDTO.prototype, "productType", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: String,
+        required: false,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsBoolean)(),
+    (0, class_validator_1.IsOptional)(),
+    tslib_1.__metadata("design:type", Boolean)
+], FindRuleDTO.prototype, "isEnabled", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: String,
+        required: false,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    tslib_1.__metadata("design:type", String)
+], FindRuleDTO.prototype, "provider", void 0);
+tslib_1.__decorate([
+    (0, swagger_1.ApiProperty)({
+        type: String,
+        required: false,
+    }),
+    (0, class_validator_1.IsNotEmpty)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.IsOptional)(),
+    tslib_1.__metadata("design:type", String)
+], FindRuleDTO.prototype, "market", void 0);

package/dist/src/rules/interface/pagination.interface.d.ts

@@ -0,0 +1,7 @@
+export interface IPagination<T> {
+    currentPage: number;
+    data: T;
+    total: number;
+    totalPages: number;
+}
+//# sourceMappingURL=pagination.interface.d.ts.map