raiton 1.1.1 → 3.0.1

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>;
+}

package/source/types/artifact.ts

@@ -0,0 +1,44 @@
+export interface ArtifactEntry {
+    id: string;
+    timestamp: Date;
+    size: number;
+}
+
+export interface ArtifactsConfig {
+    types: string[]
+}
+
+// export type ArtifactDecoratorHandler = () => void;
+
+// export interface ArtifactDecorator {
+//     syntax: RegExp;
+//     handler: ArtifactDecoratorHandler;
+// }
+
+// export interface ArtifactOptions {
+//     readonly artifact: string;
+//     readonly provider: string;
+//     readonly decorator: ArtifactDecorator;
+//     verbose?: boolean;
+// }
+
+// export interface ArtifactInterface {
+//     readonly options: ArtifactOptions;
+//     readonly directory: string;
+//     readonly file: string;
+//     readonly workdir: string;
+//
+//     get files(): string[];
+//
+//     get extensions(): string[];
+//
+//     scan(): string[];
+//
+//     generate(): boolean;
+// }
+
+// export interface ArtifactEntry {
+//     vendor: string;
+//     decorator: string;
+//     pattern: string;
+// }

package/source/types/builder.ts

@@ -0,0 +1,44 @@
+import {WatchEventType} from "node:fs";
+
+export interface BuildCommandOptions {
+    develop?: boolean;
+    bootstrap?: boolean;
+}
+
+export interface BuilderConfig {
+    development?: boolean;
+}
+
+export type BuilderBootCallable = (builder: BuilderInterface) => Promise<void>
+
+export interface BuilderInterface {
+    readonly workdir: string;
+    readonly options: BuilderConfig;
+    // readonly signal: ISignalStack<BuilderSignalMap>;
+
+    // get context(): BuildContext<BuildOptions> | null;
+
+    get source(): string | null;
+
+    get out(): string | null;
+
+    get bootstrapper(): string | null;
+
+    get bootstrapperFile(): string | null;
+
+    // get baseConfig(): BuildOptions;
+
+    prepare(): Promise<this>;
+
+    boot(): Promise<any>;
+
+    // start(callable?: BuilderBootCallable): Promise<this>;
+}
+
+
+export interface BuilderHMRDeclaration {
+    filename: string;
+    timestamp?: number;
+    version?: number;
+    type?: WatchEventType
+}

package/source/types/config.ts

@@ -0,0 +1,7 @@
+import type {ArtifactsConfig} from "@/types/artifact";
+
+export interface Configurable {
+    rootDir: string;
+    version: string;
+    artifacts?: ArtifactsConfig
+}

package/source/types/controller.ts

@@ -0,0 +1,33 @@
+import {HttpMethod, Parametrable} from "@/sdk/enums";
+import {Context} from "@/types/core";
+import {MiddlewareCallable, MiddlewareType} from "@/types/middleware";
+
+export interface ControllerMetaInterface {
+    prefix?: string;
+    routes: RouteMetaInterface[];
+    middlewares: Record<string, MiddlewareCallable[]>;
+}
+
+export type ControllerDecoratorCallable = (metadata: ControllerMetaInterface) => void
+
+export interface RouteMetaInterface {
+    method: HttpMethod;
+    path: string;
+    propertyKey: string;
+}
+
+export interface ParamMetaInterface {
+    index: number;
+    type: Parametrable;
+    key?: string;
+    callable?: (ctx: Context) => any;
+    metatype?: any;
+}
+
+export interface RouteDecoratorParameters {
+    controller: ControllerMetaInterface;
+    route: RouteMetaInterface;
+    index: number;
+}
+
+export type RouteDecoratorCallable = (parameters: RouteDecoratorParameters) => void;

package/source/types/contruct.ts

@@ -0,0 +1,3 @@
+
+
+export type IConstructor<T = any> = new (...args: any[]) => T;

package/source/types/core.ts

