raiton 0.0.2 → 1.0.0-alpha.2

package/source/sdk/json.ts

@@ -0,0 +1,55 @@
+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/plugins/body-parser.plugin.ts

@@ -0,0 +1,119 @@
+import type {MiddlewareParameters, Plugin} from "@/types";
+import {RequestContext} from "@/core/context";
+import {Logger} from "@protorians/logger";
+import {tryParseJson} from "@/sdk/utilities/json.util";
+
+export function bodyParserPlugin(): Plugin {
+    return {
+        name: 'body-parser-plugin',
+        setup: (scope) => {
+            scope.use(async ({context, next}: MiddlewareParameters) => {
+                const contentType = context.req.headers.get('content-type') || '';
+
+                if (context.req.body && !context.state.bodyParsed) {
+                    try {
+                        const rawBody = await readRawBody(context.req.body);
+                        const bodyString = decode(rawBody);
+
+                        readQueryBody(context);
+                        readJsonBody(context, contentType, bodyString);
+                        readUrlEncodedBody(context, contentType, bodyString);
+                        readTextBody(context, contentType, bodyString);
+
+                        if (!context.state.bodyParsed) {
+                            context.req.body = rawBody as unknown as any;
+                            context.state.bodyParsed = true;
+                        }
+
+                    } catch (e) {
+                        Logger.error('Error parsing body:', e);
+                    }
+                }
+
+                await next();
+            });
+        }
+    };
+}
+
+function readJsonBody(ctx: RequestContext, contentType: string, body: any) {
+    if (contentType.includes('application/json')) {
+        ctx.req.body = tryParseJson(body) || {} as unknown as any;
+        ctx.state.bodyParsed = true;
+    }
+}
+
+function readUrlEncodedBody(ctx: RequestContext, contentType: string, body: string) {
+    if (contentType.includes('application/x-www-form-urlencoded')) {
+        const params = new URLSearchParams(body);
+        const record: Record<string, any> = {};
+        params.forEach((value, key) => {
+            record[key] = value;
+        });
+        ctx.req.body = record as unknown as any;
+        ctx.state.bodyParsed = true;
+    }
+}
+
+function readTextBody(ctx: RequestContext, contentType: string, body: string) {
+    if (contentType.includes('text/')) {
+        ctx.req.body = body as unknown as any;
+        ctx.state.bodyParsed = true;
+    }
+}
+
+function readQueryBody(ctx: RequestContext) {
+    const searchParams = new URLSearchParams(ctx.req.url.split('?')[1] || '');
+    const record = {} as Record<string, any>;
+    searchParams.forEach((value, key) => record[key] = value);
+    ctx.req.query = record as unknown as any;
+}
+
+async function readRawBody(body: any): Promise<Uint8Array | string> {
+    if (body instanceof ReadableStream) {
+        const reader = body.getReader();
+        const chunks: Uint8Array[] = [];
+        while (true) {
+            const {done, value} = await reader.read();
+            if (done) break;
+            chunks.push(value);
+        }
+        const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return result;
+    }
+
+    if (typeof body === 'object' && body !== null && 'on' in body && typeof body.on === 'function') {
+        return new Promise((resolve, reject) => {
+            const chunks: any[] = [];
+            body.on('data', (chunk: any) => chunks.push(chunk));
+            body.on('end', () => {
+                if (chunks.length > 0 && typeof chunks[0] === 'string') {
+                    resolve(chunks.join(''));
+                } else {
+                    const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+                    const result = new Uint8Array(totalLength);
+                    let offset = 0;
+                    for (const chunk of chunks) {
+                        result.set(new Uint8Array(chunk), offset);
+                        offset += chunk.length;
+                    }
+                    resolve(result);
+                }
+            });
+            body.on('error', reject);
+        });
+    }
+
+    return body;
+}
+
+function decode(data: Uint8Array | string): string {
+    if (typeof data === 'string') return data;
+    return new TextDecoder().decode(data);
+}

package/source/sdk/plugins/index.ts

@@ -0,0 +1,2 @@
+export * from "./body-parser.plugin"
+export * from "./security/index"

