raiton 1.0.0-alpha.2 → 1.0.0-alpha.3

package/source/core/hmr.ts

@@ -1,106 +0,0 @@
-import {HmrInterface, HMRMetadataInterface} from "@/types";
-import {Logger} from "@protorians/logger";
-
-
-export class Hmr implements HmrInterface {
-    protected files: Map<string, HMRMetadataInterface> = new Map();
-
-    set(file: string, filename: string, size: number = 0) {
-
-        if(!filename.endsWith('.js')) return this;
-
-        this.files.set(file, {
-            filename,
-            size,
-            version: 1,
-            timestamp: Date.now(),
-        });
-        return this;
-    }
-
-    clear(): this {
-        this.files.clear();
-        return this;
-    }
-
-    entries(): Record<string, HMRMetadataInterface> {
-        return Object.fromEntries(this.files.entries());
-    }
-
-    has(key: string): boolean {
-        return this.files.has(key);
-    }
-
-    async refresh(): Promise<this> {
-        await this.each(async (file, key) => await this.upsert(key, file.filename));
-        return this;
-    }
-
-    async load<T>(key: string): Promise<T | undefined> {
-        const file = this.files.get(key);
-        Logger.log('HMR', file)
-
-        const mod = file ? await import(`${file.filename}?t=${file.timestamp}&v=${file.version}`) : undefined;
-        return mod as T | undefined;
-    }
-
-    async reload<T>(key: string): Promise<T | undefined> {
-        const file = this.files.get(key);
-
-        if (!file) return undefined;
-
-        file.version++
-        file.timestamp = Date.now();
-        this.files.set(key, file);
-
-        return await import(`${file.filename}?t=${file.timestamp}&v=${file.version}`);
-    }
-
-    unset(key: string): this {
-        this.files.delete(key);
-        return this;
-    }
-
-    size(): number {
-        return this.files.size;
-    }
-
-    async each(callable: (value: HMRMetadataInterface, key: string, map: Map<string, HMRMetadataInterface>) => void | Promise<void>): Promise<this> {
-        await Promise.all([...this.files.entries()].map(async ([key, value]) => await callable(value, key, this.files)));
-        return this;
-    }
-
-    get(key: string): HMRMetadataInterface | undefined {
-        return this.files.get(key);
-    }
-
-    getEntries(): Array<[string, HMRMetadataInterface]> {
-        return [...this.files.entries()];
-    }
-
-    getKeys(): string[] {
-        return [...this.files.keys()];
-    }
-
-    getValues(): Array<HMRMetadataInterface> {
-        return [...this.files.values()];
-    }
-
-    async upsert<T>(key: string, filename: string, size: number = 0): Promise<T | undefined> {
-        let file: HMRMetadataInterface | undefined = this.files.get(key);
-
-        if (!file) {
-            this.set(key, filename);
-            file = this.files.get(key);
-        }
-
-        if (!file) return undefined;
-        if (file.size === size) return undefined;
-
-        file.version++;
-        file.timestamp = Date.now();
-        file.size = size;
-
-        return await this.set(key, filename, size).load(key);
-    }
-}

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

@@ -1,77 +0,0 @@
-// 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/json.ts

@@ -1,55 +0,0 @@
-import {ParseableEntriesType, ParseablePrimitiveType} from "../types/parseable";
-import {stabilizeJson} from "./utilities";
-
-
-export class Json<T extends ParseableEntriesType> {
-
-    public readonly stack: Map<keyof T, T[keyof T]> = new Map();
-
-    constructor(json: ParseablePrimitiveType<T>) {
-        this.records(stabilizeJson<T>(json));
-    }
-
-    records(data: T): this {
-        for (const [key, value] of Object.entries(data))
-            this.stack.set(key as keyof T, value as T[keyof T]);
-        return this;
-    }
-
-    get<K extends keyof T>(key: K): T[K] {
-        return this.stack.get(key) as T[K];
-    }
-
-    set<K extends keyof T>(key: K, value: T[K]): this {
-        this.stack.set(key, value);
-        return this;
-    }
-
-    remove<K extends keyof T>(key: K): this {
-        this.stack.delete(key);
-        return this;
-    }
-
-    clear(): this {
-        this.stack.clear();
-        return this;
-    }
-
-    render(): T {
-        return Object.fromEntries(this.stack) as any as T;
-    }
-
-    static stabilize<T>(json: string | T | null): T {
-        return stabilizeJson<T>(json);
-    }
-
-    static from<T extends ParseableEntriesType>(data: T): Json<T> {
-        const json = new Json<T>(null);
-        json.records(data);
-        return json;
-    }
-
-    static records<T extends ParseableEntriesType>(support: Json<T>, data: ParseablePrimitiveType<T>): Json<T> {
-        return support.records(this.stabilize(data));
-    }
-}

