raiton 1.0.0-alpha.4 → 1.0.0-beta.1

package/CHANGELOG.md

@@ -1,20 +1,53 @@
-# [1.0.0-alpha.4](https://github.com/protorians/raiton/compare/v1.0.0-alpha.3...v1.0.0-alpha.4) (2026-02-17)
+# 1.0.0-beta.1 (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))
+* Add `pnpm-lock.yaml` for dependency management ([86dab7e](https://github.com/protorians/raiton/commit/86dab7ee712bcf72024687f59ada9974af9bdbe4))
+* lazy-initialize `_container` in `GraftsRegistry` to optimize resource usage ([2847249](https://github.com/protorians/raiton/commit/2847249a70e08957ae618421bab11e68d126f057))
+* update log method in `BuildCommand`, add `LBadge` for improved log formatting ([63d1126](https://github.com/protorians/raiton/commit/63d11265a65af60e47e07053376c87dd541a5fbb))
 
 
 ### 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))
+* 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 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))
+* 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))
+* 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))
+
+# [1.0.0-alpha.3](https://github.com/protorians/raiton/compare/v1.0.0-alpha.2...v1.0.0-alpha.3) (2026-02-17)
+
+
+### Bug Fixes
+
+* extend `ChildProcess` types to include `ChildProcessWithoutNullStreams` and adjust `Logger` for optional child process PID ([e1e7e17](https://github.com/protorians/raiton/commit/e1e7e17ddd921da5f09cf3240f06a64fddd274f5))
+* refactor runtime detection in `CliTools` and streamline imports in bin files ([b431aa3](https://github.com/protorians/raiton/commit/b431aa31d86e2ef480fbafa8a2cfbb5ae6a4c640))
+* remove unused HMR and artifact modules, refactor thread lifecycle, and optimize artifact initialization in application core ([af88e34](https://github.com/protorians/raiton/commit/af88e341ba8c695b3a9817d450845e25bb004b9e))
+* remove unused SDK modules, rework artifacts handling, and enhance parametrable decorators ([ddc6d35](https://github.com/protorians/raiton/commit/ddc6d35cd070e25f0da19185e776feead0843ad0))
+* remove unused types, streamline imports, and enhance type definitions with Lifecycle interfaces ([5ef2e46](https://github.com/protorians/raiton/commit/5ef2e46ecec191c1e51d79c997ebe2f8244dc7fc))
+
+
+### Features
+
+* add `class-validator` dependency and update README to remove Deno beta references ([a616086](https://github.com/protorians/raiton/commit/a616086652d437d0763d7c8313150c56ee4d11d9))
+* add basic `deno.json` with imports and tasks configuration ([e31b024](https://github.com/protorians/raiton/commit/e31b02414bc4378a7125678fe88268f57367c646))
+* add global runtime detection constants for Bun and Deno in `constants.ts` ([c63ac8e](https://github.com/protorians/raiton/commit/c63ac8e36089e58856c180706c89b51390ae850f))
+* introduce HTTP response handling modules with enums, exceptions, and utilities for streamlined error management and parameterized responses ([e1c5fa3](https://github.com/protorians/raiton/commit/e1c5fa3cc00fd7e7ce61ac44243483c2127f1dfe))
+
+# [1.0.0-alpha.2](https://github.com/protorians/raiton/compare/v1.0.0-alpha.1...v1.0.0-alpha.2) (2026-02-16)
+
+
+### Bug Fixes
+
+* `CliTools`: add support for Deno runtime, improve runtime detection, and adjust spawn logic for `.ts` file handling ([71c506a](https://github.com/protorians/raiton/commit/71c506afcbb4ec3acffec8d4b36934afa8d0b6b3))
 
 # [1.0.0-alpha.3](https://github.com/protorians/raiton/compare/v1.0.0-alpha.2...v1.0.0-alpha.3) (2026-02-17)
 
@@ -35,6 +68,21 @@
 * add global runtime detection constants for Bun and Deno in `constants.ts` ([c63ac8e](https://github.com/protorians/raiton/commit/c63ac8e36089e58856c180706c89b51390ae850f))
 * introduce HTTP response handling modules with enums, exceptions, and utilities for streamlined error management and parameterized responses ([e1c5fa3](https://github.com/protorians/raiton/commit/e1c5fa3cc00fd7e7ce61ac44243483c2127f1dfe))
 
+# [1.0.0-alpha.3](https://github.com/protorians/raiton/compare/v1.0.0-alpha.2...v1.0.0-alpha.3) (2026-02-17)
+
+### Features
+
+* **core:** intégration de `class-validator` pour la validation automatique via les DTO ([a616086](https://github.com/protorians/raiton/commit/a616086))
+* **core:** refonte complète de l'injection de dépendances avec gestion des cycles de vie `onInit`, `onMount`, `onUnmount` ([e90e5fb](https://github.com/protorians/raiton/commit/e90e5fb))
+* **core:** introduction de la gestion des exceptions HTTP et des réponses paramétrables ([e1c5fa3](https://github.com/protorians/raiton/commit/e1c5fa3))
+* **cli:** détection améliorée du runtime et support initial de Deno via `deno.json` ([e31b024](https://github.com/protorians/raiton/commit/e31b024))
+* **ci:** passage à Bun pour les workflows de build et de release
+
+### Bug Fixes
+
+* **core:** correction de la détection du runtime dans `CliTools` ([b431aa3](https://github.com/protorians/raiton/commit/b431aa3))
+* **core:** suppression des modules HMR et artifacts inutilisés pour alléger le noyau ([af88e34](https://github.com/protorians/raiton/commit/af88e34))
+
 # [1.0.0-alpha.2](https://github.com/protorians/raiton/compare/v1.0.0-alpha.1...v1.0.0-alpha.2) (2026-02-16)
 
 

package/README.md

@@ -11,7 +11,9 @@ il offre également un support complet pour **Node.js** et **Deno**.
 
 - **Optimisé pour Bun** : Utilise `Bun.serve` nativement pour des performances maximales.
 - **Multi-Runtime** : Compatible avec Bun (recommandé), Node.js et les environnements Web.
-- **Architecture Décorative** : Utilise les décorateurs TypeScript pour définir contrôleurs, routes et injections.
+- **Architecture Décorative** : Utilise les décorateurs TypeScript pour définir contrôleurs, routes et injections de dépendances.
+- **Validation DTO** : Intégration native de `class-validator` pour la validation des données entrantes.
+- **Cycle de Vie** : Support des hooks `onInit`, `onMount` et `onUnmount` pour les services et contrôleurs.
 - **Modulaire** : Système de plugins et de middlewares flexible.
 - **CLI Puissant** : Outils intégrés pour le développement, le build et le déploiement.
 
@@ -67,22 +69,56 @@ export default async function (thread: ThreadInterface) {
 }
 ```
 
+### 3. Validation avec DTO (`source/dtos/user.dto.ts`)
+
+Raiton intègre `class-validator` pour valider vos données entrantes via des DTOs.
+
+```typescript
+import { DataTransferObject } from "raiton/sdk";
+import { IsString, MinLength } from "class-validator";
+
+export class CreateUserDto extends DataTransferObject {
+    @IsString()
+    @MinLength(3)
+    name: string;
+}
+```
+
+Utilisez-le dans votre contrôleur :
+
+```typescript
+import { Controllable, Post, Body } from "raiton/sdk";
+import { CreateUserDto } from "../dtos/user.dto";
+
+@Controllable('/users')
+export class UserController {
+    @Post('/')
+    create(@Body(CreateUserDto) body: CreateUserDto) {
+        return { message: `Utilisateur ${body.name} créé !` };
+    }
+}
+```
+
 ## Utilisation du CLI
 
 Raiton est livré avec une interface en ligne de commande pour faciliter le développement.
 
+> **Note :** Il est recommandé d'utiliser **Bun** pour une meilleure expérience.
+
 ```bash
 # Lancer en mode développement (avec hot reload)
-bun raiton develop
+raiton develop
 
 # Builder le projet
-bun raiton build
+raiton build
 
 # Démarrer le projet buildé
-bun raiton start
+raiton start
 ```
 
-## Runtimes supportés
+Si `raiton` n'est pas dans votre PATH, utilisez `bun x raiton` ou `npx raiton`.
+
+## 🛠 Runtimes supportés
 
 Raiton détecte automatiquement l'environnement d'exécution et adapte son serveur :
 
@@ -90,7 +126,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.4";
+var version = "1.0.0-beta.1";
 
 // source/bin/cli.ts
 var CLI = new Command;

package/package.json

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

package/source/sdk/responses/http.ts

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

package/source/core/artifacts/artifact.ts

@@ -1,109 +0,0 @@
-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/hmr.ts

@@ -1,106 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,77 +0,0 @@
-// 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

@@ -1,25 +0,0 @@
-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

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

package/source/sdk/fastify.ts

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

package/source/sdk/json.ts

@@ -1,55 +0,0 @@
-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

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

package/source/sdk/responses.ts

@@ -1,31 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,178 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,61 +0,0 @@
-// 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

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

package/source/types/hmr.ts

@@ -1,39 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

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