@riktajs/core 0.10.1 → 0.10.3

package/package.json

@@ -1,56 +1,63 @@
-{
-  "name": "@riktajs/core",
-  "version": "0.10.1",
-  "description": "A fast and modern TypeScript backend framework with zero-config autowiring, powered by Fastify",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "clean": "rm -rf dist",
-    "prebuild": "npm run clean",
-    "build": "tsc",
-    "dev": "ts-node-dev --respawn src/index.ts",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "prepublishOnly": "npm run build"
-  },
-  "keywords": [
-    "framework",
-    "backend",
-    "typescript",
-    "fastify",
-    "decorators",
-    "dependency-injection",
-    "nestjs-like"
-  ],
-  "author": "riktar",
-  "license": "MIT",
-  "dependencies": {
-    "dotenv": "^17.2.3",
-    "fast-glob": "3.3.3",
-    "fastify": "5.3.2",
-    "reflect-metadata": "0.2.2",
-    "zod": "4.3.5"
-  },
-  "devDependencies": {
-    "@types/node": "^22.10.2",
-    "@vitest/coverage-v8": "^2.1.9",
-    "ts-node": "^10.9.2",
-    "ts-node-dev": "^2.0.0",
-    "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
-  },
-  "engines": {
-    "node": ">=20.0.0"
-  }
-}
+{
+  "name": "@riktajs/core",
+  "version": "0.10.3",
+  "description": "A fast and modern TypeScript backend framework with zero-config autowiring, powered by Fastify",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist",
+    "prebuild": "npm run clean",
+    "build": "tsup",
+    "dev": "ts-node-dev --respawn src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "framework",
+    "backend",
+    "typescript",
+    "fastify",
+    "decorators",
+    "dependency-injection",
+    "nestjs-like"
+  ],
+  "author": "riktar",
+  "license": "MIT",
+  "dependencies": {
+    "dotenv": "^17.2.3",
+    "fast-glob": "3.3.3",
+    "fastify": "5.3.2",
+    "reflect-metadata": "0.2.2",
+    "zod": "4.3.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@vitest/coverage-v8": "^2.1.9",
+    "ts-node": "^10.9.2",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/dist/core/application.d.ts

@@ -1,6 +0,0 @@
-import 'reflect-metadata';
-import { RiktaConfig, RiktaApplication } from './types.js';
-export declare class RiktaFactory {
-    static create(config?: RiktaConfig): Promise<RiktaApplication>;
-}
-export { RiktaFactory as Rikta };

package/dist/core/application.js

@@ -1,248 +0,0 @@
-import 'reflect-metadata';
-import Fastify from 'fastify';
-import { Container } from './container/container.js';
-import { Router } from './router/router.js';
-import { registry } from './registry.js';
-import { discoverModules, getCallerDirectory } from './discovery.js';
-import { EventBus } from './lifecycle/event-bus.js';
-import { ON_EVENT_METADATA } from './lifecycle/on.decorator.js';
-import { DEFAULT_CONFIG, PROVIDER_METADATA, INJECTABLE_METADATA } from './constants.js';
-import { GlobalExceptionFilter, createExceptionHandler, getCatchMetadata } from './exceptions/index.js';
-import { loadEnvFiles } from './config/env-loader.js';
-export class RiktaFactory {
-    static async create(config = {}) {
-        loadEnvFiles();
-        const silent = config.silent ?? false;
-        if (!silent)
-            console.log('\n🚀 Rikta Framework Starting...\n');
-        const callerDir = getCallerDirectory();
-        let discoveredFiles = [];
-        if (!config.controllers && config.autowired !== false) {
-            const patterns = Array.isArray(config.autowired) && config.autowired.length > 0
-                ? config.autowired
-                : ['./**'];
-            discoveredFiles = await discoverModules({
-                patterns,
-                cwd: callerDir,
-                strict: config.strictDiscovery ?? false,
-                onImportError: config.onDiscoveryError,
-            });
-        }
-        const app = new RiktaApplicationImpl(config);
-        await app.init(discoveredFiles);
-        return app;
-    }
-}
-class RiktaApplicationImpl {
-    server;
-    container;
-    config;
-    router;
-    events;
-    initializedProviders = [];
-    customExceptionFilters = new Map();
-    startTime = Date.now();
-    isListening = false;
-    address = '';
-    constructor(config) {
-        const silent = config.silent ?? false;
-        this.config = {
-            port: config.port ?? DEFAULT_CONFIG.port,
-            host: config.host ?? DEFAULT_CONFIG.host,
-            logger: config.logger ?? (silent ? false : DEFAULT_CONFIG.logger),
-            prefix: config.prefix ?? DEFAULT_CONFIG.prefix,
-            silent: silent,
-            controllers: config.controllers,
-            providers: config.providers,
-            exceptionFilter: config.exceptionFilter,
-            exceptionFilters: config.exceptionFilters,
-        };
-        this.server = Fastify({ logger: this.config.logger });
-        this.container = Container.getInstance();
-        this.router = new Router(this.server, this.container, this.config.prefix);
-        this.events = new EventBus();
-        this.container.registerInstance(EventBus, this.events);
-        this.setupExceptionHandler();
-    }
-    setupExceptionHandler() {
-        const silent = this.config.silent ?? false;
-        const globalFilter = new GlobalExceptionFilter({
-            includeStack: this.config.exceptionFilter?.includeStack,
-            logErrors: this.config.exceptionFilter?.logErrors ?? (silent ? false : true),
-        });
-        const customFilters = this.config.exceptionFilters ?? [];
-        for (const FilterClass of customFilters) {
-            const metadata = getCatchMetadata(FilterClass);
-            const filterInstance = this.container.resolve(FilterClass);
-            if (metadata && metadata.exceptions.length > 0) {
-                for (const ExceptionType of metadata.exceptions) {
-                    this.customExceptionFilters.set(ExceptionType, filterInstance);
-                }
-            }
-            else {
-                this.customExceptionFilters.set(Error, filterInstance);
-            }
-        }
-        this.server.setErrorHandler(createExceptionHandler(globalFilter, this.customExceptionFilters));
-    }
-    async init(discoveredFiles = []) {
-        await this.events.emit('app:discovery', { files: discoveredFiles });
-        await this.processConfigProviders();
-        await this.processCustomProviders();
-        await this.events.emit('app:providers', {
-            count: registry.getCustomProviders().length
-        });
-        const providers = this.getSortedProviders();
-        const additionalProviders = this.config.providers ?? [];
-        for (const provider of additionalProviders) {
-            this.registerProvider(provider);
-        }
-        for (const { target, priority } of providers) {
-            await this.initializeProvider(target, priority);
-        }
-        const controllers = this.config.controllers ?? registry.getControllers();
-        if (!this.config.silent)
-            console.log('📡 Registering routes:');
-        for (const controller of controllers) {
-            this.router.registerController(controller, this.config.silent);
-        }
-        await this.events.emit('app:routes', { count: controllers.length });
-        await this.callHook('onApplicationBootstrap');
-        await this.events.emit('app:bootstrap', {
-            providerCount: this.initializedProviders.length
-        });
-        if (!this.config.silent)
-            console.log('\n✅ Rikta is ready\n');
-    }
-    async processConfigProviders() {
-        const configProviders = registry.getConfigProviderRegistrations();
-        if (configProviders.length === 0)
-            return;
-        for (const { token, providerClass } of configProviders) {
-            this.container.registerProvider({
-                provide: token,
-                useClass: providerClass,
-            });
-        }
-    }
-    async processCustomProviders() {
-        const customProviders = registry.getCustomProviders();
-        if (customProviders.length === 0)
-            return;
-        for (const ProviderClass of customProviders) {
-            const metadata = Reflect.getMetadata(PROVIDER_METADATA, ProviderClass);
-            if (!metadata)
-                continue;
-            const providerInstance = this.container.resolve(ProviderClass);
-            const value = await providerInstance.provide();
-            this.container.registerValue(metadata.token, value);
-        }
-    }
-    getSortedProviders() {
-        const providers = registry.getProviders();
-        return providers
-            .map(target => ({
-            target,
-            priority: this.getProviderPriority(target),
-        }))
-            .sort((a, b) => b.priority - a.priority);
-    }
-    getProviderPriority(target) {
-        const options = Reflect.getMetadata(INJECTABLE_METADATA, target);
-        return options?.priority ?? 0;
-    }
-    async initializeProvider(target, priority) {
-        const instance = this.container.resolve(target);
-        const name = target.name;
-        this.initializedProviders.push({ instance, priority, name });
-        if (this.hasHook(instance, 'onProviderInit')) {
-            await instance.onProviderInit();
-        }
-        await this.events.emit('provider:init', { provider: target, name, priority });
-        this.registerEventListeners(target, instance);
-    }
-    registerEventListeners(target, instance) {
-        const metadata = Reflect.getMetadata(ON_EVENT_METADATA, target) ?? [];
-        for (const { event, methodName } of metadata) {
-            const method = instance[methodName];
-            if (typeof method === 'function') {
-                this.events.on(event, method.bind(instance), target.name);
-            }
-        }
-    }
-    registerProvider(provider) {
-        const instance = this.container.resolve(provider);
-        const priority = this.getProviderPriority(provider);
-        this.initializedProviders.push({ instance, priority, name: provider.name });
-    }
-    async callHook(hookName) {
-        for (const { instance } of this.initializedProviders) {
-            if (this.hasHook(instance, hookName)) {
-                await instance[hookName]();
-            }
-        }
-    }
-    hasHook(instance, hookName) {
-        return (instance !== null &&
-            typeof instance === 'object' &&
-            hookName in instance &&
-            typeof instance[hookName] === 'function');
-    }
-    async listen() {
-        if (this.isListening) {
-            return this.address;
-        }
-        this.address = await this.server.listen({
-            port: this.config.port,
-            host: this.config.host,
-        });
-        this.isListening = true;
-        for (const { instance } of this.initializedProviders) {
-            if (this.hasHook(instance, 'onApplicationListen')) {
-                await instance.onApplicationListen(this.address);
-            }
-        }
-        await this.events.emit('app:listen', {
-            address: this.address,
-            port: this.config.port
-        });
-        return this.address;
-    }
-    async close(signal) {
-        await this.events.emit('app:shutdown', { signal });
-        const reversed = [...this.initializedProviders].reverse();
-        for (const { instance, name } of reversed) {
-            if (this.hasHook(instance, 'onApplicationShutdown')) {
-                await instance.onApplicationShutdown(signal);
-            }
-            if (this.hasHook(instance, 'onProviderDestroy')) {
-                await instance.onProviderDestroy();
-            }
-            this.events.removeByOwner(name);
-        }
-        await this.server.close();
-        this.isListening = false;
-        await this.events.emit('app:destroy', {
-            uptime: Date.now() - this.startTime
-        });
-        this.events.clear();
-        if (!this.config.silent)
-            console.log('\n👋 Application closed\n');
-    }
-    getUrl() {
-        return this.address;
-    }
-    getEventBus() {
-        return this.events;
-    }
-    getContainer() {
-        return this.container;
-    }
-    getRouter() {
-        return this.router;
-    }
-    clearRouterCaches() {
-        this.router.clearAllCaches();
-    }
-}
-export { RiktaFactory as Rikta };

package/dist/core/config/abstract-config-provider.d.ts

@@ -1,14 +0,0 @@
-import { z, ZodSchema } from 'zod';
-export declare class ConfigValidationException extends Error {
-    readonly errors: z.ZodError;
-    constructor(errors: z.ZodError, providerName: string);
-}
-export declare abstract class AbstractConfigProvider {
-    private _cache?;
-    protected abstract schema(): ZodSchema;
-    constructor();
-    private validateAndCache;
-    protected populate(): void;
-    protected getConfig(): Readonly<Record<string, unknown>>;
-    protected get<T = unknown>(key: string): T | undefined;
-}

package/dist/core/config/abstract-config-provider.js

@@ -1,53 +0,0 @@
-import { z } from 'zod';
-import { getConfigPropertyMappings } from '../decorators/config-property.decorator.js';
-import { loadEnvFiles } from './env-loader.js';
-export class ConfigValidationException extends Error {
-    errors;
-    constructor(errors, providerName) {
-        const errorMessages = errors.issues
-            .map(err => `  - ${err.path.join('.')}: ${err.message}`)
-            .join('\n');
-        super(`Configuration validation failed for ${providerName}:\n${errorMessages}\n\n` +
-            `Please check your .env file and ensure all required variables are set correctly.`);
-        this.errors = errors;
-        this.name = 'ConfigValidationException';
-    }
-}
-export class AbstractConfigProvider {
-    _cache;
-    constructor() {
-        loadEnvFiles();
-    }
-    validateAndCache() {
-        if (this._cache) {
-            return this._cache;
-        }
-        try {
-            const schema = this.schema();
-            const validated = schema.parse(process.env);
-            this._cache = Object.freeze(validated);
-            return this._cache;
-        }
-        catch (error) {
-            if (error instanceof z.ZodError) {
-                throw new ConfigValidationException(error, this.constructor.name);
-            }
-            throw error;
-        }
-    }
-    populate() {
-        const config = this.validateAndCache();
-        const mappings = getConfigPropertyMappings(this.constructor);
-        for (const mapping of mappings) {
-            const value = config[mapping.envKey];
-            this[mapping.propertyKey] = value;
-        }
-    }
-    getConfig() {
-        return this.validateAndCache();
-    }
-    get(key) {
-        const config = this.validateAndCache();
-        return config[key];
-    }
-}

package/dist/core/config/env-loader.d.ts

@@ -1,3 +0,0 @@
-export declare function loadEnvFiles(): void;
-export declare function isEnvLoaded(): boolean;
-export declare function resetEnvLoaded(): void;

package/dist/core/config/env-loader.js

@@ -1,26 +0,0 @@
-import { config as loadEnv } from 'dotenv';
-import { existsSync } from 'fs';
-import { resolve } from 'path';
-let envLoaded = false;
-export function loadEnvFiles() {
-    if (envLoaded) {
-        return;
-    }
-    const env = process.env.NODE_ENV || 'development';
-    const cwd = process.cwd();
-    const baseEnvPath = resolve(cwd, '.env');
-    if (existsSync(baseEnvPath)) {
-        loadEnv({ path: baseEnvPath, override: false });
-    }
-    const envSpecificPath = resolve(cwd, `.env.${env}`);
-    if (existsSync(envSpecificPath)) {
-        loadEnv({ path: envSpecificPath, override: true });
-    }
-    envLoaded = true;
-}
-export function isEnvLoaded() {
-    return envLoaded;
-}
-export function resetEnvLoaded() {
-    envLoaded = false;
-}

package/dist/core/config/index.d.ts

@@ -1,2 +0,0 @@
-export * from './abstract-config-provider.js';
-export * from './env-loader.js';

package/dist/core/config/index.js

@@ -1,2 +0,0 @@
-export * from './abstract-config-provider.js';
-export * from './env-loader.js';

package/dist/core/constants.d.ts

@@ -1,30 +0,0 @@
-export declare const CONTROLLER_METADATA: unique symbol;
-export declare const ROUTES_METADATA: unique symbol;
-export declare const INJECTABLE_METADATA: unique symbol;
-export declare const PARAM_METADATA: unique symbol;
-export declare const GUARDS_METADATA: unique symbol;
-export declare const INTERCEPTORS_METADATA: unique symbol;
-export declare const MIDDLEWARE_METADATA: unique symbol;
-export declare const HTTP_CODE_METADATA: unique symbol;
-export declare const HEADERS_METADATA: unique symbol;
-export declare const INJECT_METADATA: unique symbol;
-export declare const ZOD_SCHEMA_METADATA: unique symbol;
-export declare const AUTOWIRED_METADATA: unique symbol;
-export declare const PROVIDER_METADATA: unique symbol;
-export declare const CONFIG_PROVIDER_METADATA: unique symbol;
-export declare const CONFIG_PROPERTY_METADATA: unique symbol;
-export declare enum ParamType {
-    BODY = "body",
-    QUERY = "query",
-    PARAM = "param",
-    HEADERS = "headers",
-    REQUEST = "request",
-    REPLY = "reply",
-    CONTEXT = "context"
-}
-export declare const DEFAULT_CONFIG: {
-    readonly port: 3000;
-    readonly host: "0.0.0.0";
-    readonly logger: true;
-    readonly prefix: "";
-};

package/dist/core/constants.js

@@ -1,31 +0,0 @@
-export const CONTROLLER_METADATA = Symbol.for('rikta:controller:metadata');
-export const ROUTES_METADATA = Symbol.for('rikta:routes:metadata');
-export const INJECTABLE_METADATA = Symbol.for('rikta:injectable:metadata');
-export const PARAM_METADATA = Symbol.for('rikta:param:metadata');
-export const GUARDS_METADATA = Symbol.for('rikta:guards:metadata');
-export const INTERCEPTORS_METADATA = Symbol.for('rikta:interceptors:metadata');
-export const MIDDLEWARE_METADATA = Symbol.for('rikta:middleware:metadata');
-export const HTTP_CODE_METADATA = Symbol.for('rikta:http:code:metadata');
-export const HEADERS_METADATA = Symbol.for('rikta:headers:metadata');
-export const INJECT_METADATA = Symbol.for('rikta:inject:metadata');
-export const ZOD_SCHEMA_METADATA = Symbol.for('rikta:zod:schema:metadata');
-export const AUTOWIRED_METADATA = Symbol.for('rikta:autowired:metadata');
-export const PROVIDER_METADATA = Symbol.for('rikta:provider:metadata');
-export const CONFIG_PROVIDER_METADATA = Symbol('config:provider:metadata');
-export const CONFIG_PROPERTY_METADATA = Symbol('config:property:metadata');
-export var ParamType;
-(function (ParamType) {
-    ParamType["BODY"] = "body";
-    ParamType["QUERY"] = "query";
-    ParamType["PARAM"] = "param";
-    ParamType["HEADERS"] = "headers";
-    ParamType["REQUEST"] = "request";
-    ParamType["REPLY"] = "reply";
-    ParamType["CONTEXT"] = "context";
-})(ParamType || (ParamType = {}));
-export const DEFAULT_CONFIG = {
-    port: 3000,
-    host: '0.0.0.0',
-    logger: true,
-    prefix: '',
-};

package/dist/core/container/abstract-class.utils.d.ts

@@ -1,10 +0,0 @@
-import { Constructor } from '../types.js';
-export declare const IMPLEMENTS_METADATA: unique symbol;
-export declare const PRIMARY_METADATA: unique symbol;
-export declare function isAbstractClass(target: unknown): target is Constructor;
-export declare function extendsFrom(derived: Constructor, base: Constructor): boolean;
-export declare function getImplementedAbstract(target: Constructor): Constructor | undefined;
-export declare function isPrimaryImplementation(target: Constructor): boolean;
-export declare function setImplementsMetadata(target: Constructor, abstractClass: Constructor): void;
-export declare function setPrimaryMetadata(target: Constructor): void;
-export declare function markAsAbstract(target: Constructor): void;

package/dist/core/container/abstract-class.utils.js

@@ -1,44 +0,0 @@
-export const IMPLEMENTS_METADATA = Symbol('rikta:implements');
-export const PRIMARY_METADATA = Symbol('rikta:primary');
-export function isAbstractClass(target) {
-    if (typeof target !== 'function') {
-        return false;
-    }
-    const isMarkedAbstract = Reflect.getMetadata(IMPLEMENTS_METADATA, target) === undefined
-        && Reflect.hasMetadata('abstract:class', target);
-    if (isMarkedAbstract) {
-        return true;
-    }
-    return Reflect.getMetadata('abstract:class', target) === true;
-}
-export function extendsFrom(derived, base) {
-    if (!derived || !base) {
-        return false;
-    }
-    if (derived === base) {
-        return false;
-    }
-    let current = Object.getPrototypeOf(derived);
-    while (current && current !== Function.prototype) {
-        if (current === base) {
-            return true;
-        }
-        current = Object.getPrototypeOf(current);
-    }
-    return false;
-}
-export function getImplementedAbstract(target) {
-    return Reflect.getMetadata(IMPLEMENTS_METADATA, target);
-}
-export function isPrimaryImplementation(target) {
-    return Reflect.getMetadata(PRIMARY_METADATA, target) === true;
-}
-export function setImplementsMetadata(target, abstractClass) {
-    Reflect.defineMetadata(IMPLEMENTS_METADATA, abstractClass, target);
-}
-export function setPrimaryMetadata(target) {
-    Reflect.defineMetadata(PRIMARY_METADATA, true, target);
-}
-export function markAsAbstract(target) {
-    Reflect.defineMetadata('abstract:class', true, target);
-}

package/dist/core/container/container.d.ts

@@ -1,32 +0,0 @@
-import 'reflect-metadata';
-import { Constructor, InjectableOptions } from '../types.js';
-import { Token, ProviderDefinition } from './injection-token.js';
-export declare class Container {
-    private static instance;
-    private singletons;
-    private providers;
-    private resolutionStack;
-    private constructor();
-    static getInstance(): Container;
-    static reset(): void;
-    register<T>(target: Constructor<T>, options?: InjectableOptions): void;
-    registerProvider<T>(provider: ProviderDefinition<T>): void;
-    registerValue<T>(token: Token<T>, value: T): void;
-    registerFactory<T>(token: Token<T>, factory: () => T, inject?: Token[]): void;
-    has(token: Token): boolean;
-    resolve<T>(token: Token<T>): T;
-    resolveOptional<T>(token: Token<T>): T | undefined;
-    private resolveToken;
-    private resolveAbstractClass;
-    private resolveProvider;
-    private resolveClass;
-    private injectProperties;
-    private resolveWithName;
-    private resolveWithNameOptional;
-    registerInstance<T>(target: Constructor<T>, instance: T): void;
-    getProviders(): Token[];
-    clearSingletons(): void;
-    private isPrimitive;
-    private getTokenName;
-}
-export declare const container: Container;