package/source/sdk/request.ts

@@ -1,3 +0,0 @@
-export class RaitonRequest {
-
-}

package/source/sdk/responses.ts

@@ -1,45 +0,0 @@
-import type {IHttpResponse, ParseableType, ResponseParameters} from "@/types";
-import {RequestContext} from "@/core/context";
-
-export function httpResponse<T extends ParseableType>(
-    statusCode: number,
-    message?: string,
-    data?: T,
-    error?: any,
-): IHttpResponse<T> {
-    return {
-        statusCode,
-        message,
-        data,
-        error,
-    }
-}
-
-export function successResponse<T extends ParseableType>(
-    message?: string,
-    data?: T,
-    error?: any,
-): IHttpResponse<T> {
-    return httpResponse<T>(200, message, data, error);
-}
-
-export function errorResponse<T extends ParseableType>(
-    message?: string,
-    data?: T,
-    error?: any,
-): IHttpResponse<T> {
-    return httpResponse<T>(500, message, data, error);
-}
-
-
-export class RaitonResponse {
-    constructor(
-        public readonly parameters: ResponseParameters,
-        public readonly context: RequestContext,
-    ) {
-    }
-
-    parse(){
-
-    }
-}

package/source/sdk/schemes.ts

@@ -1,178 +0,0 @@
-import {TSchema, Static, TProperties, Type} from "@sinclair/typebox";
-import {ISchemeConfig, ISchemeOptions, IScheme} from "@/types";
-
-
-export * from "@sinclair/typebox"
-
-export function scheme() {
-    return new Scheme({});
-}
-
-
-/**
- * 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
- * defined by the `Schematic.infer` function. If the condition is not met, the type resolves to `never`.
- *
- * @template T - The generic type to evaluate and potentially infer from the `Schematic` structure.
- *
- * 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`.
- */
-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 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.
- */
-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>) {
-        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 {
-        return this._$body;
-    }
-
-    /**
-     * Adds or updates a key-value pair in the body object.
-     *
-     * @param {string} key - The key to set or update in the body object.
-     * @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 {
-        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 {
-        return this._$params;
-    }
-
-    /**
-     * Adds or updates a parameter with the specified key and value.
-     *
-     * @param {string} key - The key associated with the parameter to set or update.
-     * @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 {
-        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 {
-        return this._$querystring;
-    }
-
-    /**
-     * Updates the query string parameters by setting the specified key-value pair.
-     *
-     * @param {string} key - The key of the query string parameter to set or update.
-     * @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 {
-        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 {
-        return this._$response;
-    }
-
-    /**
-     * Adds or updates a response key-value pair in the internal response object.
-     *
-     * @param {number} key - The key to be added or updated in the response object.
-     * @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 {
-        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> {
-        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.
-     *
-     * @param {T extends Schematic<any, any, any, any>} schema - The schema to infer types from. This should extend the Schematic type.
-     * @return {Object} An object containing inferred types including:
-     * - Body: The static type of the request body if defined in the schema, otherwise undefined.
-     * - Params: The static type of the request parameters if defined in the schema, otherwise undefined.
-     * - 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) {
-        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,
-        };
-    }
-}

package/source/sdk/utilities/artifacts.util.ts

@@ -1,62 +0,0 @@
-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/controller.util.ts

@@ -1,8 +0,0 @@
-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/types/data-transfer-object.ts

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

package/source/types/hmr.ts

@@ -1,39 +0,0 @@
-export interface HMRMetadataInterface {
-    version: number;
-    timestamp: number;
-    filename: string;
-    size: number;
-}
-
-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>
-
-    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>;
-
-}