@edirect/rate-limit-module 11.0.62 → 11.0.64

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

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.interface.d.ts","sourceRoot":"","sources":["../../../../src/rules/interface/pagination.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,CAAC,CAAC;IACR,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB"}

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

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

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

@@ -0,0 +1,29 @@
+export interface IRule {
+    ruleId?: string;
+    name: string;
+    targetAction?: string;
+    expression: string;
+    enabled?: boolean;
+    errorMessage?: string;
+    partner?: string;
+    provider?: string;
+    market?: string;
+    productType?: string;
+    variables?: Record<string, unknown>;
+    variablesRequired?: boolean;
+    deletedAt?: Date;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+export interface IFindRule {
+    name?: string;
+    targetAction?: string;
+    enabled?: string;
+    partner?: string | undefined;
+    provider?: string | undefined;
+    market?: string | undefined;
+    productType?: string | undefined;
+    page: number;
+    limit: number;
+}
+//# sourceMappingURL=rule.interface.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule.interface.d.ts","sourceRoot":"","sources":["../../../../src/rules/interface/rule.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,KAAK;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,SAAS,CAAC,EAAE,IAAI,CAAC;IACjB,SAAS,CAAC,EAAE,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,SAAS;IACxB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf"}

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

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

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

@@ -0,0 +1,14 @@
+import { CreateRuleDTO, FindRuleDTO } from './dto/rule.dto';
+import { IPagination } from './interface/pagination.interface';
+import { IRule } from './interface/rule.interface';
+import { RuleService } from './rule.service';
+export declare class RuleController {
+    private readonly ruleService;
+    constructor(ruleService: RuleService);
+    create(dto: CreateRuleDTO): Promise<IRule>;
+    findAll(query: FindRuleDTO): Promise<IPagination<IRule[]>>;
+    findOne(id: string): Promise<IRule>;
+    updateSale(id: string, patchData: Partial<IRule>): Promise<IRule | null>;
+    delete(id: string): Promise<void>;
+}
+//# sourceMappingURL=rule.controller.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule.controller.d.ts","sourceRoot":"","sources":["../../../src/rules/rule.controller.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAC/D,OAAO,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAM7C,qBAEa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,WAAW;gBAAX,WAAW,EAAE,WAAW;IAMrD,MAAM,CAAS,GAAG,EAAE,aAAa;IAOjC,OAAO,CAAU,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC;IAOnE,OAAO,CAAc,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAOhD,UAAU,CAAc,EAAE,EAAE,MAAM,EAAU,SAAS,EAAE,OAAO,CAAC,KAAK,CAAC;IAOrE,MAAM,CAAc,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAG/C"}

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleController = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const auth_1 = require("@edirect/auth");
+const rule_dto_1 = require("./dto/rule.dto");
+const rule_service_1 = require("./rule.service");
+var ResourceServiceEnum;
+(function (ResourceServiceEnum) {
+    ResourceServiceEnum["DEFAULT"] = "Default Resource";
+})(ResourceServiceEnum || (ResourceServiceEnum = {}));
+let RuleController = class RuleController {
+    ruleService;
+    constructor(ruleService) {
+        this.ruleService = ruleService;
+    }
+    create(dto) {
+        return this.ruleService.create(dto);
+    }
+    findAll(query) {
+        return this.ruleService.findAll(query);
+    }
+    findOne(id) {
+        return this.ruleService.findById(id);
+    }
+    updateSale(id, patchData) {
+        return this.ruleService.updateOne(id, patchData);
+    }
+    delete(id) {
+        return this.ruleService.delete(id);
+    }
+};
+exports.RuleController = RuleController;
+tslib_1.__decorate([
+    (0, common_1.Post)(),
+    (0, swagger_1.ApiResponse)({ status: 201 }),
+    (0, auth_1.Resources)(ResourceServiceEnum.DEFAULT),
+    (0, common_1.UsePipes)(new common_1.ValidationPipe({ transform: true })),
+    tslib_1.__param(0, (0, common_1.Body)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [rule_dto_1.CreateRuleDTO]),
+    tslib_1.__metadata("design:returntype", void 0)
+], RuleController.prototype, "create", null);
+tslib_1.__decorate([
+    (0, common_1.Get)(),
+    (0, auth_1.Resources)(ResourceServiceEnum.DEFAULT),
+    (0, common_1.UsePipes)(new common_1.ValidationPipe({ transform: true })),
+    tslib_1.__param(0, (0, common_1.Query)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [rule_dto_1.FindRuleDTO]),
+    tslib_1.__metadata("design:returntype", Promise)
+], RuleController.prototype, "findAll", null);
+tslib_1.__decorate([
+    (0, common_1.Get)(':id'),
+    (0, auth_1.Resources)(ResourceServiceEnum.DEFAULT),
+    (0, common_1.UsePipes)(new common_1.ValidationPipe({ transform: true })),
+    tslib_1.__param(0, (0, common_1.Param)('id')),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], RuleController.prototype, "findOne", null);
+tslib_1.__decorate([
+    (0, common_1.Patch)(':id'),
+    (0, auth_1.Resources)(ResourceServiceEnum.DEFAULT),
+    (0, common_1.UsePipes)(new common_1.ValidationPipe({ transform: true })),
+    tslib_1.__param(0, (0, common_1.Param)('id')),
+    tslib_1.__param(1, (0, common_1.Body)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, Object]),
+    tslib_1.__metadata("design:returntype", void 0)
+], RuleController.prototype, "updateSale", null);
+tslib_1.__decorate([
+    (0, common_1.Delete)(':id'),
+    (0, auth_1.Resources)(ResourceServiceEnum.DEFAULT),
+    (0, common_1.UsePipes)(new common_1.ValidationPipe({ transform: true })),
+    tslib_1.__param(0, (0, common_1.Param)('id')),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String]),
+    tslib_1.__metadata("design:returntype", Promise)
+], RuleController.prototype, "delete", null);
+exports.RuleController = RuleController = tslib_1.__decorate([
+    (0, swagger_1.ApiTags)('rate-limiting-rule'),
+    (0, common_1.Controller)('/rule'),
+    tslib_1.__metadata("design:paramtypes", [rule_service_1.RuleService])
+], RuleController);

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

