@noxfly/noxus 2.4.0 → 3.0.0-dev.0

package/src/decorators/injectable.decorator.ts

@@ -4,25 +4,78 @@
  * @author NoxFly
  */
 
-import { Lifetime } from "src/DI/app-injector";
-import { InjectorExplorer } from "src/DI/injector-explorer";
-import { defineInjectableMetadata } from "src/decorators/injectable.metadata";
-import { Type } from "src/main";
-export { getInjectableMetadata, hasInjectableMetadata, INJECTABLE_METADATA_KEY } from "src/decorators/injectable.metadata";
+import { Lifetime } from '../DI/app-injector';
+import { InjectorExplorer } from '../DI/injector-explorer';
+import { Token, TokenKey } from '../DI/token';
+import { Type } from '../utils/types';
+
+export interface InjectableOptions {
+    /**
+     * Lifetime of this injectable.
+     * @default 'scope'
+     */
+    lifetime?: Lifetime;
+
+    /**
+     * Explicit list of constructor dependencies, in the same order as the constructor parameters.
+     * Each entry is either a class constructor or a Token created with token().
+     *
+     * This replaces reflect-metadata / emitDecoratorMetadata entirely.
+     *
+     * @example
+     * @Injectable({ lifetime: 'singleton', deps: [MyRepo, DB_URL] })
+     * class MyService {
+     *   constructor(private repo: MyRepo, private dbUrl: string) {}
+     * }
+     */
+    deps?: ReadonlyArray<TokenKey>;
+}
 
 /**
- * The Injectable decorator marks a class as injectable.
- * It allows the class to be registered in the dependency injection system.
- * A class decorated with @Injectable can be injected into other classes
- * either from the constructor of the class that needs it of from the `inject` function.
- * @param lifetime - The lifetime of the injectable. Can be 'singleton', 'scope', or 'transient'.
+ * Marks a class as injectable into the Noxus DI container.
+ *
+ * Unlike the v2 @Injectable, this decorator:
+ * - Does NOT require reflect-metadata or emitDecoratorMetadata.
+ * - Requires you to declare deps explicitly when the class has constructor parameters.
+ * - Supports standalone usage — no module declaration needed.
+ *
+ * @example
+ * // No dependencies
+ * @Injectable()
+ * class Logger {}
+ *
+ * // With dependencies
+ * @Injectable({ lifetime: 'singleton', deps: [Logger, MyRepo] })
+ * class MyService {
+ *   constructor(private logger: Logger, private repo: MyRepo) {}
+ * }
+ *
+ * // With a named token
+ * const DB_URL = token<string>('DB_URL');
+ *
+ * @Injectable({ deps: [DB_URL] })
+ * class DbService {
+ *   constructor(private url: string) {}
+ * }
  */
