raiton 0.0.2 → 1.0.0-alpha.1

package/source/core/injection/injection.ts

@@ -0,0 +1,157 @@
+import "reflect-metadata";
+import type {IConstructor, ContainerDefinitionInterface} from "@/types";
+import {Throwable} from "@/sdk/throwable";
+import {LifetimeEnum, TextUtility} from "@protorians/core";
+import {Logger} from "@protorians/logger";
+import {METADATA_KEYS} from "@/sdk/constants";
+import camelCase = TextUtility.camelCase;
+
+export class Injection {
+
+    protected static _classes: Map<string, ContainerDefinitionInterface> = new Map();
+    protected static _instances: Map<string, Map<any, any>> = new Map();
+    protected static _resolutionStack: string[] = [];
+
+    static get classes(): Map<string, ContainerDefinitionInterface> {
+        return this._classes;
+    }
+
+    static defaultScope = Symbol('default');
+
+    static get instances(): Map<string, Map<any, any>> {
+        return this._instances;
+    }
+
+    static has(name: string): boolean {
+        return this._classes.has(this.normalizeName(name));
+    }
+
+    static clear(): void {
+        this._classes.clear();
+        this._instances.clear();
+    }
+
+    static normalizeName(name: string): string {
+        const stableName = camelCase(name);
+        return stableName[0].toLowerCase() + stableName.slice(1);
+    }
+
+    static registry(
+        name: string,
+        construct: IConstructor,
+        lifetime: LifetimeEnum = LifetimeEnum.SINGLETON,
+        scope?: Symbol
+    ): typeof this {
+        if (!construct.name)
+            throw new Error('Le constructeur doit avoir un nom valide pour être enregistré dans le conteneur.');
+
+        this._classes.set(this.normalizeName(name), {name, construct, lifetime, scope});
+        return this;
+    }
+
+    static resolveArguments(definition: ContainerDefinitionInterface, scope?: any): any[] {
+        try {
+            const parameters = Reflect.getMetadata(METADATA_KEYS.INJECT_PARAMETERS, definition.construct) || [];
+            const designParameters = Reflect.getMetadata('design:paramtypes', definition.construct) || [];
+            const effectiveScope = scope || definition.scope || this.defaultScope;
+
+            const maxLen = Math.max(parameters.length, designParameters.length);
+            const args = [];
+
+            for (let i = 0; i < maxLen; i++) {
+                const param = parameters[i];
+                const designParam = designParameters[i];
+
+                if (param && param !== true) {
+                    const token = typeof param === 'function' ? (param.name || param) : param;
+                    if (typeof token === 'string') {
+                        args.push(this.get(token, effectiveScope));
+                        continue;
+                    }
+                    if (typeof param === 'function') {
+                        const metadata: ContainerDefinitionInterface = Reflect.getMetadata(METADATA_KEYS.CONTAINER, param);
+                        args.push(this.get(metadata?.name || param.name, effectiveScope));
+                        continue;
+                    }
+                }
+
+                if (designParam && typeof designParam === 'function' && designParam.name) {
+                    const metadata: ContainerDefinitionInterface = Reflect.getMetadata(METADATA_KEYS.CONTAINER, designParam);
+                    args.push(this.get(metadata?.name || designParam.name, effectiveScope));
+                    continue;
+                }
+
+                args.push(undefined);
+            }
+            return args;
+        } catch (e) {
+            Logger.error('Resolve', e);
+            return [];
+        }
+    }
+
+    static get<T>(name: string, scope?: Symbol): T | undefined {
+        const name_ = this.normalizeName(name);
+        const cls = this._classes.get(name_);
+        if (!cls) throw new Throwable(`Dependency ${name} not registered`);
+
+        const effectiveScope = scope || cls.scope || this.defaultScope;
+        if (this._resolutionStack.includes(name_)) {
+            throw new Throwable(`Circular dependency detected: ${this._resolutionStack.join(' -> ')} -> ${name}`);
+        }
+
+        this._resolutionStack.push(name_);
+
+        try {
+            let instance: any;
+            if (cls.lifetime === LifetimeEnum.SINGLETON) {
+                if (!this._instances.has(name_)) {
+                    this._instances.set(name_, new Map());
+                }
+                const scopeInstances = this._instances.get(name_)!;
+
+                if (!scopeInstances.has(effectiveScope)) {
+                    instance = new cls.construct(...this.resolveArguments(cls, effectiveScope));
+                    scopeInstances.set(effectiveScope, instance);
+                    this.injectProperties(instance, cls, effectiveScope);
+                }
+                return scopeInstances.get(effectiveScope);
+            }
+
+            if (cls.lifetime === LifetimeEnum.TRANSIENT) {
+                instance = new cls.construct(...this.resolveArguments(cls, effectiveScope));
+                this.injectProperties(instance, cls, effectiveScope);
+                return instance as any;
+            }
+        } finally {
+            this._resolutionStack.pop();
+        }
+
+        return undefined;
+    }
+
+    protected static injectProperties(instance: any, definition: ContainerDefinitionInterface, scope?: any): void {
+        const properties: Map<string | symbol, any> = Reflect.getMetadata(METADATA_KEYS.INJECT_PROPERTIES, definition.construct);
+
+        if (properties) {
+            for (const [propertyKey, type] of properties) {
+                const token = typeof type === 'function' ? (type.name || type) : type;
+                if (typeof token === 'string') {
+                    instance[propertyKey] = this.get(token, scope);
+                } else if (typeof type === 'function') {
+                    const metadata: ContainerDefinitionInterface = Reflect.getMetadata(METADATA_KEYS.CONTAINER, type);
+                    instance[propertyKey] = this.get(metadata?.name || type.name, scope);
+                }
+            }
+        }
+    }
+
+    static resolve<T>(construct: IConstructor<T>): T {
+        const metadata: ContainerDefinitionInterface = Reflect.getMetadata(METADATA_KEYS.CONTAINER, construct);
+
+        if (!metadata)
+            throw new Throwable(`Cannot resolve ${construct.name} as dependency`);
+
+        return this.get(metadata.name) as T;
+    }
+}