@@ -0,0 +1,5 @@
+import { DynamicModule } from '@nestjs/common';
+export declare class RuleModule {
+    static register(connectionToken: string): DynamicModule;
+}
+//# sourceMappingURL=rule.module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule.module.d.ts","sourceRoot":"","sources":["../../../src/rules/rule.module.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAU,MAAM,gBAAgB,CAAC;AASvD,qBACa,UAAU;IACrB,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,aAAa;CAoBxD"}

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

@@ -0,0 +1,36 @@
+"use strict";
+var RuleModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleModule = void 0;
+const tslib_1 = require("tslib");
+const logger_1 = require("@edirect/logger");
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+const shared_module_1 = require("../shared/shared.module");
+const rule_controller_1 = require("./rule.controller");
+const rule_repository_1 = require("./rule.repository");
+const rule_schema_1 = require("./rule.schema");
+const rule_service_1 = require("./rule.service");
+let RuleModule = RuleModule_1 = class RuleModule {
+    static register(connectionToken) {
+        const enableController = process.env.ENABLE_RATE_LIMITING_RULE_CONTROLLER === 'true';
+        const modelProvider = {
+            provide: (0, mongoose_1.getModelToken)(rule_schema_1.RateLimitingRule.name),
+            useFactory: (connection) => {
+                return connection.model(rule_schema_1.RateLimitingRule.name, rule_schema_1.RateLimitingRuleSchema);
+            },
+            inject: [connectionToken],
+        };
+        return {
+            module: RuleModule_1,
+            imports: [logger_1.LoggerModule, shared_module_1.SharedModule],
+            controllers: enableController ? [rule_controller_1.RuleController] : [],
+            providers: [modelProvider, rule_service_1.RuleService, rule_repository_1.RuleRepository],
+            exports: [rule_service_1.RuleService, rule_repository_1.RuleRepository],
+        };
+    }
+};
+exports.RuleModule = RuleModule;
+exports.RuleModule = RuleModule = RuleModule_1 = tslib_1.__decorate([
+    (0, common_1.Module)({})
+], RuleModule);

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

