@noxfly/noxus 3.0.0-dev.4 → 3.0.0-dev.6

package/src/DI/injector-explorer.ts

@@ -1,201 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import { Lifetime, RootInjector } from './app-injector';
-import { TokenKey } from './token';
-import { Type } from '../utils/types';
-import { Logger } from '../utils/logger';
-import { Guard } from '../decorators/guards.decorator';
-import { Middleware } from '../decorators/middleware.decorator';
-
-export interface PendingRegistration {
-    key: TokenKey;
-    implementation: Type<unknown>;
-    lifetime: Lifetime;
-    deps: ReadonlyArray<TokenKey>;
-    isController: boolean;
-    pathPrefix?: string;
-}
-
-/**
- * Callback invoked for each controller registration discovered during flush.
- * Decouples InjectorExplorer from the Router to avoid circular imports.
- */
-export type ControllerRegistrar = (
-    controllerClass: Type<unknown>,
-    pathPrefix: string,
-    routeGuards: Guard[],
-    routeMiddlewares: Middleware[],
-) => void;
-
-/**
- * InjectorExplorer accumulates registrations emitted by decorators
- * at import time, then flushes them in two phases (bind → resolve)
- * once bootstrapApplication triggers processing.
- *
- * Because deps are now explicit arrays (no reflect-metadata), this class
- * no longer needs to introspect constructor parameter types.
- */
-export class InjectorExplorer {
-    private static readonly pending: PendingRegistration[] = [];
-    private static processed = false;
-    private static accumulating = false;
-    private static loadingLock: Promise<void> = Promise.resolve();
-    private static controllerRegistrar: ControllerRegistrar | null = null;
-
-    // -------------------------------------------------------------------------
-    // Public API
-    // -------------------------------------------------------------------------
-
-    /**
-     * Sets the callback used to register controllers.
-     * Must be called once before processPending (typically by bootstrapApplication).
-     */
-    public static setControllerRegistrar(registrar: ControllerRegistrar): void {
-        InjectorExplorer.controllerRegistrar = registrar;
-    }
-
-    public static enqueue(reg: PendingRegistration): void {
-        if (InjectorExplorer.processed && !InjectorExplorer.accumulating) {
-            InjectorExplorer._registerImmediate(reg);
-            return;
-        }
-        InjectorExplorer.pending.push(reg);
-    }
-
-    /**
-     * Two-phase flush of all pending registrations collected at startup.
-     * Called by bootstrapApplication after app.whenReady().
-     */
-    public static processPending(singletonOverrides?: Map<TokenKey, unknown>): void {
-        const queue = [...InjectorExplorer.pending];
-        InjectorExplorer.pending.length = 0;
-
-        InjectorExplorer._phaseOne(queue);
-        InjectorExplorer._phaseTwo(queue, singletonOverrides);
-
-        InjectorExplorer.processed = true;
-    }
-
-    /** Enters accumulation mode for lazy-loaded batches. */
-    public static beginAccumulate(): void {
-        InjectorExplorer.accumulating = true;
-    }
-
-    /**
-     * Exits accumulation mode and flushes queued registrations
-     * with the same two-phase guarantee as processPending.
-     * Serialised through a lock to prevent concurrent lazy loads from corrupting the queue.
-     */
-    public static flushAccumulated(
-        routeGuards: Guard[] = [],
-        routeMiddlewares: Middleware[] = [],
-        pathPrefix = '',
-    ): Promise<void> {
-        InjectorExplorer.loadingLock = InjectorExplorer.loadingLock.then(() => {
-            InjectorExplorer.accumulating = false;
-            const queue = [...InjectorExplorer.pending];
-            InjectorExplorer.pending.length = 0;
-            InjectorExplorer._phaseOne(queue);
-
-            // Stamp the path prefix on controller registrations
-            for (const reg of queue) {
-                if (reg.isController) reg.pathPrefix = pathPrefix;
-            }
-
-            InjectorExplorer._phaseTwo(queue, undefined, routeGuards, routeMiddlewares);
-        });
-
-        return InjectorExplorer.loadingLock;
-    }
-
-    /**
-     * Returns a Promise that resolves once all pending flushAccumulated calls
-     * have completed. Useful for awaiting lazy-load serialisation.
-     */
-    public static waitForFlush(): Promise<void> {
-        return InjectorExplorer.loadingLock;
-    }
-
-    /**
-     * Resets the explorer state. Intended for tests only.
-     */
-    public static reset(): void {
-        InjectorExplorer.pending.length = 0;
-        InjectorExplorer.processed = false;
-        InjectorExplorer.accumulating = false;
-        InjectorExplorer.loadingLock = Promise.resolve();
-        InjectorExplorer.controllerRegistrar = null;
-    }
-
-    // -------------------------------------------------------------------------
-    // Private helpers
-    // -------------------------------------------------------------------------
-
-    /** Phase 1: register all bindings without instantiating anything. */
-    private static _phaseOne(queue: PendingRegistration[]): void {
-        for (const reg of queue) {
-            RootInjector.register(reg.key, reg.implementation, reg.lifetime, reg.deps);
-        }
-    }
-
-    /** Phase 2: validate deps, resolve singletons and register controllers via the registrar callback. */
-    private static _phaseTwo(
-        queue: PendingRegistration[],
-        overrides?: Map<TokenKey, unknown>,
-        routeGuards: Guard[] = [],
-        routeMiddlewares: Middleware[] = [],
-    ): void {
-        // Early dependency validation: warn about deps that have no binding
-        for (const reg of queue) {
-            for (const dep of reg.deps) {
-                if (!RootInjector.bindings.has(dep as any) && !RootInjector.singletons.has(dep as any)) {
-                    Logger.warn(`[Noxus DI] "${reg.implementation.name}" declares dep "${(dep as any).name ?? dep}" which has no binding`);
-                }
-            }
-        }
-
-        for (const reg of queue) {
-            // Apply value overrides (e.g. singleton instances provided via bootstrapApplication config)
-            if (overrides?.has(reg.key)) {
-                const override = overrides.get(reg.key);
-                RootInjector.singletons.set(reg.key as any, override);
-                Logger.log(`Registered ${reg.implementation.name} as singleton (overridden)`);
-                continue;
-            }
-
-            if (reg.lifetime === 'singleton') {
-                RootInjector.resolve(reg.key);
-            }
-
-            if (reg.isController) {
-                if (!InjectorExplorer.controllerRegistrar) {
-                    throw new Error('[Noxus DI] No controller registrar set. Call InjectorExplorer.setControllerRegistrar() before processing.');
-                }
-                InjectorExplorer.controllerRegistrar(
-                    reg.implementation,
-                    reg.pathPrefix ?? '',
-                    routeGuards,
-                    routeMiddlewares,
-                );
-            } else if (reg.lifetime !== 'singleton') {
-                Logger.log(`Registered ${reg.implementation.name} as ${reg.lifetime}`);
-            }
-        }
-    }
-
-    private static _registerImmediate(reg: PendingRegistration): void {
-        RootInjector.register(reg.key, reg.implementation, reg.lifetime, reg.deps);
-
-        if (reg.lifetime === 'singleton') {
-            RootInjector.resolve(reg.key);
-        }
-
-        if (reg.isController && InjectorExplorer.controllerRegistrar) {
-            InjectorExplorer.controllerRegistrar(reg.implementation, '', [], []);
-        }
-    }
-}