package/source/core/middleware/compose.ts

@@ -0,0 +1,40 @@
+import {MiddlewareType} from '@/types'
+import {Throwable} from "@/sdk/throwable";
+
+export function middlewareCompose(middlewares: MiddlewareType[]) {
+    return function (request: any) {
+        let index = -1
+
+        return dispatch(0)
+
+        async function dispatch(i: number): Promise<void> {
+            if (i <= index) {
+                return Promise.reject(
+                    new Throwable('next() called multiple times')
+                )
+            }
+
+            index = i
+            const fn = middlewares[i];
+            try {
+                if (!fn) return Promise.resolve()
+
+                if (typeof fn === 'function') {
+                    return Promise.resolve(fn({context: request, next: () => dispatch(i + 1)}))
+                }
+
+                if (typeof fn === 'object' && 'setup' in fn && typeof fn.setup == 'function') {
+                    if (fn.setup.length === 1) {
+                        await Promise.resolve(fn.setup(request))
+                        return await dispatch(i + 1)
+                    }
+                    return Promise.resolve(fn.setup(request, () => dispatch(i + 1)))
+                }
+
+                return Promise.resolve()
+            } catch (err) {
+                return Promise.reject(err)
+            }
+        }
+    }
+}

package/source/core/middleware/index.ts

@@ -0,0 +1,2 @@
+export * from "./compose"
+export * from "./pipeline"

package/source/core/middleware/pipeline.ts

@@ -0,0 +1,27 @@
+import { MiddlewareType } from '@/types'
+import { middlewareCompose } from '@/core'
+
+export class MiddlewarePipeline {
+  private stack: MiddlewareType[] = []
+
+  use(mw: MiddlewareType): this {
+    this.stack.push(mw)
+    return this;
+  }
+
+  clear(): this {
+    this.stack = []
+    return this;
+  }
+
+  run(ctx: any) {
+    const fn = middlewareCompose(this.stack)
+    return typeof fn == 'function' ? fn(ctx) : undefined;
+  }
+
+  clone() {
+    const pipeline = new MiddlewarePipeline()
+    pipeline.stack = [...this.stack]
+    return pipeline
+  }
+}

package/source/core/plugins/index.ts

@@ -0,0 +1,2 @@
+export * from "./scope"
+export * from "./plugin"

package/source/core/plugins/plugin.ts

@@ -0,0 +1,8 @@
+import { Plugin, PluginFn } from '@/types'
+
+export function definePlugin(
+  setup: PluginFn,
+  name?: string
+): Plugin {
+  return { setup, name }
+}

package/source/core/plugins/scope.ts

