raiton 1.0.0-alpha.1 → 1.0.0-alpha.2

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [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.1 (2026-02-16)
 
 

package/README.md

@@ -1,22 +1,99 @@
 # Protorians Raiton
-Protorians Raiton development kit for backend microservice
 
-## Bun Optimization
-Raiton is optimized for Bun. It automatically detects the Bun runtime and uses `Bun.serve` for maximum performance.
+[![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)
 
-### Usage with Bun
-To run your project with Bun:
+**Protorians Raiton** est un kit de développement (SDK) 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**.
+
+## Caractéristiques
+
+- **Optimisé pour Bun** : Utilise `Bun.serve` nativement pour des performances maximales.
+- **Multi-Runtime** : Compatible avec Bun, Node.js, Deno et les environnements Web.
+- **Architecture Décorative** : Utilise les décorateurs TypeScript pour définir contrôleurs, routes et injections.
+- **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.
+
+## Installation
 
 ```bash
-bun run source/bin/index.ts
+bun add raiton reflect-metadata
+# ou
+npm install raiton reflect-metadata
+```
+
+> **Note :** Raiton nécessite `reflect-metadata` pour fonctionner avec les décorateurs. Importez-le au début de votre point d'entrée.
+
+## Démarrage Rapide
+
+### 1. Créez un contrôleur (`source/controllers/hello.controller.ts`)
+
+```typescript
+import { Controllable, Get, Param } from "raiton/sdk";
+
+@Controllable('/hello')
+export class HelloController {
+    @Get('/')
+    index() {
+        return { message: "Bonjour de Raiton !" };
+    }
+
+    @Get('/:name')
+    greet(@Param("name") name?: string) {
+        return { message: `Bonjour, ${name} !` };
+    }
+}
+```
+
+### 2. Configurez votre application (`source/main.ts`)
+
+```typescript
+import "reflect-metadata";
+import {ThreadInterface} from "raiton/types";
+import {Application} from "raiton/core";
+
+export default async function (thread: ThreadInterface) {
+    const app = new Application({
+        port: 3000,
+        prefix: '/api'
+    });
+
+    // Enregistrez vos plugins, middlewares et contrôleurs ici
+    // ...
+
+    // Lier son application au thread
+    return await thread.setup({application: app}).run()
+}
 ```
 
-Or using the provided scripts:
+## Utilisation du CLI
+
+Raiton est livré avec une interface en ligne de commande pour faciliter le développement.
 
 ```bash
-# Development mode with hot reload
-bun run bun:dev
+# Lancer en mode développement (avec hot reload)
+bun raiton develop
+
+# Builder le projet
+bun raiton build
 
-# Start built project
-bun run bun:start
+# Démarrer le projet buildé
+bun raiton start
 ```
+
+## 🛠 Runtimes supportés
+
+Raiton détecte automatiquement l'environnement d'exécution et adapte son serveur :
+
+- **Bun** : Utilisation de `Bun.serve`.
+- **Node.js** : Adaptateur pour serveurs HTTP Node.
+- **Deno** : Support natif de l'environnement Deno.
+- **Web** : Compatible avec les environnements basés sur les standards Web (Fetch API).
+
+## 📄 Licence
+
+Ce projet est sous licence MIT. Voir le fichier [LICENSE](LICENSE) pour plus de détails.
+
+---
+Développé avec ❤️ par **Y. Yannick GOBOU**

package/build/bin/index.mjs

@@ -6720,20 +6720,33 @@ class RaitonCommands {
 }
 // source/bin/cli-tools.ts
 import { spawn } from "node:child_process";
-var isBunUsed = typeof Bun !== "undefined";
+var isBunUsed = typeof globalThis.Bun !== "undefined";
+var isDenoUsed = typeof globalThis.Deno !== "undefined";
 
 class CliTools {
   static get cwd() {
-    return `${process.cwd()}`;
+    return `${isDenoUsed ? globalThis.Deno.cwd() : process.cwd()}`;
   }
   static set cwd(value) {
-    process.chdir(value);
+    if (isDenoUsed) {
+      globalThis.Deno.chdir(value);
+    } else {
+      process.chdir(value);
+    }
   }
   static get argv() {
-    return isBunUsed ? Bun.argv : process.argv;
+    if (isBunUsed)
+      return globalThis.Bun.argv;
+    if (isDenoUsed)
+      return globalThis.Deno.args;
+    return process.argv;
   }
   static get process() {
-    return isBunUsed ? Bun : process;
+    if (isBunUsed)
+      return globalThis.Bun;
+    if (isDenoUsed)
+      return globalThis.Deno;
+    return process;
   }
   static spawn(command2, args = [], options) {
     if (isBunUsed) {
@@ -6746,11 +6759,26 @@ class CliTools {
       }
       return Bun.spawn(cmdArray, options);
     }
+    if (isDenoUsed) {
+      const cmd2 = typeof command2 == "string" ? command2 : command2[0];
+      const cmdArgs2 = typeof command2 == "string" ? args : [...command2.slice(1), ...args];
+      if (cmd2.endsWith(".ts")) {
+        return new Deno.Command("deno", {
+          args: ["run", "-A", cmd2, ...cmdArgs2],
+          ...options
+        }).spawn();
+      }
+      return new Deno.Command(cmd2, {
+        args: cmdArgs2,
+        ...options
+      }).spawn();
+    }
     const cmd = typeof command2 == "string" ? command2 : command2[0];
+    const cmdArgs = typeof command2 == "string" ? args : [...command2.slice(1), ...args];
     if (cmd.endsWith(".ts")) {
-      return spawn("bun", [cmd, ...args], options);
+      return spawn("node", ["--loader", "ts-node/register", cmd, ...cmdArgs], options);
     }
-    return spawn(cmd, args, options);
+    return spawn(cmd, cmdArgs, options);
   }
 }
 
@@ -6780,7 +6808,7 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "1.0.0-alpha.1";
+var version = "1.0.0-alpha.2";
 
 // source/bin/cli.ts
 var CLI = new Command;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "raiton",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.2",
   "private": false,
   "type": "module",
   "description": "Protorians Raiton Development Kit",
@@ -16,7 +16,9 @@
     "development",
     "kit",
     "typescript",
+    "node",
     "bun",
+    "deno",
     "backend"
   ],
   "author": "Y. Yannick GOBOU",

package/source/bin/cli-tools.ts

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