raiton 0.0.2 → 1.0.0-alpha.1

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "raiton",
-  "version": "0.0.2",
+  "version": "1.0.0-alpha.1",
   "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",
@@ -13,7 +16,7 @@
     "development",
     "kit",
     "typescript",
-    "node",
+    "bun",
     "backend"
   ],
   "author": "Y. Yannick GOBOU",
@@ -23,36 +26,22 @@
     "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"
+    "commit": "bun semantic-release",
+    "commit:test": "bun 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",
+    "postinstall": "chmod +x source/bin/index.ts",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
     "@protorians/core": "^0.6.13",
@@ -65,9 +54,6 @@
     "bcrypt": "^6.0.0",
     "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": {
@@ -82,7 +68,6 @@
     "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 +77,7 @@
   },
   "compilerOptions": {
     "types": [
-      "node"
+      "bun"
     ]
   },
   "publishConfig": {

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,43 @@
+import {spawn} from 'node:child_process';
+
+const isBunUsed = typeof Bun !== "undefined";
+
+export class CliTools {
+    static get cwd() {
+        return `${process.cwd()}`;
+    }
+
+    static set cwd(value: string) {
+        process.chdir(value)
+    }
+
+    static get argv() {
+        return isBunUsed ? Bun.argv : process.argv;
+    }
+
+    static get process() {
+        return isBunUsed ? Bun : 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 the command is a .ts file, prepend bun
+            if (typeof command === 'string' && command.endsWith('.ts')) {
+                cmdArray.unshift('bun');
+            }
+            return Bun.spawn(cmdArray, options);
+        }
+
+        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)
+        if (cmd.endsWith('.ts')) {
+            return spawn('bun', [cmd, ...args], options);
+        }
+
+        return spawn(cmd, args, 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/index.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env bun
+import "reflect-metadata"
+import bootstrapper from "./bootstrapper";
+import CLI from "./cli";
+
+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} 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 | 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 | 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,115 @@
+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";
+
+export class Application implements ApplicationInterface {
+    private root: PluginScope
+
+    constructor(
+        readonly config: ApplicationConfig
+    ) {
+        this.root = new PluginScope()
+    }
+
+    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 {
+        this.root.route(method, path, 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)
+
+        await this.root.hooks.run('onRequest', ctx)
+
+        const route = this.root.router.match(
+            req.method,
+            new URL(req.url, this.hostname).pathname
+        )
+
+        if (!route) {
+            reply.status(404)
+            return reply.send({error: false, statusCode: 404})
+        }
+
+        const pipeline = this.root.middleware.clone()
+        pipeline.use(async ({context}) => {
+            (context as any).params = route.parameters;
+
+            const responses = await route.handler(context)
+
+            // Logger.debug('Responses', responses)
+            // request.reply.header('Content-Type', 'application/json')
+            context.reply.send(responses)
+        })
+
+        await pipeline.run(ctx)
+        await this.root.hooks.run('onResponse', ctx)
+    }
+}

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 () {
+
+}