@riktajs/core 0.4.7 → 0.6.0

package/dist/core/config/abstract-config-provider.js

@@ -7,7 +7,7 @@ const env_loader_1 = require("./env-loader");
 class ConfigValidationException extends Error {
     errors;
     constructor(errors, providerName) {
-        const errorMessages = errors.errors
+        const errorMessages = errors.issues
             .map(err => `  - ${err.path.join('.')}: ${err.message}`)
             .join('\n');
         super(`Configuration validation failed for ${providerName}:\n${errorMessages}\n\n` +

package/dist/core/decorators/param.decorator.js

@@ -6,7 +6,7 @@ const constants_1 = require("../constants");
 function isZodType(value) {
     return (value !== null &&
         typeof value === 'object' &&
-        '_def' in value &&
+        ('_zod' in value || '_def' in value) &&
         'safeParse' in value &&
         typeof value.safeParse === 'function');
 }

package/dist/core/exceptions/validation.exception.d.ts

@@ -12,8 +12,6 @@ export declare class ValidationException extends HttpException {
     readonly errors: ValidationErrorDetails[];
     constructor(zodError: ZodError, message?: string);
     getValidationErrors(): ValidationErrorDetails[];
-    getFlattenedErrors(): import("zod").typeToFlattenedError<any, string>;
-    getFormattedErrors(): {
-        _errors: string[];
-    };
+    getFlattenedErrors(): import("zod").ZodFlattenedError<unknown, string>;
+    getFormattedErrors(): import("zod").ZodFormattedError<unknown, string>;
 }

package/dist/core/index.d.ts

@@ -9,6 +9,7 @@ export * from './application';
 export * from './decorators';
 export * from './exceptions';
 export * from './guards';
+export * from './middleware';
 export * from './config';
 export * from './metadata';
 export { z } from 'zod';

package/dist/core/index.js

@@ -26,6 +26,7 @@ __exportStar(require("./application"), exports);
 __exportStar(require("./decorators"), exports);
 __exportStar(require("./exceptions"), exports);
 __exportStar(require("./guards"), exports);
+__exportStar(require("./middleware"), exports);
 __exportStar(require("./config"), exports);
 __exportStar(require("./metadata"), exports);
 var zod_1 = require("zod");

package/dist/core/middleware/index.d.ts

@@ -0,0 +1,3 @@
+export { Middleware } from './middleware.decorator';
+export { RiktaMiddleware, NextFunction } from './rikta-middleware.interface';
+export { UseMiddleware, getMiddlewareMetadata, getMiddlewareMetadata as getMiddlewaresMetadata, MiddlewareClass } from './use-middleware.decorator';

package/dist/core/middleware/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMiddlewaresMetadata = exports.getMiddlewareMetadata = exports.UseMiddleware = exports.Middleware = void 0;
+var middleware_decorator_1 = require("./middleware.decorator");
+Object.defineProperty(exports, "Middleware", { enumerable: true, get: function () { return middleware_decorator_1.Middleware; } });
+var use_middleware_decorator_1 = require("./use-middleware.decorator");
+Object.defineProperty(exports, "UseMiddleware", { enumerable: true, get: function () { return use_middleware_decorator_1.UseMiddleware; } });
+Object.defineProperty(exports, "getMiddlewareMetadata", { enumerable: true, get: function () { return use_middleware_decorator_1.getMiddlewareMetadata; } });
+Object.defineProperty(exports, "getMiddlewaresMetadata", { enumerable: true, get: function () { return use_middleware_decorator_1.getMiddlewareMetadata; } });

package/dist/core/middleware/middleware.decorator.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+export declare function Middleware(): ClassDecorator;

package/dist/core/middleware/middleware.decorator.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Middleware = Middleware;
+require("reflect-metadata");
+function Middleware() {
+    return (target) => {
+        Reflect.defineMetadata('middleware', true, target);
+        Reflect.defineMetadata('injectable', true, target);
+    };
+}

package/dist/core/middleware/rikta-middleware.interface.d.ts

@@ -0,0 +1,5 @@
+import type { FastifyRequest, FastifyReply } from 'fastify';
+export type NextFunction = () => void | Promise<void>;
+export interface RiktaMiddleware {
+    use(req: FastifyRequest, res: FastifyReply, next: NextFunction): void | Promise<void>;
+}

package/dist/core/middleware/rikta-middleware.interface.js

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

package/dist/core/middleware/use-middleware.decorator.d.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+import type { Constructor } from '../types';
+import type { RiktaMiddleware } from './rikta-middleware.interface';
+export type MiddlewareClass = Constructor<RiktaMiddleware>;
+export declare function UseMiddleware(...middleware: MiddlewareClass[]): ClassDecorator & MethodDecorator;
+export declare function getMiddlewareMetadata(target: Constructor, propertyKey?: string | symbol): MiddlewareClass[];

package/dist/core/middleware/use-middleware.decorator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseMiddleware = UseMiddleware;
+exports.getMiddlewareMetadata = getMiddlewareMetadata;
+require("reflect-metadata");
+const constants_1 = require("../constants");
+function UseMiddleware(...middleware) {
+    return (target, propertyKey) => {
+        if (propertyKey !== undefined) {
+            const existingMiddleware = Reflect.getMetadata(constants_1.MIDDLEWARE_METADATA, target.constructor, propertyKey) ?? [];
+            Reflect.defineMetadata(constants_1.MIDDLEWARE_METADATA, [...existingMiddleware, ...middleware], target.constructor, propertyKey);
+        }
+        else {
+            const existingMiddleware = Reflect.getMetadata(constants_1.MIDDLEWARE_METADATA, target) ?? [];
+            Reflect.defineMetadata(constants_1.MIDDLEWARE_METADATA, [...existingMiddleware, ...middleware], target);
+        }
+    };
+}
+function getMiddlewareMetadata(target, propertyKey) {
+    const controllerMiddleware = Reflect.getMetadata(constants_1.MIDDLEWARE_METADATA, target) ?? [];
+    if (!propertyKey) {
+        return controllerMiddleware;
+    }
+    const methodMiddleware = Reflect.getMetadata(constants_1.MIDDLEWARE_METADATA, target, propertyKey) ?? [];
+    return [...controllerMiddleware, ...methodMiddleware];
+}

package/dist/core/router/router.d.ts

@@ -7,6 +7,7 @@ export declare class Router {
     private readonly container;
     private readonly globalPrefix;
     private readonly guardCache;
+    private readonly middlewareCache;
     constructor(server: FastifyInstance, container: Container, globalPrefix?: string);
     registerController(controllerClass: Constructor, silent?: boolean): void;
     private registerRoute;
@@ -15,5 +16,7 @@ export declare class Router {
     private resolveParamsOptimized;
     private resolveGuardInstances;
     private executeGuardsOptimized;
+    private resolveMiddlewareInstances;
+    private executeMiddlewareChain;
     private buildPath;
 }

package/dist/core/router/router.js

@@ -7,11 +7,13 @@ const validation_exception_1 = require("../exceptions/validation.exception");
 const exceptions_1 = require("../exceptions/exceptions");
 const execution_context_1 = require("../guards/execution-context");
 const use_guards_decorator_1 = require("../guards/use-guards.decorator");
+const use_middleware_decorator_1 = require("../middleware/use-middleware.decorator");
 class Router {
     server;
     container;
     globalPrefix;
     guardCache = new Map();
+    middlewareCache = new Map();
     constructor(server, container, globalPrefix = '') {
         this.server = server;
         this.container = container;
@@ -38,47 +40,31 @@ class Router {
         const paramsMeta = Reflect.getMetadata(constants_1.PARAM_METADATA, controllerClass, route.handlerName) ?? [];
         const statusCode = Reflect.getMetadata(constants_1.HTTP_CODE_METADATA, controllerClass, route.handlerName);
         const guards = (0, use_guards_decorator_1.getGuardsMetadata)(controllerClass, route.handlerName);
+        const middleware = (0, use_middleware_decorator_1.getMiddlewareMetadata)(controllerClass, route.handlerName);
         const compiledResolvers = this.compileParamResolvers(paramsMeta);
         const hasParams = compiledResolvers.length > 0;
         const maxParamIndex = hasParams ? Math.max(...compiledResolvers.map(r => r.index)) : -1;
         const guardInstances = this.resolveGuardInstances(guards);
         const hasGuards = guardInstances.length > 0;
-        let routeHandler;
-        if (!hasGuards && !hasParams && !statusCode) {
-            routeHandler = async (_request, _reply) => {
-                return handler.call(controllerInstance);
-            };
-        }
-        else if (!hasGuards && !hasParams) {
-            routeHandler = async (_request, reply) => {
-                const result = await handler.call(controllerInstance);
-                if (statusCode)
-                    reply.status(statusCode);
-                return result;
-            };
-        }
-        else if (!hasGuards) {
-            routeHandler = async (request, reply) => {
-                const args = this.resolveParamsOptimized(compiledResolvers, maxParamIndex, request, reply);
-                const result = await handler.apply(controllerInstance, args);
-                if (statusCode)
-                    reply.status(statusCode);
-                return result;
-            };
-        }
-        else {
-            const createContext = (req, rep) => new execution_context_1.ExecutionContextImpl(req, rep, controllerClass, route.handlerName);
-            routeHandler = async (request, reply) => {
+        const middlewareInstances = this.resolveMiddlewareInstances(middleware);
+        const hasMiddleware = middlewareInstances.length > 0;
+        const createContext = hasGuards
+            ? (req, rep) => new execution_context_1.ExecutionContextImpl(req, rep, controllerClass, route.handlerName)
+            : null;
+        const routeHandler = async (request, reply) => {
+            if (createContext) {
                 await this.executeGuardsOptimized(guardInstances, createContext(request, reply));
-                const args = hasParams
-                    ? this.resolveParamsOptimized(compiledResolvers, maxParamIndex, request, reply)
-                    : [];
-                const result = await handler.apply(controllerInstance, args);
-                if (statusCode)
-                    reply.status(statusCode);
-                return result;
-            };
-        }
+            }
+            if (hasMiddleware) {
+                await this.executeMiddlewareChain(middlewareInstances, request, reply);
+            }
+            const result = hasParams
+                ? await handler.apply(controllerInstance, this.resolveParamsOptimized(compiledResolvers, maxParamIndex, request, reply))
+                : await handler.call(controllerInstance);
+            if (statusCode)
+                reply.status(statusCode);
+            return result;
+        };
         const method = route.method.toLowerCase();
         this.server[method](fullPath, routeHandler);
         if (!silent)
@@ -179,6 +165,37 @@ class Router {
             }
         }
     }
+    resolveMiddlewareInstances(middleware) {
+        return middleware.map(MiddlewareClass => {
+            let instance = this.middlewareCache.get(MiddlewareClass);
+            if (instance)
+                return instance;
+            try {
+                instance = this.container.resolve(MiddlewareClass);
+            }
+            catch (error) {
+                throw new Error(`Failed to resolve middleware ${MiddlewareClass.name}. ` +
+                    `Make sure it is decorated with @Injectable(). ` +
+                    `Original error: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (typeof instance.use !== 'function') {
+                throw new Error(`${MiddlewareClass.name} does not implement RiktaMiddleware interface. ` +
+                    `The middleware must have a use(req, res, next) method.`);
+            }
+            this.middlewareCache.set(MiddlewareClass, instance);
+            return instance;
+        });
+    }
+    async executeMiddlewareChain(middlewareInstances, request, reply) {
+        let index = 0;
+        const next = async () => {
+            if (index < middlewareInstances.length) {
+                const middleware = middlewareInstances[index++];
+                await middleware.use(request, reply, next);
+            }
+        };
+        await next();
+    }
     buildPath(controllerPrefix, routePath) {
         const parts = [this.globalPrefix, controllerPrefix, routePath]
             .filter(Boolean)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riktajs/core",
-  "version": "0.4.7",
+  "version": "0.6.0",
   "description": "A fast and modern TypeScript backend framework with zero-config autowiring, powered by Fastify",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -33,7 +33,7 @@
     "fast-glob": "3.3.3",
     "fastify": "5.3.2",
     "reflect-metadata": "0.2.2",
-    "zod": "3.25.76"
+    "zod": "4.3.5"
   },
   "devDependencies": {
     "@types/node": "^22.10.2",