raiton 3.0.1 → 3.1.0

package/source/core/config/config.ts

@@ -1,19 +1,19 @@
 import path from "node:path";
 import fs from "node:fs";
-import {Configurable} from "@/types";
+import {ConfigurableInterface} from "../../types";
 import {Logger} from "@protorians/logger";
-import {Raiton} from "@/core/raiton";
+import {Raiton} from "../raiton";
 
 export class RaitonConfig {
-    static readonly current: Map<keyof Configurable, Configurable[keyof Configurable]> = new Map();
+    static readonly current: Map<keyof ConfigurableInterface, ConfigurableInterface[keyof ConfigurableInterface]> = new Map();
 
     protected static _extensions: string[] = ['.js', '.mjs'];
 
-    static get<K extends keyof Configurable>(key: K): Configurable[K] | undefined {
-        return this.current.get(key) as Configurable[K];
+    static get<K extends keyof ConfigurableInterface>(key: K): ConfigurableInterface[K] | undefined {
+        return this.current.get(key) as ConfigurableInterface[K];
     }
 
-    static defaultConfig: Configurable = {
+    static defaultConfig: ConfigurableInterface = {
         rootDir: '.',
         version: '0.0.1'
     }
@@ -26,7 +26,7 @@ export class RaitonConfig {
                 if (fs.existsSync(configJsonPath)) {
                     const configContent = fs.readFileSync(configJsonPath, 'utf-8');
                     for (const [key, value] of Object.entries({...this.defaultConfig, ...(JSON.parse(configContent) || {})}))
-                        this.current.set(key as keyof Configurable, value as Configurable[keyof Configurable]);
+                        this.current.set(key as keyof ConfigurableInterface, value as ConfigurableInterface[keyof ConfigurableInterface]);
                 } else {
                     for (const ext of this._extensions) {
                         const configPath = path.join(workdir, `${Raiton.identifier}.config${ext}`);
@@ -34,7 +34,7 @@ export class RaitonConfig {
                             const configModule = await import(configPath);
                             const config = await configModule?.default || configModule;
                             for (const [key, value] of Object.entries(config)) {
-                                this.current.set(key as keyof Configurable, value as Configurable[keyof Configurable]);
+                                this.current.set(key as keyof ConfigurableInterface, value as ConfigurableInterface[keyof ConfigurableInterface]);
                             }
                         }
                     }

package/source/core/config/define.ts

@@ -1,11 +1,11 @@
-import {Configurable} from "@/types/config";
-import {JsonUtil} from "@/sdk/utilities";
+import {ConfigurableInterface} from "../../types/config";
+import {JsonUtil} from "../../sdk/utilities";
 
-export async function defineConfig(config?: Configurable) {
+export async function defineConfig(config?: ConfigurableInterface) {
     const workdir = process.cwd();
     const pkg = JsonUtil.import(workdir + '/package.json');
 
-    config = {...config || {}, ...pkg.raitonConfig || {}} as Configurable;
+    config = {...config || {}, ...pkg.raitonConfig || {}} as ConfigurableInterface;
     config.rootDir = config.rootDir || './';
     config.version = config.version || pkg.version || '0.0.1';
 

package/source/core/context.ts

@@ -1,7 +1,7 @@
 import type {
   RuntimeRequestInterface,
   RuntimeReplyInterface
-} from '@/types'
+} from '../types'
 
 export class RequestContext {
   public state: Record<string, any> = {}

package/source/core/controller/builder.ts

@@ -1,10 +1,10 @@
 import fs from "node:fs";
-import {BuilderHMRDeclaration} from "@/types";
+import {BuilderHMRDeclarationInterface} from "../../types";
 import {LBadge, Logger} from "@protorians/logger";
-import {compileController} from "@/core/controller/compiler";
-import {RaitonThread} from "@/core/thread";
-import {Injection} from "@/core/injection";
-import {isControllerArtifact} from "@/sdk";
+import {compileController} from "./compiler";
+import {RaitonThread} from "../thread";
+import {Injection} from "../injection";
+import {isControllerArtifact} from "../../sdk";
 import path from "node:path";
 
 export class ControllerBuilder {
@@ -21,7 +21,7 @@ export class ControllerBuilder {
         return output.filter(f => typeof f !== 'undefined');
     }
 
-    static async build<T>({filename, version, timestamp}: BuilderHMRDeclaration): Promise<T | undefined> {
+    static async build<T>({filename, version, timestamp}: BuilderHMRDeclarationInterface): Promise<T | undefined> {
         if (!isControllerArtifact(filename))
             return undefined;
 

package/source/core/controller/compiler.ts

@@ -1,8 +1,8 @@
-import {ApplicationInterface} from "@/types/application";
-import {getControllerMetadata} from "@/core";
-import {createHandler} from "@/core/router";
-import {Injection} from "@/core/injection";
-import {ControllerMetaInterface} from "@/types";
+import {ApplicationInterface} from "../../types/application";
+import {getControllerMetadata} from "..";
+import {createHandler} from "../router";
+import {Injection} from "../injection";
+import {ControllerMetaInterface} from "../../types";
 
 export function compileController(
     ControllerClass: any,

package/source/core/controller/metadata.ts

@@ -1,5 +1,5 @@
-import {ControllerMetaInterface} from "@/types";
-import {METADATA_KEYS} from "@/sdk";
+import {ControllerMetaInterface} from "../../types";
+import {METADATA_KEYS} from "../../sdk";
 import "reflect-metadata";
 
 export function getControllerMetadata(target: any): ControllerMetaInterface {

package/source/core/directories.ts

@@ -1,6 +1,6 @@
 import path from "node:path";
 import {RaitonConfig} from "./config";
-import {Raiton} from "@/core/raiton";
+import {Raiton} from "./raiton";
 
 
 export class RaitonDirectories {

package/source/core/guards.ts

@@ -0,0 +1,43 @@
+import {GuardDeclaration} from "../types";
+import {Logger} from "@protorians/logger";
+
+export class RaitonGuards {
+    protected static _map: Map<string, GuardDeclaration> = new Map();
+
+    static set(name: string, guard: GuardDeclaration): typeof this {
+        this._map.set(name, guard);
+        return this;
+    }
+
+    static get(name: string): GuardDeclaration | undefined {
+        return this._map.get(name);
+    }
+
+    static remove(name: string): typeof this {
+        this._map.delete(name);
+        return this;
+    }
+
+    static removeAll(): typeof this {
+        Logger.error('Removing all guards');
+        this._map.clear();
+        return this;
+    }
+
+    static enabled(name: string): boolean {
+        const guard = this.get(name);
+        return (!guard) ? false : guard.enabled;
+    }
+
+    static enable(name: string): typeof this {
+        const guard = this.get(name);
+        if(guard) guard.enabled = true;
+        return this;
+    }
+
+    static disable(name: string){
+        const guard = this.get(name);
+        if(guard) guard.enabled = false;
+        return this;
+    }
+}

package/source/core/hooks.ts

@@ -1,15 +1,15 @@
-import {HookName, HookHandler} from '@/types'
+import {HookNameType, HookHandlerCallable} from '../types'
 
 export class HookStore {
-    private hooks = new Map<HookName, HookHandler[]>()
+    private hooks = new Map<HookNameType, HookHandlerCallable[]>()
 
-    add(name: HookName, handler: HookHandler) {
+    add(name: HookNameType, handler: HookHandlerCallable) {
         const list = this.hooks.get(name) ?? []
         list.push(handler)
         this.hooks.set(name, list)
     }
 
-    async run(name: HookName, ctx: any) {
+    async run(name: HookNameType, ctx: any) {
         const list = this.hooks.get(name)
         if (!list) return
 

package/source/core/injection/injection.ts

@@ -1,9 +1,9 @@
 import "reflect-metadata";
-import type {IConstructor, ContainerDefinitionInterface} from "@/types";
+import type {ConstructorType, 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";
+import {METADATA_KEYS} from "../../sdk/constants";
+import {Throwable} from "../../sdk/exceptions";
 
 const camelCase = TextUtility.camelCase;
 
@@ -30,20 +30,21 @@ export class Injection {
     }
 
     static clear(): void {
+        Logger.error('Clearing injection container');
         this._classes.clear();
         this._instances.clear();
         this._dependents.clear();
         this._artifactPaths.clear();
     }
 
-    static normalizeName(name: string): string {
+    protected static normalizeName(name: string): string {
         const stableName = camelCase(name);
         return stableName[0].toLowerCase() + stableName.slice(1);
     }
 
     static registry(
         name: string,
-        construct: IConstructor,
+        construct: ConstructorType,
         lifetime: LifetimeEnum = LifetimeEnum.SINGLETON,
         scope?: Symbol
     ): typeof this {
@@ -54,7 +55,7 @@ export class Injection {
         return this;
     }
 
-    static updateConstruct(name: string, construct: IConstructor): typeof this {
+    static updateConstruct(name: string, construct: ConstructorType): typeof this {
         const name_ = this.normalizeName(name);
         this._classes.set(name_, {...this._classes.get(this.normalizeName(name))!, construct});
         return this;
@@ -208,7 +209,7 @@ export class Injection {
         this.clear();
     }
 
-    static resolve<T>(construct: IConstructor<T>): T {
+    static resolve<T>(construct: ConstructorType<T>): T {
         const metadata: ContainerDefinitionInterface = Reflect.getMetadata(METADATA_KEYS.CONTAINER, construct);
 
         if (!metadata)

package/source/core/middleware/compose.ts

@@ -1,5 +1,5 @@
-import {MiddlewareType} from '@/types'
-import {Throwable} from "@/sdk/exceptions";
+import {MiddlewareType} from '../../types'
+import {Throwable} from "../../sdk/exceptions";
 
 export function middlewareCompose(middlewares: MiddlewareType[]) {
     return function (request: any) {

package/source/core/middleware/pipeline.ts

@@ -1,5 +1,5 @@
-import { MiddlewareType } from '@/types'
-import { middlewareCompose } from '@/core'
+import { MiddlewareType } from '../../types'
+import { middlewareCompose } from '..'
 
 export class MiddlewarePipeline {
   private stack: MiddlewareType[] = []

package/source/core/plugins/plugin.ts

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

package/source/core/plugins/scope.ts

@@ -1,6 +1,6 @@
-import {HookStore} from '@/core/hooks'
-import {MiddlewarePipeline} from '@/core/middleware'
-import {Route, Router} from '@/core/router'
+import {HookStore} from '../hooks'
+import {MiddlewarePipeline} from '../middleware'
+import {Route, Router} from '../router'
 
 export class PluginScope {
     public hooks: HookStore

package/source/core/raiton.ts

@@ -1,11 +1,11 @@
-import {RaitonSignalMap, ThreadInterface} from "@/types";
+import {RaitonSignalMapInterface, 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 readonly signals: ISignalStack<RaitonSignalMapInterface> = new Signal.Stack<RaitonSignalMapInterface>()
     static title: string = 'Protorians Raiton';
     static identifier: string = 'raiton';
 

package/source/core/router/handler.ts

@@ -1,11 +1,11 @@
-import {ControllerMetaInterface, MiddlewareCallable, ParamMetaInterface, RouteMetaInterface} from "@/types";
-import {METADATA_KEYS, Parametrable} from "@/sdk";
+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";
+import {middlewareCompose, Raiton} from "..";
+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,

package/source/core/router/matcher.ts

@@ -1,4 +1,4 @@
-import {Route} from '@/core/router'
+import {Route} from '.'
 
 export class RouteMatcher {
     protected routes = new Map<string, Route>()

package/source/core/router/route.ts

@@ -1,13 +1,13 @@
-import type {RouteDefinition} from '@/types/router'
+import type {RouteDefinitionInterface} from '../../types/router'
 
 export class Route {
     method: string
     path: string
     version?: string
-    handler: RouteDefinition['handler']
+    handler: RouteDefinitionInterface['handler']
     parameters: Record<string, string> = {}
 
-    constructor(def: RouteDefinition) {
+    constructor(def: RouteDefinitionInterface) {
         this.method = def.method
         this.path = def.path
         this.version = def.version

package/source/core/router/router.ts

@@ -1,12 +1,12 @@
-import {RouteHandler} from '@/types'
-import {HttpMethod} from "@/sdk/enums";
-import {Route} from '@/core/router/route'
-import {RouteMatcher} from '@/core/router/matcher'
+import {RouteHandlerCallable} from '../../types'
+import {HttpMethod} from "../../sdk/enums";
+import {Route} from './route'
+import {RouteMatcher} from './matcher'
 
 export class Router {
     private matcher = new RouteMatcher()
 
-    add(method: HttpMethod, path: string, handler: RouteHandler, version?: string) {
+    add(method: HttpMethod, path: string, handler: RouteHandlerCallable, version?: string) {
         const route = new Route({
             method,
             path,

package/source/core/server.ts

@@ -1,4 +1,4 @@
-import type {ServerInterface, ServerOptions} from "@/types";
+import type {ServerInterface, ServerOptionsInterface} from "../types";
 
 
 export class Server implements ServerInterface {
@@ -14,12 +14,12 @@ export class Server implements ServerInterface {
     }
 
     constructor(
-        public readonly options: ServerOptions
+        public readonly options: ServerOptionsInterface
     ) {
         Server.instance = this;
     }
 
-    option<K extends keyof ServerOptions>(key: K): ServerOptions[K] {
+    option<K extends keyof ServerOptionsInterface>(key: K): ServerOptionsInterface[K] {
         return this.options[key];
     }
 

package/source/core/thread.ts

@@ -3,20 +3,20 @@ import type {
     RuntimeAdapterInterface,
     RuntimeServerInterface,
     ThreadInterface,
-    ThreadOptions,
-    ThreadSetupOptions,
+    ThreadOptionsInterface,
+    ThreadSetupOptionsInterface,
     ThreadWaitCallable,
-} from "@/types";
-import {EventMessageEnum, RuntimeType} from "@/sdk/enums";
+} 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 {ApplicationInterface} from "../types/application";
+import {Runtime} from "../sdk/runtime";
 import {LBadge, Logger} from "@protorians/logger";
-import {ControllerBuilder} from "@/core/controller";
-import {bodyParserPlugin} from "@/sdk/plugins/body-parser.plugin";
-import {Injection} from "@/core/injection/injection";
-import {Throwable} from "@/sdk/exceptions";
+import {ControllerBuilder} from "./controller";
+import {bodyParserPlugin} from "../sdk/plugins/body-parser.plugin";
+import {Injection} from "./injection/injection";
+import {Throwable} from "../sdk/exceptions";
 import os from "os";
 
 
@@ -37,7 +37,7 @@ export class RaitonThread implements ThreadInterface {
 
     constructor(
         public readonly builder: BuilderInterface,
-        protected _options: ThreadOptions = {}
+        protected _options: ThreadOptionsInterface = {}
     ) {
         this.appDir = process.cwd();
         RaitonThread.instance = this;
@@ -72,7 +72,7 @@ export class RaitonThread implements ThreadInterface {
         return null;
     }
 
-    public setup({application, runtime}: ThreadSetupOptions): this {
+    public setup({application, runtime}: ThreadSetupOptionsInterface): this {
         const defaultRuntime = typeof Bun !== 'undefined' ? RuntimeType.Bun : RuntimeType.Node;
         this.runtime = new Runtime(runtime || defaultRuntime);
         this.application = application;
@@ -106,7 +106,8 @@ export class RaitonThread implements ThreadInterface {
         await this.runtimeServer.listen(port, hostname)
         if (this.builder.source) await ControllerBuilder.scan(this.builder.source)
 
-        Logger.log(LBadge.info('Server Started'), `http://${displayHostname}:${port}${prefix ?? ''}`)
+        Logger.log(LBadge.info('Local access:'), `http://localhost:${port}${prefix ?? ''}`,)
+        Logger.log(LBadge.info('LAN access:'), `http://${displayHostname}:${port}${prefix ?? ''}`,)
         return this;
     }
 }

package/source/sdk/artifacts.ts

@@ -1,8 +1,8 @@
-import {Injection} from "@/core/injection";
+import {Injection} from "../core/injection";
 import {Logger} from "@protorians/logger";
-import type {IConstructor} from "@/types";
-import {Raiton} from "@/core/raiton";
-import {isArtifact, isControllerArtifact} from "@/sdk/utilities";
+import type {ConstructorType} from "../types";
+import {Raiton} from "../core/raiton";
+import {isArtifact, isControllerArtifact} from "./utilities";
 
 export class Artifacts {
 
@@ -59,7 +59,7 @@ export class Artifacts {
 
             if (typeof name === 'string' && Injection.has(name)) {
                 if (filename) Injection.registerArtifactPath(name, filename);
-                Injection.updateConstruct(name, mod as IConstructor)
+                Injection.updateConstruct(name, mod as ConstructorType)
 
                 const dependents = Injection.getDependents(name);
                 for (const dependent of dependents) {

package/source/sdk/decorators/controllable.decorator.ts

@@ -1,7 +1,7 @@
-import {getControllerMetadata} from "@/core/controller";
-import {Injectable} from "@/sdk";
+import {getControllerMetadata} from "../../core/controller";
+import {Injectable} from "..";
 import {LifetimeEnum} from "@protorians/core";
-import {ControllerDecoratorCallable} from "@/types";
+import {ControllerDecoratorCallable} from "../../types";
 
 export function Controllable(prefix = '') {
     return (target: any) => {

package/source/sdk/decorators/guard.decorator.ts

@@ -0,0 +1,23 @@
+import {GuardOptions} from "../../types";
+import {Middleware} from "./middleware.decorator";
+import {RaitonGuards} from "../../core/guards";
+import {HttpStatus} from "../enums";
+
+export function createGuardDecoration({name, handler}: GuardOptions) {
+    return Middleware(async ({next, context}) => {
+        const guard = RaitonGuards.get(name);
+
+        if (!guard) RaitonGuards.set(name, {name, handler, enabled: true})
+        if (guard && !guard.enabled) return next();
+
+        const response = await handler({context, next})
+
+        if (response) return next()
+
+        context.reply.status(HttpStatus.FORBIDDEN)
+        return context.reply.send({
+            error: true,
+            message: 'Forbidden'
+        });
+    });
+}

package/source/sdk/decorators/index.ts

@@ -2,4 +2,5 @@ export * from "./controllable.decorator"
 export * from "./middleware.decorator"
 export * from "./routable.decorator"
 export * from "./parametrable"
-export * from "./injection.decorator"
+export * from "./injection.decorator"
+export * from "./guard.decorator"

package/source/sdk/decorators/injection.decorator.ts

@@ -1,13 +1,13 @@
 import "reflect-metadata";
-import type {IConstructor} from "@/types/contruct";
-import {Injection} from "@/core/injection";
+import type {ConstructorType} from "../../types/contruct";
+import {Injection} from "../../core/injection";
 import {LifetimeEnum} from "@protorians/core";
 import {Logger} from "@protorians/logger";
-import {METADATA_KEYS} from "@/sdk/constants";
+import {METADATA_KEYS} from "../constants";
 
 
 export function Injectable(lifetime?: LifetimeEnum, name?: string, scope?: any) {
-    return function <T extends IConstructor>(target: T) {
+    return function <T extends ConstructorType>(target: T) {
         const metadata = {
             name: name || target.name,
             construct: target,

package/source/sdk/decorators/middleware.decorator.ts

@@ -1,5 +1,5 @@
-import {MiddlewareCallable} from "@/types";
-import {getControllerMetadata} from "@/core";
+import {MiddlewareCallable} from "../../types";
+import {getControllerMetadata} from "../../core";
 
 
 export function Middleware(middleware: MiddlewareCallable) {

package/source/sdk/decorators/parametrable.ts

@@ -1,8 +1,8 @@
 import "reflect-metadata";
-import type {Context, ParamMetaInterface} from "@/types";
-import {METADATA_KEYS, Parametrable} from "@/sdk";
+import type {ContextInterface, ParamMetaInterface} from "../../types";
+import {METADATA_KEYS, Parametrable} from "..";
 
-function createRouteParametrableDecorator(type: ParamMetaInterface['type'], callable?: (context: Context) => any) {
+function createRouteParametrableDecorator(type: ParamMetaInterface['type'], callable?: (context: ContextInterface) => any) {
     return (key?: string) => {
         return (target: any, propertyKey: string, index: number) => {
             const params = Reflect.getMetadata(METADATA_KEYS.ROUTE_PARAMETERS, target.constructor) || {}

package/source/sdk/decorators/routable.decorator.ts

@@ -1,6 +1,6 @@
-import {getControllerMetadata} from "@/core";
-import {HttpMethod} from "@/sdk";
-import {ControllerMetaInterface, RouteDecoratorCallable, RouteMetaInterface} from "@/types";
+import {getControllerMetadata} from "../../core";
+import {HttpMethod} from "..";
+import {ControllerMetaInterface, RouteDecoratorCallable, RouteMetaInterface} from "../../types";
 
 
 function stabilizeRoute(meta: ControllerMetaInterface, {path, method, propertyKey}: Partial<RouteMetaInterface>) {