@@ -0,0 +1,15 @@
+import { Model } from 'mongoose';
+import { IPagination } from './interface/pagination.interface';
+import { IFindRule, IRule } from './interface/rule.interface';
+import { RuleDocument } from './rule.schema';
+export declare class RuleRepository {
+    private readonly model;
+    private readonly MAX_LIMIT;
+    constructor(model: Model<RuleDocument>);
+    save(data: IRule): Promise<IRule>;
+    update(ruleRateId: string, data: Partial<IRule>): Promise<IRule | null>;
+    findOneByRateId(rateRuleId: string): Promise<IRule | null>;
+    findAll(query: IFindRule): Promise<IPagination<IRule[]>>;
+    private buildQuery;
+}
+//# sourceMappingURL=rule.repository.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule.repository.d.ts","sourceRoot":"","sources":["../../../src/rules/rule.repository.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAoB,YAAY,EAAE,MAAM,eAAe,CAAC;AAE/D,qBACa,cAAc;IAKvB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAJxB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAe;gBAItB,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC;IAGvC,IAAI,CAAC,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;IAIjC,MAAM,CACV,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,GACnB,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAMlB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAShE,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC;IA2CxD,OAAO,CAAC,UAAU;CASnB"}

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleRepository = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+const mongoose_2 = require("mongoose");
+const rule_schema_1 = require("./rule.schema");
+let RuleRepository = class RuleRepository {
+    model;
+    MAX_LIMIT = 100;
+    constructor(model) {
+        this.model = model;
+    }
+    async save(data) {
+        return new this.model(data).save();
+    }
+    async update(ruleRateId, data) {
+        return this.model.findOneAndUpdate({ ruleId: ruleRateId }, data, {
+            new: true,
+        });
+    }
+    async findOneByRateId(rateRuleId) {
+        return this.model
+            .findOne({ ruleId: rateRuleId })
+            .select('-__v')
+            .select('-_id')
+            .lean()
+            .exec();
+    }
+    findAll(query) {
+        const { page, limit } = query;
+        const LIMIT = limit && limit < this.MAX_LIMIT ? limit : this.MAX_LIMIT;
+        let limitCount = 500;
+        while (limitCount < page * LIMIT) {
+            limitCount += 500;
+        }
+        const queryBuilt = this.buildQuery(query);
+        const count = this.model
+            .countDocuments(queryBuilt)
+            .limit(limitCount)
+            .exec();
+        const rules = this.model
+            .find(queryBuilt)
+            .limit(LIMIT)
+            .skip((page - 1) * LIMIT)
+            .select('-__v')
+            .exec();
+        return Promise.all([count, rules]).then(values => {
+            const [count, result] = values;
+            const mapped = result.map(e => e.toJSON());
+            let currentCount = count;
+            if (count > limitCount) {
+                currentCount = limitCount;
+            }
+            const totalPages = Math.ceil(count / LIMIT);
+            return {
+                total: currentCount,
+                currentPage: +page || 1,
+                totalPages,
+                data: mapped,
+            };
+        });
+    }
+    buildQuery(queryParameters) {
+        return Object.entries(queryParameters).reduce((acc, [key, value]) => {
+            if (key === 'page' || key === 'limit')
+                return acc;
+            acc[key] = value || '';
+            return acc;
+        }, {});
+    }
+};
+exports.RuleRepository = RuleRepository;
+exports.RuleRepository = RuleRepository = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, mongoose_1.InjectModel)(rule_schema_1.RateLimitingRule.name)),
+    tslib_1.__metadata("design:paramtypes", [mongoose_2.Model])
+], RuleRepository);

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

