@riktajs/core 0.6.0 → 0.8.0

package/dist/core/container/abstract-class.utils.d.ts

@@ -0,0 +1,10 @@
+import { Constructor } from '../types';
+export declare const IMPLEMENTS_METADATA: unique symbol;
+export declare const PRIMARY_METADATA: unique symbol;
+export declare function isAbstractClass(target: unknown): target is Constructor;
+export declare function extendsFrom(derived: Constructor, base: Constructor): boolean;
+export declare function getImplementedAbstract(target: Constructor): Constructor | undefined;
+export declare function isPrimaryImplementation(target: Constructor): boolean;
+export declare function setImplementsMetadata(target: Constructor, abstractClass: Constructor): void;
+export declare function setPrimaryMetadata(target: Constructor): void;
+export declare function markAsAbstract(target: Constructor): void;

package/dist/core/container/abstract-class.utils.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRIMARY_METADATA = exports.IMPLEMENTS_METADATA = void 0;
+exports.isAbstractClass = isAbstractClass;
+exports.extendsFrom = extendsFrom;
+exports.getImplementedAbstract = getImplementedAbstract;
+exports.isPrimaryImplementation = isPrimaryImplementation;
+exports.setImplementsMetadata = setImplementsMetadata;
+exports.setPrimaryMetadata = setPrimaryMetadata;
+exports.markAsAbstract = markAsAbstract;
+exports.IMPLEMENTS_METADATA = Symbol('rikta:implements');
+exports.PRIMARY_METADATA = Symbol('rikta:primary');
+function isAbstractClass(target) {
+    if (typeof target !== 'function') {
+        return false;
+    }
+    const isMarkedAbstract = Reflect.getMetadata(exports.IMPLEMENTS_METADATA, target) === undefined
+        && Reflect.hasMetadata('abstract:class', target);
+    if (isMarkedAbstract) {
+        return true;
+    }
+    return Reflect.getMetadata('abstract:class', target) === true;
+}
+function extendsFrom(derived, base) {
+    if (!derived || !base) {
+        return false;
+    }
+    if (derived === base) {
+        return false;
+    }
+    let current = Object.getPrototypeOf(derived);
+    while (current && current !== Function.prototype) {
+        if (current === base) {
+            return true;
+        }
+        current = Object.getPrototypeOf(current);
+    }
+    return false;
+}
+function getImplementedAbstract(target) {
+    return Reflect.getMetadata(exports.IMPLEMENTS_METADATA, target);
+}
+function isPrimaryImplementation(target) {
+    return Reflect.getMetadata(exports.PRIMARY_METADATA, target) === true;
+}
+function setImplementsMetadata(target, abstractClass) {
+    Reflect.defineMetadata(exports.IMPLEMENTS_METADATA, abstractClass, target);
+}
+function setPrimaryMetadata(target) {
+    Reflect.defineMetadata(exports.PRIMARY_METADATA, true, target);
+}
+function markAsAbstract(target) {
+    Reflect.defineMetadata('abstract:class', true, target);
+}

package/dist/core/container/container.d.ts

