@flusys/nestjs-shared 9.1.1 → 9.2.0

package/interceptors/idempotency.interceptor.d.ts

@@ -1,10 +1,22 @@
 import { type CallHandler, type ExecutionContext, type NestInterceptor } from '@nestjs/common';
 import { Observable } from 'rxjs';
 import { HybridCache } from '../classes/hybrid-cache.class.js';
+interface IIdempotentRequest {
+    headers: Record<string, string | string[] | undefined>;
+    method?: string;
+    originalUrl?: string;
+    url?: string;
+    route?: {
+        path?: string;
+    };
+    user?: {
+        id?: string;
+    } | null;
+}
+export declare function buildIdempotencyCacheKey(request: IIdempotentRequest, idempotencyKey: string): string;
 export declare class IdempotencyInterceptor implements NestInterceptor {
     private readonly cache?;
-    private readonly CACHE_TTL;
-    private readonly PROCESSING_MARKER;
     constructor(cache?: HybridCache | undefined);
     intercept<T = any>(context: ExecutionContext, next: CallHandler<T>): Promise<Observable<T>>;
 }
+export {};

package/interceptors/slug.interceptor.d.ts

@@ -5,4 +5,5 @@ export declare class Slug implements NestInterceptor {
     private readonly utilsService;
     constructor(utilsService: UtilsService);
     intercept<T = any>(context: ExecutionContext, next: CallHandler<T>): Observable<T>;
+    private withSlug;
 }

package/interfaces/expression.interface.d.ts

@@ -0,0 +1,45 @@
+export declare const EXPRESSION_ARITHMETIC_OPS: readonly ["sum", "subtract", "multiply", "divide", "modulo", "power", "average", "min", "max"];
+export type ExpressionArithmeticOp = (typeof EXPRESSION_ARITHMETIC_OPS)[number];
+export declare const EXPRESSION_COMPARISONS: readonly ["equals", "not_equals", "greater_than", "less_than", "greater_or_equal", "less_or_equal", "contains", "not_contains", "starts_with", "ends_with", "in", "not_in", "is_empty", "is_not_empty", "is_true", "is_false", "matches", "not_matches"];
+export type ExpressionComparison = (typeof EXPRESSION_COMPARISONS)[number];
+export declare const UNARY_EXPRESSION_COMPARISONS: readonly ExpressionComparison[];
+export declare const EXPRESSION_DURATION_UNITS: readonly ["second", "minute", "hour", "day", "week", "month", "year"];
+export type ExpressionDurationUnit = (typeof EXPRESSION_DURATION_UNITS)[number];
+export declare const EXPRESSION_DATE_PARTS: readonly ["year", "month", "day", "weekday", "hour", "minute"];
+export type ExpressionDatePart = (typeof EXPRESSION_DATE_PARTS)[number];
+export interface IExpressionCondition {
+    left: Expression;
+    comparison: ExpressionComparison;
+    right?: Expression;
+}
+export interface IExpressionConditionGroup {
+    operator: 'AND' | 'OR';
+    conditions: Array<IExpressionCondition | IExpressionConditionGroup>;
+}
+export type Expression = {
+    type: 'literal';
+    value: string | number | boolean | null;
+} | {
+    type: 'field_ref';
+    ref: string;
+} | {
+    type: 'arithmetic';
+    op: ExpressionArithmeticOp;
+    operands: Expression[];
+} | {
+    type: 'concat';
+    parts: Expression[];
+    separator?: string;
+} | {
+    type: 'template';
+    template: string;
+} | {
+    type: 'function';
+    name: string;
+    args: Expression[];
+} | {
+    type: 'if';
+    condition: IExpressionConditionGroup;
+    whenTrue: Expression;
+    whenFalse?: Expression;
+};

package/interfaces/index.d.ts

@@ -6,6 +6,7 @@ export * from './datasource.interface.js';
 export * from './email-adapter.interface.js';
 export * from './event-bus.interface.js';
 export * from './event-manager-adapter.interface.js';
+export * from './expression.interface.js';
 export * from './identity.interface.js';
 export * from './logged-user-info.interface.js';
 export * from './message-ref.interface.js';

package/interfaces/permission-action-registry.interface.d.ts

