raiton 1.0.0-alpha.2 → 1.0.0-alpha.3

package/source/core/router/handler.ts

@@ -1,8 +1,11 @@
-import {ControllerMetaInterface, MiddlewareCallable, RouteMetaInterface} from "@/types";
-import {Parametrable} from "@/sdk";
+import {ControllerMetaInterface, MiddlewareCallable, ParamMetaInterface, RouteMetaInterface} from "@/types";
+import {METADATA_KEYS, Parametrable} from "@/sdk";
 import {Logger} from "@protorians/logger";
-import {Throwable} from "@/sdk/throwable";
-import {middlewareCompose} from "@/core";
+import {middlewareCompose, Raiton} from "@/core";
+import {DataTransferObject} from "@/sdk/data-transfer-object";
+import {Throwable} from "@/sdk/exceptions/throwable";
+import {HttpException} from "@/sdk/exceptions";
+import {ThrowableResponse} from "@/sdk/responses/http-throwable";
 
 export function createHandler(
     instance: any,
@@ -10,50 +13,103 @@ export function createHandler(
     controllerMeta: ControllerMetaInterface,
 ) {
     return async (ctx: any) => {
-        const args: any[] = []
-
-        for (const p of routeMeta.params) {
-
-            switch (p.type) {
-                case Parametrable.QUERY:
-                    args[p.index] =
-                        ctx.req.query?.[p.key!]
-                    break
-                case Parametrable.PARAM:
-                    args[p.index] =
-                        ctx.req.params?.[p.key!] ?? ctx.params?.[p.key!]
-                    break
-                case Parametrable.BODY:
-                    args[p.index] = ctx.req.body
-                    break
-                case Parametrable.HEADER:
-                    args[p.index] = ctx.req.headers[p.key!.toLowerCase()] as any;
-                    break
-                case Parametrable.REQ:
-                    args[p.index] = ctx.req
-                    break
-                case Parametrable.REPLY:
-                    args[p.index] = ctx.REPLY
-                    break
-                case Parametrable.UPLOAD_FILE:
-                    args[p.index] = ctx.req.file
-                    break
-                case Parametrable.CUSTOM:
-                    args[p.index] = p.callable?.(ctx) ?? null;
-                    break;
+        const isDevelopment = Raiton.thread?.builder?.options?.development || false;
+        const handlerName = `${instance.constructor.name}.${routeMeta.propertyKey}`
+
+        try {
+            const args: any[] = []
+            const params: ParamMetaInterface[] = Reflect.getMetadata(METADATA_KEYS.ROUTE_PARAMETERS, instance.constructor)?.[routeMeta.propertyKey] || []
+
+            for (const p of params) {
+
+                switch (p.type) {
+                    case Parametrable.QUERY:
+                        args[p.index] =
+                            ctx.req.query?.[p.key!]
+                        break
+                    case Parametrable.PARAM:
+                        args[p.index] =
+                            ctx.req.params?.[p.key!] ?? ctx.params?.[p.key!]
+                        break
+                    case Parametrable.BODY:
+                        if (p.metatype && 'prototype' in p.metatype) {
+                            ctx.req.body = new p.metatype(ctx.req.body)
+                        }
+                        args[p.index] = ctx.req.body
+                        break
+                    case Parametrable.HEADER:
+                        args[p.index] = ctx.req.headers[p.key!.toLowerCase()] as any;
+                        break
+                    case Parametrable.REQ:
+                        args[p.index] = ctx.req
+                        break
+                    case Parametrable.REPLY:
+                        args[p.index] = ctx.REPLY
+                        break
+                    case Parametrable.UPLOAD_FILE:
+                        args[p.index] = ctx.req.file
+                        break
+                    case Parametrable.CUSTOM:
+                        args[p.index] = p.callable?.(ctx) ?? null;
+                        break;
+                }
             }
-        }
 
-        if (!(routeMeta.propertyKey in instance))
-            throw new Throwable(`${routeMeta.propertyKey} does not exist`)
+            if (!(routeMeta.propertyKey in instance))
+                throw new Throwable(`${routeMeta.propertyKey} does not exist`)
+
+            /**
+             * Middlewares running order
+             */
+            const middlewares: MiddlewareCallable[] = [
+                ...controllerMeta.middlewares['@'] || [],
+                ...controllerMeta.middlewares[routeMeta.propertyKey] || []
+            ]
+            if (middlewares.length > 0) await middlewareCompose(middlewares)(ctx)
+
+            /**
+             * Vérification des arguments
+             */
+            for (const input of args) {
+                /** DTO validation */
+                if (input instanceof DataTransferObject) {
+                    const errors = await input.validation(false);
+                    if (errors && errors.length) {
+                        const stack = Object.values(errors[0].constraints || {})
+                        throw new Throwable(stack.join(';'), 500)
+                    }
+                }
+            }
+
+            let responses = instance[routeMeta.propertyKey](...args)
+            if (responses instanceof Promise) responses = await responses
+
+            return responses;
+        } catch (err: any) {
 
-        const middlewares: MiddlewareCallable[] = [
-            ...controllerMeta.middlewares['@'] || [],
-            ...controllerMeta.middlewares[routeMeta.propertyKey] || []
-        ]
+            if (!(err instanceof ThrowableResponse)) {
+                Logger.error(`Failed to execute ${handlerName} handler`, err.message ?? err);
+                ctx.reply.status(500)
+            }
 
-        if (middlewares.length > 0) await middlewareCompose(middlewares)(ctx)
+            if (err instanceof ThrowableResponse) {
+                ctx.reply.status(err.statusCode || 201)
+            }
 
-        return instance[routeMeta.propertyKey](...args)
+            if (err instanceof HttpException || err instanceof ThrowableResponse)
+                return err.render()
+
+            return {
+                statusCode: 500,
+                error: true,
+                message: err.message ?? err,
+                data: null,
+                stack: isDevelopment
+                    ? (typeof err.stack === 'string' ? err.stack.split('\n')
+                        : [String(err.stack || err.toString() || err.message || err.name || 'Unknown error')])
+                        .map((l: any) => typeof l === 'string' ? l.trim() : String(l)) : undefined
+                ,
+            }
+        }
     }
 }

package/source/core/thread.ts

@@ -13,17 +13,18 @@ import {until} from "./process.util";
 import {ApplicationInterface} from "@/types/application";
 import {Runtime} from "@/sdk/runtime";
 import {LBadge, Logger} from "@protorians/logger";
-import {Throwable} from "@/sdk/throwable";
 import {ControllerBuilder} from "@/core/controller";
 import {bodyParserPlugin} from "@/sdk/plugins/body-parser.plugin";
+import {Injection} from "@/core/injection/injection";
+import {Throwable} from "@/sdk/exceptions";
 
 
 export class RaitonThread implements ThreadInterface {
 
     protected static instance: RaitonThread | null = null;
 
-    public static get current(): RaitonThread {
-        if (!RaitonThread.instance) throw new Throwable('Thread not initialized')
+    public static get current(): RaitonThread | null {
+        // if (!RaitonThread.instance) throw new Throwable('Thread not initialized')
         return RaitonThread.instance;
     }
 
@@ -45,7 +46,8 @@ export class RaitonThread implements ThreadInterface {
         process.send?.(EventMessageEnum.RESTART)
     }
 
-    public stop(): void {
+    public async stop(): Promise<void> {
+        await Injection.shutdown();
         process.exit(0)
     }
 
@@ -73,15 +75,23 @@ export class RaitonThread implements ThreadInterface {
         if (!this.runtime)
             throw new Throwable('Runtime not defined');
 
+        process.on('SIGINT', async () => {
+            await this.stop();
+        });
+
+        process.on('SIGTERM', async () => {
+            await this.stop();
+        });
+
         const port = this.application.config.port || 5712;
+        const hostname = this.application.config.hostname || 'localhost';
 
         this.runtimeServer = this.runtime.createServer(this.application.handle.bind(this.application))
 
-        await this.runtimeServer.listen(port)
-        if (this.builder.out)
-            await ControllerBuilder.scan(this.builder.out)
+        await this.runtimeServer.listen(port, hostname)
+        if (this.builder.source) await ControllerBuilder.scan(this.builder.source)
 
-        Logger.log(LBadge.info('Server Started'), `http://localhost:${port}`)
+        Logger.log(LBadge.info('Server Started'), `http://${hostname}:${port}`)
         return this;
     }
 }

package/source/sdk/artifacts.ts

@@ -1,55 +1,79 @@
-import path from "node:path";
-import fs from "fs";
+import {Injection} from "@/core/injection";
 import {Logger} from "@protorians/logger";
-import {IFileStatInfo} from "@/types";
+import type {IConstructor} from "@/types";
 import {Raiton} from "@/core/raiton";
-import {RaitonDirectories} from "@/core";
+import {isArtifact, isControllerArtifact} from "@/sdk/utilities";
 
-export class ArtifactFactory {
-    protected static readonly stack: Map<string, Set<IFileStatInfo>> = new Map();
+export class Artifacts {
 
-    static getSource(key: string) {
-        return path.join(
-            RaitonDirectories.artifacts(Raiton.thread.builder.workdir),
-            `${key}.json`
-        );
-    }
+    static readonly types: Set<string> = new Set();
 
-    static add(key: string, file: IFileStatInfo) {
-        if (!this.stack.has(key)) this.stack.set(key, new Set());
-        this.stack.get(key)?.add(file);
-    }
+    static readonly defaultTypes = [
+        'service',
+        'provider',
+        'type',
+        'repository',
+        'database',
+        'db',
+        'util',
+        'utility',
+        'source',
+        'controller',
+        'middleware',
+        'hook',
+        'event',
+        'listener',
+        'validator',
+        'strategy',
+        'strategy-provider',
+        'strategy-type',
+    ]
 
-    static get(key: string): Set<IFileStatInfo> | undefined {
-        return this.stack.get(key);
+    static register(type: string) {
+        this.types.add(type)
+        return this
     }
 
-    static has(key: string): boolean {
-        return this.stack.has(key);
+    static registerMany(...types: string[]) {
+        for (const type of types) this.register(type)
+        return this;
     }
 
-    static load(key: string) {
-        const outputFile = this.getSource(key)
-        if (!fs.existsSync(outputFile)) return this;
-        const content = fs.readFileSync(outputFile, "utf-8");
-        const files = JSON.parse(content) as IFileStatInfo[];
-        files.forEach(file => this.add(key, file));
-        return this;
+    static is(filename: string) {
+        return [...this.types]
+            .map(type => isArtifact(filename, type))
+            .some(Boolean)
     }
 
-    static save(key: string) {
-        try {
-            const set = this.stack.get(key);
-            if (!set) return;
-            const content = JSON.stringify([...set.values()]);
-            const outputFile = this.getSource(key)
-            const dir = path.dirname(outputFile);
-            if (!fs.existsSync(dir)) fs.mkdirSync(dir, {recursive: true})
-            fs.writeFileSync(outputFile, content, "utf-8");
-            return true
-        } catch (e) {
-            Logger.error(`Failed to save artifacts for key ${key}:`, e);
-            return false;
+    static reload(modulo: any, filename?: string) {
+
+        if (Raiton.thread?.builder.options.development === false)
+            return Logger.warn(
+                'Artifact reload is only available in development mode'
+            )
+
+        for (const mod of Object.values(modulo)) {
+            const name = (mod && typeof mod === 'object' && 'name' in mod) ? mod.name : (
+                typeof mod === 'function' ? mod.name ?? mod.constructor.name : undefined
+            );
+
+            if (typeof name === 'string' && Injection.has(name)) {
+                if (filename) Injection.registerArtifactPath(name, filename);
+                Injection.updateConstruct(name, mod as IConstructor)
+
+                const dependents = Injection.getDependents(name);
+                for (const dependent of dependents) {
+                    const dependentPath = Injection.getArtifactPath(dependent);
+                    if (dependentPath && isControllerArtifact(dependentPath)) {
+                        Raiton.signals.dispatch('hmr:controller', {
+                            filename: dependentPath,
+                            timestamp: Date.now(),
+                            version: 1
+                        })
+                    }
+                }
+            }
         }
+
     }
-}
+}

package/source/sdk/constants/decorators.constant.ts

@@ -1,5 +1,6 @@
 export const METADATA_KEYS = {
     CONTROLLERS: Symbol('controller:meta'),
+    ROUTE_PARAMETERS: Symbol('route:meta'),
     GRAFTS: Symbol('graft:meta'),
     CONTAINER: Symbol('container:meta'),
     INJECT_PARAMETERS: Symbol('inject:parameters'),

package/source/sdk/data-transfer-object.ts

@@ -1,7 +1,15 @@
-import {DynamicParameter} from "@protorians/parameters";
-import {IDataTransferObject} from "@/types";
+import {validate, validateOrReject, ValidationError} from "class-validator";
+import {Logger} from "@protorians/logger";
 
 
-export class DataTransferObject<T extends IDataTransferObject<T>> extends DynamicParameter<T> {
+export class DataTransferObject {
+    constructor(initial: Record<string, any>) {
+        for (const [key, value] of Object.entries(initial)) {
+            if (typeof value !== 'function') this[key as keyof typeof this] = value;
+        }
+    }
 
+    async validation(strict: boolean = true): Promise<void | ValidationError[]> {
+        return await ((strict ? validateOrReject : validate)(this))
+    }
 }

package/source/sdk/decorators/parametrable.ts

@@ -1,24 +1,28 @@
+import "reflect-metadata";
 import type {Context, ParamMetaInterface} from "@/types";
-import {getControllerMetadata} from "@/core";
-import {Parametrable} from "@/sdk";
-import {Logger} from "@protorians/logger";
+import {METADATA_KEYS, Parametrable} from "@/sdk";
 
-function createParametrable(type: ParamMetaInterface['type'], callable?: (context: Context) => any) {
+function createRouteParametrableDecorator(type: ParamMetaInterface['type'], callable?: (context: Context) => any) {
     return (key?: string) => {
         return (target: any, propertyKey: string, index: number) => {
-            const meta = getControllerMetadata(target)
-            if (!meta.params[propertyKey])
-                meta.params[propertyKey] = []
-            meta.params[propertyKey].push({index, type, key, callable})
+            const params = Reflect.getMetadata(METADATA_KEYS.ROUTE_PARAMETERS, target.constructor) || {}
+            const metatypes = Reflect.getMetadata("design:paramtypes", target, propertyKey);
+            const metatype = metatypes ? metatypes[index] : undefined;
+
+            if (!params[propertyKey]) {
+                params[propertyKey] = []
+            }
+            params[propertyKey].push({index, type, key, callable, metatype})
+            Reflect.defineMetadata(METADATA_KEYS.ROUTE_PARAMETERS, params, target.constructor)
         }
     }
 }
 
-export const Query = createParametrable(Parametrable.QUERY)
-export const Param = createParametrable(Parametrable.PARAM)
-export const Body = createParametrable(Parametrable.BODY)
-export const UploadedFile = createParametrable(Parametrable.UPLOAD_FILE)
-export const Headers = createParametrable(Parametrable.HEADER)
-export const Req = createParametrable(Parametrable.REQ)
-export const Reply = createParametrable(Parametrable.REPLY)
+export const Query = createRouteParametrableDecorator(Parametrable.QUERY)
+export const Param = createRouteParametrableDecorator(Parametrable.PARAM)
+export const Body = createRouteParametrableDecorator(Parametrable.BODY)
+export const UploadedFile = createRouteParametrableDecorator(Parametrable.UPLOAD_FILE)
+export const Headers = createRouteParametrableDecorator(Parametrable.HEADER)
+export const Req = createRouteParametrableDecorator(Parametrable.REQ)
+export const Reply = createRouteParametrableDecorator(Parametrable.REPLY)
 

package/source/sdk/decorators/routable.decorator.ts

@@ -1,7 +1,6 @@
 import {getControllerMetadata} from "@/core";
 import {HttpMethod} from "@/sdk";
 import {ControllerMetaInterface, RouteDecoratorCallable, RouteMetaInterface} from "@/types";
-import path from "node:path";
 
 
 function stabilizeRoute(meta: ControllerMetaInterface, {path, method, propertyKey}: Partial<RouteMetaInterface>) {
@@ -10,7 +9,6 @@ function stabilizeRoute(meta: ControllerMetaInterface, {path, method, propertyKe
         method,
         path,
         propertyKey,
-        params: (propertyKey ? meta.params[propertyKey] : []) || [],
     } as RouteMetaInterface;
 }
 
@@ -22,7 +20,6 @@ export function createRoutableDecorator(method: HttpMethod) {
                 method,
                 path,
                 propertyKey,
-                params: meta.params[propertyKey] || [],
             });
             meta.routes.push(route)
         }

package/source/sdk/encryption.ts

@@ -1,7 +1,6 @@
-
 import crypto from "node:crypto";
 import argon2, {Options} from "argon2";
-import {HashAlgoEnum} from "./enums";
+import {HashAlgoEnum, PasswordAlgoEnum} from "./enums";
 import bcrypt from "bcrypt";
 import {IDerivationOptions, IEncryptionResult, IScryptOptions} from "@/types";
 
@@ -10,14 +9,14 @@ export class Encryption {
         return HashAlgoEnum;
     }
 
-    static randomAlgo() {
-        return Object.values(this.algos)[
+    static randomAlgo(algo?: PasswordAlgoEnum[] | HashAlgoEnum[]) {
+        return (algo ?? Object.values(this.algos))[
             Math.floor(Math.random() * Object.values(this.algos).length)
             ];
     }
 
-    constructor(public readonly algo: HashAlgoEnum) {
-        if (!Object.values(HashAlgoEnum).includes(this.algo)) {
+    constructor(public readonly algo: HashAlgoEnum | PasswordAlgoEnum) {
+        if (![...Object.values(HashAlgoEnum), ...Object.values(PasswordAlgoEnum)].includes(this.algo)) {
             throw new Error(`Invalid hash algorithm: ${this.algo}`);
         }
     }

package/source/sdk/enums/encrypted.enum.ts

@@ -10,4 +10,14 @@ export enum HashAlgoEnum {
     BLAKE2B = 'BLAKE2B',
     SHA3_256 = 'SHA3_256',
     SHA3_512 = 'SHA3_512',
+}
+
+export enum CipherAlgoEnum {
+    AES_256_CBC = 'AES-256-CBC',
+}
+
+export enum PasswordAlgoEnum {
+    ARGON2ID = 'argon2id',
+    BCRYPT = 'BCRYPT',
+    SCRYPT = 'SCRYPT',
 }

package/source/sdk/enums/http-status.enum.ts

@@ -0,0 +1,73 @@
+export enum HttpStatus {
+
+  CONTINUE = 100,
+  SWITCHING_PROTOCOLS = 101,
+  PROCESSING = 102,
+  EARLY_HINTS = 103,
+
+
+  OK = 200,
+  CREATED = 201,
+  ACCEPTED = 202,
+  NON_AUTHORITATIVE_INFORMATION = 203,
+  NO_CONTENT = 204,
+  RESET_CONTENT = 205,
+  PARTIAL_CONTENT = 206,
+  MULTI_STATUS = 207,
+  ALREADY_REPORTED = 208,
+  IM_USED = 226,
+
+
+  MULTIPLE_CHOICES = 300,
+  MOVED_PERMANENTLY = 301,
+  FOUND = 302,
+  SEE_OTHER = 303,
+  NOT_MODIFIED = 304,
+  USE_PROXY = 305,
+  TEMPORARY_REDIRECT = 307,
+  PERMANENT_REDIRECT = 308,
+
+
+  BAD_REQUEST = 400,
+  UNAUTHORIZED = 401,
+  PAYMENT_REQUIRED = 402,
+  FORBIDDEN = 403,
+  NOT_FOUND = 404,
+  METHOD_NOT_ALLOWED = 405,
+  NOT_ACCEPTABLE = 406,
+  PROXY_AUTHENTICATION_REQUIRED = 407,
+  REQUEST_TIMEOUT = 408,
+  CONFLICT = 409,
+  GONE = 410,
+  LENGTH_REQUIRED = 411,
+  PRECONDITION_FAILED = 412,
+  PAYLOAD_TOO_LARGE = 413,
+  URI_TOO_LONG = 414,
+  UNSUPPORTED_MEDIA_TYPE = 415,
+  RANGE_NOT_SATISFIABLE = 416,
+  EXPECTATION_FAILED = 417,
+  IM_A_TEAPOT = 418,
+  MISDIRECTED_REQUEST = 421,
+  UNPROCESSABLE_ENTITY = 422,
+  LOCKED = 423,
+  FAILED_DEPENDENCY = 424,
+  TOO_EARLY = 425,
+  UPGRADE_REQUIRED = 426,
+  PRECONDITION_REQUIRED = 428,
+  TOO_MANY_REQUESTS = 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+  UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+
+
+  INTERNAL_SERVER_ERROR = 500,
+  NOT_IMPLEMENTED = 501,
+  BAD_GATEWAY = 502,
+  SERVICE_UNAVAILABLE = 503,
+  GATEWAY_TIMEOUT = 504,
+  HTTP_VERSION_NOT_SUPPORTED = 505,
+  VARIANT_ALSO_NEGOTIATES = 506,
+  INSUFFICIENT_STORAGE = 507,
+  LOOP_DETECTED = 508,
+  NOT_EXTENDED = 510,
+  NETWORK_AUTHENTICATION_REQUIRED = 511,
+}

package/source/sdk/enums/index.ts

@@ -1,5 +1,6 @@
-export * from "./http.enum"
+export * from "./http-method.enum"
 export * from "./http-parameters.enum"
+export * from "./http-status.enum"
 export * from "./encrypted.enum"
 export * from "./event.message.enum"
 export * from "./timestamp.enum"

package/source/sdk/exceptions/http-exception.ts

@@ -0,0 +1,28 @@
+import {HttpStatus} from "@/sdk/enums/http-status.enum";
+import {Raiton} from "@/core";
+import {HttpResponseBaseInterface} from "@/types";
+
+export class HttpException extends Error {
+
+    constructor(
+        error: string | HttpResponseBaseInterface | Error,
+        public statusCode: HttpStatus = HttpStatus.INTERNAL_SERVER_ERROR,
+    ) {
+        super(typeof error === 'string' ? error : error.message);
+    }
+
+    render() {
+        return {
+            message: this.message,
+            statusCode: this.statusCode,
+            error: true,
+            stack: Raiton.thread?.builder?.options?.development
+                ? this.stack?.split('\n').map(e => e.trim())
+                : undefined
+        }
+    }
+
+    toString() {
+        return `HttpException: ${this.message} with status code ${this.statusCode}`
+    }
+}

package/source/sdk/exceptions/index.ts

@@ -0,0 +1,2 @@
+export * from "./http-exception"
+export * from "./throwable"

package/source/sdk/index.ts

@@ -1,6 +1,13 @@
 export * from "./enums/index"
 export * from "./constants/index"
 export * from "./decorators/index"
+export * from "./responses/index"
 export * from "./plugins/index"
 export * from "./utilities/index"
 export * from "./runtime/index"
+export * from "./controllers"
+export * from "./data-transfer-object"
+export * from "./encryption"
+export * from "./parameter-bag"
+export * from "./repositories"
+export * from "./services"