@edirect/rate-limit-module 11.0.45 → 11.0.47

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

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleService = void 0;
+const tslib_1 = require("tslib");
+const logger_1 = require("@edirect/logger");
+const common_1 = require("@nestjs/common");
+const object_utils_1 = require("../object.utils");
+const cache_service_1 = require("../shared/cache/cache.service");
+const rule_repository_1 = require("./rule.repository");
+let RuleService = class RuleService {
+    logger;
+    repository;
+    cacheService;
+    MAX_EXPRESSION_LENGTH = 500;
+    MAX_EXPRESSION_DEPTH = 8;
+    FORBIDDEN_PATTERNS = [
+        /constructor/i,
+        /__proto__/i,
+        /prototype/i,
+        /process/i,
+        /global/i,
+        /require/i,
+        /import/i,
+        /eval/i,
+        /Function/i,
+        /setTimeout/i,
+        /setInterval/i,
+        /api/i,
+        /request/i,
+        /\[".*"\s*\+\s*".*"\]/,
+    ];
+    constructor(logger, repository, cacheService) {
+        this.logger = logger;
+        this.repository = repository;
+        this.cacheService = cacheService;
+    }
+    async create(input) {
+        try {
+            if (!input)
+                throw new common_1.BadRequestException('[ERROR] payload invalid!');
+            const cacheKey = this.generateRateLimitingCountCacheKey({
+                partner: input?.partner,
+                provider: input?.provider,
+                productType: input?.productType,
+                market: input?.market,
+            });
+            if (cacheKey || cacheKey === '') {
+                const isDeleted = await this.cacheService.delete([cacheKey]);
+                if (!isDeleted) {
+                    await this.cacheService.deleteByPattern('rate-limit-config');
+                }
+            }
+            return this.repository.save(input);
+        }
+        catch (error) {
+            this.logError(`[ERROR] error to create rate limiting `, error);
+            throw error;
+        }
+    }
+    async findAll(queryParameters) {
+        try {
+            return this.repository.findAll(queryParameters);
+        }
+        catch (error) {
+            this.logError('[ERROR] error to find rate limiting', error);
+            throw new common_1.InternalServerErrorException();
+        }
+    }
+    async findAllWithoutPagination(queryParameters) {
+        try {
+            const cachedData = await this.getFromCache(queryParameters);
+            if (cachedData && cachedData.length)
+                return cachedData;
+            const { data } = await this.repository.findAll(queryParameters);
+            const cacheKey = this.generateRateLimitingCountCacheKey({
+                partner: queryParameters?.partner || '',
+                provider: queryParameters?.provider || '',
+                productType: queryParameters?.productType || '',
+                market: queryParameters?.market || '',
+            });
+            if (data && data.length) {
+                await this.cacheService.set(cacheKey, data, 3600);
+            }
+            return data;
+        }
+        catch (error) {
+            this.logError('[ERROR] error to fnd rate limiting', error);
+            throw new common_1.InternalServerErrorException();
+        }
+    }
+    async findById(id) {
+        try {
+            const rate = await this.repository.findOneByRateId(id);
+            if (!rate)
+                throw new common_1.NotFoundException('Rate Limiting rule');
+            return rate;
+        }
+        catch (error) {
+            this.logError('[ERROR] error to find quote by ID', error);
+            throw error;
+        }
+    }
+    async updateOne(id, fieldsToUpdate) {
+        try {
+            if (!id)
+                throw new common_1.NotFoundException('Rate Limiting rule');
+            const current = await this.repository.findOneByRateId(id);
+            if (!current)
+                throw new common_1.NotFoundException('Rate Limiting rule');
+            if (current.deletedAt) {
+                throw new common_1.GoneException(`Already Deleted at ${current.deletedAt}`);
+            }
+            const cacheKey = this.generateRateLimitingCountCacheKey({
+                partner: current?.partner || '',
+                provider: current?.provider || '',
+                productType: current?.productType || '',
+                market: current?.market || '',
+            });
+            if (cacheKey || cacheKey === '') {
+                const isDeleted = await this.cacheService.delete([cacheKey]);
+                if (!isDeleted) {
+                    await this.cacheService.deleteByPattern('rate-limit-config');
+                }
+            }
+            return this.repository.update(id, fieldsToUpdate);
+        }
+        catch (error) {
+            this.logError(`[ERROR] error to update ${id}`, error);
+            throw error;
+        }
+    }
+    async delete(id) {
+        try {
+            if (!id)
+                throw new common_1.NotFoundException('Rate limiting rule');
+            const rule = await this.repository.findOneByRateId(id);
+            if (rule?.deletedAt) {
+                throw new common_1.GoneException(`Already Deleted at ${rule.deletedAt}`);
+            }
+            await this.repository.update(id, {
+                deletedAt: new Date(),
+            });
+        }
+        catch (error) {
+            this.logError(`[ERROR] Error to delete rule`, error);
+            throw error;
+        }
+    }
+    logError(message, error) {
+        this.logger.error(message, error instanceof Error ? error.stack || error.message : String(error));
+    }
+    validateRuleExpression(expression) {
+        if (expression && expression.length > this.MAX_EXPRESSION_LENGTH) {
+            return `Expression too long: ${expression.length} chars`;
+        }
+        for (const pattern of this.FORBIDDEN_PATTERNS) {
+            if (pattern.test(expression)) {
+                return `Expression contains forbidden pattern: ${pattern}`;
+            }
+        }
+        const depth = (0, object_utils_1.calculateDepth)(expression);
+        if (depth && depth > this.MAX_EXPRESSION_DEPTH) {
+            return `Expression too complex`;
+        }
+        return null;
+    }
+    async getFromCache(queryParameters) {
+        const cacheKey = this.generateRateLimitingCountCacheKey({
+            partner: queryParameters?.partner || '',
+            provider: queryParameters?.provider || '',
+            productType: queryParameters?.productType || '',
+            market: queryParameters?.market || '',
+        });
+        const cachedData = await this.cacheService.get(cacheKey);
+        if (cachedData && cachedData.length) {
+            this.logger.info(`[INFO] Cache hit for: ${JSON.stringify(cachedData)}`);
+            return cachedData;
+        }
+        return [];
+    }
+    generateRateLimitingCountCacheKey(params) {
+        if (!params.partner && !params.provider)
+            return '';
+        const parameters = {
+            ...params,
+            enabled: 'true',
+        };
+        const orderedParams = Object.keys(parameters)
+            .sort()
+            .reduce((obj, key) => {
+            // Ensure all values are stringified for cache key
+            obj[key] = String(parameters[key]);
+            return obj;
+        }, {});
+        return `rate-limit-config:${JSON.stringify(orderedParams)}`;
+    }
+};
+exports.RuleService = RuleService;
+exports.RuleService = RuleService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [logger_1.LoggerService,
+        rule_repository_1.RuleRepository,
+        cache_service_1.CacheService])
+], RuleService);