@@ -9,4 +9,5 @@ export interface IPermissionActionInput {
 export interface IPermissionActionRegistry {
     registerActions(actions: IPermissionActionInput[]): Promise<void>;
     removeActionsByCodes(codes: string[]): Promise<void>;
+    findMissingCodes?(codes: string[]): Promise<string[]>;
 }

package/interfaces/permission.interface.d.ts

@@ -18,4 +18,5 @@ export interface PermissionGuardConfig {
     enableCompanyFeature?: boolean;
     userPermissionKeyFormat?: string;
     companyPermissionKeyFormat?: string;
+    multiTenant?: boolean;
 }

package/modules/shared-permission-cache/shared-permission-cache.service.d.ts

@@ -1,10 +1,12 @@
 import { HybridCache } from '../../classes/hybrid-cache.class.js';
 import type { ILogicNode, PermissionGuardConfig } from '../../interfaces/index.js';
+import { type IPermissionResolver } from '../../interfaces/permission-resolver.interface.js';
 import { type PermissionCacheKeyOptions } from '../../utils/permission-cache-key.util.js';
 export declare class SharedPermissionCacheService {
     private readonly cache?;
+    private readonly resolver?;
     private readonly config;
-    constructor(cache?: HybridCache | undefined, config?: PermissionGuardConfig);
+    constructor(cache?: HybridCache | undefined, config?: PermissionGuardConfig, resolver?: IPermissionResolver | undefined);
     getPermissions(options: PermissionCacheKeyOptions): Promise<string[]>;
     setPermissions(options: PermissionCacheKeyOptions, permissions: string[], ttl?: number): Promise<void>;
     clearPermissions(options: PermissionCacheKeyOptions): Promise<void>;

package/modules/utils/utils.service.d.ts

@@ -1,10 +1,10 @@
 import { HybridCache } from '../../classes/hybrid-cache.class.js';
 export declare class UtilsService {
-    getCacheKey(entityName: string, params: any, entityId?: string, tenantId?: string): string;
-    trackCacheKey(cacheKey: string, entityName: string, cacheManager: HybridCache, entityId?: string, tenantId?: string): Promise<void>;
-    clearCache(entityName: string, cacheManager: HybridCache, entityId?: string, tenantId?: string): Promise<void>;
-    transformToSlug(value: string, salt?: boolean): string;
-    getRandomInt(min: number, max: number): number;
+    private readonly logger;
+    getCacheStamp(cacheManager: HybridCache, entityNames: string[], tenantId?: string): Promise<string>;
+    getCacheKey(entityName: string, params: unknown, entityId: string | undefined, tenantId: string | undefined, stamp: string): string;
+    clearCache(entityName: string, cacheManager: HybridCache, tenantId?: string): Promise<void>;
+    getStampName(entityName: string, tenantId?: string): string;
+    transformToSlug(value: string): string;
     private buildTenantPrefix;
-    private buildTrackingKey;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flusys/nestjs-shared",
-  "version": "9.1.1",
+  "version": "9.2.0",
   "description": "Common shared utilities for Flusys NestJS applications",
   "type": "module",
   "main": "./fesm/index.js",
@@ -104,6 +104,7 @@
     "rxjs": "^7.8.0"
   },
   "dependencies": {
-    "@flusys/nestjs-core": "9.1.1"
+    "@flusys/nestjs-core": "9.2.0",
+    "re2js": "^2.8.6"
   }
 }

package/utils/date-time.util.d.ts

@@ -5,4 +5,3 @@ export declare function utcToLocal(utcDate: Date | string, timezone: string): {
     display: string;
 };
 export declare function formatInTimezone(utcDate: Date | string, timezone: string, options?: Intl.DateTimeFormatOptions): string;
-export declare function getTodayInTimezone(timezone: string): string;

package/utils/event-pattern.util.d.ts

@@ -1,3 +1,4 @@
 export declare function matchEventPattern(pattern: string, eventName: string): boolean;
 export declare function isMultiWildcard(segment: string): boolean;
 export declare function sanitizeEventPayload<T>(value: T): T;
+export declare function isSensitiveKey(key: string): boolean;

package/utils/expression.util.d.ts

@@ -0,0 +1,35 @@
+import { type Expression, type IExpressionConditionGroup } from '../interfaces/expression.interface.js';
+export declare const EXPRESSION_LIMITS: {
+    readonly MAX_DEPTH: 16;
+    readonly MAX_NODES: 500;
+    readonly MAX_TEMPLATE_LENGTH: 4000;
+    readonly MAX_TEXT_LENGTH: 100000;
+    readonly MAX_PAD_LENGTH: 1000;
+};
+export type ExpressionErrorCode = 'invalid_node' | 'unknown_function' | 'wrong_arg_count' | 'unknown_comparison' | 'unknown_ref' | 'too_deep' | 'too_many_nodes' | 'template_too_long' | 'text_too_long' | 'expected_number' | 'expected_date' | 'division_by_zero' | 'invalid_unit' | 'invalid_date_part' | 'regex_too_long' | 'regex_invalid' | 'regex_too_complex' | 'regex_input_too_long';
+export declare class ExpressionError extends Error {
+    readonly code: ExpressionErrorCode;
+    readonly variables: Record<string, string | number>;
+    constructor(code: ExpressionErrorCode, variables?: Record<string, string | number>);
+}
+export declare function isExpressionError(error: unknown): error is ExpressionError;
+export interface IExpressionFunction {
+    minArgs: number;
+    maxArgs?: number;
+    regexArgs?: readonly number[];
+    call(args: unknown[], ctx: IExpressionContext): unknown;
+}
+export interface IExpressionContext {
+    resolveRef(ref: string): unknown;
+    now?: () => Date;
+}
+export interface IExpressionValidationOptions {
+    isKnownRef?: (ref: string) => boolean;
+}
+export declare function expressionToText(value: unknown): string | null;
+export declare function expressionToNumber(value: unknown): number | null;
+export declare const EXPRESSION_FUNCTIONS: Readonly<Record<string, IExpressionFunction>>;
+export declare function evaluateExpression(expression: Expression, ctx: IExpressionContext): unknown;
+export declare function evaluateConditionGroup(group: IExpressionConditionGroup, ctx: IExpressionContext): boolean;
+export declare function assertValidExpression(expression: unknown, options?: IExpressionValidationOptions): void;
+export declare function assertValidConditionGroup(group: unknown, options?: IExpressionValidationOptions): void;

package/utils/index.d.ts

@@ -2,6 +2,7 @@ export * from './branch-hierarchy.util.js';
 export * from './cache-tenant.util.js';
 export * from './date-time.util.js';
 export * from './event-pattern.util.js';
+export * from './expression.util.js';
 export * from './html-sanitizer.util.js';
 export * from './message-ref.util.js';
 export * from './optional-module.util.js';
@@ -9,5 +10,6 @@ export * from './permission-cache-key.util.js';
 export * from './permission-match.util.js';
 export * from './query-helpers.util.js';
 export * from './request.util.js';
+export * from './safe-regex.util.js';
 export * from './string.util.js';
 export * from './token.util.js';

package/utils/permission-cache-key.util.d.ts

@@ -1,3 +1,4 @@
+import { type HybridCache } from '../classes/hybrid-cache.class.js';
 import { type PermissionGuardConfig } from '../interfaces/permission.interface.js';
 export interface PermissionCacheKeyOptions {
     userId: string;
@@ -7,3 +8,5 @@ export interface PermissionCacheKeyOptions {
 export declare const DEFAULT_USER_PERMISSION_KEY_FORMAT = "my-permissions:user:{userId}";
 export declare const DEFAULT_COMPANY_PERMISSION_KEY_FORMAT = "my-permissions:company:{companyId}:branch:{branchId}:user:{userId}";
 export declare function buildPermissionCacheKey(options: PermissionCacheKeyOptions, config?: PermissionGuardConfig): string;
+export declare function resolvePermissionCacheKey(cache: Pick<HybridCache, 'getStamp'>, options: PermissionCacheKeyOptions, config?: PermissionGuardConfig): Promise<string>;
+export declare function invalidatePermissionCache(cache: Pick<HybridCache, 'bumpStamp'>, userId: string, config?: PermissionGuardConfig): Promise<void>;

package/utils/query-helpers.util.d.ts

@@ -1,4 +1,4 @@
-import { type ObjectLiteral, type QueryRunner, SelectQueryBuilder } from 'typeorm';
+import { type FindOperator, type ObjectLiteral, type QueryRunner, SelectQueryBuilder } from 'typeorm';
 import { type ILoggedUserInfo } from '../interfaces/index.js';
 export interface ICompanyFilterConfig {
     isCompanyFeatureEnabled: boolean;
@@ -13,7 +13,7 @@ export interface IBranchFilterConfig {
 }
 export declare function applyBranchFilter<T extends ObjectLiteral>(query: SelectQueryBuilder<T>, config: IBranchFilterConfig, branchIds: ReadonlyArray<string | null | undefined>): SelectQueryBuilder<T>;
 export declare function buildCompanyWhereCondition<T extends Record<string, unknown>>(baseWhere: T, isCompanyFeatureEnabled: boolean, user: ILoggedUserInfo | null | undefined): T & {
-    companyId?: string;
+    companyId?: string | FindOperator<string>;
 };
 export interface ICompanyEnabled {
     companyId?: string | null;

package/utils/safe-regex.util.d.ts

@@ -0,0 +1,10 @@
+import { RE2JS } from 're2js';
+export declare const SAFE_REGEX_LIMITS: {
+    readonly MAX_PATTERN_LENGTH: 500;
+    readonly MAX_INPUT_LENGTH: 10000;
+    readonly MAX_REPEAT: 100;
+    readonly MAX_REPEAT_EXPANSION: 300;
+};
+export type SafeRegexProblem = 'too_long' | 'invalid' | 'too_complex';
+export declare function safeRegexProblem(pattern: string): SafeRegexProblem | null;
+export declare function compileSafeRegex(pattern: string): RE2JS;