package/source/sdk/plugins/security/body-limit.ts

@@ -0,0 +1,19 @@
+import {definePlugin} from "@/core/plugins";
+import {MiddlewareParameters} from "@/types";
+
+
+export const secureBodyLimit = (maxBytes = 1_000_000) =>
+  definePlugin((scope) => {
+    scope.use(async ({context, next}: MiddlewareParameters) => {
+      const len = Number(
+        context.req.headers.get('content-length') ?? 0
+      )
+
+      if (len > maxBytes) {
+        context.reply.status(413)
+        return context.send({ error: 'Payload too large' })
+      }
+
+      await next()
+    })
+  }, 'body-limit')

package/source/sdk/plugins/security/cors.ts

@@ -0,0 +1,44 @@
+import {definePlugin} from "@/core/plugins";
+import {Context, MiddlewareParameters, NextCallable} from "@/types";
+
+export interface CorsOptions {
+    origin?: string | string[]
+    methods?: string[]
+    headers?: string[]
+}
+
+export const secureCors = (opts: CorsOptions = {}) =>
+    definePlugin((scope) => {
+        scope.use(async ({context, next}: MiddlewareParameters) => {
+            const origin = context.req.headers.get('origin')
+
+            if (opts.origin) {
+                const allowed = Array.isArray(opts.origin)
+                    ? opts.origin.includes(origin!)
+                    : opts.origin === origin
+
+                if (allowed) {
+                    context.reply.header('Access-Control-Allow-Origin', origin!)
+                }
+            } else {
+                context.reply.header('Access-Control-Allow-Origin', '*')
+            }
+
+            context.reply.header(
+                'Access-Control-Allow-Methods',
+                (opts.methods ?? ['GET', 'POST', 'PUT', 'DELETE']).join(',')
+            )
+
+            context.reply.header(
+                'Access-Control-Allow-Headers',
+                (opts.headers ?? ['Content-Type', 'Authorization']).join(',')
+            )
+
+            if (context.req.method === 'OPTIONS') {
+                context.reply.status(204)
+                return context.send(null)
+            }
+
+            await next()
+        })
+    }, 'cors')

package/source/sdk/plugins/security/headers.ts

@@ -0,0 +1,14 @@
+import {definePlugin} from "@/core/plugins";
+import {Context, MiddlewareParameters, NextCallable} from "@/types";
+
+
+export const secureHeaders = definePlugin((scope) => {
+  scope.use(async ({context, next}: MiddlewareParameters) => {
+    context.reply.header('X-Content-Type-Options', 'nosniff')
+    context.reply.header('X-Frame-Options', 'DENY')
+    context.reply.header('Referrer-Policy', 'no-referrer')
+    context.reply.header('X-XSS-Protection', '1; mode=block')
+
+    await next()
+  })
+}, 'security-headers')

package/source/sdk/plugins/security/index.ts

@@ -0,0 +1,13 @@
+import {secureHeaders} from './headers'
+import {secureCors} from './cors'
+import {secureRateLimit} from './rate-limit'
+import {secureBodyLimit} from './body-limit'
+import {secureMethodGuard} from './method-guard'
+
+export class Security {
+    static headers = secureHeaders
+    static cors = secureCors
+    static rateLimit = secureRateLimit
+    static bodyLimit = secureBodyLimit
+    static methodGuard = secureMethodGuard
+}

package/source/sdk/plugins/security/method-guard.ts

@@ -0,0 +1,14 @@
+import {definePlugin} from "@/core/plugins";
+import {Context, MiddlewareParameters, NextCallable} from "@/types";
+
+
+export const secureMethodGuard = (allowed: string[]) =>
+  definePlugin((scope) => {
+    scope.use(async ({context, next}: MiddlewareParameters) => {
+      if (!allowed.includes(context.req.method)) {
+        context.reply.status(405)
+        return context.send({ error: 'Method not allowed' })
+      }
+      await next()
+    })
+  }, 'method-guard')

package/source/sdk/plugins/security/rate-limit.ts

