@noony-serverless/core 0.3.2 → 0.3.4

package/build/middlewares/ProcessingMiddleware.d.ts

@@ -42,7 +42,7 @@ export interface ProcessingMiddlewareConfig {
     parser?: BodyParserConfig;
     query?: QueryProcessingConfig;
     attributes?: AttributesConfig;
-    skipProcessing?: (context: Context) => boolean;
+    skipProcessing?: <TBody, TUser>(context: Context<TBody, TUser>) => boolean;
 }
 /**
  * Consolidated ProcessingMiddleware that combines body parsing, query processing, and attribute extraction.
@@ -52,6 +52,9 @@ export interface ProcessingMiddlewareConfig {
  * - QueryParametersMiddleware
  * - HttpAttributesMiddleware
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
+ *
  * @example
  * Complete processing setup:
  * ```typescript
@@ -95,10 +98,10 @@ export interface ProcessingMiddlewareConfig {
  *   }));
  * ```
  */
-export declare class ProcessingMiddleware implements BaseMiddleware {
+export declare class ProcessingMiddleware<TBody = unknown, TUser = unknown> implements BaseMiddleware<TBody, TUser> {
     private config;
     constructor(config?: ProcessingMiddlewareConfig);
-    before(context: Context): Promise<void>;
+    before(context: Context<TBody, TUser>): Promise<void>;
     private extractAttributes;
     private processQueryParameters;
     private parseBody;

package/build/middlewares/ProcessingMiddleware.js

@@ -10,6 +10,9 @@ const core_1 = require("../core");
  * - QueryParametersMiddleware
  * - HttpAttributesMiddleware
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
+ *
  * @example
  * Complete processing setup:
  * ```typescript

package/build/middlewares/dependencyInjectionMiddleware.d.ts

@@ -3,7 +3,9 @@ import { BaseMiddleware, Context } from '../core';
  * Middleware to inject dependencies into the request context using typedi.
  * This allows handlers to access shared services or data via context.container.
  *
- * @implements {BaseMiddleware}
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
+ * @implements {BaseMiddleware<TBody, TUser>}
  *
  * @example
  * Basic service injection:
@@ -145,18 +147,20 @@ import { BaseMiddleware, Context } from '../core';
  *   });
  * ```
  */
-export declare class DependencyInjectionMiddleware implements BaseMiddleware {
+export declare class DependencyInjectionMiddleware<TBody = unknown, TUser = unknown> implements BaseMiddleware<TBody, TUser> {
     private services;
     constructor(services: {
         id: any;
         value: any;
     }[]);
-    before(context: Context): Promise<void>;
+    before(context: Context<TBody, TUser>): Promise<void>;
 }
 /**
  * Factory function that creates a dependency injection middleware.
  * Creates a new container instance for each request to avoid shared state issues.
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @param services - Array of service definitions with id and value
  * @returns BaseMiddleware object with dependency injection logic
  *
@@ -245,8 +249,8 @@ export declare class DependencyInjectionMiddleware implements BaseMiddleware {
  *   });
  * ```
  */
-export declare const dependencyInjection: (services?: {
+export declare const dependencyInjection: <TBody = unknown, TUser = unknown>(services?: {
     id: any;
     value: any;
-}[]) => BaseMiddleware;
+}[]) => BaseMiddleware<TBody, TUser>;
 //# sourceMappingURL=dependencyInjectionMiddleware.d.ts.map

package/build/middlewares/dependencyInjectionMiddleware.js

@@ -7,7 +7,9 @@ const typedi_1 = require("typedi");
  * Middleware to inject dependencies into the request context using typedi.
  * This allows handlers to access shared services or data via context.container.
  *
- * @implements {BaseMiddleware}
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
+ * @implements {BaseMiddleware<TBody, TUser>}
  *
  * @example
  * Basic service injection:
@@ -166,6 +168,8 @@ exports.DependencyInjectionMiddleware = DependencyInjectionMiddleware;
  * Factory function that creates a dependency injection middleware.
  * Creates a new container instance for each request to avoid shared state issues.
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @param services - Array of service definitions with id and value
  * @returns BaseMiddleware object with dependency injection logic
  *

package/build/middlewares/headerVariablesMiddleware.d.ts

@@ -3,7 +3,9 @@ import { BaseMiddleware, Context } from '../core';
  * Middleware class that validates the presence of required HTTP headers.
  * Throws a ValidationError if any required header is missing or empty.
  *
- * @implements {BaseMiddleware}
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
+ * @implements {BaseMiddleware<TBody, TUser>}
  *
  * @example
  * API key authentication via headers:
@@ -63,15 +65,17 @@ import { BaseMiddleware, Context } from '../core';
  *   });
  * ```
  */
-export declare class HeaderVariablesMiddleware implements BaseMiddleware {
+export declare class HeaderVariablesMiddleware<TBody = unknown, TUser = unknown> implements BaseMiddleware<TBody, TUser> {
     private requiredHeaders;
     constructor(requiredHeaders: string[]);
-    before(context: Context): Promise<void>;
+    before(context: Context<TBody, TUser>): Promise<void>;
 }
 /**
  * Factory function that creates a header validation middleware.
  * Validates that all required headers are present in the request.
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @param requiredHeaders - Array of header names that must be present
  * @returns BaseMiddleware object with header validation logic
  *
@@ -122,5 +126,5 @@ export declare class HeaderVariablesMiddleware implements BaseMiddleware {
  *   });
  * ```
  */
-export declare const headerVariablesMiddleware: (requiredHeaders: string[]) => BaseMiddleware;
+export declare const headerVariablesMiddleware: <TBody = unknown, TUser = unknown>(requiredHeaders: string[]) => BaseMiddleware<TBody, TUser>;
 //# sourceMappingURL=headerVariablesMiddleware.d.ts.map

package/build/middlewares/headerVariablesMiddleware.js

@@ -15,7 +15,9 @@ const validateHeaders = (requiredHeaders, headers) => {
  * Middleware class that validates the presence of required HTTP headers.
  * Throws a ValidationError if any required header is missing or empty.
  *
- * @implements {BaseMiddleware}
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
+ * @implements {BaseMiddleware<TBody, TUser>}
  *
  * @example
  * API key authentication via headers:
@@ -90,6 +92,8 @@ exports.HeaderVariablesMiddleware = HeaderVariablesMiddleware;
  * Factory function that creates a header validation middleware.
  * Validates that all required headers are present in the request.
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @param requiredHeaders - Array of header names that must be present
  * @returns BaseMiddleware object with header validation logic
  *

package/build/middlewares/httpAttributesMiddleware.d.ts

@@ -5,7 +5,9 @@ import { ZodSchema } from 'zod';
  * Middleware class that extracts path parameters from the URL.
  * Parses URL segments and extracts parameters based on colon-prefixed patterns.
  *
- * @implements {BaseMiddleware}
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
+ * @implements {BaseMiddleware<TBody, TUser>}
  *
  * @example
  * Basic path parameter extraction:
@@ -56,8 +58,8 @@ import { ZodSchema } from 'zod';
  *   });
  * ```
  */
-export declare class PathParametersMiddleware implements BaseMiddleware {
-    before(context: Context): Promise<void>;
+export declare class PathParametersMiddleware<TBody = unknown, TUser = unknown> implements BaseMiddleware<TBody, TUser> {
+    before(context: Context<TBody, TUser>): Promise<void>;
 }
 /**
  * Factory function that creates a path parameters extraction middleware.

package/build/middlewares/httpAttributesMiddleware.js

@@ -7,7 +7,9 @@ const zod_1 = require("zod");
  * Middleware class that extracts path parameters from the URL.
  * Parses URL segments and extracts parameters based on colon-prefixed patterns.
  *
- * @implements {BaseMiddleware}
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
+ * @implements {BaseMiddleware<TBody, TUser>}
  *
  * @example
  * Basic path parameter extraction:

package/build/middlewares/rateLimitingMiddleware.d.ts

@@ -14,7 +14,7 @@ export interface RateLimitOptions {
      * Function to generate rate limiting key
      * @default Uses IP address
      */
-    keyGenerator?: (context: Context) => string;
+    keyGenerator?: <TBody, TUser>(context: Context<TBody, TUser>) => string;
     /**
      * Custom error message
      * @default 'Too many requests, please try again later'
@@ -28,7 +28,7 @@ export interface RateLimitOptions {
     /**
      * Skip rate limiting for certain requests
      */
-    skip?: (context: Context) => boolean;
+    skip?: <TBody, TUser>(context: Context<TBody, TUser>) => boolean;
     /**
      * Headers to include in response
      */
@@ -40,7 +40,7 @@ export interface RateLimitOptions {
         [key: string]: {
             maxRequests: number;
             windowMs: number;
-            matcher: (context: Context) => boolean;
+            matcher: <TBody, TUser>(context: Context<TBody, TUser>) => boolean;
         };
     };
     /**
@@ -120,7 +120,9 @@ declare class MemoryStore implements RateLimitStore {
  * - Implement multiple protection layers within middleware
  * - Critical for security in simple deployments
  *
- * @implements {BaseMiddleware}
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
+ * @implements {BaseMiddleware<TBody, TUser>}
  *
  * @example
  * Basic API rate limiting:
@@ -274,11 +276,11 @@ declare class MemoryStore implements RateLimitStore {
  *   });
  * ```
  */
