raiton 0.0.2 → 1.0.0-alpha.2

package/source/sdk/artifacts.ts

@@ -0,0 +1,55 @@
+import path from "node:path";
+import fs from "fs";
+import {Logger} from "@protorians/logger";
+import {IFileStatInfo} from "@/types";
+import {Raiton} from "@/core/raiton";
+import {RaitonDirectories} from "@/core";
+
+export class ArtifactFactory {
+    protected static readonly stack: Map<string, Set<IFileStatInfo>> = new Map();
+
+    static getSource(key: string) {
+        return path.join(
+            RaitonDirectories.artifacts(Raiton.thread.builder.workdir),
+            `${key}.json`
+        );
+    }
+
+    static add(key: string, file: IFileStatInfo) {
+        if (!this.stack.has(key)) this.stack.set(key, new Set());
+        this.stack.get(key)?.add(file);
+    }
+
+    static get(key: string): Set<IFileStatInfo> | undefined {
+        return this.stack.get(key);
+    }
+
+    static has(key: string): boolean {
+        return this.stack.has(key);
+    }
+
+    static load(key: string) {
+        const outputFile = this.getSource(key)
+        if (!fs.existsSync(outputFile)) return this;
+        const content = fs.readFileSync(outputFile, "utf-8");
+        const files = JSON.parse(content) as IFileStatInfo[];
+        files.forEach(file => this.add(key, file));
+        return this;
+    }
+
+    static save(key: string) {
+        try {
+            const set = this.stack.get(key);
+            if (!set) return;
+            const content = JSON.stringify([...set.values()]);
+            const outputFile = this.getSource(key)
+            const dir = path.dirname(outputFile);
+            if (!fs.existsSync(dir)) fs.mkdirSync(dir, {recursive: true})
+            fs.writeFileSync(outputFile, content, "utf-8");
+            return true
+        } catch (e) {
+            Logger.error(`Failed to save artifacts for key ${key}:`, e);
+            return false;
+        }
+    }
+}

package/source/sdk/constants/decorators.constant.ts

@@ -0,0 +1,7 @@
+export const METADATA_KEYS = {
+    CONTROLLERS: Symbol('controller:meta'),
+    GRAFTS: Symbol('graft:meta'),
+    CONTAINER: Symbol('container:meta'),
+    INJECT_PARAMETERS: Symbol('inject:parameters'),
+    INJECT_PROPERTIES: Symbol('inject:properties'),
+}

package/source/sdk/constants/index.ts

@@ -0,0 +1,2 @@
+export * from "./decorators.constant"
+export * from "./microservices.constant"

package/source/sdk/constants/microservices.constant.ts

@@ -0,0 +1,4 @@
+export const MICROSERVICE_NAME = {
+    INDEX: 'Current:Microservice',
+};
+

package/source/sdk/controllers.ts

@@ -0,0 +1,4 @@
+
+export class DelegateController {
+
+}

package/source/sdk/data-transfer-object.ts

@@ -0,0 +1,7 @@
+import {DynamicParameter} from "@protorians/parameters";
+import {IDataTransferObject} from "@/types";
+
+
+export class DataTransferObject<T extends IDataTransferObject<T>> extends DynamicParameter<T> {
+
+}

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

@@ -0,0 +1,9 @@
+// import {IAccessGuardDeclaration} from "../../types";
+// import {SYSTEM_DECORATORS_KEYS} from "../constants";
+//
+// export function AccessGuard(declaration: IAccessGuardDeclaration){
+//     return (target: any, methodKey: any)=> {
+//         const current: IAccessGuardDeclaration = {...(Reflect.getMetadata(SYSTEM_DECORATORS_KEYS.ACCESS_GUARD, target.constructor, methodKey) || {}), ...declaration};
+//         Reflect.defineMetadata(SYSTEM_DECORATORS_KEYS.ACCESS_GUARD, current, target.constructor, methodKey);
+//     }
+// }

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

@@ -0,0 +1,20 @@
+import {getControllerMetadata} from "@/core/controller";
+import {Injectable} from "@/sdk";
+import {LifetimeEnum} from "@protorians/core";
+import {ControllerDecoratorCallable} from "@/types";
+
+export function Controllable(prefix = '') {
+    return (target: any) => {
+        const name = target.name;
+        Injectable(LifetimeEnum.TRANSIENT, name,)(target)
+
+        const meta = getControllerMetadata(target.prototype || target)
+        meta.prefix = prefix;
+    }
+}
+
+export function createControllerDecorator(callable: ControllerDecoratorCallable) {
+    return (target: any) => {
+        callable(getControllerMetadata(target.prototype || target))
+    }
+}