package/dist/src/shared/cache/cache.service.d.ts

@@ -0,0 +1,10 @@
+import { RedisService } from '../redis/redis.service';
+export declare class CacheService {
+    private readonly redis;
+    constructor(redis: RedisService);
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(keys: string[]): Promise<number>;
+    deleteByPattern(pattern: string): Promise<number>;
+}
+//# sourceMappingURL=cache.service.d.ts.map

package/dist/src/shared/cache/cache.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.service.d.ts","sourceRoot":"","sources":["../../../../src/shared/cache/cache.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEtD,qBACa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAAL,KAAK,EAAE,YAAY;IAE1C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAI5C,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI1D,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAIvC,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAGlD"}

package/dist/src/shared/cache/cache.service.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const redis_service_1 = require("../redis/redis.service");
+let CacheService = class CacheService {
+    redis;
+    constructor(redis) {
+        this.redis = redis;
+    }
+    async get(key) {
+        return await this.redis.get(key);
+    }
+    set(key, value, ttl) {
+        return this.redis.set(key, value, ttl);
+    }
+    delete(keys) {
+        return this.redis.delKeys(keys);
+    }
+    deleteByPattern(pattern) {
+        return this.redis.deleteByPattern(pattern);
+    }
+};
+exports.CacheService = CacheService;
+exports.CacheService = CacheService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [redis_service_1.RedisService])
+], CacheService);

package/dist/src/shared/dsl/dsl.interface.d.ts

