@riktajs/core 0.9.0 → 0.10.0

package/README.md

@@ -1,132 +1,132 @@
-# @riktajs/core
-
-The core package of the Rikta framework.
-
-See the [main repository README](../../README.md) for full documentation.
-
-## Installation
-
-```bash
-npm install @riktajs/core
-```
-
-## Quick Start
-
-```typescript
-import { Rikta, Controller, Injectable, Get, Autowired } from '@riktajs/core';
-
-@Injectable()
-class HelloService {
-  getMessage() {
-    return { message: 'Hello from Rikta!' };
-  }
-}
-
-@Controller('/api')
-class HelloController {
-  @Autowired()
-  private helloService!: HelloService;
-
-  @Get('/hello')
-  getHello() {
-    return this.helloService.getMessage();
-  }
-}
-
-const app = await Rikta.create({ 
-  port: 3000, 
-  autowired: ['./src']
-});
-await app.listen();
-```
-
-## Features
-
-- 🚀 Zero-Config Autowiring
-- ⚡ Fastify Powered
-- 🛡️ Type-Safe by Default
-- 🔄 Hybrid Lifecycle
-- 📦 Built-in Dependency Injection
-- ✅ Zod Validation Integration
-
-## Provider Scopes
-
-Rikta supports three provider scopes:
-
-```typescript
-// Singleton (default) - shared instance
-@Injectable()
-class ConfigService {}
-
-// Transient - new instance each time
-@Injectable({ scope: 'transient' })
-class RequestLogger {}
-
-// Request - one instance per HTTP request
-@Injectable({ scope: 'request' })
-class RequestContext {}
-```
-
-## Strict Discovery Mode
-
-Enable strict discovery to catch import errors early:
-
-```typescript
-const app = await Rikta.create({
-  strictDiscovery: process.env.NODE_ENV !== 'production',
-  onDiscoveryError: (file, error) => {
-    console.warn(`Failed to import: ${file}`);
-  },
-});
-```
-
-## EventBus
-
-The EventBus provides pub/sub for lifecycle events:
-
-```typescript
-import { Injectable, Autowired, EventBus } from '@riktajs/core';
-
-@Injectable()
-class MonitorService {
-  @Autowired()
-  private events!: EventBus;
-
-  onProviderInit() {
-    this.events.on('app:listen', ({ address }) => {
-      console.log(`Server at ${address}`);
-    });
-  }
-}
-```
-
-## Interceptors
-
-Interceptors allow you to bind extra logic before/after method execution:
-
-```typescript
-import { Injectable, Interceptor, ExecutionContext, CallHandler, UseInterceptors } from '@riktajs/core';
-
-@Injectable()
-class LoggingInterceptor implements Interceptor {
-  async intercept(context: ExecutionContext, next: CallHandler): Promise<unknown> {
-    const start = Date.now();
-    const result = await next.handle();
-    console.log(`Request took ${Date.now() - start}ms`);
-    return result;
-  }
-}
-
-@Controller('/api')
-@UseInterceptors(LoggingInterceptor)
-class ApiController {
-  @Get('/data')
-  getData() {
-    return { data: 'example' };
-  }
-}
-```
-
-## License
-
-MIT
+# @riktajs/core
+
+The core package of the Rikta framework.
+
+See the [main repository README](../../README.md) for full documentation.
+
+## Installation
+
+```bash
+npm install @riktajs/core
+```
+
+## Quick Start
+
+```typescript
+import { Rikta, Controller, Injectable, Get, Autowired } from '@riktajs/core';
+
+@Injectable()
+class HelloService {
+  getMessage() {
+    return { message: 'Hello from Rikta!' };
+  }
+}
+
+@Controller('/api')
+class HelloController {
+  @Autowired()
+  private helloService!: HelloService;
+
+  @Get('/hello')
+  getHello() {
+    return this.helloService.getMessage();
+  }
+}
+
+const app = await Rikta.create({ 
+  port: 3000, 
+  autowired: ['./src']
+});
+await app.listen();
+```
+
+## Features
+
+- 🚀 Zero-Config Autowiring
+- ⚡ Fastify Powered
+- 🛡️ Type-Safe by Default
+- 🔄 Hybrid Lifecycle
+- 📦 Built-in Dependency Injection
+- ✅ Zod Validation Integration
+
+## Provider Scopes
+
+Rikta supports three provider scopes:
+
+```typescript
+// Singleton (default) - shared instance
+@Injectable()
+class ConfigService {}
+
+// Transient - new instance each time
+@Injectable({ scope: 'transient' })
+class RequestLogger {}
+
+// Request - one instance per HTTP request
+@Injectable({ scope: 'request' })
+class RequestContext {}
+```
+
+## Strict Discovery Mode
+
+Enable strict discovery to catch import errors early:
+
+```typescript
+const app = await Rikta.create({
+  strictDiscovery: process.env.NODE_ENV !== 'production',
+  onDiscoveryError: (file, error) => {
+    console.warn(`Failed to import: ${file}`);
+  },
+});
+```
+
+## EventBus
+
+The EventBus provides pub/sub for lifecycle events:
+
+```typescript
+import { Injectable, Autowired, EventBus } from '@riktajs/core';
+
+@Injectable()
+class MonitorService {
+  @Autowired()
+  private events!: EventBus;
+
+  onProviderInit() {
+    this.events.on('app:listen', ({ address }) => {
+      console.log(`Server at ${address}`);
+    });
+  }
+}
+```
+
+## Interceptors
+
+Interceptors allow you to bind extra logic before/after method execution:
+
+```typescript
+import { Injectable, Interceptor, ExecutionContext, CallHandler, UseInterceptors } from '@riktajs/core';
+
+@Injectable()
+class LoggingInterceptor implements Interceptor {
+  async intercept(context: ExecutionContext, next: CallHandler): Promise<unknown> {
+    const start = Date.now();
+    const result = await next.handle();
+    console.log(`Request took ${Date.now() - start}ms`);
+    return result;
+  }
+}
+
+@Controller('/api')
+@UseInterceptors(LoggingInterceptor)
+class ApiController {
+  @Get('/data')
+  getData() {
+    return { data: 'example' };
+  }
+}
+```
+
+## License
+
+MIT