package/source/sdk/decorators/index.ts

@@ -0,0 +1,5 @@
+export * from "./controllable.decorator"
+export * from "./middleware.decorator"
+export * from "./routable.decorator"
+export * from "./parametrable"
+export * from "./injection.decorator"

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

@@ -0,0 +1,46 @@
+import "reflect-metadata";
+import type {IConstructor} from "@/types/contruct";
+import {Injection} from "@/core/injection";
+import {LifetimeEnum} from "@protorians/core";
+import {Logger} from "@protorians/logger";
+import {METADATA_KEYS} from "@/sdk/constants";
+
+
+export function Injectable(lifetime?: LifetimeEnum, name?: string, scope?: any) {
+    return function <T extends IConstructor>(target: T) {
+        const metadata = {
+            name: name || target.name,
+            construct: target,
+            lifetime: lifetime || LifetimeEnum.TRANSIENT,
+            scope
+        };
+        Reflect.defineMetadata(METADATA_KEYS.CONTAINER, metadata, target);
+        Injection.registry(
+            metadata.name,
+            target,
+            metadata.lifetime,
+            scope
+        );
+    };
+}
+
+export function Inject(token?: any) {
+    return function (target: any, propertyKey: string | symbol | undefined, parameterIndex?: number) {
+        if (parameterIndex !== undefined) {
+            const parameters = Reflect.getMetadata(METADATA_KEYS.INJECT_PARAMETERS, target) || [];
+            parameters[parameterIndex] = token || true;
+            Reflect.defineMetadata(METADATA_KEYS.INJECT_PARAMETERS, parameters, target);
+        } else if (propertyKey !== undefined) {
+            const properties = Reflect.getMetadata(METADATA_KEYS.INJECT_PROPERTIES, target.constructor) || new Map();
+            const type = token || Reflect.getMetadata('design:type', target, propertyKey);
+
+            if (type === undefined || type === Object) {
+                Logger.warn(`Injection: impossible de déterminer le type pour la propriété "${String(propertyKey)}" de ${target.constructor.name}. Assurez-vous d'utiliser un token ou que le type est une classe.`);
+            }
+
+            properties.set(propertyKey, type);
+            Reflect.defineMetadata(METADATA_KEYS.INJECT_PROPERTIES, properties, target.constructor);
+        }
+        return target;
+    };
+}

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

@@ -0,0 +1,15 @@
+import {MiddlewareCallable} from "@/types";
+import {getControllerMetadata} from "@/core";
+
+
+export function Middleware(middleware: MiddlewareCallable) {
+    return (target: any, propertyKey?: string) => {
+        const meta = getControllerMetadata(target.prototype || target)
+        const segment = propertyKey ? propertyKey : '@'
+        meta.middlewares[segment] = [...(meta.middlewares[segment] || []), middleware];
+    }
+}
+
+export function createMiddlewareDecoration(middleware: MiddlewareCallable) {
+    return Middleware(middleware);
+}

package/source/sdk/decorators/parametrable.ts

@@ -0,0 +1,24 @@
+import type {Context, ParamMetaInterface} from "@/types";
+import {getControllerMetadata} from "@/core";
+import {Parametrable} from "@/sdk";
+import {Logger} from "@protorians/logger";
+
+function createParametrable(type: ParamMetaInterface['type'], callable?: (context: Context) => any) {
+    return (key?: string) => {
+        return (target: any, propertyKey: string, index: number) => {
+            const meta = getControllerMetadata(target)
+            if (!meta.params[propertyKey])
+                meta.params[propertyKey] = []
+            meta.params[propertyKey].push({index, type, key, callable})
+        }
+    }
+}
+
+export const Query = createParametrable(Parametrable.QUERY)
+export const Param = createParametrable(Parametrable.PARAM)
+export const Body = createParametrable(Parametrable.BODY)
+export const UploadedFile = createParametrable(Parametrable.UPLOAD_FILE)
+export const Headers = createParametrable(Parametrable.HEADER)
+export const Req = createParametrable(Parametrable.REQ)
+export const Reply = createParametrable(Parametrable.REPLY)
+

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

