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

package/source/sdk/parameter-bag.ts

@@ -0,0 +1,55 @@
+import {ParseableEntriesType, ParseablePrimitiveType} from "@/types";
+import {stabilizeJson} from "./utilities";
+import {DynamicParameter, IDynamicParameters, IDynamicProps, IParameter,} from "@protorians/parameters";
+
+
+export class ParameterBag<T extends ParseableEntriesType> {
+
+    protected _bag: IDynamicParameters<any>;
+
+    constructor(data: T) {
+        this._bag = new DynamicParameter(this.initializeData(data));
+    }
+
+    protected initializeData(data: T): any {
+        const prepared = {} as IDynamicProps<T>
+
+        for (const [key, value] of Object.entries(data)) {
+            prepared[key as keyof T] = {
+                value,
+            } as IParameter<T[keyof T]>
+        }
+
+        return prepared
+    }
+
+    get bag(): IDynamicParameters<any> {
+        return this._bag;
+    }
+
+    records(data: T): this {
+        for (const [key, value] of Object.entries(data))
+            this._bag.update(key as keyof T, value);
+        return this;
+    }
+
+    render(): T {
+        return Object.fromEntries(this._bag.stack) as any as T;
+    }
+
+    toString(): string {
+        return JSON.stringify(this.render());
+    }
+
+    static stabilize<T>(json: string | T | null): T {
+        return stabilizeJson<T>(json);
+    }
+
+    static from<T extends IDynamicProps<T>>(data: T): ParameterBag<T> {
+        return new ParameterBag<T>(data);
+    }
+
+    static records<T extends IDynamicProps<T>>(support: ParameterBag<T>, data: ParseablePrimitiveType<T>): ParameterBag<T> {
+        return support.records(this.stabilize(data));
+    }
+}

package/source/sdk/repositories.ts