@@ -0,0 +1,166 @@
+import { Document } from 'mongoose';
+import { IRule } from './interface/rule.interface';
+export type RuleDocument = RateLimitingRule & Document;
+export declare class RateLimitingRule implements IRule {
+    ruleId: string;
+    name: string;
+    targetAction?: string;
+    expression: string;
+    enabled: boolean;
+    market: string;
+    errorMessage?: string;
+    partner: string;
+    provider?: string;
+    productType?: string;
+    variables?: Record<string, string>;
+    variablesRequired?: boolean;
+    deletedAt?: Date;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+export declare const RateLimitingRuleSchema: import("mongoose").Schema<RateLimitingRule, import("mongoose").Model<RateLimitingRule, any, any, any, any, any, RateLimitingRule>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+    id: string;
+}, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & import("mongoose").HydratedDocumentOverrides<{
+    id: string;
+}>, {
+    ruleId?: import("mongoose").SchemaDefinitionProperty<string, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & import("mongoose").HydratedDocumentOverrides<{
+        id: string;
+    }>> | undefined;
+    name?: import("mongoose").SchemaDefinitionProperty<string, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & import("mongoose").HydratedDocumentOverrides<{
+        id: string;
+    }>> | undefined;
+    targetAction?: import("mongoose").SchemaDefinitionProperty<string | undefined, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & import("mongoose").HydratedDocumentOverrides<{
+        id: string;
+    }>> | undefined;
+    expression?: import("mongoose").SchemaDefinitionProperty<string, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & import("mongoose").HydratedDocumentOverrides<{
+        id: string;
+    }>> | undefined;
+    enabled?: import("mongoose").SchemaDefinitionProperty<boolean, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & import("mongoose").HydratedDocumentOverrides<{
+        id: string;
+    }>> | undefined;
+    market?: import("mongoose").SchemaDefinitionProperty<string, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & import("mongoose").HydratedDocumentOverrides<{
+        id: string;
+    }>> | undefined;
+    errorMessage?: import("mongoose").SchemaDefinitionProperty<string | undefined, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & import("mongoose").HydratedDocumentOverrides<{
+        id: string;
+    }>> | undefined;
+    partner?: import("mongoose").SchemaDefinitionProperty<string, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & import("mongoose").HydratedDocumentOverrides<{
+        id: string;
+    }>> | undefined;
+    provider?: import("mongoose").SchemaDefinitionProperty<string | undefined, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & import("mongoose").HydratedDocumentOverrides<{
+        id: string;
+    }>> | undefined;
+    productType?: import("mongoose").SchemaDefinitionProperty<string | undefined, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & import("mongoose").HydratedDocumentOverrides<{
+        id: string;
+    }>> | undefined;
+    variables?: import("mongoose").SchemaDefinitionProperty<Record<string, string> | undefined, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & import("mongoose").HydratedDocumentOverrides<{
+        id: string;
+    }>> | undefined;
+    variablesRequired?: import("mongoose").SchemaDefinitionProperty<boolean | undefined, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & import("mongoose").HydratedDocumentOverrides<{
+        id: string;
+    }>> | undefined;
+    deletedAt?: import("mongoose").SchemaDefinitionProperty<Date | undefined, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & import("mongoose").HydratedDocumentOverrides<{
+        id: string;
+    }>> | undefined;
+    createdAt?: import("mongoose").SchemaDefinitionProperty<Date | undefined, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & import("mongoose").HydratedDocumentOverrides<{
+        id: string;
+    }>> | undefined;
+    updatedAt?: import("mongoose").SchemaDefinitionProperty<Date | undefined, RateLimitingRule, Document<unknown, {}, RateLimitingRule, {
+        id: string;
+    }, import("mongoose").DefaultSchemaOptions> & Omit<RateLimitingRule & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & import("mongoose").HydratedDocumentOverrides<{
+        id: string;
+    }>> | undefined;
+}, RateLimitingRule>;
+//# sourceMappingURL=rule.schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule.schema.d.ts","sourceRoot":"","sources":["../../../src/rules/rule.schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC,OAAO,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAEnD,MAAM,MAAM,YAAY,GAAG,gBAAgB,GAAG,QAAQ,CAAC;AAEvD,qBACa,gBAAiB,YAAW,KAAK;IAU5C,MAAM,EAAG,MAAM,CAAC;IAMhB,IAAI,EAAG,MAAM,CAAC;IAMd,YAAY,CAAC,EAAE,MAAM,CAAC;IAMtB,UAAU,EAAG,MAAM,CAAC;IAOpB,OAAO,EAAG,OAAO,CAAC;IAMlB,MAAM,EAAG,MAAM,CAAC;IAMhB,YAAY,CAAC,EAAE,MAAM,CAAC;IAMtB,OAAO,EAAG,MAAM,CAAC;IAMjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAMlB,WAAW,CAAC,EAAE,MAAM,CAAC;IAMrB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAMnC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAM5B,SAAS,CAAC,EAAE,IAAI,CAAC;IAMjB,SAAS,CAAC,EAAE,IAAI,CAAC;IAMjB,SAAS,CAAC,EAAE,IAAI,CAAC;CAClB;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACa,CAAC"}

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

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitingRuleSchema = exports.RateLimitingRule = void 0;
+const tslib_1 = require("tslib");
+const mongoose_1 = require("@nestjs/mongoose");
+let RateLimitingRule = class RateLimitingRule {
+    ruleId;
+    name;
+    targetAction;
+    expression;
+    enabled;
+    market;
+    errorMessage;
+    partner;
+    provider;
+    productType;
+    variables;
+    variablesRequired;
+    deletedAt;
+    createdAt;
+    updatedAt;
+};
+exports.RateLimitingRule = RateLimitingRule;
+tslib_1.__decorate([
+    (0, mongoose_1.Prop)({
+        required: true,
+        unique: true,
+        default: async () => {
+            const { v4: uuidv4 } = await import('uuid');
+            return uuidv4();
+        },
+        type: String,
+    }),
+    tslib_1.__metadata("design:type", String)
+], RateLimitingRule.prototype, "ruleId", void 0);
+tslib_1.__decorate([
+    (0, mongoose_1.Prop)({
+        required: true,
+        type: String,
+    }),
+    tslib_1.__metadata("design:type", String)
+], RateLimitingRule.prototype, "name", void 0);
+tslib_1.__decorate([
+    (0, mongoose_1.Prop)({
+        required: true,
+        type: String,
+    }),
+    tslib_1.__metadata("design:type", String)
+], RateLimitingRule.prototype, "targetAction", void 0);
+tslib_1.__decorate([
+    (0, mongoose_1.Prop)({
+        required: true,
+        type: String,
+    }),
+    tslib_1.__metadata("design:type", String)
+], RateLimitingRule.prototype, "expression", void 0);
+tslib_1.__decorate([
+    (0, mongoose_1.Prop)({
+        required: true,
+        default: true,
+        type: Boolean,
+    }),
+    tslib_1.__metadata("design:type", Boolean)
+], RateLimitingRule.prototype, "enabled", void 0);
+tslib_1.__decorate([
+    (0, mongoose_1.Prop)({
+        required: false,
+        type: String,
+    }),
+    tslib_1.__metadata("design:type", String)
+], RateLimitingRule.prototype, "market", void 0);
+tslib_1.__decorate([
+    (0, mongoose_1.Prop)({
+        required: false,
+        type: String,
+    }),
+    tslib_1.__metadata("design:type", String)
+], RateLimitingRule.prototype, "errorMessage", void 0);
+tslib_1.__decorate([
+    (0, mongoose_1.Prop)({
+        required: true,
+        type: String,
+    }),
+    tslib_1.__metadata("design:type", String)
+], RateLimitingRule.prototype, "partner", void 0);
+tslib_1.__decorate([
+    (0, mongoose_1.Prop)({
+        required: false,
+        type: String,
+    }),
+    tslib_1.__metadata("design:type", String)
+], RateLimitingRule.prototype, "provider", void 0);
+tslib_1.__decorate([
+    (0, mongoose_1.Prop)({
+        required: false,
+        type: String,
+    }),
+    tslib_1.__metadata("design:type", String)
+], RateLimitingRule.prototype, "productType", void 0);
+tslib_1.__decorate([
+    (0, mongoose_1.Prop)({
+        required: false,
+        type: Object,
+    }),
+    tslib_1.__metadata("design:type", Object)
+], RateLimitingRule.prototype, "variables", void 0);
+tslib_1.__decorate([
+    (0, mongoose_1.Prop)({
+        required: false,
+        type: Boolean,
+    }),
+    tslib_1.__metadata("design:type", Boolean)
+], RateLimitingRule.prototype, "variablesRequired", void 0);
+tslib_1.__decorate([
+    (0, mongoose_1.Prop)({
+        required: false,
+        type: Date,
+    }),
+    tslib_1.__metadata("design:type", Date)
+], RateLimitingRule.prototype, "deletedAt", void 0);
+tslib_1.__decorate([
+    (0, mongoose_1.Prop)({
+        required: false,
+        type: Date,
+    }),
+    tslib_1.__metadata("design:type", Date)
+], RateLimitingRule.prototype, "createdAt", void 0);
+tslib_1.__decorate([
+    (0, mongoose_1.Prop)({
+        required: false,
+        type: Date,
+    }),
+    tslib_1.__metadata("design:type", Date)
+], RateLimitingRule.prototype, "updatedAt", void 0);
+exports.RateLimitingRule = RateLimitingRule = tslib_1.__decorate([
+    (0, mongoose_1.Schema)({ timestamps: true })
+], RateLimitingRule);
+exports.RateLimitingRuleSchema = mongoose_1.SchemaFactory.createForClass(RateLimitingRule);
+exports.RateLimitingRuleSchema.index({
+    partner: 1,
+    provider: 1,
+    productType: 1,
+});
+exports.RateLimitingRuleSchema.index({
+    partner: 1,
+    provider: 1,
+});
+exports.RateLimitingRuleSchema.index({
+    partner: 1,
+});

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