@@ -0,0 +1,46 @@
+import {HookStore} from '@/core/hooks'
+import {MiddlewarePipeline} from '@/core/middleware'
+import {Route, Router} from '@/core/router'
+
+export class PluginScope {
+    public hooks: HookStore
+    public middleware: MiddlewarePipeline
+    public router: Router
+
+    constructor(parent?: PluginScope) {
+        this.hooks = parent ? parent.hooks.clone() : new HookStore()
+        this.middleware = parent
+            ? parent.middleware.clone()
+            : new MiddlewarePipeline()
+        this.router = parent ? parent.router : new Router()
+    }
+
+    addHook(name: any, fn: any): this {
+        this.hooks.add(name, fn)
+        return this;
+    }
+
+    use(mw: any): this {
+        if (typeof mw === 'object' && mw !== null && 'setup' in mw && typeof mw.setup === 'function' && mw.setup.length === 1) {
+            mw.setup(this)
+            return this
+        }
+        this.middleware.use(mw)
+        return this;
+    }
+
+    route(
+        method: any,
+        path: string,
+        handler: any,
+        version?: string
+    ): Route {
+        return this.router.add(method, path, handler, version)
+    }
+
+    register(plugin: any): PluginScope {
+        const child = new PluginScope(this)
+        plugin.setup(child)
+        return child
+    }
+}

package/source/core/process.util.ts

@@ -0,0 +1,12 @@
+
+export async function until(condition: () => boolean | Promise<boolean>, interval = 50): Promise<void> {
+  return new Promise<void>((resolve) => {
+    const check = () => {
+      const result = condition();
+      if (result instanceof Promise)
+        result.then((res) => res ? resolve() : setTimeout(check, interval));
+      else ((result) ? resolve() : setTimeout(check, interval))
+    }
+    check();
+  });
+}

package/source/core/raiton.ts

@@ -0,0 +1,21 @@
+import {RaitonSignalMap, ThreadInterface} from "@/types";
+import {ISignalStack, Signal} from "@protorians/core";
+
+
+export class Raiton {
+    protected static _thread: ThreadInterface | undefined;
+
+    static readonly signals: ISignalStack<RaitonSignalMap> = new Signal.Stack<RaitonSignalMap>()
+    static title: string = 'Protorians Raiton';
+    static identifier: string = 'raiton';
+
+    static get thread(): ThreadInterface {
+        if (!this._thread)
+            throw new Error(`${Raiton.title} Thread instance not initialized`);
+        return this._thread;
+    }
+
+    static set thread(thread: ThreadInterface | undefined) {
+        this._thread = this._thread || thread;
+    }
+}

package/source/core/router/handler.ts

@@ -0,0 +1,59 @@
+import {ControllerMetaInterface, MiddlewareCallable, RouteMetaInterface} from "@/types";
+import {Parametrable} from "@/sdk";
+import {Logger} from "@protorians/logger";
+import {Throwable} from "@/sdk/throwable";
+import {middlewareCompose} from "@/core";
+
+export function createHandler(
+    instance: any,
+    routeMeta: RouteMetaInterface,
+    controllerMeta: ControllerMetaInterface,
+) {
+    return async (ctx: any) => {
+        const args: any[] = []
+
+        for (const p of routeMeta.params) {
+
+            switch (p.type) {
+                case Parametrable.QUERY:
+                    args[p.index] =
+                        ctx.req.query?.[p.key!]
+                    break
+                case Parametrable.PARAM:
+                    args[p.index] =
+                        ctx.req.params?.[p.key!] ?? ctx.params?.[p.key!]
+                    break
+                case Parametrable.BODY:
+                    args[p.index] = ctx.req.body
+                    break
+                case Parametrable.HEADER:
+                    args[p.index] = ctx.req.headers[p.key!.toLowerCase()] as any;
+                    break
+                case Parametrable.REQ:
+                    args[p.index] = ctx.req
+                    break
+                case Parametrable.REPLY:
+                    args[p.index] = ctx.REPLY
+                    break
+                case Parametrable.UPLOAD_FILE:
+                    args[p.index] = ctx.req.file
+                    break
+                case Parametrable.CUSTOM:
+                    args[p.index] = p.callable?.(ctx) ?? null;
+                    break;
+            }
+        }
+
+        if (!(routeMeta.propertyKey in instance))
+            throw new Throwable(`${routeMeta.propertyKey} does not exist`)
+
+        const middlewares: MiddlewareCallable[] = [
+            ...controllerMeta.middlewares['@'] || [],
+            ...controllerMeta.middlewares[routeMeta.propertyKey] || []
+        ]
+
+        if (middlewares.length > 0) await middlewareCompose(middlewares)(ctx)
+
+        return instance[routeMeta.propertyKey](...args)
+    }
+}

package/source/core/router/index.ts

