raiton 1.1.1 → 3.0.1

package/source/core/builder.ts

@@ -0,0 +1,144 @@
+import {RaitonConfig} from "./config";
+import path from "node:path";
+import {RaitonDirectories} from "./directories";
+import fs, {WatchEventType} from "node:fs";
+import type {BuilderConfig, BuilderInterface,} from "@/types";
+import {RaitonThread} from "./thread";
+import {Raiton} from "@/core/raiton";
+import {isControllerArtifact, isServiceArtifact} from "@/sdk";
+import {ControllerBuilder} from "@/core/controller";
+import {watch} from "fs";
+import {LBadge, Logger} from "@protorians/logger";
+import {Throwable} from "@/sdk/exceptions";
+import {Injection} from "@/core/injection";
+import {Artifacts} from "@/sdk/artifacts";
+
+export class RaitonBuilder implements BuilderInterface {
+    protected _source: string | null = null;
+    protected _out: string | null = null;
+    protected _bootstrapper: string | null = null;
+    protected _bootstrapperFile: string | null = null;
+    protected _compiledVersionNumber: number = 1;
+    protected _watcher?: fs.FSWatcher;
+
+
+    constructor(
+        public readonly workdir: string,
+        public readonly options: BuilderConfig = {},
+    ) {
+
+    }
+
+    public get source(): string | null {
+        return this._source;
+    }
+
+    public get out(): string | null {
+        return this._out;
+    }
+
+    public get bootstrapper(): string | null {
+        return this._bootstrapper;
+    }
+
+    public get bootstrapperFile(): string | null {
+        return this._bootstrapperFile
+    }
+
+    public get watcher(): fs.FSWatcher | undefined {
+        return this._watcher;
+    }
+
+    protected async parse(filename: string, type?: WatchEventType) {
+        if (!fs.existsSync(filename)) return;
+
+        const payload = {
+            filename,
+            timestamp: Date.now(),
+            version: this._compiledVersionNumber,
+            type
+        }
+
+        Logger.log(LBadge.info('HMR'), 'activated');
+
+        if (isControllerArtifact(filename)) {
+            Raiton.signals.dispatch('hmr:controller', payload)
+        }
+
+        if (Artifacts.is(filename))
+            Artifacts.reload(
+                await import(`${filename}?v=${payload.version || 1}&t=${payload.timestamp || Date.now()}`),
+                filename
+            )
+
+        return payload;
+    }
+
+    protected async parsing(): Promise<this> {
+        if (typeof this._source != 'string') throw new Throwable('Application source not found');
+
+        for (const filename of [...fs.readdirSync(this._source, {recursive: true})])
+            await this.parse(path.join(this._source, String(filename)));
+
+        return this;
+    }
+
+    protected watching(): this {
+        if (typeof this._source != 'string') throw new Throwable('Application source not found');
+
+        this._watcher = watch(this._source, {recursive: true}, (event, relativePath) => {
+            if (this._source && relativePath) {
+                this.parse(path.join(this._source, relativePath));
+            }
+        });
+
+        return this;
+    }
+
+    protected async initialize(): Promise<this> {
+        const rootDir = RaitonConfig.get('rootDir') || './';
+        this._source = path.resolve(this.workdir, rootDir);
+        this._out = path.resolve(this.workdir, RaitonDirectories.server(this.workdir));
+
+        if (!fs.existsSync(this._source))
+            throw new Error(`Source directory "${this._source}" does not exists`)
+
+        if (!fs.existsSync(this._out))
+            fs.mkdirSync(this._out, {recursive: true})
+
+
+        this._bootstrapper = path.join(this._source, RaitonDirectories.bootstrapFile)
+        this._bootstrapperFile = path.join(RaitonDirectories.server('./'), RaitonDirectories.bootstrapFile)
+
+        return this;
+
+    }
+
+    public async prepare(): Promise<this> {
+        await this.initialize()
+        Raiton.signals.listen(
+            'hmr:controller',
+            async ({filename, version, timestamp}) => {
+                await ControllerBuilder.build({filename, version, timestamp})
+            }
+        )
+        // this.parsing();
+        this.watching();
+        return this;
+    }
+
+    public async boot(): Promise<any> {
+        if (!this.bootstrapper) throw new Error('Bootstrapper not found')
+        if (!fs.existsSync(this.bootstrapper))
+            throw new Error(`Bootstrapper file "${this.bootstrapper}" does not exists`)
+
+        const bootstrapper = await import(this.bootstrapper);
+        if (!('default' in bootstrapper))
+            throw new Error('Bootstrapper not supported! Please export to "default"')
+
+        const thread = new RaitonThread(this, {})
+        Raiton.thread = thread;
+        return await bootstrapper.default(thread);
+    }
+
+}