@@ -0,0 +1,43 @@
+type Primitive = string | number | boolean | Date;
+interface EqFilter<T = Primitive> {
+    eq: T;
+}
+interface InFilter<T = Primitive> {
+    in: T[];
+}
+interface RangeFilter<T = Date | number> {
+    range: {
+        from?: T;
+        to?: T;
+    };
+}
+interface GteFilter<T = Date | number> {
+    gte: T;
+}
+interface LteFilter<T = Date | number> {
+    lte: T;
+}
+interface ElemMatchFilter {
+    elemMatch: FilterDsl;
+}
+type FieldFilter = EqFilter | InFilter | RangeFilter | ElemMatchFilter | LteFilter | GteFilter;
+export interface FilterDsl {
+    or?: FilterDsl[];
+    [field: string]: FieldFilter | FilterDsl[] | undefined;
+}
+export interface IDslQuery {
+    fnContext: string;
+    query: IDslQueryItem[];
+}
+export interface IDslQueryItem {
+    label: string;
+    value: unknown;
+    op: OperationDslEnum;
+}
+export declare enum OperationDslEnum {
+    EQ = "eq",
+    RANGE = "range",
+    GTE = "gte"
+}
+export {};
+//# sourceMappingURL=dsl.interface.d.ts.map

package/dist/src/shared/dsl/dsl.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dsl.interface.d.ts","sourceRoot":"","sources":["../../../../src/shared/dsl/dsl.interface.ts"],"names":[],"mappings":"AAAA,KAAK,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAElD,UAAU,QAAQ,CAAC,CAAC,GAAG,SAAS;IAC9B,EAAE,EAAE,CAAC,CAAC;CACP;AAED,UAAU,QAAQ,CAAC,CAAC,GAAG,SAAS;IAC9B,EAAE,EAAE,CAAC,EAAE,CAAC;CACT;AAED,UAAU,WAAW,CAAC,CAAC,GAAG,IAAI,GAAG,MAAM;IACrC,KAAK,EAAE;QACL,IAAI,CAAC,EAAE,CAAC,CAAC;QACT,EAAE,CAAC,EAAE,CAAC,CAAC;KACR,CAAC;CACH;AAED,UAAU,SAAS,CAAC,CAAC,GAAG,IAAI,GAAG,MAAM;IACnC,GAAG,EAAE,CAAC,CAAC;CACR;AAED,UAAU,SAAS,CAAC,CAAC,GAAG,IAAI,GAAG,MAAM;IACnC,GAAG,EAAE,CAAC,CAAC;CACR;AAED,UAAU,eAAe;IACvB,SAAS,EAAE,SAAS,CAAC;CACtB;AAED,KAAK,WAAW,GACZ,QAAQ,GACR,QAAQ,GACR,WAAW,GACX,eAAe,GACf,SAAS,GACT,SAAS,CAAC;AAEd,MAAM,WAAW,SAAS;IACxB,EAAE,CAAC,EAAE,SAAS,EAAE,CAAC;IACjB,CAAC,KAAK,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,EAAE,GAAG,SAAS,CAAC;CACxD;AAED,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,aAAa,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;IACf,EAAE,EAAE,gBAAgB,CAAC;CACtB;AAED,oBAAY,gBAAgB;IAC1B,EAAE,OAAO;IACT,KAAK,UAAU;IACf,GAAG,QAAQ;CACZ"}

package/dist/src/shared/dsl/dsl.interface.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationDslEnum = void 0;
+var OperationDslEnum;
+(function (OperationDslEnum) {
+    OperationDslEnum["EQ"] = "eq";
+    OperationDslEnum["RANGE"] = "range";
+    OperationDslEnum["GTE"] = "gte";
+})(OperationDslEnum || (exports.OperationDslEnum = OperationDslEnum = {}));

package/dist/src/shared/dsl/dsl.service.d.ts

@@ -0,0 +1,8 @@
+import { QueryFilter } from 'mongoose';
+import { FilterDsl, IDslQueryItem } from './dsl.interface';
+export declare class DslService {
+    #private;
+    static buildFilter: (query: IDslQueryItem[]) => FilterDsl;
+    static toMongoQuery: (filter: FilterDsl) => QueryFilter<IDslQueryItem>;
+}
+//# sourceMappingURL=dsl.service.d.ts.map

package/dist/src/shared/dsl/dsl.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dsl.service.d.ts","sourceRoot":"","sources":["../../../../src/shared/dsl/dsl.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAE3D,qBAAa,UAAU;;IACrB,MAAM,CAAC,WAAW,GAAI,OAAO,aAAa,EAAE,KAAG,SAAS,CAWtD;IAEF,MAAM,CAAC,YAAY,GACjB,QAAQ,SAAS,KAChB,WAAW,CAAC,aAAa,CAAC,CAuD3B;CAuBH"}