@@ -0,0 +1,4 @@
+export * from "./route"
+export * from "./matcher"
+export * from "./router"
+export * from "./handler"

package/source/core/router/matcher.ts

@@ -0,0 +1,51 @@
+import {Route} from '@/core/router'
+
+export class RouteMatcher {
+    protected routes = new Map<string, Route>()
+
+    protected getKey(route: Route): string {
+        return `${route.method}:${route.path}`
+    }
+
+    add(route: Route): this {
+        this.routes.set(this.getKey(route), route)
+        return this;
+    }
+
+    has(route: Route): boolean {
+        return this.routes.has(this.getKey(route))
+    }
+
+    find(route: Route): Route | undefined {
+        return this.routes.get(this.getKey(route))
+    }
+
+    replace(route: Route): this {
+        if (this.has(route)) {
+            this.routes.set(this.getKey(route), route)
+        }
+        return this;
+    }
+
+    upsert(route: Route): this {
+        this.routes.set(this.getKey(route), route)
+        return this
+    }
+
+    remove(route: Route): this {
+        this.routes.delete(this.getKey(route))
+        return this;
+    }
+
+    match(method: string, url: string): Route | null {
+        for (const route of this.routes.values())
+            if (route.match(method, url))
+                return route.extractParams(url)
+        return null
+    }
+
+    clear(): this {
+        this.routes.clear()
+        return this;
+    }
+}

package/source/core/router/route.ts

@@ -0,0 +1,63 @@
+import type {RouteDefinition} from '@/types/router'
+
+export class Route {
+    method: string
+    path: string
+    version?: string
+    handler: RouteDefinition['handler']
+    parameters: Record<string, string> = {}
+
+    constructor(def: RouteDefinition) {
+        this.method = def.method
+        this.path = def.path
+        this.version = def.version
+        this.handler = def.handler
+    }
+
+    get params(): string[] {
+        const fullPath = this.version ? `/${this.version}${this.path}` : this.path
+        const matches = fullPath.match(/:[a-zA-Z0-9_]+/g)
+        return matches ? matches.map(m => m.substring(1)) : []
+    }
+
+    get name(): string {
+        return this.handler.name
+    }
+
+    extractParams(url: string): this {
+        const fullPath = (this.version ? `/${this.version}${this.path}` : this.path)
+            .replace(/\/+$/, '')
+        const paramNames = this.params
+        if (paramNames.length === 0) return this
+
+        const regexPath = fullPath.replace(/:[a-zA-Z0-9_]+/g, '([^/]+)')
+        const regex = new RegExp(`^${regexPath || '/'}/?$`)
+        const matches = url.match(regex)
+
+        if (matches) {
+            const params: Record<string, string> = {}
+            paramNames.forEach((name, index) => {
+                params[name] = matches[index + 1]
+            })
+            this.parameters = params
+        }
+
+        return this
+    }
+
+    match(method: string, url: string): boolean {
+        if (method !== this.method) return false
+
+        const fullPath = (this.version ? `/${this.version}${this.path}` : this.path)
+            .replace(/\/+$/, '')
+        const cleanUrl = url.replace(/\/+$/, '')
+
+        if (!fullPath.includes(':')) {
+            return (fullPath || '/') === (cleanUrl || '/')
+        }
+
+        const regexPath = fullPath.replace(/:[a-zA-Z0-9_]+/g, '([^/]+)')
+        const regex = new RegExp(`^${regexPath || '/'}/?$`)
+        return regex.test(url)
+    }
+}

package/source/core/router/router.ts

@@ -0,0 +1,31 @@
+import {RouteHandler} from '@/types'
+import {HttpMethod} from "@/sdk/enums";
+import {Route} from '@/core/router/route'
+import {RouteMatcher} from '@/core/router/matcher'
+
+export class Router {
+    private matcher = new RouteMatcher()
+
+    add(method: HttpMethod, path: string, handler: RouteHandler, version?: string) {
+        const route = new Route({
+            method,
+            path,
+            handler,
+            version
+        })
+        this.matcher.add(route)
+        return route
+    }
+
+    remove(route: Route) {
+        this.matcher.remove(route)
+    }
+
+    match(method: string, url: string) {
+        return this.matcher.match(method, url)
+    }
+
+    reset() {
+        this.matcher.clear()
+    }
+}

package/source/core/server.ts