package/source/core/bytes.util.ts

@@ -0,0 +1,17 @@
+import {FileSizeFormated} from "../types";
+
+export function parseBytes(bytes: number, decimals = 2): FileSizeFormated {
+    if (bytes === 0) return {size: 0, unit: "o"};
+
+    const k = 1024;
+    const units = ["o", "Ko", "Mo", "Go", "To"];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+    const size = parseFloat((bytes / Math.pow(k, i)).toFixed(decimals));
+    return {size, unit: units[i]}
+}
+
+export function formatBytes(bytes: number, decimals = 2): string {
+    const {size, unit} = parseBytes(bytes, decimals);
+    return `${size.toString().trim()}${unit.trim()}`;
+}

package/source/core/command.ts

@@ -0,0 +1,24 @@
+import {Command} from "commander";
+
+export class RaitonCommand {
+
+    public readonly name: string = '';
+    public readonly description?: string;
+    public readonly version: string = '0.0.0';
+    public readonly enabled: boolean = true;
+
+    public constructor(
+        public readonly cli: Command,
+        public readonly workdir: string,
+        public readonly appdir: string = ''
+    ) {
+        this.construct()
+    }
+
+    public construct(): void {
+    }
+
+    public register(): void {
+    }
+
+}

package/source/core/commands.ts

@@ -0,0 +1,44 @@
+import {Command} from "commander";
+import {RaitonCommand} from "./command";
+import fs from 'node:fs';
+import path from "node:path";
+import {Logger} from "@protorians/logger";
+
+export class RaitonCommands {
+
+    public readonly stack: Set<RaitonCommand> = new Set();
+
+    constructor(
+        public readonly cli: Command,
+        public readonly appdir: string,
+        public readonly workdir: string
+    ) {
+    }
+
+    public async harvest(): Promise<void> {
+        const dir = path.join(this.appdir, 'commands');
+        
+        if (!fs.existsSync(dir)) {
+            return;
+        }
+
+        const files = fs.readdirSync(dir);
+
+        for (const file of files) {
+            if (file.startsWith('~')) continue;
+            if (file.endsWith('.d.ts')) continue;
+            if (!file.includes('.command.')) continue;
+
+            const filepath = path.join(dir, file);
+            const mod = await import(filepath);
+
+            const capability = new mod.default(this.cli, this.workdir, this.appdir)
+
+            if (!(capability instanceof RaitonCommand)) continue;
+
+            capability.register();
+            this.stack.add(capability);
+        }
+
+    }
+}

package/source/core/config/config.ts