-export function Injectable(lifetime: Lifetime = "scope"): ClassDecorator {
+export function Injectable(options: InjectableOptions = {}): ClassDecorator {
+    const { lifetime = 'scope', deps = [] } = options;
+
     return (target) => {
-        if (typeof target !== "function" || !target.prototype) {
-            throw new Error(`@Injectable can only be used on classes, not on ${typeof target}`);
+        if (typeof target !== 'function' || !target.prototype) {
+            throw new Error(`@Injectable can only be applied to classes, not ${typeof target}`);
         }
-        defineInjectableMetadata(target, lifetime);
-        InjectorExplorer.enqueue(target as unknown as Type<any>, lifetime);
+
+        const key = target as unknown as Type<unknown>;
+
+        InjectorExplorer.enqueue({
+            key,
+            implementation: key,
+            lifetime,
+            deps,
+            isController: false,
+        });
     };
 }
+
+export { Token, TokenKey };

package/src/decorators/method.decorator.ts

@@ -4,104 +4,63 @@
  * @author NoxFly
  */
 
-import { getGuardForControllerAction, IGuard } from "src/decorators/guards.decorator";
-import { Type } from "src/utils/types";
+import { Guard } from './guards.decorator';
+import { Middleware } from './middleware.decorator';
+
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'BATCH';
+export type AtomicHttpMethod = Exclude<HttpMethod, 'BATCH'>;
+
+const ATOMIC_METHODS = new Set<AtomicHttpMethod>(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']);
+export function isAtomicHttpMethod(m: unknown): m is AtomicHttpMethod {
+    return typeof m === 'string' && ATOMIC_METHODS.has(m as AtomicHttpMethod);
+}
+
+export interface IRouteOptions {
+    /**
+     * Guards specific to this route (merged with controller guards).
+     */
+    guards?: Guard[];
+    /**
+     * Middlewares specific to this route (merged with controller middlewares).
+     */
+    middlewares?: Middleware[];
+}
 
-/**
- * IRouteMetadata interface defines the metadata for a route.
- * It includes the HTTP method, path, handler name, and guards associated with the route.
- * This metadata is used to register the route in the application.
- * This is the configuration that waits a route's decorator.
- */
 export interface IRouteMetadata {
     method: HttpMethod;
     path: string;
     handler: string;
-    guards: Type<IGuard>[];
+    guards: Guard[];
+    middlewares: Middleware[];
 }
 
-/**
- * The different HTTP methods that can be used in the application.
- */
-export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'BATCH';
+const routeMetaMap = new WeakMap<object, IRouteMetadata[]>();
 
-/**
- * Atomic HTTP verbs supported by controllers. BATCH is handled at the router level only.
- */
-export type AtomicHttpMethod = Exclude<HttpMethod, 'BATCH'>;
-
-/**
- * The configuration that waits a route's decorator.
- * It contains the HTTP method, path, handler, and guards for the route.
- * @param verb The HTTP method for the route.
- * @returns A method decorator that registers the route with the specified HTTP method.
- */
-function createRouteDecorator(verb: HttpMethod): (path: string) => MethodDecorator {
-    return (path: string): MethodDecorator => {
+function createRouteDecorator(verb: HttpMethod) {
+    return (path: string, options: IRouteOptions = {}): MethodDecorator => {
         return (target, propertyKey) => {
-            const existingRoutes: IRouteMetadata[] = Reflect.getMetadata(ROUTE_METADATA_KEY, target.constructor) || [];
+            const ctor = target.constructor;
+            const existing: IRouteMetadata[] = routeMetaMap.get(ctor) ?? [];
 
-            const metadata: IRouteMetadata = {
+            existing.push({
                 method: verb,
-                path: path.trim().replace(/^\/|\/$/g, ''),
+                path: (path ?? '').trim().replace(/^\/|\/$/g, ''),
                 handler: propertyKey as string,
-                guards: getGuardForControllerAction((target.constructor as any).__controllerName, propertyKey as string),
-            };
+                guards: options.guards ?? [],
+                middlewares: options.middlewares ?? [],
+            });
 
-            existingRoutes.push(metadata);
-
-            Reflect.defineMetadata(ROUTE_METADATA_KEY, existingRoutes, target.constructor);
+            routeMetaMap.set(ctor, existing);
         };
     };
 }
 
-/**
- * Gets the route metadata for a given target class.
- * This metadata includes the HTTP method, path, handler, and guards defined by the route decorators.
- * @see Get
- * @see Post
- * @see Put
- * @see Patch
- * @see Delete
- * @param target The target class to get the route metadata from.
- * @returns An array of route metadata if it exists, otherwise an empty array.
- */
-export function getRouteMetadata(target: Type<unknown>): IRouteMetadata[] {
-    return Reflect.getMetadata(ROUTE_METADATA_KEY, target) || [];
+export function getRouteMetadata(target: object): IRouteMetadata[] {
+    return routeMetaMap.get(target) ?? [];
 }
 
-/**
- * Route decorator that defines a leaf in the routing tree, attaching it to a controller method
- * that will be called when the route is matched.
- * This route will have to be called with the GET method.
- */
-export const Get = createRouteDecorator('GET');
-
-/**
- * Route decorator that defines a leaf in the routing tree, attaching it to a controller method
- * that will be called when the route is matched.
- * This route will have to be called with the POST method.
- */
-export const Post = createRouteDecorator('POST');
-
-/**
- * Route decorator that defines a leaf in the routing tree, attaching it to a controller method
- * that will be called when the route is matched.
- * This route will have to be called with the PUT method.
- */
-export const Put = createRouteDecorator('PUT');
-/**
- * Route decorator that defines a leaf in the routing tree, attaching it to a controller method
- * that will be called when the route is matched.
- * This route will have to be called with the PATCH method.
- */
-export const Patch = createRouteDecorator('PATCH');
-
-/**
- * Route decorator that defines a leaf in the routing tree, attaching it to a controller method
- * that will be called when the route is matched.
- * This route will have to be called with the DELETE method.
- */
+export const Get    = createRouteDecorator('GET');
+export const Post   = createRouteDecorator('POST');
+export const Put    = createRouteDecorator('PUT');
+export const Patch  = createRouteDecorator('PATCH');
 export const Delete = createRouteDecorator('DELETE');
-
-export const ROUTE_METADATA_KEY = Symbol('ROUTE_METADATA_KEY');

package/src/decorators/middleware.decorator.ts

@@ -4,79 +4,12 @@
  * @author NoxFly
  */
 
-import { IResponse, Request } from "src/request";
-import { Logger } from "src/utils/logger";
-import { MaybeAsync, Type } from "src/utils/types";
+import { IResponse, Request } from '../request';
+import { MaybeAsync } from '../utils/types';
 
 /**
- * NextFunction is a function that is called to continue the middleware chain.
- * It returns an Promise that emits when the next middleware is done.
+ * A middleware intercepts requests before they reach guards and the handler.
+ * Implement this interface and pass the class to @Controller({ middlewares }) or per-route options.
  */
+export type Middleware = (request: Request, response: IResponse, next: NextFunction) => MaybeAsync<void>;
 export type NextFunction = () => Promise<void>;
-
-/**
- * IMiddleware interface defines a middleware that can be used in the application.
- * It has an `invoke` method that takes a request, a response, and a next function.
- * The `invoke` method can return a MaybeAsync, which means it can return either a value or a Promise.
- *
- * Use it on a class that should be registered as a middleware in the application.
- */
-export interface IMiddleware {
-    invoke(request: Request, response: IResponse, next: NextFunction): MaybeAsync<void>;
-}
-
-/**
- * UseMiddlewares decorator can be used to register middlewares for a controller or a controller action.
- *
- * @param mdlw - The middlewares list to register for the controller or the controller action.
- */
-export function UseMiddlewares(mdlw: Type<IMiddleware>[]): ClassDecorator & MethodDecorator {
-    return (target: Function | object, propertyKey?: string | symbol) => {
-        let key: string;
-
-        // Method decorator
-        if(propertyKey) {
-            const ctrlName = target.constructor.name;
-            const actionName = propertyKey as string;
-            key = `${ctrlName}.${actionName}`;
-        }
-        // Class decorator
-        else {
-            const ctrlName = (target as Type<unknown>).name;
-            key = `${ctrlName}`;
-        }
-
-        if(middlewares.has(key)) {
-            throw new Error(`Middlewares(s) already registered for ${key}`);
-        }
-
-        middlewares.set(key, mdlw);
-    };
-}
-
-/**
- * Gets the middlewares for a controller or a controller action.
- * This function retrieves the middlewares registered with the UseMiddlewares decorator.
- * It returns an array of middleware classes that can be used to process requests for the specified controller.
- * @param controllerName The name of the controller to get the middlewares for.
- * @returns An array of middlewares for the controller.
- */
-export function getMiddlewaresForController(controllerName: string): Type<IMiddleware>[] {
-    const key = `${controllerName}`;
-    return middlewares.get(key) ?? [];
-}
-
-/**
- * Gets the middlewares for a controller action.
- * This function retrieves the middlewares registered with the UseMiddlewares decorator for a specific action in a controller.
- * It returns an array of middleware classes that can be used to process requests for the specified controller action.
- * @param controllerName The name of the controller to get the middlewares for.
- * @param actionName The name of the action to get the middlewares for.
- * @returns An array of middlewares for the controller action.
- */
-export function getMiddlewaresForControllerAction(controllerName: string, actionName: string): Type<IMiddleware>[] {
-    const key = `${controllerName}.${actionName}`;
-    return middlewares.get(key) ?? [];
-}
-
-const middlewares = new Map<string, Type<IMiddleware>[]>();

package/src/index.ts

@@ -2,9 +2,12 @@
  * @copyright 2025 NoxFly
  * @license MIT
  * @author NoxFly
+ *
+ * Entry point for renderer process and preload consumers.
  */
 
 export * from './request';
+export * from './preload-bridge';
 export * from './renderer-events';
 export * from './renderer-client';
 export type { HttpMethod, AtomicHttpMethod } from './decorators/method.decorator';

package/src/main.ts

@@ -2,15 +2,12 @@
  * @copyright 2025 NoxFly
  * @license MIT
  * @author NoxFly
- */
-
-/**
+ *
  * Entry point for Electron main-process consumers.
- * order of exports here matters and can affect module resolution.
- * Please be cautious when modifying.
  */
 
 export * from './DI/app-injector';
+export * from './DI/token';
 export * from './router';
 export * from './app';
 export * from './bootstrap';
@@ -19,15 +16,11 @@ export * from './decorators/middleware.decorator';
 export * from './decorators/guards.decorator';
 export * from './decorators/controller.decorator';
 export * from './decorators/injectable.decorator';
-export * from './decorators/inject.decorator';
 export * from './decorators/method.decorator';
-export * from './decorators/module.decorator';
-export * from './preload-bridge';
 export * from './utils/logger';
 export * from './utils/types';
 export * from './utils/forward-ref';
 export * from './request';
-export * from './renderer-events';
-export * from './renderer-client';
 export * from './socket';
-
+export * from './window/window-manager';
+export * from './routes';

package/src/non-electron-process.ts

@@ -17,7 +17,6 @@
 export * from './DI/app-injector';
 export * from './exceptions';
 export * from './decorators/injectable.decorator';
-export * from './decorators/inject.decorator';
 export * from './utils/logger';
 export * from './utils/types';
 export * from './utils/forward-ref';

package/src/preload-bridge.ts

@@ -5,7 +5,7 @@
  */
 
 import { contextBridge, ipcRenderer } from 'electron/renderer';
-import type { IPortRequester } from 'src/renderer-client';
+import type { IPortRequester } from './renderer-client';
 
 export interface NoxusPreloadAPI extends IPortRequester {}
 

package/src/renderer-client.ts

@@ -4,8 +4,8 @@
  * @author NoxFly
  */
 
-import { IBatchRequestItem, IBatchResponsePayload, IRequest, IResponse } from 'src/request';
-import { RendererEventRegistry } from 'src/renderer-events';
+import { IBatchRequestItem, IBatchResponsePayload, IRequest, IResponse } from './request';
+import { RendererEventRegistry } from './renderer-events';
 
 export interface IPortRequester {
     requestPort(): void;

package/src/renderer-events.ts

@@ -8,7 +8,7 @@
  * Lightweight event registry to help renderer processes subscribe to
  * push messages sent by the main process through Noxus.
  */
-import { IRendererEventMessage, isRendererEventMessage } from 'src/request';
+import { IRendererEventMessage, isRendererEventMessage } from './request';
 
 export type RendererEventHandler<TPayload = unknown> = (payload: TPayload) => void;
 

package/src/request.ts

@@ -4,9 +4,9 @@
  * @author NoxFly
  */
 
-import 'reflect-metadata';
-import { AtomicHttpMethod, HttpMethod } from 'src/decorators/method.decorator';
-import { AppInjector, RootInjector } from 'src/DI/app-injector';
+
+import { AtomicHttpMethod, HttpMethod } from './decorators/method.decorator';
+import { AppInjector, RootInjector } from './DI/app-injector';
 
 /**
  * The Request class represents an HTTP request in the Noxus framework.