raiton 1.0.0-alpha.3 → 1.0.0-alpha.4

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+# [1.0.0-alpha.4](https://github.com/protorians/raiton/compare/v1.0.0-alpha.3...v1.0.0-alpha.4) (2026-02-17)
+
+
+### Bug Fixes
+
+* remove emojis from README section titles for consistency ([8d604ee](https://github.com/protorians/raiton/commit/8d604eec0825bfdf172988ee9fe662076b7e46be))
+* remove unused Fastify dependencies and deprecate parameter handling utilities ([282db2c](https://github.com/protorians/raiton/commit/282db2cb4baeb52b816e1444f9d618570a073443))
+* update `.releaserc.json` to refine branch configurations and format `assets` array ([0f803c0](https://github.com/protorians/raiton/commit/0f803c08d03549bd28ef9e61fe9c6c121d2f781d))
+* update keywords in `package.json` and reset version to `0.0.0` ([44f7c85](https://github.com/protorians/raiton/commit/44f7c858330fc5455260d66d05b78a5a33d388f8))
+
+
+### Features
+
+* add `NODE_AUTH_TOKEN` to `publish.yml` for semantic-release environment setup ([44a561b](https://github.com/protorians/raiton/commit/44a561b60bc3f35ae59bb404c343ef56baab4d26))
+* enable provenance support in `package.json` and `.releaserc.json` ([b5db171](https://github.com/protorians/raiton/commit/b5db171a84150aefc2978b37c5d3544b5769b160))
+* make package public and fix `publish.yml` token variable ([0293ee6](https://github.com/protorians/raiton/commit/0293ee629e444be0d90823896ea57212743d357d))
+* remove redundant comments from `publish.yml` workflow ([37ddce9](https://github.com/protorians/raiton/commit/37ddce94356dba8f2c2d5e87af7fc3ade4ca3cf5))
+
 # [1.0.0-alpha.3](https://github.com/protorians/raiton/compare/v1.0.0-alpha.2...v1.0.0-alpha.3) (2026-02-17)
 
 

package/README.md

@@ -82,7 +82,7 @@ bun raiton build
 bun raiton start
 ```
 
-## 🛠 Runtimes supportés
+## Runtimes supportés
 
 Raiton détecte automatiquement l'environnement d'exécution et adapte son serveur :
 
@@ -90,7 +90,7 @@ Raiton détecte automatiquement l'environnement d'exécution et adapte son serve
 - **Node.js** : Adaptateur pour serveurs HTTP Node.
 - **Web** : Compatible avec les environnements basés sur les standards Web (Fetch API).
 
-## 📄 Licence
+## Licence
 
 Ce projet est sous licence MIT. Voir le fichier [LICENSE](LICENSE) pour plus de détails.
 

package/build/bin/index.mjs

@@ -4803,7 +4803,7 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "1.0.0-alpha.3";
+var version = "1.0.0-alpha.4";
 
 // source/bin/cli.ts
 var CLI = new Command;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "raiton",
-  "version": "1.0.0-alpha.3",
+  "version": "1.0.0-alpha.4",
   "private": false,
   "type": "module",
   "description": "Protorians Raiton Development Kit",

package/source/core/artifacts/artifact.ts

@@ -0,0 +1,109 @@
+import type {ArtifactEntry, ArtifactInterface, ArtifactOptions} from "@/types/artifact";
+import {RaitonDirectories} from "@/core/directories";
+import {Raiton} from "@/core/raiton";
+import path from "node:path";
+import fs from "node:fs";
+import {LBadge, Logger} from "@protorians/logger";
+import {ArtifactFactory} from "@/sdk/artifacts";
+import {Throwable} from "@/sdk/throwable";
+
+export class Artifact implements ArtifactInterface {
+    public readonly directory: string;
+    public readonly file: string;
+    public readonly workdir: string;
+
+    protected _files: string[] = [];
+
+    constructor(
+        public readonly options: ArtifactOptions,
+    ) {
+        this.options.verbose = typeof options.verbose === "undefined" ? false : options.verbose;
+
+        if (!Raiton.thread.builder?.source)
+            throw new Throwable("Artifact need project source");
+
+        this.directory = RaitonDirectories.artifacts(Raiton.thread.builder?.workdir)
+        this.workdir = Raiton.thread.builder.source;
+        this.file = path.join(this.directory, `${this.options.artifact}.d.ts`);
+    }
+
+    get files(): string[] {
+        return this._files;
+    }
+
+    get extensions(): string[] {
+        return [
+            `${this.options.artifact}.ts`,
+            `${this.options.artifact}.js`,
+            `${this.options.artifact}.mjs`,
+            `${this.options.artifact}.cjs`,
+        ]
+    }
+
+    /**
+     * Finds all files with end 'artifact.EXT'
+     */
+    scan(): string[] {
+        this._files = [];
+
+        fs.readdirSync(this.workdir, {recursive: true})
+            .forEach(f => {
+                this._files = [
+                    ...this._files,
+                    ...this.extensions.filter(ext => f.toString().endsWith(ext))
+                ];
+            })
+        ;
+
+        return this._files;
+    }
+
+    generate(): boolean {
+        try {
+            let mappings = "";
+
+            for (const file of this._files) {
+                const filename = path.join(this.workdir, file);
+                const content = fs.readFileSync(filename, "utf-8");
+                const match = content.match(this.options.decorator?.syntax);
+
+                if (!match) continue;
+
+                let name = match[3] || match[1] || "";
+                if (!name) {
+                    const classMatch = content.match(/export\s+default\s+class\s+([A-Za-z0-9_]+)/);
+                    name = classMatch?.[1] || path.parse(filename).name;
+                }
+
+                mappings += `    ${name}: InstanceType<typeof import("@/${file}").default>;\n`;
+
+                if (this.options.verbose) Logger.info(LBadge.debug(name), `artifact detected`);
+
+                ArtifactFactory.add(
+                    this.options.artifact, {
+                        file,
+                        dir: this.workdir,
+                        relative: file,
+                        absolute: filename
+                    }
+                )
+            }
+
+            const content = `// AUTO-GENERATED FILE — DO NOT EDIT MANUALLY
+declare global {
+  interface ${this.options.provider} {
+${mappings} }
+}
+export {};`;
+            fs.writeFileSync(this.file, content, "utf-8");
+            if (!ArtifactFactory.save(this.options.artifact))
+                throw new Throwable(`Failed to save artifacts for ${this.options.artifact}`);
+
+            return true;
+        } catch (e: any) {
+            Logger.error(`Failed to resolve artifacts for ${this.options.artifact}`, e.message ?? e);
+        }
+        return false;
+    }
+
+}

package/source/core/artifacts/artifacts.ts

@@ -0,0 +1,10 @@
+import {RaitonConfig} from "@/core";
+
+export class Artifacts {
+
+    public static async load(workdir: string) {
+        await RaitonConfig.sync(workdir);
+        return RaitonConfig.get('artifacts');
+    }
+
+}

package/source/core/artifacts/index.ts

@@ -0,0 +1 @@
+export * from "./artifact";

package/source/core/artifacts/runner.ts

@@ -0,0 +1,3 @@
+export function artifactRunner () {
+
+}

package/source/core/hmr.ts

@@ -0,0 +1,106 @@
+import {HmrInterface, HMRMetadataInterface} from "@/types";
+import {Logger} from "@protorians/logger";
+
+
+export class Hmr implements HmrInterface {
+    protected files: Map<string, HMRMetadataInterface> = new Map();
+
+    set(file: string, filename: string, size: number = 0) {
+
+        if(!filename.endsWith('.js')) return this;
+
+        this.files.set(file, {
+            filename,
+            size,
+            version: 1,
+            timestamp: Date.now(),
+        });
+        return this;
+    }
+
+    clear(): this {
+        this.files.clear();
+        return this;
+    }
+
+    entries(): Record<string, HMRMetadataInterface> {
+        return Object.fromEntries(this.files.entries());
+    }
+
+    has(key: string): boolean {
+        return this.files.has(key);
+    }
+
+    async refresh(): Promise<this> {
+        await this.each(async (file, key) => await this.upsert(key, file.filename));
+        return this;
+    }
+
+    async load<T>(key: string): Promise<T | undefined> {
+        const file = this.files.get(key);
+        Logger.log('HMR', file)
+
+        const mod = file ? await import(`${file.filename}?t=${file.timestamp}&v=${file.version}`) : undefined;
+        return mod as T | undefined;
+    }
+
+    async reload<T>(key: string): Promise<T | undefined> {
+        const file = this.files.get(key);
+
+        if (!file) return undefined;
+
+        file.version++
+        file.timestamp = Date.now();
+        this.files.set(key, file);
+
+        return await import(`${file.filename}?t=${file.timestamp}&v=${file.version}`);
+    }
+
+    unset(key: string): this {
+        this.files.delete(key);
+        return this;
+    }
+
+    size(): number {
+        return this.files.size;
+    }
+
+    async each(callable: (value: HMRMetadataInterface, key: string, map: Map<string, HMRMetadataInterface>) => void | Promise<void>): Promise<this> {
+        await Promise.all([...this.files.entries()].map(async ([key, value]) => await callable(value, key, this.files)));
+        return this;
+    }
+
+    get(key: string): HMRMetadataInterface | undefined {
+        return this.files.get(key);
+    }
+
+    getEntries(): Array<[string, HMRMetadataInterface]> {
+        return [...this.files.entries()];
+    }
+
+    getKeys(): string[] {
+        return [...this.files.keys()];
+    }
+
+    getValues(): Array<HMRMetadataInterface> {
+        return [...this.files.values()];
+    }
+
+    async upsert<T>(key: string, filename: string, size: number = 0): Promise<T | undefined> {
+        let file: HMRMetadataInterface | undefined = this.files.get(key);
+
+        if (!file) {
+            this.set(key, filename);
+            file = this.files.get(key);
+        }
+
+        if (!file) return undefined;
+        if (file.size === size) return undefined;
+
+        file.version++;
+        file.timestamp = Date.now();
+        file.size = size;
+
+        return await this.set(key, filename, size).load(key);
+    }
+}

package/source/core/injection/metadata.ts

@@ -0,0 +1,22 @@
+import {METADATA_KEYS} from "@/sdk/constants";
+import type {ContainerDefinitionInterface} from "@/types";
+import {LifetimeEnum} from "@protorians/core";
+import "reflect-metadata";
+
+export function getContainerMetadata(target: any): ContainerDefinitionInterface {
+    let metadata = Reflect.getMetadata(METADATA_KEYS.CONTAINER, target);
+
+    if (!metadata) {
+        metadata = {
+            name: `${target.name}`,
+            construct: target,
+            parameters: [],
+            lifetime: LifetimeEnum.TRANSIENT,
+            instance: undefined,
+            scope: undefined,
+        } as ContainerDefinitionInterface;
+        Reflect.defineMetadata(METADATA_KEYS.CONTAINER, metadata, target);
+    }
+
+    return metadata;
+}

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

@@ -0,0 +1,77 @@
+// import {IPayload} from "@/types";
+// import {SYSTEM_DECORATORS_KEYS} from "@/sdk/constants";
+//
+// /**
+//  * A decorator function that combines and assigns schema-related metadata
+//  * to a specific property in the target constructor using reflective metadata.
+//  *
+//  * @param {IPayload} payload - The schema-related payload to be merged and assigned as metadata.
+//  * @return {Function} A decorator function that applies the merged metadata to the property.
+//  */
+// export function Schemeable(payload: IPayload): (target: any, propertyKey: (string | symbol)) => void {
+//     return (target: any, propertyKey: string | symbol,) => {
+//         const current: IPayload = {...(Reflect.getMetadata(SYSTEM_DECORATORS_KEYS.ROUTES_SCHEMES, target.constructor, propertyKey) || {}), ...payload};
+//         Reflect.defineMetadata(SYSTEM_DECORATORS_KEYS.ROUTES_SCHEMES, current, target.constructor, propertyKey);
+//     };
+// }
+//
+//
+// /**
+//  * Constructs a schematizable object for the provided payload body.
+//  *
+//  * @param {IPayload['body']} payload - The body of the payload to be schematized.
+//  * @return {object} Returns a schematized object containing the provided payload body.
+//  */
+// export function BodySchemeable(payload: IPayload['body']): (target: any, propertyKey: (string | symbol)) => void {
+//     return Schemeable({
+//         body: payload
+//     });
+// }
+//
+// /**
+//  * Transforms the provided headers payload into a schematizable format.
+//  *
+//  * @param {IPayload['headers']} payload - The headers payload to be processed and transformed.
+//  * @return {object} The transformed schematizable object containing the headers.
+//  */
+// export function HeadersSchemeable(payload: IPayload['headers']): (target: any, propertyKey: (string | symbol)) => void {
+//     return Schemeable({
+//         headers: payload
+//     });
+// }
+//
+// /**
+//  * Constructs a schematizable object using the given query string payload.
+//  *
+//  * @param {IPayload['querystring']} payload - The query string object to be included in the schematizable configuration.
+//  * @return {object} The resulting schematizable object containing the query string.
+//  */
+// export function QuerySchemeable(payload: IPayload['querystring']): (target: any, propertyKey: (string | symbol)) => void {
+//     return Schemeable({
+//         querystring: payload
+//     });
+// }
+//
+// /**
+//  * Creates a schematizable object using the provided parameters.
+//  *
+//  * @param {IPayload['params']} payload - The parameters to be used for creating the schematizable object.
+//  * @return {Object} The resulting schematizable object containing the specified parameters.
+//  */
+// export function ParamsSchemeable(payload: IPayload['params']): (target: any, propertyKey: (string | symbol)) => void {
+//     return Schemeable({
+//         params: payload
+//     });
+// }
+//
+// /**
+//  * Constructs a schematized response payload.
+//  *
+//  * @param {IPayload['response']} payload - The response payload to be schematized.
+//  * @return {object} The schematized response object.
+//  */
+// export function ResponseSchemeable(payload: IPayload['response']): (target: any, propertyKey: (string | symbol)) => void {
+//     return Schemeable({
+//         response: payload
+//     });
+// }

package/source/sdk/decorators/routable.ts

@@ -0,0 +1,25 @@
+import {getControllerMetadata} from "@/core";
+import {HttpMethod} from "@/sdk";
+import {ControllerMeta} from "@/types";
+
+function createRoutableMethod(method: HttpMethod) {
+    return (path = '') =>
+        (target: any, propertyKey: string) => {
+            const meta: ControllerMeta = getControllerMetadata(target)
+            meta.routes.push({
+                method,
+                path,
+                propertyKey,
+                params: meta.params[propertyKey] || []
+            })
+        }
+}
+
+export const Get = createRoutableMethod(HttpMethod.GET)
+export const Post = createRoutableMethod(HttpMethod.POST)
+export const Put = createRoutableMethod(HttpMethod.PUT)
+export const Patch = createRoutableMethod(HttpMethod.PATCH)
+export const Options = createRoutableMethod(HttpMethod.OPTIONS)
+export const Trace = createRoutableMethod(HttpMethod.TRACE)
+export const Delete = createRoutableMethod(HttpMethod.DELETE)
+export const Head = createRoutableMethod(HttpMethod.HEAD)

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

@@ -0,0 +1,10 @@
+export enum HttpMethod {
+    GET = 'GET',
+    POST = 'POST',
+    PUT = 'PUT',
+    DELETE = 'DELETE',
+    PATCH = 'PATCH',
+    OPTIONS = 'OPTIONS',
+    HEAD = 'HEAD',
+    TRACE = 'TRACE',
+}

package/source/sdk/fastify.ts

@@ -0,0 +1,5 @@
+import * as fastifyCore from 'fastify'
+import fastifyPlugin from 'fastify-plugin'
+
+export const FastifyPlugin = fastifyPlugin;
+export default {...fastifyCore};

package/source/sdk/json.ts

@@ -0,0 +1,55 @@
+import {IParseableEntries, IParseablePrimitiveEntry} from "../types/parseable";
+import {stabilizeJson} from "./utilities";
+
+
+export class Json<T extends IParseableEntries> {
+
+    public readonly stack: Map<keyof T, T[keyof T]> = new Map();
+
+    constructor(json: IParseablePrimitiveEntry<T>) {
+        this.records(stabilizeJson<T>(json));
+    }
+
+    records(data: T): this {
+        for (const [key, value] of Object.entries(data))
+            this.stack.set(key as keyof T, value as T[keyof T]);
+        return this;
+    }
+
+    get<K extends keyof T>(key: K): T[K] {
+        return this.stack.get(key) as T[K];
+    }
+
+    set<K extends keyof T>(key: K, value: T[K]): this {
+        this.stack.set(key, value);
+        return this;
+    }
+
+    remove<K extends keyof T>(key: K): this {
+        this.stack.delete(key);
+        return this;
+    }
+
+    clear(): this {
+        this.stack.clear();
+        return this;
+    }
+
+    render(): T {
+        return Object.fromEntries(this.stack) as any as T;
+    }
+
+    static stabilize<T>(json: string | T | null): T {
+        return stabilizeJson<T>(json);
+    }
+
+    static from<T extends IParseableEntries>(data: T): Json<T> {
+        const json = new Json<T>(null);
+        json.records(data);
+        return json;
+    }
+
+    static records<T extends IParseableEntries>(support: Json<T>, data: IParseablePrimitiveEntry<T>): Json<T> {
+        return support.records(this.stabilize(data));
+    }
+}

package/source/sdk/request.ts

@@ -0,0 +1,3 @@
+export class RaitonRequest {
+
+}

package/source/sdk/responses/http.ts

@@ -1,6 +1,6 @@
 import {HttpResponseInterface} from "@/types";
 import {HttpStatus} from "@/sdk/enums";
-import {ThrowableResponse} from "@/sdk/responses";
+import {ThrowableResponse} from "@/sdk";
 
 
 export class HttpResponse {

package/source/sdk/responses.ts

@@ -0,0 +1,31 @@
+import type {IHttpResponse, IParseableEntry} from "@/types";
+
+export function httpResponse<T extends IParseableEntry>(
+    statusCode: number,
+    message?: string,
+    data?: T,
+    error?: any,
+): IHttpResponse<T> {
+    return {
+        statusCode,
+        message,
+        data,
+        error,
+    }
+}
+
+export function successResponse<T extends IParseableEntry>(
+    message?: string,
+    data?: T,
+    error?: any,
+): IHttpResponse<T> {
+    return httpResponse<T>(200, message, data, error);
+}
+
+export function errorResponse<T extends IParseableEntry>(
+    message?: string,
+    data?: T,
+    error?: any,
+): IHttpResponse<T> {
+    return httpResponse<T>(500, message, data, error);
+}

package/source/sdk/routes.ts

@@ -0,0 +1,21 @@
+import path from "node:path";
+import * as fs from "node:fs";
+import {FastifyInstance} from "fastify";
+import {aliasPath} from "./utilities";
+
+
+export async function registryRoutes(app: FastifyInstance) {
+    const dir = aliasPath('@/routes');
+    if (!dir || !fs.existsSync(dir)) return app;
+
+    const files = fs.readdirSync(dir);
+
+    for (const file of files) {
+        if (file.endsWith(".route.ts")) {
+            const route = await import(path.join(dir, file));
+            route.default(app);
+        }
+    }
+
+    return app;
+}

package/source/sdk/schemes.ts

@@ -0,0 +1,178 @@
+import {TSchema, Static, TProperties, Type} from "@sinclair/typebox";
+import {ISchemeConfig, ISchemeOptions, IScheme} from "@/types";
+
+
+export * from "@sinclair/typebox"
+
+export function scheme() {
+    return new Scheme({});
+}
+
+
+/**
+ * A utility type for casting and inferring a type based on the provided `Schematic` generic structure.
+ * It checks if the given type `T` extends from the `Schematic` type and applies the inference logic
+ * defined by the `Schematic.infer` function. If the condition is not met, the type resolves to `never`.
+ *
+ * @template T - The generic type to evaluate and potentially infer from the `Schematic` structure.
+ *
+ * If `T` is an instance of `Schematic` with defined type parameters, this utility resolves to the
+ * result returned by the `Schematic.infer` method applied to `T`. Otherwise, it will resolve to `never`.
+ */
+export type SchematicCast<T> = T extends Scheme<any, any, any, any>
+    ? ReturnType<typeof Scheme.infer<T>>
+    : never;
+
+/**
+ * Represents a schema configuration that can be used with type-safe operations
+ * and is compatible with fastify route options.
+ *
+ * @template TBody - Optional schema type for the request body.
+ * @template TParams - Optional schema type for the route parameters.
+ * @template TQuery - Optional schema type for the query string parameters.
+ * @template TResponse - Optional schema type for the response, where each status code can have its own schema.
+ */
+export class Scheme<
+    TBody extends TSchema | undefined = undefined,
+    TParams extends TSchema | undefined = undefined,
+    TQuery extends TSchema | undefined = undefined,
+    TResponse extends Record<number, TSchema> | undefined = undefined
+> implements IScheme<TBody, TParams, TQuery, TResponse> {
+    protected _$body?: TBody;
+    protected _$params?: TParams;
+    protected _$querystring?: TQuery;
+    protected _$response?: TResponse;
+
+    constructor(config: ISchemeConfig<TBody, TParams, TQuery, TResponse>) {
+        this._$body = config.body;
+        // this._$body = config.body;
+        this._$params = config.params;
+        this._$querystring = config.querystring;
+        this._$response = config.response;
+    }
+
+    /**
+     * Retrieves the current value of the $body property.
+     *
+     * @return {TBody | undefined} The value of the $body property, or undefined if it is not set.
+     */
+    get $body(): TBody | undefined {
+        return this._$body;
+    }
+
+    /**
+     * Adds or updates a key-value pair in the body object.
+     *
+     * @param {string} key - The key to set or update in the body object.
+     * @param {TProperties} value - The value to associate with the specified key.
+     * @return {this} The current instance with the updated body object.
+     */
+    body(key: string, value: TProperties): this {
+        this._$body = {...(this._$body || {}), [key]: value} as TBody;
+        return this;
+    }
+
+    /**
+     * Retrieves the current value of the `$params` property.
+     *
+     * @return {TParams | undefined} The value of `$params` if set, otherwise undefined.
+     */
+    get $params(): TParams | undefined {
+        return this._$params;
+    }
+
+    /**
+     * Adds or updates a parameter with the specified key and value.
+     *
+     * @param {string} key - The key associated with the parameter to set or update.
+     * @param {TProperties} value - The value to associate with the specified key.
+     * @return {this} The current instance with the updated parameters.
+     */
+    params(key: string, value: TProperties): this {
+        this._$params = {...(this._$params || {}), [key]: value} as TParams;
+        return this;
+    }
+
+    /**
+     * Retrieves the current query string.
+     *
+     * @return {TQuery | undefined} The query string object if available, otherwise undefined.
+     */
+    get $querystring(): TQuery | undefined {
+        return this._$querystring;
+    }
+
+    /**
+     * Updates the query string parameters by setting the specified key-value pair.
+     *
+     * @param {string} key - The key of the query string parameter to set or update.
+     * @param {TProperties} value - The value associated with the specified key.
+     * @return {this} The current instance of the class for method chaining.
+     */
+    querystring(key: string, value: TProperties): this {
+        this._$querystring = {...(this._$querystring || {}), [key]: value} as TQuery;
+        return this;
+    }
+
+    /**
+     * Retrieves the current response object.
+     *
+     * @return {TResponse | undefined} The response object if available; otherwise, undefined.
+     */
+    get $response(): TResponse | undefined {
+        return this._$response;
+    }
+
+    /**
+     * Adds or updates a response key-value pair in the internal response object.
+     *
+     * @param {number} key - The key to be added or updated in the response object.
+     * @param {TProperties} value - The value associated with the given key.
+     * @return {this} The current instance to allow method chaining.
+     */
+    response(key: number, value: TProperties): this {
+        this._$response = {...(this._$response || {}), [key]: value} as TResponse;
+        return this;
+    }
+
+    /**
+     * Generates a schema object for validating different parts of an HTTP request.
+     *
+     * @return {Object} An object containing the schema definitions for `body`, `params`, `querystring`, and `response`. Each property returns a corresponding schema object.
+     */
+    schema(): ISchemeOptions<TBody, TParams, TQuery, TResponse> {
+        const schema: ISchemeOptions<TBody, TParams, TQuery, TResponse> = {}
+
+        if (this._$body) schema.body = Type.Object(this._$body);
+        if (this._$params) schema.params = Type.Object(this._$params);
+        if (this._$querystring) schema.querystring = Type.Object(this._$querystring);
+        if (this._$response) schema.response = Type.Object(this._$response);
+
+        return schema;
+    }
+
+    /**
+     * Infers and extracts static types from a given schema object.
+     *
+     * @param {T extends Schematic<any, any, any, any>} schema - The schema to infer types from. This should extend the Schematic type.
+     * @return {Object} An object containing inferred types including:
+     * - Body: The static type of the request body if defined in the schema, otherwise undefined.
+     * - Params: The static type of the request parameters if defined in the schema, otherwise undefined.
+     * - Query: The static type of the query string if defined in the schema, otherwise undefined.
+     * - Reply: The response type mappings if defined in the schema, otherwise undefined.
+     */
+    static infer<T extends Scheme<any, any, any, any>>(schema: T) {
+        return {
+            Body: schema._$body ? ({} as Static<NonNullable<T["$body"]>>) : undefined,
+            Params: schema._$params
+                ? ({} as Static<NonNullable<T["$params"]>>)
+                : undefined,
+            Query: schema._$querystring
+                ? ({} as Static<NonNullable<T["$querystring"]>>)
+                : undefined,
+            Reply: schema._$response
+                ? schema._$response as ({ [K in keyof NonNullable<T["$response"]>]: Static<NonNullable<T["$response"]>[K]> })
+                : undefined,
+        };
+    }
+}

package/source/sdk/throwable.ts

@@ -0,0 +1,101 @@
+import {LBadge, Logger} from "@protorians/logger";
+import {EventBus, EventBusEnum} from "@protorians/events-bus";
+
+/**
+ * Represents a throwable error that extends the built-in JavaScript Error class.
+ * The Throwable class provides utility methods for triggering different levels
+ * of error notifications, including error, warning, and critical errors.
+ *
+ * The class dispatches error notifications via the EventBus and optionally
+ * throws an exception or exits the application depending on the severity level
+ * or the provided parameters.
+ */
+export class Throwable extends Error {
+    constructor(message: string, protected statusCode: number = 500, label?: string) {
+        super(message);
+        this.name = 'Throwable';
+        if (label) Logger.debug(LBadge.debug(label), message);
+        EventBus.dispatch(EventBusEnum.SERVER_THROW, {error: this})
+    }
+
+    /**
+     * Dispatches a system server error event and optionally throws an error.
+     *
+     * @param {string} message - The error message to be dispatched and potentially thrown.
+     * @param {boolean} [soft=true] - Determines whether the error should be thrown. If true, the error is only dispatched. If false, the error is dispatched and then thrown.
+     * @param statusCode
+     * @return {void} This method does not return a value.
+     */
+    static error(message: string, soft: boolean = true, statusCode: number = 500): void {
+        EventBus.dispatch(EventBusEnum.SERVER_ERROR, {message, soft})
+        if (!soft) throw new Throwable(message, statusCode, 'ERR');
+    }
+
+    /**
+     * Emits a system server warning event and optionally throws an error based on the severity of the warning.
+     *
+     * @param {string} message - The warning message to be dispatched and possibly thrown as an error.
+     * @param {boolean} [soft=true] - Determines whether the warning should be treated as non-critical (soft). If false, an error is thrown.
+     * @param statusCode
+     * @return {void} This method does not return a value.
+     */
+    static warning(message: string, soft: boolean = true, statusCode: number = 500): void {
+        EventBus.dispatch(EventBusEnum.SERVER_WARNING, {message, soft})
+        if (!soft) throw new Throwable(message, statusCode, 'WRN');
+    }
+
+    /**
+     * Triggers a critical system event, dispatching an alert message and terminating the process.
+     *
+     * @param {string} message - The critical error message to be dispatched with the event.
+     * @return {void} This method does not return a value as it terminates the process.
+     */
+    static critical(message: string): void {
+        Logger.debug(LBadge.debug('CRITICAL'), message);
+        EventBus.dispatch(EventBusEnum.SERVER_CRITICAL, {message})
+        process.exit(1);
+    }
+}
+
+/**
+ * A function that throws an error with a provided message and a specified error type.
+ *
+ * @param {string} message - The error message to be used when throwing the error.
+ * @param {boolean} [soft=true] - Determines whether the error is categorized as "soft".
+ *                                 If true, it will be treated as a soft error. Defaults to true.
+ * @param statusCode
+ * @returns {void}
+ */
+export const throwError = (message: string, soft: boolean = true, statusCode: number = 500): void => Throwable.error(message, soft, statusCode);
+
+/**
+ * Function to throw an error with a specified message.
+ *
+ * @param {string} message - The error message to be used in the thrown error.
+ * @param statusCode
+ * @throws {Throwable} always throw an error with the provided message.
+ */
+export const throwException = (message: string, statusCode: number = 500): void => throwError(message, false, statusCode);
+
+/**
+ * Emits a warning with the specified message and behavior.
+ *
+ * @param {string} message - The warning message to be displayed.
+ * @param {boolean} [soft=true] - Indicates whether the warning should be soft (true)
+ * or treated as a harder warning (false). Defaults to true.
+ * @param statusCode
+ * @returns {void} This function does not return any value.
+ */
+export const throwWarning = (message: string, soft: boolean = true, statusCode: number = 500): void =>
+    Throwable.warning(message, soft, statusCode);
+
+/**
+ * A variable representing a function that throws a critical error.
+ *
+ * This function is used to trigger a critical error by providing a specific message.
+ * It encapsulates the logic for generating a throwable critical error through the `Throwable.critical` method.
+ *
+ * @param {string} message - The error message describing the critical error to be thrown.
+ * @returns {Throwable} The critical throwable generated with the provided message.
+ */
+export const throwCritical = (message: string): void => Throwable.critical(message);

package/source/sdk/utilities/artifacts.util.ts

@@ -0,0 +1,62 @@
+import path from "node:path";
+import fs from "fs";
+import {LBadge, Logger} from "@protorians/logger";
+import {RaitonDirectories} from "@/core";
+import {Raiton} from "@/core/raiton";
+import {ArtifactFactory} from "@/sdk/artifacts";
+
+
+export function generateArtifacts(
+    artifact: string,
+    interfaceName: string,
+    decoratorSyntax: RegExp,
+    verbose: boolean = false,
+) {
+    const artifacts = RaitonDirectories.artifacts(Raiton.thread.builder.workdir)
+    const dir = Raiton.thread.builder.source;
+    const outputFile = path.join(artifacts, `${artifact}.d.ts`);
+
+    if (!dir) return;
+
+    const files = fs.readdirSync(dir, {recursive: true})
+        .filter(f => [`.ts`, `.js`, `.mjs`, `.cjs`,].some(ext => f.toString().endsWith(ext)))
+        .map(f => f.toString())
+    ;
+
+    let mappings = "";
+    for (const file of files) {
+
+        const filename = path.join(dir, file);
+        const content = fs.readFileSync(filename, "utf-8");
+        const match = content.match(decoratorSyntax);
+
+        if (!match) continue;
+
+        let name = match[3] || match[1] || "";
+        if (!name) {
+            const classMatch = content.match(/export\s+default\s+class\s+([A-Za-z0-9_]+)/);
+            name = classMatch?.[1] || path.parse(filename).name;
+        }
+
+        mappings += `    ${name}: InstanceType<typeof import("@/${file}").default>;\n`;
+
+        if (verbose) Logger.info(LBadge.debug(name), `artifact detected`);
+        ArtifactFactory.add(artifact, {
+            file,
+            dir,
+            relative: file,
+            absolute: filename
+        })
+    }
+
+    const content = `// AUTO-GENERATED FILE — DO NOT EDIT MANUALLY
+declare global {
+  interface ${interfaceName} {
+${mappings} }
+}
+export {};`;
+    fs.writeFileSync(outputFile, content, "utf-8");
+    if (!ArtifactFactory.save(artifact)) Logger.error(`Failed to save artifacts for ${artifact}`);
+}
+
+

package/source/sdk/utilities/controller.util.ts

@@ -0,0 +1,8 @@
+export function isControllerFile(filename: string) {
+    return [
+        filename.endsWith(".controller.ts"),
+        filename.endsWith(".controller.js"),
+        filename.endsWith(".controller.mjs"),
+        filename.endsWith(".controller.cjs"),
+    ].some(Boolean)
+}

package/source/sdk/utilities/parameters-arguments.util.ts

@@ -0,0 +1,61 @@
+// import {Parametrable} from "@/sdk/enums";
+// import {FastifyReply, FastifyRequest} from "fastify";
+// import {RouteParametersMetadataInterface} from "@/types/parameters";
+// // import {MultipartFile} from "@fastify/multipart";
+//
+// export async function parseParametersArguments(
+//     req: FastifyRequest,
+//     res: FastifyReply,
+//     metadata: RouteParametersMetadataInterface[]
+// ): Promise<any[]> {
+//     const args: any[] = [];
+//     const files: AsyncIterableIterator<any> | any[] = ('files' in req && typeof req.files === 'function') ? req.files() : [];
+//
+//     for (const param of metadata) {
+//         switch (param.type) {
+//             // case Parametrable.APP:
+//             //     args[param.index] = req.server as any;
+//             //     break;
+//             case Parametrable.PARAM:
+//                 args[param.index] = param.key ? (req.params as any)[param.key] : req.params;
+//                 break;
+//             case Parametrable.BODY:
+//                 args[param.index] = param.key ? (req.body as any)[param.key] : req.body;
+//                 break;
+//             case Parametrable.QUERY:
+//                 args[param.index] = param.key ? (req.query as any)[param.key] : req.query;
+//                 break;
+//             case Parametrable.HEADER:
+//                 args[param.index] = req.headers[param.key.toLowerCase()] as any;
+//                 break;
+//             case Parametrable.REQ:
+//                 args[param.index] = req as any;
+//                 break;
+//             case Parametrable.REPLY:
+//                 args[param.index] = res as any;
+//                 break;
+//             case Parametrable.UPLOAD_FILE:
+//                 let accumulate: any = param.multiple ? [] : null;
+//                 for await (const part of files) {
+//                     if (param.key === part.fieldname) {
+//                         const packed = {
+//                             filename: part.filename,
+//                             mimetype: part.mimetype,
+//                             encoding: part.encoding,
+//                             toFile: () => part.file,
+//                             toBuffer: async () => await part.toBuffer(),
+//                         }
+//                         accumulate = param.multiple ? [...accumulate, packed] : packed;
+//                     }
+//                 }
+//                 args[param.index] = accumulate as any;
+//                 break;
+//
+//             case Parametrable.CUSTOM:
+//                 args[param.index] = param.callable?.({request: req, reply: res, files}) ?? null;
+//                 break;
+//         }
+//     }
+//
+//     return args;
+// }

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

@@ -0,0 +1,4 @@
+import {type IDynamicProps} from "@protorians/parameters";
+
+
+export type IDataTransferObject<T> = IDynamicProps<T>

package/source/types/hmr.ts

@@ -0,0 +1,39 @@
+export interface HMRMetadataInterface {
+    version: number;
+    timestamp: number;
+    filename: string;
+    size: number;
+}
+
+export interface HmrInterface {
+    entries(): Record<string, HMRMetadataInterface>;
+
+    set(key: string, filename: string, size: number): this;
+
+    get(key: string): HMRMetadataInterface | undefined;
+
+    getKeys(): string[];
+
+    getValues(): Array<HMRMetadataInterface>;
+
+    getEntries(): Array<[string, HMRMetadataInterface]>;
+
+    each(callable: (value: HMRMetadataInterface, key: string, map: Map<string, HMRMetadataInterface>) => void| Promise<void>): Promise<this>
+
+    unset(key: string): this;
+
+    clear(): this;
+
+    load<T>(key: string): Promise<T | undefined>;
+
+    reload<T>(key: string): Promise<T | undefined>;
+
+    has(key: string): boolean;
+
+    upsert<T>(key: string, filename: string, size: number): Promise<T | undefined>;
+
+    size(): number;
+
+    refresh(): Promise<this>;
+
+}

package/source/types/parameters.ts

@@ -0,0 +1,21 @@
+import {Parametrable} from "@/sdk/enums/http-parameters.enum";
+import {FastifyReply, FastifyRequest} from "fastify";
+// import {MultipartFile} from "@fastify/multipart";
+
+
+export interface RouteParametersMetadataPayload {
+    request: FastifyRequest;
+    reply: FastifyReply;
+    files: AsyncIterableIterator<any> | any[]
+}
+
+export type RouteParametersMetadataCallable = (payload: RouteParametersMetadataPayload) => any[];
+
+export interface RouteParametersMetadataInterface {
+    index: number;
+    type: Parametrable;
+    key: string;
+    multiple: boolean;
+    optional: boolean;
+    callable?: RouteParametersMetadataCallable;
+}

package/source/types/payload.ts

@@ -0,0 +1,5 @@
+import {FastifySchema} from "fastify/types/schema";
+
+
+export interface IPayload extends FastifySchema{
+}