raiton 1.0.0 → 3.0.0

package/source/core/injection/injection.ts

@@ -0,0 +1,219 @@
+import "reflect-metadata";
+import type {IConstructor, ContainerDefinitionInterface} from "@/types";
+import {LifetimeEnum, TextUtility} from "@protorians/core";
+import {Logger} from "@protorians/logger";
+import {METADATA_KEYS} from "@/sdk/constants";
+import {Throwable} from "@/sdk/exceptions";
+
+const 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[] = [];
+    protected static _dependents: Map<string, Set<string>> = new Map();
+    protected static _artifactPaths: Map<string, string> = new Map();
+
+    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();
+        this._dependents.clear();
+        this._artifactPaths.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 updateConstruct(name: string, construct: IConstructor): typeof this {
+        const name_ = this.normalizeName(name);
+        this._classes.set(name_, {...this._classes.get(this.normalizeName(name))!, construct});
+        return this;
+    }
+
+    static getDependents(name: string): string[] {
+        return Array.from(this._dependents.get(this.normalizeName(name)) || []);
+    }
+
+    static registerArtifactPath(name: string, path: string): typeof this {
+        this._artifactPaths.set(this.normalizeName(name), path);
+        return this;
+    }
+
+    static getArtifactPath(name: string): string | undefined {
+        return this._artifactPaths.get(this.normalizeName(name));
+    }
+
+    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') {
+                        this.addDependent(token, definition.name);
+                        args.push(this.get(token, effectiveScope));
+                        continue;
+                    }
+                    if (typeof param === 'function') {
+                        const metadata: ContainerDefinitionInterface = Reflect.getMetadata(METADATA_KEYS.CONTAINER, param);
+                        const token = metadata?.name || param.name;
+                        this.addDependent(token, definition.name);
+                        args.push(this.get(token, effectiveScope));
+                        continue;
+                    }
+                }
+
+                if (designParam && typeof designParam === 'function' && designParam.name) {
+                    const metadata: ContainerDefinitionInterface = Reflect.getMetadata(METADATA_KEYS.CONTAINER, designParam);
+                    const token = metadata?.name || designParam.name;
+                    this.addDependent(token, definition.name);
+                    args.push(this.get(token, effectiveScope));
+                    continue;
+                }
+
+                args.push(undefined);
+            }
+            return args;
+        } catch (e) {
+            Logger.error('Resolve', e);
+            return [];
+        }
+    }
+
+    protected static addDependent(dependencyName: string, dependentName: string) {
+        const dep = this.normalizeName(dependencyName);
+        if (!this._dependents.has(dep)) {
+            this._dependents.set(dep, new Set());
+        }
+        this._dependents.get(dep)!.add(this.normalizeName(dependentName));
+    }
+
+    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);
+                    this.triggerLifecycle(instance);
+                }
+                return scopeInstances.get(effectiveScope);
+            }
+
+            if (cls.lifetime === LifetimeEnum.TRANSIENT) {
+                instance = new cls.construct(...this.resolveArguments(cls, effectiveScope));
+                this.injectProperties(instance, cls, effectiveScope);
+                this.triggerLifecycle(instance);
+                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') {
+                    this.addDependent(token, definition.name);
+                    instance[propertyKey] = this.get(token, scope);
+                } else if (typeof type === 'function') {
+                    const metadata: ContainerDefinitionInterface = Reflect.getMetadata(METADATA_KEYS.CONTAINER, type);
+                    const token_ = metadata?.name || type.name;
+                    this.addDependent(token_, definition.name);
+                    instance[propertyKey] = this.get(token_, scope);
+                }
+            }
+        }
+    }
+
+    protected static triggerLifecycle(instance: any): void {
+        if (typeof instance.onInit === 'function') {
+            instance.onInit();
+        }
+        if (typeof instance.onMount === 'function') {
+            instance.onMount();
+        }
+    }
+
+    static async shutdown(): Promise<void> {
+        for (const scopeInstances of this._instances.values()) {
+            for (const instance of scopeInstances.values()) {
+                if (typeof instance.onUnmount === 'function') {
+                    await instance.onUnmount();
+                }
+            }
+        }
+        this.clear();
+    }
+
+    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/exceptions";
+
+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,20 @@
+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| undefined {
+        // 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,115 @@
+import {ControllerMetaInterface, MiddlewareCallable, ParamMetaInterface, RouteMetaInterface} from "@/types";
+import {METADATA_KEYS, Parametrable} from "@/sdk";
+import {Logger} from "@protorians/logger";
+import {middlewareCompose, Raiton} from "@/core";
+import {DataTransferObject} from "@/sdk/data-transfer-object";
+import {Throwable} from "@/sdk/exceptions/throwable";
+import {HttpException} from "@/sdk/exceptions";
+import {ThrowableResponse} from "@/sdk/responses/http-throwable";
+
+export function createHandler(
+    instance: any,
+    routeMeta: RouteMetaInterface,
+    controllerMeta: ControllerMetaInterface,
+) {
+    return async (ctx: any) => {
+        const isDevelopment = Raiton.thread?.builder?.options?.development || false;
+        const handlerName = `${instance.constructor.name}.${routeMeta.propertyKey}`
+
+        try {
+            const args: any[] = []
+            const params: ParamMetaInterface[] = Reflect.getMetadata(METADATA_KEYS.ROUTE_PARAMETERS, instance.constructor)?.[routeMeta.propertyKey] || []
+
+            for (const p of 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:
+                        if (p.metatype && 'prototype' in p.metatype) {
+                            ctx.req.body = new p.metatype(ctx.req.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 || ctx.req.files?.[p.key!]
+                        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`)
+
+            /**
+             * Middlewares running order
+             */
+            const middlewares: MiddlewareCallable[] = [
+                ...controllerMeta.middlewares['@'] || [],
+                ...controllerMeta.middlewares[routeMeta.propertyKey] || []
+            ]
+            if (middlewares.length > 0) await middlewareCompose(middlewares)(ctx)
+
+            /**
+             * Vérification des arguments
+             */
+            for (const input of args) {
+                /** DTO validation */
+                if (input instanceof DataTransferObject) {
+                    const errors = await input.validation(false);
+                    if (errors && errors.length) {
+                        const stack = Object.values(errors[0].constraints || {})
+                        throw new Throwable(stack.join(';'), 500)
+                    }
+                }
+            }
+
+            let responses = instance[routeMeta.propertyKey](...args)
+            if (responses instanceof Promise) responses = await responses
+
+            return responses;
+        } catch (err: any) {
+
+            if (!(err instanceof ThrowableResponse)) {
+                Logger.error(`Failed to execute ${handlerName} handler`, err.message ?? err);
+                ctx.reply.status(500)
+            }
+
+            if (err instanceof ThrowableResponse) {
+                ctx.reply.status(err.statusCode || 201)
+            }
+
+            if (err instanceof HttpException || err instanceof ThrowableResponse)
+                return err.render()
+
+            return {
+                statusCode: 500,
+                error: true,
+                message: err.message ?? err,
+                data: null,
+                stack: isDevelopment
+                    ? (typeof err.stack === 'string' ? err.stack.split('\n')
+                        : [String(err.stack || err.toString() || err.message || err.name || 'Unknown error')])
+                        .map((l: any) => typeof l === 'string' ? l.trim() : String(l)) : undefined
+                ,
+            }
+        }
+    }
+}

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];
+    }
+
+}