raiton 1.0.0 → 3.0.0

package/source/sdk/repositories.ts

@@ -0,0 +1,14 @@
+import {Throwable} from "@/sdk/exceptions";
+
+
+export class DelegateRepository {
+    protected readonly client: any;
+    public readonly model!: any;
+
+    protected supported(method: string): boolean {
+        if (typeof this.model !== 'object') throw new Throwable('Model not found, please check your repository')
+        else if (!(method in this.model)) throw new Throwable(`Method ${method} not found, please check your repository`)
+        return true;
+    }
+
+}

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/responses";
+
+
+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/runtime/bun/server.ts

@@ -0,0 +1,73 @@
+import {RuntimeAdapterInterface} from '@/types'
+
+export const bunRuntime: RuntimeAdapterInterface = {
+    createServer(handler) {
+        if (typeof Bun === 'undefined') throw new Error(
+            'bun is not installed, please run `npm install bun`'
+        )
+
+        let server: any
+
+        return {
+            async listen(port, hostname) {
+                server = Bun.serve({
+                    port,
+                    hostname,
+                    fetch: async (request: Request) => {
+                        let responseBody: any
+                        let statusCode = 200
+                        const headers = new Headers()
+
+                        await handler(
+                            {
+                                method: request.method,
+                                url: request.url,
+                                headers: request.headers as any,
+                                body: request.body as any
+                            },
+                            {
+                                status(code) {
+                                    statusCode = code
+                                },
+                                header(name, value) {
+                                    headers.set(name, value)
+                                },
+                                send(body: any) {
+                                    if (body === undefined) {
+                                        responseBody = ''
+                                    } else if (typeof body === 'string' || Buffer.isBuffer(body)) {
+                                        responseBody = body;
+                                    } else {
+                                        headers.set('content-type', 'application/json');
+                                        responseBody = (JSON.stringify(body));
+                                    }
+                                },
+                                text(text: string | Buffer) {
+                                    responseBody = text
+                                },
+                                json(json: any) {
+                                    headers.set('content-type', 'application/json')
+                                    responseBody = JSON.stringify(json)
+                                },
+                            }
+                        )
+
+                        if (responseBody instanceof Response) {
+                            return responseBody;
+                        }
+
+                        return new Response(
+                            typeof responseBody === 'object' && !(responseBody instanceof Buffer)
+                                ? JSON.stringify(responseBody)
+                                : responseBody,
+                            {status: statusCode, headers}
+                        )
+                    }
+                })
+            },
+            async close() {
+                server?.stop()
+            }
+        }
+    }
+}

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

@@ -0,0 +1,53 @@
+import {RuntimeAdapterInterface} from '@/types'
+
+export const denoRuntime: RuntimeAdapterInterface = {
+    createServer(handler) {
+        let controller: AbortController
+
+        return {
+            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, hostname, signal: controller.signal}, async (req: any) => {
+                    let body: any
+                    let status = 200
+                    const headers = new Headers()
+
+                    await handler(
+                        {
+                            method: req.method,
+                            url: req.url,
+                            headers: req.headers,
+                            body: req.body
+                        },
+                        {
+                            status(code) {
+                                status = code
+                            },
+                            header(name, value) {
+                                headers.set(name, value)
+                            },
+                            send(value: any) {
+                                body = value
+                            },
+                            text(text: string | Buffer) {
+                                body = text
+                            },
+                            json(json: any) {
+                                body = JSON.stringify(json)
+                            },
+                        }
+                    )
+
+                    return new Response(body, {status, headers})
+                })
+            },
+            async close() {
+                controller.abort()
+            }
+        }
+    }
+}

package/source/sdk/runtime/index.ts

@@ -0,0 +1,47 @@
+import type {RuntimeAdapterInterface, RuntimeHandlerCallable, RuntimeInterface, RuntimeServerInterface} from "@/types";
+import {RuntimeType} from "@/sdk/enums/runtime.enum";
+import {nodeRuntime} from "@/sdk/runtime/node/server";
+import {bunRuntime} from "@/sdk/runtime/bun/server";
+import {denoRuntime} from "@/sdk/runtime/deno/server";
+import {webRuntime} from "@/sdk/runtime/web/server";
+
+
+export class Runtime implements RuntimeInterface {
+    constructor(
+        public readonly type: RuntimeType = RuntimeType.Node
+    ) {
+    }
+
+    get isNode(): boolean {
+        return this.type === RuntimeType.Node;
+    }
+
+    get isDeno(): boolean {
+        return this.type === RuntimeType.Deno;
+    }
+
+    get isWeb(): boolean {
+        return this.type === RuntimeType.Web;
+    }
+
+    get isBun(): boolean {
+        return this.type === RuntimeType.Bun;
+    }
+
+    adapter(): RuntimeAdapterInterface {
+        switch (this.type) {
+            case RuntimeType.Node:
+                return nodeRuntime
+            case RuntimeType.Bun:
+                return bunRuntime
+            case RuntimeType.Deno:
+                return denoRuntime
+            case RuntimeType.Web:
+                return webRuntime
+        }
+    }
+
+    createServer(handler: RuntimeHandlerCallable): RuntimeServerInterface {
+        return this.adapter().createServer(handler)
+    }
+}

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