@@ -0,0 +1,28 @@
+import type {
+    RuntimeRequestInterface,
+    RuntimeReplyInterface
+} from './runtime'
+
+export type HookName =
+    | 'onRequest'
+    | 'preParsing'
+    | 'preHandler'
+    | 'onSend'
+    | 'onResponse'
+
+export type HookHandler = (
+    ctx: Context
+) => Promise<void> | void
+
+export interface Context {
+    req: RuntimeRequestInterface
+    reply: RuntimeReplyInterface
+
+    state: Record<string, any>
+
+    decorate<T = any>(key: string, value: T): void
+
+    get<T = any>(key: string): T
+
+    send(body: any): void
+}

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

@@ -1,8 +1,8 @@
-interface IFileStatInfo {
+
+
+export interface IFileStatInfo {
     absolute: string;
     relative: string;
     dir: string;
     file: string;
-}
-
-export type { IFileStatInfo };
+}

package/source/types/encryption.ts

@@ -0,0 +1,17 @@
+
+export type IEncryptionResult = string;
+
+export interface IDerivationOptions {
+    salt?: string; // hex string; if not provided, a random 16-byte salt will be generated
+    iterations?: number; // for PBKDF2
+    keylen?: number; // bytes length for derived key (default 64)
+    digest?: string; // for PBKDF2 digest (default 'sha512')
+}
+
+export interface IScryptOptions {
+    salt?: string; // hex string; if not provided, a random 16-byte salt will be generated
+    keylen?: number; // bytes length for derived key (default 64)
+    cost?: number; // N parameter (default 16384)
+    blockSize?: number; // r parameter (default 8)
+    parallelization?: number; // p parameter (default 1)
+}

package/source/types/generic.ts

@@ -0,0 +1,3 @@
+export type IGenericValue = 'string' | 'int' | 'bigInt' | 'float' | 'boolean'
+
+export type IGenericValueType = IGenericValue | 'array' | 'object' | 'function' | undefined;

package/source/types/http-responses.ts

@@ -0,0 +1,8 @@
+import {ParseableEntriesType, ParseableType} from "./parseable";
+
+export interface IHttpResponse<T extends ParseableType> extends ParseableEntriesType {
+    statusCode: number,
+    message?: string,
+    data?: T,
+    error?: any,
+}

package/source/types/index.ts

@@ -0,0 +1,25 @@
+export type * from "./config"
+export type * from "./builder"
+export type * from "./thread"
+export type * from "./access-guards"
+export type * from "./contruct"
+export type * from "./directory"
+export type * from "./encryption"
+export type * from "./generic"
+export type * from "./http-responses"
+export type * from "./parseable"
+export type * from "./scheme"
+export type * from "./values"
+export type * from "./utilities"
+export type * from "./artifact"
+export type * from "./middleware"
+export type * from "./core"
+export type * from "./plugin"
+export type * from "./runtime"
+export type * from "./router"
+export type * from "./controller"
+export type * from "./injection"
+export type * from "./responses"
+export type * from "./server"
+export type * from "./raiton"
+export type * from "./lifecycle"

package/source/types/injection.ts

@@ -0,0 +1,13 @@
+import {IConstructor} from "@/types/contruct";
+import {LifetimeEnum} from "@protorians/core";
+
+
+export interface ContainerDefinitionInterface<T = any> {
+    name: string;
+    construct: IConstructor<T>;
+    lifetime: LifetimeEnum;
+    instance?: any;
+    scope?: Symbol;
+    parameters?: any[];
+    properties?: Map<string | symbol, any>;
+}

package/source/types/lifecycle.ts

@@ -0,0 +1,11 @@
+export interface OnMount {
+    onMount(): void | Promise<void>;
+}
+
+export interface OnUnmount {
+    onUnmount(): void | Promise<void>;
+}
+
+export interface OnInit {
+    onInit(): void | Promise<void>;
+}

