raiton 1.1.1 → 3.0.1

package/source/sdk/enums/http-status.enum.ts

@@ -0,0 +1,73 @@
+export enum HttpStatus {
+
+  CONTINUE = 100,
+  SWITCHING_PROTOCOLS = 101,
+  PROCESSING = 102,
+  EARLY_HINTS = 103,
+
+
+  OK = 200,
+  CREATED = 201,
+  ACCEPTED = 202,
+  NON_AUTHORITATIVE_INFORMATION = 203,
+  NO_CONTENT = 204,
+  RESET_CONTENT = 205,
+  PARTIAL_CONTENT = 206,
+  MULTI_STATUS = 207,
+  ALREADY_REPORTED = 208,
+  IM_USED = 226,
+
+
+  MULTIPLE_CHOICES = 300,
+  MOVED_PERMANENTLY = 301,
+  FOUND = 302,
+  SEE_OTHER = 303,
+  NOT_MODIFIED = 304,
+  USE_PROXY = 305,
+  TEMPORARY_REDIRECT = 307,
+  PERMANENT_REDIRECT = 308,
+
+
+  BAD_REQUEST = 400,
+  UNAUTHORIZED = 401,
+  PAYMENT_REQUIRED = 402,
+  FORBIDDEN = 403,
+  NOT_FOUND = 404,
+  METHOD_NOT_ALLOWED = 405,
+  NOT_ACCEPTABLE = 406,
+  PROXY_AUTHENTICATION_REQUIRED = 407,
+  REQUEST_TIMEOUT = 408,
+  CONFLICT = 409,
+  GONE = 410,
+  LENGTH_REQUIRED = 411,
+  PRECONDITION_FAILED = 412,
+  PAYLOAD_TOO_LARGE = 413,
+  URI_TOO_LONG = 414,
+  UNSUPPORTED_MEDIA_TYPE = 415,
+  RANGE_NOT_SATISFIABLE = 416,
+  EXPECTATION_FAILED = 417,
+  IM_A_TEAPOT = 418,
+  MISDIRECTED_REQUEST = 421,
+  UNPROCESSABLE_ENTITY = 422,
+  LOCKED = 423,
+  FAILED_DEPENDENCY = 424,
+  TOO_EARLY = 425,
+  UPGRADE_REQUIRED = 426,
+  PRECONDITION_REQUIRED = 428,
+  TOO_MANY_REQUESTS = 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+  UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+
+
+  INTERNAL_SERVER_ERROR = 500,
+  NOT_IMPLEMENTED = 501,
+  BAD_GATEWAY = 502,
+  SERVICE_UNAVAILABLE = 503,
+  GATEWAY_TIMEOUT = 504,
+  HTTP_VERSION_NOT_SUPPORTED = 505,
+  VARIANT_ALSO_NEGOTIATES = 506,
+  INSUFFICIENT_STORAGE = 507,
+  LOOP_DETECTED = 508,
+  NOT_EXTENDED = 510,
+  NETWORK_AUTHENTICATION_REQUIRED = 511,
+}

package/source/sdk/enums/index.ts

@@ -0,0 +1,7 @@
+export * from "./http-method.enum"
+export * from "./http-parameters.enum"
+export * from "./http-status.enum"
+export * from "./encrypted.enum"
+export * from "./event.message.enum"
+export * from "./timestamp.enum"
+export * from "./runtime.enum"

package/{build/sdk/enums/runtime.enum.d.ts → source/sdk/enums/runtime.enum.ts}

@@ -1,8 +1,6 @@
-declare enum RuntimeType {
+export enum RuntimeType {
     Node = "node",
     Deno = "deno",
     Bun = "bun",
     Web = "web"
-}
-
-export { RuntimeType };
+}

package/{build/sdk/enums/timestamp.enum.d.ts → source/sdk/enums/timestamp.enum.ts}

