raiton 1.0.0-alpha.2 → 1.0.0-alpha.4

package/source/sdk/exceptions/throwable.ts

@@ -0,0 +1,101 @@
+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
+ * of error notifications, including error, warning, and critical errors.
+ *
+ * The class dispatches error notifications via the EventBus and optionally
+ * throws an exception or exits the application depending on the severity level
+ * or the provided parameters.
+ */
+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.
+     *
+     * @param {string} message - The error message to be dispatched and potentially thrown.
+     * @param {boolean} [soft=true] - Determines whether the error should be thrown. If true, the error is only dispatched. If false, the error is dispatched and then thrown.
+     * @param statusCode
+     * @return {void} This method does not return a value.
+     */
+    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.
+     *
+     * @param {string} message - The warning message to be dispatched and possibly thrown as an error.
+     * @param {boolean} [soft=true] - Determines whether the warning should be treated as non-critical (soft). If false, an error is thrown.
+     * @param statusCode
+     * @return {void} This method does not return a value.
+     */
+    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 {
+        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.
+ *
+ * @param {string} message - The error message to be used when throwing the error.
+ * @param {boolean} [soft=true] - Determines whether the error is categorized as "soft".
+ *                                 If true, it will be treated as a soft error. Defaults to true.
+ * @param statusCode
+ * @returns {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.
+ *
+ * @param {string} message - The error message to be used in the thrown error.
+ * @param statusCode
+ * @throws {Throwable} always throw an error with the provided message.
+ */
+export const throwException = (message: string, statusCode: number = 500): void => throwError(message, false, statusCode);
+
+/**
+ * Emits a warning with the specified message and behavior.
+ *
+ * @param {string} message - The warning message to be displayed.
+ * @param {boolean} [soft=true] - Indicates whether the warning should be soft (true)
+ * or treated as a harder warning (false). Defaults to true.
+ * @param statusCode
+ * @returns {void} This function does not return any value.
+ */
+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.
+ *
+ * This function is used to trigger a critical error by providing a specific message.
+ * It encapsulates the logic for generating a throwable critical error through the `Throwable.critical` method.
+ *
+ * @param {string} message - The error message describing the critical error to be thrown.
+ * @returns {Throwable} The critical throwable generated with the provided message.
+ */
+export const throwCritical = (message: string): void => Throwable.critical(message);

package/source/sdk/fastify.ts

@@ -0,0 +1,5 @@
+import * as fastifyCore from 'fastify'
+import fastifyPlugin from 'fastify-plugin'
+
+export const FastifyPlugin = fastifyPlugin;
+export default {...fastifyCore};

package/source/sdk/index.ts

@@ -1,6 +1,13 @@
 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 "./controllers"
+export * from "./data-transfer-object"
+export * from "./encryption"
+export * from "./parameter-bag"
+export * from "./repositories"
+export * from "./services"

package/source/sdk/json.ts

@@ -1,12 +1,12 @@
-import {ParseableEntriesType, ParseablePrimitiveType} from "../types/parseable";
+import {IParseableEntries, IParseablePrimitiveEntry} from "../types/parseable";
 import {stabilizeJson} from "./utilities";
 
 
-export class Json<T extends ParseableEntriesType> {
+export class Json<T extends IParseableEntries> {
 
     public readonly stack: Map<keyof T, T[keyof T]> = new Map();
 
-    constructor(json: ParseablePrimitiveType<T>) {
+    constructor(json: IParseablePrimitiveEntry<T>) {
         this.records(stabilizeJson<T>(json));
     }
 
@@ -43,13 +43,13 @@ export class Json<T extends ParseableEntriesType> {
         return stabilizeJson<T>(json);
     }
 
-    static from<T extends ParseableEntriesType>(data: T): Json<T> {
+    static from<T extends IParseableEntries>(data: T): Json<T> {
         const json = new Json<T>(null);
         json.records(data);
         return json;
     }
 
-    static records<T extends ParseableEntriesType>(support: Json<T>, data: ParseablePrimitiveType<T>): Json<T> {
+    static records<T extends IParseableEntries>(support: Json<T>, data: IParseablePrimitiveEntry<T>): Json<T> {
         return support.records(this.stabilize(data));
     }
 }

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/repositories.ts

@@ -1,4 +1,4 @@
-import {Throwable} from "./throwable";
+import {Throwable} from "@/sdk/exceptions";
 
 
 export class DelegateRepository {

package/source/sdk/responses/error.ts

@@ -0,0 +1,52 @@
+import type {ErrorResponseInterface} from "@/types";
+import {HttpResponse} from "@/sdk/responses/http";
+
+
+export class HttpErrorResponse {
+    public readonly stack: Map<string, ErrorResponseInterface> = new Map();
+
+    public get entries(): ErrorResponseInterface[] {
+        return [...this.stack.values()];
+    }
+
+    public add(input: ErrorResponseInterface): this {
+        this.stack.set(input.id, input)
+        return this;
+    }
+
+    public remove(id: string): this {
+        this.stack.delete(id);
+        return this;
+    }
+
+    public get(id: string): ErrorResponseInterface | undefined {
+        return this.stack.get(id);
+    }
+
+    public has(id: string): boolean {
+        return this.stack.has(id);
+    }
+
+    public clear(): this {
+        this.stack.clear();
+        return this;
+    }
+
+    public get empty(): boolean {
+        return this.stack.size === 0;
+    }
+
+    public get existence(): number {
+        return this.stack.size
+    }
+
+    public push() {
+        const first = this.stack.values().next().value;
+        HttpResponse.push({
+            statusCode: 500,
+            message: first?.message || 'Internal server error',
+            error: true,
+            errorStack: this.entries
+        })
+    }
+}

package/source/sdk/responses/helpers.ts

@@ -0,0 +1,28 @@
+import {HttpResponse, HttpStatus} from "@/sdk";
+import {HttpResponseInterface} from "@/types";
+import {Raiton} from "@/core";
+
+
+export function RaitonResponses(
+    message: string,
+    data: HttpResponseInterface,
+    statusCode: HttpStatus,
+    metadata?: Omit<HttpResponseInterface<any>, 'data' | 'message' | 'statusCode'>
+) {
+
+    if (metadata) {
+        metadata.error = typeof data.error === 'boolean' ? data.error : false
+        metadata.errorStack = (metadata.errorStack instanceof Error)
+            ? metadata.errorStack
+            : (Raiton.thread?.builder?.options?.development
+                ? (Array.isArray(metadata.errorStack) ? metadata.errorStack : [])
+                : undefined)
+    }
+
+    return {
+        ...metadata,
+        statusCode,
+        message,
+        data,
+    }
+}

package/source/sdk/responses/http-throwable.ts

@@ -0,0 +1,28 @@
+import {HttpResponseInterface} from "@/types";
+import {HttpStatus} from "@/sdk/enums";
+import {Raiton} from "@/core";
+
+
+export class ThrowableResponse extends Error {
+    constructor(
+        public input: string | HttpResponseInterface,
+        public statusCode: HttpStatus = HttpStatus.INTERNAL_SERVER_ERROR,
+    ) {
+        super(typeof input === 'string' ? input : input.message);
+    }
+
+    render() {
+        const stack = typeof this.input === 'object' ? this.input.errorStack : undefined
+        return {
+            message: this.message,
+            statusCode: this.statusCode,
+            data: (typeof this.input === 'object') ? this.input.data : undefined,
+            error: (typeof this.input === 'object') ? this.input.error : false,
+            stack: stack instanceof Error ?
+                (Raiton.thread?.builder?.options?.development
+                    ? this.stack?.split('\n').map(e => e.trim())
+                    : undefined)
+                : stack
+        }
+    }
+}

package/source/sdk/responses/http.ts

@@ -0,0 +1,48 @@
+import {HttpResponseInterface} from "@/types";
+import {HttpStatus} from "@/sdk/enums";
+import {ThrowableResponse} from "@/sdk";
+
+
+export class HttpResponse {
+    public static push(response: Partial<HttpResponseInterface>): void {
+        throw new ThrowableResponse({
+            statusCode: response.statusCode || HttpStatus.BAD_REQUEST,
+            message: response.message || 'No response message provided',
+            data: response.data,
+            error: response.error,
+            errorStack: response.errorStack
+        })
+    }
+
+    constructor(public readonly response: HttpResponseInterface) {
+    }
+
+    status(statusCode: HttpStatus): this {
+        this.response.statusCode = statusCode;
+        return this;
+    }
+
+    message(message: string) {
+        this.response.message = message;
+        return this;
+    }
+
+    data(data: any) {
+        this.response.data = data;
+        return this;
+    }
+
+    error(error: boolean) {
+        this.response.error = error;
+        return this;
+    }
+
+    stack(stack: Error) {
+        this.response.errorStack = stack
+        return this;
+    }
+
+    render(): HttpResponseInterface {
+        return (new ThrowableResponse({...this.response})).render()
+    }
+}

package/source/sdk/responses/index.ts

@@ -0,0 +1,4 @@
+export * from "./error"
+export * from "./http-throwable"
+export * from "./http"
+export * from "./helpers"

package/source/sdk/responses.ts

@@ -1,7 +1,6 @@
-import type {IHttpResponse, ParseableType, ResponseParameters} from "@/types";
-import {RequestContext} from "@/core/context";
+import type {IHttpResponse, IParseableEntry} from "@/types";
 
-export function httpResponse<T extends ParseableType>(
+export function httpResponse<T extends IParseableEntry>(
     statusCode: number,
     message?: string,
     data?: T,
@@ -15,7 +14,7 @@ export function httpResponse<T extends ParseableType>(
     }
 }
 
-export function successResponse<T extends ParseableType>(
+export function successResponse<T extends IParseableEntry>(
     message?: string,
     data?: T,
     error?: any,
@@ -23,23 +22,10 @@ export function successResponse<T extends ParseableType>(
     return httpResponse<T>(200, message, data, error);
 }
 
-export function errorResponse<T extends ParseableType>(
+export function errorResponse<T extends IParseableEntry>(
     message?: string,
     data?: T,
     error?: any,
 ): IHttpResponse<T> {
     return httpResponse<T>(500, message, data, error);
 }
-
-
-export class RaitonResponse {
-    constructor(
-        public readonly parameters: ResponseParameters,
-        public readonly context: RequestContext,
-    ) {
-    }
-
-    parse(){
-
-    }
-}

package/source/sdk/routes.ts

@@ -0,0 +1,21 @@
+import path from "node:path";
+import * as fs from "node:fs";
+import {FastifyInstance} from "fastify";
+import {aliasPath} from "./utilities";
+
+
+export async function registryRoutes(app: FastifyInstance) {
+    const dir = aliasPath('@/routes');
+    if (!dir || !fs.existsSync(dir)) return app;
+
+    const files = fs.readdirSync(dir);
+
+    for (const file of files) {
+        if (file.endsWith(".route.ts")) {
+            const route = await import(path.join(dir, file));
+            route.default(app);
+        }
+    }
+
+    return app;
+}

package/source/sdk/runtime/bun/server.ts

@@ -9,9 +9,10 @@ export const bunRuntime: RuntimeAdapterInterface = {
         let server: any
 
         return {
-            async listen(port) {
+            async listen(port, hostname) {
                 server = Bun.serve({
                     port,
+                    hostname,
                     fetch: async (request: Request) => {
                         let responseBody: any
                         let statusCode = 200

package/source/sdk/runtime/deno/server.ts

@@ -5,13 +5,13 @@ export const denoRuntime: RuntimeAdapterInterface = {
         let controller: AbortController
 
         return {
-            async listen(port) {
+            async listen(port, hostname) {
                 if (typeof Deno === 'undefined') throw new Error(
                     'Deno is not installed, please run `deno install -A -f --unstable https://deno.land/x/raiton/cli.ts`'
                 )
 
                 controller = new AbortController()
-                Deno.serve({port, signal: controller.signal}, async (req: any) => {
+                Deno.serve({port, hostname, signal: controller.signal}, async (req: any) => {
                     let body: any
                     let status = 200
                     const headers = new Headers()

package/source/sdk/runtime/node/server.ts

@@ -45,9 +45,9 @@ export const nodeRuntime: RuntimeAdapterInterface = {
         })
 
         return {
-            listen(port) {
+            listen(port, hostname) {
                 return new Promise((resolve) =>
-                    server.listen(port, resolve)
+                    server.listen(port, hostname, resolve)
                 )
             },
             close() {

package/source/sdk/schemes.ts

@@ -25,7 +25,7 @@ export type SchematicCast<T> = T extends Scheme<any, any, any, any>
 
 /**
  * Represents a schema configuration that can be used with type-safe operations
- * and is compatible with route options.
+ * and is compatible with fastify route options.
  *
  * @template TBody - Optional schema type for the request body.
  * @template TParams - Optional schema type for the route parameters.

package/source/sdk/utilities/artifact.util.ts

@@ -0,0 +1,18 @@
+export function isControllerArtifact(filename: string) {
+    return isArtifact(filename, 'controller')
+}
+
+
+export function isServiceArtifact(filename: string) {
+    return isArtifact(filename, 'service')
+}
+
+export function isArtifact(filename: string, artifact: string) {
+    return [
+        filename.endsWith(`.${artifact}.ts`),
+        filename.endsWith(`.${artifact}.js`),
+        filename.endsWith(`.${artifact}.mjs`),
+        filename.endsWith(`.${artifact}.cjs`),
+    ].some(Boolean)
+}
+

package/source/sdk/utilities/index.ts

@@ -1,7 +1,5 @@
-// export * from "./alias-path.util"
-export * from "./artifacts.util"
 export * from "./callable.util"
 export * from "./utilities.util"
-export * from "./controller.util"
+export * from "./artifact.util"
 export * from "./json.util"
 export * from "./path.util"

package/source/sdk/utilities/parameters-arguments.util.ts

@@ -0,0 +1,61 @@
+// import {Parametrable} from "@/sdk/enums";
+// import {FastifyReply, FastifyRequest} from "fastify";
+// import {RouteParametersMetadataInterface} from "@/types/parameters";
+// // import {MultipartFile} from "@fastify/multipart";
+//
+// export async function parseParametersArguments(
+//     req: FastifyRequest,
+//     res: FastifyReply,
+//     metadata: RouteParametersMetadataInterface[]
+// ): Promise<any[]> {
+//     const args: any[] = [];
+//     const files: AsyncIterableIterator<any> | any[] = ('files' in req && typeof req.files === 'function') ? req.files() : [];
+//
+//     for (const param of metadata) {
+//         switch (param.type) {
+//             // case Parametrable.APP:
+//             //     args[param.index] = req.server as any;
+//             //     break;
+//             case Parametrable.PARAM:
+//                 args[param.index] = param.key ? (req.params as any)[param.key] : req.params;
+//                 break;
+//             case Parametrable.BODY:
+//                 args[param.index] = param.key ? (req.body as any)[param.key] : req.body;
+//                 break;
+//             case Parametrable.QUERY:
+//                 args[param.index] = param.key ? (req.query as any)[param.key] : req.query;
+//                 break;
+//             case Parametrable.HEADER:
+//                 args[param.index] = req.headers[param.key.toLowerCase()] as any;
+//                 break;
+//             case Parametrable.REQ:
+//                 args[param.index] = req as any;
+//                 break;
+//             case Parametrable.REPLY:
+//                 args[param.index] = res as any;
+//                 break;
+//             case Parametrable.UPLOAD_FILE:
+//                 let accumulate: any = param.multiple ? [] : null;
+//                 for await (const part of files) {
+//                     if (param.key === part.fieldname) {
+//                         const packed = {
+//                             filename: part.filename,
+//                             mimetype: part.mimetype,
+//                             encoding: part.encoding,
+//                             toFile: () => part.file,
+//                             toBuffer: async () => await part.toBuffer(),
+//                         }
+//                         accumulate = param.multiple ? [...accumulate, packed] : packed;
+//                     }
+//                 }
+//                 args[param.index] = accumulate as any;
+//                 break;
+//
+//             case Parametrable.CUSTOM:
+//                 args[param.index] = param.callable?.({request: req, reply: res, files}) ?? null;
+//                 break;
+//         }
+//     }
+//
+//     return args;
+// }

package/source/types/application.ts

@@ -16,9 +16,9 @@ export interface ApplicationInterface {
 
     get hostname(): string;
 
-    // setOption<K extends keyof ApplicationConfig>(key: K, value: ApplicationConfig[K]): this;
-    //
-    // setOptions(options: ApplicationConfig): this;
+    setOption<K extends keyof ApplicationConfig>(key: K, value: ApplicationConfig[K]): this;
+
+    setOptions(options: ApplicationConfig): this;
 
     register(plugin: any): this;