raiton 1.0.0 → 3.0.0

package/deno.json

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

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "raiton",
-  "version": "1.0.0",
+  "version": "3.0.0",
   "private": false,
   "type": "module",
   "description": "Protorians Raiton Development Kit",
+  "main": "./source/core/index.ts",
+  "module": "./source/core/index.ts",
+  "types": "./source/core/index.d.ts",
   "bin": {
-    "raiton": "build/bin/index.mjs"
+    "raiton": "source/bin/index.ts"
   },
   "keywords": [
     "protorians",
@@ -14,6 +17,8 @@
     "kit",
     "typescript",
     "node",
+    "bun",
+    "deno",
     "backend"
   ],
   "author": "Y. Yannick GOBOU",
@@ -23,36 +28,21 @@
     "url": "git+https://github.com/protorians/raiton.git"
   },
   "exports": {
-    "./core/*": {
-      "types": "./build/core/*.d.ts",
-      "import": "./build/core/*.mjs"
-    },
-    ".": {
-      "types": "./build/core/index.d.ts",
-      "import": "./build/core/index.mjs"
-    },
-    "./commands/*": {
-      "types": "./build/commands/*.d.ts",
-      "import": "./build/commands/*.mjs"
-    },
-    "./sdk/*": {
-      "types": "./build/sdk/*.d.ts",
-      "import": "./build/sdk/*.mjs"
-    },
-    "./sdk": {
-      "types": "./build/sdk/index.d.ts",
-      "import": "./build/sdk/index.mjs"
-    },
-    "./types/*": {
-      "types": "./build/types/index.d.ts",
-      "import": "./build/types/index.mjs"
-    }
+    ".": "./source/core/index.ts",
+    "./core/*": "./source/core/*.ts",
+    "./commands/*": "./source/commands/*.ts",
+    "./sdk": "./source/sdk/index.ts",
+    "./sdk/*": "./source/sdk/*.ts",
+    "./types": "./source/types/index.ts",
+    "./types/*": "./source/types/*.ts"
   },
   "scripts": {
-    "dev": "tsup --watch --config tsup.config.ts",
-    "build": "tsup --config tsup.config.ts",
-    "commit": "pnpx semantic-release",
-    "commit:test": "pnpx semantic-release --dry-run"
+    "dev": "bun run --hot source/bin/index.ts",
+    "start": "bun run build/bin/index.mjs",
+    "build": "bun build source/bin/index.ts --target=node --format=esm --outfile=build/bin/index.mjs",
+    "version": "bun run scripts/update-version.ts",
+    "postinstall": "chmod +x source/bin/index.ts",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
     "@protorians/core": "^0.6.13",
@@ -63,26 +53,15 @@
     "@types/node": "^25.0.3",
     "argon2": "^0.44.0",
     "bcrypt": "^6.0.0",
+    "class-validator": "^0.14.3",
     "commander": "^14.0.2",
     "dotenv": "^17.2.3",
-    "esbuild": "^0.27.1",
-    "fastify": "^5.6.2",
-    "fastify-plugin": "^5.1.0",
     "reflect-metadata": "^0.2.2"
   },
   "devDependencies": {
-    "@semantic-release/changelog": "^6.0.3",
-    "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^12.0.2",
-    "@semantic-release/npm": "^13.1.2",
     "@types/bcrypt": "^6.0.0",
     "@types/bun": "^1.3.5",
     "@types/deno": "^2.5.0",
-    "commitizen": "^4.3.1",
-    "conventional-changelog-conventionalcommits": "^9.1.0",
-    "cz-conventional-changelog": "^3.3.0",
-    "semantic-release": "^25.0.2",
-    "tsup": "^8.3.0",
     "typescript": "^5.9.3"
   },
   "config": {
@@ -92,7 +71,7 @@
   },
   "compilerOptions": {
     "types": [
-      "node"
+      "bun"
     ]
   },
   "publishConfig": {

package/scripts/update-version.ts

@@ -0,0 +1,97 @@
+import { execSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+function getLatestTag() {
+  try {
+    return execSync("git describe --tags --abbrev=0").toString().trim();
+  } catch {
+    return null;
+  }
+}
+
+function getCommitsSince(tag: string | null) {
+  const range = tag ? `${tag}..HEAD` : "HEAD";
+  try {
+    const output = execSync(`git log ${range} --format=%s`).toString().trim();
+    return output ? output.split("\n") : [];
+  } catch {
+    return [];
+  }
+}
+
+function determineIncrement(commits: string[]) {
+  let increment: "major" | "minor" | "patch" | null = null;
+
+  for (let commit of commits) {
+    commit = commit.trim();
+    if (
+        commit.includes("BREAKING CHANGE") ||
+        commit.includes("!") ||
+        commit.toLowerCase().startsWith("release") ||
+        commit.toLowerCase().startsWith("upgrade") ||
+        commit.toLowerCase().startsWith("remove")
+    ) {
+      return "major";
+    }
+    if (
+        commit.startsWith("feat") ||
+        commit.startsWith("add")
+    ) {
+      increment = "minor";
+    } else if (
+        !increment &&
+        commit.startsWith("fix") ||
+        commit.startsWith("update")
+    ) {
+      increment = "patch";
+    }
+  }
+
+  return increment;
+}
+
+function updateVersion(increment: "major" | "minor" | "patch") {
+  const packageJsonPath = path.resolve(process.cwd(), "package.json");
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  const currentVersion = packageJson.version;
+  const [major, minor, patch] = currentVersion.split(".").map(Number);
+
+  let nextVersion = "";
+  if (increment === "major") {
+    nextVersion = `${major + 1}.0.0`;
+  } else if (increment === "minor") {
+    nextVersion = `${major}.${minor + 1}.0`;
+  } else {
+    nextVersion = `${major}.${minor}.${patch + 1}`;
+  }
+
+  packageJson.version = nextVersion;
+  writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+  console.log(`Version updated from ${currentVersion} to ${nextVersion}`);
+  return nextVersion;
+}
+
+function main() {
+  const latestTag = getLatestTag();
+  console.log(`Latest tag: ${latestTag || "None"}`);
+
+  const commits = getCommitsSince(latestTag);
+  console.log(`Commits since last tag: ${commits.length}`);
+
+  if (commits.length === 0) {
+    console.log("No new commits. Skipping version update.");
+    return;
+  }
+
+  const increment = determineIncrement(commits);
+  if (!increment) {
+    console.log("No version-triggering commits found (feat, fix, BREAKING CHANGE). Skipping version update.");
+    return;
+  }
+
+  console.log(`Determined increment: ${increment}`);
+  updateVersion(increment);
+}
+
+main();

package/source/bin/bootstrapper.ts

@@ -0,0 +1,15 @@
+import {Command} from 'commander';
+import {RaitonCommands, RaitonConfig} from "@/core";
+import {getPackageRoot} from "@/sdk";
+import {CliTools} from "@/bin/cli-tools";
+
+
+export default async function bootstrapper(cli: Command) {
+    const appdir = getPackageRoot(import.meta.url);
+    const workdir = `${CliTools.cwd || './'}`;
+    const capabilities = new RaitonCommands(cli, appdir, workdir)
+
+    await RaitonConfig.sync(workdir);
+    await capabilities.harvest();
+    return cli.parse(process.argv)
+}

package/source/bin/cli-tools.ts

@@ -0,0 +1,68 @@
+import {spawn} from 'node:child_process';
+import {isBunUsed, isDenoUsed} from "@/bin/constants";
+
+
+export class CliTools {
+    static get cwd() {
+        return `${isDenoUsed ? (globalThis as any).Deno.cwd() : process.cwd()}`;
+    }
+
+    static set cwd(value: string) {
+        if (isDenoUsed) {
+            (globalThis as any).Deno.chdir(value);
+        } else {
+            process.chdir(value);
+        }
+    }
+
+    static get argv() {
+        if (isBunUsed) return (globalThis as any).Bun.argv;
+        if (isDenoUsed) return (globalThis as any).Deno.args;
+        return process.argv;
+    }
+
+    static get 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>) {
+        if (isBunUsed) {
+            const cmdArray = [
+                ...(typeof command == 'string' ? [command] : (Array.isArray(command) ? command : [])),
+                ...args
+            ];
+            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];
+        const cmdArgs = typeof command == 'string' ? args : [...command.slice(1), ...args];
+
+        if (cmd.endsWith('.ts')) {
+            return spawn('node', ['--loader', 'ts-node/register', cmd, ...cmdArgs], options);
+        }
+
+        return spawn(cmd, cmdArgs, options);
+    }
+}

package/source/bin/cli.ts

@@ -0,0 +1,12 @@
+import {Command} from "commander";
+import {version} from '../../package.json';
+
+
+const CLI = new Command();
+
+CLI
+    .name('raiton')
+    .description('Protorians Raiton development kit for backend microservice')
+    .version(version);
+
+export default CLI;

package/source/bin/constants.ts

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

package/source/bin/index.ts

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

package/source/commands/artifact.command.ts

@@ -0,0 +1,28 @@
+import {RaitonCommand, RaitonBuilder} from "@/core";
+import {Logger} from "@protorians/logger";
+import type {BuildCommandOptions} from "@/types";
+
+
+export default class ArtifactCommand extends RaitonCommand {
+    public readonly name: string = 'artifact';
+    public readonly description: string = 'Manage artifacts';
+
+    public register(): void {
+        this.cli
+            .command(this.name)
+            .alias("art")
+            .description(this.description)
+            .option("--dump, -d", "Dump the application artifacts configured")
+            .option("--create, -c", "Create an artifact")
+            .option("--remove, -r", "Remove an artifact")
+            .option("--clear", "Clear all artifacts")
+            .action(this.run.bind(this));
+    }
+
+    protected async run(options: BuildCommandOptions): Promise<void> {
+
+        Logger.notice("Artifact management is not yet implemented");
+        Logger.debug('Options:', options, '')
+
+    }
+}

package/source/commands/build.command.ts

@@ -0,0 +1,31 @@
+import {RaitonCommand, RaitonBuilder} from "@/core";
+import {LBadge, Logger} from "@protorians/logger";
+import type {BuildCommandOptions} from "@/types";
+
+
+export default class BuildCommand extends RaitonCommand {
+    public readonly name: string = 'build';
+    public readonly description: string = 'Build the application';
+
+    public register(): void {
+        this.cli
+            .command(this.name)
+            .alias("b")
+            .description("Build the application")
+            .option("--develop, -d", "Build in development mode")
+            .option("--bootstrap, -b", "Bootstrap the application")
+            .action(this.run.bind(this));
+    }
+
+    protected async run(options: BuildCommandOptions): Promise<void> {
+        if (options.develop) Logger.warn(LBadge.log("Dev Mode"),);
+
+        const builder = new RaitonBuilder(this.workdir, {
+            development: options.develop
+        });
+
+        await builder.prepare()
+        await builder.boot()
+        // await builder.start(async () => (options.develop || options.bootstrap) ? await builder.boot() : void (0))
+    }
+}

package/source/commands/develop.command.ts

@@ -0,0 +1,47 @@
+import {Raiton, RaitonCommand} from "@/core";
+import {ChildProcess, ChildProcessWithoutNullStreams} from 'node:child_process';
+import {Logger} from "@protorians/logger";
+import {EventMessageEnum} from "@/sdk";
+import {CliTools} from "@/bin/cli-tools";
+import path from "node:path";
+
+export default class DevelopCommand extends RaitonCommand {
+    public readonly name: string = 'develop';
+    public readonly description: string = 'Run the application in development mode';
+
+    private child: Bun.Subprocess<"ignore", "pipe", "inherit"> | ChildProcess | Deno.ChildProcess | ChildProcessWithoutNullStreams | null = null;
+
+    public register(): void {
+        this.cli
+            .command(this.name)
+            .alias("dev")
+            .description("Start the application in development mode")
+            .action(this.run.bind(this));
+    }
+
+    protected async restart(): Promise<void> {
+        Logger.info('Reloading...');
+        console.clear();
+        this.child?.kill('SIGTERM');
+
+        if (this.child && 'on' in this.child)
+            this.child?.on('exit', () => this.run());
+    }
+
+    protected async run(): Promise<void> {
+        // Logger.info('Workdir', this.workdir);
+
+        const entryPoint = path.join(this.appdir, 'bin/index.ts');
+        this.child = CliTools.spawn(entryPoint, ['build', '-d'], {
+            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+            cwd: this.workdir
+        });
+
+        if (this.child && 'on' in this.child)
+            this.child.on('message', (msg) => {
+                if (msg === EventMessageEnum.RESTART) this.restart()
+            });
+
+        Logger.log('PID', this.child?.pid)
+    }
+}

package/source/commands/grafts.command.ts

@@ -0,0 +1,27 @@
+import {RaitonCommand} from "@/core";
+
+
+export default class GraftsCommand extends RaitonCommand {
+
+    public readonly name: string = 'grafts';
+    public readonly description: string = 'Generates typings grafts';
+    public readonly version: string = '0.0.1';
+
+    public register(): void {
+        this.cli
+            .command(this.name)
+            .description("Generates typings grafts")
+            .action(this.generates.bind(this))
+    }
+
+    protected async generates(): Promise<void> {
+        console.log("Running grafts generator command");
+        // generateArtifacts(
+        //     "graft",
+        //     "IGlobalGrafts",
+        //     /@Graftable\(\s*(?:([A-Za-z0-9_.]+)\s*,\s*)?(?:(["'`])(.*?)\2)?\s*\)/,
+        //     true,
+        // )
+    }
+
+}

package/source/commands/start.command.ts

@@ -0,0 +1,28 @@
+import {RaitonCommand} from "@/core";
+import {ChildProcess} from 'node:child_process';
+import {Raiton} from "@/core/raiton";
+import {CliTools} from "@/bin/cli-tools";
+import path from "node:path";
+
+export default class StartCommand extends RaitonCommand {
+    public readonly name: string = 'start';
+    public readonly description: string = 'Run the application in production mode';
+
+    private child:  Bun.Subprocess<"ignore", "pipe", "inherit"> | ChildProcess | Deno.ChildProcess | null = null;
+
+    public register(): void {
+        this.cli
+            .command(this.name)
+            .alias("run")
+            .description("Start the application in production mode")
+            .action(this.run.bind(this));
+    }
+
+    protected async run(): Promise<void> {
+        const entryPoint = path.join(this.appdir, 'bin/index.ts');
+        this.child = CliTools.spawn(entryPoint, ['build', '--bootstrap'], {
+            stdio: 'inherit',
+            cwd: this.workdir
+        });
+    }
+}

package/source/core/application.ts

@@ -0,0 +1,163 @@
+import {PluginScope} from '@/core/plugins/scope'
+import {RequestContext} from './context'
+import {ApplicationConfig, ApplicationInterface} from "@/types/application";
+import {HttpMethod} from "@/sdk";
+import {RouteHandler} from "@/types";
+import {Logger} from "@protorians/logger";
+import {RaitonConfig} from "@/core/config";
+import {Artifacts} from "@/sdk/artifacts";
+
+export class Application implements ApplicationInterface {
+    private root: PluginScope
+
+    constructor(
+        readonly config: ApplicationConfig
+    ) {
+        this.root = new PluginScope()
+        if (this.config.workdir) {
+            process.chdir(this.config.workdir)
+        }
+        this.initialize()
+    }
+
+    protected initialize(): this {
+        const artifacts = RaitonConfig.get('artifacts')
+        const artifactTypes = [...artifacts?.types || [], ...Artifacts.defaultTypes]
+
+        Artifacts.registerMany(...artifactTypes)
+        return this;
+    }
+
+    public get hostname(): string {
+        return `${
+            this.config.protocole || 'http'
+        }://${
+            this.config.hostname || 'localhost'
+        }${
+            this.config.port ? `:${this.config.port}` : ''
+        }${
+            this.config.pathname || '/'
+        }`
+    }
+
+    public setOption<K extends keyof ApplicationConfig>(key: K, value: ApplicationConfig[K]): this {
+        this.config[key] = value;
+        return this;
+    }
+
+    public setOptions(options: ApplicationConfig): this {
+        Object.assign(this.config, options);
+        return this;
+    }
+
+    register(plugin: any): this {
+        this.root.register(plugin)
+        return this
+    }
+
+    use(mw: any): this {
+        this.root.use(mw)
+        return this
+    }
+
+    route(method: HttpMethod, path: string, handler: RouteHandler, version?: string): this {
+        const prefix = this.config.prefix ?? ''
+        const fullPath = `${prefix}${path}`.replace(/\/+/g, '/') || '/'
+        this.root.route(method, fullPath, handler, version)
+        return this
+    }
+
+    get(path: string, handler: RouteHandler, version?: string): this {
+        return this.route(HttpMethod.GET, path, handler, version)
+    }
+
+    post(path: string, handler: RouteHandler, version?: string): this {
+        return this.route(HttpMethod.POST, path, handler, version)
+    }
+
+    patch(path: string, handler: RouteHandler, version?: string): this {
+        return this.route(HttpMethod.PATCH, path, handler, version)
+    }
+
+    put(path: string, handler: RouteHandler, version?: string): this {
+        return this.route(HttpMethod.PUT, path, handler, version)
+    }
+
+    delete(path: string, handler: RouteHandler, version?: string): this {
+        return this.route(HttpMethod.DELETE, path, handler, version)
+    }
+
+    options(path: string, handler: RouteHandler, version?: string): this {
+        return this.route(HttpMethod.OPTIONS, path, handler, version)
+    }
+
+    head(path: string, handler: RouteHandler, version?: string): this {
+        return this.route(HttpMethod.HEAD, path, handler, version)
+    }
+
+    trace(path: string, handler: RouteHandler, version?: string): this {
+        return this.route(HttpMethod.TRACE, path, handler, version)
+    }
+
+    async handle(req: any, reply: any): Promise<any> {
+        const ctx = new RequestContext(req, reply)
+
+        if (this.config.verbose) {
+            Logger.info(
+                `Incoming request: ${req.method} ${req.url}`
+            )
+        }
+
+        await this.root.hooks.run('onRequest', ctx)
+
+        const url = new URL(req.url, this.hostname)
+        let pathname = url.pathname
+
+        if (this.config.pathname && this.config.pathname !== '/') {
+            const appPathname = this.config.pathname.endsWith('/') ? this.config.pathname : `${this.config.pathname}/`
+            if (pathname.startsWith(appPathname)) {
+                pathname = pathname.substring(appPathname.length - 1) || '/'
+            } else if (pathname === this.config.pathname) {
+                pathname = '/'
+            } else {
+                // Requête hors du pathname de l'application
+                if (this.config.verbose) {
+                    Logger.warn(`Request out of application pathname: ${pathname} (expected prefix: ${this.config.pathname})`)
+                }
+                reply.status(404)
+                return reply.send({error: false, statusCode: 404})
+            }
+        }
+
+        const route = this.root.router.match(
+            req.method,
+            pathname
+        )
+
+        if (!route) {
+            if (this.config.verbose) {
+                Logger.warn(`Route not found: ${req.method} ${pathname}`)
+            }
+            reply.status(404)
+            return reply.send({error: false, statusCode: 404})
+        }
+
+        const pipeline = this.root.middleware.clone()
+        pipeline.use(async ({context}) => {
+            try {
+                (context as any).params = route.parameters;
+                let responses = await route.handler(context)
+
+                context.reply.send(responses)
+            } catch (e: any) {
+                Logger.error('Failed to handle request', e.message ?? e)
+                if (this.config.develop) {
+                    console.error(e)
+                }
+            }
+        })
+
+        await pipeline.run(ctx)
+        await this.root.hooks.run('onResponse', ctx)
+    }
+}