@@ -0,0 +1,42 @@
+import {definePlugin} from "@/core/plugins";
+import {Context, MiddlewareParameters, NextCallable} from "@/types";
+
+
+export interface RateLimitOptions {
+    windowMs?: number
+    max?: number
+}
+
+export const secureRateLimit = (
+    opts: RateLimitOptions = {}
+) =>
+    definePlugin((scope) => {
+        const hits = new Map<string, { count: number; ts: number }>()
+
+        const windowMs = opts.windowMs ?? 60_000
+        const max = opts.max ?? 100
+
+        scope.use(async ({context, next}: MiddlewareParameters) => {
+            const ip =
+                context.req.remoteAddress ?? 'unknown'
+            const now = Date.now()
+
+            const entry = hits.get(ip) ?? {count: 0, ts: now}
+
+            if (now - entry.ts > windowMs) {
+                entry.count = 0
+                entry.ts = now
+            }
+
+            entry.count++
+
+            hits.set(ip, entry)
+
+            if (entry.count > max) {
+                context.reply.status(429)
+                return context.send({error: 'Too many requests'})
+            }
+
+            await next()
+        })
+    }, 'rate-limit')

package/source/sdk/repositories.ts

@@ -0,0 +1,14 @@
+import {Throwable} from "./throwable";
+
+
+export class DelegateRepository {
+    protected readonly client: any;
+    public readonly model!: any;
+
+    protected supported(method: string): boolean {
+        if (typeof this.model !== 'object') throw new Throwable('Model not found, please check your repository')
+        else if (!(method in this.model)) throw new Throwable(`Method ${method} not found, please check your repository`)
+        return true;
+    }
+
+}

package/source/sdk/request.ts

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

package/source/sdk/responses.ts

@@ -0,0 +1,45 @@
+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/runtime/bun/server.ts

@@ -0,0 +1,72 @@
+import {RuntimeAdapterInterface} from '@/types'
+
+export const bunRuntime: RuntimeAdapterInterface = {
+    createServer(handler) {
+        if (typeof Bun === 'undefined') throw new Error(
+            'bun is not installed, please run `npm install bun`'
+        )
+
+        let server: any
+
+        return {
+            async listen(port) {
+                server = Bun.serve({
+                    port,
+                    fetch: async (request: Request) => {
+                        let responseBody: any
+                        let statusCode = 200
+                        const headers = new Headers()
+
+                        await handler(
+                            {
+                                method: request.method,
+                                url: request.url,
+                                headers: request.headers as any,
+                                body: request.body as any
+                            },
+                            {
+                                status(code) {
+                                    statusCode = code
+                                },
+                                header(name, value) {
+                                    headers.set(name, value)
+                                },
+                                send(body: any) {
+                                    if (body === undefined) {
+                                        responseBody = ''
+                                    } else if (typeof body === 'string' || Buffer.isBuffer(body)) {
+                                        responseBody = body;
+                                    } else {
+                                        headers.set('content-type', 'application/json');
+                                        responseBody = (JSON.stringify(body));
+                                    }
+                                },
+                                text(text: string | Buffer) {
+                                    responseBody = text
+                                },
+                                json(json: any) {
+                                    headers.set('content-type', 'application/json')
+                                    responseBody = JSON.stringify(json)
+                                },
+                            }
+                        )
+
+                        if (responseBody instanceof Response) {
+                            return responseBody;
+                        }
+
+                        return new Response(
+                            typeof responseBody === 'object' && !(responseBody instanceof Buffer)
+                                ? JSON.stringify(responseBody)
+                                : responseBody,
+                            {status: statusCode, headers}
+                        )
+                    }
+                })
+            },
+            async close() {
+                server?.stop()
+            }
+        }
+    }
+}

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