package/src/DI/token.ts

@@ -1,53 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import { Type } from '../utils/types';
-
-/**
- * A DI token uniquely identifies a dependency.
- * It can wrap a class (Type<T>) or be a named symbol token.
- *
- * Using tokens instead of reflect-metadata means dependencies are
- * declared explicitly — no magic type inference, no emitDecoratorMetadata.
- *
- * @example
- * // Class token (most common)
- * const MY_SERVICE = token(MyService);
- *
- * // Named symbol token (for interfaces or non-class values)
- * const DB_URL = token<string>('DB_URL');
- */
-export class Token<T> {
-    public readonly description: string;
-
-    constructor(
-        public readonly target: Type<T> | string,
-    ) {
-        this.description = typeof target === 'string' ? target : target.name;
-    }
-
-    public toString(): string {
-        return `Token(${this.description})`;
-    }
-}
-
-/**
- * Creates a DI token for a class type or a named value.
- *
- * @example
- * export const MY_SERVICE = token(MyService);
- * export const DB_URL = token<string>('DB_URL');
- */
-export function token<T>(target: Type<T> | string): Token<T> {
-    return new Token<T>(target);
-}
-
-/**
- * The key used to look up a class token in the registry.
- * For class tokens, the key is the class constructor itself.
- * For named tokens, the key is the Token instance.
- */
-export type TokenKey<T = unknown> = Type<T> | Token<T>;