@@ -0,0 +1,77 @@
+// import {IPayload} from "@/types";
+// import {SYSTEM_DECORATORS_KEYS} from "@/sdk/constants";
+//
+// /**
+//  * A decorator function that combines and assigns schema-related metadata
+//  * to a specific property in the target constructor using reflective metadata.
+//  *
+//  * @param {IPayload} payload - The schema-related payload to be merged and assigned as metadata.
+//  * @return {Function} A decorator function that applies the merged metadata to the property.
+//  */
+// export function Schemeable(payload: IPayload): (target: any, propertyKey: (string | symbol)) => void {
+//     return (target: any, propertyKey: string | symbol,) => {
+//         const current: IPayload = {...(Reflect.getMetadata(SYSTEM_DECORATORS_KEYS.ROUTES_SCHEMES, target.constructor, propertyKey) || {}), ...payload};
+//         Reflect.defineMetadata(SYSTEM_DECORATORS_KEYS.ROUTES_SCHEMES, current, target.constructor, propertyKey);
+//     };
+// }
+//
+//
+// /**
+//  * Constructs a schematizable object for the provided payload body.
+//  *
+//  * @param {IPayload['body']} payload - The body of the payload to be schematized.
+//  * @return {object} Returns a schematized object containing the provided payload body.
+//  */
+// export function BodySchemeable(payload: IPayload['body']): (target: any, propertyKey: (string | symbol)) => void {
+//     return Schemeable({
+//         body: payload
+//     });
+// }
+//
+// /**
+//  * Transforms the provided headers payload into a schematizable format.
+//  *
+//  * @param {IPayload['headers']} payload - The headers payload to be processed and transformed.
+//  * @return {object} The transformed schematizable object containing the headers.
+//  */
+// export function HeadersSchemeable(payload: IPayload['headers']): (target: any, propertyKey: (string | symbol)) => void {
+//     return Schemeable({
+//         headers: payload
+//     });
+// }
+//
+// /**
+//  * Constructs a schematizable object using the given query string payload.
+//  *
+//  * @param {IPayload['querystring']} payload - The query string object to be included in the schematizable configuration.
+//  * @return {object} The resulting schematizable object containing the query string.
+//  */
+// export function QuerySchemeable(payload: IPayload['querystring']): (target: any, propertyKey: (string | symbol)) => void {
+//     return Schemeable({
+//         querystring: payload
+//     });
+// }
+//
+// /**
+//  * Creates a schematizable object using the provided parameters.
+//  *
+//  * @param {IPayload['params']} payload - The parameters to be used for creating the schematizable object.
+//  * @return {Object} The resulting schematizable object containing the specified parameters.
+//  */
+// export function ParamsSchemeable(payload: IPayload['params']): (target: any, propertyKey: (string | symbol)) => void {
+//     return Schemeable({
+//         params: payload
+//     });
+// }
+//
+// /**
+//  * Constructs a schematized response payload.
+//  *
+//  * @param {IPayload['response']} payload - The response payload to be schematized.
+//  * @return {object} The schematized response object.
+//  */
+// export function ResponseSchemeable(payload: IPayload['response']): (target: any, propertyKey: (string | symbol)) => void {
+//     return Schemeable({
+//         response: payload
+//     });
+// }

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

@@ -0,0 +1,48 @@
+import {getControllerMetadata} from "@/core";
+import {HttpMethod} from "@/sdk";
+import {ControllerMetaInterface, RouteDecoratorCallable, RouteMetaInterface} from "@/types";
+import path from "node:path";
+
+
+function stabilizeRoute(meta: ControllerMetaInterface, {path, method, propertyKey}: Partial<RouteMetaInterface>) {
+    return {
+        ...meta.routes.filter(route => (route.path === path && route.method === method) || (route.propertyKey === propertyKey))[0] || {},
+        method,
+        path,
+        propertyKey,
+        params: (propertyKey ? meta.params[propertyKey] : []) || [],
+    } as RouteMetaInterface;
+}
+
+export function createRoutableDecorator(method: HttpMethod) {
+    return (path = '') =>
+        (target: any, propertyKey: string) => {
+            const meta: ControllerMetaInterface = getControllerMetadata(target);
+            const route = stabilizeRoute(meta, {
+                method,
+                path,
+                propertyKey,
+                params: meta.params[propertyKey] || [],
+            });
+            meta.routes.push(route)
+        }
+}
+
+export function createRouteDecorator(callable: RouteDecoratorCallable) {
+    return (target: any, propertyKey: string) => {
+        const controller: ControllerMetaInterface = getControllerMetadata(target);
+        const route: RouteMetaInterface = stabilizeRoute(controller, {propertyKey})
+        const index = controller.routes.findIndex(route => route.propertyKey === propertyKey)
+
+        callable({controller, route, index})
+    }
+}
+
+export const Get = createRoutableDecorator(HttpMethod.GET)
+export const Post = createRoutableDecorator(HttpMethod.POST)
+export const Put = createRoutableDecorator(HttpMethod.PUT)
+export const Patch = createRoutableDecorator(HttpMethod.PATCH)
+export const Options = createRoutableDecorator(HttpMethod.OPTIONS)
+export const Trace = createRoutableDecorator(HttpMethod.TRACE)
+export const Delete = createRoutableDecorator(HttpMethod.DELETE)
+export const Head = createRoutableDecorator(HttpMethod.HEAD)

