raiton 1.0.0-alpha.1 → 1.0.0-alpha.3

package/deno.json

@@ -0,0 +1,9 @@
+{
+  "imports": {
+    "@": "./source",
+    "@/": "./source/"
+  },
+  "tasks": {
+    "start": "deno run --allow-all source/bin/bootstrapper.ts"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "raiton",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.3",
   "private": false,
   "type": "module",
   "description": "Protorians Raiton Development Kit",
@@ -16,7 +16,9 @@
     "development",
     "kit",
     "typescript",
+    "node",
     "bun",
+    "deno",
     "backend"
   ],
   "author": "Y. Yannick GOBOU",
@@ -52,6 +54,7 @@
     "@types/node": "^25.0.3",
     "argon2": "^0.44.0",
     "bcrypt": "^6.0.0",
+    "class-validator": "^0.14.3",
     "commander": "^14.0.2",
     "dotenv": "^17.2.3",
     "reflect-metadata": "^0.2.2"

package/source/bin/cli-tools.ts

@@ -1,22 +1,30 @@
 import {spawn} from 'node:child_process';
+import {isBunUsed, isDenoUsed} from "@/bin/constants";
 
-const isBunUsed = typeof Bun !== "undefined";
 
 export class CliTools {
     static get cwd() {
-        return `${process.cwd()}`;
+        return `${isDenoUsed ? (globalThis as any).Deno.cwd() : process.cwd()}`;
     }
 
     static set cwd(value: string) {
-        process.chdir(value)
+        if (isDenoUsed) {
+            (globalThis as any).Deno.chdir(value);
+        } else {
+            process.chdir(value);
+        }
     }
 
     static get argv() {
-        return isBunUsed ? Bun.argv : process.argv;
+        if (isBunUsed) return (globalThis as any).Bun.argv;
+        if (isDenoUsed) return (globalThis as any).Deno.args;
+        return process.argv;
     }
 
     static get process() {
-        return isBunUsed ? Bun : process;
+        if (isBunUsed) return (globalThis as any).Bun;
+        if (isDenoUsed) return (globalThis as any).Deno;
+        return process;
     }
 
     static spawn(command: string | string[], args: string[] = [], options?: Record<string, any>) {
@@ -25,19 +33,36 @@ export class CliTools {
                 ...(typeof command == 'string' ? [command] : (Array.isArray(command) ? command : [])),
                 ...args
             ];
-            // If the command is a .ts file, prepend bun
             if (typeof command === 'string' && command.endsWith('.ts')) {
                 cmdArray.unshift('bun');
             }
             return Bun.spawn(cmdArray, options);
         }
 
+        if (isDenoUsed) {
+            const cmd = typeof command == 'string' ? command : command[0];
+            const cmdArgs = typeof command == 'string' ? args : [...command.slice(1), ...args];
+
+            if (cmd.endsWith('.ts')) {
+                return new Deno.Command('deno', {
+                    args: ['run', '-A', cmd, ...cmdArgs],
+                    ...options
+                }).spawn();
+            }
+
+            return new Deno.Command(cmd, {
+                args: cmdArgs,
+                ...options
+            }).spawn();
+        }
+
         const cmd = typeof command == 'string' ? command : command[0];
-        // If the command is a .ts file, prepend bun (or npx tsx/ts-node if we wanted to be Node generic, but here we favor Bun)
+        const cmdArgs = typeof command == 'string' ? args : [...command.slice(1), ...args];
+
         if (cmd.endsWith('.ts')) {
-            return spawn('bun', [cmd, ...args], options);
+            return spawn('node', ['--loader', 'ts-node/register', cmd, ...cmdArgs], options);
         }
 
-        return spawn(cmd, args, options);
+        return spawn(cmd, cmdArgs, options);
     }
 }

package/source/bin/constants.ts

@@ -0,0 +1,5 @@
+export const isBunUsed = typeof (globalThis as any).Bun !== "undefined";
+export const isDenoUsed = typeof (globalThis as any).Deno !== "undefined";
+
+declare const Bun: any;
+declare const Deno: any;