@@ -17,9 +17,12 @@ export declare class Container {
     resolve<T>(token: Token<T>): T;
     resolveOptional<T>(token: Token<T>): T | undefined;
     private resolveToken;
+    private resolveAbstractClass;
     private resolveProvider;
     private resolveClass;
     private injectProperties;
+    private resolveWithName;
+    private resolveWithNameOptional;
     registerInstance<T>(target: Constructor<T>, instance: T): void;
     getProviders(): Token[];
     clearSingletons(): void;

package/dist/core/container/container.js

@@ -4,6 +4,8 @@ exports.container = exports.Container = void 0;
 require("reflect-metadata");
 const constants_1 = require("../constants");
 const injection_token_1 = require("./injection-token");
+const registry_1 = require("../registry");
+const abstract_class_utils_1 = require("./abstract-class.utils");
 class Container {
     static instance;
     singletons = new Map();
@@ -70,12 +72,20 @@ class Container {
         }
         const config = this.providers.get(token);
         if (!config) {
+            if (typeof token === 'function') {
+                const implementation = this.resolveAbstractClass(token);
+                if (implementation) {
+                    const instance = this.resolveClass(implementation);
+                    this.singletons.set(token, instance);
+                    return instance;
+                }
+                if (!(0, abstract_class_utils_1.isAbstractClass)(token)) {
+                    return this.resolveClass(token);
+                }
+            }
             if (optional) {
                 return undefined;
             }
-            if (typeof token === 'function') {
-                return this.resolveClass(token);
-            }
             throw new Error(`No provider found for token: ${this.getTokenName(token)}`);
         }
         if (config.provider && typeof config.provider !== 'function') {
@@ -86,6 +96,16 @@ class Container {
         }
         throw new Error(`Cannot resolve token: ${this.getTokenName(token)}`);
     }
+    resolveAbstractClass(abstractClass, name) {
+        if (name) {
+            return registry_1.registry.resolveImplementation(abstractClass, name);
+        }
+        const config = this.providers.get(abstractClass);
+        if (config?.provider && 'useClass' in config.provider) {
+            return config.provider.useClass;
+        }
+        return registry_1.registry.resolveImplementation(abstractClass);
+    }
     resolveProvider(provider, scope) {
         if (typeof provider === 'function') {
             return this.resolveClass(provider);
@@ -142,6 +162,7 @@ class Container {
                 const injectOverride = injectMeta.find(m => m.index === index);
                 const token = injectOverride?.token ?? paramType;
                 const isOptional = injectOverride?.optional ?? false;
+                const name = injectOverride?.name;
                 if (!token) {
                     if (isOptional) {
                         dependencies.push(undefined);
@@ -159,8 +180,8 @@ class Container {
                         `Use @Autowired(token) decorator.`);
                 }
                 dependencies.push(isOptional
-                    ? this.resolveOptional(token)
-                    : this.resolve(token));
+                    ? this.resolveWithNameOptional(token, name)
+                    : this.resolveWithName(token, name));
             }
             const instance = new target(...dependencies);
             this.injectProperties(target, instance);
@@ -181,8 +202,8 @@ class Container {
             const isOptional = meta.optional ?? false;
             try {
                 const value = isOptional
-                    ? this.resolveOptional(meta.token)
-                    : this.resolve(meta.token);
+                    ? this.resolveWithNameOptional(meta.token, meta.name)
+                    : this.resolveWithName(meta.token, meta.name);
                 instance[meta.propertyKey] = value;
             }
             catch (error) {
@@ -192,6 +213,24 @@ class Container {
             }
         }
     }
+    resolveWithName(token, name) {
+        if (name && typeof token === 'function') {
+            const implementation = this.resolveAbstractClass(token, name);
+            if (implementation) {
+                return this.resolveClass(implementation);
+            }
+            throw new Error(`No implementation named '${name}' found for ${this.getTokenName(token)}`);
+        }
+        return this.resolve(token);
+    }
+    resolveWithNameOptional(token, name) {
+        try {
+            return this.resolveWithName(token, name);
+        }
+        catch {
+            return undefined;
+        }
+    }
     registerInstance(target, instance) {
         this.providers.set(target, { scope: 'singleton' });
         this.singletons.set(target, instance);

package/dist/core/container/implements.decorator.d.ts

@@ -0,0 +1,6 @@
+import 'reflect-metadata';
+import { AnyConstructor } from '../types';
+export declare function Implements<T extends AnyConstructor>(abstractClass: T): ClassDecorator;
+export declare function Primary(): ClassDecorator;
+export declare function Named(name: string): ClassDecorator;
+export declare function AbstractClass(): ClassDecorator;

package/dist/core/container/implements.decorator.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Implements = Implements;
+exports.Primary = Primary;
+exports.Named = Named;
+exports.AbstractClass = AbstractClass;
+require("reflect-metadata");
+const abstract_class_utils_1 = require("./abstract-class.utils");
+const registry_1 = require("../registry");
+function Implements(abstractClass) {
+    return (target) => {
+        (0, abstract_class_utils_1.setImplementsMetadata)(target, abstractClass);
+        (0, abstract_class_utils_1.markAsAbstract)(abstractClass);
+        const name = Reflect.getMetadata('rikta:named', target);
+        registry_1.registry.registerAbstractImplementation(abstractClass, target, name);
+        const isPrimary = Reflect.getMetadata('rikta:is-primary', target) === true;
+        if (isPrimary) {
+            registry_1.registry.setPrimaryImplementation(abstractClass, target);
+        }
+    };
+}
+function Primary() {
+    return (target) => {
+        (0, abstract_class_utils_1.setPrimaryMetadata)(target);
+        const abstractClass = Reflect.getMetadata(abstract_class_utils_1.IMPLEMENTS_METADATA, target);
+        if (abstractClass) {
+            registry_1.registry.setPrimaryImplementation(abstractClass, target);
+        }
+        Reflect.defineMetadata('rikta:is-primary', true, target);
+    };
+}
+function Named(name) {
+    return (target) => {
+        Reflect.defineMetadata('rikta:named', name, target);
+        const abstractClass = Reflect.getMetadata(abstract_class_utils_1.IMPLEMENTS_METADATA, target);
+        if (abstractClass) {
+            registry_1.registry.setImplementationName(abstractClass, target, name);
+        }
+    };
+}
+function AbstractClass() {
+    return (target) => {
+        (0, abstract_class_utils_1.markAsAbstract)(target);
+    };
+}

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

@@ -1,2 +1,4 @@
 export * from './container';
 export * from './injection-token';
+export * from './abstract-class.utils';
+export * from './implements.decorator';

package/dist/core/container/index.js

@@ -16,3 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./container"), exports);
 __exportStar(require("./injection-token"), exports);
+__exportStar(require("./abstract-class.utils"), exports);
+__exportStar(require("./implements.decorator"), exports);

package/dist/core/decorators/apply-decorators.d.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata';
+type ClassDecorator = <TFunction extends Function>(target: TFunction) => TFunction | void;
+type MethodDecorator = <T>(target: Object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<T>) => TypedPropertyDescriptor<T> | void;
+type PropertyDecorator = (target: Object, propertyKey: string | symbol) => void;
+type AnyDecorator = ClassDecorator | MethodDecorator | PropertyDecorator;
+export declare function applyDecorators(...decorators: AnyDecorator[]): MethodDecorator & ClassDecorator & PropertyDecorator;
+export declare function SetMetadata<T = unknown>(key: string | symbol, value: T): MethodDecorator & ClassDecorator;
+export {};

package/dist/core/decorators/apply-decorators.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyDecorators = applyDecorators;
+exports.SetMetadata = SetMetadata;
+require("reflect-metadata");
+function applyDecorators(...decorators) {
+    return ((target, propertyKey, descriptor) => {
+        for (const decorator of decorators.reverse()) {
+            if (descriptor) {
+                const result = decorator(target, propertyKey, descriptor);
+                if (result) {
+                    descriptor = result;
+                }
+            }
+            else if (propertyKey !== undefined) {
+                decorator(target, propertyKey);
+            }
+            else {
+                const result = decorator(target);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        if (descriptor) {
+            return descriptor;
+        }
+    });
+}
+function SetMetadata(key, value) {
+    const decoratorFactory = (target, propertyKey, descriptor) => {
+        if (descriptor) {
+            Reflect.defineMetadata(key, value, target.constructor, propertyKey);
+        }
+        else {
+            Reflect.defineMetadata(key, value, target);
+        }
+    };
+    return decoratorFactory;
+}

package/dist/core/decorators/autowired.decorator.d.ts

@@ -5,6 +5,7 @@ export interface AutowiredMetadata {
     index?: number;
     propertyKey?: string;
     optional?: boolean;
+    name?: string;
 }
-export declare function Autowired(token?: Token): ParameterDecorator & PropertyDecorator;
+export declare function Autowired(token?: Token, name?: string): ParameterDecorator & PropertyDecorator;
 export declare function Optional(): ParameterDecorator & PropertyDecorator;

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

@@ -4,7 +4,7 @@ exports.Autowired = Autowired;
 exports.Optional = Optional;
 require("reflect-metadata");
 const constants_1 = require("../constants");
-function Autowired(token) {
+function Autowired(token, name) {
     return (target, propertyKey, parameterIndex) => {
         if (typeof parameterIndex === 'number') {
             const paramTypes = Reflect.getMetadata('design:paramtypes', target) ?? [];
@@ -18,6 +18,7 @@ function Autowired(token) {
             existingInjects.push({
                 token: resolvedToken,
                 index: parameterIndex,
+                name,
             });
             Reflect.defineMetadata(constants_1.INJECT_METADATA, existingInjects, target);
         }
@@ -32,6 +33,7 @@ function Autowired(token) {
             existingAutowires.push({
                 token: resolvedToken,
                 propertyKey: String(propertyKey),
+                name,
             });
             Reflect.defineMetadata(constants_1.AUTOWIRED_METADATA, existingAutowires, target.constructor);
         }

package/dist/core/decorators/create-param-decorator.d.ts

@@ -0,0 +1,11 @@
+import 'reflect-metadata';
+import { ExecutionContext } from '../guards/execution-context';
+export declare const CUSTOM_PARAM_METADATA: unique symbol;
+export interface CustomParamMetadata<T = unknown> {
+    index: number;
+    factory: CustomParamFactory<T, unknown>;
+    data?: T;
+}
+export type CustomParamFactory<TData = unknown, TResult = unknown> = (data: TData, ctx: ExecutionContext) => TResult | Promise<TResult>;
+export declare function createParamDecorator<TData = unknown, TResult = unknown>(factory: CustomParamFactory<TData, TResult>): (data?: TData) => ParameterDecorator;
+export declare function getCustomParamMetadata<T = unknown>(target: Function, propertyKey: string | symbol): CustomParamMetadata<T>[];

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUSTOM_PARAM_METADATA = void 0;
+exports.createParamDecorator = createParamDecorator;
+exports.getCustomParamMetadata = getCustomParamMetadata;
+require("reflect-metadata");
+exports.CUSTOM_PARAM_METADATA = Symbol.for('rikta:custom:param:metadata');
+function createParamDecorator(factory) {
+    return (data) => {
+        return (target, propertyKey, parameterIndex) => {
+            if (propertyKey === undefined)
+                return;
+            const existingParams = Reflect.getMetadata(exports.CUSTOM_PARAM_METADATA, target.constructor, propertyKey) ?? [];
+            const metadata = {
+                index: parameterIndex,
+                factory: factory,
+                data,
+            };
+            existingParams.push(metadata);
+            Reflect.defineMetadata(exports.CUSTOM_PARAM_METADATA, existingParams, target.constructor, propertyKey);
+        };
+    };
+}
+function getCustomParamMetadata(target, propertyKey) {
+    return Reflect.getMetadata(exports.CUSTOM_PARAM_METADATA, target, propertyKey) ?? [];
+}

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

@@ -5,3 +5,5 @@ export * from './param.decorator';
 export * from './autowired.decorator';
 export * from './provider.decorator';
 export * from './config-property.decorator';
+export * from './create-param-decorator';
+export * from './apply-decorators';

package/dist/core/decorators/index.js

@@ -21,3 +21,5 @@ __exportStar(require("./param.decorator"), exports);
 __exportStar(require("./autowired.decorator"), exports);
 __exportStar(require("./provider.decorator"), exports);
 __exportStar(require("./config-property.decorator"), exports);
+__exportStar(require("./create-param-decorator"), exports);
+__exportStar(require("./apply-decorators"), exports);

package/dist/core/registry.d.ts

@@ -3,12 +3,18 @@ interface ConfigProviderRegistration {
     token: string;
     providerClass: Constructor;
 }
+interface AbstractImplementation {
+    implementation: Constructor;
+    isPrimary: boolean;
+    name?: string;
+}
 declare class Registry {
     private static instance;
     private controllers;
     private providers;
     private customProviders;
     private configProviderMap;
+    private abstractImplementations;
     private constructor();
     static getInstance(): Registry;
     static reset(): void;
@@ -24,6 +30,14 @@ declare class Registry {
     registerConfigProvider(token: string, providerClass: Constructor): void;
     getConfigProviderRegistrations(): ConfigProviderRegistration[];
     clearConfigProviders(): void;
+    registerAbstractImplementation(abstractClass: Constructor, implementation: Constructor, name?: string): void;
+    setImplementationName(abstractClass: Constructor, implementation: Constructor, name: string): void;
+    setPrimaryImplementation(abstractClass: Constructor, implementation: Constructor): void;
+    getImplementations(abstractClass: Constructor): AbstractImplementation[];
+    resolveImplementation(abstractClass: Constructor, name?: string): Constructor | undefined;
+    getNamedImplementation(abstractClass: Constructor, name: string): Constructor | undefined;
+    hasImplementation(abstractClass: Constructor): boolean;
+    clearAbstractImplementations(): void;
 }
 export declare const registry: Registry;
 export { Registry };

package/dist/core/registry.js

@@ -8,6 +8,7 @@ class Registry {
     providers = new Set();
     customProviders = new Set();
     configProviderMap = new Map();
+    abstractImplementations = new Map();
     constructor() { }
     static getInstance() {
         if (!Registry.instance) {
@@ -62,6 +63,82 @@ class Registry {
     clearConfigProviders() {
         this.configProviderMap.clear();
     }
+    registerAbstractImplementation(abstractClass, implementation, name) {
+        const implementations = this.abstractImplementations.get(abstractClass) ?? [];
+        const existing = implementations.find(i => i.implementation === implementation);
+        if (!existing) {
+            implementations.push({
+                implementation,
+                isPrimary: false,
+                name,
+            });
+            this.abstractImplementations.set(abstractClass, implementations);
+        }
+        else if (name && !existing.name) {
+            existing.name = name;
+        }
+    }
+    setImplementationName(abstractClass, implementation, name) {
+        const implementations = this.abstractImplementations.get(abstractClass);
+        if (!implementations) {
+            return;
+        }
+        const impl = implementations.find(i => i.implementation === implementation);
+        if (impl) {
+            impl.name = name;
+        }
+    }
+    setPrimaryImplementation(abstractClass, implementation) {
+        const implementations = this.abstractImplementations.get(abstractClass);
+        if (!implementations) {
+            return;
+        }
+        for (const impl of implementations) {
+            impl.isPrimary = impl.implementation === implementation;
+        }
+    }
+    getImplementations(abstractClass) {
+        return this.abstractImplementations.get(abstractClass) ?? [];
+    }
+    resolveImplementation(abstractClass, name) {
+        const implementations = this.abstractImplementations.get(abstractClass);
+        if (!implementations || implementations.length === 0) {
+            return undefined;
+        }
+        if (name) {
+            const named = implementations.find(i => i.name === name);
+            if (named) {
+                return named.implementation;
+            }
+            throw new Error(`No implementation named '${name}' found for abstract class ${abstractClass.name}. ` +
+                `Available names: ${implementations.filter(i => i.name).map(i => i.name).join(', ') || 'none'}`);
+        }
+        if (implementations.length === 1) {
+            return implementations[0].implementation;
+        }
+        const primary = implementations.find(i => i.isPrimary);
+        if (primary) {
+            return primary.implementation;
+        }
+        const implNames = implementations.map(i => i.implementation.name).join(', ');
+        throw new Error(`Multiple implementations found for abstract class ${abstractClass.name}: ${implNames}. ` +
+            `Use @Primary() to mark one as the default, or @Named() for qualified injection.`);
+    }
+    getNamedImplementation(abstractClass, name) {
+        const implementations = this.abstractImplementations.get(abstractClass);
+        if (!implementations) {
+            return undefined;
+        }
+        const named = implementations.find(i => i.name === name);
+        return named?.implementation;
+    }
+    hasImplementation(abstractClass) {
+        const implementations = this.abstractImplementations.get(abstractClass);
+        return !!implementations && implementations.length > 0;
+    }
+    clearAbstractImplementations() {
+        this.abstractImplementations.clear();
+    }
 }
 exports.Registry = Registry;
 exports.registry = Registry.getInstance();

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

@@ -13,7 +13,7 @@ export declare class Router {
     private registerRoute;
     private compileParamResolvers;
     private createParamExtractor;
-    private resolveParamsOptimized;
+    private resolveAllParams;
     private resolveGuardInstances;
     private executeGuardsOptimized;
     private resolveMiddlewareInstances;

package/dist/core/router/router.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Router = void 0;
 require("reflect-metadata");
 const constants_1 = require("../constants");
+const create_param_decorator_1 = require("../decorators/create-param-decorator");
 const validation_exception_1 = require("../exceptions/validation.exception");
 const exceptions_1 = require("../exceptions/exceptions");
 const execution_context_1 = require("../guards/execution-context");
@@ -38,28 +39,41 @@ class Router {
             throw new Error(`Handler ${String(route.handlerName)} not found on ${controllerClass.name}`);
         }
         const paramsMeta = Reflect.getMetadata(constants_1.PARAM_METADATA, controllerClass, route.handlerName) ?? [];
+        const customParamsMeta = (0, create_param_decorator_1.getCustomParamMetadata)(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 hasBuiltinParams = compiledResolvers.length > 0;
+        const hasCustomParams = customParamsMeta.length > 0;
+        const hasParams = hasBuiltinParams || hasCustomParams;
+        const allParamIndexes = [
+            ...compiledResolvers.map(r => r.index),
+            ...customParamsMeta.map(r => r.index)
+        ];
+        const maxParamIndex = hasParams ? Math.max(...allParamIndexes) : -1;
         const guardInstances = this.resolveGuardInstances(guards);
         const hasGuards = guardInstances.length > 0;
         const middlewareInstances = this.resolveMiddlewareInstances(middleware);
         const hasMiddleware = middlewareInstances.length > 0;
-        const createContext = hasGuards
+        const needsContext = hasGuards || hasCustomParams;
+        const createContext = needsContext
             ? (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 executionContext = createContext ? createContext(request, reply) : null;
+            if (hasGuards && executionContext) {
+                await this.executeGuardsOptimized(guardInstances, executionContext);
             }
             if (hasMiddleware) {
                 await this.executeMiddlewareChain(middlewareInstances, request, reply);
             }
-            const result = hasParams
-                ? await handler.apply(controllerInstance, this.resolveParamsOptimized(compiledResolvers, maxParamIndex, request, reply))
+            let args;
+            if (hasParams) {
+                args = await this.resolveAllParams(compiledResolvers, customParamsMeta, maxParamIndex, request, reply, executionContext);
+            }
+            const result = args
+                ? await handler.apply(controllerInstance, args)
                 : await handler.call(controllerInstance);
             if (statusCode)
                 reply.status(statusCode);
@@ -113,8 +127,8 @@ class Router {
                 return () => undefined;
         }
     }
-    resolveParamsOptimized(resolvers, maxIndex, request, reply) {
-        const context = {
+    async resolveAllParams(compiledResolvers, customParams, maxIndex, request, reply, executionContext) {
+        const routeContext = {
             request,
             reply,
             params: request.params,
@@ -122,9 +136,9 @@ class Router {
             body: request.body,
         };
         const args = new Array(maxIndex + 1);
-        for (let i = 0; i < resolvers.length; i++) {
-            const resolver = resolvers[i];
-            let value = resolver.extract(context);
+        for (let i = 0; i < compiledResolvers.length; i++) {
+            const resolver = compiledResolvers[i];
+            let value = resolver.extract(routeContext);
             if (resolver.zodSchema) {
                 const result = resolver.zodSchema.safeParse(value);
                 if (!result.success) {
@@ -134,6 +148,13 @@ class Router {
             }
             args[resolver.index] = value;
         }
+        if (customParams.length > 0) {
+            const ctx = executionContext ?? new execution_context_1.ExecutionContextImpl(request, reply, {}, '');
+            for (const customParam of customParams) {
+                const value = await customParam.factory(customParam.data, ctx);
+                args[customParam.index] = value;
+            }
+        }
         return args;
     }
     resolveGuardInstances(guards) {

package/dist/core/types.d.ts

@@ -1,6 +1,8 @@
 import type { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
 import { Container } from "@rikta/core/container";
 export type Constructor<T = any> = new (...args: any[]) => T;
+export type AbstractConstructor<T = any> = abstract new (...args: any[]) => T;
+export type AnyConstructor<T = any> = Constructor<T> | AbstractConstructor<T>;
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
 export interface RouteContext {
     request: FastifyRequest;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riktajs/core",
-  "version": "0.6.0",
+  "version": "0.8.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",
@@ -26,7 +26,7 @@
     "dependency-injection",
     "nestjs-like"
   ],
-  "author": "",
+  "author": "riktar",
   "license": "MIT",
   "dependencies": {
     "dotenv": "^17.2.3",