raiton 1.1.1

package/build/types/middleware.d.ts

@@ -0,0 +1,12 @@
+import { RequestContext } from '../core/context.js';
+import './runtime.js';
+import '../sdk/enums/runtime.enum.js';
+
+type Next = () => Promise<void>;
+type MiddlewareStepped = {
+    setup: any;
+    name: string;
+};
+type Middleware = ((ctx: RequestContext, next: Next) => Promise<any> | void) | MiddlewareStepped;
+
+export type { Middleware, MiddlewareStepped, Next };

package/build/types/parameters.d.ts

@@ -0,0 +1,19 @@
+import { Parametrable } from '../sdk/enums/http-parameters.enum.js';
+import { FastifyRequest, FastifyReply } from 'fastify';
+
+interface RouteParametersMetadataPayload {
+    request: FastifyRequest;
+    reply: FastifyReply;
+    files: AsyncIterableIterator<any> | any[];
+}
+type RouteParametersMetadataCallable = (payload: RouteParametersMetadataPayload) => any[];
+interface RouteParametersMetadataInterface {
+    index: number;
+    type: Parametrable;
+    key: string;
+    multiple: boolean;
+    optional: boolean;
+    callable?: RouteParametersMetadataCallable;
+}
+
+export type { RouteParametersMetadataCallable, RouteParametersMetadataInterface, RouteParametersMetadataPayload };

package/build/types/parseable.d.ts

@@ -0,0 +1,5 @@
+type IParseableEntry = string | number | boolean | null | undefined | IParseableEntry[] | object;
+type IParseableEntries = Record<string, IParseableEntry>;
+type IParseablePrimitiveEntry<T extends IParseableEntries> = string | T | null;
+
+export type { IParseableEntries, IParseableEntry, IParseablePrimitiveEntry };

package/build/types/payload.d.ts

@@ -0,0 +1,6 @@
+import { FastifySchema } from 'fastify/types/schema';
+
+interface IPayload extends FastifySchema {
+}
+
+export type { IPayload };

package/build/types/plugin.d.ts

@@ -0,0 +1,20 @@
+import { PluginScope } from '../core/plugins/scope.js';
+import '../core/hooks.js';
+import './core.js';
+import './runtime.js';
+import '../sdk/enums/runtime.enum.js';
+import '../core/middleware/pipeline.js';
+import './middleware.js';
+import '../core/context.js';
+import '../core/router/route.js';
+import './router.js';
+import '../sdk/enums/http.enum.js';
+import '../core/router/router.js';
+
+type PluginFn = (scope: PluginScope) => Promise<void> | void;
+interface Plugin {
+    name?: string;
+    setup: PluginFn;
+}
+
+export type { Plugin, PluginFn };

package/build/types/raiton.d.ts

@@ -0,0 +1,12 @@
+import { BuilderHMRDeclaration } from './builder.js';
+import { Metafile } from 'esbuild';
+import './hmr.js';
+
+interface RaitonSignalMap {
+    ready?: undefined;
+    errors: any;
+    'hmr:controller': BuilderHMRDeclaration;
+    'hmr:triggered': Metafile | undefined;
+}
+
+export type { RaitonSignalMap };

package/build/types/repositories.d.ts

@@ -0,0 +1,8 @@
+import { IDependencyContainerDefinition } from './dependency-container.js';
+import './contruct.js';
+import '@protorians/core';
+
+interface IRepositoryDefinition<T = any> extends IDependencyContainerDefinition<T> {
+}
+
+export type { IRepositoryDefinition };

package/build/types/router.d.ts

@@ -0,0 +1,14 @@
+import { RequestContext } from '../core/context.js';
+import { HttpMethod } from '../sdk/enums/http.enum.js';
+import './runtime.js';
+import '../sdk/enums/runtime.enum.js';
+
+type RouteHandler = (ctx: RequestContext) => Promise<any> | any;
+interface RouteDefinition {
+    method: HttpMethod;
+    path: string;
+    version?: string;
+    handler: RouteHandler;
+}
+
+export type { RouteDefinition, RouteHandler };

package/build/types/runtime.d.ts

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

package/build/types/scheme.d.ts