package/source/types/middleware.ts

@@ -0,0 +1,18 @@
+import {RequestContext} from "@/core/context";
+
+
+export type NextCallable = () => Promise<void>
+
+export interface MiddlewareSetupInterface {
+    setup: any,
+    name: string;
+}
+
+export interface MiddlewareParameters {
+    context: RequestContext;
+    next: NextCallable;
+}
+
+export type MiddlewareCallable = (parameters: MiddlewareParameters) => Promise<any> | void
+
+export type MiddlewareType = MiddlewareCallable | MiddlewareSetupInterface

package/source/types/parseable.ts

@@ -0,0 +1,7 @@
+
+
+export type ParseableType = string | number | boolean | null | undefined | ParseableType[] | object;
+
+export type ParseableEntriesType = Record<string, ParseableType>;
+
+export type ParseablePrimitiveType<T extends ParseableEntriesType> = string | T | null;

package/source/types/plugin.ts

@@ -0,0 +1,10 @@
+import {PluginScope} from "@/core/plugins/scope";
+
+export type PluginFn = (
+  scope: PluginScope
+) => Promise<void> | void
+
+export interface Plugin {
+  name?: string
+  setup: PluginFn
+}

package/source/types/raiton.ts

@@ -0,0 +1,7 @@
+import {BuilderHMRDeclaration} from "@/types/builder";
+
+export interface RaitonSignalMap {
+    ready?: undefined;
+    errors: any;
+    'hmr:controller': BuilderHMRDeclaration;
+}

package/source/types/responses.ts

@@ -0,0 +1,20 @@
+import {HttpStatus} from "@/sdk/enums/http-status.enum";
+
+export interface HttpResponseBaseInterface {
+    message: string;
+    statusCode?: HttpStatus;
+}
+
+export interface HttpResponseInterface<T = any> extends HttpResponseBaseInterface{
+    error?: boolean;
+    errorStack?: Error | ErrorResponseInterface[];
+    data?: T
+}
+
+export interface ErrorResponseInterface {
+    id: string;
+    message?: string;
+    code?: string;
+    statusCode?: HttpStatus;
+    error?: Error
+}

package/source/types/router.ts

@@ -0,0 +1,11 @@
+import {RequestContext} from "@/core/context";
+import {HttpMethod} from "@/sdk";
+
+export type RouteHandler = (ctx: RequestContext) => Promise<any> | any
+
+export interface RouteDefinition {
+    method: HttpMethod
+    path: string
+    version?: string
+    handler: RouteHandler
+}

package/source/types/runtime.ts

@@ -0,0 +1,56 @@
+import {RuntimeType} from "@/sdk/enums/runtime.enum";
+
+export interface RuntimeServerInterface {
+    listen(port: number, hostname?: string): Promise<void>
+
+    close(): Promise<void>
+
+    handle?(request: Request): Promise<Response>
+}
+
+export interface RuntimeRequestInterface {
+    method: string
+    url: string
+    headers: Headers
+    body?: ReadableStream<Uint8Array> | Uint8Array | Record<string, any> | null;
+    query?: Record<string, any>
+    params?: Record<string, any>
+    file?: any
+    files?: any
+    remoteAddress?: string
+}
+
+export type RuntimeHandlerCallable = (req: RuntimeRequestInterface, reply: RuntimeReplyInterface) => Promise<void>
+
+export interface RuntimeReplyInterface {
+    status(code: number): void
+
+    header(name: string, value: string): void
+
+    send(body: any): void
+
+    text(text: string | Buffer): void
+
+    json(data: any): void
+}
+
+export interface RuntimeAdapterInterface {
+    createServer(handler: RuntimeHandlerCallable): RuntimeServerInterface
+}
+
+
+export interface RuntimeInterface {
+    readonly type: RuntimeType;
+
+    get isNode(): boolean;
+
+    get isDeno(): boolean;
+
+    get isWeb(): boolean;
+
+    get isBun(): boolean
+
+    adapter(): RuntimeAdapterInterface;
+
+    createServer(handler: RuntimeHandlerCallable): RuntimeServerInterface;
+}

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