@@ -0,0 +1,53 @@
+import {RuntimeAdapterInterface} from '@/types'
+
+export const denoRuntime: RuntimeAdapterInterface = {
+    createServer(handler) {
+        let controller: AbortController
+
+        return {
+            async listen(port) {
+                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) => {
+                    let body: any
+                    let status = 200
+                    const headers = new Headers()
+
+                    await handler(
+                        {
+                            method: req.method,
+                            url: req.url,
+                            headers: req.headers,
+                            body: req.body
+                        },
+                        {
+                            status(code) {
+                                status = code
+                            },
+                            header(name, value) {
+                                headers.set(name, value)
+                            },
+                            send(value: any) {
+                                body = value
+                            },
+                            text(text: string | Buffer) {
+                                body = text
+                            },
+                            json(json: any) {
+                                body = JSON.stringify(json)
+                            },
+                        }
+                    )
+
+                    return new Response(body, {status, headers})
+                })
+            },
+            async close() {
+                controller.abort()
+            }
+        }
+    }
+}

package/source/sdk/runtime/index.ts

@@ -0,0 +1,47 @@
+import type {RuntimeAdapterInterface, RuntimeHandlerCallable, RuntimeInterface, RuntimeServerInterface} from "@/types";
+import {RuntimeType} from "@/sdk/enums/runtime.enum";
+import {nodeRuntime} from "@/sdk/runtime/node/server";
+import {bunRuntime} from "@/sdk/runtime/bun/server";
+import {denoRuntime} from "@/sdk/runtime/deno/server";
+import {webRuntime} from "@/sdk/runtime/web/server";
+
+
+export class Runtime implements RuntimeInterface {
+    constructor(
+        public readonly type: RuntimeType = RuntimeType.Node
+    ) {
+    }
+
+    get isNode(): boolean {
+        return this.type === RuntimeType.Node;
+    }
+
+    get isDeno(): boolean {
+        return this.type === RuntimeType.Deno;
+    }
+
+    get isWeb(): boolean {
+        return this.type === RuntimeType.Web;
+    }
+
+    get isBun(): boolean {
+        return this.type === RuntimeType.Bun;
+    }
+
+    adapter(): RuntimeAdapterInterface {
+        switch (this.type) {
+            case RuntimeType.Node:
+                return nodeRuntime
+            case RuntimeType.Bun:
+                return bunRuntime
+            case RuntimeType.Deno:
+                return denoRuntime
+            case RuntimeType.Web:
+                return webRuntime
+        }
+    }
+
+    createServer(handler: RuntimeHandlerCallable): RuntimeServerInterface {
+        return this.adapter().createServer(handler)
+    }
+}

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

@@ -0,0 +1,60 @@
+import http from 'node:http'
+import {
+    RuntimeAdapterInterface,
+    RuntimeRequestInterface,
+    RuntimeReplyInterface
+} from '@/types'
+
+export const nodeRuntime: RuntimeAdapterInterface = {
+    createServer(handler) {
+        const server = http.createServer(async (req, res) => {
+            const runtimeReq: RuntimeRequestInterface = {
+                method: req.method || 'GET',
+                url: req.url || '/',
+                headers: new Headers(req.headers as any),
+                body: req as any,
+                remoteAddress: req.socket.remoteAddress
+            }
+
+            const runtimeReply: RuntimeReplyInterface = {
+                status(code) {
+                    res.statusCode = code
+                },
+                header(name, value) {
+                    res.setHeader(name, value)
+                },
+                send(body: any) {
+                    if (body === undefined) {
+                        res.end()
+                    } else if (typeof body === 'string' || Buffer.isBuffer(body)) {
+                        res.end(body)
+                    } else {
+                        res.setHeader('content-type', 'application/json')
+                        res.end(JSON.stringify(body))
+                    }
+                },
+                text(text: string|Buffer) {
+                    res.end(text)
+                },
+                json(json: any) {
+                    res.end(JSON.stringify(json))
+                },
+            }
+
+            await handler(runtimeReq, runtimeReply)
+        })
+
+        return {
+            listen(port) {
+                return new Promise((resolve) =>
+                    server.listen(port, resolve)
+                )
+            },
+            close() {
+                return new Promise((resolve, reject) =>
+                    server.close(err => err ? reject(err) : resolve())
+                )
+            }
+        }
+    }
+}