raiton 0.0.2 → 1.0.0-alpha.1

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/{build/sdk/schemes.d.ts → source/sdk/schemes.ts}

@@ -1,8 +1,14 @@
-import { TSchema, TProperties } from '@sinclair/typebox';
-export * from '@sinclair/typebox';
-import { IScheme, ISchemeConfig, ISchemeOptions } from '../types/scheme.js';
+import {TSchema, Static, TProperties, Type} from "@sinclair/typebox";
+import {ISchemeConfig, ISchemeOptions, IScheme} from "@/types";
+
+
+export * from "@sinclair/typebox"
+
+export function scheme() {
+    return new Scheme({});
+}
+
 
-declare function scheme(): Scheme<undefined, undefined, undefined, undefined>;
 /**
  * A utility type for casting and inferring a type based on the provided `Schematic` generic structure.
  * It checks if the given type `T` extends from the `Schematic` type and applies the inference logic
@@ -13,28 +19,47 @@ declare function scheme(): Scheme<undefined, undefined, undefined, undefined>;
  * If `T` is an instance of `Schematic` with defined type parameters, this utility resolves to the
  * result returned by the `Schematic.infer` method applied to `T`. Otherwise, it will resolve to `never`.
  */
-type SchematicCast<T> = T extends Scheme<any, any, any, any> ? ReturnType<typeof Scheme.infer<T>> : never;
+export type SchematicCast<T> = T extends Scheme<any, any, any, any>
+    ? ReturnType<typeof Scheme.infer<T>>
+    : never;
+
 /**
  * Represents a schema configuration that can be used with type-safe operations
- * and is compatible with fastify route options.
+ * and is compatible with route options.
  *
  * @template TBody - Optional schema type for the request body.
  * @template TParams - Optional schema type for the route parameters.
  * @template TQuery - Optional schema type for the query string parameters.
  * @template TResponse - Optional schema type for the response, where each status code can have its own schema.
  */