@@ -1,8 +1,6 @@
-declare enum TimestampEnum {
+export enum TimestampEnum {
     HH_MM_SS = "HH:mm:ss",
     HH_MM_SS_SSS = "HH:mm:ss.SSS",
     DD_MM_YYYY_HH_MM_SS = "DD/MM/YYYY HH:mm:ss",
     DD_MM_YYYY_HH_MM_SS_SSS = "DD/MM/YYYY HH:mm:ss.SSS"
-}
-
-export { TimestampEnum };
+}

package/source/sdk/env.ts

@@ -0,0 +1,40 @@
+import {IGenericValue} from "../types/generic";
+import {getType} from "./utilities";
+
+export function env<T>(key: string, type?: IGenericValue): T | undefined {
+    const value = process.env[key];
+    type = type || getType(value) as IGenericValue;
+
+    if (value) {
+        switch (type) {
+
+            case "bigInt":
+                return BigInt(value) as any;
+
+            case 'float':
+                return parseFloat(value) as any;
+
+            case 'boolean':
+                return Boolean(value) as any;
+
+            case "int":
+                return parseInt(value) as any;
+
+            default:
+                return value as any;
+        }
+    }
+
+    return undefined;
+}
+
+export function envGroup(key: string): Record<string, IGenericValue | undefined> {
+    const filtered = Object.entries(process.env)
+        .filter(([index]) => key.startsWith(index))
+    const gen: Record<string, IGenericValue | undefined> = {}
+
+    for (const [index, value] of filtered)
+        gen[index] = env(value as any, undefined)
+
+    return gen;
+}

package/source/sdk/exceptions/http-exception.ts

@@ -0,0 +1,28 @@
+import {HttpStatus} from "@/sdk/enums/http-status.enum";
+import {Raiton} from "@/core";
+import {HttpResponseBaseInterface} from "@/types";
+
+export class HttpException extends Error {
+
+    constructor(
+        error: string | HttpResponseBaseInterface | Error,
+        public statusCode: HttpStatus = HttpStatus.INTERNAL_SERVER_ERROR,
+    ) {
+        super(typeof error === 'string' ? error : error.message);
+    }
+
+    render() {
+        return {
+            message: this.message,
+            statusCode: this.statusCode,
+            error: true,
+            stack: Raiton.thread?.builder?.options?.development
+                ? this.stack?.split('\n').map(e => e.trim())
+                : undefined
+        }
+    }
+
+    toString() {
+        return `HttpException: ${this.message} with status code ${this.statusCode}`
+    }
+}

package/source/sdk/exceptions/index.ts

@@ -0,0 +1,2 @@
+export * from "./http-exception"
+export * from "./throwable"

package/{build/sdk/throwable.d.ts → source/sdk/exceptions/throwable.ts}

@@ -1,3 +1,6 @@
+import {LBadge, Logger} from "@protorians/logger";
+import {EventBus, EventBusEnum} from "@protorians/events-bus";
+
 /**
  * Represents a throwable error that extends the built-in JavaScript Error class.
  * The Throwable class provides utility methods for triggering different levels
@@ -7,9 +10,14 @@
  * throws an exception or exits the application depending on the severity level
  * or the provided parameters.
  */
