@noony-serverless/core 0.6.0 → 0.7.0

package/build/core/handler.d.ts

@@ -23,6 +23,30 @@ export interface BaseMiddleware<T = unknown, U = unknown> {
  * process a request/response flow either before the main handler (via `before`),
  * after the main handler (via `after`), or handle errors (via `onError`).
  *
+ * @example Type-safe handler with explicit types
+ * interface LoginRequest {
+ *   email: string;
+ *   password: string;
+ * }
+ *
+ * interface AuthUser extends BaseAuthenticatedUser {
+ *   role: 'admin' | 'user';
+ * }
+ *
+ * const handler = new Handler<LoginRequest, AuthUser>()
+ *   .use(new ErrorHandlerMiddleware<LoginRequest, AuthUser>())
+ *   .use(new BodyValidationMiddleware<LoginRequest, AuthUser>(loginSchema))
+ *   .handle(loginController);  // ✅ No 'as any' needed
+ *
+ * @example Type inference with createTypedHandler
+ * async function loginController(context: Context<LoginRequest, AuthUser>) {
+ *   // controller logic
+ * }
+ *
+ * const handler = createTypedHandler(loginController)
+ *   .use(new ErrorHandlerMiddleware())  // Types inferred
+ *   .handle(loginController);  // ✅ No 'as any' needed
+ *
  * interface MessagePayload {
  *   action: string;
  *   data: Record<string, unknown>;
@@ -45,7 +69,7 @@ export declare class Handler<T = unknown, U = unknown> {
     private errorMiddlewares;
     private middlewaresPrecomputed;
     static use<T = unknown, U = unknown>(middleware: BaseMiddleware<T, U>): Handler<T, U>;
-    use<NewT = T, NewU = U>(middleware: BaseMiddleware<NewT, NewU>): Handler<NewT, NewU>;
+    use(middleware: BaseMiddleware<T, U>): Handler<T, U>;
     handle(handler: (context: Context<T, U>) => Promise<void | unknown>): Handler<T, U>;
     /**
      * Performance optimization: Pre-compute middleware arrays to avoid runtime array operations
@@ -69,4 +93,30 @@ export declare class Handler<T = unknown, U = unknown> {
      */
     executeGeneric(req: GenericRequest<T>, res: GenericResponse): Promise<void>;
 }
+/**
+ * Helper to infer types automatically from the controller function.
+ *
+ * This helper is a permanent feature that improves Developer Experience (DX).
+ * It eliminates the need to write explicit generic type parameters when they
+ * are already defined in the controller signature.
+ *
+ * @example
+ * // Controller with explicit types
+ * async function loginController(context: Context<LoginRequest, AuthUser>) {
+ *   const { email, password } = context.req.validatedBody!;
+ *   // ... authentication logic
+ * }
+ *
+ * // Helper infers LoginRequest and AuthUser automatically
+ * const handler = createTypedHandler(loginController)
+ *   .use(new ErrorHandlerMiddleware())  // Types inferred
+ *   .use(new BodyValidationMiddleware(loginSchema))
+ *   .handle(loginController);  // ✅ Types match perfectly, no 'as any' needed
+ *
+ * @template T - The request body type (inferred from controller's Context<T, U>)
+ * @template U - The user type (inferred from controller's Context<T, U>)
+ * @param controller - The controller function with explicit Context<T, U> types
+ * @returns A new Handler instance with types inferred from the controller
+ */
+export declare function createTypedHandler<T, U>(_controller: (context: Context<T, U>) => Promise<void | unknown>): Handler<T, U>;
 //# sourceMappingURL=handler.d.ts.map

package/build/core/handler.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Handler = void 0;
+exports.createTypedHandler = createTypedHandler;
 // Container import removed - now using containerPool for performance
 const core_1 = require("./core");
 const containerPool_1 = require("./containerPool");
@@ -12,6 +13,30 @@ const containerPool_1 = require("./containerPool");
  * process a request/response flow either before the main handler (via `before`),
  * after the main handler (via `after`), or handle errors (via `onError`).
  *
+ * @example Type-safe handler with explicit types
+ * interface LoginRequest {
+ *   email: string;
+ *   password: string;
+ * }
+ *
+ * interface AuthUser extends BaseAuthenticatedUser {
+ *   role: 'admin' | 'user';
+ * }
+ *
+ * const handler = new Handler<LoginRequest, AuthUser>()
+ *   .use(new ErrorHandlerMiddleware<LoginRequest, AuthUser>())
+ *   .use(new BodyValidationMiddleware<LoginRequest, AuthUser>(loginSchema))
+ *   .handle(loginController);  // ✅ No 'as any' needed
+ *
+ * @example Type inference with createTypedHandler
+ * async function loginController(context: Context<LoginRequest, AuthUser>) {
+ *   // controller logic
+ * }
+ *
+ * const handler = createTypedHandler(loginController)
+ *   .use(new ErrorHandlerMiddleware())  // Types inferred
+ *   .handle(loginController);  // ✅ No 'as any' needed
+ *
  * interface MessagePayload {
  *   action: string;
  *   data: Record<string, unknown>;
@@ -40,12 +65,8 @@ class Handler {
         return handler;
     }
     use(middleware) {
-        const handler = new Handler();
-        handler.baseMiddlewares = [
-            ...this.baseMiddlewares,
-            middleware,
-        ];
-        return handler;
+        this.baseMiddlewares.push(middleware);
+        return this;
     }
     handle(handler) {
         this.handler = handler;
@@ -152,4 +173,32 @@ class Handler {
     }
 }
 exports.Handler = Handler;
+/**
+ * Helper to infer types automatically from the controller function.
+ *
+ * This helper is a permanent feature that improves Developer Experience (DX).
+ * It eliminates the need to write explicit generic type parameters when they
+ * are already defined in the controller signature.
+ *
+ * @example
+ * // Controller with explicit types
+ * async function loginController(context: Context<LoginRequest, AuthUser>) {
+ *   const { email, password } = context.req.validatedBody!;
+ *   // ... authentication logic
+ * }
+ *
+ * // Helper infers LoginRequest and AuthUser automatically
+ * const handler = createTypedHandler(loginController)
+ *   .use(new ErrorHandlerMiddleware())  // Types inferred
+ *   .use(new BodyValidationMiddleware(loginSchema))
+ *   .handle(loginController);  // ✅ Types match perfectly, no 'as any' needed
+ *
+ * @template T - The request body type (inferred from controller's Context<T, U>)
+ * @template U - The user type (inferred from controller's Context<T, U>)
+ * @param controller - The controller function with explicit Context<T, U> types
+ * @returns A new Handler instance with types inferred from the controller
+ */
+function createTypedHandler(_controller) {
+    return new Handler();
+}
 //# sourceMappingURL=handler.js.map

package/package.json

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