-declare class Scheme<TBody extends TSchema | undefined = undefined, TParams extends TSchema | undefined = undefined, TQuery extends TSchema | undefined = undefined, TResponse extends Record<number, TSchema> | undefined = undefined> implements IScheme<TBody, TParams, TQuery, TResponse> {
+export class Scheme<
+    TBody extends TSchema | undefined = undefined,
+    TParams extends TSchema | undefined = undefined,
+    TQuery extends TSchema | undefined = undefined,
+    TResponse extends Record<number, TSchema> | undefined = undefined
+> implements IScheme<TBody, TParams, TQuery, TResponse> {
     protected _$body?: TBody;
     protected _$params?: TParams;
     protected _$querystring?: TQuery;
     protected _$response?: TResponse;
-    constructor(config: ISchemeConfig<TBody, TParams, TQuery, TResponse>);
+
+    constructor(config: ISchemeConfig<TBody, TParams, TQuery, TResponse>) {
+        this._$body = config.body;
+        // this._$body = config.body;
+        this._$params = config.params;
+        this._$querystring = config.querystring;
+        this._$response = config.response;
+    }
+
     /**
      * Retrieves the current value of the $body property.
      *
      * @return {TBody | undefined} The value of the $body property, or undefined if it is not set.
      */
-    get $body(): TBody | undefined;
+    get $body(): TBody | undefined {
+        return this._$body;
+    }
+
     /**
      * Adds or updates a key-value pair in the body object.
      *
@@ -42,13 +67,20 @@ declare class Scheme<TBody extends TSchema | undefined = undefined, TParams exte
      * @param {TProperties} value - The value to associate with the specified key.
      * @return {this} The current instance with the updated body object.
      */
-    body(key: string, value: TProperties): this;
+    body(key: string, value: TProperties): this {
+        this._$body = {...(this._$body || {}), [key]: value} as TBody;
+        return this;
+    }
+
     /**
      * Retrieves the current value of the `$params` property.
      *
      * @return {TParams | undefined} The value of `$params` if set, otherwise undefined.
      */
-    get $params(): TParams | undefined;
+    get $params(): TParams | undefined {
+        return this._$params;
+    }
+
     /**
      * Adds or updates a parameter with the specified key and value.
      *
@@ -56,13 +88,20 @@ declare class Scheme<TBody extends TSchema | undefined = undefined, TParams exte
      * @param {TProperties} value - The value to associate with the specified key.
      * @return {this} The current instance with the updated parameters.
      */
-    params(key: string, value: TProperties): this;
+    params(key: string, value: TProperties): this {
+        this._$params = {...(this._$params || {}), [key]: value} as TParams;
+        return this;
+    }
+
     /**
      * Retrieves the current query string.
      *
      * @return {TQuery | undefined} The query string object if available, otherwise undefined.
      */
-    get $querystring(): TQuery | undefined;
+    get $querystring(): TQuery | undefined {
+        return this._$querystring;
+    }
+
     /**
      * Updates the query string parameters by setting the specified key-value pair.
      *
@@ -70,13 +109,20 @@ declare class Scheme<TBody extends TSchema | undefined = undefined, TParams exte
      * @param {TProperties} value - The value associated with the specified key.
      * @return {this} The current instance of the class for method chaining.
      */
-    querystring(key: string, value: TProperties): this;
+    querystring(key: string, value: TProperties): this {
+        this._$querystring = {...(this._$querystring || {}), [key]: value} as TQuery;
+        return this;
+    }
+
     /**
      * Retrieves the current response object.
      *
      * @return {TResponse | undefined} The response object if available; otherwise, undefined.
      */
-    get $response(): TResponse | undefined;
+    get $response(): TResponse | undefined {
+        return this._$response;
+    }
+
     /**
      * Adds or updates a response key-value pair in the internal response object.
      *
@@ -84,13 +130,27 @@ declare class Scheme<TBody extends TSchema | undefined = undefined, TParams exte
      * @param {TProperties} value - The value associated with the given key.
      * @return {this} The current instance to allow method chaining.
      */
-    response(key: number, value: TProperties): this;
+    response(key: number, value: TProperties): this {
+        this._$response = {...(this._$response || {}), [key]: value} as TResponse;
+        return this;
+    }
+
     /**
      * Generates a schema object for validating different parts of an HTTP request.
      *
      * @return {Object} An object containing the schema definitions for `body`, `params`, `querystring`, and `response`. Each property returns a corresponding schema object.
      */
-    schema(): ISchemeOptions<TBody, TParams, TQuery, TResponse>;
+    schema(): ISchemeOptions<TBody, TParams, TQuery, TResponse> {
+        const schema: ISchemeOptions<TBody, TParams, TQuery, TResponse> = {}
+
+        if (this._$body) schema.body = Type.Object(this._$body);
+        if (this._$params) schema.params = Type.Object(this._$params);
+        if (this._$querystring) schema.querystring = Type.Object(this._$querystring);
+        if (this._$response) schema.response = Type.Object(this._$response);
+
+        return schema;
+    }
+
     /**
      * Infers and extracts static types from a given schema object.
      *
@@ -101,20 +161,18 @@ declare class Scheme<TBody extends TSchema | undefined = undefined, TParams exte
      * - Query: The static type of the query string if defined in the schema, otherwise undefined.
      * - Reply: The response type mappings if defined in the schema, otherwise undefined.
      */
-    static infer<T extends Scheme<any, any, any, any>>(schema: T): {
-        Body: (T["$body"] & {
-            params: [];
-        })["static"] | undefined;
-        Params: (T["$params"] & {
-            params: [];
-        })["static"] | undefined;
-        Query: (T["$querystring"] & {
-            params: [];
-        })["static"] | undefined;
-        Reply: { [K in keyof NonNullable<T["$response"]>]: (NonNullable<T["$response"]>[K] & {
-            params: [];
-        })["static"]; } | undefined;
-    };
+    static infer<T extends Scheme<any, any, any, any>>(schema: T) {
+        return {
+            Body: schema._$body ? ({} as Static<NonNullable<T["$body"]>>) : undefined,
+            Params: schema._$params
+                ? ({} as Static<NonNullable<T["$params"]>>)
+                : undefined,
+            Query: schema._$querystring
+                ? ({} as Static<NonNullable<T["$querystring"]>>)
+                : undefined,
+            Reply: schema._$response
+                ? schema._$response as ({ [K in keyof NonNullable<T["$response"]>]: Static<NonNullable<T["$response"]>[K]> })
+                : undefined,
+        };
+    }
 }
-
-export { type SchematicCast, Scheme, scheme };

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/{build/sdk/throwable.d.ts → source/sdk/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/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/artifacts.util.ts

@@ -0,0 +1,62 @@
+import path from "node:path";
+import fs from "fs";
+import {LBadge, Logger} from "@protorians/logger";
+import {RaitonDirectories} from "@/core";
+import {Raiton} from "@/core/raiton";
+import {ArtifactFactory} from "@/sdk/artifacts";
+
+
+export function generateArtifacts(
+    artifact: string,
+    interfaceName: string,
+    decoratorSyntax: RegExp,
+    verbose: boolean = false,
+) {
+    const artifacts = RaitonDirectories.artifacts(Raiton.thread.builder.workdir)
+    const dir = Raiton.thread.builder.source;
+    const outputFile = path.join(artifacts, `${artifact}.d.ts`);
+
+    if (!dir) return;
+
+    const files = fs.readdirSync(dir, {recursive: true})
+        .filter(f => [`.ts`, `.js`, `.mjs`, `.cjs`,].some(ext => f.toString().endsWith(ext)))
+        .map(f => f.toString())
+    ;
+
+    let mappings = "";
+    for (const file of files) {
+
+        const filename = path.join(dir, file);
+        const content = fs.readFileSync(filename, "utf-8");
+        const match = content.match(decoratorSyntax);
+
+        if (!match) continue;
+
+        let name = match[3] || match[1] || "";
+        if (!name) {
+            const classMatch = content.match(/export\s+default\s+class\s+([A-Za-z0-9_]+)/);
+            name = classMatch?.[1] || path.parse(filename).name;
+        }
+
+        mappings += `    ${name}: InstanceType<typeof import("@/${file}").default>;\n`;
+
+        if (verbose) Logger.info(LBadge.debug(name), `artifact detected`);
+        ArtifactFactory.add(artifact, {
+            file,
+            dir,
+            relative: file,
+            absolute: filename
+        })
+    }
+
+    const content = `// AUTO-GENERATED FILE — DO NOT EDIT MANUALLY
+declare global {
+  interface ${interfaceName} {
+${mappings} }
+}
+export {};`;
+    fs.writeFileSync(outputFile, content, "utf-8");
+    if (!ArtifactFactory.save(artifact)) Logger.error(`Failed to save artifacts for ${artifact}`);
+}
+
+

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

@@ -0,0 +1,8 @@
+export function isControllerFile(filename: string) {
+    return [
+        filename.endsWith(".controller.ts"),
+        filename.endsWith(".controller.js"),
+        filename.endsWith(".controller.mjs"),
+        filename.endsWith(".controller.cjs"),
+    ].some(Boolean)
+}

package/source/sdk/utilities/index.ts

@@ -0,0 +1,7 @@
+// export * from "./alias-path.util"
+export * from "./artifacts.util"
+export * from "./callable.util"
+export * from "./utilities.util"
+export * from "./controller.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[];
+}

package/{build/types/application.d.ts → source/types/application.ts}

@@ -1,6 +1,6 @@
-import { HttpMethod } from '../sdk/enums/http.enum.js';
+import {HttpMethod} from "@/sdk";
 
-interface ApplicationConfig {
+export interface ApplicationConfig {
     workdir?: string;
     hostname?: string;
     port?: number;
@@ -10,21 +10,37 @@ interface ApplicationConfig {
     develop?: boolean;
     verbose?: boolean;
 }
-interface ApplicationInterface {
+
+export interface ApplicationInterface {
     readonly config: ApplicationConfig;
+
     get hostname(): string;
+
+    // setOption<K extends keyof ApplicationConfig>(key: K, value: ApplicationConfig[K]): this;
+    //
+    // setOptions(options: ApplicationConfig): this;
+
     register(plugin: any): this;
+
     use(mw: any): this;
-    route(method: HttpMethod, path: string, handler: any, version?: string): this;
+
+    route(method: HttpMethod, path: string, handler: any, version?: string): this
+
     get(path: string, handler: any, version?: string): this;
+
     post(path: string, handler: any, version?: string): this;
+
     patch(path: string, handler: any, version?: string): this;
+
     put(path: string, handler: any, version?: string): this;
+
     delete(path: string, handler: any, version?: string): this;
+
     options(path: string, handler: any, version?: string): this;
+
     head(path: string, handler: any, version?: string): this;
+
     trace(path: string, handler: any, version?: string): this;
-    handle(req: any, reply: any): Promise<any>;
-}
 
-export type { ApplicationConfig, ApplicationInterface };
+    handle(req: any, reply: any): Promise<any>;
+}