-declare class Throwable extends Error {
-    protected statusCode: number;
-    constructor(message: string, statusCode?: number, label?: string);
+export class Throwable extends Error {
+    constructor(message: string, protected statusCode: number = 500, label?: string) {
+        super(message);
+        this.name = 'Throwable';
+        if (label) Logger.debug(LBadge.debug(label), message);
+        EventBus.dispatch(EventBusEnum.SERVER_THROW, {error: this})
+    }
+
     /**
      * Dispatches a system server error event and optionally throws an error.
      *
@@ -18,7 +26,11 @@ declare class Throwable extends Error {
      * @param statusCode
      * @return {void} This method does not return a value.
      */
-    static error(message: string, soft?: boolean, statusCode?: number): void;
+    static error(message: string, soft: boolean = true, statusCode: number = 500): void {
+        EventBus.dispatch(EventBusEnum.SERVER_ERROR, {message, soft})
+        if (!soft) throw new Throwable(message, statusCode, 'ERR');
+    }
+
     /**
      * Emits a system server warning event and optionally throws an error based on the severity of the warning.
      *
@@ -27,15 +39,24 @@ declare class Throwable extends Error {
      * @param statusCode
      * @return {void} This method does not return a value.
      */
-    static warning(message: string, soft?: boolean, statusCode?: number): void;
+    static warning(message: string, soft: boolean = true, statusCode: number = 500): void {
+        EventBus.dispatch(EventBusEnum.SERVER_WARNING, {message, soft})
+        if (!soft) throw new Throwable(message, statusCode, 'WRN');
+    }
+
     /**
      * Triggers a critical system event, dispatching an alert message and terminating the process.
      *
      * @param {string} message - The critical error message to be dispatched with the event.
      * @return {void} This method does not return a value as it terminates the process.
      */
-    static critical(message: string): void;
+    static critical(message: string): void {
+        Logger.debug(LBadge.debug('CRITICAL'), message);
+        EventBus.dispatch(EventBusEnum.SERVER_CRITICAL, {message})
+        process.exit(1);
+    }
 }
+
 /**
  * A function that throws an error with a provided message and a specified error type.
  *
@@ -45,7 +66,8 @@ declare class Throwable extends Error {
  * @param statusCode
  * @returns {void}
  */
-declare const throwError: (message: string, soft?: boolean, statusCode?: number) => void;
+export const throwError = (message: string, soft: boolean = true, statusCode: number = 500): void => Throwable.error(message, soft, statusCode);
+
 /**
  * Function to throw an error with a specified message.
  *
@@ -53,7 +75,8 @@ declare const throwError: (message: string, soft?: boolean, statusCode?: number)
  * @param statusCode
  * @throws {Throwable} always throw an error with the provided message.
  */
-declare const throwException: (message: string, statusCode?: number) => void;
+export const throwException = (message: string, statusCode: number = 500): void => throwError(message, false, statusCode);
+
 /**
  * Emits a warning with the specified message and behavior.
  *
@@ -63,7 +86,9 @@ declare const throwException: (message: string, statusCode?: number) => void;
  * @param statusCode
  * @returns {void} This function does not return any value.
  */
-declare const throwWarning: (message: string, soft?: boolean, statusCode?: number) => void;
+export const throwWarning = (message: string, soft: boolean = true, statusCode: number = 500): void =>
+    Throwable.warning(message, soft, statusCode);
+
 /**
  * A variable representing a function that throws a critical error.
  *
@@ -73,6 +98,4 @@ declare const throwWarning: (message: string, soft?: boolean, statusCode?: numbe
  * @param {string} message - The error message describing the critical error to be thrown.
  * @returns {Throwable} The critical throwable generated with the provided message.
  */
-declare const throwCritical: (message: string) => void;
-
-export { Throwable, throwCritical, throwError, throwException, throwWarning };
+export const throwCritical = (message: string): void => Throwable.critical(message);

package/source/sdk/index.ts

@@ -0,0 +1,14 @@
+export * from "./enums/index"
+export * from "./constants/index"
+export * from "./decorators/index"
+export * from "./responses/index"
+export * from "./plugins/index"
+export * from "./utilities/index"
+export * from "./runtime/index"
+export * from "./exceptions/index"
+export * from "./controllers"
+export * from "./data-transfer-object"
+export * from "./encryption"
+export * from "./parameter-bag"
+export * from "./repositories"
+export * from "./services"

package/source/sdk/parameter-bag.ts

@@ -0,0 +1,55 @@
+import {ParseableEntriesType, ParseablePrimitiveType} from "@/types";
+import {stabilizeJson} from "./utilities";
+import {DynamicParameter, IDynamicParameters, IDynamicProps, IParameter,} from "@protorians/parameters";
+
+
+export class ParameterBag<T extends ParseableEntriesType> {
+
+    protected _bag: IDynamicParameters<any>;
+
+    constructor(data: T) {
+        this._bag = new DynamicParameter(this.initializeData(data));
+    }
+
+    protected initializeData(data: T): any {
+        const prepared = {} as IDynamicProps<T>
+
+        for (const [key, value] of Object.entries(data)) {
+            prepared[key as keyof T] = {
+                value,
+            } as IParameter<T[keyof T]>
+        }
+
+        return prepared
+    }
+
+    get bag(): IDynamicParameters<any> {
+        return this._bag;
+    }
+
+    records(data: T): this {
+        for (const [key, value] of Object.entries(data))
+            this._bag.update(key as keyof T, value);
+        return this;
+    }
+
+    render(): T {
+        return Object.fromEntries(this._bag.stack) as any as T;
+    }
+
+    toString(): string {
+        return JSON.stringify(this.render());
+    }
+
+    static stabilize<T>(json: string | T | null): T {
+        return stabilizeJson<T>(json);
+    }
+
+    static from<T extends IDynamicProps<T>>(data: T): ParameterBag<T> {
+        return new ParameterBag<T>(data);
+    }
+
+    static records<T extends IDynamicProps<T>>(support: ParameterBag<T>, data: ParseablePrimitiveType<T>): ParameterBag<T> {
+        return support.records(this.stabilize(data));
+    }
+}

package/source/sdk/plugins/body-parser.plugin.ts

@@ -0,0 +1,160 @@
+import type {MiddlewareParameters, Plugin} from "@/types";
+import {RequestContext} from "@/core/context";
+import {Logger} from "@protorians/logger";
+import {tryParseJson} from "@/sdk/utilities/json.util";
+
+export function bodyParserPlugin(): Plugin {
+    return {
+        name: 'body-parser-plugin',
+        setup: (scope) => {
+            scope.use(async ({context, next}: MiddlewareParameters) => {
+                const contentType = context.req.headers.get('content-type') || '';
+
+                if (context.req.body && !context.state.bodyParsed) {
+                    try {
+                        const rawBody = await readRawBody(context.req.body);
+                        context.req.body = rawBody as unknown as any;
+                        const bodyString = decode(rawBody);
+
+                        readQueryBody(context);
+                        await readMultipartBody(context, contentType);
+                        readJsonBody(context, contentType, bodyString);
+                        readUrlEncodedBody(context, contentType, bodyString);
+                        readTextBody(context, contentType, bodyString);
+
+                        if (!context.state.bodyParsed) {
+                            context.state.bodyParsed = true;
+                        }
+
+                    } catch (e) {
+                        Logger.error('Error parsing body:', e);
+                    }
+                }
+
+                await next();
+            });
+        }
+    };
+}
+
+function readJsonBody(ctx: RequestContext, contentType: string, body: any) {
+    if (contentType.includes('application/json')) {
+        ctx.req.body = tryParseJson(body) || {} as unknown as any;
+        ctx.state.bodyParsed = true;
+    }
+}
+
+async function readMultipartBody(ctx: RequestContext, contentType: string) {
+    if (contentType.includes('multipart/form-data')) {
+        const body = ctx.req.body;
+
+        try {
+            const tempRequest = new Request(ctx.req.url, {
+                method: ctx.req.method,
+                headers: ctx.req.headers,
+                body: body as any
+            });
+
+            const formData = await tempRequest.formData();
+            const record: Record<string, any> = {};
+            const files: Record<string, any> = {};
+
+            for (const [key, value] of formData.entries()) {
+                const v = value as any;
+                if (v && (v instanceof File)) {
+                    files[key] = {
+                        name: v.name,
+                        type: v.type,
+                        size: v.size,
+                        lastModified: v.lastModified,
+                        buffer: Buffer.from(await v.arrayBuffer())
+                    };
+                } else {
+                    record[key] = value;
+                }
+            }
+
+            ctx.req.body = record;
+            ctx.req.files = files;
+            ctx.req.file = Object.values(files)[0] || null;
+            ctx.state.bodyParsed = true;
+        } catch (e) {
+            Logger.error('Error parsing multipart body:', e);
+        }
+    }
+}
+
+function readUrlEncodedBody(ctx: RequestContext, contentType: string, body: string) {
+    if (contentType.includes('application/x-www-form-urlencoded')) {
+        const params = new URLSearchParams(body);
+        const record: Record<string, any> = {};
+        params.forEach((value, key) => {
+            record[key] = value;
+        });
+        ctx.req.body = record as unknown as any;
+        ctx.state.bodyParsed = true;
+    }
+}
+
+function readTextBody(ctx: RequestContext, contentType: string, body: string) {
+    if (contentType.includes('text/')) {
+        ctx.req.body = body as unknown as any;
+        ctx.state.bodyParsed = true;
+    }
+}
+
+function readQueryBody(ctx: RequestContext) {
+    const searchParams = new URLSearchParams(ctx.req.url.split('?')[1] || '');
+    const record = {} as Record<string, any>;
+    searchParams.forEach((value, key) => record[key] = value);
+    ctx.req.query = record as unknown as any;
+}
+
+async function readRawBody(body: any): Promise<Uint8Array | string> {
+    if (body instanceof ReadableStream) {
+        const reader = body.getReader();
+        const chunks: Uint8Array[] = [];
+        while (true) {
+            const {done, value} = await reader.read();
+            if (done) break;
+            chunks.push(value);
+        }
+        const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return result;
+    }
+
+    if (typeof body === 'object' && body !== null && 'on' in body && typeof body.on === 'function') {
+        return new Promise((resolve, reject) => {
+            const chunks: any[] = [];
+            body.on('data', (chunk: any) => chunks.push(chunk));
+            body.on('end', () => {
+                if (chunks.length > 0 && typeof chunks[0] === 'string') {
+                    resolve(chunks.join(''));
+                } else {
+                    const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+                    const result = new Uint8Array(totalLength);
+                    let offset = 0;
+                    for (const chunk of chunks) {
+                        result.set(new Uint8Array(chunk), offset);
+                        offset += chunk.length;
+                    }
+                    resolve(result);
+                }
+            });
+            body.on('error', reject);
+        });
+    }
+
+    return body;
+}
+
+function decode(data: Uint8Array | string): string {
+    if (typeof data === 'string') return data;
+    return new TextDecoder().decode(data);
+}

package/source/sdk/plugins/index.ts

@@ -0,0 +1,2 @@
+export * from "./body-parser.plugin"
+export * from "./security/index"

package/source/sdk/plugins/security/body-limit.ts

@@ -0,0 +1,19 @@
+import {definePlugin} from "@/core/plugins";
+import {MiddlewareParameters} from "@/types";
+
+
+export const secureBodyLimit = (maxBytes = 1_000_000) =>
+  definePlugin((scope) => {
+    scope.use(async ({context, next}: MiddlewareParameters) => {
+      const len = Number(
+        context.req.headers.get('content-length') ?? 0
+      )
+
+      if (len > maxBytes) {
+        context.reply.status(413)
+        return context.send({ error: 'Payload too large' })
+      }
+
+      await next()
+    })
+  }, 'body-limit')

package/source/sdk/plugins/security/cors.ts

@@ -0,0 +1,44 @@
+import {definePlugin} from "@/core/plugins";
+import {Context, MiddlewareParameters, NextCallable} from "@/types";
+
+export interface CorsOptions {
+    origin?: string | string[]
+    methods?: string[]
+    headers?: string[]
+}
+
+export const secureCors = (opts: CorsOptions = {}) =>
+    definePlugin((scope) => {
+        scope.use(async ({context, next}: MiddlewareParameters) => {
+            const origin = context.req.headers.get('origin')
+
+            if (opts.origin) {
+                const allowed = Array.isArray(opts.origin)
+                    ? opts.origin.includes(origin!)
+                    : opts.origin === origin
+
+                if (allowed) {
+                    context.reply.header('Access-Control-Allow-Origin', origin!)
+                }
+            } else {
+                context.reply.header('Access-Control-Allow-Origin', '*')
+            }
+
+            context.reply.header(
+                'Access-Control-Allow-Methods',
+                (opts.methods ?? ['GET', 'POST', 'PUT', 'DELETE']).join(',')
+            )
+
+            context.reply.header(
+                'Access-Control-Allow-Headers',
+                (opts.headers ?? ['Content-Type', 'Authorization']).join(',')
+            )
+
+            if (context.req.method === 'OPTIONS') {
+                context.reply.status(204)
+                return context.send(null)
+            }
+
+            await next()
+        })
+    }, 'cors')

package/source/sdk/plugins/security/headers.ts

@@ -0,0 +1,14 @@
+import {definePlugin} from "@/core/plugins";
+import {Context, MiddlewareParameters, NextCallable} from "@/types";
+
+
+export const secureHeaders = definePlugin((scope) => {
+  scope.use(async ({context, next}: MiddlewareParameters) => {
+    context.reply.header('X-Content-Type-Options', 'nosniff')
+    context.reply.header('X-Frame-Options', 'DENY')
+    context.reply.header('Referrer-Policy', 'no-referrer')
+    context.reply.header('X-XSS-Protection', '1; mode=block')
+
+    await next()
+  })
+}, 'security-headers')

package/source/sdk/plugins/security/index.ts

@@ -0,0 +1,13 @@
+import {secureHeaders} from './headers'
+import {secureCors} from './cors'
+import {secureRateLimit} from './rate-limit'
+import {secureBodyLimit} from './body-limit'
+import {secureMethodGuard} from './method-guard'
+
+export class Security {
+    static headers = secureHeaders
+    static cors = secureCors
+    static rateLimit = secureRateLimit
+    static bodyLimit = secureBodyLimit
+    static methodGuard = secureMethodGuard
+}

package/source/sdk/plugins/security/method-guard.ts

@@ -0,0 +1,14 @@
+import {definePlugin} from "@/core/plugins";
+import {Context, MiddlewareParameters, NextCallable} from "@/types";
+
+
+export const secureMethodGuard = (allowed: string[]) =>
+  definePlugin((scope) => {
+    scope.use(async ({context, next}: MiddlewareParameters) => {
+      if (!allowed.includes(context.req.method)) {
+        context.reply.status(405)
+        return context.send({ error: 'Method not allowed' })
+      }
+      await next()
+    })
+  }, 'method-guard')

package/source/sdk/plugins/security/rate-limit.ts

@@ -0,0 +1,42 @@
+import {definePlugin} from "@/core/plugins";
+import {Context, MiddlewareParameters, NextCallable} from "@/types";
+
+
+export interface RateLimitOptions {
+    windowMs?: number
+    max?: number
+}
+
+export const secureRateLimit = (
+    opts: RateLimitOptions = {}
+) =>
+    definePlugin((scope) => {
+        const hits = new Map<string, { count: number; ts: number }>()
+
+        const windowMs = opts.windowMs ?? 60_000
+        const max = opts.max ?? 100
+
+        scope.use(async ({context, next}: MiddlewareParameters) => {
+            const ip =
+                context.req.remoteAddress ?? 'unknown'
+            const now = Date.now()
+
+            const entry = hits.get(ip) ?? {count: 0, ts: now}
+
+            if (now - entry.ts > windowMs) {
+                entry.count = 0
+                entry.ts = now
+            }
+
+            entry.count++
+
+            hits.set(ip, entry)
+
+            if (entry.count > max) {
+                context.reply.status(429)
+                return context.send({error: 'Too many requests'})
+            }
+
+            await next()
+        })
+    }, 'rate-limit')