@@ -0,0 +1,26 @@
+import type {ServerInterface, ServerOptions} from "@/types";
+
+
+export class Server implements ServerInterface {
+
+    protected static _instance?: Server;
+
+    static get instance(): Server | undefined {
+        return this._instance
+    }
+
+    static set instance(value: Server) {
+        this._instance = this._instance || value;
+    }
+
+    constructor(
+        public readonly options: ServerOptions
+    ) {
+        Server.instance = this;
+    }
+
+    option<K extends keyof ServerOptions>(key: K): ServerOptions[K] {
+        return this.options[key];
+    }
+
+}

package/source/core/thread.ts

@@ -0,0 +1,87 @@
+import type {
+    BuilderInterface,
+    RuntimeAdapterInterface,
+    RuntimeServerInterface,
+    ThreadInterface,
+    ThreadOptions,
+    ThreadSetupOptions,
+    ThreadWaitCallable,
+} from "@/types";
+import {EventMessageEnum, RuntimeType} from "@/sdk/enums";
+import {ProcessUtility} from "@protorians/core";
+import {until} from "./process.util";
+import {ApplicationInterface} from "@/types/application";
+import {Runtime} from "@/sdk/runtime";
+import {LBadge, Logger} from "@protorians/logger";
+import {Throwable} from "@/sdk/throwable";
+import {ControllerBuilder} from "@/core/controller";
+import {bodyParserPlugin} from "@/sdk/plugins/body-parser.plugin";
+
+
+export class RaitonThread implements ThreadInterface {
+
+    protected static instance: RaitonThread | null = null;
+
+    public static get current(): RaitonThread {
+        if (!RaitonThread.instance) throw new Throwable('Thread not initialized')
+        return RaitonThread.instance;
+    }
+
+    public application: ApplicationInterface | null = null;
+    public runtime: RuntimeAdapterInterface | null = null;
+    public runtimeServer: RuntimeServerInterface | null = null;
+
+    readonly appDir: string;
+
+    constructor(
+        public readonly builder: BuilderInterface,
+        protected _options: ThreadOptions = {}
+    ) {
+        this.appDir = process.cwd();
+        RaitonThread.instance = this;
+    }
+
+    public restart(): void {
+        process.send?.(EventMessageEnum.RESTART)
+    }
+
+    public stop(): void {
+        process.exit(0)
+    }
+
+    public async sleep(milliseconds: number): Promise<unknown> {
+        return await ProcessUtility.sleep(milliseconds);
+    }
+
+    public async wait(condition: ThreadWaitCallable): Promise<void> {
+        return await until(condition)
+    }
+
+    public setup({application, runtime}: ThreadSetupOptions): this {
+        const defaultRuntime = typeof Bun !== 'undefined' ? RuntimeType.Bun : RuntimeType.Node;
+        this.runtime = new Runtime(runtime || defaultRuntime);
+        this.application = application;
+        this.application.use(bodyParserPlugin())
+        return this;
+    }
+
+    async run(): Promise<this> {
+
+        if (!this.application)
+            throw new Throwable('Application not defined');
+
+        if (!this.runtime)
+            throw new Throwable('Runtime not defined');
+
+        const port = this.application.config.port || 5712;
+
+        this.runtimeServer = this.runtime.createServer(this.application.handle.bind(this.application))
+
+        await this.runtimeServer.listen(port)
+        if (this.builder.out)
+            await ControllerBuilder.scan(this.builder.out)
+
+        Logger.log(LBadge.info('Server Started'), `http://localhost:${port}`)
+        return this;
+    }
+}

package/source/env.d.ts

@@ -0,0 +1,3 @@
+declare interface IGlobalGrafts{
+
+}

package/source/requirements.ts

@@ -0,0 +1,27 @@
+import dotenv from "dotenv";
+import path from "node:path";
+import {EventBus, EventBusEnum} from "@protorians/events-bus";
+
+dotenv.config({
+    path: path.join(process.cwd(), '.env'),
+    debug: false,
+    quiet: true,
+});
+
+// @ts-ignore
+process.env.RAITON_NATURAL_MODE = !!process[Symbol.for("ts-node.register.instance")];
+
+
+/**
+ * Process Events caching
+ */
+process.on('beforeExit', (code) => EventBus.dispatch(EventBusEnum.SERVER_SHUTDOWN, {code}));
+// process.on('exit', (code) => EventBus.dispatch(EventBusEnum.SYSTEM_SERVER_SHUTDOWN, {code}));
+process.on('SIGINT', (code) => {
+    EventBus.dispatch(EventBusEnum.SERVER_STOPPED, {code})
+    process.exit(1);
+});
+process.on('SIGTERM', (code) => {
+    EventBus.dispatch(EventBusEnum.SERVER_STOPPED, {code})
+    process.exit(1);
+});