@@ -0,0 +1,60 @@
+import http from 'node:http'
+import {
+    RuntimeAdapterInterface,
+    RuntimeRequestInterface,
+    RuntimeReplyInterface
+} from '@/types'
+
+export const nodeRuntime: RuntimeAdapterInterface = {
+    createServer(handler) {
+        const server = http.createServer(async (req, res) => {
+            const runtimeReq: RuntimeRequestInterface = {
+                method: req.method || 'GET',
+                url: req.url || '/',
+                headers: new Headers(req.headers as any),
+                body: req as any,
+                remoteAddress: req.socket.remoteAddress
+            }
+
+            const runtimeReply: RuntimeReplyInterface = {
+                status(code) {
+                    res.statusCode = code
+                },
+                header(name, value) {
+                    res.setHeader(name, value)
+                },
+                send(body: any) {
+                    if (body === undefined) {
+                        res.end()
+                    } else if (typeof body === 'string' || Buffer.isBuffer(body)) {
+                        res.end(body)
+                    } else {
+                        res.setHeader('content-type', 'application/json')
+                        res.end(JSON.stringify(body))
+                    }
+                },
+                text(text: string|Buffer) {
+                    res.end(text)
+                },
+                json(json: any) {
+                    res.end(JSON.stringify(json))
+                },
+            }
+
+            await handler(runtimeReq, runtimeReply)
+        })
+
+        return {
+            listen(port, hostname) {
+                return new Promise((resolve) =>
+                    server.listen(port, hostname, resolve)
+                )
+            },
+            close() {
+                return new Promise((resolve, reject) =>
+                    server.close(err => err ? reject(err) : resolve())
+                )
+            }
+        }
+    }
+}

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

@@ -0,0 +1,57 @@
+import {RuntimeAdapterInterface, RuntimeReplyInterface, RuntimeRequestInterface} from '@/types'
+
+export const webRuntime: RuntimeAdapterInterface = {
+    createServer(handler) {
+        async function fetching(request: Request, handler: (req: RuntimeRequestInterface, reply: RuntimeReplyInterface) => Promise<void>): Promise<Response> {
+            let responseBody: any
+            let statusCode = 200
+            const headers = new Headers()
+
+            const runtimeReq: RuntimeRequestInterface = {
+                method: request.method,
+                url: request.url,
+                headers: request.headers,
+                body: request.body as any
+            }
+
+            const runtimeReply: RuntimeReplyInterface = {
+                status(code) {
+                    statusCode = code
+                },
+                header(name, value) {
+                    headers.set(name, value)
+                },
+                send(body) {
+                    responseBody = body
+                },
+                text(text: string | Buffer) {
+                    responseBody = text
+                },
+                json(json: any) {
+                    responseBody = JSON.stringify(json)
+                },
+            }
+
+            await handler(runtimeReq, runtimeReply)
+
+            return new Response(
+                typeof responseBody === 'object' && !(responseBody instanceof Uint8Array)
+                    ? JSON.stringify(responseBody)
+                    : responseBody,
+                {status: statusCode, headers}
+            )
+        }
+
+        return {
+            async listen() {
+                console.warn('Web runtime does not support listening')
+            },
+            async close() {
+                console.warn('Web runtime does not support closing')
+            },
+            async handle(request: Request) {
+                return fetching(request, handler)
+            }
+        }
+    }
+}

package/source/sdk/services.ts

@@ -0,0 +1,9 @@
+import {DelegateRepository} from "./repositories";
+
+export class DelegateService {
+    protected repository!: DelegateRepository;
+
+    getRepository() {
+        return this.repository as typeof this.repository;
+    }
+}

package/source/sdk/utilities/alias-path.util.ts

