@noony-serverless/core 0.1.5 → 0.2.1

package/build/middlewares/guards/resolvers/ExpressionPermissionResolver.d.ts

@@ -118,7 +118,7 @@ export declare class ExpressionPermissionResolver extends PermissionResolver<Per
     /**
      * Check if this resolver can handle the given requirement type
      */
-    canHandle(requirement: any): requirement is PermissionExpression;
+    canHandle(requirement: unknown): requirement is PermissionExpression;
     /**
      * Normalize expression for consistent cache keys
      *

package/build/middlewares/guards/resolvers/ExpressionPermissionResolver.js

@@ -412,7 +412,7 @@ class ExpressionPermissionResolver extends PermissionResolver_1.PermissionResolv
      * Check if this resolver can handle the given requirement type
      */
     canHandle(requirement) {
-        return (requirement &&
+        return Boolean(requirement &&
             typeof requirement === 'object' &&
             PermissionResolver_1.PermissionUtils.isValidExpression(requirement));
     }

package/build/middlewares/guards/resolvers/PermissionResolver.d.ts

@@ -19,7 +19,7 @@
  * different types of permission requirements. The generic type T represents
  * the specific requirement format for each resolver.
  */
-export declare abstract class PermissionResolver<T = any> {
+export declare abstract class PermissionResolver<T = unknown> {
     /**
      * Check if user permissions satisfy the requirement
      *

package/build/middlewares/guards/resolvers/PlainPermissionResolver.d.ts

@@ -96,6 +96,6 @@ export declare class PlainPermissionResolver extends PermissionResolver<string[]
      * @param requirement - The requirement to check
      * @returns true if this resolver can handle the requirement
      */
-    canHandle(requirement: any): requirement is string[];
+    canHandle(requirement: unknown): requirement is string[];
 }
 //# sourceMappingURL=PlainPermissionResolver.d.ts.map

package/build/middlewares/guards/resolvers/WildcardPermissionResolver.d.ts

@@ -141,6 +141,6 @@ export declare class WildcardPermissionResolver extends PermissionResolver<strin
     /**
      * Check if this resolver can handle the given requirement type
      */
-    canHandle(requirement: any): requirement is string[];
+    canHandle(requirement: unknown): requirement is string[];
 }
 //# sourceMappingURL=WildcardPermissionResolver.d.ts.map

package/build/middlewares/guards/services/FastUserContextService.d.ts

@@ -23,9 +23,13 @@
  * @version 1.0.0
  */
 import { CacheAdapter } from '../cache/CacheAdapter';
-import { GuardConfiguration, PermissionResolutionStrategy } from '../config/GuardConfiguration';
+import { GuardConfiguration } from '../config/GuardConfiguration';
 import { PermissionRegistry } from '../registry/PermissionRegistry';
-import { PermissionResolverType, PermissionCheckResult } from '../resolvers/PermissionResolver';
+import { PermissionResolverType, PermissionCheckResult, PermissionExpression } from '../resolvers/PermissionResolver';
+/**
+ * Type alias for permission requirements that can be strings, string arrays, or complex expressions
+ */
+type PermissionRequirement = string | string[] | PermissionExpression | Record<string, unknown>;
 /**
  * User context with cached permissions and metadata
  */
@@ -33,7 +37,7 @@ export interface UserContext {
     userId: string;
     permissions: Set<string>;
     roles: string[];
-    metadata: Record<string, any>;
+    metadata: Record<string, unknown>;
     expandedPermissions?: Set<string>;
     lastUpdated: string;
     expiresAt?: string;
@@ -48,7 +52,7 @@ export interface UserPermissionSource {
     getUserPermissions(userId: string): Promise<{
         permissions: string[];
         roles: string[];
-        metadata?: Record<string, any>;
+        metadata?: Record<string, unknown>;
     } | null>;
     /**
      * Get role-based permissions for expansion
@@ -85,6 +89,12 @@ export declare class FastUserContextService {
     private permissionChecks;
     private totalResolutionTimeUs;
     constructor(cache: CacheAdapter, config: GuardConfiguration, permissionSource: UserPermissionSource, permissionRegistry: PermissionRegistry);
+    /**
+     * Check if caching is effectively disabled
+     *
+     * @returns true if caching is disabled (either by environment variable or NoopCacheAdapter)
+     */
+    private isCachingDisabled;
     /**
      * Get or load user context with permissions
      *
@@ -107,7 +117,7 @@ export declare class FastUserContextService {
      * @param options - Check options
      * @returns Detailed permission check result
      */
-    checkPermission(userId: string, requirement: any, options?: PermissionCheckOptions): Promise<PermissionCheckResult>;
+    checkPermission(userId: string, requirement: PermissionRequirement, options?: PermissionCheckOptions): Promise<PermissionCheckResult>;
     /**
      * Batch check multiple permissions for a user
      *
@@ -120,7 +130,7 @@ export declare class FastUserContextService {
      * @returns Array of permission check results
      */
     checkPermissions(userId: string, requirements: Array<{
-        requirement: any;
+        requirement: PermissionRequirement;
         resolverType?: PermissionResolverType;
     }>, options?: PermissionCheckOptions): Promise<PermissionCheckResult[]>;
     /**
@@ -155,33 +165,9 @@ export declare class FastUserContextService {
         averageResolutionTimeUs: number;
         totalResolutionTimeUs: number;
         resolverStats: {
-            plain: {
-                checkCount: number;
-                averageResolutionTimeUs: number;
-                totalResolutionTimeUs: number;
-            };
-            wildcard: {
-                strategy: PermissionResolutionStrategy;
-                checkCount: number;
-                averageResolutionTimeUs: number;
-                totalResolutionTimeUs: number;
-                cacheHitRate: number;
-                cacheHits: number;
-                cacheMisses: number;
-            };
-            expression: {
-                checkCount: number;
-                averageResolutionTimeUs: number;
-                totalResolutionTimeUs: number;
-                cacheHitRate: number;
-                cacheHits: number;
-                cacheMisses: number;
-                complexityDistribution: {
-                    simple: number;
-                    moderate: number;
-                    complex: number;
-                };
-            };
+            plain: Record<string, unknown>;
+            wildcard: Record<string, unknown>;
+            expression: Record<string, unknown>;
         };
     };
     /**
@@ -213,4 +199,5 @@ export declare class FastUserContextService {
      */
     private recordAuditTrail;
 }
+export {};
 //# sourceMappingURL=FastUserContextService.d.ts.map

package/build/middlewares/guards/services/FastUserContextService.js

@@ -41,6 +41,7 @@ const PlainPermissionResolver_1 = require("../resolvers/PlainPermissionResolver"
 const WildcardPermissionResolver_1 = require("../resolvers/WildcardPermissionResolver");
 const ExpressionPermissionResolver_1 = require("../resolvers/ExpressionPermissionResolver");
 const PermissionResolver_1 = require("../resolvers/PermissionResolver");
+const NoopCacheAdapter_1 = require("../cache/NoopCacheAdapter");
 /**
  * Fast User Context Service Implementation
  */
@@ -70,6 +71,15 @@ let FastUserContextService = class FastUserContextService {
             GuardConfiguration_1.PermissionResolutionStrategy.PRE_EXPANSION, this._permissionRegistry, cache);
         this.expressionResolver = new ExpressionPermissionResolver_1.ExpressionPermissionResolver(cache);
     }
+    /**
+     * Check if caching is effectively disabled
+     *
+     * @returns true if caching is disabled (either by environment variable or NoopCacheAdapter)
+     */
+    isCachingDisabled() {
+        return (!GuardConfiguration_1.GuardConfiguration.isCachingEnabled() ||
+            this.cache instanceof NoopCacheAdapter_1.NoopCacheAdapter);
+    }
     /**
      * Get or load user context with permissions
      *
@@ -84,8 +94,9 @@ let FastUserContextService = class FastUserContextService {
         const startTime = process.hrtime.bigint();
         this.contextLoads++;
         try {
-            // Check cache first unless forced refresh
-            if (!forceRefresh) {
+            const cachingDisabled = this.isCachingDisabled();
+            // Check cache first unless forced refresh or caching is disabled
+            if (!forceRefresh && !cachingDisabled) {
                 const cachedContext = await this.loadFromCache(userId);
                 if (cachedContext) {
                     this.cacheHits++;
@@ -100,8 +111,10 @@ let FastUserContextService = class FastUserContextService {
             }
             // Build user context
             const context = await this.buildUserContext(userId, userData);
-            // Cache the context
-            await this.saveToCache(context);
+            // Cache the context only if caching is enabled
+            if (!cachingDisabled) {
+                await this.saveToCache(context);
+            }
             return context;
         }
         finally {

package/build/middlewares/httpAttributesMiddleware.js

@@ -296,7 +296,7 @@ const validatedQueryParameters = (schema) => ({
         }
         catch (error) {
             if (error instanceof zod_1.z.ZodError) {
-                throw new errors_1.ValidationError('Validation error', JSON.stringify(error.errors));
+                throw new errors_1.ValidationError('Validation error', JSON.stringify(error.issues));
             }
             throw error;
         }

package/build/middlewares/index.d.ts

@@ -1,3 +1,6 @@
+export * from './SecurityMiddleware';
+export * from './ConsolidatedValidationMiddleware';
+export * from './ProcessingMiddleware';
 export * from './authenticationMiddleware';
 export * from './bodyParserMiddleware';
 export * from './bodyValidationMiddleware';
@@ -10,6 +13,5 @@ export * from './rateLimitingMiddleware';
 export * from './responseWrapperMiddleware';
 export * from './securityAuditMiddleware';
 export * from './securityHeadersMiddleware';
-export * from './validationMiddleware';
 export * from './guards';
 //# sourceMappingURL=index.d.ts.map

package/build/middlewares/index.js

@@ -14,6 +14,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+// === NEW CONSOLIDATED MIDDLEWARES ===
+__exportStar(require("./SecurityMiddleware"), exports);
+__exportStar(require("./ConsolidatedValidationMiddleware"), exports);
+__exportStar(require("./ProcessingMiddleware"), exports);
+// === EXISTING INDIVIDUAL MIDDLEWARES (for backward compatibility) ===
 __exportStar(require("./authenticationMiddleware"), exports);
 __exportStar(require("./bodyParserMiddleware"), exports);
 __exportStar(require("./bodyValidationMiddleware"), exports);
@@ -26,6 +31,6 @@ __exportStar(require("./rateLimitingMiddleware"), exports);
 __exportStar(require("./responseWrapperMiddleware"), exports);
 __exportStar(require("./securityAuditMiddleware"), exports);
 __exportStar(require("./securityHeadersMiddleware"), exports);
-__exportStar(require("./validationMiddleware"), exports);
+// NOTE: validationMiddleware export removed due to naming conflict with new ValidationMiddleware
 __exportStar(require("./guards"), exports);
 //# sourceMappingURL=index.js.map