package/source/bin/index.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import "reflect-metadata"
-import bootstrapper from "./bootstrapper";
 import CLI from "./cli";
+import bootstrapper from "./bootstrapper";
 
 bootstrapper(CLI)

package/source/commands/develop.command.ts

@@ -1,5 +1,5 @@
 import {Raiton, RaitonCommand} from "@/core";
-import {ChildProcess} from 'node:child_process';
+import {ChildProcess, ChildProcessWithoutNullStreams} from 'node:child_process';
 import {Logger} from "@protorians/logger";
 import {EventMessageEnum} from "@/sdk";
 import {CliTools} from "@/bin/cli-tools";
@@ -9,7 +9,7 @@ export default class DevelopCommand extends RaitonCommand {
     public readonly name: string = 'develop';
     public readonly description: string = 'Run the application in development mode';
 
-    private child: Bun.Subprocess<"ignore", "pipe", "inherit"> | ChildProcess | null = null;
+    private child: Bun.Subprocess<"ignore", "pipe", "inherit"> | ChildProcess | Deno.ChildProcess | ChildProcessWithoutNullStreams | null = null;
 
     public register(): void {
         this.cli
@@ -42,6 +42,6 @@ export default class DevelopCommand extends RaitonCommand {
                 if (msg === EventMessageEnum.RESTART) this.restart()
             });
 
-        Logger.log('PID', this.child.pid)
+        Logger.log('PID', this.child?.pid)
     }
 }

package/source/commands/start.command.ts