@@ -0,0 +1,49 @@
+// import fs from "fs";
+// import path from "path";
+// import tsconfig from "../../../tsconfig.json";
+//
+// /**
+//  * Resolves the provided pathname to its corresponding alias path based on the configured TypeScript paths and output directories.
+//  *
+//  * @param {string} pathname - The input path to resolve as per the alias configurations in the TypeScript configuration.
+//  * @return {string | null} - The resolved alias path if it exists, or null if no matching alias is found.
+//  */
+// export function aliasPath(pathname: string): string | null {
+//
+//     const paths = (tsconfig.compilerOptions as any)?.paths ?? {};
+//     const prefix = (process.env.RAITON_NATURAL_MODE) ? "" : (tsconfig.compilerOptions?.outDir ?? "dist");
+//     // pathname = pathname.replace(/^@\/?/, prefix ? prefix + "/" : "");
+//
+//     const baseUrl = (tsconfig.compilerOptions as any)?.baseUrl ?? ".";
+//
+//     for (const [aliasPattern, resolvedPaths] of Object.entries(paths)) {
+//         const aliasKey = aliasPattern.replace("/*", "");
+//         const aliasValue = path.join(prefix, (resolvedPaths as string[])[0]?.replace("/*", ""));
+//
+//         if (pathname.startsWith(aliasKey)) {
+//             const relativePath = pathname.replace(aliasKey, aliasValue);
+//             const fullPath = path.resolve(baseUrl, relativePath);
+//             const extensions = [".ts", ".js"];
+//
+//             for (const ext of extensions)
+//                 if (fs.existsSync(fullPath + ext))
+//                     return fullPath + ext;
+//
+//             if (fs.existsSync(path.join(fullPath, "index.ts")))
+//                 return path.join(fullPath, "index.ts");
+//
+//             if (fs.existsSync(path.join(fullPath, "index.js")))
+//                 return path.join(fullPath, "index.js");
+//
+//             if (fs.existsSync(path.join(fullPath, "index.mjs")))
+//                 return path.join(fullPath, "index.mjs");
+//
+//             if (fs.existsSync(path.join(fullPath, "index.cjs")))
+//                 return path.join(fullPath, "index.cjs");
+//
+//             return fullPath;
+//         }
+//     }
+//
+//     return null;
+// }

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/callable.util.ts

@@ -0,0 +1,27 @@
+import {LBadge, Logger} from "@protorians/logger";
+
+export async function retryCallable(
+    label: string,
+    callback: () => Promise<void>,
+    onFail?: (e: any) => void,
+    trying: number = 0,
+    limit: number = 7,
+) {
+    try {
+        Logger.info(
+            LBadge.debug(label || 'Running'),
+            LBadge.info(trying),
+            LBadge.log(limit),
+        )
+        await callback()
+    } catch (e) {
+        Logger.info(
+            LBadge.debug('Trying'),
+            LBadge.info(trying),
+            LBadge.log(limit),
+        )
+        if (trying < limit)
+            setTimeout(() => retryCallable(label, callback, onFail, trying + 1, limit), 1000);
+        else onFail?.(e)
+    }
+}

package/source/sdk/utilities/index.ts

@@ -0,0 +1,5 @@
+export * from "./callable.util"
+export * from "./utilities.util"
+export * from "./artifact.util"
+export * from "./json.util"
+export * from "./path.util"

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

@@ -0,0 +1,21 @@
+import fs from "node:fs";
+
+export function tryParseJson<T>(obj: any): T | null {
+    try {
+        return JSON.parse(obj);
+    } catch (e) {
+        return null;
+    }
+}
+
+
+export class JsonUtil {
+    static trying = tryParseJson;
+    static parse = JSON.parse;
+    static stringify = JSON.stringify;
+
+    static import(pathname: string) {
+        const json = fs.readFileSync(pathname, "utf-8");
+        return JSON.parse(json);
+    }
+}

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

@@ -0,0 +1,19 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export function getDirname(importMetaUrl: string): string {
+    return path.dirname(fileURLToPath(importMetaUrl));
+}
+
+export function getFilename(importMetaUrl: string): string {
+    return fileURLToPath(importMetaUrl);
+}
+
+export function getPackageRoot(importMetaUrl: string): string {
+    const dirname = getDirname(importMetaUrl);
+    // On remonte jusqu'à trouver un package.json ou on remonte d'un niveau si on est dans source/bin ou build/bin
+    if (dirname.endsWith('bin')) {
+        return path.join(dirname, '..');
+    }
+    return dirname;
+}

package/source/sdk/utilities/url.ts

@@ -0,0 +1,5 @@
+
+
+export function escapeUrl(str: string) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}

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

@@ -0,0 +1,25 @@
+import {IGenericValueType} from "../../types";
+
+export function getType(value: any): IGenericValueType {
+    if (typeof value === "string") return "string";
+    if (typeof value === "boolean") return "boolean";
+    if (typeof value === "bigint") return "bigInt";
+    if (typeof value === "number") {
+        if (Number.isInteger(value)) return "int";
+        return "float";
+    }
+    return (typeof value) as any;
+}
+
+export function stabilizeJson<T>(json: string | T | null) {
+    if (!json) return {} as T;
+
+    switch (typeof json) {
+        case 'string':
+            return JSON.parse(json);
+        case 'object':
+            return json as T;
+        default:
+            throw new Error('Invalid JSON format');
+    }
+}

package/source/types/access-guards.ts

@@ -0,0 +1,4 @@
+export interface IAccessGuardDeclaration {
+    credential?: boolean;
+    capabilities?: string[];
+}