package/src/decorators/controller.decorator.ts

@@ -1,58 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import { InjectorExplorer } from '../DI/injector-explorer';
-import { TokenKey } from '../DI/token';
-import { Type } from '../utils/types';
-
-export interface ControllerOptions {
-    /**
-     * Explicit constructor dependencies.
-     */
-    deps?: ReadonlyArray<TokenKey>;
-}
-
-export interface IControllerMetadata {
-    deps: ReadonlyArray<TokenKey>;
-}
-
-const controllerMetaMap = new WeakMap<object, IControllerMetadata>();
-
-/**
- * Marks a class as a Noxus controller.
- * Controllers are always scope-scoped injectables.
- * The route prefix and guards/middlewares are declared in defineRoutes(), not here.
- *
- * @example
- * @Controller({ deps: [UserService] })
- * export class UserController {
- *   constructor(private svc: UserService) {}
- *
- *   @Get('byId/:userId')
- *   getUserById(req: Request) { ... }
- * }
- */
-export function Controller(options: ControllerOptions = {}): ClassDecorator {
-    return (target) => {
-        const meta: IControllerMetadata = {
-            deps: options.deps ?? [],
-        };
-
-        controllerMetaMap.set(target, meta);
-
-        InjectorExplorer.enqueue({
-            key: target as unknown as Type<unknown>,
-            implementation: target as unknown as Type<unknown>,
-            lifetime: 'scope',
-            deps: options.deps ?? [],
-            isController: true,
-        });
-    };
-}
-
-export function getControllerMetadata(target: object): IControllerMetadata | undefined {
-    return controllerMetaMap.get(target);
-}

package/src/decorators/guards.decorator.ts

@@ -1,15 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import { Request } from '../internal/request';
-import { MaybeAsync } from '../utils/types';
-
-/**
- * A guard decides whether an incoming request should reach the handler.
- * Implement this interface and pass the class to @Controller({ guards }) or @Get('path', { guards }).
- */
-
-export type Guard = (request: Request) => MaybeAsync<boolean>;

package/src/decorators/injectable.decorator.ts

@@ -1,81 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-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>;
-}
-
-/**
- * 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(options: InjectableOptions = {}): ClassDecorator {
-    const { lifetime = 'scope', deps = [] } = options;
-
-    return (target) => {
-        if (typeof target !== 'function' || !target.prototype) {
-            throw new Error(`@Injectable can only be applied to classes, not ${typeof target}`);
-        }
-
-        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

@@ -1,66 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-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[];
-}
-
-export interface IRouteMetadata {
-    method: HttpMethod;
-    path: string;
-    handler: string;
-    guards: Guard[];
-    middlewares: Middleware[];
-}
-
-const routeMetaMap = new WeakMap<object, IRouteMetadata[]>();
-
-function createRouteDecorator(verb: HttpMethod) {
-    return (path: string, options: IRouteOptions = {}): MethodDecorator => {
-        return (target, propertyKey) => {
-            const ctor = target.constructor;
-            const existing: IRouteMetadata[] = routeMetaMap.get(ctor) ?? [];
-
-            existing.push({
-                method: verb,
-                path: (path ?? '').trim().replace(/^\/|\/$/g, ''),
-                handler: propertyKey as string,
-                guards: options.guards ?? [],
-                middlewares: options.middlewares ?? [],
-            });
-
-            routeMetaMap.set(ctor, existing);
-        };
-    };
-}
-
-export function getRouteMetadata(target: object): IRouteMetadata[] {
-    return routeMetaMap.get(target) ?? [];
-}
-
-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');

package/src/decorators/middleware.decorator.ts

@@ -1,15 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import { IResponse, Request } from '../internal/request';
-import { MaybeAsync } from '../utils/types';
-
-/**
- * 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>;

package/src/index.ts

@@ -1,10 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- *
- * Entry point for renderer process and preload consumers.
- */
-
-// src/index.ts — redirige vers renderer
-export * from './renderer';