@@ -0,0 +1,26 @@
+import { LoggerService } from '@edirect/logger';
+import { CacheService } from '../shared/cache/cache.service';
+import { CreateRuleDTO } from './dto/rule.dto';
+import { IPagination } from './interface/pagination.interface';
+import { IFindRule, IRule } from './interface/rule.interface';
+import { RuleRepository } from './rule.repository';
+export declare class RuleService {
+    private readonly logger;
+    private readonly repository;
+    private readonly cacheService;
+    private readonly MAX_EXPRESSION_LENGTH;
+    private readonly MAX_EXPRESSION_DEPTH;
+    private readonly FORBIDDEN_PATTERNS;
+    constructor(logger: LoggerService, repository: RuleRepository, cacheService: CacheService);
+    create(input?: CreateRuleDTO): Promise<IRule>;
+    findAll(queryParameters: IFindRule): Promise<IPagination<IRule[]>>;
+    findAllWithoutPagination(queryParameters: IFindRule): Promise<IRule[]>;
+    findById(id: string): Promise<IRule>;
+    updateOne(id: string, fieldsToUpdate: Partial<IRule>): Promise<IRule | null>;
+    delete(id: string): Promise<void>;
+    private logError;
+    validateRuleExpression(expression: string): string | null;
+    private getFromCache;
+    private generateRateLimitingCountCacheKey;
+}
+//# sourceMappingURL=rule.service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rule.service.d.ts","sourceRoot":"","sources":["../../../src/rules/rule.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAShD,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC7D,OAAO,EAAE,aAAa,EAAe,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAC/D,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,qBACa,WAAW;IAqBpB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,YAAY;IAtB/B,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAO;IAC7C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAK;IAC1C,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAejC;gBAGiB,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,cAAc,EAC1B,YAAY,EAAE,YAAY;IAGvC,MAAM,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC;IA0B7C,OAAO,CAAC,eAAe,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC,CAAC;IASlE,wBAAwB,CAAC,eAAe,EAAE,SAAS,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC;IA0BtE,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAapC,SAAS,CACb,EAAE,EAAE,MAAM,EACV,cAAc,EAAE,OAAO,CAAC,KAAK,CAAC,GAC7B,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;IAgClB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBvC,OAAO,CAAC,QAAQ;IAOhB,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;YAoB3C,YAAY;IAiB1B,OAAO,CAAC,iCAAiC;CAuB1C"}