package/dist/core/application.d.ts

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

package/dist/core/application.js

@@ -1,33 +1,27 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Rikta = exports.RiktaFactory = void 0;
-require("reflect-metadata");
-const fastify_1 = __importDefault(require("fastify"));
-const container_1 = require("./container/container");
-const router_1 = require("./router/router");
-const registry_1 = require("./registry");
-const discovery_1 = require("./discovery");
-const event_bus_1 = require("./lifecycle/event-bus");
-const on_decorator_1 = require("./lifecycle/on.decorator");
-const constants_1 = require("./constants");
-const exceptions_1 = require("./exceptions");
-const env_loader_1 = require("./config/env-loader");
-class RiktaFactory {
+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 = {}) {
-        (0, env_loader_1.loadEnvFiles)();
+        loadEnvFiles();
         const silent = config.silent ?? false;
         if (!silent)
             console.log('\n🚀 Rikta Framework Starting...\n');
-        const callerDir = (0, discovery_1.getCallerDirectory)();
+        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 (0, discovery_1.discoverModules)({
+            discoveredFiles = await discoverModules({
                 patterns,
                 cwd: callerDir,
                 strict: config.strictDiscovery ?? false,
@@ -39,8 +33,6 @@ class RiktaFactory {
         return app;
     }
 }
-exports.RiktaFactory = RiktaFactory;
-exports.Rikta = RiktaFactory;
 class RiktaApplicationImpl {
     server;
     container;
@@ -55,32 +47,32 @@ class RiktaApplicationImpl {
     constructor(config) {
         const silent = config.silent ?? false;
         this.config = {
-            port: config.port ?? constants_1.DEFAULT_CONFIG.port,
-            host: config.host ?? constants_1.DEFAULT_CONFIG.host,
-            logger: config.logger ?? (silent ? false : constants_1.DEFAULT_CONFIG.logger),
-            prefix: config.prefix ?? constants_1.DEFAULT_CONFIG.prefix,
+            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 = (0, fastify_1.default)({ logger: this.config.logger });
-        this.container = container_1.Container.getInstance();
-        this.router = new router_1.Router(this.server, this.container, this.config.prefix);
-        this.events = new event_bus_1.EventBus();
-        this.container.registerInstance(event_bus_1.EventBus, this.events);
+        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 exceptions_1.GlobalExceptionFilter({
+        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 = (0, exceptions_1.getCatchMetadata)(FilterClass);
+            const metadata = getCatchMetadata(FilterClass);
             const filterInstance = this.container.resolve(FilterClass);
             if (metadata && metadata.exceptions.length > 0) {
                 for (const ExceptionType of metadata.exceptions) {
@@ -91,14 +83,14 @@ class RiktaApplicationImpl {
                 this.customExceptionFilters.set(Error, filterInstance);
             }
         }
-        this.server.setErrorHandler((0, exceptions_1.createExceptionHandler)(globalFilter, this.customExceptionFilters));
+        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_1.registry.getCustomProviders().length
+            count: registry.getCustomProviders().length
         });
         const providers = this.getSortedProviders();
         const additionalProviders = this.config.providers ?? [];
@@ -108,7 +100,7 @@ class RiktaApplicationImpl {
         for (const { target, priority } of providers) {
             await this.initializeProvider(target, priority);
         }
-        const controllers = this.config.controllers ?? registry_1.registry.getControllers();
+        const controllers = this.config.controllers ?? registry.getControllers();
         if (!this.config.silent)
             console.log('📡 Registering routes:');
         for (const controller of controllers) {
@@ -123,7 +115,7 @@ class RiktaApplicationImpl {
             console.log('\n✅ Rikta is ready\n');
     }
     async processConfigProviders() {
-        const configProviders = registry_1.registry.getConfigProviderRegistrations();
+        const configProviders = registry.getConfigProviderRegistrations();
         if (configProviders.length === 0)
             return;
         for (const { token, providerClass } of configProviders) {
@@ -134,11 +126,11 @@ class RiktaApplicationImpl {
         }
     }
     async processCustomProviders() {
-        const customProviders = registry_1.registry.getCustomProviders();
+        const customProviders = registry.getCustomProviders();
         if (customProviders.length === 0)
             return;
         for (const ProviderClass of customProviders) {
-            const metadata = Reflect.getMetadata(constants_1.PROVIDER_METADATA, ProviderClass);
+            const metadata = Reflect.getMetadata(PROVIDER_METADATA, ProviderClass);
             if (!metadata)
                 continue;
             const providerInstance = this.container.resolve(ProviderClass);
@@ -147,7 +139,7 @@ class RiktaApplicationImpl {
         }
     }
     getSortedProviders() {
-        const providers = registry_1.registry.getProviders();
+        const providers = registry.getProviders();
         return providers
             .map(target => ({
             target,
@@ -156,7 +148,7 @@ class RiktaApplicationImpl {
             .sort((a, b) => b.priority - a.priority);
     }
     getProviderPriority(target) {
-        const options = Reflect.getMetadata(constants_1.INJECTABLE_METADATA, target);
+        const options = Reflect.getMetadata(INJECTABLE_METADATA, target);
         return options?.priority ?? 0;
     }
     async initializeProvider(target, priority) {
@@ -170,7 +162,7 @@ class RiktaApplicationImpl {
         this.registerEventListeners(target, instance);
     }
     registerEventListeners(target, instance) {
-        const metadata = Reflect.getMetadata(on_decorator_1.ON_EVENT_METADATA, target) ?? [];
+        const metadata = Reflect.getMetadata(ON_EVENT_METADATA, target) ?? [];
         for (const { event, methodName } of metadata) {
             const method = instance[methodName];
             if (typeof method === 'function') {
@@ -253,3 +245,4 @@ class RiktaApplicationImpl {
         this.router.clearAllCaches();
     }
 }
+export { RiktaFactory as Rikta };

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

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractConfigProvider = exports.ConfigValidationException = void 0;
-const zod_1 = require("zod");
-const config_property_decorator_1 = require("../decorators/config-property.decorator");
-const env_loader_1 = require("./env-loader");
-class ConfigValidationException extends Error {
+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
@@ -16,11 +13,10 @@ class ConfigValidationException extends Error {
         this.name = 'ConfigValidationException';
     }
 }
-exports.ConfigValidationException = ConfigValidationException;
-class AbstractConfigProvider {
+export class AbstractConfigProvider {
     _cache;
     constructor() {
-        (0, env_loader_1.loadEnvFiles)();
+        loadEnvFiles();
     }
     validateAndCache() {
         if (this._cache) {
@@ -33,7 +29,7 @@ class AbstractConfigProvider {
             return this._cache;
         }
         catch (error) {
-            if (error instanceof zod_1.z.ZodError) {
+            if (error instanceof z.ZodError) {
                 throw new ConfigValidationException(error, this.constructor.name);
             }
             throw error;
@@ -41,7 +37,7 @@ class AbstractConfigProvider {
     }
     populate() {
         const config = this.validateAndCache();
-        const mappings = (0, config_property_decorator_1.getConfigPropertyMappings)(this.constructor);
+        const mappings = getConfigPropertyMappings(this.constructor);
         for (const mapping of mappings) {
             const value = config[mapping.envKey];
             this[mapping.propertyKey] = value;
@@ -55,4 +51,3 @@ class AbstractConfigProvider {
         return config[key];
     }
 }
-exports.AbstractConfigProvider = AbstractConfigProvider;

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

@@ -1,31 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadEnvFiles = loadEnvFiles;
-exports.isEnvLoaded = isEnvLoaded;
-exports.resetEnvLoaded = resetEnvLoaded;
-const dotenv_1 = require("dotenv");
-const fs_1 = require("fs");
-const path_1 = require("path");
+import { config as loadEnv } from 'dotenv';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
 let envLoaded = false;
-function loadEnvFiles() {
+export function loadEnvFiles() {
     if (envLoaded) {
         return;
     }
     const env = process.env.NODE_ENV || 'development';
     const cwd = process.cwd();
-    const baseEnvPath = (0, path_1.resolve)(cwd, '.env');
-    if ((0, fs_1.existsSync)(baseEnvPath)) {
-        (0, dotenv_1.config)({ path: baseEnvPath, override: false });
+    const baseEnvPath = resolve(cwd, '.env');
+    if (existsSync(baseEnvPath)) {
+        loadEnv({ path: baseEnvPath, override: false });
     }
-    const envSpecificPath = (0, path_1.resolve)(cwd, `.env.${env}`);
-    if ((0, fs_1.existsSync)(envSpecificPath)) {
-        (0, dotenv_1.config)({ path: envSpecificPath, override: true });
+    const envSpecificPath = resolve(cwd, `.env.${env}`);
+    if (existsSync(envSpecificPath)) {
+        loadEnv({ path: envSpecificPath, override: true });
     }
     envLoaded = true;
 }
-function isEnvLoaded() {
+export function isEnvLoaded() {
     return envLoaded;
 }
-function resetEnvLoaded() {
+export function resetEnvLoaded() {
     envLoaded = false;
 }

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

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

package/dist/core/config/index.js

@@ -1,18 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./abstract-config-provider"), exports);
-__exportStar(require("./env-loader"), exports);
+export * from './abstract-config-provider.js';
+export * from './env-loader.js';

package/dist/core/constants.js

@@ -1,22 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CONFIG = exports.ParamType = exports.CONFIG_PROPERTY_METADATA = exports.CONFIG_PROVIDER_METADATA = exports.PROVIDER_METADATA = exports.AUTOWIRED_METADATA = exports.ZOD_SCHEMA_METADATA = exports.INJECT_METADATA = exports.HEADERS_METADATA = exports.HTTP_CODE_METADATA = exports.MIDDLEWARE_METADATA = exports.INTERCEPTORS_METADATA = exports.GUARDS_METADATA = exports.PARAM_METADATA = exports.INJECTABLE_METADATA = exports.ROUTES_METADATA = exports.CONTROLLER_METADATA = void 0;
-exports.CONTROLLER_METADATA = Symbol.for('rikta:controller:metadata');
-exports.ROUTES_METADATA = Symbol.for('rikta:routes:metadata');
-exports.INJECTABLE_METADATA = Symbol.for('rikta:injectable:metadata');
-exports.PARAM_METADATA = Symbol.for('rikta:param:metadata');
-exports.GUARDS_METADATA = Symbol.for('rikta:guards:metadata');
-exports.INTERCEPTORS_METADATA = Symbol.for('rikta:interceptors:metadata');
-exports.MIDDLEWARE_METADATA = Symbol.for('rikta:middleware:metadata');
-exports.HTTP_CODE_METADATA = Symbol.for('rikta:http:code:metadata');
-exports.HEADERS_METADATA = Symbol.for('rikta:headers:metadata');
-exports.INJECT_METADATA = Symbol.for('rikta:inject:metadata');
-exports.ZOD_SCHEMA_METADATA = Symbol.for('rikta:zod:schema:metadata');
-exports.AUTOWIRED_METADATA = Symbol.for('rikta:autowired:metadata');
-exports.PROVIDER_METADATA = Symbol.for('rikta:provider:metadata');
-exports.CONFIG_PROVIDER_METADATA = Symbol('config:provider:metadata');
-exports.CONFIG_PROPERTY_METADATA = Symbol('config:property:metadata');
-var ParamType;
+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";
@@ -25,8 +22,8 @@ var ParamType;
     ParamType["REQUEST"] = "request";
     ParamType["REPLY"] = "reply";
     ParamType["CONTEXT"] = "context";
-})(ParamType || (exports.ParamType = ParamType = {}));
-exports.DEFAULT_CONFIG = {
+})(ParamType || (ParamType = {}));
+export const DEFAULT_CONFIG = {
     port: 3000,
     host: '0.0.0.0',
     logger: true,

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

@@ -1,4 +1,4 @@
-import { Constructor } from '../types';
+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;