package/dist/src/shared/dsl/dsl.service.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DslService = void 0;
+const tslib_1 = require("tslib");
+const dayjs_1 = tslib_1.__importDefault(require("dayjs"));
+class DslService {
+    static buildFilter = (query) => {
+        return query.reduce((acc, cur) => {
+            if (!cur || !cur.label)
+                return acc;
+            const value = cur.value ?? '';
+            return {
+                ...acc,
+                [cur.label]: this.#buildOp(cur.op, value),
+            };
+        }, {});
+    };
+    static toMongoQuery = (filter) => {
+        const query = {};
+        for (const key in filter) {
+            const condition = filter[key];
+            if (!condition)
+                continue;
+            if (key === 'or' && Array.isArray(condition)) {
+                query['$or'] = condition.map(subCond => this.toMongoQuery(subCond));
+                continue;
+            }
+            if ('eq' in condition && condition.eq !== undefined) {
+                query[key] = condition.eq;
+            }
+            if ('in' in condition && condition.in !== undefined) {
+                query[key] = { $in: condition.in };
+            }
+            if ('range' in condition && condition.range !== undefined) {
+                const rangeQuery = {};
+                const conditionRange = condition.range;
+                if (conditionRange.from)
+                    rangeQuery['$gte'] = conditionRange.from;
+                if (conditionRange.to)
+                    rangeQuery['$lte'] = conditionRange.to;
+                query[key] = rangeQuery;
+            }
+            if ('gte' in condition) {
+                const gteQuery = {};
+                if (condition.gte !== undefined)
+                    gteQuery['$gte'] = condition.gte;
+                query[key] = gteQuery;
+            }
+            if ('lte' in condition) {
+                const lteQuery = {};
+                if (condition.lte !== undefined)
+                    lteQuery['$lte'] = condition.lte;
+                query[key] = lteQuery;
+            }
+            if ('elemMatch' in condition) {
+                const elemMatchQuery = {};
+                if (condition.elemMatch) {
+                    elemMatchQuery['$elemMatch'] = this.toMongoQuery(condition.elemMatch);
+                    query[key] = elemMatchQuery;
+                }
+            }
+        }
+        return query;
+    };
+    static #buildOp = (op, value) => {
+        if (op === 'rangeDate') {
+            const data = value;
+            return {
+                range: {
+                    from: data?.from || (0, dayjs_1.default)().subtract(1, 'month').toDate(),
+                    to: data?.to || new Date(),
+                },
+            };
+        }
+        if (op === 'range') {
+            const data = value;
+            return {
+                range: {
+                    from: data?.from,
+                    to: data?.to,
+                },
+            };
+        }
+        return { [op || 'eq']: value };
+    };
+}
+exports.DslService = DslService;

package/dist/src/shared/redis/redis.module.d.ts

@@ -0,0 +1,3 @@
+export declare class RedisModule {
+}
+//# sourceMappingURL=redis.module.d.ts.map

package/dist/src/shared/redis/redis.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.module.d.ts","sourceRoot":"","sources":["../../../../src/shared/redis/redis.module.ts"],"names":[],"mappings":"AAKA,qBAmBa,WAAW;CAAG"}

package/dist/src/shared/redis/redis.module.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const ioredis_1 = tslib_1.__importDefault(require("ioredis"));
+const redis_service_1 = require("./redis.service");
+let RedisModule = class RedisModule {
+};
+exports.RedisModule = RedisModule;
+exports.RedisModule = RedisModule = tslib_1.__decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        imports: [config_1.ConfigModule],
+        providers: [
+            {
+                provide: 'REDIS_CLIENT',
+                useFactory: (config) => {
+                    return new ioredis_1.default({
+                        host: config.get('REDIS_HOST'),
+                        port: config.get('REDIS_PORT'),
+                        password: config.get('REDIS_PASSWORD'),
+                    });
+                },
+                inject: [config_1.ConfigService],
+            },
+            redis_service_1.RedisService,
+        ],
+        exports: ['REDIS_CLIENT', redis_service_1.RedisService],
+    })
+], RedisModule);

package/dist/src/shared/redis/redis.service.d.ts