@@ -0,0 +1,128 @@
+import { TSchema, TProperties, TObject } from '@sinclair/typebox';
+
+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.
+ * It allows dynamic assignment of schema properties and the retrieval of constructed schema configurations.
+ *
+ * @template TBody The schema type defining the request body.
+ * @template TParams The schema type defining the request parameters.
+ * @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> {
+    /**
+     * 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.
+     *
+     * @param {string} key - The key to be added or updated in the body of the request.
+     * @param {TProperties} value - The value associated with the specified key.
+     * @return {this} The current instance to allow method chaining.
+     */
+    body(key: string, value: TProperties): this;
+    /**
+     * Retrieves the current value of `$params`.
+     *
+     * This method returns the parameter(s) associated with the instance.
+     * It may return undefined if no parameters are set.
+     *
+     * @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.
+     *
+     * @param {string} key - The key for the parameter to be set.
+     * @param {TProperties} value - The value associated with the specified key.
+     * @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.
+     *
+     * @param {string} key - The key of the query string parameter to be updated or added.
+     * @param {TProperties} value - The value to be set for the specified query string key.
+     * @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.
+     *
+     * @param {number} key - The unique identifier for the value to be stored.
+     * @param {TProperties} value - The value to store associated with the provided key.
+     * @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.
+     *
+     * @return {ISchemeOptions<TBody, TParams, TQuery, TResponse>} The schema options defining the types for body, params, query, and response.
+     */
+    schema(): ISchemeOptions<TBody, TParams, TQuery, TResponse>;
+}
+/**
+ * Interface representing the schema configuration for various aspects of a request-response process.
+ *
+ * @template TBody Represents the schema for the request body. Defaults to undefined if not specified.
+ * @template TParams Represents the schema for request parameters. Defaults to undefined if not specified.
+ * @template TQuery Represents the schema for query string parameters. Defaults to undefined if not specified.
+ * @template TResponse Represents the schema for response objects, mapped by status codes. Defaults to undefined if not specified.
+ *
+ * @property {TBody} [body] Optional schema definition for the request body.
+ * @property {TParams} [params] Optional schema definition for the request parameters.
+ * @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> {
+    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.
+ *
+ * @template TBody - The type of the schema for the request body, or undefined if not applicable.
+ * @template TParams - The type of the schema for the request parameters, or undefined if not applicable.
+ * @template TQuery - The type of the schema for the query string, or undefined if not applicable.
+ * @template TResponse - A record of HTTP status codes to their respective response schemas, or undefined if not applicable.
+ *
+ * @property body - Represents the schema definition for the request body.
+ *                   This is an optional property and only applies if TBody is specified.
+ * @property params - Represents the schema definition for the request parameters.
+ *                     This is an optional property and only applies if TParams is specified.
+ * @property querystring - Represents the schema definition for the query string.
+ *                          This is an optional property and only applies if TQuery is specified.
+ * @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> {
+    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/build/types/server.d.ts

@@ -0,0 +1,57 @@
+import { FastifyRequest, FastifyReply, FastifyInstance } from 'fastify';
+import { ISchemeOptions } from './scheme.js';
+import { TSchema } from '@sinclair/typebox';
+import { ISignalStack } from '@protorians/core';
+import { Metafile } from 'esbuild';
+
+interface ServerOptions {
+    workdir: string;
+    prefix?: string;
+    develop?: boolean;
+    port?: number;
+    verbose?: boolean;
+    trustProxy?: boolean;
+}
+type ServerFeaturesUsed = Map<string, any>;
+interface ServerInterface {
+    readonly options: ServerOptions;
+    readonly controllers: Map<string, ServerControllerInterface>;
+    readonly signals: ISignalStack<ServerSignalMap>;
+    get runner(): FastifyInstance;
+    get feature(): ServerFeaturesUsed;
+    useAuthenticate(): Promise<this>;
+    useFormbody(): Promise<this>;
+    useMultipart(): Promise<this>;
+    useSwagger(): Promise<this>;
+    usePublicDirectory(directory?: string): Promise<this>;
+    prepare(): Promise<this>;
+    start(): Promise<this>;
+}
+interface ServerRouteInterface {
+    method: string;
+    path: string;
+    name: string;
+    url: string;
+    paramsMetadata: any[];
+    schema?: ISchemeOptions<TSchema, TSchema, TSchema, Record<number, TSchema>> | undefined;
+}
+interface ServerControllerInterface {
+    prefix: string;
+    routes: ServerRouteInterface[];
+    instance: (...args: any[]) => Record<string, Function>;
+    filename?: string;
+    handler: (handleName: string, params: any[]) => (req: FastifyRequest, reply: FastifyReply) => Promise<any>;
+}
+interface ServerHMRDeclaration {
+    filename: string;
+    timestamp?: number;
+    version?: number;
+}
+interface ServerSignalMap {
+    ready: undefined;
+    errors: any;
+    'hmr:controller': ServerHMRDeclaration;
+    'hmr:triggered': Metafile | undefined;
+}
+
+export type { ServerControllerInterface, ServerFeaturesUsed, ServerHMRDeclaration, ServerInterface, ServerOptions, ServerRouteInterface, ServerSignalMap };

package/build/types/services.d.ts

@@ -0,0 +1,8 @@
+import { IDependencyContainerDefinition } from './dependency-container.js';
+import './contruct.js';
+import '@protorians/core';
+
+interface IGraftDefinition<T = any> extends IDependencyContainerDefinition<T> {
+}
+
+export type { IGraftDefinition };

package/build/types/thread.d.ts

@@ -0,0 +1,24 @@
+import { BuilderInterface } from './builder.js';
+import { ApplicationInterface } from './application.js';
+import { RuntimeType } from '../sdk/enums/runtime.enum.js';
+import 'esbuild';
+import './hmr.js';
+import '../sdk/enums/http.enum.js';
+
+interface ThreadSetupOptions {
+    application: ApplicationInterface;
+    runtime?: RuntimeType;
+}
+type ThreadWaitCallable = () => (boolean | Promise<boolean>);
+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 type { ThreadInterface, ThreadSetupOptions, ThreadWaitCallable };

package/build/types/utilities.d.ts

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

package/build/types/values.d.ts

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

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "raiton",
+  "version": "1.1.1",
+  "private": false,
+  "type": "module",
+  "description": "Protorians Raiton Development Kit",
+  "bin": {
+    "raiton": "build/bin/index.mjs"
+  },
+  "keywords": [
+    "protorians",
+    "raiton"
+  ],
+  "author": "Y. Yannick GOBOU",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/protorians/raiton.git"
+  },
+  "exports": {
+    "./core/*": {
+      "types": "./build/core/*.d.ts",
+      "import": "./build/core/*.mjs"
+    },
+    ".": {
+      "types": "./build/core/index.d.ts",
+      "import": "./build/core/index.mjs"
+    },
+    "./commands/*": {
+      "types": "./build/commands/*.d.ts",
+      "import": "./build/commands/*.mjs"
+    },
+    "./sdk/*": {
+      "types": "./build/sdk/*.d.ts",
+      "import": "./build/sdk/*.mjs"
+    },
+    "./sdk": {
+      "types": "./build/sdk/index.d.ts",
+      "import": "./build/sdk/index.mjs"
+    },
+    "./types/*": {
+      "types": "./build/types/index.d.ts",
+      "import": "./build/types/index.mjs"
+    }
+  },
+  "scripts": {
+    "dev": "tsup --watch --config tsup.config.ts",
+    "build": "tsup --config tsup.config.ts",
+    "commit": "pnpx semantic-release",
+    "commit:test": "pnpx semantic-release --dry-run"
+  },
+  "dependencies": {
+    "@protorians/core": "^0.6.13",
+    "@protorians/events-bus": "^0.0.1",
+    "@protorians/logger": "^0.0.10",
+    "@protorians/parameters": "^0.0.5",
+    "@sinclair/typebox": "^0.34.41",
+    "@types/node": "^25.0.3",
+    "argon2": "^0.44.0",
+    "bcrypt": "^6.0.0",
+    "commander": "^14.0.2",
+    "dotenv": "^17.2.3",
+    "esbuild": "^0.27.1",
+    "fastify": "^5.6.2",
+    "fastify-plugin": "^5.1.0",
+    "reflect-metadata": "^0.2.2"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.2",
+    "@semantic-release/npm": "^13.1.2",
+    "@types/bcrypt": "^6.0.0",
+    "@types/bun": "^1.3.5",
+    "@types/deno": "^2.5.0",
+    "commitizen": "^4.3.1",
+    "conventional-changelog-conventionalcommits": "^9.1.0",
+    "cz-conventional-changelog": "^3.3.0",
+    "semantic-release": "^25.0.2",
+    "tsup": "^8.3.0",
+    "typescript": "^5.9.3"
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
+  },
+  "compilerOptions": {
+    "types": [
+      "node"
+    ]
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}