@@ -0,0 +1,51 @@
+import path from "node:path";
+import fs from "node:fs";
+import {Configurable} from "@/types";
+import {Logger} from "@protorians/logger";
+import {Raiton} from "@/core/raiton";
+
+export class RaitonConfig {
+    static readonly current: Map<keyof Configurable, Configurable[keyof Configurable]> = new Map();
+
+    protected static _extensions: string[] = ['.js', '.mjs'];
+
+    static get<K extends keyof Configurable>(key: K): Configurable[K] | undefined {
+        return this.current.get(key) as Configurable[K];
+    }
+
+    static defaultConfig: Configurable = {
+        rootDir: '.',
+        version: '0.0.1'
+    }
+
+    static async sync(workdir: string) {
+        try {
+            if (!this.current.size) {
+                const configJsonPath = path.join(workdir, `${Raiton.identifier}.config.json`);
+
+                if (fs.existsSync(configJsonPath)) {
+                    const configContent = fs.readFileSync(configJsonPath, 'utf-8');
+                    for (const [key, value] of Object.entries({...this.defaultConfig, ...(JSON.parse(configContent) || {})}))
+                        this.current.set(key as keyof Configurable, value as Configurable[keyof Configurable]);
+                } else {
+                    for (const ext of this._extensions) {
+                        const configPath = path.join(workdir, `${Raiton.identifier}.config${ext}`);
+                        if (fs.existsSync(configPath)) {
+                            const configModule = await import(configPath);
+                            const config = await configModule?.default || configModule;
+                            for (const [key, value] of Object.entries(config)) {
+                                this.current.set(key as keyof Configurable, value as Configurable[keyof Configurable]);
+                            }
+                        }
+                    }
+                }
+            }
+
+            return this.current;
+        } catch (e: any) {
+            Logger.error(`Failed to load ${Raiton.identifier} config:`, e.message ?? e);
+            return this.current;
+        }
+
+    }
+}

package/source/core/config/define.ts

@@ -0,0 +1,13 @@
+import {Configurable} from "@/types/config";
+import {JsonUtil} from "@/sdk/utilities";
+
+export async function defineConfig(config?: Configurable) {
+    const workdir = process.cwd();
+    const pkg = JsonUtil.import(workdir + '/package.json');
+
+    config = {...config || {}, ...pkg.raitonConfig || {}} as Configurable;
+    config.rootDir = config.rootDir || './';
+    config.version = config.version || pkg.version || '0.0.1';
+
+    return config;
+}

package/source/core/config/index.ts

@@ -0,0 +1,2 @@
+export * from "./config"
+export * from "./define"

package/source/core/context.ts

@@ -0,0 +1,33 @@
+import type {
+  RuntimeRequestInterface,
+  RuntimeReplyInterface
+} from '@/types'
+
+export class RequestContext {
+  public state: Record<string, any> = {}
+  private decorations = new Map<string, any>()
+
+  constructor(
+    public req: RuntimeRequestInterface,
+    public reply: RuntimeReplyInterface
+  ) {}
+
+  decorate<T = any>(key: string, value: T) {
+    if (this.decorations.has(key)) {
+      throw new Error(`Decoration "${key}" already exists`)
+    }
+    this.decorations.set(key, value)
+  }
+
+  get<T = any>(key: string): T {
+    if (key in this.state) return this.state[key]
+    if (this.decorations.has(key)) {
+      return this.decorations.get(key)
+    }
+    throw new Error(`Context value "${key}" not found`)
+  }
+
+  send(body: any) {
+    this.reply.send(body)
+  }
+}

package/source/core/controller/builder.ts

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import {BuilderHMRDeclaration} from "@/types";
+import {LBadge, Logger} from "@protorians/logger";
+import {compileController} from "@/core/controller/compiler";
+import {RaitonThread} from "@/core/thread";
+import {Injection} from "@/core/injection";
+import {isControllerArtifact} from "@/sdk";
+import path from "node:path";
+
+export class ControllerBuilder {
+
+    static async scan(workdir: string) {
+        const files = fs.readdirSync(workdir, {recursive: true})
+            .map(file => file.toString());
+        const output: any[] = []
+
+        for (const file of files) {
+            output.push(await this.build<any>({filename: path.join(workdir, file), version: 1, timestamp: Date.now()}))
+        }
+
+        return output.filter(f => typeof f !== 'undefined');
+    }
+
+    static async build<T>({filename, version, timestamp}: BuilderHMRDeclaration): Promise<T | undefined> {
+        if (!isControllerArtifact(filename))
+            return undefined;
+
+        const imported = await import(`${filename}?v=${version || 1}&t=${timestamp || Date.now()}`)
+        const controller = imported.default || imported || undefined;
+
+        if (!controller) return undefined;
+        if (!RaitonThread.current?.application) return undefined;
+
+        const compilated = compileController(controller, RaitonThread.current.application);
+        const name = controller.name || (typeof controller === 'function' ? controller.name : undefined);
+        if (name) Injection.registerArtifactPath(name, filename);
+
+        return compilated;
+    }
+
+}