@@ -1,8 +1,10 @@
-import { TSchema, TProperties, TObject } from '@sinclair/typebox';
+import {TObject, TProperties, TSchema} from "@sinclair/typebox";
 
-interface ISchemePropertyOptions {
+
+export interface ISchemePropertyOptions {
     optional?: boolean;
 }
+
 /**
  * The `ISchematic` interface provides a structured contract for managing and constructing schemas
  * that define the shape of request bodies, parameters, query strings, and response structures.
@@ -13,13 +15,19 @@ interface ISchemePropertyOptions {
  * @template TQuery The schema type defining the query string.
  * @template TResponse The schema type defining the response structure, indexed by HTTP status codes.
  */
-interface IScheme<TBody extends TSchema | undefined = undefined, TParams extends TSchema | undefined = undefined, TQuery extends TSchema | undefined = undefined, TResponse extends Record<number, TSchema> | undefined = undefined> {
+export interface IScheme<
+    TBody extends TSchema | undefined = undefined,
+    TParams extends TSchema | undefined = undefined,
+    TQuery extends TSchema | undefined = undefined,
+    TResponse extends Record<number, TSchema> | undefined = undefined
+> {
     /**
      * Retrieves the value of the `$body` property.
      *
      * @return {TBody | undefined} The body content of type `TBody` or `undefined` if not set.
      */
     get $body(): TBody | undefined;
+
     /**
      * Updates the body of the request with a specified key-value pair.
      *
@@ -28,6 +36,7 @@ interface IScheme<TBody extends TSchema | undefined = undefined, TParams extends
      * @return {this} The current instance to allow method chaining.
      */
     body(key: string, value: TProperties): this;
+
     /**
      * Retrieves the current value of `$params`.
      *
@@ -37,6 +46,7 @@ interface IScheme<TBody extends TSchema | undefined = undefined, TParams extends
      * @return {TParams | undefined} The current parameters or undefined if none are set.
      */
     get $params(): TParams | undefined;
+
     /**
      * Assigns a key-value pair to the parameters of the current instance.
      *
@@ -45,12 +55,14 @@ interface IScheme<TBody extends TSchema | undefined = undefined, TParams extends
      * @return {this} The current instance with the updated parameter.
      */
     params(key: string, value: TProperties): this;
+
     /**
      * Retrieves the query string associated with the current object.
      *
      * @return {TQuery | undefined} The query string if defined, otherwise undefined.
      */
     get $querystring(): TQuery | undefined;
+
     /**
      * Updates or sets a query string parameter with the specified key and value.
      * If the query string already contains the key, its value will be updated.
@@ -60,12 +72,14 @@ interface IScheme<TBody extends TSchema | undefined = undefined, TParams extends
      * @return {this} The current instance to allow for method chaining.
      */
     querystring(key: string, value: TProperties): this;
+
     /**
      * Retrieves the response object associated with the instance.
      *
      * @return {TResponse | undefined} The response object if it exists, otherwise undefined.
      */
     get $response(): TResponse | undefined;
+
     /**
      * Stores a key-value pair in the response object and returns the current instance for chaining.
      *
@@ -74,6 +88,7 @@ interface IScheme<TBody extends TSchema | undefined = undefined, TParams extends
      * @return {this} Returns the current instance to allow method chaining.
      */
     response(key: number, value: TProperties): this;
+
     /**
      * Provides the schema options for handling the request and response structure.
      *
@@ -81,6 +96,7 @@ interface IScheme<TBody extends TSchema | undefined = undefined, TParams extends
      */
     schema(): ISchemeOptions<TBody, TParams, TQuery, TResponse>;
 }
+
 /**
  * Interface representing the schema configuration for various aspects of a request-response process.
  *
@@ -94,12 +110,18 @@ interface IScheme<TBody extends TSchema | undefined = undefined, TParams extends
  * @property {TQuery} [querystring] Optional schema definition for query string parameters.
  * @property {TResponse} [response] Optional schema definition for response objects, associated with HTTP status codes.
  */
-interface ISchemeConfig<TBody extends TSchema | undefined = undefined, TParams extends TSchema | undefined = undefined, TQuery extends TSchema | undefined = undefined, TResponse extends Record<number, TSchema> | undefined = undefined> {
+export interface ISchemeConfig<
+    TBody extends TSchema | undefined = undefined,
+    TParams extends TSchema | undefined = undefined,
+    TQuery extends TSchema | undefined = undefined,
+    TResponse extends Record<number, TSchema> | undefined = undefined
+> {
     body?: TBody;
     params?: TParams;
     querystring?: TQuery;
     response?: TResponse;
 }
+
 /**
  * Interface representing schema options for defining request and response payloads
  * in a structured and strongly-typed manner.
@@ -118,11 +140,14 @@ interface ISchemeConfig<TBody extends TSchema | undefined = undefined, TParams e
  * @property response - Represents the schema definition for the response body, mapped by status code.
  *                       This is an optional property and only applies if TResponse is specified.
  */
-interface ISchemeOptions<TBody extends TSchema | undefined = undefined, TParams extends TSchema | undefined = undefined, TQuery extends TSchema | undefined = undefined, TResponse extends Record<number, TSchema> | undefined = undefined> {
+export interface ISchemeOptions<
+    TBody extends TSchema | undefined = undefined,
+    TParams extends TSchema | undefined = undefined,
+    TQuery extends TSchema | undefined = undefined,
+    TResponse extends Record<number, TSchema> | undefined = undefined
+> {
     body?: TObject<NonNullable<TBody>> | undefined;
     params?: TObject<NonNullable<TParams>> | undefined;
     querystring?: TObject<NonNullable<TQuery>> | undefined;
     response?: TObject<NonNullable<TResponse>> | undefined;
-}
-
-export type { IScheme, ISchemeConfig, ISchemeOptions, ISchemePropertyOptions };
+}

package/source/types/server.ts

@@ -0,0 +1,12 @@
+export interface ServerInterface {
+    readonly options: ServerOptions;
+
+    option<K extends keyof ServerOptions>(key: K): ServerOptions[K];
+}
+
+export interface ServerOptions {
+    os?: string;
+    arch?: string;
+    ip?: string;
+    port?: string;
+}

package/source/types/thread.ts

@@ -0,0 +1,31 @@
+import {BuilderInterface} from "@/types/builder";
+import {RuntimeAdapterInterface} from "@/types/runtime";
+import {ApplicationInterface} from "@/types/application";
+import {RuntimeType} from "@/sdk/enums/runtime.enum";
+
+export interface ThreadSetupOptions {
+    application: ApplicationInterface;
+    runtime?: RuntimeType
+}
+
+export type ThreadWaitCallable = () => (boolean | Promise<boolean>)
+
+export interface ThreadInterface {
+    readonly appDir: string;
+    readonly builder: BuilderInterface;
+
+    setup(options: ThreadSetupOptions): this
+
+    run(): Promise<this>;
+
+    restart(): void;
+
+    stop(): void;
+
+    sleep(milliseconds: number): Promise<unknown>;
+
+    wait(condition: ThreadWaitCallable): Promise<void>;
+}
+
+
+export interface ThreadOptions{}

package/source/types/utilities.ts

@@ -0,0 +1,4 @@
+export interface FileSizeFormated {
+    size: number;
+    unit: string;
+}

package/source/types/values.ts

@@ -0,0 +1,3 @@
+
+export type IString = string | Object | null | undefined;
+export type IStringable = IString | IString[] | Promise<IString | IString[]>;