@@ -8,7 +8,7 @@ export default class StartCommand extends RaitonCommand {
     public readonly name: string = 'start';
     public readonly description: string = 'Run the application in production mode';
 
-    private child:  Bun.Subprocess<"ignore", "pipe", "inherit"> | ChildProcess | null = null;
+    private child:  Bun.Subprocess<"ignore", "pipe", "inherit"> | ChildProcess | Deno.ChildProcess | null = null;
 
     public register(): void {
         this.cli

package/source/core/application.ts

@@ -4,6 +4,8 @@ import {ApplicationConfig, ApplicationInterface} from "@/types/application";
 import {HttpMethod} from "@/sdk";
 import {RouteHandler} from "@/types";
 import {Logger} from "@protorians/logger";
+import {RaitonConfig} from "@/core/config";
+import {Artifacts} from "@/sdk/artifacts";
 
 export class Application implements ApplicationInterface {
     private root: PluginScope
@@ -12,6 +14,18 @@ export class Application implements ApplicationInterface {
         readonly config: ApplicationConfig
     ) {
         this.root = new PluginScope()
+        if (this.config.workdir) {
+            process.chdir(this.config.workdir)
+        }
+        this.initialize()
+    }
+
+    protected initialize(): this {
+        const artifacts = RaitonConfig.get('artifacts')
+        const artifactTypes = [...artifacts?.types || [], ...Artifacts.defaultTypes]
+
+        Artifacts.registerMany(...artifactTypes)
+        return this;
     }
 
     public get hostname(): string {
@@ -26,15 +40,15 @@ export class Application implements ApplicationInterface {
         }`
     }
 
-    // public setOption<K extends keyof ApplicationConfig>(key: K, value: ApplicationConfig[K]): this {
-    //     this.config[key] = value;
-    //     return this;
-    // }
-    //
-    // public setOptions(options: ApplicationConfig): this {
-    //     Object.assign(this.config, options);
-    //     return this;
-    // }
+    public setOption<K extends keyof ApplicationConfig>(key: K, value: ApplicationConfig[K]): this {
+        this.config[key] = value;
+        return this;
+    }
+
+    public setOptions(options: ApplicationConfig): this {
+        Object.assign(this.config, options);
+        return this;
+    }
 
     register(plugin: any): this {
         this.root.register(plugin)
@@ -47,7 +61,9 @@ export class Application implements ApplicationInterface {
     }
 
     route(method: HttpMethod, path: string, handler: RouteHandler, version?: string): this {
-        this.root.route(method, path, handler, version)
+        const prefix = this.config.prefix ?? ''
+        const fullPath = `${prefix}${path}`.replace(/\/+/g, '/') || '/'
+        this.root.route(method, fullPath, handler, version)
         return this
     }
 
@@ -86,27 +102,59 @@ export class Application implements ApplicationInterface {
     async handle(req: any, reply: any): Promise<any> {
         const ctx = new RequestContext(req, reply)
 
+        if (this.config.verbose) {
+            Logger.info(
+                `Incoming request: ${req.method} ${req.url}`
+            )
+        }
+
         await this.root.hooks.run('onRequest', ctx)
 
+        const url = new URL(req.url, this.hostname)
+        let pathname = url.pathname
+
+        if (this.config.pathname && this.config.pathname !== '/') {
+            const appPathname = this.config.pathname.endsWith('/') ? this.config.pathname : `${this.config.pathname}/`
+            if (pathname.startsWith(appPathname)) {
+                pathname = pathname.substring(appPathname.length - 1) || '/'
+            } else if (pathname === this.config.pathname) {
+                pathname = '/'
+            } else {
+                // Requête hors du pathname de l'application
+                if (this.config.verbose) {
+                    Logger.warn(`Request out of application pathname: ${pathname} (expected prefix: ${this.config.pathname})`)
+                }
+                reply.status(404)
+                return reply.send({error: false, statusCode: 404})
+            }
+        }
+
         const route = this.root.router.match(
             req.method,
-            new URL(req.url, this.hostname).pathname
+            pathname
         )
 
         if (!route) {
+            if (this.config.verbose) {
+                Logger.warn(`Route not found: ${req.method} ${pathname}`)
+            }
             reply.status(404)
             return reply.send({error: false, statusCode: 404})
         }
 
         const pipeline = this.root.middleware.clone()
         pipeline.use(async ({context}) => {
-            (context as any).params = route.parameters;
-
-            const responses = await route.handler(context)
-
-            // Logger.debug('Responses', responses)
-            // request.reply.header('Content-Type', 'application/json')
-            context.reply.send(responses)
+            try {
+                (context as any).params = route.parameters;
+                let responses = await route.handler(context)
+
+                context.reply.send(responses)
+            } catch (e: any) {
+                Logger.error('Failed to handle request', e.message ?? e)
+                if (this.config.develop) {
+                    console.error(e)
+                }
+            }
         })
 
         await pipeline.run(ctx)

package/source/core/builder.ts

@@ -2,18 +2,16 @@ import {RaitonConfig} from "./config";
 import path from "node:path";
 import {RaitonDirectories} from "./directories";
 import fs, {WatchEventType} from "node:fs";
-import type {
-    BuilderConfig,
-    BuilderInterface,
-    HmrInterface,
-} from "@/types";
+import type {BuilderConfig, BuilderInterface,} from "@/types";
 import {RaitonThread} from "./thread";
 import {Raiton} from "@/core/raiton";
-import {isControllerFile} from "@/sdk";
-import {Hmr} from "@/core/hmr";
-import {Throwable} from "@/sdk/throwable";
+import {isControllerArtifact, isServiceArtifact} from "@/sdk";
 import {ControllerBuilder} from "@/core/controller";
 import {watch} from "fs";
+import {LBadge, Logger} from "@protorians/logger";
+import {Throwable} from "@/sdk/exceptions";
+import {Injection} from "@/core/injection";
+import {Artifacts} from "@/sdk/artifacts";
 
 export class RaitonBuilder implements BuilderInterface {
     protected _source: string | null = null;
@@ -21,8 +19,6 @@ export class RaitonBuilder implements BuilderInterface {
     protected _bootstrapper: string | null = null;
     protected _bootstrapperFile: string | null = null;
     protected _compiledVersionNumber: number = 1;
-
-    public readonly hmr: HmrInterface = new Hmr()
     protected _watcher?: fs.FSWatcher;
 
 
@@ -53,7 +49,7 @@ export class RaitonBuilder implements BuilderInterface {
         return this._watcher;
     }
 
-    protected parse(filename: string, type?: WatchEventType) {
+    protected async parse(filename: string, type?: WatchEventType) {
         if (!fs.existsSync(filename)) return;
 
         const payload = {
@@ -63,20 +59,28 @@ export class RaitonBuilder implements BuilderInterface {
             type
         }
 
-        if (isControllerFile(filename)) {
+        Logger.log(LBadge.info('HMR'), 'activated');
+
+        if (isControllerArtifact(filename)) {
             Raiton.signals.dispatch('hmr:controller', payload)
         }
 
+        if (Artifacts.is(filename))
+            Artifacts.reload(
+                await import(`${filename}?v=${payload.version || 1}&t=${payload.timestamp || Date.now()}`),
+                filename
+            )
+
         return payload;
     }
 
-    protected parsing() {
+    protected async parsing(): Promise<this> {
         if (typeof this._source != 'string') throw new Throwable('Application source not found');
 
-        for (const filename of [...fs.readdirSync(this._source, {recursive: true})]) {
-            this.parse(path.join(this._source, String(filename)));
-        }
+        for (const filename of [...fs.readdirSync(this._source, {recursive: true})])
+            await this.parse(path.join(this._source, String(filename)));
 
+        return this;
     }
 
     protected watching(): this {
@@ -114,11 +118,12 @@ export class RaitonBuilder implements BuilderInterface {
         await this.initialize()
         Raiton.signals.listen(
             'hmr:controller',
-            async ({filename, version, timestamp}) =>
+            async ({filename, version, timestamp}) => {
                 await ControllerBuilder.build({filename, version, timestamp})
+            }
         )
-        this.parsing()
-        this.watching()
+        // this.parsing();
+        this.watching();
         return this;
     }
 
@@ -131,8 +136,9 @@ export class RaitonBuilder implements BuilderInterface {
         if (!('default' in bootstrapper))
             throw new Error('Bootstrapper not supported! Please export to "default"')
 
-        Raiton.thread = new RaitonThread(this, {})
-        return bootstrapper.default(Raiton.thread)
+        const thread = new RaitonThread(this, {})
+        Raiton.thread = thread;
+        return await bootstrapper.default(thread);
     }
 
 }

package/source/core/controller/builder.ts

@@ -3,7 +3,8 @@ import {BuilderHMRDeclaration} from "@/types";
 import {LBadge, Logger} from "@protorians/logger";
 import {compileController} from "@/core/controller/compiler";
 import {RaitonThread} from "@/core/thread";
-import {isControllerFile} from "@/sdk";
+import {Injection} from "@/core/injection";
+import {isControllerArtifact} from "@/sdk";
 import path from "node:path";
 
 export class ControllerBuilder {
@@ -13,24 +14,26 @@ export class ControllerBuilder {
             .map(file => file.toString());
         const output: any[] = []
 
-        for (const file of files)
+        for (const file of files) {
             output.push(await this.build<any>({filename: path.join(workdir, file), version: 1, timestamp: Date.now()}))
+        }
 
         return output.filter(f => typeof f !== 'undefined');
     }
 
     static async build<T>({filename, version, timestamp}: BuilderHMRDeclaration): Promise<T | undefined> {
-        if (!isControllerFile(filename))
+        if (!isControllerArtifact(filename))
             return undefined;
 
         const imported = await import(`${filename}?v=${version || 1}&t=${timestamp || Date.now()}`)
         const controller = imported.default || imported || undefined;
 
         if (!controller) return undefined;
-        if(!RaitonThread.current.application) return undefined;
+        if (!RaitonThread.current?.application) return undefined;
 
         const compilated = compileController(controller, RaitonThread.current.application);
-        Logger.log(LBadge.info('Controller'), controller.name, 'compilated');
+        const name = controller.name || (typeof controller === 'function' ? controller.name : undefined);
+        if (name) Injection.registerArtifactPath(name, filename);
 
         return compilated;
     }

package/source/core/controller/metadata.ts

@@ -5,7 +5,7 @@ import "reflect-metadata";
 export function getControllerMetadata(target: any): ControllerMetaInterface {
     let metadata = Reflect.getMetadata(METADATA_KEYS.CONTROLLERS, target);
     if (!metadata) {
-        metadata = {routes: [], params: {}, middlewares: {}};
+        metadata = {routes: [], middlewares: {}};
         Reflect.defineMetadata(METADATA_KEYS.CONTROLLERS, metadata, target);
     }
 

package/source/core/directories.ts

@@ -25,6 +25,6 @@ export class RaitonDirectories {
     }
 
     public static app(): string {
-        return path.join(Raiton.thread.builder.workdir, RaitonConfig.get('rootDir') || './');
+        return path.join(Raiton.thread?.builder.workdir || '', RaitonConfig.get('rootDir') || './');
     }
 }

package/source/core/index.ts

@@ -1,7 +1,6 @@
 export * from "./config"
 export * from "./process.util"
 export * from "./builder"
-export * from "./hmr"
 export * from "./bytes.util"
 export * from "./commands"
 export * from "./command"

package/source/core/injection/injection.ts

@@ -1,16 +1,19 @@
 import "reflect-metadata";
 import type {IConstructor, ContainerDefinitionInterface} from "@/types";
-import {Throwable} from "@/sdk/throwable";
 import {LifetimeEnum, TextUtility} from "@protorians/core";
 import {Logger} from "@protorians/logger";
 import {METADATA_KEYS} from "@/sdk/constants";
-import camelCase = TextUtility.camelCase;
+import {Throwable} from "@/sdk/exceptions";
+
+const camelCase = TextUtility.camelCase;
 
 export class Injection {
 
     protected static _classes: Map<string, ContainerDefinitionInterface> = new Map();
     protected static _instances: Map<string, Map<any, any>> = new Map();
     protected static _resolutionStack: string[] = [];
+    protected static _dependents: Map<string, Set<string>> = new Map();
+    protected static _artifactPaths: Map<string, string> = new Map();
 
     static get classes(): Map<string, ContainerDefinitionInterface> {
         return this._classes;
@@ -29,6 +32,8 @@ export class Injection {
     static clear(): void {
         this._classes.clear();
         this._instances.clear();
+        this._dependents.clear();
+        this._artifactPaths.clear();
     }
 
     static normalizeName(name: string): string {
@@ -49,6 +54,25 @@ export class Injection {
         return this;
     }
 
+    static updateConstruct(name: string, construct: IConstructor): typeof this {
+        const name_ = this.normalizeName(name);
+        this._classes.set(name_, {...this._classes.get(this.normalizeName(name))!, construct});
+        return this;
+    }
+
+    static getDependents(name: string): string[] {
+        return Array.from(this._dependents.get(this.normalizeName(name)) || []);
+    }
+
+    static registerArtifactPath(name: string, path: string): typeof this {
+        this._artifactPaths.set(this.normalizeName(name), path);
+        return this;
+    }
+
+    static getArtifactPath(name: string): string | undefined {
+        return this._artifactPaths.get(this.normalizeName(name));
+    }
+
     static resolveArguments(definition: ContainerDefinitionInterface, scope?: any): any[] {
         try {
             const parameters = Reflect.getMetadata(METADATA_KEYS.INJECT_PARAMETERS, definition.construct) || [];
@@ -65,19 +89,24 @@ export class Injection {
                 if (param && param !== true) {
                     const token = typeof param === 'function' ? (param.name || param) : param;
                     if (typeof token === 'string') {
+                        this.addDependent(token, definition.name);
                         args.push(this.get(token, effectiveScope));
                         continue;
                     }
                     if (typeof param === 'function') {
                         const metadata: ContainerDefinitionInterface = Reflect.getMetadata(METADATA_KEYS.CONTAINER, param);
-                        args.push(this.get(metadata?.name || param.name, effectiveScope));
+                        const token = metadata?.name || param.name;
+                        this.addDependent(token, definition.name);
+                        args.push(this.get(token, effectiveScope));
                         continue;
                     }
                 }
 
                 if (designParam && typeof designParam === 'function' && designParam.name) {
                     const metadata: ContainerDefinitionInterface = Reflect.getMetadata(METADATA_KEYS.CONTAINER, designParam);
-                    args.push(this.get(metadata?.name || designParam.name, effectiveScope));
+                    const token = metadata?.name || designParam.name;
+                    this.addDependent(token, definition.name);
+                    args.push(this.get(token, effectiveScope));
                     continue;
                 }
 
@@ -90,6 +119,14 @@ export class Injection {
         }
     }
 
+    protected static addDependent(dependencyName: string, dependentName: string) {
+        const dep = this.normalizeName(dependencyName);
+        if (!this._dependents.has(dep)) {
+            this._dependents.set(dep, new Set());
+        }
+        this._dependents.get(dep)!.add(this.normalizeName(dependentName));
+    }
+
     static get<T>(name: string, scope?: Symbol): T | undefined {
         const name_ = this.normalizeName(name);
         const cls = this._classes.get(name_);
@@ -114,6 +151,7 @@ export class Injection {
                     instance = new cls.construct(...this.resolveArguments(cls, effectiveScope));
                     scopeInstances.set(effectiveScope, instance);
                     this.injectProperties(instance, cls, effectiveScope);
+                    this.triggerLifecycle(instance);
                 }
                 return scopeInstances.get(effectiveScope);
             }
@@ -121,6 +159,7 @@ export class Injection {
             if (cls.lifetime === LifetimeEnum.TRANSIENT) {
                 instance = new cls.construct(...this.resolveArguments(cls, effectiveScope));
                 this.injectProperties(instance, cls, effectiveScope);
+                this.triggerLifecycle(instance);
                 return instance as any;
             }
         } finally {
@@ -137,13 +176,36 @@ export class Injection {
             for (const [propertyKey, type] of properties) {
                 const token = typeof type === 'function' ? (type.name || type) : type;
                 if (typeof token === 'string') {
+                    this.addDependent(token, definition.name);
                     instance[propertyKey] = this.get(token, scope);
                 } else if (typeof type === 'function') {
                     const metadata: ContainerDefinitionInterface = Reflect.getMetadata(METADATA_KEYS.CONTAINER, type);
-                    instance[propertyKey] = this.get(metadata?.name || type.name, scope);
+                    const token_ = metadata?.name || type.name;
+                    this.addDependent(token_, definition.name);
+                    instance[propertyKey] = this.get(token_, scope);
+                }
+            }
+        }
+    }
+
+    protected static triggerLifecycle(instance: any): void {
+        if (typeof instance.onInit === 'function') {
+            instance.onInit();
+        }
+        if (typeof instance.onMount === 'function') {
+            instance.onMount();
+        }
+    }
+
+    static async shutdown(): Promise<void> {
+        for (const scopeInstances of this._instances.values()) {
+            for (const instance of scopeInstances.values()) {
+                if (typeof instance.onUnmount === 'function') {
+                    await instance.onUnmount();
                 }
             }
         }
+        this.clear();
     }
 
     static resolve<T>(construct: IConstructor<T>): T {

package/source/core/middleware/compose.ts

@@ -1,5 +1,5 @@
 import {MiddlewareType} from '@/types'
-import {Throwable} from "@/sdk/throwable";
+import {Throwable} from "@/sdk/exceptions";
 
 export function middlewareCompose(middlewares: MiddlewareType[]) {
     return function (request: any) {

package/source/core/raiton.ts

@@ -9,9 +9,8 @@ export class Raiton {
     static title: string = 'Protorians Raiton';
     static identifier: string = 'raiton';
 
-    static get thread(): ThreadInterface {
-        if (!this._thread)
-            throw new Error(`${Raiton.title} Thread instance not initialized`);
+    static get thread(): ThreadInterface| undefined {
+        // if (!this._thread) throw new Error(`${Raiton.title} Thread instance not initialized`);
         return this._thread;
     }