package/source/core/controller/compiler.ts

@@ -0,0 +1,22 @@
+import {ApplicationInterface} from "@/types/application";
+import {getControllerMetadata} from "@/core";
+import {createHandler} from "@/core/router";
+import {Injection} from "@/core/injection";
+import {ControllerMetaInterface} from "@/types";
+
+export function compileController(
+    ControllerClass: any,
+    app: ApplicationInterface
+) {
+    const instance: any = Injection.resolve<typeof ControllerClass>(ControllerClass)
+    const metadata: ControllerMetaInterface = getControllerMetadata(ControllerClass.prototype)
+
+    for (const route of metadata.routes)
+        app.route(
+            route.method as any,
+            `${metadata.prefix ?? ''}${route.path}`,
+            createHandler(instance, route, metadata),
+        )
+
+    return instance;
+}

package/source/core/controller/index.ts

@@ -0,0 +1,3 @@
+export * from "./metadata"
+export * from "./compiler"
+export * from "./builder"

package/source/core/controller/metadata.ts

@@ -0,0 +1,13 @@
+import {ControllerMetaInterface} from "@/types";
+import {METADATA_KEYS} from "@/sdk";
+import "reflect-metadata";
+
+export function getControllerMetadata(target: any): ControllerMetaInterface {
+    let metadata = Reflect.getMetadata(METADATA_KEYS.CONTROLLERS, target);
+    if (!metadata) {
+        metadata = {routes: [], middlewares: {}};
+        Reflect.defineMetadata(METADATA_KEYS.CONTROLLERS, metadata, target);
+    }
+
+    return metadata;
+}

package/source/core/directories.ts

@@ -0,0 +1,30 @@
+import path from "node:path";
+import {RaitonConfig} from "./config";
+import {Raiton} from "@/core/raiton";
+
+
+export class RaitonDirectories {
+    public static readonly index = `.${Raiton.identifier}`;
+    public static readonly bootstrapFile = 'main.ts';
+    // public static readonly bootstrapFile = 'main.js';
+
+    public static caches(workdir: string): string {
+        return path.join(workdir, this.index, 'caches');
+    }
+
+    public static artifacts(workdir: string): string {
+        return path.join(workdir, this.index, 'artifacts');
+    }
+
+    public static server(workdir: string): string {
+        return path.join(workdir, this.index, 'server');
+    }
+
+    public static root(workdir: string): string {
+        return path.join(workdir, this.index);
+    }
+
+    public static app(): string {
+        return path.join(Raiton.thread?.builder.workdir || '', RaitonConfig.get('rootDir') || './');
+    }
+}

package/source/core/helpers/index.ts

@@ -0,0 +1 @@
+export * from './raiton';

package/source/core/helpers/raiton.ts

@@ -0,0 +1,3 @@
+export function raiton<T>(input: T) {
+
+}

package/source/core/hooks.ts

@@ -0,0 +1,28 @@
+import {HookName, HookHandler} from '@/types'
+
+export class HookStore {
+    private hooks = new Map<HookName, HookHandler[]>()
+
+    add(name: HookName, handler: HookHandler) {
+        const list = this.hooks.get(name) ?? []
+        list.push(handler)
+        this.hooks.set(name, list)
+    }
+
+    async run(name: HookName, ctx: any) {
+        const list = this.hooks.get(name)
+        if (!list) return
+
+        for (const hook of list) {
+            await hook(ctx)
+        }
+    }
+
+    clone() {
+        const store = new HookStore()
+        for (const [key, value] of this.hooks) {
+            store.hooks.set(key, [...value])
+        }
+        return store
+    }
+}

package/source/core/index.ts

@@ -0,0 +1,14 @@
+export * from "./config"
+export * from "./process.util"
+export * from "./builder"
+export * from "./bytes.util"
+export * from "./commands"
+export * from "./command"
+export * from "./directories"
+export * from "./raiton"
+export * from "./thread"
+export * from "./application"
+export * from "./controller"
+export * from "./plugins"
+export * from "./middleware"
+export * from "./router"

package/source/core/injection/index.ts

@@ -0,0 +1 @@
+export * from './injection';