package/source/sdk/encryption.ts

@@ -0,0 +1,155 @@
+
+import crypto from "node:crypto";
+import argon2, {Options} from "argon2";
+import {HashAlgoEnum} from "./enums";
+import bcrypt from "bcrypt";
+import {IDerivationOptions, IEncryptionResult, IScryptOptions} from "@/types";
+
+export class Encryption {
+    static get algos() {
+        return HashAlgoEnum;
+    }
+
+    static randomAlgo() {
+        return Object.values(this.algos)[
+            Math.floor(Math.random() * Object.values(this.algos).length)
+            ];
+    }
+
+    constructor(public readonly algo: HashAlgoEnum) {
+        if (!Object.values(HashAlgoEnum).includes(this.algo)) {
+            throw new Error(`Invalid hash algorithm: ${this.algo}`);
+        }
+    }
+
+    async make(value: string, options?: IDerivationOptions | IScryptOptions): Promise<IEncryptionResult> {
+        if (!value) {
+            throw new Error('Value cannot be empty');
+        }
+
+        switch (this.algo) {
+            case HashAlgoEnum.SHA256:
+                return this.sha256(value);
+            case HashAlgoEnum.SHA512:
+                return this.sha512(value);
+            case HashAlgoEnum.MD5:
+                return this.md5(value);
+            case HashAlgoEnum.RIPEMD160:
+                return this.ripemd160(value);
+            case HashAlgoEnum.BLAKE2B:
+                return this.blake2b(value);
+            case HashAlgoEnum.SHA3_256:
+                return this.sha3_256(value);
+            case HashAlgoEnum.SHA3_512:
+                return this.sha3_512(value);
+            case HashAlgoEnum.PBKDF2:
+                return this.pbkdf2(value, options as IDerivationOptions | undefined);
+            case HashAlgoEnum.SCRYPT:
+                return this.scrypt(value, options as IScryptOptions | undefined);
+            case HashAlgoEnum.ARGON2ID:
+            case HashAlgoEnum.BCRYPT:
+                return this.password(value);
+            default:
+                throw new Error(`Unsupported algorithm: ${this.algo}`);
+        }
+    }
+
+    protected sha256(value: string): IEncryptionResult {
+        return crypto.createHash("sha256").update(value).digest("hex");
+    }
+
+    protected sha512(value: string): IEncryptionResult {
+        return crypto.createHash("sha512").update(value).digest("hex");
+    }
+
+    protected md5(value: string): IEncryptionResult {
+        return crypto.createHash("md5").update(value).digest("hex");
+    }
+
+    protected ripemd160(value: string): IEncryptionResult {
+        return crypto.createHash("ripemd160").update(value).digest("hex");
+    }
+
+    protected blake2b(value: string): IEncryptionResult {
+        return crypto.createHash("blake2b512").update(value).digest("hex");
+    }
+
+    protected sha3_256(value: string): IEncryptionResult {
+        return crypto.createHash("sha3-256").update(value).digest("hex");
+    }
+
+    protected sha3_512(value: string): IEncryptionResult {
+        return crypto.createHash("sha3-512").update(value).digest("hex");
+    }
+
+    protected pbkdf2(value: string, options?: IDerivationOptions): IEncryptionResult {
+        const {salt, iterations, keylen, digest} = options || {};
+        const usedSalt = salt ?? crypto.randomBytes(16).toString("hex");
+        const usedIterations = iterations ?? 100_000;
+        const usedKeylen = keylen ?? 64;
+        const usedDigest = digest ?? "sha512";
+        const derived = crypto
+            .pbkdf2Sync(value, Buffer.from(usedSalt, "hex"), usedIterations, usedKeylen, usedDigest)
+            .toString("hex");
+        return `pbkdf2$${usedDigest}$${usedIterations}$${usedSalt}$${derived}`;
+    }
+
+    protected scrypt(value: string, options?: IScryptOptions): IEncryptionResult {
+        const {salt, keylen, cost, blockSize, parallelization} = options || {} as IScryptOptions;
+        const usedSalt = salt ?? crypto.randomBytes(16).toString("hex");
+        const usedKeylen = keylen ?? 64;
+        const usedCost = cost ?? 16384; // N
+        const usedBlockSize = blockSize ?? 8; // r
+        const usedParallel = parallelization ?? 1; // p
+        const derived = crypto
+            .scryptSync(value, Buffer.from(usedSalt, "hex"), usedKeylen, {
+                N: usedCost,
+                r: usedBlockSize,
+                p: usedParallel,
+                maxmem: 32 * 1024 * 1024,
+            })
+            .toString("hex");
+        return `scrypt$${usedCost}$${usedBlockSize}$${usedParallel}$${usedSalt}$${derived}`;
+    }
+
+    protected unsupported(): never {
+        throw new Error(`${this.algo} not supported without optional dependency`);
+    }
+
+    async password(value: string, options?: (Options & {
+        raw?: boolean
+    }) | (string | number) | undefined): Promise<IEncryptionResult> {
+        switch (this.algo) {
+            case HashAlgoEnum.ARGON2ID: {
+                return await argon2.hash(value, {
+                    ...(typeof options === 'object' ? options : {}),
+                    type: argon2.argon2id
+                });
+            }
+            case HashAlgoEnum.BCRYPT: {
+                try {
+                    const saltRounds = 12;
+                    return await bcrypt.hash(
+                        value,
+                        (typeof options === 'string' || typeof options === 'number') ? options : saltRounds
+                    );
+                } catch (e) {
+                    throw new Error(`BCRYPT not supported without optional dependency "bcrypt"`);
+                }
+            }
+            default:
+                throw new Error(`password() is only available for BCRYPT and ARGON2ID (current: ${this.algo})`);
+        }
+    }
+
+    async checkPassword(hash: string, password: string): Promise<boolean> {
+        switch (this.algo) {
+            case HashAlgoEnum.ARGON2ID:
+                return await argon2.verify(hash, password);
+            case HashAlgoEnum.BCRYPT:
+                return await bcrypt.compare(password, hash);
+        }
+        return false;
+    }
+
+}

