@riktajs/core 0.8.0 → 0.10.0

package/README.md

@@ -1,54 +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
-
-## 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,41 +1,38 @@
-"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)(patterns, callerDir);
+            discoveredFiles = await discoverModules({
+                patterns,
+                cwd: callerDir,
+                strict: config.strictDiscovery ?? false,
+                onImportError: config.onDiscoveryError,
+            });
         }
         const app = new RiktaApplicationImpl(config);
         await app.init(discoveredFiles);
         return app;
     }
 }
-exports.RiktaFactory = RiktaFactory;
-exports.Rikta = RiktaFactory;
 class RiktaApplicationImpl {
     server;
     container;
@@ -50,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) {
@@ -86,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 ?? [];
@@ -103,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) {
@@ -118,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) {
@@ -129,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);
@@ -142,7 +139,7 @@ class RiktaApplicationImpl {
         }
     }
     getSortedProviders() {
-        const providers = registry_1.registry.getProviders();
+        const providers = registry.getProviders();
         return providers
             .map(target => ({
             target,
@@ -151,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) {
@@ -165,11 +162,11 @@ 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') {
-                this.events.on(event, method.bind(instance));
+                this.events.on(event, method.bind(instance), target.name);
             }
         }
     }
@@ -214,19 +211,21 @@ class RiktaApplicationImpl {
     async close(signal) {
         await this.events.emit('app:shutdown', { signal });
         const reversed = [...this.initializedProviders].reverse();
-        for (const { instance } of reversed) {
+        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');
     }
@@ -239,4 +238,11 @@ class RiktaApplicationImpl {
     getContainer() {
         return this.container;
     }
+    getRouter() {
+        return this.router;
+    }
+    clearRouterCaches() {
+        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;

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

@@ -1,27 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PRIMARY_METADATA = exports.IMPLEMENTS_METADATA = void 0;
-exports.isAbstractClass = isAbstractClass;
-exports.extendsFrom = extendsFrom;
-exports.getImplementedAbstract = getImplementedAbstract;
-exports.isPrimaryImplementation = isPrimaryImplementation;
-exports.setImplementsMetadata = setImplementsMetadata;
-exports.setPrimaryMetadata = setPrimaryMetadata;
-exports.markAsAbstract = markAsAbstract;
-exports.IMPLEMENTS_METADATA = Symbol('rikta:implements');
-exports.PRIMARY_METADATA = Symbol('rikta:primary');
-function isAbstractClass(target) {
+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(exports.IMPLEMENTS_METADATA, target) === undefined
+    const isMarkedAbstract = Reflect.getMetadata(IMPLEMENTS_METADATA, target) === undefined
         && Reflect.hasMetadata('abstract:class', target);
     if (isMarkedAbstract) {
         return true;
     }
     return Reflect.getMetadata('abstract:class', target) === true;
 }
-function extendsFrom(derived, base) {
+export function extendsFrom(derived, base) {
     if (!derived || !base) {
         return false;
     }
@@ -37,18 +27,18 @@ function extendsFrom(derived, base) {
     }
     return false;
 }
-function getImplementedAbstract(target) {
-    return Reflect.getMetadata(exports.IMPLEMENTS_METADATA, target);
+export function getImplementedAbstract(target) {
+    return Reflect.getMetadata(IMPLEMENTS_METADATA, target);
 }
-function isPrimaryImplementation(target) {
-    return Reflect.getMetadata(exports.PRIMARY_METADATA, target) === true;
+export function isPrimaryImplementation(target) {
+    return Reflect.getMetadata(PRIMARY_METADATA, target) === true;
 }
-function setImplementsMetadata(target, abstractClass) {
-    Reflect.defineMetadata(exports.IMPLEMENTS_METADATA, abstractClass, target);
+export function setImplementsMetadata(target, abstractClass) {
+    Reflect.defineMetadata(IMPLEMENTS_METADATA, abstractClass, target);
 }
-function setPrimaryMetadata(target) {
-    Reflect.defineMetadata(exports.PRIMARY_METADATA, true, target);
+export function setPrimaryMetadata(target) {
+    Reflect.defineMetadata(PRIMARY_METADATA, true, target);
 }
-function markAsAbstract(target) {
+export function markAsAbstract(target) {
     Reflect.defineMetadata('abstract:class', true, target);
 }

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

@@ -1,6 +1,6 @@
 import 'reflect-metadata';
-import { Constructor, InjectableOptions } from '../types';
-import { Token, ProviderDefinition } from './injection-token';
+import { Constructor, InjectableOptions } from '../types.js';
+import { Token, ProviderDefinition } from './injection-token.js';
 export declare class Container {
     private static instance;
     private singletons;