@@ -0,0 +1,13 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import Redis from 'ioredis';
+export declare class RedisService implements OnModuleDestroy {
+    private readonly client;
+    constructor(client: Redis);
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, ttlSeconds?: number): Promise<void>;
+    delKeys(keys: string[]): Promise<number>;
+    scan(pattern: string, count?: number): Promise<string[]>;
+    deleteByPattern(pattern: string): Promise<number>;
+    onModuleDestroy(): void;
+}
+//# sourceMappingURL=redis.service.d.ts.map

package/dist/src/shared/redis/redis.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.service.d.ts","sourceRoot":"","sources":["../../../../src/shared/redis/redis.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,KAAK,MAAM,SAAS,CAAC;AAE5B,qBACa,YAAa,YAAW,eAAe;IAGhD,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,KAAK;IAG1B,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAKtC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASjE,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAKxC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,SAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAmBrD,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAKvD,eAAe;CAGhB"}

package/dist/src/shared/redis/redis.service.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const ioredis_1 = tslib_1.__importDefault(require("ioredis"));
+let RedisService = class RedisService {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async get(key) {
+        const raw = await this.client.get(key);
+        return raw ? JSON.parse(raw) : null;
+    }
+    async set(key, value, ttlSeconds) {
+        const str = JSON.stringify(value);
+        if (ttlSeconds) {
+            await this.client.set(key, str, 'EX', ttlSeconds);
+        }
+        else {
+            await this.client.set(key, str);
+        }
+    }
+    async delKeys(keys) {
+        if (keys.length === 0)
+            return 0;
+        return this.client.del(...keys);
+    }
+    async scan(pattern, count = 100) {
+        let cursor = '0';
+        const found = [];
+        do {
+            const [nextCursor, keys] = await this.client.scan(cursor, 'MATCH', pattern, 'COUNT', count);
+            cursor = nextCursor;
+            found.push(...keys);
+        } while (cursor !== '0');
+        return found;
+    }
+    async deleteByPattern(pattern) {
+        const keys = await this.scan(pattern);
+        return this.delKeys(keys);
+    }
+    onModuleDestroy() {
+        this.client.quit();
+    }
+};
+exports.RedisService = RedisService;
+exports.RedisService = RedisService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, common_1.Inject)('REDIS_CLIENT')),
+    tslib_1.__metadata("design:paramtypes", [ioredis_1.default])
+], RedisService);

package/dist/src/shared/rule-engine/interface/rule-engine.interface.d.ts

@@ -0,0 +1,14 @@
+export interface IRuleFunction {
+    fn: (...args: unknown[]) => Promise<unknown>;
+    params: string[];
+    description: string;
+    name: string;
+    entity?: string;
+    returnType?: string;
+}
+export interface RuleEngineInterface {
+    evaluate<T>(expression: string, context: T): Promise<boolean>;
+    registerCustomFunctions(customFunctions: IRuleFunction[]): void;
+    validateExpressionVariables<T>(expression: string, context: T): Promise<string[]>;
+}
+//# sourceMappingURL=rule-engine.interface.d.ts.map

package/dist/src/shared/rule-engine/interface/rule-engine.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-engine.interface.d.ts","sourceRoot":"","sources":["../../../../../src/shared/rule-engine/interface/rule-engine.interface.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7C,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9D,uBAAuB,CAAC,eAAe,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC;IAChE,2BAA2B,CAAC,CAAC,EAC3B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,CAAC,GACT,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CACtB"}

package/dist/src/shared/rule-engine/interface/rule-engine.interface.js

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

package/dist/src/shared/rule-engine/rule-engine.module.d.ts

@@ -0,0 +1,11 @@
+import { DynamicModule, InjectionToken, OptionalFactoryDependency } from '@nestjs/common';
+import { IRuleFunction } from './interface/rule-engine.interface';
+export declare class RuleEngineModule {
+    static forFeatureAsync(options: {
+        useFactory: (...args: any[]) => Promise<IRuleFunction[]>;
+        inject?: Array<InjectionToken | OptionalFactoryDependency>;
+        imports?: DynamicModule['imports'];
+    }): DynamicModule;
+    static forFeature(functions: IRuleFunction[]): DynamicModule;
+}
+//# sourceMappingURL=rule-engine.module.d.ts.map