-export declare class RateLimitingMiddleware implements BaseMiddleware {
+export declare class RateLimitingMiddleware<TBody = unknown, TUser = unknown> implements BaseMiddleware<TBody, TUser> {
     private store;
     private options;
     constructor(options?: RateLimitOptions);
-    before(context: Context): Promise<void>;
+    before(context: Context<TBody, TUser>): Promise<void>;
 }
 /**
  * Factory function that creates a rate limiting middleware.

package/build/middlewares/rateLimitingMiddleware.js

@@ -138,7 +138,9 @@ const getRateLimit = (context, options) => {
  * - Implement multiple protection layers within middleware
  * - Critical for security in simple deployments
  *
- * @implements {BaseMiddleware}
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
+ * @implements {BaseMiddleware<TBody, TUser>}
  *
  * @example
  * Basic API rate limiting:

package/build/middlewares/securityAuditMiddleware.d.ts

@@ -72,12 +72,15 @@ declare const securityEventTracker: SecurityEventTracker;
 /**
  * Security Audit Middleware
  * Provides comprehensive security event logging and monitoring
+ *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  */
-export declare class SecurityAuditMiddleware implements BaseMiddleware {
+export declare class SecurityAuditMiddleware<TBody = unknown, TUser = unknown> implements BaseMiddleware<TBody, TUser> {
     private options;
     constructor(options?: SecurityAuditOptions);
-    before(context: Context): Promise<void>;
-    after(context: Context): Promise<void>;
+    before(context: Context<TBody, TUser>): Promise<void>;
+    after(context: Context<TBody, TUser>): Promise<void>;
     onError(error: Error, context: Context): Promise<void>;
     private logSecurityEvent;
     private sanitizeHeaders;

package/build/middlewares/securityAuditMiddleware.js

@@ -156,6 +156,9 @@ const extractClientInfo = (context) => ({
 /**
  * Security Audit Middleware
  * Provides comprehensive security event logging and monitoring
+ *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  */
 class SecurityAuditMiddleware {
     options;

package/build/middlewares/securityHeadersMiddleware.d.ts

@@ -75,11 +75,14 @@ export interface SecurityHeadersOptions {
 /**
  * Security Headers Middleware
  * Implements comprehensive security headers following OWASP recommendations
+ *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  */
-export declare class SecurityHeadersMiddleware implements BaseMiddleware {
+export declare class SecurityHeadersMiddleware<TBody = unknown, TUser = unknown> implements BaseMiddleware<TBody, TUser> {
     private options;
     constructor(options?: SecurityHeadersOptions);
-    before(context: Context): Promise<void>;
+    before(context: Context<TBody, TUser>): Promise<void>;
 }
 /**
  * Security Headers Middleware Factory

package/build/middlewares/securityHeadersMiddleware.js

@@ -40,6 +40,9 @@ const isOriginAllowed = (origin, allowedOrigins) => {
 /**
  * Security Headers Middleware
  * Implements comprehensive security headers following OWASP recommendations
+ *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  */
 class SecurityHeadersMiddleware {
     options;

package/build/middlewares/validationMiddleware.d.ts

@@ -4,7 +4,9 @@ import { z } from 'zod';
  * Middleware class that validates request data (body or query parameters) using Zod schemas.
  * Automatically detects GET requests and validates query parameters, or validates body for other methods.
  *
- * @implements {BaseMiddleware}
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
+ * @implements {BaseMiddleware<TBody, TUser>}
  *
  * @example
  * User registration validation:
@@ -76,15 +78,17 @@ import { z } from 'zod';
  *   });
  * ```
  */
-export declare class ValidationMiddleware implements BaseMiddleware {
+export declare class ValidationMiddleware<TBody = unknown, TUser = unknown> implements BaseMiddleware<TBody, TUser> {
     private readonly schema;
     constructor(schema: z.ZodSchema);
-    before(context: Context): Promise<void>;
+    before(context: Context<TBody, TUser>): Promise<void>;
 }
 /**
  * Factory function that creates a validation middleware using Zod schema.
  * Automatically validates request body for non-GET requests or query parameters for GET requests.
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @param schema - Zod schema to validate against
  * @returns BaseMiddleware object with validation logic
  *
@@ -150,5 +154,5 @@ export declare class ValidationMiddleware implements BaseMiddleware {
  *   });
  * ```
  */
-export declare const validationMiddleware: (schema: z.ZodSchema) => BaseMiddleware;
+export declare const validationMiddleware: <TBody = unknown, TUser = unknown>(schema: z.ZodSchema) => BaseMiddleware<TBody, TUser>;
 //# sourceMappingURL=validationMiddleware.d.ts.map

package/build/middlewares/validationMiddleware.js

@@ -25,7 +25,9 @@ const validate = async (schema, context) => {
  * Middleware class that validates request data (body or query parameters) using Zod schemas.
  * Automatically detects GET requests and validates query parameters, or validates body for other methods.
  *
- * @implements {BaseMiddleware}
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
+ * @implements {BaseMiddleware<TBody, TUser>}
  *
  * @example
  * User registration validation:
@@ -111,6 +113,8 @@ exports.ValidationMiddleware = ValidationMiddleware;
  * Factory function that creates a validation middleware using Zod schema.
  * Automatically validates request body for non-GET requests or query parameters for GET requests.
  *
+ * @template TBody - The type of the request body payload (preserves type chain)
+ * @template TUser - The type of the authenticated user (preserves type chain)
  * @param schema - Zod schema to validate against
  * @returns BaseMiddleware object with validation logic
  *

package/build/utils/container.utils.d.ts

@@ -2,12 +2,12 @@ import type { Context } from '../core/core';
 /**
  * Get a service from the dependency injection container
  *
- * Type-safe utility to resolve services from the TypeDI container
- * without casting.
+ * Type-safe utility to resolve services from the TypeDI container.
+ * Supports both class constructors and string identifiers.
  *
  * @template T The service type to resolve
  * @param context - Request context containing the DI container
- * @param serviceClass - Service class constructor
+ * @param serviceIdentifier - Service class constructor OR string identifier
  * @returns Service instance
  * @throws Error if container is not initialized
  *
@@ -16,13 +16,26 @@ import type { Context } from '../core/core';
  * import { getService } from '@noony-serverless/core';
  * import { UserService } from '../services/user.service';
  *
- * export async function createUserController(context: Context<CreateUserRequest>) {
- *   const userService = getService(context, UserService); // Type-safe!
+ * // ✅ Best: Class-based access (type inferred automatically)
+ * export async function handler(context: Context) {
+ *   const userService = getService(context, UserService);
+ *   // userService is typed as UserService automatically
+ *   const users = await userService.getUsers();
+ * }
+ *
+ * // ✅ Good: String-based with explicit generic (when manual instantiation required)
+ * export async function handler(context: Context) {
+ *   const planRepo = getService<ActionPlanRepository>(context, 'ActionPlanRepository');
+ *   // planRepo is typed as ActionPlanRepository via explicit generic
+ *   const plan = await planRepo.findById(id);
+ * }
  *
- *   const user = await userService.createUser(context.req.parsedBody);
- *   context.res.status(201).json({ data: user });
+ * // ⚠️ Avoid: String without generic (only for quick prototypes)
+ * export async function handler(context: Context) {
+ *   const repo = getService(context, 'ActionPlanRepository');
+ *   // repo has type 'unknown' - requires manual type assertion
  * }
  * ```
  */
-export declare function getService<T>(context: Context<unknown, unknown>, serviceClass: new (...args: any[]) => T): T;
+export declare function getService<T>(context: Context<unknown, unknown>, serviceIdentifier: (new (...args: any[]) => T) | string): T;
 //# sourceMappingURL=container.utils.d.ts.map

package/build/utils/container.utils.js

@@ -4,12 +4,12 @@ exports.getService = getService;
 /**
  * Get a service from the dependency injection container
  *
- * Type-safe utility to resolve services from the TypeDI container
- * without casting.
+ * Type-safe utility to resolve services from the TypeDI container.
+ * Supports both class constructors and string identifiers.
  *
  * @template T The service type to resolve
  * @param context - Request context containing the DI container
- * @param serviceClass - Service class constructor
+ * @param serviceIdentifier - Service class constructor OR string identifier
  * @returns Service instance
  * @throws Error if container is not initialized
  *
@@ -18,18 +18,31 @@ exports.getService = getService;
  * import { getService } from '@noony-serverless/core';
  * import { UserService } from '../services/user.service';
  *
- * export async function createUserController(context: Context<CreateUserRequest>) {
- *   const userService = getService(context, UserService); // Type-safe!
+ * // ✅ Best: Class-based access (type inferred automatically)
+ * export async function handler(context: Context) {
+ *   const userService = getService(context, UserService);
+ *   // userService is typed as UserService automatically
+ *   const users = await userService.getUsers();
+ * }
+ *
+ * // ✅ Good: String-based with explicit generic (when manual instantiation required)
+ * export async function handler(context: Context) {
+ *   const planRepo = getService<ActionPlanRepository>(context, 'ActionPlanRepository');
+ *   // planRepo is typed as ActionPlanRepository via explicit generic
+ *   const plan = await planRepo.findById(id);
+ * }
  *
- *   const user = await userService.createUser(context.req.parsedBody);
- *   context.res.status(201).json({ data: user });
+ * // ⚠️ Avoid: String without generic (only for quick prototypes)
+ * export async function handler(context: Context) {
+ *   const repo = getService(context, 'ActionPlanRepository');
+ *   // repo has type 'unknown' - requires manual type assertion
  * }
  * ```
  */
-function getService(context, serviceClass) {
+function getService(context, serviceIdentifier) {
     if (!context.container) {
         throw new Error('Container not initialized. Did you forget to add DependencyInjectionMiddleware?');
     }
-    return context.container.get(serviceClass);
+    return context.container.get(serviceIdentifier);
 }
 //# sourceMappingURL=container.utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noony-serverless/core",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "A Middy base framework compatible with Firebase and GCP Cloud Functions with TypeScript",
   "main": "build/index.js",
   "types": "build/index.d.ts",