raiton 3.0.2 → 3.1.0

package/CHANGELOG.md

@@ -19,16 +19,16 @@
 
 * add `IGlobalGrafts` interface definition ([72585ed](https://github.com/protorians/raiton/commit/72585ed24c3c1b4e84626fca92ad9d9303a33061))
 * add CLI commands and bootstrap logic for the `Raiton` framework ([61d6565](https://github.com/protorians/raiton/commit/61d6565e6b6f4f2eaeaf65e2878c0f24936bfd68))
-* add constants for SDK modularization ([98bae11](https://github.com/protorians/raiton/commit/98bae1177e2b458a1e1925e151f1844db50b78c5))
-* add enums for SDK modularization ([087864f](https://github.com/protorians/raiton/commit/087864f89f8a5d87746f5595ca3c148145473044))
+* add constants for framework modularization ([98bae11](https://github.com/protorians/raiton/commit/98bae1177e2b458a1e1925e151f1844db50b78c5))
+* add enums for framework modularization ([087864f](https://github.com/protorians/raiton/commit/087864f89f8a5d87746f5595ca3c148145473044))
 * add process event handling and environment configuration setup ([93fc142](https://github.com/protorians/raiton/commit/93fc142bde480cd166e1f2681644768692fcecf7))
 * add Swagger HTML page plugin for API documentation ([d287757](https://github.com/protorians/raiton/commit/d2877576d7a310ba814aa7c4b7790271582a20bf))
 * add type definitions for core application structures ([c756482](https://github.com/protorians/raiton/commit/c75648245c7f7e2f2d25350c04e2dc0e4f5e3109))
-* add utility functions for SDK ([b947207](https://github.com/protorians/raiton/commit/b947207afe37e9a876fe6f86facc081ce4fbb0de))
+* add utility functions for framework ([b947207](https://github.com/protorians/raiton/commit/b947207afe37e9a876fe6f86facc081ce4fbb0de))
 * implement core modules for `Raiton` framework ([89c1288](https://github.com/protorians/raiton/commit/89c12886a300015da603cda57f9dbbcd5394962a))
-* implement SDK core modules and utilities ([085da37](https://github.com/protorians/raiton/commit/085da37d03399f1732d463763302d67df85848b1))
+* implement framework core modules and utilities ([085da37](https://github.com/protorians/raiton/commit/085da37d03399f1732d463763302d67df85848b1))
 * integrate `bodyParserPlugin` into application setup, refine `ControllerMeta` structure, and clean up router handler logging ([3dc29b9](https://github.com/protorians/raiton/commit/3dc29b9d203fd1d56cd22de65f58dc6c9353566a))
-* introduce decorators for SDK modularization ([e90e5fb](https://github.com/protorians/raiton/commit/e90e5fb017325115594985844328ac4d0542ccc5))
+* introduce decorators for framework modularization ([e90e5fb](https://github.com/protorians/raiton/commit/e90e5fb017325115594985844328ac4d0542ccc5))
 
 ## [0.0.2](https://github.com/protorians/raiton/compare/v0.0.1...v0.0.2) (2025-12-30)
 
@@ -90,16 +90,16 @@
 
 * add `IGlobalGrafts` interface definition ([72585ed](https://github.com/protorians/raiton/commit/72585ed24c3c1b4e84626fca92ad9d9303a33061))
 * add CLI commands and bootstrap logic for the `Raiton` framework ([61d6565](https://github.com/protorians/raiton/commit/61d6565e6b6f4f2eaeaf65e2878c0f24936bfd68))
-* add constants for SDK modularization ([98bae11](https://github.com/protorians/raiton/commit/98bae1177e2b458a1e1925e151f1844db50b78c5))
-* add enums for SDK modularization ([087864f](https://github.com/protorians/raiton/commit/087864f89f8a5d87746f5595ca3c148145473044))
+* add constants for framework modularization ([98bae11](https://github.com/protorians/raiton/commit/98bae1177e2b458a1e1925e151f1844db50b78c5))
+* add enums for framework modularization ([087864f](https://github.com/protorians/raiton/commit/087864f89f8a5d87746f5595ca3c148145473044))
 * add process event handling and environment configuration setup ([93fc142](https://github.com/protorians/raiton/commit/93fc142bde480cd166e1f2681644768692fcecf7))
 * add Swagger HTML page plugin for API documentation ([d287757](https://github.com/protorians/raiton/commit/d2877576d7a310ba814aa7c4b7790271582a20bf))
 * add type definitions for core application structures ([c756482](https://github.com/protorians/raiton/commit/c75648245c7f7e2f2d25350c04e2dc0e4f5e3109))
-* add utility functions for SDK ([b947207](https://github.com/protorians/raiton/commit/b947207afe37e9a876fe6f86facc081ce4fbb0de))
+* add utility functions for framework ([b947207](https://github.com/protorians/raiton/commit/b947207afe37e9a876fe6f86facc081ce4fbb0de))
 * implement core modules for `Raiton` framework ([89c1288](https://github.com/protorians/raiton/commit/89c12886a300015da603cda57f9dbbcd5394962a))
-* implement SDK core modules and utilities ([085da37](https://github.com/protorians/raiton/commit/085da37d03399f1732d463763302d67df85848b1))
+* implement framework core modules and utilities ([085da37](https://github.com/protorians/raiton/commit/085da37d03399f1732d463763302d67df85848b1))
 * integrate `bodyParserPlugin` into application setup, refine `ControllerMeta` structure, and clean up router handler logging ([3dc29b9](https://github.com/protorians/raiton/commit/3dc29b9d203fd1d56cd22de65f58dc6c9353566a))
-* introduce decorators for SDK modularization ([e90e5fb](https://github.com/protorians/raiton/commit/e90e5fb017325115594985844328ac4d0542ccc5))
+* introduce decorators for framework modularization ([e90e5fb](https://github.com/protorians/raiton/commit/e90e5fb017325115594985844328ac4d0542ccc5))
 
 # [1.0.0-alpha.4](https://github.com/protorians/raiton/compare/v1.0.0-alpha.3...v1.0.0-alpha.4) (2025-12-30)
 
@@ -127,15 +127,15 @@
 
 * add `IGlobalGrafts` interface definition ([72585ed](https://github.com/protorians/raiton/commit/72585ed24c3c1b4e84626fca92ad9d9303a33061))
 * add CLI commands and bootstrap logic for the `Raiton` framework ([61d6565](https://github.com/protorians/raiton/commit/61d6565e6b6f4f2eaeaf65e2878c0f24936bfd68))
-* add constants for SDK modularization ([98bae11](https://github.com/protorians/raiton/commit/98bae1177e2b458a1e1925e151f1844db50b78c5))
-* add enums for SDK modularization ([087864f](https://github.com/protorians/raiton/commit/087864f89f8a5d87746f5595ca3c148145473044))
+* add constants for framework modularization ([98bae11](https://github.com/protorians/raiton/commit/98bae1177e2b458a1e1925e151f1844db50b78c5))
+* add enums for framework modularization ([087864f](https://github.com/protorians/raiton/commit/087864f89f8a5d87746f5595ca3c148145473044))
 * add process event handling and environment configuration setup ([93fc142](https://github.com/protorians/raiton/commit/93fc142bde480cd166e1f2681644768692fcecf7))
 * add Swagger HTML page plugin for API documentation ([d287757](https://github.com/protorians/raiton/commit/d2877576d7a310ba814aa7c4b7790271582a20bf))
 * add type definitions for core application structures ([c756482](https://github.com/protorians/raiton/commit/c75648245c7f7e2f2d25350c04e2dc0e4f5e3109))
-* add utility functions for SDK ([b947207](https://github.com/protorians/raiton/commit/b947207afe37e9a876fe6f86facc081ce4fbb0de))
+* add utility functions for framework ([b947207](https://github.com/protorians/raiton/commit/b947207afe37e9a876fe6f86facc081ce4fbb0de))
 * implement core modules for `Raiton` framework ([89c1288](https://github.com/protorians/raiton/commit/89c12886a300015da603cda57f9dbbcd5394962a))
-* implement SDK core modules and utilities ([085da37](https://github.com/protorians/raiton/commit/085da37d03399f1732d463763302d67df85848b1))
-* introduce decorators for SDK modularization ([e90e5fb](https://github.com/protorians/raiton/commit/e90e5fb017325115594985844328ac4d0542ccc5))
+* implement framework core modules and utilities ([085da37](https://github.com/protorians/raiton/commit/085da37d03399f1732d463763302d67df85848b1))
+* introduce decorators for framework modularization ([e90e5fb](https://github.com/protorians/raiton/commit/e90e5fb017325115594985844328ac4d0542ccc5))
 
 # 1.0.0-alpha.1 (2025-12-04)
 

package/README.md

@@ -3,7 +3,7 @@
 [![Version](https://img.shields.io/npm/v/raiton.svg)](https://www.npmjs.com/package/raiton)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-**Protorians Raiton** est un kit de développement (SDK) backend moderne et performant, 
+**Protorians Raiton** est un framework backend moderne et performant, 
 conçu pour construire des microservices TypeScript. Optimisé pour **Bun**, 
 il offre également un support complet pour **Node.js** et **Deno**.
 

package/build/bin/index.mjs

@@ -4817,11 +4817,11 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "3.0.2";
+var version = "3.1.0";
 
 // source/bin/cli.ts
 var CLI = new Command;
-CLI.name("raiton").description("Protorians Raiton development kit for backend microservice").version(version);
+CLI.name("raiton").description("Protorians Raiton framework for backend microservice").version(version);
 var cli_default = CLI;
 
 // source/core/config/config.ts
@@ -6369,6 +6369,7 @@ class Injection {
     return this._classes.has(this.normalizeName(name));
   }
   static clear() {
+    Logger.error("Clearing injection container");
     this._classes.clear();
     this._instances.clear();
     this._dependents.clear();
@@ -6524,6 +6525,42 @@ class Injection {
     return this.get(metadata.name);
   }
 }
+// source/core/guards.ts
+class RaitonGuards {
+  static _map = new Map;
+  static set(name, guard) {
+    this._map.set(name, guard);
+    return this;
+  }
+  static get(name) {
+    return this._map.get(name);
+  }
+  static remove(name) {
+    this._map.delete(name);
+    return this;
+  }
+  static removeAll() {
+    Logger.error("Removing all guards");
+    this._map.clear();
+    return this;
+  }
+  static enabled(name) {
+    const guard = this.get(name);
+    return !guard ? false : guard.enabled;
+  }
+  static enable(name) {
+    const guard = this.get(name);
+    if (guard)
+      guard.enabled = true;
+    return this;
+  }
+  static disable(name) {
+    const guard = this.get(name);
+    if (guard)
+      guard.enabled = false;
+    return this;
+  }
+}
 // source/sdk/responses/http.ts
 class HttpResponse {
   response;
@@ -6649,6 +6686,59 @@ class HookStore {
     return store;
   }
 }
+
+// source/core/middleware/compose.ts
+function middlewareCompose(middlewares) {
+  return function(request) {
+    let index = -1;
+    return dispatch(0);
+    async function dispatch(i) {
+      if (i <= index) {
+        return Promise.reject(new Throwable("next() called multiple times"));
+      }
+      index = i;
+      const fn = middlewares[i];
+      try {
+        if (!fn)
+          return Promise.resolve();
+        if (typeof fn === "function") {
+          return Promise.resolve(fn({ context: request, next: () => dispatch(i + 1) }));
+        }
+        if (typeof fn === "object" && "setup" in fn && typeof fn.setup == "function") {
+          if (fn.setup.length === 1) {
+            await Promise.resolve(fn.setup(request));
+            return await dispatch(i + 1);
+          }
+          return Promise.resolve(fn.setup(request, () => dispatch(i + 1)));
+        }
+        return Promise.resolve();
+      } catch (err) {
+        return Promise.reject(err);
+      }
+    }
+  };
+}
+// source/core/middleware/pipeline.ts
+class MiddlewarePipeline {
+  stack = [];
+  use(mw) {
+    this.stack.push(mw);
+    return this;
+  }
+  clear() {
+    this.stack = [];
+    return this;
+  }
+  run(ctx) {
+    const fn = middlewareCompose(this.stack);
+    return typeof fn == "function" ? fn(ctx) : undefined;
+  }
+  clone() {
+    const pipeline = new MiddlewarePipeline;
+    pipeline.stack = [...this.stack];
+    return pipeline;
+  }
+}
 // source/core/router/route.ts
 class Route {
   method;
@@ -6764,6 +6854,37 @@ class Router {
     this.matcher.clear();
   }
 }
+// source/core/plugins/scope.ts
+class PluginScope {
+  hooks;
+  middleware;
+  router;
+  constructor(parent) {
+    this.hooks = parent ? parent.hooks.clone() : new HookStore;
+    this.middleware = parent ? parent.middleware.clone() : new MiddlewarePipeline;
+    this.router = parent ? parent.router : new Router;
+  }
+  addHook(name, fn) {
+    this.hooks.add(name, fn);
+    return this;
+  }
+  use(mw) {
+    if (typeof mw === "object" && mw !== null && "setup" in mw && typeof mw.setup === "function" && mw.setup.length === 1) {
+      mw.setup(this);
+      return this;
+    }
+    this.middleware.use(mw);
+    return this;
+  }
+  route(method, path5, handler2, version2) {
+    return this.router.add(method, path5, handler2, version2);
+  }
+  register(plugin) {
+    const child = new PluginScope(this);
+    plugin.setup(child);
+    return child;
+  }
+}
 // source/core/plugins/plugin.ts
 function definePlugin(setup, name) {
   return { setup, name };
@@ -6934,6 +7055,123 @@ class RequestContext {
     this.reply.send(body);
   }
 }
+
+// source/core/application.ts
+class Application {
+  config;
+  root;
+  version = RaitonConfig.get("version") || "0.0.1";
+  container = Injection;
+  constructor(config2) {
+    this.config = config2;
+    this.root = new PluginScope;
+    if (this.config.workdir) {
+      process.chdir(this.config.workdir);
+    }
+    this.initialize();
+  }
+  initialize() {
+    const artifacts = RaitonConfig.get("artifacts");
+    const artifactTypes = [...artifacts?.types || [], ...Artifacts.defaultTypes];
+    Artifacts.registerMany(...artifactTypes);
+    return this;
+  }
+  get hostname() {
+    return `${this.config.protocole || "http"}://${this.config.hostname || "localhost"}${this.config.port ? `:${this.config.port}` : ""}${this.config.pathname || "/"}`;
+  }
+  setOption(key, value) {
+    this.config[key] = value;
+    return this;
+  }
+  setOptions(options) {
+    Object.assign(this.config, options);
+    return this;
+  }
+  register(plugin2) {
+    this.root.register(plugin2);
+    return this;
+  }
+  use(mw) {
+    this.root.use(mw);
+    return this;
+  }
+  route(method, path6, handler2, version2) {
+    const prefix = this.config.prefix ?? "";
+    const fullPath = `${prefix}${path6}`.replace(/\/+/g, "/") || "/";
+    this.root.route(method, fullPath, handler2, version2);
+    return this;
+  }
+  get(path6, handler2, version2) {
+    return this.route("GET" /* GET */, path6, handler2, version2);
+  }
+  post(path6, handler2, version2) {
+    return this.route("POST" /* POST */, path6, handler2, version2);
+  }
+  patch(path6, handler2, version2) {
+    return this.route("PATCH" /* PATCH */, path6, handler2, version2);
+  }
+  put(path6, handler2, version2) {
+    return this.route("PUT" /* PUT */, path6, handler2, version2);
+  }
+  delete(path6, handler2, version2) {
+    return this.route("DELETE" /* DELETE */, path6, handler2, version2);
+  }
+  options(path6, handler2, version2) {
+    return this.route("OPTIONS" /* OPTIONS */, path6, handler2, version2);
+  }
+  head(path6, handler2, version2) {
+    return this.route("HEAD" /* HEAD */, path6, handler2, version2);
+  }
+  trace(path6, handler2, version2) {
+    return this.route("TRACE" /* TRACE */, path6, handler2, version2);
+  }
+  async handle(req, reply) {
+    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 {
+        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 route2 = this.root.router.match(req.method, pathname);
+    if (!route2) {
+      if (this.config.verbose) {
+        Logger.warn(`Route not found: ${req.method} ${pathname}`);
+      }
+      reply.status(404);
+      return reply.send({ error: false, statusCode: 404 });
+    }
+    const pipeline2 = this.root.middleware.clone();
+    pipeline2.use(async ({ context }) => {
+      try {
+        context.params = route2.parameters;
+        let responses2 = await route2.handler(context);
+        context.reply.send(responses2);
+      } catch (e) {
+        Logger.error("Failed to handle request", e.message ?? e);
+        if (this.config.develop) {
+          console.error(e);
+        }
+      }
+    });
+    await pipeline2.run(ctx);
+    await this.root.hooks.run("onResponse", ctx);
+  }
+}
 // source/bin/cli-tools.ts
 import { spawn } from "node:child_process";
 

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "raiton",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "private": false,
   "type": "module",
-  "description": "Protorians Raiton Development Kit",
+  "description": "Modular TypeScript Backend Framework with Dependency Injection, Plugins, Controllers, Middleware and Hot Reloading.",
   "main": "./source/core/index.ts",
   "module": "./source/core/index.ts",
   "types": "./source/core/index.d.ts",
@@ -13,8 +13,7 @@
   "keywords": [
     "protorians",
     "raiton",
-    "development",
-    "kit",
+    "framework",
     "typescript",
     "node",
     "bun",

package/scripts/update-version.ts

@@ -24,12 +24,12 @@ function determineIncrement(commits: string[]) {
   let increment: "major" | "minor" | "patch" | null = null;
 
   for (let commit of commits) {
-    commit = commit.trim();
+    commit = commit.trim().toLowerCase();
     if (
-        commit.includes("BREAKING CHANGE") ||
+        commit.includes("breaking change") ||
         commit.includes("!") ||
-        commit.toLowerCase().startsWith("release") ||
-        commit.toLowerCase().startsWith("upgrade")
+        commit.startsWith("release") ||
+        commit.startsWith("upgrade")
     ) {
       return "major";
     }
@@ -42,7 +42,7 @@ function determineIncrement(commits: string[]) {
         !increment &&
         commit.startsWith("fix") ||
         commit.startsWith("update") ||
-        commit.toLowerCase().startsWith("remove")
+        commit.startsWith("remove")
     ) {
       increment = "patch";
     }

package/source/bin/cli.ts

@@ -6,7 +6,7 @@ const CLI = new Command();
 
 CLI
     .name('raiton')
-    .description('Protorians Raiton development kit for backend microservice')
+    .description('Protorians Raiton framework for backend microservice')
     .version(version);
 
 export default CLI;

package/source/commands/artifact.command.ts

@@ -1,6 +1,6 @@
 import {RaitonCommand, RaitonBuilder} from "../core";
 import {Logger} from "@protorians/logger";
-import type {BuildCommandOptions} from "../types";
+import type {BuildCommandOptionsInterface} from "../types";
 
 
 export default class ArtifactCommand extends RaitonCommand {
@@ -19,7 +19,7 @@ export default class ArtifactCommand extends RaitonCommand {
             .action(this.run.bind(this));
     }
 
-    protected async run(options: BuildCommandOptions): Promise<void> {
+    protected async run(options: BuildCommandOptionsInterface): Promise<void> {
 
         Logger.notice("Artifact management is not yet implemented");
         Logger.debug('Options:', options, '')

package/source/commands/build.command.ts

@@ -1,6 +1,6 @@
 import {RaitonCommand, RaitonBuilder} from "../core";
 import {LBadge, Logger} from "@protorians/logger";
-import type {BuildCommandOptions} from "../types";
+import type {BuildCommandOptionsInterface} from "../types";
 
 
 export default class BuildCommand extends RaitonCommand {
@@ -17,7 +17,7 @@ export default class BuildCommand extends RaitonCommand {
             .action(this.run.bind(this));
     }
 
-    protected async run(options: BuildCommandOptions): Promise<void> {
+    protected async run(options: BuildCommandOptionsInterface): Promise<void> {
         if (options.develop) Logger.warn(LBadge.log("Dev Mode"),);
 
         const builder = new RaitonBuilder(this.workdir, {

package/source/core/application.ts

@@ -1,17 +1,22 @@
 import {PluginScope} from './plugins/scope'
 import {RequestContext} from './context'
-import {ApplicationConfig, ApplicationInterface} from "../types/application";
+import {ApplicationConfigInterface, ApplicationInterface} from "../types/application";
 import {HttpMethod} from "../sdk";
-import {RouteHandler} from "../types";
+import {RouteHandlerCallable} from "../types";
 import {Logger} from "@protorians/logger";
 import {RaitonConfig} from "./config";
 import {Artifacts} from "../sdk/artifacts";
+import {Injection} from "./injection";
 
 export class Application implements ApplicationInterface {
     private root: PluginScope
 
+    readonly version: string = RaitonConfig.get('version') || '0.0.1'
+
+    readonly container: Injection = Injection;
+
     constructor(
-        readonly config: ApplicationConfig
+        readonly config: ApplicationConfigInterface
     ) {
         this.root = new PluginScope()
         if (this.config.workdir) {
@@ -40,12 +45,12 @@ export class Application implements ApplicationInterface {
         }`
     }
 
-    public setOption<K extends keyof ApplicationConfig>(key: K, value: ApplicationConfig[K]): this {
+    public setOption<K extends keyof ApplicationConfigInterface>(key: K, value: ApplicationConfigInterface[K]): this {
         this.config[key] = value;
         return this;
     }
 
-    public setOptions(options: ApplicationConfig): this {
+    public setOptions(options: ApplicationConfigInterface): this {
         Object.assign(this.config, options);
         return this;
     }
@@ -60,42 +65,42 @@ export class Application implements ApplicationInterface {
         return this
     }
 
-    route(method: HttpMethod, path: string, handler: RouteHandler, version?: string): this {
+    route(method: HttpMethod, path: string, handler: RouteHandlerCallable, version?: string): this {
         const prefix = this.config.prefix ?? ''
         const fullPath = `${prefix}${path}`.replace(/\/+/g, '/') || '/'
         this.root.route(method, fullPath, handler, version)
         return this
     }
 
-    get(path: string, handler: RouteHandler, version?: string): this {
+    get(path: string, handler: RouteHandlerCallable, version?: string): this {
         return this.route(HttpMethod.GET, path, handler, version)
     }
 
-    post(path: string, handler: RouteHandler, version?: string): this {
+    post(path: string, handler: RouteHandlerCallable, version?: string): this {
         return this.route(HttpMethod.POST, path, handler, version)
     }
 
-    patch(path: string, handler: RouteHandler, version?: string): this {
+    patch(path: string, handler: RouteHandlerCallable, version?: string): this {
         return this.route(HttpMethod.PATCH, path, handler, version)
     }
 
-    put(path: string, handler: RouteHandler, version?: string): this {
+    put(path: string, handler: RouteHandlerCallable, version?: string): this {
         return this.route(HttpMethod.PUT, path, handler, version)
     }
 
-    delete(path: string, handler: RouteHandler, version?: string): this {
+    delete(path: string, handler: RouteHandlerCallable, version?: string): this {
         return this.route(HttpMethod.DELETE, path, handler, version)
     }
 
-    options(path: string, handler: RouteHandler, version?: string): this {
+    options(path: string, handler: RouteHandlerCallable, version?: string): this {
         return this.route(HttpMethod.OPTIONS, path, handler, version)
     }
 
-    head(path: string, handler: RouteHandler, version?: string): this {
+    head(path: string, handler: RouteHandlerCallable, version?: string): this {
         return this.route(HttpMethod.HEAD, path, handler, version)
     }
 
-    trace(path: string, handler: RouteHandler, version?: string): this {
+    trace(path: string, handler: RouteHandlerCallable, version?: string): this {
         return this.route(HttpMethod.TRACE, path, handler, version)
     }
 

package/source/core/builder.ts

@@ -2,7 +2,7 @@ import {RaitonConfig} from "./config";
 import path from "node:path";
 import {RaitonDirectories} from "./directories";
 import fs, {WatchEventType} from "node:fs";
-import type {BuilderConfig, BuilderInterface,} from "../types";
+import type {BuilderConfigInterface, BuilderInterface,} from "../types";
 import {RaitonThread} from "./thread";
 import {Raiton} from "./raiton";
 import {isControllerArtifact, isServiceArtifact} from "../sdk";
@@ -24,7 +24,7 @@ export class RaitonBuilder implements BuilderInterface {
 
     constructor(
         public readonly workdir: string,
-        public readonly options: BuilderConfig = {},
+        public readonly options: BuilderConfigInterface = {},
     ) {
 
     }

package/source/core/bytes.util.ts

@@ -1,6 +1,6 @@
-import {FileSizeFormated} from "../types";
+import {FileSizeFormatedInterface} from "../types";
 
-export function parseBytes(bytes: number, decimals = 2): FileSizeFormated {
+export function parseBytes(bytes: number, decimals = 2): FileSizeFormatedInterface {
     if (bytes === 0) return {size: 0, unit: "o"};
 
     const k = 1024;

package/source/core/config/config.ts

@@ -1,19 +1,19 @@
 import path from "node:path";
 import fs from "node:fs";
-import {Configurable} from "../../types";
+import {ConfigurableInterface} from "../../types";
 import {Logger} from "@protorians/logger";
 import {Raiton} from "../raiton";
 
 export class RaitonConfig {
-    static readonly current: Map<keyof Configurable, Configurable[keyof Configurable]> = new Map();
+    static readonly current: Map<keyof ConfigurableInterface, ConfigurableInterface[keyof ConfigurableInterface]> = new Map();
 
     protected static _extensions: string[] = ['.js', '.mjs'];
 
-    static get<K extends keyof Configurable>(key: K): Configurable[K] | undefined {
-        return this.current.get(key) as Configurable[K];
+    static get<K extends keyof ConfigurableInterface>(key: K): ConfigurableInterface[K] | undefined {
+        return this.current.get(key) as ConfigurableInterface[K];
     }
 
-    static defaultConfig: Configurable = {
+    static defaultConfig: ConfigurableInterface = {
         rootDir: '.',
         version: '0.0.1'
     }
@@ -26,7 +26,7 @@ export class RaitonConfig {
                 if (fs.existsSync(configJsonPath)) {
                     const configContent = fs.readFileSync(configJsonPath, 'utf-8');
                     for (const [key, value] of Object.entries({...this.defaultConfig, ...(JSON.parse(configContent) || {})}))
-                        this.current.set(key as keyof Configurable, value as Configurable[keyof Configurable]);
+                        this.current.set(key as keyof ConfigurableInterface, value as ConfigurableInterface[keyof ConfigurableInterface]);
                 } else {
                     for (const ext of this._extensions) {
                         const configPath = path.join(workdir, `${Raiton.identifier}.config${ext}`);
@@ -34,7 +34,7 @@ export class RaitonConfig {
                             const configModule = await import(configPath);
                             const config = await configModule?.default || configModule;
                             for (const [key, value] of Object.entries(config)) {
-                                this.current.set(key as keyof Configurable, value as Configurable[keyof Configurable]);
+                                this.current.set(key as keyof ConfigurableInterface, value as ConfigurableInterface[keyof ConfigurableInterface]);
                             }
                         }
                     }

package/source/core/config/define.ts

@@ -1,11 +1,11 @@
-import {Configurable} from "../../types/config";
+import {ConfigurableInterface} from "../../types/config";
 import {JsonUtil} from "../../sdk/utilities";
 
-export async function defineConfig(config?: Configurable) {
+export async function defineConfig(config?: ConfigurableInterface) {
     const workdir = process.cwd();
     const pkg = JsonUtil.import(workdir + '/package.json');
 
-    config = {...config || {}, ...pkg.raitonConfig || {}} as Configurable;
+    config = {...config || {}, ...pkg.raitonConfig || {}} as ConfigurableInterface;
     config.rootDir = config.rootDir || './';
     config.version = config.version || pkg.version || '0.0.1';
 

package/source/core/controller/builder.ts

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import {BuilderHMRDeclaration} from "../../types";
+import {BuilderHMRDeclarationInterface} from "../../types";
 import {LBadge, Logger} from "@protorians/logger";
 import {compileController} from "./compiler";
 import {RaitonThread} from "../thread";
@@ -21,7 +21,7 @@ export class ControllerBuilder {
         return output.filter(f => typeof f !== 'undefined');
     }
 
-    static async build<T>({filename, version, timestamp}: BuilderHMRDeclaration): Promise<T | undefined> {
+    static async build<T>({filename, version, timestamp}: BuilderHMRDeclarationInterface): Promise<T | undefined> {
         if (!isControllerArtifact(filename))
             return undefined;