package/source/sdk/enums/encrypted.enum.ts

@@ -0,0 +1,13 @@
+export enum HashAlgoEnum {
+    ARGON2ID = 'ARGON2ID',
+    BCRYPT = 'BCRYPT',
+    PBKDF2 = 'PBKDF2',
+    SCRYPT = 'SCRYPT',
+    SHA256 = 'SHA256',
+    SHA512 = 'SHA512',
+    MD5 = 'MD5',
+    RIPEMD160 = 'RIPEMD160',
+    BLAKE2B = 'BLAKE2B',
+    SHA3_256 = 'SHA3_256',
+    SHA3_512 = 'SHA3_512',
+}

package/source/sdk/enums/event.message.enum.ts

@@ -0,0 +1,4 @@
+export enum EventMessageEnum {
+    RESTART = ":restart",
+    STOP = ":stop",
+}

package/{build/sdk/enums/http-parameters.enum.d.ts → source/sdk/enums/http-parameters.enum.ts}

@@ -1,4 +1,4 @@
-declare enum Parametrable {
+export enum Parametrable {
     PARAM = "param",
     BODY = "body",
     QUERY = "query",
@@ -6,7 +6,5 @@ declare enum Parametrable {
     REQ = "req",
     REPLY = "reply",
     UPLOAD_FILE = "upload",
-    CUSTOM = "custom"
-}
-
-export { Parametrable };
+    CUSTOM = "custom",
+}

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

@@ -0,0 +1,10 @@
+export enum HttpMethod {
+    GET = 'GET',
+    POST = 'POST',
+    PUT = 'PUT',
+    DELETE = 'DELETE',
+    PATCH = 'PATCH',
+    OPTIONS = 'OPTIONS',
+    HEAD = 'HEAD',
+    TRACE = 'TRACE',
+}

package/source/sdk/enums/index.ts

@@ -0,0 +1,6 @@
+export * from "./http.enum"
+export * from "./http-parameters.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/index.ts

@@ -0,0 +1,6 @@
+export * from "./enums/index"
+export * from "./constants/index"
+export * from "./decorators/index"
+export * from "./plugins/index"
+export * from "./utilities/index"
+export * from "./runtime/index"