@noxfly/noxus 1.0.0

package/src/guards.ts

@@ -0,0 +1,51 @@
+import { Logger } from 'src/logger';
+import { Type } from 'src/metadata';
+import { MaybeAsync } from 'src/misc';
+import { Request } from 'src/request';
+
+export interface IGuard {
+    canActivate(request: Request): MaybeAsync<boolean>;
+}
+
+const authorizations = new Map<string, Type<IGuard>[]>();
+
+/**
+ * Peut être utilisé pour protéger les routes d'un contrôleur.
+ * Peut être utilisé sur une classe controleur, ou sur une méthode de contrôleur.
+ */
+export function Authorize(...guardClasses: Type<IGuard>[]): MethodDecorator & ClassDecorator {
+    return (target: any, 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(authorizations.has(key)) {
+            throw new Error(`Guard(s) already registered for ${key}`);
+        }
+
+        Logger.debug(`Registering guards for ${key}: ${guardClasses.map(c => c.name).join(', ')}`);
+
+        authorizations.set(key, guardClasses);
+    };
+}
+
+
+export function getGuardForController(controllerName: string): Type<IGuard>[] {
+    const key = `${controllerName}`;
+    return authorizations.get(key) ?? [];
+}
+
+export function getGuardForControllerAction(controllerName: string, actionName: string): Type<IGuard>[] {
+    const key = `${controllerName}.${actionName}`;
+    return authorizations.get(key) ?? [];
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from './app-injector';
+export * from './router';
+export * from './app';
+export * from './bootstrap';
+export * from './exceptions';
+export * from './guards';
+export * from './logger';
+export * from './metadata';
+export * from './misc';
+export * from './request';

package/src/injector-explorer.ts

@@ -0,0 +1,53 @@
+import { Lifetime, RootInjector } from "src/app-injector";
+import { Logger } from "src/logger";
+import { Type, getModuleMetadata, getControllerMetadata, getRouteMetadata, getInjectableMetadata } from "src/metadata";
+import { Router } from "src/router";
+
+export class InjectorExplorer {
+    /**
+     * Enregistre la classe comme étant injectable.
+     * Lorsqu'une classe sera instanciée, si elle a des dépendances, et que celles-ci
+     * figurent dans la liste grâce à cette méthode, elles seront injectées dans le
+     * constructeur de la classe.
+     */
+    public static register(target: Type<unknown>, lifetime: Lifetime): typeof RootInjector {
+        Logger.debug(`Registering ${target.name} as ${lifetime}`);
+        if(RootInjector.bindings.has(target)) // already registered
+            return RootInjector;
+
+        RootInjector.bindings.set(target, {
+            implementation: target,
+            lifetime
+        });
+
+        if(lifetime === 'singleton') {
+            RootInjector.resolve(target);
+        }
+
+        if(getModuleMetadata(target)) {
+            Logger.log(`${target.name} dependencies initialized`);
+            return RootInjector;
+        }
+
+        const controllerMeta = getControllerMetadata(target);
+        
+        if(controllerMeta) {
+            const router = RootInjector.resolve(Router);
+            router?.registerController(target);
+            return RootInjector;
+        }
+
+        const routeMeta = getRouteMetadata(target);
+        
+        if(routeMeta) {
+            return RootInjector;
+        }
+
+        if(getInjectableMetadata(target)) {
+            Logger.log(`Registered ${target.name} as ${lifetime}`);
+            return RootInjector;
+        }
+
+        return RootInjector;
+    }
+}

package/src/logger.ts

@@ -0,0 +1,136 @@
+function getPrettyTimestamp(): string {
+    const now = new Date();
+    return `${now.getDate().toString().padStart(2, '0')}/${(now.getMonth() + 1).toString().padStart(2, '0')}/${now.getFullYear()}`
+        + ` ${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`;
+}
+
+function getLogPrefix(callee: string, messageType: string, color: string): string {
+    const timestamp = getPrettyTimestamp();
+
+    const spaces = ' '.repeat(10 - messageType.length);
+
+    return `${color}[APP] ${process.pid} - ${Logger.colors.initial}`
+        + `${timestamp}${spaces}`
+        + `${color}${messageType.toUpperCase()}${Logger.colors.initial} `
+        + `${Logger.colors.yellow}[${callee}]${Logger.colors.initial}`;
+}
+
+function formatObject(prefix: string, arg: object): string {
+    const json = JSON.stringify(arg, null, 2);
+                
+    const prefixedJson = json
+        .split('\n')
+        .map((line, idx) => idx === 0 ? `${Logger.colors.darkGrey}${line}` : `${prefix} ${Logger.colors.grey}${line}`)
+        .join('\n') + Logger.colors.initial;
+
+    return prefixedJson;
+}
+
+function formattedArgs(prefix: string, args: any[], color: string): any[] {
+    return args.map(arg => {
+        if(typeof arg === 'string') {
+            return `${color}${arg}${Logger.colors.initial}`;
+        }
+
+        else if(typeof arg === 'object') {
+            return formatObject(prefix, arg);
+        }
+
+        return arg;
+    });
+}
+
+function getCallee(): string {
+    const stack = new Error().stack?.split('\n') ?? [];
+    const caller = stack[3]?.trim().match(/at (.+?)(?:\..+)? .+$/)?.[1]?.replace('Object', '') || "App";
+    return caller;
+}
+
+export type LogLevel = 'log' | 'info' | 'warn' | 'error' | 'debug';
+
+const logLevelRank: Record<LogLevel, number> = {
+    debug: 0,
+    log: 1,
+    info: 2,
+    warn: 3,
+    error: 4,
+};
+
+function canLog(level: LogLevel): boolean {
+    return logLevelRank[level] >= logLevelRank[logLevel];
+}
+
+let logLevel: LogLevel = 'log';
+
+export namespace Logger {
+    
+    export function setLogLevel(level: LogLevel): void {
+        logLevel = level;
+    }
+
+    export const colors = {
+        black: '\x1b[0;30m',
+        grey: '\x1b[0;37m',
+        red: '\x1b[0;31m',
+        green: '\x1b[0;32m',
+        brown: '\x1b[0;33m',
+        blue: '\x1b[0;34m',
+        purple: '\x1b[0;35m',
+        
+        darkGrey: '\x1b[1;30m',
+        lightRed: '\x1b[1;31m',
+        lightGreen: '\x1b[1;32m',
+        yellow: '\x1b[1;33m',
+        lightBlue: '\x1b[1;34m',
+        magenta: '\x1b[1;35m',
+        cyan: '\x1b[1;36m',
+        white: '\x1b[1;37m',
+
+        initial: '\x1b[0m'
+    };
+
+    export function log(...args: any[]): void {
+        if(!canLog('log'))
+            return;
+
+        const callee = getCallee();
+        const prefix = getLogPrefix(callee, "log", colors.green);
+        console.log(prefix, ...formattedArgs(prefix, args, colors.green));
+    }
+
+    export function info(...args: any[]): void {
+        if(!canLog('info'))
+            return;
+
+        const callee = getCallee();
+        const prefix = getLogPrefix(callee, "info", colors.blue);
+        console.info(prefix, ...formattedArgs(prefix, args, colors.blue));
+    }
+
+    export function warn(...args: any[]): void {
+        if(!canLog('warn'))
+            return;
+
+        const callee = getCallee();
+        const prefix = getLogPrefix(callee, "warn", colors.brown);
+        console.warn(prefix, ...formattedArgs(prefix, args, colors.brown));
+    }
+
+    export function error(...args: any[]): void {
+        if(!canLog('error'))
+            return;
+
+        const callee = getCallee();
+        const prefix = getLogPrefix(callee, "error", colors.red);
+        console.error(prefix, ...formattedArgs(prefix, args, colors.red));
+    }
+
+    export function debug(...args: any[]): void {
+        if(!canLog('debug'))
+            return;
+
+        const callee = getCallee();
+        const prefix = getLogPrefix(callee, "debug", colors.purple);
+        console.debug(prefix, ...formattedArgs(prefix, args, colors.purple));
+    }
+}

package/src/metadata.ts

@@ -0,0 +1,52 @@
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+
+import { Lifetime } from "src/app-injector";
+import { IGuard } from "src/guards";
+import { HttpMethod } from "src/router";
+
+declare const Type: FunctionConstructor;
+export interface Type<T> extends Function {
+    // eslint-disable-next-line @typescript-eslint/prefer-function-type
+    new (...args: any[]): T;
+}
+
+export const MODULE_METADATA_KEY = Symbol('MODULE_METADATA_KEY');
+export const INJECTABLE_METADATA_KEY = Symbol('INJECTABLE_METADATA_KEY');
+export const CONTROLLER_METADATA_KEY = Symbol('CONTROLLER_METADATA_KEY');
+export const ROUTE_METADATA_KEY = Symbol('ROUTE_METADATA_KEY');
+
+export interface IModuleMetadata {
+    imports?: Type<unknown>[];
+    providers?: Type<unknown>[];
+    controllers?: Type<unknown>[];
+    exports?: Type<unknown>[];
+}
+
+export interface IRouteMetadata {
+    method: HttpMethod;
+    path: string;
+    handler: string;
+    guards: Type<IGuard>[];
+}
+
+export interface IControllerMetadata {
+    path: string;
+    guards: Type<IGuard>[];
+}
+
+
+export function getControllerMetadata(target: Type<unknown>): IControllerMetadata | undefined {
+    return Reflect.getMetadata(CONTROLLER_METADATA_KEY, target);
+}
+
+export function getRouteMetadata(target: Type<unknown>): IRouteMetadata[] {
+    return Reflect.getMetadata(ROUTE_METADATA_KEY, target) || [];
+}
+
+export function getModuleMetadata(target: Function): IModuleMetadata | undefined {
+    return Reflect.getMetadata(MODULE_METADATA_KEY, target);
+}
+
+export function getInjectableMetadata(target: Type<unknown>): Lifetime | undefined {
+    return Reflect.getMetadata(INJECTABLE_METADATA_KEY, target);
+}

package/src/misc.ts

@@ -0,0 +1 @@
+export type MaybeAsync<T> = T | Promise<T>;

package/src/radix-tree.ts

@@ -0,0 +1,137 @@
+type Params = Record<string, string>;
+
+interface ISearchResult<T> {
+    node: RadixNode<T>;
+    params: Params;
+}
+
+class RadixNode<T> {
+    public segment: string;
+    public children: RadixNode<T>[] = [];
+    public value?: T;
+    public isParam: boolean;
+    public paramName?: string;
+
+    constructor(segment: string) {
+        this.segment = segment;
+        this.isParam = segment.startsWith(":");
+        
+        if(this.isParam) {
+            this.paramName = segment.slice(1);
+        }
+    }
+
+    public matchChild(segment: string): RadixNode<T> | undefined {
+        for(const child of this.children) {
+            if(child.isParam || segment.startsWith(child.segment))
+                return child; // param match
+        }
+
+        return undefined;
+    }
+
+    public findExactChild(segment: string): RadixNode<T> | undefined {
+        return this.children.find(c => c.segment === segment);
+    }
+
+    public addChild(node: RadixNode<T>): void {
+        this.children.push(node);
+    }
+}
+
+export class RadixTree<T> {
+    private readonly root = new RadixNode<T>("");
+
+    public insert(path: string, value: T): void {
+        const segments = this.normalize(path);
+        this.insertRecursive(this.root, segments, value);
+    }
+
+    private insertRecursive(node: RadixNode<T>, segments: string[], value: T): void {
+        if(segments.length === 0) {
+            node.value = value;
+            return;
+        }
+
+        const segment = segments[0] ?? "";
+
+        let child = node.children.find(c =>
+            c.isParam === segment.startsWith(":") &&
+            (c.isParam || c.segment === segment)
+        );
+
+        if(!child) {
+            child = new RadixNode<T>(segment);
+            node.addChild(child);
+        }
+
+        this.insertRecursive(child, segments.slice(1), value);
+    }
+
+    public search(path: string): ISearchResult<T> | undefined {
+        const segments = this.normalize(path);
+        return this.searchRecursive(this.root, segments, {});
+    }
+
+    private searchRecursive(node: RadixNode<T>, segments: string[], params: Params): ISearchResult<T> | undefined {
+        if(segments.length === 0) {
+            if(node.value !== undefined) {
+                return {
+                    node: node,
+                    params
+                };
+            }
+
+            return undefined;
+        }
+
+        const [segment, ...rest] = segments;
+
+        for(const child of node.children) {
+            if(child.isParam) {
+                const paramName = child.paramName!;
+                
+                const childParams: Params = {
+                    ...params,
+                    [paramName]: segment ?? "",
+                };
+
+                if(rest.length === 0) {
+                    return {
+                        node: child,
+                        params: childParams
+                    };
+                }
+
+                const result = this.searchRecursive(child, rest, childParams);
+                
+                if(result)
+                    return result;
+            }
+            else if(segment === child.segment) {
+                if(rest.length === 0) {
+                    return {
+                        node: child,
+                        params
+                    };
+                }
+
+                const result = this.searchRecursive(child, rest, params);
+
+                if(result)
+                    return result;
+            }
+        }
+
+        return undefined;
+    }
+
+    private normalize(path: string): string[] {
+        const segments = path
+            .replace(/^\/+|\/+$/g, "")
+            .split("/")
+            .filter(Boolean);
+
+        return ['', ...segments];
+    } 
+}

package/src/request.ts

@@ -0,0 +1,38 @@
+import { IApp } from 'src/app';
+import { RootInjector } from 'src/app-injector';
+import { HttpMethod } from 'src/router';
+import 'reflect-metadata';
+
+
+//
+
+export class Request {
+    public readonly context: any = RootInjector.createScope();
+
+    public readonly params: Record<string, string> = {};
+
+    constructor(
+        public readonly app: IApp,
+        public readonly event: Electron.MessageEvent,
+        public readonly id: string,
+        public readonly method: HttpMethod,
+        public readonly path: string,
+        public readonly body: any,
+    ) {
+        this.path = path.replace(/^\/|\/$/g, '');
+    }
+}
+
+export interface IRequest<T = any> {
+    requestId: string;
+    path: string;
+    method: HttpMethod;
+    body?: T;
+}
+
+export interface IResponse<T = any> {
+    requestId: string;
+    status: number;
+    body?: T;
+    error?: string;
+}