package/dist/src/shared/rule-engine/rule-engine.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-engine.module.d.ts","sourceRoot":"","sources":["../../../../src/shared/rule-engine/rule-engine.module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAU,cAAc,EAAU,yBAAyB,EAAY,MAAM,gBAAgB,CAAC;AAEpH,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,qBAEa,gBAAgB;IAC3B,MAAM,CAAC,eAAe,CAAC,OAAO,EAAE;QAC9B,UAAU,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;QACzD,MAAM,CAAC,EAAE,KAAK,CAAC,cAAc,GAAG,yBAAyB,CAAC,CAAC;QAC3D,OAAO,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;KACpC,GAAG,aAAa;IAuBjB,MAAM,CAAC,UAAU,CAAC,SAAS,EAAE,aAAa,EAAE,GAAG,aAAa;CAkB7D"}

package/dist/src/shared/rule-engine/rule-engine.module.js

@@ -0,0 +1,51 @@
+"use strict";
+var RuleEngineModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleEngineModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const index_1 = require("../../index");
+const rule_engine_service_1 = require("./rule-engine.service");
+let RuleEngineModule = RuleEngineModule_1 = class RuleEngineModule {
+    static forFeatureAsync(options) {
+        const functionsProvider = {
+            provide: index_1.CUSTOM_RULE_FUNCTIONS,
+            useFactory: options.useFactory,
+            inject: options?.inject || [],
+        };
+        const ruleEngineProvider = {
+            provide: index_1.RULE_ENGINE_INSTANCE,
+            useFactory: (fns) => {
+                return new rule_engine_service_1.RuleEngineService(fns);
+            },
+            inject: [index_1.CUSTOM_RULE_FUNCTIONS],
+        };
+        return {
+            module: RuleEngineModule_1,
+            imports: options.imports || [],
+            providers: [functionsProvider, ruleEngineProvider],
+            exports: [index_1.RULE_ENGINE_INSTANCE],
+        };
+    }
+    static forFeature(functions) {
+        const functionsProvider = {
+            provide: index_1.CUSTOM_RULE_FUNCTIONS,
+            useValue: functions,
+        };
+        const ruleEngineProvider = {
+            provide: index_1.RULE_ENGINE_INSTANCE,
+            useFactory: (fns) => new rule_engine_service_1.RuleEngineService(fns),
+            inject: [index_1.CUSTOM_RULE_FUNCTIONS],
+        };
+        return {
+            module: RuleEngineModule_1,
+            providers: [functionsProvider, ruleEngineProvider],
+            exports: [index_1.RULE_ENGINE_INSTANCE],
+        };
+    }
+};
+exports.RuleEngineModule = RuleEngineModule;
+exports.RuleEngineModule = RuleEngineModule = RuleEngineModule_1 = tslib_1.__decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], RuleEngineModule);

package/dist/src/shared/rule-engine/rule-engine.service.d.ts

@@ -0,0 +1,18 @@
+import { IRuleFunction } from './interface/rule-engine.interface';
+export declare class RuleEngineService {
+    private readonly fns;
+    private readonly jexl;
+    private readonly allowedFns;
+    constructor(fns?: IRuleFunction[]);
+    evaluate<T>(expression: string, context: T): Promise<boolean>;
+    getResultCustomFunction(fnName: string, context: Record<string, unknown>): Promise<unknown>;
+    validateExpressionVariables<T>(expression: string, context: T): Promise<string[]>;
+    validateFunctionsAreValid(expression: string): string[];
+    getAllowedFunctions(): string[];
+    injectCustomFns(): void;
+    private _extractVariables;
+    private _validateVariablesInContext;
+    private _extractFunctionCalls;
+    private _resolveValue;
+}
+//# sourceMappingURL=rule-engine.service.d.ts.map

package/dist/src/shared/rule-engine/rule-engine.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule-engine.service.d.ts","sourceRoot":"","sources":["../../../../src/shared/rule-engine/rule-engine.service.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,qBAAa,iBAAiB;IAIhB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAHhC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoB;IACzC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;gBAEd,GAAG,GAAE,aAAa,EAAO;IAKhD,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IAqB7D,uBAAuB,CAC3B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,OAAO,CAAC,OAAO,CAAC;IAWb,2BAA2B,CAAC,CAAC,EACjC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,CAAC,GACT,OAAO,CAAC,MAAM,EAAE,CAAC;IASpB,yBAAyB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE;IAgBvD,mBAAmB,IAAI,MAAM,EAAE;IAI/B,eAAe,IAAI,IAAI;IAOvB,OAAO,CAAC,iBAAiB;IAoBzB,OAAO,CAAC,2BAA2B;IAqCnC,OAAO,CAAC,qBAAqB;IAe7B,OAAO,CAAC,aAAa;CAatB"}