@@ -1,4 +1,4 @@
-import {Throwable} from "./throwable";
+import {Throwable} from "@/sdk/exceptions";
 
 
 export class DelegateRepository {

package/source/sdk/responses/error.ts

@@ -0,0 +1,52 @@
+import type {ErrorResponseInterface} from "@/types";
+import {HttpResponse} from "@/sdk/responses/http";
+
+
+export class HttpErrorResponse {
+    public readonly stack: Map<string, ErrorResponseInterface> = new Map();
+
+    public get entries(): ErrorResponseInterface[] {
+        return [...this.stack.values()];
+    }
+
+    public add(input: ErrorResponseInterface): this {
+        this.stack.set(input.id, input)
+        return this;
+    }
+
+    public remove(id: string): this {
+        this.stack.delete(id);
+        return this;
+    }
+
+    public get(id: string): ErrorResponseInterface | undefined {
+        return this.stack.get(id);
+    }
+
+    public has(id: string): boolean {
+        return this.stack.has(id);
+    }
+
+    public clear(): this {
+        this.stack.clear();
+        return this;
+    }
+
+    public get empty(): boolean {
+        return this.stack.size === 0;
+    }
+
+    public get existence(): number {
+        return this.stack.size
+    }
+
+    public push() {
+        const first = this.stack.values().next().value;
+        HttpResponse.push({
+            statusCode: 500,
+            message: first?.message || 'Internal server error',
+            error: true,
+            errorStack: this.entries
+        })
+    }
+}

package/source/sdk/responses/helpers.ts

@@ -0,0 +1,28 @@
+import {HttpResponse, HttpStatus} from "@/sdk";
+import {HttpResponseInterface} from "@/types";
+import {Raiton} from "@/core";
+
+
+export function RaitonResponses(
+    message: string,
+    data: HttpResponseInterface,
+    statusCode: HttpStatus,
+    metadata?: Omit<HttpResponseInterface<any>, 'data' | 'message' | 'statusCode'>
+) {
+
+    if (metadata) {
+        metadata.error = typeof data.error === 'boolean' ? data.error : false
+        metadata.errorStack = (metadata.errorStack instanceof Error)
+            ? metadata.errorStack
+            : (Raiton.thread?.builder?.options?.development
+                ? (Array.isArray(metadata.errorStack) ? metadata.errorStack : [])
+                : undefined)
+    }
+
+    return {
+        ...metadata,
+        statusCode,
+        message,
+        data,
+    }
+}

package/source/sdk/responses/http-throwable.ts

@@ -0,0 +1,28 @@
+import {HttpResponseInterface} from "@/types";
+import {HttpStatus} from "@/sdk/enums";
+import {Raiton} from "@/core";
+
+
+export class ThrowableResponse extends Error {
+    constructor(
+        public input: string | HttpResponseInterface,
+        public statusCode: HttpStatus = HttpStatus.INTERNAL_SERVER_ERROR,
+    ) {
+        super(typeof input === 'string' ? input : input.message);
+    }
+
+    render() {
+        const stack = typeof this.input === 'object' ? this.input.errorStack : undefined
+        return {
+            message: this.message,
+            statusCode: this.statusCode,
+            data: (typeof this.input === 'object') ? this.input.data : undefined,
+            error: (typeof this.input === 'object') ? this.input.error : false,
+            stack: stack instanceof Error ?
+                (Raiton.thread?.builder?.options?.development
+                    ? this.stack?.split('\n').map(e => e.trim())
+                    : undefined)
+                : stack
+        }
+    }
+}

package/source/sdk/responses/http.ts

@@ -0,0 +1,48 @@
+import {HttpResponseInterface} from "@/types";
+import {HttpStatus} from "@/sdk/enums";
+import {ThrowableResponse} from "@/sdk/responses";
+
+
+export class HttpResponse {
+    public static push(response: Partial<HttpResponseInterface>): void {
+        throw new ThrowableResponse({
+            statusCode: response.statusCode || HttpStatus.BAD_REQUEST,
+            message: response.message || 'No response message provided',
+            data: response.data,
+            error: response.error,
+            errorStack: response.errorStack
+        })
+    }
+
+    constructor(public readonly response: HttpResponseInterface) {
+    }
+
+    status(statusCode: HttpStatus): this {
+        this.response.statusCode = statusCode;
+        return this;
+    }
+
+    message(message: string) {
+        this.response.message = message;
+        return this;
+    }
+
+    data(data: any) {
+        this.response.data = data;
+        return this;
+    }
+
+    error(error: boolean) {
+        this.response.error = error;
+        return this;
+    }
+
+    stack(stack: Error) {
+        this.response.errorStack = stack
+        return this;
+    }
+
+    render(): HttpResponseInterface {
+        return (new ThrowableResponse({...this.response})).render()
+    }
+}

package/source/sdk/responses/index.ts

@@ -0,0 +1,4 @@
+export * from "./error"
+export * from "./http-throwable"
+export * from "./http"
+export * from "./helpers"

package/source/sdk/runtime/bun/server.ts

@@ -9,9 +9,10 @@ export const bunRuntime: RuntimeAdapterInterface = {
         let server: any
 
         return {
-            async listen(port) {
+            async listen(port, hostname) {
                 server = Bun.serve({
                     port,
+                    hostname,
                     fetch: async (request: Request) => {
                         let responseBody: any
                         let statusCode = 200

package/source/sdk/runtime/deno/server.ts

@@ -5,13 +5,13 @@ export const denoRuntime: RuntimeAdapterInterface = {
         let controller: AbortController
 
         return {
-            async listen(port) {
+            async listen(port, hostname) {
                 if (typeof Deno === 'undefined') throw new Error(
                     'Deno is not installed, please run `deno install -A -f --unstable https://deno.land/x/raiton/cli.ts`'
                 )
 
                 controller = new AbortController()
-                Deno.serve({port, signal: controller.signal}, async (req: any) => {
+                Deno.serve({port, hostname, signal: controller.signal}, async (req: any) => {
                     let body: any
                     let status = 200
                     const headers = new Headers()

package/source/sdk/runtime/node/server.ts

@@ -45,9 +45,9 @@ export const nodeRuntime: RuntimeAdapterInterface = {
         })
 
         return {
-            listen(port) {
+            listen(port, hostname) {
                 return new Promise((resolve) =>
-                    server.listen(port, resolve)
+                    server.listen(port, hostname, resolve)
                 )
             },
             close() {

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

@@ -0,0 +1,18 @@
+export function isControllerArtifact(filename: string) {
+    return isArtifact(filename, 'controller')
+}
+
+
+export function isServiceArtifact(filename: string) {
+    return isArtifact(filename, 'service')
+}
+
+export function isArtifact(filename: string, artifact: string) {
+    return [
+        filename.endsWith(`.${artifact}.ts`),
+        filename.endsWith(`.${artifact}.js`),
+        filename.endsWith(`.${artifact}.mjs`),
+        filename.endsWith(`.${artifact}.cjs`),
+    ].some(Boolean)
+}
+

package/source/sdk/utilities/index.ts

@@ -1,7 +1,5 @@
-// export * from "./alias-path.util"
-export * from "./artifacts.util"
 export * from "./callable.util"
 export * from "./utilities.util"
-export * from "./controller.util"
+export * from "./artifact.util"
 export * from "./json.util"
 export * from "./path.util"

package/source/types/application.ts

@@ -16,9 +16,9 @@ export interface ApplicationInterface {
 
     get hostname(): string;
 
-    // setOption<K extends keyof ApplicationConfig>(key: K, value: ApplicationConfig[K]): this;
-    //
-    // setOptions(options: ApplicationConfig): this;
+    setOption<K extends keyof ApplicationConfig>(key: K, value: ApplicationConfig[K]): this;
+
+    setOptions(options: ApplicationConfig): this;
 
     register(plugin: any): this;
 

package/source/types/artifact.ts

@@ -4,37 +4,41 @@ export interface ArtifactEntry {
     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 ArtifactsConfig {
+    types: string[]
 }
 
-export interface ArtifactEntry {
-    vendor: string;
-    decorator: string;
-    pattern: 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

@@ -1,6 +1,3 @@
-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 {
@@ -17,7 +14,6 @@ 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;

package/source/types/config.ts

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

package/source/types/controller.ts

@@ -5,7 +5,6 @@ import {MiddlewareCallable, MiddlewareType} from "@/types/middleware";
 export interface ControllerMetaInterface {
     prefix?: string;
     routes: RouteMetaInterface[];
-    params: Record<string, ParamMetaInterface[]>;
     middlewares: Record<string, MiddlewareCallable[]>;
 }
 
@@ -15,7 +14,6 @@ export interface RouteMetaInterface {
     method: HttpMethod;
     path: string;
     propertyKey: string;
-    params: ParamMetaInterface[];
 }
 
 export interface ParamMetaInterface {
@@ -23,6 +21,7 @@ export interface ParamMetaInterface {
     type: Parametrable;
     key?: string;
     callable?: (ctx: Context) => any;
+    metatype?: any;
 }
 
 export interface RouteDecoratorParameters {

package/source/types/index.ts

@@ -3,7 +3,6 @@ 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"
@@ -13,7 +12,6 @@ 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"
@@ -23,4 +21,5 @@ export type * from "./controller"
 export type * from "./injection"
 export type * from "./responses"
 export type * from "./server"
-export type * from "./raiton"
+export type * from "./raiton"
+export type * from "./lifecycle"

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/responses.ts

@@ -1,10 +1,20 @@
-import type {ParseableEntriesType} from "@/types/parseable";
+import {HttpStatus} from "@/sdk/enums/http-status.enum";
 
-export interface ResponseParameters {
-    readonly message?: string;
-    readonly error?: boolean;
-    readonly statusCode?: number;
-    readonly errorStack?: Error;
-    readonly data?: ParseableEntriesType
+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/runtime.ts

@@ -1,7 +1,7 @@
 import {RuntimeType} from "@/sdk/enums/runtime.enum";
 
 export interface RuntimeServerInterface {
-    listen(port: number): Promise<void>
+    listen(port: number, hostname?: string): Promise<void>
 
     close(): Promise<void>
 

package/source/core/artifacts/artifact.ts

@@ -1,109 +0,0 @@
-import type {ArtifactEntry, ArtifactInterface, ArtifactOptions} from "@/types/artifact";
-import {RaitonDirectories} from "@/core/directories";
-import {Raiton} from "@/core/raiton";
-import path from "node:path";
-import fs from "node:fs";
-import {LBadge, Logger} from "@protorians/logger";
-import {ArtifactFactory} from "@/sdk/artifacts";
-import {Throwable} from "@/sdk/throwable";
-
-export class Artifact implements ArtifactInterface {
-    public readonly directory: string;
-    public readonly file: string;
-    public readonly workdir: string;
-
-    protected _files: string[] = [];
-
-    constructor(
-        public readonly options: ArtifactOptions,
-    ) {
-        this.options.verbose = typeof options.verbose === "undefined" ? false : options.verbose;
-
-        if (!Raiton.thread.builder?.source)
-            throw new Throwable("Artifact need project source");
-
-        this.directory = RaitonDirectories.artifacts(Raiton.thread.builder?.workdir)
-        this.workdir = Raiton.thread.builder.source;
-        this.file = path.join(this.directory, `${this.options.artifact}.d.ts`);
-    }
-
-    get files(): string[] {
-        return this._files;
-    }
-
-    get extensions(): string[] {
-        return [
-            `${this.options.artifact}.ts`,
-            `${this.options.artifact}.js`,
-            `${this.options.artifact}.mjs`,
-            `${this.options.artifact}.cjs`,
-        ]
-    }
-
-    /**
-     * Finds all files with end 'artifact.EXT'
-     */
-    scan(): string[] {
-        this._files = [];
-
-        fs.readdirSync(this.workdir, {recursive: true})
-            .forEach(f => {
-                this._files = [
-                    ...this._files,
-                    ...this.extensions.filter(ext => f.toString().endsWith(ext))
-                ];
-            })
-        ;
-
-        return this._files;
-    }
-
-    generate(): boolean {
-        try {
-            let mappings = "";
-
-            for (const file of this._files) {
-                const filename = path.join(this.workdir, file);
-                const content = fs.readFileSync(filename, "utf-8");
-                const match = content.match(this.options.decorator?.syntax);
-
-                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 (this.options.verbose) Logger.info(LBadge.debug(name), `artifact detected`);
-
-                ArtifactFactory.add(
-                    this.options.artifact, {
-                        file,
-                        dir: this.workdir,
-                        relative: file,
-                        absolute: filename
-                    }
-                )
-            }
-
-            const content = `// AUTO-GENERATED FILE — DO NOT EDIT MANUALLY
-declare global {
-  interface ${this.options.provider} {
-${mappings} }
-}
-export {};`;
-            fs.writeFileSync(this.file, content, "utf-8");
-            if (!ArtifactFactory.save(this.options.artifact))
-                throw new Throwable(`Failed to save artifacts for ${this.options.artifact}`);
-
-            return true;
-        } catch (e: any) {
-            Logger.error(`Failed to resolve artifacts for ${this.options.artifact}`, e.message ?? e);
-        }
-        return false;
-    }
-
-}

package/source/core/artifacts/artifacts.ts

@@ -1,10 +0,0 @@
-import {RaitonConfig} from "@/core";
-
-export class Artifacts {
-
-    public static async load(workdir: string) {
-        await RaitonConfig.sync(workdir);
-        return RaitonConfig.get('artifacts');
-    }
-
-}

package/source/core/artifacts/index.ts

@@ -1 +0,0 @@
-export * from "./artifact";

package/source/core/artifacts/runner.ts

@@ -1,3 +0,0 @@
-export function artifactRunner () {
-
-}