raiton 0.0.2 → 1.0.0-alpha.1

package/source/types/artifact.ts

@@ -0,0 +1,40 @@
+export interface ArtifactEntry {
+    id: string;
+    timestamp: Date;
+    size: number;
+}
+
+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,48 @@
+import type {BuildContext, BuildOptions, Metafile} from "esbuild";
+import {HmrInterface} from "@/types/hmr";
+import {ISignalStack} from "@protorians/core";
+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 hmr: HmrInterface;
+    // 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 {ArtifactEntry} from "@/types/artifact";
+
+export interface Configurable {
+    rootDir: string;
+    version: string;
+    artifacts?: ArtifactEntry[]
+}

package/source/types/controller.ts

@@ -0,0 +1,34 @@
+import {HttpMethod, Parametrable} from "@/sdk/enums";
+import {Context} from "@/types/core";
+import {MiddlewareCallable, MiddlewareType} from "@/types/middleware";
+
+export interface ControllerMetaInterface {
+    prefix?: string;
+    routes: RouteMetaInterface[];
+    params: Record<string, ParamMetaInterface[]>;
+    middlewares: Record<string, MiddlewareCallable[]>;
+}
+
+export type ControllerDecoratorCallable = (metadata: ControllerMetaInterface) => void
+
+export interface RouteMetaInterface {
+    method: HttpMethod;
+    path: string;
+    propertyKey: string;
+    params: ParamMetaInterface[];
+}
+
+export interface ParamMetaInterface {
+    index: number;
+    type: Parametrable;
+    key?: string;
+    callable?: (ctx: Context) => 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/source/types/data-transfer-object.ts

@@ -0,0 +1,4 @@
+import {type IDynamicProps} from "@protorians/parameters";
+
+
+export type IDataTransferObject<T> = IDynamicProps<T>

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

@@ -1,25 +1,39 @@
-interface HMRMetadataInterface {
+export interface HMRMetadataInterface {
     version: number;
     timestamp: number;
     filename: string;
     size: number;
 }
-interface HmrInterface {
+
+export interface HmrInterface {
     entries(): Record<string, HMRMetadataInterface>;
+
     set(key: string, filename: string, size: number): this;
+
     get(key: string): HMRMetadataInterface | undefined;
+
     getKeys(): string[];
+
     getValues(): Array<HMRMetadataInterface>;
+
     getEntries(): Array<[string, HMRMetadataInterface]>;
-    each(callable: (value: HMRMetadataInterface, key: string, map: Map<string, HMRMetadataInterface>) => void | Promise<void>): Promise<this>;
+
+    each(callable: (value: HMRMetadataInterface, key: string, map: Map<string, HMRMetadataInterface>) => void| Promise<void>): Promise<this>
+
     unset(key: string): this;
+
     clear(): this;
+
     load<T>(key: string): Promise<T | undefined>;
+
     reload<T>(key: string): Promise<T | undefined>;
+
     has(key: string): boolean;
+
     upsert<T>(key: string, filename: string, size: number): Promise<T | undefined>;
+
     size(): number;
+
     refresh(): Promise<this>;
-}
 
-export type { HMRMetadataInterface, HmrInterface };
+}

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,26 @@
+export type * from "./config"
+export type * from "./builder"
+export type * from "./thread"
+export type * from "./access-guards"
+export type * from "./contruct"
+export type * from "./data-transfer-object"
+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 "./hmr"
+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"

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/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,9 @@
+import {BuilderHMRDeclaration} from "@/types/builder";
+import {Metafile} from "esbuild";
+
+export interface RaitonSignalMap {
+    ready?: undefined;
+    errors: any;
+    'hmr:controller': BuilderHMRDeclaration;
+    'hmr:triggered': Metafile | undefined;
+}

package/source/types/responses.ts

@@ -0,0 +1,10 @@
+import type {ParseableEntriesType} from "@/types/parseable";
+
+export interface ResponseParameters {
+    readonly message?: string;
+    readonly error?: boolean;
+    readonly statusCode?: number;
+    readonly errorStack?: Error;
+    readonly data?: ParseableEntriesType
+}
+

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,53 @@
+import {RuntimeType} from "@/sdk/enums/runtime.enum";
+
+export interface RuntimeServerInterface {
+    listen(port: number): 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>
+    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[]>;

package/.releaserc.json

@@ -1,45 +0,0 @@
-{
-  "branches": [
-    {
-      "name": "main",
-      "prerelease": false
-    },
-    {
-      "name": "beta",
-      "prerelease": true
-    },
-    {
-      "name": "alpha",
-      "prerelease": true
-    }
-  ],
-  "plugins": [
-    "@semantic-release/commit-analyzer",
-    "@semantic-release/release-notes-generator",
-    [
-      "@semantic-release/changelog",
-      {
-        "changelogFile": "CHANGELOG.md"
-      }
-    ],
-    [
-      "@semantic-release/npm",
-      {
-        "npmPublish": true,
-        "tarballDir": "build",
-        "provenance": true
-      }
-    ],
-    [
-      "@semantic-release/git",
-      {
-        "assets": [
-          "package.json",
-          "CHANGELOG.md"
-        ],
-        "message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
-      }
-    ],
-    "@semantic-release/github"
-  ]
-}

package/build/bin/bootstrapper.d.ts

@@ -1,5 +0,0 @@
-import { Command } from 'commander';
-
-declare function bootstrapper(cli: Command): Promise<Command>;
-
-export { bootstrapper as default };